public override void PostprocessMouseUp(MouseButtonEventArgs e)
        {
            uint cmdId;

            switch (e.ChangedButton)
            {
            case MouseButton.XButton1:
                cmdId = (uint)VSConstants.VSStd97CmdID.ShellNavBackward;
                break;

            case MouseButton.XButton2:
                cmdId = (uint)VSConstants.VSStd97CmdID.ShellNavForward;
                break;

            default:
                return;
            }

            try
            {
                IVsUIShell    shell      = (IVsUIShell)ServiceProvider.GetService(typeof(SVsUIShell));
                Guid          cmdGroup   = VSConstants.GUID_VSStandardCommandSet97;
                OLECMDEXECOPT cmdExecOpt = OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER;
                object        obj        = null;
                ErrorHandler.ThrowOnFailure(shell.PostExecCommand(cmdGroup, cmdId, (uint)cmdExecOpt, ref obj));
                e.Handled = true;
            }
            catch (COMException)
            {
            }
        }
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
            {
                switch ((VSConstants.VSStd2KCmdID)commandId)
                {
                case VSConstants.VSStd2KCmdID.RETURN:
                    return(HandleCompletion('\n'));

                case VSConstants.VSStd2KCmdID.TAB:
                    return(HandleCompletion('\t'));

                case VSConstants.VSStd2KCmdID.TYPECHAR:
                    char typedChar = Convert.ToChar(Marshal.GetObjectForNativeVariant(pvaIn));

                    switch (typedChar)
                    {
                    case '/':
                    case '>':
                    case ' ':
                        return(HandleCompletion(typedChar));

                    default:
                        return(false);
                    }

                default:
                    break;
                }
            }

            return(false);
        }
Beispiel #3
0
        private int InnerExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (_next != null)
            {
                return(_next.Exec(ref commandGroup, commandId, (uint)executionOptions, pvaIn, pvaOut));
            }

            return((int)OleConstants.OLECMDERR_E_NOTSUPPORTED);
        }
Beispiel #4
0
        /// <summary>
        /// This is overridden to handle command execution for the node
        /// </summary>
        /// <param name="cmdGroup">Unique identifier of the command group</param>
        /// <param name="cmd">The command to be executed.</param>
        /// <param name="nCmdexecopt">Values describe how the object should
        /// execute the command.</param>
        /// <param name="pvaIn">Pointer to a <c>VARIANTARG</c> structure
        /// containing input arguments. Can be NULL</param>
        /// <param name="pvaOut"><c>VARIANTARG</c> structure to receive command
        /// output.  It can be null.</param>
        /// <returns>If the method succeeds, it returns <c>S_OK</c>. If it
        /// fails, it returns an error code.</returns>
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn,
                                                 IntPtr pvaOut)
        {
            if (cmdGroup == GuidList.guidSandcastleBuilderPackageCmdSet && (int)cmd == PkgCmdIDList.AddDocSource)
            {
                this.AddDocumentationSources();
                return(VSConstants.S_OK);
            }

            return(base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut));
        }
Beispiel #5
0
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                if ((VsCommands2K)cmd == VsCommands2K.QUICKOBJECTSEARCH)
                {
                    return(this.ShowObjectBrowser());
                }
            }

            return(base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut));
        }
Beispiel #6
0
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch ((VsCommands2K)cmd)
                {
                case VsCommands2K.ADDREFERENCE:
                    return(this.ProjectManager.AddProjectReference());

                case VsCommands2K.ADDWEBREFERENCE:
                    return(this.ProjectManager.AddWebReference());
                }
            }

            return(base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut));
        }
