public void BuildEquityAnalysisModel(IRibbonControl control)
        {
            MessageDialog x = new MessageDialog("Building Model...", Constants.AddInName);
            x.DoAction(
                (dialog) =>
                {
                    TaskEx.Delay(0).Then((t) =>
                    {
                        string ticker = (string)ExcelUtil.Worksheet("Main").Range("Symbol").Value;
                        FinanceDataLoader.BuildEquityAnalysis(ticker).Then(
                            result =>
                            {
                                dialog.SetMessage("Done!");
                                dialog.Resume();
                            }
                        ).Finally(
                            e =>
                            {
                                dialog.SetMessage("Error occurred" + e.Message);
                            }
                        );

                    });
                }
            );
        }

        public void HighlightWords(IRibbonControl control)
        {
            Window context = control.Context as Window;

            try
            {
                WordMatcher matcher = new WordMatcher(AppRegKey);
                matcher.LoadHightlightDefineFile(null);

                string pageId = OneNoteHelper.HierarchyHelper.GetActiveObjectID(context.Application, OneNoteHelper.HierarchyHelper._ObjectType.Page);
                HighlightPage(context.Application, pageId, matcher);
                //OneNoteHelper.HierarchyHelper.GoThoughHierarchy(context.Application, (application, pageId) => HighlightPage(application, pageId, matcher));
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString(), "Error");
                EventLog.WriteEntry(EventLogSource, ex.ToString());
            }
            finally
            {
                context = null;
                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
            }
        }

        public void OnLogonButtonPressed(IRibbonControl control)
        {
            string clusterUrl = "";
            int itemIndx = 0;

            switch (control.Id)
            {
                case "LogonButton1":
                    clusterUrl = "https://dev.ufora.com:443";
                    itemIndx = 1;
                    break;
                case "LogonButton2":
                    clusterUrl = "https://demo.ufora.com:443";
                    itemIndx = 2;
                    break;
                case "LogonButton3":
                    clusterUrl = "https://stable.ufora.com:443";
                    itemIndx = 3;
                    break;
                default:
                    clusterUrl = "";
                    break;
            }
            if (clusterUrl != "")
            {
                ClusterLogonForm logonForm = new ClusterLogonForm(clusterUrl, itemIndx);
                logonForm.Show();
            }
            else
                MessageBox.Show("undefined url");
        }

 public Image GetImage(IRibbonControl control)
 {
     switch (control.Id)
     {
         case "WorkshareSaveAsRecentFoldersBrowse":
         {
             return Utils.GetEmbeddedImage("Workshare.SharedRibbon.Library.Resources.browse.png");
         }
         case "SaveToWorkshareButton":
         {
             return Utils.GetEmbeddedImage("Workshare.SharedRibbon.Library.Resources.save-icon.png");
         }
         case "ShareToWorkshareButton":
         {
             return Utils.GetEmbeddedImage("Workshare.SharedRibbon.Library.Resources.share-icon.png");
         }
         case "Bullet1":
         case "Bullet2":
         case "Bullet3":
         case "Bullet4":
         case "Bullet5":
         case "Bullet6":
         case "Bullet7":
         case "Bullet8":
         {
             return Utils.GetEmbeddedImage("Workshare.SharedRibbon.Library.Resources.bullet.png");
         }
             
         default:
         {
             return Image;
         }
     }
 }

        public void CreateModel(IRibbonControl control)
        {
            SelectTemplate t = new SelectTemplate();
            if (t.ShowDialog().Value)
            {
                //MessageDialog x = new MessageDialog("Creating Model...", Constants.AddInName);
                //x.DoAction(
                //    (dialog) =>
                //    {
                        Excel.Application app = ExcelUtil.Application;
                        Excel.Workbook wb = app.Workbooks.Open(t.SelectedTemplateFullPath);

                        Excel.Worksheet currentSheet = (Excel.Worksheet)wb.ActiveSheet;
                        Excel.Worksheet ws = (Excel.Worksheet)wb.Worksheets.Add();
                        ws.Name = "Config";
                        ws.Visible = Excel.Enums.XlSheetVisibility.xlSheetVeryHidden;
                        currentSheet.Activate();
                        ws.Range("A1").Value = t.SelectedTemplate;

                        //dialog.SetMessage("Done!");
                        //dialog.Resume();
                //    }
                //);
            }
        }

 public void CreateIssue(IRibbonControl ribbonControl)
 {
     //TODO create proper task window and show it here.. selectedMailItem will be populated properly
     new Window
         {
             Content = new TextBlock { Text = string.Format("Create issue here for {0}", selectedMailItem.Subject)}
         }.Show();
 }

        public void CreateIssue(IRibbonControl ribbonControl)
        {
            if (!CanCreateIssue) return;

            var issueViewModel = createIssuesViewModelFactory();
            issueViewModel.Initialise(selectedMailItem);
            contentHost.AddOrActivate(issueViewModel);
            CanCreateIssue = false;
        }

 // RunTagMacro helper function
 public virtual void RunTagMacro(IRibbonControl control)
 {
     if (!string.IsNullOrEmpty(control.Tag))
     {
         // CONSIDER: Is this a danger for shutting down - surely not...?
         object app = ExcelDnaUtil.Application;
         app.GetType().InvokeMember("Run", BindingFlags.InvokeMethod, null, app, new object[] { control.Tag }, new CultureInfo(1033));
     }
 }

 private void adxRibbonButton1_OnClick(object sender, IRibbonControl control, bool pressed)
 {
   Excel.Range selectedRange = null;
   if (ExcelApp.Selection is Excel.Range)
   {
     selectedRange = ExcelApp.Selection as Excel.Range;
   }
   Form derpForm = new ParamMapForm(selectedRange);
   derpForm.ShowDialog();
 }

 public void OnMainButtonClick(IRibbonControl control)
 {
     HTMLGenerator.IsResizeFont = IsSizeChange;
     var l = cli.GetCurrentId();
     var px = cli.GetPageContent(l);
     var xe = HTMLGenerator.CreateFromXml(px);
     var id = HTMLGenerator.PageId;
     id = id.Remove(id.LastIndexOf('}')).Remove(0, id.LastIndexOf('{') + 1);
     var xmlPath = System.IO.Path.Combine(pathdict, id + ".html");
     HTMLGenerator.WriteXml(xmlPath, xe);
 }

        public IPictureDisp GetImage(IRibbonControl control)
        {
            switch (control.Id)
            {
                case "createTask":
                    {
                        return base.GetPicture(Properties.Resources.gtfo32x32);
                    }
            }

            return null;
        }

        public void RegisterRibbonExtension(IRibbonControl ribbonControl, string location)
        {
            ribbon.RegisterDataExtension(ribbonControl.GetXmlDefinition(), location);

            // Select all command to register
            if (ribbonControl.Command != null)
            {
                ribbonCommands.Add(ribbonControl.Command);
            }

            isRegistedRibbons = true;
        }

        public void Invoke(IRibbonControl control, Expression<Action> caller, params object[] parameters)
        {
            try
            {
                CallbackTarget callbackTarget =
                    vstoContribContext.TagToCallbackTargetLookup[control.Tag + caller.GetMethodName()];

                IRibbonViewModel viewModelInstance = ribbonViewModelResolver.ResolveInstanceFor(control.Context);

                Type type = viewModelInstance.GetType();
                PropertyInfo property = type.GetProperty(callbackTarget.Method);

                if (property != null)
                {
                    type.InvokeMember(callbackTarget.Method,
                        BindingFlags.SetProperty,
                        null,
                        viewModelInstance,
                        new[]
                        {
                            parameters.Single()
                        });
                }
                else
                {
                    type.InvokeMember(callbackTarget.Method,
                        BindingFlags.InvokeMethod,
                        null,
                        viewModelInstance,
                        new[]
                        {
                            control
                        }
                            .Concat(parameters)
                            .ToArray());
                }
            }
            catch (TargetInvocationException e)
            {
                var innerEx = e.InnerException;
                PreserveStackTrace(innerEx);
                if (vstoContribContext.ErrorHandlers.Count == 0)
                {
                    Trace.TraceError(innerEx.ToString());
                }

                var handled = vstoContribContext.ErrorHandlers.Any(errorHandler => errorHandler.Handle(innerEx));

                if (!handled)
                    throw innerEx;
            }
        }

        public string GetLabel(IRibbonControl control)
        {
            if (!string.IsNullOrEmpty(control.Tag))
            {
                var index = Convert.ToInt32(control.Tag);
                if (index > _recentFolders.Count - 1)
                {
                    return string.Empty;
                }

                return MakePrettyBreadcrumb(_recentFolders[index]);
            }
            return string.Empty;
        }

        public string InvokeGetContent(IRibbonControl control, Expression<Action> caller, params object[] parameters)
        {
            // Remove any previous registered callbacks for this dynamic context
            vstoContribContext.RemoveCallbacksForDynamicContext(control.Tag);
            
            // Delegate to the view model to get the raw xml
            var xmlString = InvokeGet(control, caller, parameters);

            if (xmlString == null) return null;

            // Rewrite the XML with our callbacks, registering new callback targets
            var ribbonXmlRewriter = new RibbonXmlRewriter(vstoContribContext, ribbonViewModelResolver);
            var ribbonType = vstoContribContext.TagToCallbackTargetLookup[control.Tag + caller.GetMethodName()].RibbonType;
            return ribbonXmlRewriter.RewriteDynamicXml(ribbonType, control.Tag, xmlString.ToString());
        }

        public void CreateIssue(IRibbonControl control)
        {
            if (mailItem == null) return;

            if (tasks.User == null)
                tasks.Login();

            tasks.Title = mailItem.Subject;
            tasks.Sender = mailItem.Sender.Name;
            tasks.ReceivedDate = mailItem.ReceivedTime;
            tasks.Body = string.Format("Sender: {0} <{1}>\nReceived: {2}\n\n{3}",
                                        mailItem.Sender.Name,
                                        mailItem.Sender.Address,
                                        mailItem.ReceivedTime.ToString(CultureInfo.CurrentCulture),
                                        mailItem.Body);

            new GithubExplorerWindow(tasks).Show();
        }

        // This will enable the form to be displayed when clicking the add in button
        public void ShowForm(IRibbonControl control)
        {
            Window context = control.Context as Window;
            if (context != null)
            {
                CWin32WindowWrapper owner = new CWin32WindowWrapper((IntPtr)context.WindowHandle);
                MainForm form = new MainForm(_applicationObject as Application);
                form.ShowDialog(owner);

                form.Dispose();
                form = null;
                context = null;
                owner = null;
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }

        public void KindleSync(IRibbonControl control)
        {
            // Extract information from the form.
            //
            AmazonRegistrationForm inputForm = new AmazonRegistrationForm();
            inputForm.ShowDialog();
            inputForm.Focus();

            if (inputForm.User == null)
            {
                return;
            }

            string username = inputForm.User.UserName;
            string password = inputForm.User.Password;

            string sectionId = onApp.Windows.CurrentWindow.CurrentSectionId;

            // Getting content from amazon site.
            //
            HighlightsExtractor extractor = new HighlightsExtractor();
            extractor.LogIn(username, password);

            foreach (BookWithHighlights bookWithHighlights in extractor.Crawl())
            {
                StringBuilder sb = new StringBuilder();
                foreach (string highlight in bookWithHighlights.Highlights)
                {
                    sb.AppendLine(highlight);
                    sb.AppendLine();
                }

                string newPageId;
                onApp.CreateNewPage(sectionId, out newPageId);

                string newPageContent;
                onApp.GetPageContent(newPageId, out newPageContent);
                var doc = XDocument.Parse(newPageContent);
                var ns = doc.Root.Name.Namespace;

                onApp.UpdatePageContent(GetXDocForNewPage(newPageId, ns, bookWithHighlights.BookName, sb.ToString()).ToString());
            }
        }

        public void OpenMainForm_Click(IRibbonControl ribbon)
        {
            try
            {
                if (_mainForm == null)
                {
                    _mainForm = new Xero2ExcelWinForm(new ExcelApplicationWrapper(Application), ServiceLocator.Current);
                }

                if (!_mainForm.Visible)
                {
                    _mainForm.Show();
                }
            }
            catch (Exception ex)
            {
                ShowGeneralError(ex);
            }
        }

        public object InvokeGet(IRibbonControl control, Expression<Action> caller, params object[] parameters)
        {
            var methodName = caller.GetMethodName();
            CallbackTarget callbackTarget = vstoContribContext.TagToCallbackTargetLookup[control.Tag + methodName];

            var view = (object)control.Context;
            IRibbonViewModel viewModelInstance = ribbonViewModelResolver.ResolveInstanceFor(view);
            VstoContribLog.Debug(l => l("Ribbon callback {0} being invoked on {1} (View: {2}, ViewModel: {3})",
                methodName, control.Id, view.ToLogFormat(), viewModelInstance.ToLogFormat()));

            Type type = viewModelInstance.GetType();
            PropertyInfo property = type.GetProperty(callbackTarget.Method);

            if (property != null)
            {
                return type.InvokeMember(callbackTarget.Method,
                                         BindingFlags.GetProperty,
                                         null,
                                         viewModelInstance,
                                         null);
            }

            try
            {
                return type.InvokeMember(callbackTarget.Method,
                                         BindingFlags.InvokeMethod,
                                         null,
                                         viewModelInstance,
                                         new[]
                                         {
                                             control
                                         }
                                             .Concat(parameters)
                                             .ToArray());
            }
            catch (MissingMethodException)
            {
                throw new InvalidOperationException(
                    string.Format("Expecting method with signature: {0}.{1}(IRibbonControl control)",
                                  type.Name,
                                  callbackTarget.Method));
            }
        }