C# Applications.CommandState类代码示例

 /// <summary>
 /// Updates command state for given command. Only called if CanDoCommand is true.</summary>
 /// <param name="commandTag">Command</param>
 /// <param name="state">Command state to update</param>
 public void UpdateCommand(object commandTag, CommandState state)
 {
     var camController = commandTag as CameraController;
     if (camController == null)
         return;            
     var designControl = m_designView.ActiveView;
     state.Check = designControl.CameraController.GetType() == camController.GetType();
 }

 /// <summary>
 /// Updates command state for given command</summary>
 /// <param name="commandTag">Command</param>
 /// <param name="commandState">Command state to update</param>
 void ICommandClient.UpdateCommand(object commandTag, CommandState commandState)
 {
     var historyContext = m_contextRegistry.GetActiveContext<IHistoryContext>();
     if (historyContext != null)
     {
         if (commandTag.Equals(StandardCommand.EditUndo))
         {
             commandState.Text = string.Format("Undo {0}".Localize("{0} is the name of the command"), historyContext.UndoDescription);
         }
         else if (commandTag.Equals(StandardCommand.EditRedo))
         {
             commandState.Text = string.Format("Redo {0}".Localize("{0} is the name of the command"), historyContext.RedoDescription);
         }
     }
 }

        /// <summary>
        /// Updates the view's commands</summary>
        /// <param name="commandTag">The command tag</param>
        /// <param name="state">State of the command</param>
        public void UpdateCommand(object commandTag, CommandState state)
        {
            ISnapSettings snapSettings = (ISnapSettings)m_designView;
            IManipulator manip = commandTag as IManipulator;
            if(manip != null)
            {
                state.Check = manip == m_designView.Manipulator;
            }
            else if (commandTag is Command)
            {
                switch ((Command)commandTag)
                {
                    case Command.Select:
                        state.Check = m_designView.Manipulator == null;
                        break;

                    case Command.SnapToVertex:
                        state.Check = snapSettings.SnapVertex;
                        break;

                    case Command.RotateOnSnap:
                        state.Check = snapSettings.RotateOnSnap;
                        break;

                }
            }
        }

        private void LegacyUpdateCommand(ICommandItem item)
        {
            ICommandClient client = GetClient(item.CommandTag);
            if (client == null)
                client = m_activeClient;

            if (client != null)
            {
                var commandState = new CommandState { Text = item.Text, Check = item.IsChecked };
                client.UpdateCommand(item.CommandTag, commandState);
                item.Text = commandState.Text.Trim();
                item.IsChecked = commandState.Check;
            }
        }

 /// <summary>
 /// Updates command state for given command</summary>
 /// <param name="commandTag">Command</param>
 /// <param name="commandState">Command info to update</param>
 public virtual void UpdateCommand(object commandTag, CommandState commandState)
 {
     if ((commandTag is Command))
     {
         if ((Command)commandTag == Command.Enabled && SourceControlService != null)
         {
             commandState.Text = SourceControlService.Enabled ? "Disable Source Control".Localize() : "Enable Source Control".Localize();
             m_sourceControlEnableCmd.GetButton().ToolTipText = commandState.Text;
             m_sourceControlEnableCmd.GetButton().Image = SourceControlService.Enabled ? m_sourceControlEnableImage: m_sourceControlDisableImage;
         }
     }
 }

        /// <summary>
        /// Updates command state for given command</summary>
        /// <remarks>This is used e.g. to set the check next to a menu command or 
        /// to show a toolbar button as pressed</remarks>
        /// <param name="commandTag">Command</param>
        /// <param name="commandState">Command info to update</param>
        public void UpdateCommand(object commandTag, CommandState commandState)
        {
            //GameDocument document = m_contextRegistry.GetActiveContext<GameDocument>();
            //if (document == null)
            //    return;

            //if (commandTag is Command)
            //{
            //    switch ((Command)commandTag)
            //    {
            //        case Command.ToggleSplitMode:
            //            commandState.Check = document.SplitManipulator.Active;
            //            break;
            //    }
            //}
        }

 /// <summary>
 /// Updates command state for given command</summary>
 /// <param name="commandTag">Command</param>
 /// <param name="state">Command state to update</param>
 public void UpdateCommand(object commandTag, CommandState state)
 {
     Control control = commandTag as Control;
     if (control != null)
     {
         string menuText = GetControlMenuText(control);
         state.Text = menuText;
         DockContent dockContent = FindContent(control);
         state.Check = dockContent.Visible && !dockContent.IsHidden
             && !IsAutoHideState(dockContent);
     }
     else if (commandTag is StandardCommand)
     {
         if ( (StandardCommand) commandTag == StandardCommand.UILock)
         {
             state.Text = UILocked ? "Unlock UI Layout".Localize() : "Lock UI Layout".Localize();
             var cmdService = m_commandService as CommandServiceBase;
             if (cmdService != null)
             {
                 string lockImgName = UILocked ? Resources.LockUIImage : Resources.UnlockUIImage;
                 if (CommandInfo.UILock.ImageName != lockImgName)
                 {
                     CommandInfo.UILock.ImageName = lockImgName;
                     cmdService.RefreshImage(CommandInfo.UILock);                            
                     CommandInfo.UILock.GetButton().ToolTipText = state.Text;
                 }
             }
         }
     }
 }

        /// <summary>
        /// Updates the view's commands</summary>
        /// <param name="commandTag">The command tag</param>
        /// <param name="state">State of the command</param>
        public void UpdateCommand(object commandTag, CommandState state)
        {
            
            if (commandTag is Command)
            {
                switch ((Command)commandTag)
                {
                   
                    case Command.SingleView:
                        state.Check = m_designView.ViewMode == ViewModes.Single;
                        break;

                    case Command.QuadView:
                        state.Check = m_designView.ViewMode == ViewModes.Quad;
                        break;

                    case Command.DualHorizontalView:
                        state.Check = m_designView.ViewMode == ViewModes.DualHorizontal;
                        break;

                    case Command.DualVerticalView:
                        state.Check = m_designView.ViewMode == ViewModes.DualVertical;
                        break;
                }
            }
        }

        private void menuItem_MouseLeave(object sender, EventArgs e)
        {
            // clear status text
            if (m_statusService != null)
                m_statusService.ShowStatus(string.Empty);

            // Clear mouseover status
            m_menuMouseLocation = Point.Empty;
            m_mouseIsOverCommandIcon = null;

            var menuItem = sender as ToolStripMenuItem;
            if (menuItem != null)
            {
                object tag = menuItem.Tag;
                if ((tag != null) && (tag is IPinnable))
                {
                    CommandState commandState = new CommandState(menuItem.Text, menuItem.Checked);
                    UpdatePinnableCommand(tag, commandState);
                }
            }
        }

        private void menuItem_MouseMove(object sender, MouseEventArgs e)
        {
            m_menuMouseLocation = e.Location;
            
            var menuItem = sender as ToolStripMenuItem;
            if (menuItem != null)
            {
                object tag = menuItem.Tag;
                if ((tag != null) && (tag is IPinnable))
                {
                    if (IsMouseOverIcon(menuItem))
                        m_mouseIsOverCommandIcon = m_commandsById[tag];
                    else
                        m_mouseIsOverCommandIcon = null;

                    CommandState commandState = new CommandState(menuItem.Text, menuItem.Checked);
                    UpdatePinnableCommand(tag, commandState);
                }
            }
        }

        /// <summary>
        /// Force an update on a particular command</summary>
        /// <param name="info">Command to update</param>
        public void UpdateCommand(CommandInfo info)
        {
            if (m_mainForm.InvokeRequired)
            {
                m_mainForm.BeginInvoke(new Action<CommandInfo>(UpdateCommand), info);
                return;
            }

            ToolStripMenuItem menuItem;
            ToolStripButton menuButton;
            info.GetMenuItemAndButton(out menuItem, out menuButton);

            CommandState commandState = new CommandState();
            commandState.Text = info.DisplayedMenuText;
            commandState.Check = menuItem.Checked;

            ICommandClient client = GetClient(info.CommandTag);
            if (client == null)
                client = m_activeClient;

            bool enabled = false;
            if (client != null)
            {
                enabled = client.CanDoCommand(info.CommandTag);
                if (enabled)
                    client.UpdateCommand(info.CommandTag, commandState);
            }

            string menuText = commandState.Text.Trim();

            menuItem.Text = menuButton.Text = menuText;
            menuItem.Checked = menuButton.Checked = commandState.Check;
            menuItem.Enabled = menuButton.Enabled = enabled;
        }

        /// <summary>
        /// Updates a command</summary>
        /// <param name="commandTag">Command</param>
        /// <param name="state">Command state</param>
        public override void UpdateCommand(object commandTag, CommandState state)
        {
            if (!(commandTag is WindowLayoutServiceCommand))
                return;

            var cmd = (WindowLayoutServiceCommand)commandTag;
            state.Check = WindowLayoutService.IsCurrent(cmd.LayoutName);
        }

        /// <summary>
        /// Updates command state for given command. Only called if CanDoCommand is true.</summary>
        /// <param name="commandTag">Command</param>
        /// <param name="state">Command state to update</param>
        public void UpdateCommand(object commandTag, CommandState state)
        {
            if (!(commandTag is Command))
                return;

            if (m_designView == null)
                return;

            var designControl = m_designView.ActiveView;

            switch ((Command)commandTag)
            {
                case Command.Arcball:
                    state.Check = (designControl.CameraController is ArcBallCameraController);
                    break;

                case Command.Maya:
                    state.Check = (designControl.CameraController is MayaStyleCameraController);
                    break;

                case Command.Walk:
                    state.Check = (designControl.CameraController is WalkCameraController);
                    break;

                case Command.Fly:
                    state.Check = (designControl.CameraController is FlyCameraController);
                    break;
            }
        }

        /// <summary>
        /// Updates command state for given command</summary>
        /// <param name="commandTag">Command</param>
        /// <param name="state">Command state to update</param>
        public void UpdateCommand(object commandTag, CommandState state)
        {
            if (commandTag is CommandTag)
            {
               
                if (commandTag.Equals(CommandTag.ResetGroupPinNames))
                {
                    if (m_targetRef != null && m_targetRef.Target != null)
                    {
                        object target = m_targetRef.Target;
                        if (target.Is<Group>())
                        {
                            var group = target.Cast<Group>();
                            state.Text = string.Format("Reset Pin Names on \"{0}\"".Localize(), group.Name);
                        }
                    }
                }
                else if (commandTag.Equals(CommandTag.ShowExpandedGroupPins))
                {
                    if (m_targetRef != null && m_targetRef.Target != null)
                    {
                        object target = m_targetRef.Target;
                        if (target.Is<Group>())
                        {
                            var group = target.Cast<Group>();
                            state.Check = group.Info.ShowExpandedGroupPins;
                            state.Text = string.Format("Show Expanded Group Pins on \"{0}\"".Localize(), group.Name);
                        }
                    }
                }
                else if (commandTag.Equals(CommandTag.HideUnconnectedPins))
                {
                    if (m_targetRef != null && m_targetRef.Target != null)
                    {
                        object target = m_targetRef.Target;
                        if (target.Is<Group>())
                        {
                            var group = target.Cast<Group>();
                            var graphContainer = group.ParentGraph.As<ICircuitContainer>();
                            if (graphContainer != null)
                            {
                                // check if all unconnected pins are hidden
                                m_allUnconnectedHidden = true;
                                foreach (var grpPin in group.InputGroupPins)
                                {
                                    bool externalConectd =
                                        graphContainer.Wires.FirstOrDefault(
                                            x => x.InputPinTarget.FullyEquals(grpPin.PinTarget)) != null;
                                    if (!externalConectd && grpPin.Visible)
                                    {
                                        m_allUnconnectedHidden = false;
                                        break;
                                    }
                                }
                                if (m_allUnconnectedHidden)
                                {
                                    foreach (var grpPin in group.OutputGroupPins)
                                    {
                                        bool externalConectd =
                                            graphContainer.Wires.FirstOrDefault(
                                                x => x.OutputPinTarget.FullyEquals(grpPin.PinTarget)) != null;
                                        if (!externalConectd && grpPin.Visible)
                                        {
                                            m_allUnconnectedHidden = false;
                                            break;
                                        }
                                    }
                                }

                                state.Check = m_allUnconnectedHidden;
                                state.Text = string.Format("Hide Unconnected Pins on \"{0}\"".Localize(), group.Name);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Updates command state for given command</summary>
        /// <param name="commandTag">Command</param>
        /// <param name="state">Command state to update</param>
        public virtual void UpdateCommand(object commandTag, CommandState state)
        {
            bool invertPinImageOnMouseover = false;
            bool useGreenPin = true;
            var info = commandTag as RecentDocumentInfo;
            if (info != null)
            {
                // For the document entries in the MRU, the pin color reflects the pinned state of
                // the item. The exception is when the user mouses over the pin icon directly - then 
                // we invert the color of the pin to show that it's clickable and will modify the
                // pinned state of the document.
                invertPinImageOnMouseover = true;
                state.Text = info.Uri.LocalPath;
                if (!info.Pinned)
                {
                    useGreenPin = false;
                }
            }
            else if (commandTag is Command)
            {
                var command = (Command)commandTag;
                if (command == Command.Pin)
                {
                    // For the other pin commands, the pin color is the opposite of the active 
                    // document's pinned state.
                    var docInfo = GetActiveRecentDocumentInfo();
                    var stateText = "Pin active document".Localize();
                    if (docInfo != null)
                    {
                        useGreenPin = !docInfo.Pinned;
                        var docPath = docInfo.Uri.AbsolutePath;
                        if (MaxPathLength > 0 && docPath.Length > MaxPathLength)
                        {
                            docPath = docPath.Substring(docPath.Length - MaxPathLength);
                            while (!docPath.StartsWith("/"))
                                docPath = docPath.Substring(1);
                            docPath = "..." + docPath;
                        }
                        stateText = string.Format(
                            docInfo.Pinned ?
                                "Unpin {0}".Localize("{0} will be replaced with a file name") :
                                "Pin {0}".Localize("{0} will be replaced with a file name"),
                                docPath);
                    }
                    state.Text = stateText;
                }
                else if (command == Command.EmptyMru)
                {
                    return;
                }
            }

            var commandServiceBase = CommandService as CommandServiceBase;
            if (commandServiceBase != null)
            {
                var commandInfo = commandServiceBase.GetCommandInfo(commandTag);

                if (commandInfo != null)
                {
                    if (invertPinImageOnMouseover)
                    {
                        // Make sure user is mousing over this command.
                        if (commandServiceBase.MouseIsOverCommandIcon == commandInfo)
                        {
                            useGreenPin = !useGreenPin;
                        }
                    }

                    var imageName = useGreenPin ? Resources.PinGreenImage : Resources.PinGreyImage;
                    if (commandInfo.ImageName != imageName)
                    {
                        commandInfo.ImageName = imageName;
                        commandServiceBase.RefreshImage(commandInfo);
                    }
                }
            }
        }