Beispiel #7
0
        /// <summary>
        /// This method provides the primary implementation for <see cref="IOleCommandTarget.Exec"/> in all cases where
        /// <see cref="OLECMDEXECOPT.OLECMDEXECOPT_SHOWHELP"/> was not requested.
        /// </summary>
        /// <param name="guidCmdGroup">The command group.</param>
        /// <param name="nCmdID">The command ID.</param>
        /// <param name="nCmdexecopt">The OLE command execution options.</param>
        /// <param name="pvaIn">An optional pointer to the command argument(s). The semantics of this parameter are
        /// specific to a particular command.</param>
        /// <param name="pvaOut">An optional pointer to the command result(s). The semantics of this parameter are
        /// specific to a particular command.</param>
        /// <returns>
        /// <para>This method returns <see cref="VSConstants.S_OK"/> on success.</para>
        /// <para>-or-</para>
        /// <para><see cref="OleConstants.OLECMDERR_E_NOTSUPPORTED"/> if the command is not handled by this command
        /// filter, and no other command filters are available to process the request.</para>
        /// </returns>
        private int ExecCommand(ref Guid guidCmdGroup, uint nCmdID, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            int rc = VSConstants.S_OK;

            if (!HandlePreExec(ref guidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut))
            {
                // Pass it along the chain.
                rc = this.InnerExec(ref guidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
                if (!ErrorHandler.Succeeded(rc))
                {
                    return(rc);
                }

                HandlePostExec(ref guidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
            }

            return(rc);
        }
Beispiel #8
0
        /// <summary>
        /// This is overridden to handle command execution for the node
        /// </summary>
        /// <param name="cmdGroup">Unique identifier of the command group</param>
        /// <param name="cmd">The command to be executed.</param>
        /// <param name="nCmdexecopt">Values describe how the object should
        /// execute the command.</param>
        /// <param name="pvaIn">Pointer to a <c>VARIANTARG</c> structure
        /// containing input arguments. Can be NULL</param>
        /// <param name="pvaOut"><c>VARIANTARG</c> structure to receive command
        /// output.  It can be null.</param>
        /// <returns>If the method succeeds, it returns <c>S_OK</c>. If it
        /// fails, it returns an error code.</returns>
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn,
                                                 IntPtr pvaOut)
        {
            // Open the Project Properties window when double-clicked or Properties is selected
            if ((cmdGroup == VsMenus.guidStandardCommandSet97 && (VsCommands)cmd == VsCommands.PropSheetOrProperties) ||
                (cmdGroup == VsMenus.guidVSUISet && (WindowCommandIds)cmd == WindowCommandIds.UIHWCMDID_DoubleClick))
            {
                IntPtr         ip    = (IntPtr)(-1);
                IVsWindowFrame frame = null;

                ((IVsProject2)this.ProjectManager).ReopenItem(VSConstants.VSITEMID_ROOT,
                                                              VSConstants.GUID_ProjectDesignerEditor, null, Guid.Empty, ip, out frame);

                return(VSConstants.S_OK);
            }

            return(base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut));
        }
        /// <inheritdoc/>
        /// <remarks>
        /// This method handles execution of the <see cref="VsCommands2K.COMMENT_BLOCK"/>
        /// and <see cref="VsCommands2K.UNCOMMENT_BLOCK"/> commands by calling
        /// <see cref="CommentSelection"/> and <see cref="UncommentSelection"/> (respectively)
        /// and returning <see langword="true"/>.
        /// </remarks>
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(VsCommands2K).GUID)
            {
                VsCommands2K cmd = (VsCommands2K)commandId;
                switch (cmd)
                {
                case VsCommands2K.COMMENT_BLOCK:
                    this.CommentSelection();
                    return(true);

                case VsCommands2K.UNCOMMENT_BLOCK:
                    this.UncommentSelection();
                    return(true);
                }
            }

            return(base.HandlePreExec(ref commandGroup, commandId, executionOptions, pvaIn, pvaOut));
        }
Beispiel #10
0
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch ((VsCommands2K)cmd)
                {
                case VsCommands2K.INCLUDEINPROJECT:
                    return(((IProjectSourceNode)this).IncludeInProject());

                case VsCommands2K.EXCLUDEFROMPROJECT:
                    return(((IProjectSourceNode)this).ExcludeFromProject());

                case ProjectFileConstants.CommandExploreFolderInWindows:
                    ProjectNode.ExploreFolderInWindows(GetMKDocument());
                    return(VSConstants.S_OK);
                }
            }

            return(base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut));
        }
        /// <inheritdoc />
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn,
                                                 IntPtr pvaOut)
        {
            if (cmdGroup == GuidList.guidSandcastleBuilderPackageCmdSet)
            {
                switch (cmd)
                {
                case PkgCmdIDList.OpenInStandaloneGUI:
                    this.OpenInStandaloneGui();
                    return(VSConstants.S_OK);

                case PkgCmdIDList.ViewBuildLog:
                    this.OpenBuildLogToolWindow(true);
                    return(VSConstants.S_OK);

                default:
                    break;
                }
            }

            return(base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut));
        }
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
            {
                switch ((VSConstants.VSStd2KCmdID)commandId)
                {
                case VSConstants.VSStd2KCmdID.RETURN:
                    return HandleReturn();

                case VSConstants.VSStd2KCmdID.TAB:
                    return HandleTab();

                case VSConstants.VSStd2KCmdID.TYPECHAR:
                    char typedChar = Convert.ToChar(Marshal.GetObjectForNativeVariant(pvaIn));
                    return HandleTypeChar(typedChar);

                default:
                    break;
                }
            }

            return false;
        }
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
            {
                switch ((VSConstants.VSStd2KCmdID)commandId)
                {
                case VSConstants.VSStd2KCmdID.OPENURL:
                    if (pvaIn != IntPtr.Zero)
                    {
                        int line = (int)Marshal.GetObjectForNativeVariant(pvaIn);
                        int column = (int)Marshal.GetObjectForNativeVariant(new IntPtr(pvaIn.ToInt32() + 16));
                        return TryOpenUrlAtPoint(line, column);
                    }

                    return TryOpenUrlAtCaret();

                default:
                    break;
                }
            }

            return base.HandlePreExec(ref commandGroup, commandId, executionOptions, pvaIn, pvaOut);
        }
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(VSConstants.VSStd2KCmdID).GUID)
            {
                switch ((VSConstants.VSStd2KCmdID)commandId)
                {
                case VSConstants.VSStd2KCmdID.OPENURL:
                    if (pvaIn != IntPtr.Zero)
                    {
                        int line   = (int)Marshal.GetObjectForNativeVariant(pvaIn);
                        int column = (int)Marshal.GetObjectForNativeVariant(new IntPtr(pvaIn.ToInt32() + 16));
                        return(TryOpenUrlAtPoint(line, column));
                    }

                    return(TryOpenUrlAtCaret());

                default:
                    break;
                }
            }

            return(base.HandlePreExec(ref commandGroup, commandId, executionOptions, pvaIn, pvaOut));
        }
