static void ProcessPendingChangesMenuOperation(
            PendingChangesMenuOperations operationToExecute,
            IPendingChangesMenuOperations pendingChangesMenuOperations,
            bool isGluonMode)
        {
            if (operationToExecute == PendingChangesMenuOperations.DiffWorkspaceContent)
            {
                if (LaunchTool.ShowDownloadPlasticExeWindow(isGluonMode))
                {
                    return;
                }

                pendingChangesMenuOperations.Diff();
                return;
            }

            if (operationToExecute == PendingChangesMenuOperations.Delete)
            {
                pendingChangesMenuOperations.Delete();
                return;
            }

            if (operationToExecute == PendingChangesMenuOperations.History)
            {
                pendingChangesMenuOperations.History();
                return;
            }
        }
Пример #2
0
        internal bool ProcessKeyActionIfNeeded(Event e)
        {
            PendingChangesMenuOperations operationToExecute =
                GetPendingChangesMenuOperation(e);

            OpenMenuOperations openOperationToExecute =
                GetOpenMenuOperation(e);

            if (operationToExecute == PendingChangesMenuOperations.None &&
                openOperationToExecute == OpenMenuOperations.None)
            {
                return(false);
            }

            SelectedChangesGroupInfo info =
                mPendingChangesMenuOperations.GetSelectedChangesGroupInfo();

            if (operationToExecute != PendingChangesMenuOperations.None)
            {
                return(ProcessKeyActionForPendingChangesMenu(
                           operationToExecute, mPendingChangesMenuOperations, info));
            }

            return(ProcessKeyActionForOpenMenu(
                       openOperationToExecute, mOpenMenuOperations, info));
        }
Пример #3
0
        static bool ProcessKeyActionForPendingChangesMenu(
            PendingChangesMenuOperations operationToExecute,
            IPendingChangesMenuOperations pendingChangesMenuOperations,
            SelectedChangesGroupInfo info)
        {
            PendingChangesMenuOperations operations =
                PendingChangesMenuUpdater.GetAvailableMenuOperations(info);

            if (!operations.HasFlag(operationToExecute))
            {
                return(false);
            }

            ProcessPendingChangesMenuOperation(
                operationToExecute, pendingChangesMenuOperations);

            return(true);
        }
Пример #4
0
        static bool ProcessKeyActionForPendingChangesMenu(
            WorkspaceInfo wkInfo,
            PendingChangesMenuOperations operationToExecute,
            IPendingChangesMenuOperations pendingChangesMenuOperations,
            SelectedChangesGroupInfo info,
            bool isGluonMode)
        {
            PendingChangesMenuOperations operations =
                PendingChangesMenuUpdater.GetAvailableMenuOperations(info);

            if (!operations.HasFlag(operationToExecute))
            {
                return(false);
            }

            ProcessPendingChangesMenuOperation(
                wkInfo, operationToExecute, pendingChangesMenuOperations, isGluonMode);

            return(true);
        }
Пример #5
0
        static void ProcessPendingChangesMenuOperation(
            PendingChangesMenuOperations operationToExecute,
            IPendingChangesMenuOperations pendingChangesMenuOperations)
        {
            if (operationToExecute == PendingChangesMenuOperations.DiffWorkspaceContent)
            {
                pendingChangesMenuOperations.Diff();
                return;
            }

            if (operationToExecute == PendingChangesMenuOperations.Delete)
            {
                pendingChangesMenuOperations.Delete();
                return;
            }

            if (operationToExecute == PendingChangesMenuOperations.History)
            {
                pendingChangesMenuOperations.History();
                return;
            }
        }
Пример #6
0
        internal bool ProcessKeyActionIfNeeded(Event e)
        {
            PendingChangesMenuOperations operationToExecute = GetMenuOperation(e);

            if (operationToExecute == PendingChangesMenuOperations.None)
            {
                return(false);
            }

            SelectedChangesGroupInfo info =
                mPendingChangesMenuOperations.GetSelectedChangesGroupInfo();
            PendingChangesMenuOperations operations =
                PendingChangesMenuUpdater.GetAvailableMenuOperations(info);

            if (!operations.HasFlag(operationToExecute))
            {
                return(false);
            }

            ProcessMenuOperation(operationToExecute, mPendingChangesMenuOperations);
            return(true);
        }
Пример #7
0
        static void ProcessPendingChangesMenuOperation(
            WorkspaceInfo wkInfo,
            PendingChangesMenuOperations operationToExecute,
            IPendingChangesMenuOperations pendingChangesMenuOperations,
            bool isGluonMode)
        {
            if (operationToExecute == PendingChangesMenuOperations.DiffWorkspaceContent)
            {
                pendingChangesMenuOperations.Diff();
                return;
            }

            if (operationToExecute == PendingChangesMenuOperations.Delete)
            {
                pendingChangesMenuOperations.Delete();
                return;
            }

            if (operationToExecute == PendingChangesMenuOperations.History)
            {
                pendingChangesMenuOperations.History();
                return;
            }
        }
