Example #1
0
 private void ListMenu_Opened(object sender, RoutedEventArgs e)
 {
     ToolWindowHelper.ConstructContextMenu(sender as ContextMenu, SelectedItem,
                                           ViewDetails, ViewTaskParentDetails, ViewCommentParentDetails,
                                           OpenInBrowser, CopyCommitMessage, DownloadScript,
                                           StartWork, StopWork, null, RemoveFromMyWork);
 }
Example #2
0
 private void RemoveFromMyWork(object sender)
 {
     if (SelectedItem?.Entity == null)
     {
         return;
     }
     ToolWindowHelper.RemoveFromMyWork(ToRemoveEntity());
 }
Example #3
0
        public void ToolWindowHelperTests_ConstructContextMenu_NullSelectedItem_Success()
        {
            var cm = new ContextMenu();

            cm.Items.Add(new MenuItem());

            ToolWindowHelper.ConstructContextMenu(cm, null, null, null, null, null, null, null, null, null, null, null);

            Assert.AreEqual(0, cm.Items.Count, "Mismatched number of menu items in context menu");
        }
        /// <summary>
        /// This function is the callback used to execute the command when the menu item is clicked.
        /// See the constructor to see how the menu item is associated with this function using
        /// OleMenuCommandService service and MenuCommand class.
        /// </summary>
        /// <param name="sender">Event sender.</param>
        /// <param name="e">Event args.</param>
        private void Execute(object sender, EventArgs e)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var project = SolutionHelper.GetCurrentProject();

            if (project == null)
            {
                LoggerHelper.Log("Unable to get current project.");
                return;
            }

            ToolWindowHelper.Prompt <ProjectRenameDialogToolPane>(this.package, new ProjectRenameDialogViewModel(project));
        }
Example #5
0
 private void DownloadScript(object sender)
 {
     ToolWindowHelper.DownloadScript(SelectedItem);
 }
Example #6
0
 private void results_MouseDoubleClick(object sender, MouseButtonEventArgs e)
 {
     ToolWindowHelper.HandleDoubleClickOnItem(GetSelectedEntity(), CopyCommitMessage);
 }
Example #7
0
 private void ViewCommentParentDetails(object param)
 {
     ToolWindowHelper.ViewCommentParentDetails(SelectedItem);
 }
Example #8
0
 private void ViewDetails(object param)
 {
     ToolWindowHelper.ViewDetails(GetSelectedEntity());
 }
Example #9
0
 private void OpenInBrowser(object param)
 {
     ToolWindowHelper.OpenInBrowser(GetSelectedEntity());
 }
Example #10
0
 /// <summary>
 /// Shows the tool window when the menu item is clicked.
 /// </summary>
 /// <param name="sender">The event sender.</param>
 /// <param name="e">The event args.</param>
 private void Execute(object sender, EventArgs e)
 {
     ToolWindowHelper.Prompt <ProjectMoverToolWindow>(this.package);
 }
Example #11
0
 private void Window_Loaded(object sender, RoutedEventArgs e)
 {
     ToolWindowHelper.SetToolWindow(this);
 }
Example #12
0
 public void ToolWindowHelperTests_ConstructContextMenu_NullContextMenu_Success()
 {
     ToolWindowHelper.ConstructContextMenu(null, null, null, null, null, null, null, null, null, null, null, null);
 }
Example #13
0
        // TODO remove useMyItems and use a more generic mechanism to obtain the BaseItemViewModel
        private void ValidateContextMenuItems <T>(T entity, List <MenuItemEnum> expectedMenuItems, bool useMyItems = true, bool setActiveItem = false) where T : BaseEntity
        {
            try
            {
                BaseItemViewModel selectedItem;
                if (useMyItems)
                {
                    var viewModel = new OctaneMyItemsViewModel();
                    viewModel.LoadMyItemsAsync().Wait();

                    selectedItem = viewModel.MyItems.FirstOrDefault(i => i.ID == entity.Id);

                    if (setActiveItem)
                    {
                        OctaneItemViewModel.SetActiveItem(selectedItem as OctaneItemViewModel);
                    }
                }
                else
                {
                    selectedItem = new BaseItemViewModel(entity);
                }

                Assert.IsNotNull(selectedItem, "Couldn't find entity");

                var cm = new ContextMenu();

                ToolWindowHelper.ConstructContextMenu(cm, selectedItem,
                                                      _viewDetailsDelegate,
                                                      _viewTaskParentDetailsDelegate,
                                                      _viewCommentParentDetailsDelegate,
                                                      _openInBrowserDelegate,
                                                      _copyCommitMessageDelegate,
                                                      _downloadScriptDelegate,
                                                      _startWorkDelegate,
                                                      _stopWorkDelegate,
                                                      null,
                                                      null);

                Assert.AreEqual(expectedMenuItems.Count, cm.Items.Count,
                                "Mismatched number of menu items in context menu");

                var items = new MenuItem[cm.Items.Count];
                cm.Items.CopyTo(items, 0);

                int index = 0;
                foreach (var item in expectedMenuItems)
                {
                    switch (item)
                    {
                    case MenuItemEnum.ViewDetails:
                        ValidateMenuItem(items, index, ToolWindowHelper.ViewDetailsHeader, ViewDetailsValue);
                        break;

                    case MenuItemEnum.TaskViewParentDetails:
                        ValidateMenuItem(items, index, ToolWindowHelper.ViewTaskParentDetailsHeader, ViewTaskParentDetailsValue);
                        break;

                    case MenuItemEnum.CommentViewParentDetails:
                        ValidateMenuItem(items, index, ToolWindowHelper.CopyCommitMessageHeader, ViewCommentParentDetailsValue);
                        break;

                    case MenuItemEnum.OpenInBrowser:
                        ValidateMenuItem(items, index, ToolWindowHelper.OpenInBrowserHeader, OpenInBrowserValue);
                        break;

                    case MenuItemEnum.CopyCommitMessage:
                        ValidateMenuItem(items, index, ToolWindowHelper.CopyCommitMessageHeader, CopyCommitMessageValue);
                        break;

                    case MenuItemEnum.DownloadScript:
                        ValidateMenuItem(items, index, ToolWindowHelper.DownloadScriptHeader, DownloadScriptValue);
                        break;

                    case MenuItemEnum.StartWork:
                        ValidateMenuItem(items, index, ToolWindowHelper.StartWorkHeader, StartWorkValue);
                        break;

                    case MenuItemEnum.StopWork:
                        ValidateMenuItem(items, index, ToolWindowHelper.StopWorkHeader, StopWorkValue);
                        break;
                    }

                    index++;
                }
            }
            finally
            {
                EntityService.DeleteById <T>(WorkspaceContext, entity.Id);
            }
        }