Beispiel #15
0
        private int ExecCommand(ref Guid guidCmdGroup, uint nCmdID, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            int rc = VSConstants.S_OK;

            if (!HandlePreExec(ref guidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut) && _next != null)
            {
                // Pass it along the chain.
                rc = this.InnerExec(ref guidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
                if (!ErrorHandler.Succeeded(rc))
                    return rc;

                HandlePostExec(ref guidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
            }

            return rc;
        }
Beispiel #16
0
        private int InnerExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (_next != null)
                return _next.Exec(ref commandGroup, commandId, (uint)executionOptions, pvaIn, pvaOut);

            return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;
        }
Beispiel #17
0
 /// <summary>
 /// This method supports the implementation for commands which are directly implemented by this command filter.
 /// </summary>
 /// <remarks>
 /// The default implementation returns <see langword="false"/> for all commands.
 /// </remarks>
 /// <param name="commandGroup">The command group.</param>
 /// <param name="commandId">The command ID.</param>
 /// <param name="executionOptions">The OLE command execution options.</param>
 /// <param name="pvaIn">An optional pointer to the command argument(s). The semantics of this parameter are specific to a particular command.</param>
 /// <param name="pvaOut">An optional pointer to the command result(s). The semantics of this parameter are specific to a particular command.</param>
 /// <returns>
 /// <see langword="true"/> if this command filter handled the command; otherwise, <see langword="false"/>
 /// to call the next <see cref="IOleCommandTarget"/> in the chain.
 /// </returns>
 protected virtual bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
     return false;
 }