Пример #8
0
        void UpdateMenuItems(GenericMenu menu)
        {
            SelectedChangesGroupInfo info =
                mPendingChangesMenuOperations.GetSelectedChangesGroupInfo();

            PendingChangesMenuOperations operations =
                PendingChangesMenuUpdater.GetAvailableMenuOperations(info);

            OpenMenuOperations openOperations =
                GetOpenMenuOperations.ForPendingChanges(info);

            if (operations == PendingChangesMenuOperations.None &&
                openOperations == OpenMenuOperations.None)
            {
                menu.AddDisabledItem(GetNoActionMenuItemContent());
                return;
            }

            UpdateOpenMenuItems(menu, openOperations);

            menu.AddSeparator(string.Empty);

            if (operations.HasFlag(PendingChangesMenuOperations.DiffWorkspaceContent))
            {
                menu.AddItem(mDiffMenuItemContent, false, DiffMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mDiffMenuItemContent);
            }

            if (mMetaMenuOperations.SelectionHasMeta())
            {
                if (operations.HasFlag(PendingChangesMenuOperations.DiffWorkspaceContent))
                {
                    menu.AddItem(mDiffMetaMenuItemContent, false, DiffMetaMenuItem_Click);
                }
                else
                {
                    menu.AddDisabledItem(mDiffMetaMenuItemContent);
                }
            }

            menu.AddSeparator(string.Empty);

            if (operations.HasFlag(PendingChangesMenuOperations.UndoChanges))
            {
                menu.AddItem(mUndoChangesMenuItemContent, false, UndoChangesMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mUndoChangesMenuItemContent);
            }

            menu.AddSeparator(string.Empty);

            if (operations.HasFlag(PendingChangesMenuOperations.ApplyLocalChanges))
            {
                menu.AddItem(mCheckoutMenuItemContent, false, CheckoutMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mCheckoutMenuItemContent);
            }

            if (operations.HasFlag(PendingChangesMenuOperations.Delete))
            {
                menu.AddItem(mDeleteMenuItemContent, false, DeleteMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mDeleteMenuItemContent);
            }

            menu.AddSeparator(string.Empty);

            mFilterMenuBuilder.UpdateMenuItems(
                menu, FilterMenuUpdater.GetMenuActions(info));

            menu.AddSeparator(string.Empty);

            if (operations.HasFlag(PendingChangesMenuOperations.History))
            {
                menu.AddItem(mViewHistoryMenuItemContent, false, HistoryMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mViewHistoryMenuItemContent, false);
            }

            if (mMetaMenuOperations.SelectionHasMeta())
            {
                if (operations.HasFlag(PendingChangesMenuOperations.History))
                {
                    menu.AddItem(mViewHistoryMetaMenuItemContent, false, HistoryMetaMenuItem_Click);
                }
                else
                {
                    menu.AddDisabledItem(mViewHistoryMetaMenuItemContent);
                }
            }
        }
Пример #9
0
        void UpdateOpenMenuItems(GenericMenu menu, PendingChangesMenuOperations operations)
        {
            if (!operations.HasFlag(PendingChangesMenuOperations.Open) &&
                !operations.HasFlag(PendingChangesMenuOperations.OpenWith) &&
                !operations.HasFlag(PendingChangesMenuOperations.OpenInExplorer))
            {
                menu.AddDisabledItem(mOpenSubmenuItemContent);
                return;
            }

            if (operations.HasFlag(PendingChangesMenuOperations.Open))
            {
                menu.AddItem(mOpenMenuItemContent, false, OpenMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mOpenMenuItemContent);
            }

            if (operations.HasFlag(PendingChangesMenuOperations.OpenWith))
            {
                menu.AddItem(mOpenWithMenuItemContent, false, OpenWithMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mOpenWithMenuItemContent);
            }

            if (operations.HasFlag(PendingChangesMenuOperations.OpenInExplorer))
            {
                menu.AddItem(mOpenInExplorerMenuItemContent, false, OpenInExplorerMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mOpenInExplorerMenuItemContent);
            }

            if (!mMetaMenuOperations.SelectionHasMeta())
            {
                return;
            }

            menu.AddSeparator(PlasticLocalization.GetString(PlasticLocalization.Name.ItemsMenuItemOpen) + "/");

            if (operations.HasFlag(PendingChangesMenuOperations.Open))
            {
                menu.AddItem(mOpenMetaMenuItemContent, false, OpenMetaMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mOpenMetaMenuItemContent);
            }

            if (operations.HasFlag(PendingChangesMenuOperations.OpenWith))
            {
                menu.AddItem(mOpenMetaWithMenuItemContent, false, OpenMetaWithMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mOpenMetaWithMenuItemContent);
            }

            if (operations.HasFlag(PendingChangesMenuOperations.OpenInExplorer))
            {
                menu.AddItem(mOpenMetaInExplorerMenuItemContent, false, OpenMetaInExplorerMenuItem_Click);
            }
            else
            {
                menu.AddDisabledItem(mOpenMetaInExplorerMenuItemContent);
            }
        }