Beispiel #18
0
 protected virtual int QueryParameterList(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
     return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;
 }
        public virtual bool PreprocessCommand(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            _isProcessingCommand = true;
            if (!IsCompletionActive)
                return false;

            if (commandGroup == VsMenus.guidStandardCommandSet97)
            {
                if (commandId == (uint)VsCommands.Delete)
                    return false;
            }
            else if (commandGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch ((VsCommands2K)commandId)
                {
                case VsCommands2K.WORDPREV:
                case VsCommands2K.WORDPREV_EXT:
                case VsCommands2K.WORDNEXT:
                case VsCommands2K.WORDNEXT_EXT:
                case VsCommands2K.CANCEL:
                case VsCommands2K.BACKSPACE:
                case VsCommands2K.DELETE:
                case VsCommands2K.LEFT:
                case VsCommands2K.LEFT_EXT:
                case VsCommands2K.RIGHT:
                case VsCommands2K.RIGHT_EXT:
                case VsCommands2K.UP:
                case VsCommands2K.UP_EXT:
                case VsCommands2K.DOWN:
                case VsCommands2K.DOWN_EXT:
                case VsCommands2K.BOL:
                case VsCommands2K.BOL_EXT:
                case VsCommands2K.FIRSTCHAR:
                case VsCommands2K.FIRSTCHAR_EXT:
                case VsCommands2K.EOL:
                case VsCommands2K.EOL_EXT:
                case VsCommands2K.PAGEUP:
                case VsCommands2K.PAGEUP_EXT:
                case VsCommands2K.PAGEDN:
                case VsCommands2K.PAGEDN_EXT:
                case VsCommands2K.TOPLINE:
                case VsCommands2K.TOPLINE_EXT:
                case VsCommands2K.BOTTOMLINE:
                case VsCommands2K.BOTTOMLINE_EXT:
                case VsCommands2K.LEFT_EXT_COL:
                case VsCommands2K.RIGHT_EXT_COL:
                case IntellisenseCommandFilter.ECMD_INCREASEFILTER:
                case VsCommands2K.ECMD_DECREASEFILTER:
                case VsCommands2K.ECMD_LEFTCLICK:
                    return false;

                case (VsCommands2K)95:
                case VsCommands2K.BACKTAB:
                case VsCommands2K.HOME:
                case VsCommands2K.HOME_EXT:
                case VsCommands2K.END:
                case VsCommands2K.END_EXT:
                case VsCommands2K.LASTCHAR:
                case VsCommands2K.LASTCHAR_EXT:
                    break;

                case VsCommands2K.TYPECHAR:
                    char c = Convert.ToChar(Marshal.GetObjectForNativeVariant(pvaIn));
                    if (IsCommitChar(c))
                    {
                        if (CompletionSession.SelectedCompletionSet.SelectionStatus.Completion == null)
                        {
                            DismissCompletion();
                        }
                        else
                        {
                            CompletionInfo.CommitChar = c;
                            return CommitCompletion();
                        }
                    }

                    return false;

                case VsCommands2K.RETURN:
                    CompletionInfo.CommitChar = '\n';
                    return CommitCompletion();

                case VsCommands2K.TAB:
                case VsCommands2K.OPENLINEABOVE:
                    var selectionStatus = CompletionSession.SelectedCompletionSet.SelectionStatus;
                    CompletionSession.SelectedCompletionSet.SelectionStatus = new CompletionSelectionStatus(selectionStatus.Completion, true, selectionStatus.IsUnique);
                    CompletionInfo.CommitChar = (VsCommands2K)commandId == VsCommands2K.TAB ? (char?)'\t' : null;
                    return CommitCompletion();

                case VsCommands2K.ToggleConsumeFirstCompletionMode:
                    return false;
                }
            }

            return false;
        }
Beispiel #20
0
 /// <summary>
 /// This method supports specialized handling in response to commands that are successfully handled by another command target.
 /// </summary>
 /// <remarks>
 /// This method is only called if <see cref="HandlePreExec"/> for the current instance returned <see langword="false"/> and
 /// the next command target in the chain returned a value indicating the command execution succeeded.
 ///
 /// <para>
 /// The default implementation is empty.
 /// </para>
 /// </remarks>
 /// <param name="commandGroup">The command group.</param>
 /// <param name="commandId">The command ID.</param>
 /// <param name="executionOptions">The OLE command execution options.</param>
 /// <param name="pvaIn">An optional pointer to the command argument(s). The semantics of this parameter are specific to a particular command.</param>
 /// <param name="pvaOut">An optional pointer to the command result(s). The semantics of this parameter are specific to a particular command.</param>
 protected virtual void HandlePostExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
 }
        /// <summary>
        /// This is overridden to handle command execution for the node
        /// </summary>
        /// <param name="cmdGroup">Unique identifier of the command group</param>
        /// <param name="cmd">The command to be executed.</param>
        /// <param name="nCmdexecopt">Values describe how the object should
        /// execute the command.</param>
        /// <param name="pvaIn">Pointer to a <c>VARIANTARG</c> structure
        /// containing input arguments. Can be NULL</param>
        /// <param name="pvaOut"><c>VARIANTARG</c> structure to receive command
        /// output.  It can be null.</param>
        /// <returns>If the method succeeds, it returns <c>S_OK</c>. If it
        /// fails, it returns an error code.</returns>
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn,
          IntPtr pvaOut)
		{
            if(cmdGroup == GuidList.guidSandcastleBuilderPackageCmdSet && (int)cmd == PkgCmdIDList.AddDocSource)
            {
                this.AddDocumentationSources();
                return VSConstants.S_OK;
            }

			return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
		}
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(GitDiffMarginCommand).GUID)
            {
                EditorDiffMarginViewModel viewModel     = null;
                EditorDiffViewModel       diffViewModel = null;
                if (TryGetMarginViewModel(out viewModel))
                {
                    diffViewModel = viewModel.DiffViewModels.OfType <EditorDiffViewModel>().FirstOrDefault(i => i.ShowPopup);
                }

                switch ((GitDiffMarginCommand)commandId)
                {
                case GitDiffMarginCommand.ShowPopup:
                {
                    diffViewModel = GetCurrentDiffViewModel(viewModel);

                    if (diffViewModel != null)
                    {
                        diffViewModel.ShowPopup = true;
                        return(true);
                    }

                    return(false);
                }

                case GitDiffMarginCommand.PreviousChange:
                case GitDiffMarginCommand.NextChange:
                {
                    if (viewModel == null)
                    {
                        return(false);
                    }

                    RelayCommand <DiffViewModel> command = (GitDiffMarginCommand)commandId == GitDiffMarginCommand.NextChange ? viewModel.NextChangeCommand : viewModel.PreviousChangeCommand;

                    // First look for a diff already showing a popup
                    if (diffViewModel != null)
                    {
                        command.Execute(diffViewModel);
                        return(true);
                    }

                    diffViewModel = GetDiffViewModelToMoveTo(commandId, viewModel);

                    if (diffViewModel == null)
                    {
                        return(false);
                    }

                    viewModel.MoveToChange(diffViewModel, 0);
                    return(true);
                }

                case GitDiffMarginCommand.RollbackChange:
                case GitDiffMarginCommand.CopyOldText:
                {
                    if (diffViewModel == null)
                    {
                        return(false);
                    }

                    ICommand command = (GitDiffMarginCommand)commandId == GitDiffMarginCommand.RollbackChange ? diffViewModel.RollbackCommand : diffViewModel.CopyOldTextCommand;
                    command.Execute(diffViewModel);
                    return(true);
                }

                case GitDiffMarginCommand.ShowDiff:
                {
                    if (diffViewModel == null)
                    {
                        return(false);
                    }

                    ICommand command = diffViewModel.ShowDifferenceCommand;
                    command.Execute(diffViewModel);
                    return(true);
                }

                case GitDiffMarginCommand.GitDiffToolbar:
                case GitDiffMarginCommand.GitDiffToolbarGroup:
                    // these aren't actually commands, but IDs of the command bars and groups
                    break;

                default:
                    break;
                }
            }

            return(false);
        }
Beispiel #23
0
 public override void Invoke(object inArg, System.IntPtr outArg, Microsoft.VisualStudio.OLE.Interop.OLECMDEXECOPT options)
 {
     this.Invoke();
 }
Beispiel #24
0
 bool ITvlIntellisenseController.PreprocessCommand(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
     throw new NotImplementedException();
 }
        /// <summary>
        /// This is overridden to handle command execution for the node
        /// </summary>
        /// <param name="cmdGroup">Unique identifier of the command group</param>
        /// <param name="cmd">The command to be executed.</param>
        /// <param name="nCmdexecopt">Values describe how the object should
        /// execute the command.</param>
        /// <param name="pvaIn">Pointer to a <c>VARIANTARG</c> structure
        /// containing input arguments. Can be NULL</param>
        /// <param name="pvaOut"><c>VARIANTARG</c> structure to receive command
        /// output.  It can be null.</param>
        /// <returns>If the method succeeds, it returns <c>S_OK</c>. If it
        /// fails, it returns an error code.</returns>
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn,
          IntPtr pvaOut)
		{
            // Open the Project Properties window when double-clicked or Properties is selected
            if((cmdGroup == VsMenus.guidStandardCommandSet97 && (VsCommands)cmd == VsCommands.PropSheetOrProperties) ||
              (cmdGroup == VsMenus.guidVSUISet && (WindowCommandIds)cmd == WindowCommandIds.UIHWCMDID_DoubleClick))
            {
                IntPtr ip = (IntPtr)(-1);
                IVsWindowFrame frame = null;

                ((IVsProject2)this.ProjectManager).ReopenItem(VSConstants.VSITEMID_ROOT,
                    VSConstants.GUID_ProjectDesignerEditor, null, Guid.Empty, ip, out frame);

                return VSConstants.S_OK;
            }

            return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
		}
Beispiel #26
0
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if(this.ProjectManager == null || this.ProjectManager.IsClosed)
            {
                return (int)OleConstants.OLECMDERR_E_NOTSUPPORTED;
            }

            // Exec on special filenode commands
            if(cmdGroup == VsMenus.guidStandardCommandSet97)
            {
                IVsWindowFrame windowFrame = null;

                switch((VsCommands)cmd)
                {
                    case VsCommands.ViewCode:
                        return ((FileDocumentManager)this.GetDocumentManager()).Open(false, false, VSConstants.LOGVIEWID_Code, out windowFrame, WindowFrameShowAction.Show);

                    case VsCommands.ViewForm:
                        return ((FileDocumentManager)this.GetDocumentManager()).Open(false, false, VSConstants.LOGVIEWID_Designer, out windowFrame, WindowFrameShowAction.Show);

                    case VsCommands.Open:
                        return ((FileDocumentManager)this.GetDocumentManager()).Open(false, false, WindowFrameShowAction.Show);

                    case VsCommands.OpenWith:
                        return ((FileDocumentManager)this.GetDocumentManager()).Open(false, true, VSConstants.LOGVIEWID_UserChooseView, out windowFrame, WindowFrameShowAction.Show);
                }
            }

            // Exec on special filenode commands
            if(cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch((VsCommands2K)cmd)
                {
                    case VsCommands2K.INCLUDEINPROJECT:
                        return ((IProjectSourceNode)this).IncludeInProject();

                    case VsCommands2K.EXCLUDEFROMPROJECT:
                        return ((IProjectSourceNode)this).ExcludeFromProject();

                    case VsCommands2K.RUNCUSTOMTOOL:
                        {
                            try
                            {
                                this.RunGenerator();
                                return VSConstants.S_OK;
                            }
                            catch(Exception e)
                            {
                                Trace.WriteLine("Running Custom Tool failed : " + e.Message);
                                throw;
                            }
                        }
                }
            }

            return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
        }
 bool ITvlIntellisenseController.PreprocessCommand(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
     throw new NotImplementedException();
 }
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(GitDiffMarginCommand).GUID)
            {
                EditorDiffMarginViewModel viewModel = null;
                EditorDiffViewModel diffViewModel = null;
                if (TryGetMarginViewModel(out viewModel))
                    diffViewModel = viewModel.DiffViewModels.OfType<EditorDiffViewModel>().FirstOrDefault(i => i.ShowPopup);

                switch ((GitDiffMarginCommand)commandId)
                {
                case GitDiffMarginCommand.PreviousChange:
                case GitDiffMarginCommand.NextChange:
                    {
                        if (viewModel == null)
                            return false;

                        RelayCommand<DiffViewModel> command = (GitDiffMarginCommand)commandId == GitDiffMarginCommand.NextChange ? viewModel.NextChangeCommand : viewModel.PreviousChangeCommand;

                        // First look for a diff already showing a popup
                        if (diffViewModel != null)
                        {
                            command.Execute(diffViewModel);
                            return true;
                        }

                        diffViewModel = GetDiffViewModelToMoveTo(commandId, viewModel);

                        if (diffViewModel == null) return false;

                        viewModel.MoveToChange(diffViewModel, 0);
                        return true;
                    }

                case GitDiffMarginCommand.RollbackChange:
                case GitDiffMarginCommand.CopyOldText:
                    {
                        if (diffViewModel == null)
                            return false;

                        //ICommand command = (GitDiffMarginCommand)commandId == GitDiffMarginCommand.RollbackChange ? diffViewModel.RollbackCommand : diffViewModel.CopyOldTextCommand;
                        //command.Execute(diffViewModel);
                        return true;
                    }

                case GitDiffMarginCommand.ShowDiff:
                    {
                        if (diffViewModel == null)
                            return false;

                        ICommand command = diffViewModel.ShowDifferenceCommand;
                        command.Execute(diffViewModel);
                        return true;
                    }

                case GitDiffMarginCommand.ToggleCompareToIndex:
                    if (diffViewModel != null)
                    {
                        // The margin will not update if the pop-up is visible
                        diffViewModel.ShowPopup = false;
                    }

                    ToggleCompareToIndex();
                    return true;

                case GitDiffMarginCommand.CompareToIndex:
                    if (diffViewModel != null)
                    {
                        // The margin will not update if the pop-up is visible
                        diffViewModel.ShowPopup = false;
                    }

                    CompareToIndex();
                    return true;

                case GitDiffMarginCommand.CompareToHead:
                    if (diffViewModel != null)
                    {
                        // The margin will not update if the pop-up is visible
                        diffViewModel.ShowPopup = false;
                    }

                    CompareToHead();
                    return true;

                case GitDiffMarginCommand.GitDiffToolbar:
                case GitDiffMarginCommand.GitDiffToolbarGroup:
                    // these aren't actually commands, but IDs of the command bars and groups
                    break;

                default:
                    break;
                }
            }

            return false;
        }
Beispiel #29
0
        /// <inheritdoc/>
        /// <remarks>
        /// This method handles execution of the <see cref="VsCommands2K.COMMENT_BLOCK"/>
        /// and <see cref="VsCommands2K.UNCOMMENT_BLOCK"/> commands by calling
        /// <see cref="CommentSelection"/> and <see cref="UncommentSelection"/> (respectively)
        /// and returning <see langword="true"/>.
        /// </remarks>
        protected override bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (commandGroup == typeof(VsCommands2K).GUID)
            {
                VsCommands2K cmd = (VsCommands2K)commandId;
                switch (cmd)
                {
                case VsCommands2K.COMMENT_BLOCK:
                    this.CommentSelection();
                    return true;

                case VsCommands2K.UNCOMMENT_BLOCK:
                    this.UncommentSelection();
                    return true;
                }
            }

            return base.HandlePreExec(ref commandGroup, commandId, executionOptions, pvaIn, pvaOut);
        }
        public virtual bool PreprocessCommand(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
        {
            _isProcessingCommand = true;
            if (!IsCompletionActive)
            {
                return(false);
            }

            if (commandGroup == VsMenus.guidStandardCommandSet97)
            {
                if (commandId == (uint)VsCommands.Delete)
                {
                    return(false);
                }
            }
            else if (commandGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch ((VsCommands2K)commandId)
                {
                case VsCommands2K.WORDPREV:
                case VsCommands2K.WORDPREV_EXT:
                case VsCommands2K.WORDNEXT:
                case VsCommands2K.WORDNEXT_EXT:
                case VsCommands2K.CANCEL:
                case VsCommands2K.BACKSPACE:
                case VsCommands2K.DELETE:
                case VsCommands2K.LEFT:
                case VsCommands2K.LEFT_EXT:
                case VsCommands2K.RIGHT:
                case VsCommands2K.RIGHT_EXT:
                case VsCommands2K.UP:
                case VsCommands2K.UP_EXT:
                case VsCommands2K.DOWN:
                case VsCommands2K.DOWN_EXT:
                case VsCommands2K.BOL:
                case VsCommands2K.BOL_EXT:
                case VsCommands2K.FIRSTCHAR:
                case VsCommands2K.FIRSTCHAR_EXT:
                case VsCommands2K.EOL:
                case VsCommands2K.EOL_EXT:
                case VsCommands2K.PAGEUP:
                case VsCommands2K.PAGEUP_EXT:
                case VsCommands2K.PAGEDN:
                case VsCommands2K.PAGEDN_EXT:
                case VsCommands2K.TOPLINE:
                case VsCommands2K.TOPLINE_EXT:
                case VsCommands2K.BOTTOMLINE:
                case VsCommands2K.BOTTOMLINE_EXT:
                case VsCommands2K.LEFT_EXT_COL:
                case VsCommands2K.RIGHT_EXT_COL:
                case IntellisenseCommandFilter.ECMD_INCREASEFILTER:
                case VsCommands2K.ECMD_DECREASEFILTER:
                case VsCommands2K.ECMD_LEFTCLICK:
                    return(false);

                case (VsCommands2K)95:
                case VsCommands2K.BACKTAB:
                case VsCommands2K.HOME:
                case VsCommands2K.HOME_EXT:
                case VsCommands2K.END:
                case VsCommands2K.END_EXT:
                case VsCommands2K.LASTCHAR:
                case VsCommands2K.LASTCHAR_EXT:
                    break;

                case VsCommands2K.TYPECHAR:
                    char c = Convert.ToChar(Marshal.GetObjectForNativeVariant(pvaIn));
                    if (IsCommitChar(c))
                    {
                        if (CompletionSession.SelectedCompletionSet.SelectionStatus.Completion == null)
                        {
                            DismissCompletion();
                        }
                        else
                        {
                            CompletionInfo.CommitChar = c;
                            return(CommitCompletion());
                        }
                    }

                    return(false);

                case VsCommands2K.RETURN:
                    CompletionInfo.CommitChar = '\n';
                    return(CommitCompletion());

                case VsCommands2K.TAB:
                case VsCommands2K.OPENLINEABOVE:
                    var selectionStatus = CompletionSession.SelectedCompletionSet.SelectionStatus;
                    CompletionSession.SelectedCompletionSet.SelectionStatus = new CompletionSelectionStatus(selectionStatus.Completion, true, selectionStatus.IsUnique);
                    CompletionInfo.CommitChar = (VsCommands2K)commandId == VsCommands2K.TAB ? (char?)'\t' : null;
                    return(CommitCompletion());

                case VsCommands2K.ToggleConsumeFirstCompletionMode:
                    return(false);
                }
            }

            return(false);
        }
Beispiel #31
0
 /// <summary>
 /// The expected behavior of this method is not clear.
 /// </summary>
 /// <remarks>
 /// <para>The default implementation returns <see cref="OleConstants.OLECMDERR_E_NOTSUPPORTED"/> for all
 /// commands.</para>
 /// </remarks>
 /// <param name="commandGroup">The command group.</param>
 /// <param name="commandId">The command ID.</param>
 /// <param name="executionOptions">The OLE command execution options.</param>
 /// <param name="pvaIn">An optional pointer to the command argument(s). The semantics of this parameter are
 /// specific to a particular command.</param>
 /// <param name="pvaOut">An optional pointer to the command result(s). The semantics of this parameter are
 /// specific to a particular command.</param>
 /// <returns>The expected behavior of this method is not clear.</returns>
 protected virtual int ShowHelp(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
     return((int)OleConstants.OLECMDERR_E_NOTSUPPORTED);
 }
Beispiel #32
0
 /// <summary>
 /// This method supports the implementation for commands which are directly implemented by this command filter.
 /// </summary>
 /// <remarks>
 /// The default implementation returns <see langword="false"/> for all commands.
 /// </remarks>
 /// <param name="commandGroup">The command group.</param>
 /// <param name="commandId">The command ID.</param>
 /// <param name="executionOptions">The OLE command execution options.</param>
 /// <param name="pvaIn">An optional pointer to the command argument(s). The semantics of this parameter are specific to a particular command.</param>
 /// <param name="pvaOut">An optional pointer to the command result(s). The semantics of this parameter are specific to a particular command.</param>
 /// <returns>
 /// <see langword="true"/> if this command filter handled the command; otherwise, <see langword="false"/>
 /// to call the next <see cref="IOleCommandTarget"/> in the chain.
 /// </returns>
 protected virtual bool HandlePreExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
     return(false);
 }
        /// <inheritdoc />
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn,
          IntPtr pvaOut)
        {
            if(cmdGroup == GuidList.guidSandcastleBuilderPackageCmdSet)
                switch(cmd)
                {
                    case PkgCmdIDList.OpenInStandaloneGUI:
                        this.OpenInStandaloneGui();
                        return VSConstants.S_OK;

                    case PkgCmdIDList.ViewBuildLog:
                        this.OpenBuildLogToolWindow(true);
                        return VSConstants.S_OK;

                    default:
                        break;
                }

            return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
        }
Beispiel #34
0
 /// <summary>
 /// This method supports specialized handling in response to commands that are successfully handled by another command target.
 /// </summary>
 /// <remarks>
 /// This method is only called if <see cref="HandlePreExec"/> for the current instance returned <see langword="false"/> and
 /// the next command target in the chain returned a value indicating the command execution succeeded.
 ///
 /// <para>
 /// The default implementation is empty.
 /// </para>
 /// </remarks>
 /// <param name="commandGroup">The command group.</param>
 /// <param name="commandId">The command ID.</param>
 /// <param name="executionOptions">The OLE command execution options.</param>
 /// <param name="pvaIn">An optional pointer to the command argument(s). The semantics of this parameter are specific to a particular command.</param>
 /// <param name="pvaOut">An optional pointer to the command result(s). The semantics of this parameter are specific to a particular command.</param>
 protected virtual void HandlePostExec(ref Guid commandGroup, uint commandId, OLECMDEXECOPT executionOptions, IntPtr pvaIn, IntPtr pvaOut)
 {
 }
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if(cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch((VsCommands2K)cmd)
                {
                    case VsCommands2K.ADDREFERENCE:
                        return this.ProjectManager.AddProjectReference();
                    case VsCommands2K.ADDWEBREFERENCE:
                        return this.ProjectManager.AddWebReference();
                }
            }

            return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
        }
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if (cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                switch ((VsCommands2K)cmd)
                {
                case VsCommands2K.INCLUDEINPROJECT:
                    return ((IProjectSourceNode)this).IncludeInProject();

                case VsCommands2K.EXCLUDEFROMPROJECT:
                    return ((IProjectSourceNode)this).ExcludeFromProject();

                case ProjectFileConstants.CommandExploreFolderInWindows:
                    ProjectNode.ExploreFolderInWindows(GetMKDocument());
                    return VSConstants.S_OK;
                }
            }

            return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
        }
        protected override int ExecCommandOnNode(Guid cmdGroup, uint cmd, OLECMDEXECOPT nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
        {
            if(cmdGroup == VsMenus.guidStandardCommandSet2K)
            {
                if((VsCommands2K)cmd == VsCommands2K.QUICKOBJECTSEARCH)
                {
                    return this.ShowObjectBrowser();
                }
            }

            return base.ExecCommandOnNode(cmdGroup, cmd, nCmdexecopt, pvaIn, pvaOut);
        }