private void CreateInfoBar(IVsInfoBarUIFactory factory, IVsWindowFrame frame, string message, ErrorReportingUI[] items)
        {
            if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID7.VSFPROPID_InfoBarHost, out var unknown)))
            {
                return;
            }

            var textSpans = new List<IVsInfoBarTextSpan>()
            {
                new InfoBarTextSpan(message)
            };

            // create action item list
            var actionItems = new List<IVsInfoBarActionItem>();

            foreach (var item in items)
            {
                switch (item.Kind)
                {
                    case ErrorReportingUI.UIKind.Button:
                        actionItems.Add(new InfoBarButton(item.Title));
                        break;
                    case ErrorReportingUI.UIKind.HyperLink:
                        actionItems.Add(new InfoBarHyperlink(item.Title));
                        break;
                    case ErrorReportingUI.UIKind.Close:
                        break;
                    default:
                        throw ExceptionUtilities.UnexpectedValue(item.Kind);
                }
            }

            var infoBarModel = new InfoBarModel(
                textSpans,
                actionItems.ToArray(),
                KnownMonikers.StatusInformation,
                isCloseButtonVisible: true);
            if (!TryCreateInfoBarUI(factory, infoBarModel, out var infoBarUI))
            {
                return;
            }

            uint? infoBarCookie = null;
            var eventSink = new InfoBarEvents(items, () =>
            {
                // run given onClose action if there is one.
                items.FirstOrDefault(i => i.Kind == ErrorReportingUI.UIKind.Close).Action?.Invoke();

                if (infoBarCookie.HasValue)
                {
                    infoBarUI.Unadvise(infoBarCookie.Value);
                }
            });
            infoBarUI.Advise(eventSink, out var cookie);
            infoBarCookie = cookie;

            var host = (IVsInfoBarHost)unknown;
            host.AddInfoBar(infoBarUI);
        }
        public void InitializeEditor(VSEditorControl form, IVsUIHierarchy hier, IVsWindowFrame frame, uint docid)
        {
            VSDocumentFormPane pane = null;
            object value;
            if (ErrorHandler.Succeeded(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out value)))
            {
                pane = value as VSDocumentFormPane;
            }

            if (pane != null)
                ((IVSEditorControlInit)form).InitializedForm(hier, docid, frame, pane.Host);
        }
        public PartViewHelper(PackageEditorPane editor, IVsWindowFrame windowFrame)
        {
            this.windowFrame = windowFrame;
            this.editor = editor;
            justOpened = true;

            object data;
            ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out data));
            textLines = (IVsTextLines)data;

            AdviseTextLinesEvents(true);

        }
        private void CreateInfoBar(IVsInfoBarUIFactory factory, IVsWindowFrame frame, string title, Action onClose, Action onEnableClicked = null, Action onEnableAndIgnoreClicked = null)
        {
            object unknown;
            if (frame.GetProperty((int)__VSFPROPID7.VSFPROPID_InfoBarHost, out unknown) == VSConstants.S_OK)
            {
                var textSpans = new List<IVsInfoBarTextSpan>()
                {
                    new InfoBarTextSpan(title)
                };

                // create action item list
                var actionItems = new List<IVsInfoBarActionItem>();
                if (onEnableClicked != null)
                {
                    actionItems.Add(s_enableItem);
                }

                if (onEnableAndIgnoreClicked != null)
                {
                    actionItems.Add(s_enableAndIgnoreItem);
                }

                var infoBarModel = new InfoBarModel(
                    textSpans,
                    actionItems.ToArray(),
                    KnownMonikers.StatusInformation,
                    isCloseButtonVisible: true);

                IVsInfoBarUIElement infoBarUI;
                if (TryCreateInfoBarUI(factory, infoBarModel, out infoBarUI))
                {
                    uint? infoBarCookie = null;
                    InfoBarEvents eventSink = new InfoBarEvents(() =>
                    {
                        onClose();
                        if (infoBarCookie.HasValue)
                        {
                            infoBarUI.Unadvise(infoBarCookie.Value);
                        }
                    }, onEnableClicked, onEnableAndIgnoreClicked);

                    uint cookie;
                    infoBarUI.Advise(eventSink, out cookie);
                    infoBarCookie = cookie;

                    IVsInfoBarHost host = (IVsInfoBarHost)unknown;
                    host.AddInfoBar(infoBarUI);
                }
            }
        }
        private static bool GetPhysicalPathFromFrame(IVsWindowFrame frame, out string frameFilePath)
        {
            object propertyValue;

            int hr = frame.GetProperty((int)__VSFPROPID.VSFPROPID_pszMkDocument, out propertyValue);
            if (hr == VSConstants.S_OK && propertyValue != null)
            {
                frameFilePath = propertyValue.ToString();
                return true;
            }

            frameFilePath = null;
            return false;
        }
        // Gets the package manager control hosted in the window frame.
        public static Control GetDeployConfigurationControl(IVsWindowFrame windowFrame)
        {
            object property;
            var hr = windowFrame.GetProperty(
                (int)__VSFPROPID.VSFPROPID_DocView,
                out property);

            var windowPane = property as WindowPane;
            if (windowPane == null)
            {
                return null;
            }

            var packageManagerControl = windowPane.Content as Control;
            return packageManagerControl;
        }
        public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
        {
            var currentDoc = CurrentDoc;

            if (CookieDocumentMap.ContainsKey(docCookie))
            {
                CurrentDoc = CookieDocumentMap[docCookie];
                MonitorSelection.SetCmdUIContext(MarkdownModeUIContextCookie, 1);
                CommandsEnabled = true;
            }
            else
            {
                string fullname = GetDocFullname(docCookie);
                if (IsUDNDocument(fullname))
                {
                    object codeWindow;
                    pFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out codeWindow);

                    IVsTextView view;
                    (codeWindow as IVsCodeWindow).GetPrimaryView(out view);

                    var wpfView = EditorAdaptersFactoryService.GetWpfTextView(view);

                    var docView = new UDNDocView(fullname, wpfView, pFrame, package, UIShell);
                    CookieDocumentMap[docCookie] = docView;
                    docView.ParsingResultsCache.AfterParsingEvent += PassResultsToChangedEvent;

                    CurrentDoc = CookieDocumentMap[docCookie];

                    MonitorSelection.SetCmdUIContext(MarkdownModeUIContextCookie, 1);
                    CommandsEnabled = true;
                }
                else
                {
                    MonitorSelection.SetCmdUIContext(MarkdownModeUIContextCookie, 0);
                    CommandsEnabled = false;
                }
            }

            if (currentDoc != CurrentDoc)
            {
                CurrentUDNDocView.ParsingResultsCache.AsyncReparseIfDirty();
            }

            return VSConstants.S_OK;
        }
        private static IVsTextView GetActiveView(IVsWindowFrame windowFrame)
        {
            if (windowFrame == null)
                throw new ArgumentNullException("windowFrame");

            object pvar;
            ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out pvar));

            var textView = pvar as IVsTextView;
            if (textView == null)
            {
                var codeWin = pvar as IVsCodeWindow;
                if (codeWin != null)
                    ErrorHandler.ThrowOnFailure(codeWin.GetLastActiveView(out textView));
            }

            return textView;
        }
        private void CreateInfoBar(string name, Action onEnableClicked, Action onEnableAndIgnoreClicked, Action onClose, IVsWindowFrame frame, IVsInfoBarUIFactory factory)
        {
            object unknown;
            if (frame.GetProperty((int)__VSFPROPID7.VSFPROPID_InfoBarHost, out unknown) == VSConstants.S_OK)
            {
                var textSpans = new List<IVsInfoBarTextSpan>()
                {
                    new InfoBarTextSpan(string.Format(ServicesVSResources.CodefixOrRefactoringEncounteredError, name)),
                };

                var infoBarModel = new InfoBarModel(
                    textSpans,
                    new IVsInfoBarActionItem[]
                        {
                            s_enableItem,
                            s_enableAndIgnoreItem
                        },
                    KnownMonikers.StatusInformation,
                    isCloseButtonVisible: true);

                IVsInfoBarUIElement infoBarUI;
                if (TryCreateInfoBarUI(factory, infoBarModel, out infoBarUI))
                {
                    uint? infoBarCookie = null;
                    InfoBarEvents eventSink = new InfoBarEvents(onEnableClicked, onEnableAndIgnoreClicked, () =>
                    {
                        onClose();
                        if (infoBarCookie.HasValue)
                        {
                            infoBarUI.Unadvise(infoBarCookie.Value);
                        }
                    });

                    uint cookie;
                    infoBarUI.Advise(eventSink, out cookie);
                    infoBarCookie = cookie;

                    IVsInfoBarHost host = (IVsInfoBarHost)unknown;
                    host.AddInfoBar(infoBarUI);
                }
            }
        }
        private static IVsTextView GetVsTextView(IVsWindowFrame windowFrame)
        {
            if (windowFrame == null)
            throw new ArgumentNullException("windowFrame");

              object obj;
              if (ErrorHandler.Failed(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out obj)))
            return null;

              var vsTextView = obj as IVsTextView;
              if (vsTextView != null)
            return vsTextView;

              var vsCodeWindow = obj as IVsCodeWindow;
              if (vsCodeWindow == null)
            return null;

              if (ErrorHandler.Failed(vsCodeWindow.GetPrimaryView(out vsTextView)))
            return null;

              return vsTextView;
        }
        private IInteractiveWindowVisualComponent GetComponent(IVsWindowFrame frame) {
            if (frame == null) {
                return null;
            }

            Guid property;
            if (ErrorHandler.Failed(frame.GetGuidProperty((int)__VSFPROPID.VSFPROPID_GuidPersistenceSlot, out property)) || property != RGuidList.ReplInteractiveWindowProviderGuid) {
                return null;
            }

            object docView;
            if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out docView))) {
                return null;
            }

            var interactiveWindow = (docView as IVsInteractiveWindow)?.InteractiveWindow;
            if (interactiveWindow == null) {
                return null;
            }

            IInteractiveWindowVisualComponent component;
            return interactiveWindow.Properties.TryGetProperty(typeof(IInteractiveWindowVisualComponent), out component) ? component : null;
        }
        /// <summary>
        /// Gets if the given window frame is a document or a tool frame.
        /// </summary>
        /// <param name="window">Window frame.</param>
        /// <returns>True for document frame. False for tool frame.</returns>
        public static bool IsDocumentFrame(IVsWindowFrame window)
        {
            object pvar;
            window.GetProperty((int)__VSFPROPID.VSFPROPID_Type, out pvar);

            if ((int)pvar == 1)
                return true;
            else
                return false;
        }
        /// <summary>
        /// Gets the editor view helper from a window frame.
        /// </summary>
        /// <param name="window">Window frame.</param>
        /// <returns>Editor view helper is it is a ModelDocView. Null otherwise.</returns>
        public static ModelDocView GetEditorViewHelper(IVsWindowFrame window)
        {
            object view;
            window.GetProperty((int)__VSFPROPID.VSFPROPID_ViewHelper, out view);

            if (view is ModelDocView)
                return (ModelDocView)view;
            return null;
        }
Exemple #14
0
        public static void OpenItem(ServiceProvider site, bool newFile, bool openWith, ref Guid logicalView,
                                    IntPtr punkDocDataExisting, IVsHierarchy pHierarchy,
                                    uint hierarchyId, out IVsWindowFrame windowFrame)
        {
            windowFrame = null;
            IntPtr docData = punkDocDataExisting;

            try {
                uint itemid = hierarchyId;

                object pvar;
                pHierarchy.GetProperty(hierarchyId, (int)__VSHPROPID.VSHPROPID_Caption, out pvar);
                string caption = (string)pvar;

                string fullPath = null;

                if (punkDocDataExisting != IntPtr.Zero)
                {
                    try  {
                        // if interface is not supported, return null
                        IPersistFileFormat pff = (IPersistFileFormat)Marshal.GetTypedObjectForIUnknown(punkDocDataExisting, typeof(IPersistFileFormat));
                        uint format;
                        pff.GetCurFile(out fullPath, out format);
                    }
                    catch  {
                    };
                }
                if (fullPath == null)
                {
                    string dir;
                    pHierarchy.GetProperty((uint)VsConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectDir, out pvar);
                    dir = (string)pvar;
                    pHierarchy.GetProperty(hierarchyId, (int)__VSHPROPID.VSHPROPID_SaveName, out pvar);
                    fullPath = dir != null?Path.Combine(dir, (string)pvar) : (string)pvar;
                }

                IVsUIHierarchy pRootHierarchy = null;
                pHierarchy.GetProperty((uint)VsConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_Root, out pvar);
                IntPtr ptr;
                if (pvar == null)
                {
                    pRootHierarchy = (IVsUIHierarchy)pHierarchy;
                }
                else
                {
                    ptr            = (IntPtr)pvar;
                    pRootHierarchy = (IVsUIHierarchy)Marshal.GetTypedObjectForIUnknown(ptr, typeof(IVsUIHierarchy));
                    Marshal.Release(ptr);
                }
                IVsUIHierarchy pVsUIHierarchy = pRootHierarchy;

                IVsUIShellOpenDocument doc = (IVsUIShellOpenDocument)site.QueryService(VsConstants.SID_VsUIShellOpenDocument, typeof(IVsUIShellOpenDocument));
                const uint             OSE_ChooseBestStdEditor = 0x20000000;
                const uint             OSE_UseOpenWithDialog   = 0x10000000;
                const uint             OSE_OpenAsNewFile       = 0x40000000;

                if (openWith)
                {
                    doc.OpenStandardEditor(OSE_UseOpenWithDialog, fullPath, ref logicalView, caption,
                                           pVsUIHierarchy, itemid, docData, site.Unwrap(), out windowFrame);
                }
                else
                {
                    // First we see if someone else has opened the requested view of the file and if so,
                    // simply activate that view.
                    IVsRunningDocumentTable pRDT = (IVsRunningDocumentTable)site.QueryService(VsConstants.SID_SVsRunningDocumentTable, typeof(IVsRunningDocumentTable));
                    if (pRDT != null)
                    {
                        uint         docCookie;
                        IVsHierarchy ppIVsHierarchy;
                        pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock,
                                                 fullPath, out ppIVsHierarchy, out itemid, out docData, out docCookie);
                        if (ppIVsHierarchy != null && docCookie != VsConstants.VSDOCCOOKIE_NIL &&
                            pHierarchy != ppIVsHierarchy && pVsUIHierarchy != ppIVsHierarchy)
                        {
                            // not opened by us, so call IsDocumentOpen with the right IVsUIHierarchy so we avoid the
                            // annoying "This document is opened by another project" message prompt.
                            pVsUIHierarchy = (IVsUIHierarchy)ppIVsHierarchy;
                            itemid         = (uint)VsConstants.VSITEMID_SELECTION;
                        }
                        ppIVsHierarchy = null;
                    }
                    IVsUIHierarchy ppHierOpen;
                    uint           pitemidOpen;
                    int            pfOpen;
                    doc.IsDocumentOpen(pVsUIHierarchy, itemid, fullPath,
                                       ref logicalView, (uint)__VSIDOFLAGS.IDO_ActivateIfOpen,
                                       out ppHierOpen, out pitemidOpen, out windowFrame, out pfOpen);
                    if (pfOpen != 1)
                    {
                        uint openFlags = OSE_ChooseBestStdEditor;
                        if (newFile)
                        {
                            openFlags |= OSE_OpenAsNewFile;
                        }

                        //NOTE: we MUST pass the IVsProject in pVsUIHierarchy and the itemid
                        // of the node being opened, otherwise the debugger doesn't work.
                        doc.OpenStandardEditor(openFlags, fullPath, ref logicalView, caption,
                                               pRootHierarchy, hierarchyId, docData,
                                               site.Unwrap(), out windowFrame);
                        if (windowFrame != null)
                        {
                            if (newFile)
                            {
                                object var;
                                windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out var);
                                IVsPersistDocData ppd = (IVsPersistDocData)var;
                                ppd.SetUntitledDocPath(fullPath);
                            }
                        }
                    }
                }
                if (windowFrame != null)
                {
                    windowFrame.Show();
                }
            } catch (COMException e) {
                if ((uint)e.ErrorCode != (uint)OleErrors.OLE_E_PROMPTSAVECANCELLED)
                {
#if DEBUG
                    MessageBox.Show(e.Message);
#endif
                }
            } catch (Exception e) {
#if DEBUG
                MessageBox.Show(e.Message);
#endif
            }
            if (docData != punkDocDataExisting)
            {
                Marshal.Release(docData);
            }
        }
Exemple #15
0
        private static IVsTextView GetVsTextView(IVsWindowFrame windowFrame)
        {
            Validate.IsNotNull(windowFrame, nameof(windowFrame));

            object docView;
            int hresult = windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out docView);

            if (ErrorHandler.Failed(hresult))
            {
                return null;
            }

            IVsTextView viewAdapter = docView as IVsTextView;

            if (viewAdapter != null)
            {
                return viewAdapter;
            }

            IVsCodeWindow codeWindow = docView as IVsCodeWindow;

            if (codeWindow != null)
            {
                IVsTextView codeView;

                if (ErrorHandler.Succeeded(codeWindow.GetPrimaryView(out codeView)) && codeView != null)
                {
                    return codeView;
                }
            }

            return null;
        }
Exemple #16
0
 public static bool GetIUnknownProperty(this IVsWindowFrame windowFrame, __VSFPROPID propid, out object result)
 {
     result = null;
     windowFrame?.GetProperty((int)propid, out result);
     return(result != null);
 }
Exemple #17
0
        /// <include file='doc\Hierarchy.uex' path='docs/doc[@for="HierarchyNode.OpenItem3"]/*' />
        public static void OpenItem(IServiceProvider site, bool newFile, bool openWith, uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr punkDocDataExisting, IVsHierarchy pHierarchy, uint hierarchyId, out IVsWindowFrame windowFrame)
		{
            windowFrame = null;

            IntPtr docData = punkDocDataExisting;
            Exception error = null;

            try
			{
                uint itemid = hierarchyId;
                object pvar;
                NativeMethods.ThrowOnFailure(pHierarchy.GetProperty(hierarchyId, (int)__VSHPROPID.VSHPROPID_Caption, out pvar));
                string caption = (string)pvar;
                string fullPath = null;
                if (punkDocDataExisting != IntPtr.Zero)
				{
                    fullPath = VsShell.GetFilePath(punkDocDataExisting);
                }
                if (fullPath == null)
				{
                    string dir;
                    NativeMethods.ThrowOnFailure(pHierarchy.GetProperty(NativeMethods.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ProjectDir, out pvar));
                    dir = (string)pvar;
                    NativeMethods.ThrowOnFailure(pHierarchy.GetProperty(hierarchyId, (int)__VSHPROPID.VSHPROPID_SaveName, out pvar));
                    // todo: what if the path is a URL?
                    fullPath = dir != null ? Path.Combine(dir, (string)pvar) : (string)pvar;
                }
                IVsUIHierarchy pRootHierarchy = null;
                NativeMethods.ThrowOnFailure(pHierarchy.GetProperty(NativeMethods.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_Root, out pvar));
                IntPtr ptr;
                if (pvar == null)
				{
                    pRootHierarchy = (IVsUIHierarchy)pHierarchy;
                }
				else
				{
                    ptr = (IntPtr)pvar;
                    pRootHierarchy = (IVsUIHierarchy)Marshal.GetTypedObjectForIUnknown(ptr, typeof(IVsUIHierarchy));
                    Marshal.Release(ptr);
                }

                IVsUIHierarchy pVsUIHierarchy = pRootHierarchy;

                IVsUIShellOpenDocument doc = site.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
                const uint OSE_ChooseBestStdEditor = 0x20000000;
                const uint OSE_UseOpenWithDialog = 0x10000000;
                const uint OSE_OpenAsNewFile = 0x40000000;

                if (openWith)
				{
                    IOleServiceProvider psp = site.GetService(typeof(IOleServiceProvider)) as IOleServiceProvider;
                    NativeMethods.ThrowOnFailure(doc.OpenStandardEditor(OSE_UseOpenWithDialog, fullPath, ref logicalView, caption, pVsUIHierarchy, itemid, docData, psp, out windowFrame));
                }
				else
				{
                    // First we see if someone else has opened the requested view of the file.
                    IVsRunningDocumentTable pRDT = site.GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
                    if (pRDT != null)
					{
                        uint docCookie;
                        IVsHierarchy ppIVsHierarchy;

                        NativeMethods.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, fullPath, out ppIVsHierarchy, out itemid, out docData, out docCookie));
                        if (ppIVsHierarchy != null && docCookie != (uint)ShellConstants.VSDOCCOOKIE_NIL && pHierarchy != ppIVsHierarchy && pVsUIHierarchy != ppIVsHierarchy)
						{
                            // not opened by us, so call IsDocumentOpen with the right IVsUIHierarchy so we avoid the
                            // annoying "This document is opened by another project" message prompt.
                            pVsUIHierarchy = (IVsUIHierarchy)ppIVsHierarchy;
                            itemid = (uint)NativeMethods.VSITEMID_SELECTION;
                        }

                        ppIVsHierarchy = null;
                    }

                    uint openFlags = 0;
                    if (newFile) openFlags |= OSE_OpenAsNewFile;
                    //NOTE: we MUST pass the IVsProject in pVsUIHierarchy and the itemid
                    // of the node being opened, otherwise the debugger doesn't work.
                    IOleServiceProvider psp = site.GetService(typeof(IOleServiceProvider)) as IOleServiceProvider;
                    int retryCount = 1;
                    while (retryCount > 0)
					{
                        try
						{
                            if (editorType != Guid.Empty)
							{
                                NativeMethods.ThrowOnFailure(doc.OpenSpecificEditor(editorFlags, fullPath, ref editorType, physicalView, ref logicalView, caption, pRootHierarchy, hierarchyId, docData, psp, out windowFrame));
                            }
							else
							{
                                openFlags |= OSE_ChooseBestStdEditor;
                                NativeMethods.ThrowOnFailure(doc.OpenStandardEditor(openFlags, fullPath, ref logicalView, caption, pRootHierarchy, hierarchyId, docData, psp, out windowFrame));
                            }

                            break;
                        }
						catch (Exception e)
						{
                            if (e is COMException)
							{
                                COMException ce = (COMException)e;
                                if (ce.ErrorCode == NativeMethods.OLE_E_PROMPTSAVECANCELLED)
								{
                                    break;
                                }
                            }
                            // perhaps the editor is not compatible with an existing one.                              
                            // try OpenStandardEditor.
                            if (editorType != Guid.Empty)
							{
                                editorType = Guid.Empty;
                            }
							else
							{
                                throw e;
                            }
                        }
                    }
                }

                if (windowFrame != null)
				{
                    if (newFile)
					{
                        object var;
                        NativeMethods.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out var));
                        IVsPersistDocData ppd = (IVsPersistDocData)var;
                        NativeMethods.ThrowOnFailure(ppd.SetUntitledDocPath(fullPath));
                    }
                }
                if (windowFrame != null)
                    NativeMethods.ThrowOnFailure(windowFrame.Show());
            }
			catch (Exception e)
			{
                error = e;
            }
            if (error != null)
			{
                string msg = error.Message;
                if (logicalView != Guid.Empty)
				{
                    if (editorType != Guid.Empty)
					{
                        msg = String.Format(SR.GetString(SR.EditorViewError), logicalView.ToString(), editorType.ToString()) + "\r\n" + msg;
                    }
					else
					{
                        msg = String.Format(SR.GetString(SR.StandardEditorViewError), logicalView.ToString()) + "\r\n" + msg;
                    }
                }
				else if (editorType != Guid.Empty)
				{
                    msg = String.Format(SR.GetString(SR.StandardEditorViewError), logicalView.ToString()) + "\r\n" + msg;
                }
                MessageBox.Show(msg, SR.GetString(SR.Error), MessageBoxButtons.OK, MessageBoxIcon.Error);


                if (windowFrame != null)
				{
                    try
					{
                        NativeMethods.ThrowOnFailure(windowFrame.CloseFrame(0));
                    }
					catch
					{
                    }
                    windowFrame = null;
                }
            }

            if (docData != punkDocDataExisting && docData != IntPtr.Zero)
			{
                Marshal.Release(docData);
            }
        }
Exemple #18
0
 internal static IVsTextView GetTextView(IVsWindowFrame windowFrame)
 {
   if (windowFrame != null) {
     object docView;
     windowFrame.Show();
     windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out docView);
     if (docView != null) {
       IVsTextView textView = docView as IVsTextView;
       if (textView == null) {
         IVsCodeWindow codeWindow = docView as IVsCodeWindow;
         if (codeWindow != null) {
           codeWindow.GetPrimaryView(out textView);
         }
       }
       return textView;
     }
   }
   return null;
 }
        /// <summary>
        /// Implements <see cref="IVsWindowFrameNotify3.OnShow"/>
        /// </summary>
        protected int OnShow(int fShow)
        {
            FrameVisibilityFlags flags      = myFrameVisibility;
            FrameVisibilityFlags startFlags = flags & ~(FrameVisibilityFlags.FrameVisibilityMask | FrameVisibilityFlags.PersistentFlagsMask);

            myFrameVisibility &= FrameVisibilityFlags.FrameVisibilityMask | FrameVisibilityFlags.PersistentFlagsMask;
            switch ((__FRAMESHOW)fShow)
            {
            case (__FRAMESHOW)__FRAMESHOW2.FRAMESHOW_BeforeWinHidden:
                myFrameVisibility |= FrameVisibilityFlags.PendingHiddenMeansClosed;
                break;

            case __FRAMESHOW.FRAMESHOW_WinMinimized:
            case __FRAMESHOW.FRAMESHOW_TabDeactivated:
                // VS2010 is sending a BeforeWinHidden/TabDeactivated/Hidden, which results in a covered state
                // with a closed window. If closed is already pending, don't degrade to cover pending instead.
                myFrameVisibility |= 0 != (startFlags & FrameVisibilityFlags.PendingHiddenMeansClosed) ? FrameVisibilityFlags.PendingHiddenMeansClosed : FrameVisibilityFlags.PendingHiddenMeansCovered;
                break;

            case __FRAMESHOW.FRAMESHOW_DestroyMultInst:
            case __FRAMESHOW.FRAMESHOW_WinClosed:
                ClearContents();
                break;

            case __FRAMESHOW.FRAMESHOW_WinHidden:
                bool           cover = false;
                object         frameModeObj;
                VSFRAMEMODE    frameMode = (VSFRAMEMODE)(-1);
                IVsWindowFrame frame     = myFrame;
                if (frame != null &&
                    VSConstants.S_OK == frame.GetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, out frameModeObj))
                {
                    // VS is changing the framemode during a hide request without telling us, always check and reset
                    // at this point so that a move on a hidden window does not reshow it.
                    myLastFrameMode = frameMode = (VSFRAMEMODE)frameModeObj;
                }
                if (0 != (startFlags & FrameVisibilityFlags.PendingHiddenMeansCovered))
                {
                    cover = true;
                }
                else if (0 == (startFlags & FrameVisibilityFlags.PendingHiddenMeansClosed))
                {
                    cover = frameMode == VSFRAMEMODE.VSFM_MdiChild;
                }
                if (cover)
                {
                    myFrameVisibility = FrameVisibilityFlags.Covered | (flags & FrameVisibilityFlags.PersistentFlagsMask);
                }
                else
                {
                    ClearContents();
                }
                break;

            case __FRAMESHOW.FRAMESHOW_AutoHideSlideBegin:
            case __FRAMESHOW.FRAMESHOW_WinMaximized:
            case __FRAMESHOW.FRAMESHOW_WinRestored:
            case __FRAMESHOW.FRAMESHOW_WinShown:
                ShowContents();
                break;
            }
            return(VSConstants.S_OK);
        }
        private int Open(bool newFile, bool openWith, uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr docDataExisting, out IVsWindowFrame windowFrame, WindowFrameShowAction windowFrameAction)
        {
            windowFrame = null;
            if (this.Node == null || this.Node.ProjectMgr == null || this.Node.ProjectMgr.IsClosed)
            {
                return(VSConstants.E_FAIL);
            }

            Debug.Assert(this.Node != null, "No node has been initialized for the document manager");
            Debug.Assert(this.Node.ProjectMgr != null, "No project manager has been initialized for the document manager");
            Debug.Assert(this.Node is FileNode, "Node is not FileNode object");

            int    returnValue = VSConstants.S_OK;
            string caption     = this.GetOwnerCaption();
            string fullPath    = this.GetFullPathForDocument();

            // Make sure that the file is on disk before we open the editor and display message if not found
            if (!((FileNode)this.Node).IsFileOnDisk(true))
            {
                // Bail since we are not able to open the item
                // Do not return an error code otherwise an internal error message is shown. The scenario for this operation
                // normally is already a reaction to a dialog box telling that the item has been removed.
                return(VSConstants.S_FALSE);
            }

            IVsUIShellOpenDocument uiShellOpenDocument = this.Node.ProjectMgr.Site.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
            IOleServiceProvider    serviceProvider     = this.Node.ProjectMgr.Site.GetService(typeof(IOleServiceProvider)) as IOleServiceProvider;

            try
            {
                this.Node.ProjectMgr.OnOpenItem(fullPath);
                int result = VSConstants.E_FAIL;

                if (openWith)
                {
                    result = uiShellOpenDocument.OpenStandardEditor((uint)__VSOSEFLAGS.OSE_UseOpenWithDialog, fullPath, ref logicalView, caption, Node.ProjectMgr.InteropSafeIVsUIHierarchy, this.Node.ID, docDataExisting, serviceProvider, out windowFrame);
                }
                else
                {
                    __VSOSEFLAGS openFlags = 0;
                    if (newFile)
                    {
                        openFlags |= __VSOSEFLAGS.OSE_OpenAsNewFile;
                    }

                    //NOTE: we MUST pass the IVsProject in pVsUIHierarchy and the itemid
                    // of the node being opened, otherwise the debugger doesn't work.
                    if (editorType != Guid.Empty)
                    {
                        result = uiShellOpenDocument.OpenSpecificEditor(editorFlags, fullPath, ref editorType, physicalView, ref logicalView, caption, Node.ProjectMgr.InteropSafeIVsUIHierarchy, this.Node.ID, docDataExisting, serviceProvider, out windowFrame);
                    }
                    else
                    {
                        openFlags |= __VSOSEFLAGS.OSE_ChooseBestStdEditor;
                        result     = uiShellOpenDocument.OpenStandardEditor((uint)openFlags, fullPath, ref logicalView, caption, Node.ProjectMgr.InteropSafeIVsUIHierarchy, this.Node.ID, docDataExisting, serviceProvider, out windowFrame);
                    }
                }

                if (result != VSConstants.S_OK && result != VSConstants.S_FALSE && result != VSConstants.OLE_E_PROMPTSAVECANCELLED)
                {
                    return(result);
                }

                if (windowFrame != null)
                {
                    object var;

                    if (newFile)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out var));
                        IVsPersistDocData persistDocData = (IVsPersistDocData)var;
                        ErrorHandler.ThrowOnFailure(persistDocData.SetUntitledDocPath(fullPath));
                    }

                    var = null;
                    ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var));
                    this.Node.DocCookie = (uint)(int)var;

                    if (windowFrameAction == WindowFrameShowAction.Show)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.Show());
                    }
                    else if (windowFrameAction == WindowFrameShowAction.ShowNoActivate)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.ShowNoActivate());
                    }
                    else if (windowFrameAction == WindowFrameShowAction.Hide)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.Hide());
                    }
                }
            }
            catch (COMException e)
            {
                Trace.WriteLine("Exception e:" + e.Message);
                returnValue = e.ErrorCode;
                this.CloseWindowFrame(ref windowFrame);
            }

            return(returnValue);
        }
        /// <summary>
        /// Gets the currently active text view(s) from Visual Studio.
        /// </summary>
        /// <returns>
        /// Zero, one or two active <see cref="ITextView"/> objects.
        /// </returns>
        /// <remarks>
        /// This method will return a single text view for a normal code window, or a pair of text
        /// views if the currently active text view is a difference view in side by side mode, with
        /// the first item being the side that currently has focus. If there is no active text view,
        /// an empty collection will be returned.
        /// </remarks>
        protected IEnumerable <ITextView> GetCurrentTextViews()
        {
            var serviceProvider  = Package;
            var monitorSelection = (IVsMonitorSelection)serviceProvider.GetService(typeof(SVsShellMonitorSelection));

            if (monitorSelection == null)
            {
                yield break;
            }

            object curDocument;

            if (ErrorHandler.Failed(monitorSelection.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_DocumentFrame, out curDocument)))
            {
                yield break;
            }

            IVsWindowFrame frame = curDocument as IVsWindowFrame;

            if (frame == null)
            {
                yield break;
            }

            object docView = null;

            if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out docView)))
            {
                yield break;
            }

            if (docView is IVsDifferenceCodeWindow)
            {
                var diffWindow = (IVsDifferenceCodeWindow)docView;

                switch (diffWindow.DifferenceViewer.ViewMode)
                {
                case DifferenceViewMode.Inline:
                    yield return(diffWindow.DifferenceViewer.InlineView);

                    break;

                case DifferenceViewMode.SideBySide:
                    switch (diffWindow.DifferenceViewer.ActiveViewType)
                    {
                    case DifferenceViewType.LeftView:
                        yield return(diffWindow.DifferenceViewer.LeftView);

                        yield return(diffWindow.DifferenceViewer.RightView);

                        break;

                    case DifferenceViewType.RightView:
                        yield return(diffWindow.DifferenceViewer.RightView);

                        yield return(diffWindow.DifferenceViewer.LeftView);

                        break;
                    }
                    yield return(diffWindow.DifferenceViewer.LeftView);

                    break;

                case DifferenceViewMode.RightViewOnly:
                    yield return(diffWindow.DifferenceViewer.RightView);

                    break;
                }
            }
            else if (docView is IVsCodeWindow)
            {
                IVsTextView textView;
                if (ErrorHandler.Failed(((IVsCodeWindow)docView).GetPrimaryView(out textView)))
                {
                    yield break;
                }

                var model          = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
                var adapterFactory = model.GetService <IVsEditorAdaptersFactoryService>();
                var wpfTextView    = adapterFactory.GetWpfTextView(textView);
                yield return(wpfTextView);
            }
        }
        /// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.GetTextView"]/*' />
        /// <devdoc>
        /// Get primary view for a window frame.
        /// </devdoc>
        /// <param name="windowFrame">The window frame</param>
        /// <returns>A reference to an IVsTextView if successful. Otherwise null.</returns>
        public static IVsTextView GetTextView(IVsWindowFrame windowFrame)
        {
            if (windowFrame == null)
            {
                throw new ArgumentException("windowFrame");
            }

            object pvar;
            ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out pvar));

            IVsTextView textView = pvar as IVsTextView;

            if (textView == null)
            {
                IVsCodeWindow codeWin = pvar as IVsCodeWindow;
                if (codeWin != null)
                {
                    ErrorHandler.ThrowOnFailure(codeWin.GetPrimaryView(out textView));
                }
            }
            return textView;
        }
 internal object GetProperty(IVsWindowFrame frame, int propertyID)
 {
     object result = null;
     ErrorHandler.ThrowOnFailure(frame.GetProperty(propertyID, out result));
     return result;
 }
Exemple #24
0
 /// <include file='doc\Utilities.uex' path='docs/doc[@for="VsShell.GetTextView"]/*' />
 public static IVsTextView GetTextView(IVsWindowFrame windowFrame) {
     IVsTextView textView = null;
     object pvar;
     NativeMethods.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out pvar));
     if (pvar is IVsTextView) {
         textView = (IVsTextView)pvar;
     } else if (pvar is IVsCodeWindow) {
         IVsCodeWindow codeWin = (IVsCodeWindow)pvar;
         try {
             NativeMethods.ThrowOnFailure(codeWin.GetPrimaryView(out textView));
         } catch (Exception) {
             // perhaps the code window doesn't use IVsTextWindow?
             textView = null;
         }
     }
     return textView;
 }
Exemple #25
0
        /// <include file='doc\Hierarchy.uex' path='docs/doc[@for="HierarchyNode.OpenItem2"]/*' />
        public virtual void OpenItem(bool newFile, bool openWith, ref Guid logicalView, IntPtr punkDocDataExisting, out IVsWindowFrame windowFrame){
            this.ProjectMgr.OnOpenItem(this.FullPath);

            windowFrame = null;
            Guid editorType = Guid.Empty;
            VsShell.OpenItem(this.projectMgr.Site, newFile, openWith, 0, ref editorType, null, ref logicalView, punkDocDataExisting, (IVsHierarchy)this, this.hierarchyId, out windowFrame);

            if (windowFrame != null){
                object var;
                windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var);
                this.docCookie = (IntPtr)VsConstants.ForceCast((int)var);
            }
        }
 public static IDifferenceViewer GetDiffViewer(IVsWindowFrame frame)
 {
     ThreadHelper.ThrowIfNotOnUIThread();
     return(ErrorHandler.Succeeded(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out object docView))
                         ? (docView as IVsDifferenceCodeWindow)?.DifferenceViewer : null);
 }
Exemple #27
0
        /// <include file='doc\Hierarchy.uex' path='docs/doc[@for="HierarchyNode.OpenItemWithSpecific"]/*' />
        public virtual void OpenItemWithSpecific(uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr punkDocDataExisting, out IVsWindowFrame windowFrame){
            this.ProjectMgr.OnOpenItem(this.FullPath);

            windowFrame = null;
            VsShell.OpenItem(this.projectMgr.Site, false, false, editorFlags, ref editorType, physicalView, ref logicalView, punkDocDataExisting, (IVsHierarchy)this, this.hierarchyId, out windowFrame);            

            if (windowFrame != null){
                object var;
                windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var);
                this.docCookie = (IntPtr)VsConstants.ForceCast((int)var);
            }
        }
Exemple #28
0
        /// <include file='doc\Hierarchy.uex' path='docs/doc[@for="HierarchyNode.OpenItemWithSpecific"]/*' />
        public virtual void OpenItemWithSpecific(uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr punkDocDataExisting, out IVsWindowFrame windowFrame)
		{
            this.ProjectMgr.OnOpenItem(this.Url);

            windowFrame = null;
            HierarchyNode.OpenItem(this.projectMgr.Site, false, false, editorFlags, ref editorType, physicalView, ref logicalView, punkDocDataExisting, (IVsHierarchy)this, this.hierarchyId, out windowFrame);

            if (windowFrame != null)
			{
                object var;
                NativeMethods.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var));
                this.docCookie = new IntPtr((int)var);
            }
        }
Exemple #29
0
 private bool IsToolWindow(IVsWindowFrame frame)
 {
   object obj2;
   int num = 0;
   NativeMethods.ThrowOnFailure(frame.GetProperty(-3000, out obj2));
   if (obj2 is int)
   {
     num = (int) obj2;
   }
   return (num == 2);
 }
        protected override void GotoSource(VSOBJGOTOSRCTYPE gotoType)
        {
            // We do not support the "Goto Reference"
            if (VSOBJGOTOSRCTYPE.GS_REFERENCE == gotoType)
            {
                return;
            }

            // There is no difference between definition and declaration, so here we
            // don't check for the other flags.

            IVsWindowFrame frame        = null;
            IntPtr         documentData = FindDocDataFromRDT();

            try {
                // Now we can try to open the editor. We assume that the owner hierarchy is
                // a project and we want to use its OpenItem method.
                IVsProject3 project = ownerHierarchy as IVsProject3;
                if (null == project)
                {
                    return;
                }
                Guid viewGuid = VSConstants.LOGVIEWID_Code;
                ErrorHandler.ThrowOnFailure(project.OpenItem(fileId, ref viewGuid, documentData, out frame));
            } finally {
                if (IntPtr.Zero != documentData)
                {
                    Marshal.Release(documentData);
                    documentData = IntPtr.Zero;
                }
            }

            // Make sure that the document window is visible.
            ErrorHandler.ThrowOnFailure(frame.Show());

            // Get the code window from the window frame.
            object docView;

            ErrorHandler.ThrowOnFailure(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out docView));
            IVsCodeWindow codeWindow = docView as IVsCodeWindow;

            if (null == codeWindow)
            {
                object docData;
                ErrorHandler.ThrowOnFailure(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out docData));
                codeWindow = docData as IVsCodeWindow;
                if (null == codeWindow)
                {
                    return;
                }
            }

            // Get the primary view from the code window.
            IVsTextView textView;

            ErrorHandler.ThrowOnFailure(codeWindow.GetPrimaryView(out textView));

            // Set the cursor at the beginning of the declaration.
            ErrorHandler.ThrowOnFailure(textView.SetCaretPos(sourceSpan.iStartLine, sourceSpan.iStartIndex));
            // Make sure that the text is visible.
            TextSpan visibleSpan = new TextSpan();

            visibleSpan.iStartLine  = sourceSpan.iStartLine;
            visibleSpan.iStartIndex = sourceSpan.iStartIndex;
            visibleSpan.iEndLine    = sourceSpan.iStartLine;
            visibleSpan.iEndIndex   = sourceSpan.iStartIndex + 1;
            ErrorHandler.ThrowOnFailure(textView.EnsureSpanVisible(visibleSpan));
        }
        /// <include file='doc\VsShellUtilities.uex' path='docs/doc[@for="VsShellUtilities.GetWindowObject"]/*' />
        /// <devdoc>
        /// Get Window interface for the window frame.
        /// </devdoc>
        /// <param name="windowFrame">The window frame.</param>
        /// <returns>A reference to the Window interaface if succesfull. Otherwise null.</returns>
        public static EnvDTE.Window GetWindowObject(IVsWindowFrame windowFrame)
        {
            if (windowFrame == null)
            {
                throw new ArgumentException("windowFrame");
            }

            EnvDTE.Window window = null;
            object pvar;
            ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_ExtWindowObject, out pvar));
            if (pvar is EnvDTE.Window)
            {
                window = (EnvDTE.Window)pvar;
            }
            return window;
        }
        private static bool TryGetInfoBarHost(IVsWindowFrame frame, out IVsInfoBarHost infoBarHost)
        {
            object infoBarHostObj;

            if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID7.VSFPROPID_InfoBarHost, out infoBarHostObj)))
            {
                infoBarHost = null;
                return false;
            }

            infoBarHost = infoBarHostObj as IVsInfoBarHost;
            return infoBarHost != null;
        }
        private int OpenItem(bool newFile, bool openWith, uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr docDataExisting, out IVsWindowFrame frame, WindowFrameShowAction windowFrameAction)
        {
            frame = null;

            if (this.ProjectMgr == null || this.ProjectMgr.IsClosed)
            {
                return VSConstants.E_FAIL;
            }

            int result = VSConstants.S_OK;
            uint[] ppItemId = new uint[1];
            ppItemId[0] = this.ID;
            int open;
            IVsUIHierarchy project;
            string fullPath = GetMkDocument();

            // check if the file exists
            if (!System.IO.File.Exists(fullPath))
            {
                // TODO Inform clients that we have an invalid item (wrong icon)
                //// Inform clients that we have an invalid item (wrong icon)
                //this.Node.OnInvalidateItems(this.Node.Parent);

                return VSConstants.S_FALSE;
            }

            IVsUIShellOpenDocument sod = (this.ProjectMgr as CogaenEditProject).Site.GetService(typeof(IVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
            if (sod != null)
            {
                try
                {
                    // try to get hold of the open file
                    sod.IsDocumentOpen(this.ProjectMgr
                        , this.ID
                        , GetMkDocument()
                        , ref logicalView /* LOGVIEWID_Code to show xml behind */
                        , (uint)__VSIDOFLAGS.IDO_ActivateIfOpen
                        , out project
                        , ppItemId
                        , out frame
                        , out open);

                    // file is not open
                    if (open == 0)
                    {
                        // TODO load doc data
                        Load(fullPath, 0, 0);
                        docDataExisting = Marshal.GetIUnknownForObject(ObjectBuilder);

                        if (openWith)
                        {
                            result = sod.OpenStandardEditor((uint)__VSOSEFLAGS.OSE_UseOpenWithDialog//(uint)__VSOSEFLAGS.OSE_ChooseBestStdEditor
                            , GetMkDocument()
                            , ref logicalView /* VSConstants.LOGVIEWID.Code_guid for xml behind*/
                            , Caption
                            , this.ProjectMgr
                            , this.ID
                                // TODO pass docData!!!!
                            , docDataExisting
                            , this.ProjectMgr.Site as Microsoft.VisualStudio.OLE.Interop.IServiceProvider
                            , out frame);
                        }
                        else
                        {
                            __VSOSEFLAGS openFlags = 0;
                            if (newFile)
                            {
                                openFlags |= __VSOSEFLAGS.OSE_OpenAsNewFile;
                            }

                            openFlags |= __VSOSEFLAGS.OSE_ChooseBestStdEditor;

                            if (editorType != Guid.Empty)
                            {
                                result = sod.OpenSpecificEditor(editorFlags
                                    , fullPath
                                    , ref editorType
                                    , physicalView
                                    , ref logicalView
                                    , Caption
                                    , this.ProjectMgr
                                    , this.ID
                                    , docDataExisting
                                    , this.ProjectMgr.Site as Microsoft.VisualStudio.OLE.Interop.IServiceProvider
                                    , out frame);
                            }
                            else
                            {

                                result = sod.OpenStandardEditor((uint)openFlags
                                , GetMkDocument()
                                , ref logicalView /* VSConstants.LOGVIEWID.Code_guid for xml behind*/
                                , Caption
                                , this.ProjectMgr
                                , this.ID
                                , docDataExisting
                                , this.ProjectMgr.Site as Microsoft.VisualStudio.OLE.Interop.IServiceProvider
                                , out frame);
                            }
                        }
                        if (result != VSConstants.S_OK && result != VSConstants.S_FALSE && result != VSConstants.OLE_E_PROMPTSAVECANCELLED)
                        {
                            ErrorHandler.ThrowOnFailure(result);
                        }
                        // eventually show window
                        if (frame != null)
                        {
                            object var;

                            if (newFile)
                            {
                                ErrorHandler.ThrowOnFailure(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out var));
                                IVsPersistDocData persistDocData = (IVsPersistDocData)var;
                                ErrorHandler.ThrowOnFailure(persistDocData.SetUntitledDocPath(fullPath));
                            }

                            var = null;
                            ErrorHandler.ThrowOnFailure(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var));
                            this.DocCookie = (uint)(int)var;

                            if (windowFrameAction == WindowFrameShowAction.Show)
                            {
                                ErrorHandler.ThrowOnFailure(frame.Show());
                            }
                            else if (windowFrameAction == WindowFrameShowAction.ShowNoActivate)
                            {
                                ErrorHandler.ThrowOnFailure(frame.ShowNoActivate());
                            }
                            else if (windowFrameAction == WindowFrameShowAction.Hide)
                            {
                                ErrorHandler.ThrowOnFailure(frame.Hide());
                            }
                        }
                    }
                    // file is already open
                    else
                    {
                        ObjectBuilder = Marshal.GetObjectForIUnknown(docDataExisting) as ObjectBuilder;
                        Marshal.Release(docDataExisting);

                        if (frame != null)
                        {
                            if (windowFrameAction == WindowFrameShowAction.Show)
                            {
                                ErrorHandler.ThrowOnFailure(frame.Show());
                            }
                            else if (windowFrameAction == WindowFrameShowAction.ShowNoActivate)
                            {
                                ErrorHandler.ThrowOnFailure(frame.ShowNoActivate());
                            }
                            else if (windowFrameAction == WindowFrameShowAction.Hide)
                            {
                                ErrorHandler.ThrowOnFailure(frame.Hide());
                            }
                        }
                    }
                }
                catch (COMException e)
                {
                    Trace.WriteLine("Exception e:" + e.Message);
                    result = e.ErrorCode;
                    CloseWindowFrame(ref frame);
                }
            }
            return result;
        }
        /// <summary>
        /// Docks the specified frame window if it is currently floating.
        /// </summary>
        /// <remarks>Works in VS2010, does not appear to work in VS2008.</remarks>
        /// <param name="frame">The frame.</param>
        private static void DockWindowIfFloating(IVsWindowFrame frame)
        {
            // Get the current tool window frame mode.
            object currentFrameMode;
            frame.GetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, out currentFrameMode);

            // If currently floating, switch to dock mode.
            if ((VSFRAMEMODE)currentFrameMode == VSFRAMEMODE.VSFM_Float)
            {
                frame.SetProperty((int)__VSFPROPID.VSFPROPID_FrameMode, VSFRAMEMODE.VSFM_Dock);
            }
        }
Exemple #35
0
 internal static IVsTextLines GetTextLines(IVsWindowFrame windowFrame)
 {
   if (windowFrame != null) {
     object docData;
     windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out docData);
     return docData as IVsTextLines;
   }
   else {
     return null;
   }
 }
Exemple #36
0
        /// <include file='doc\Hierarchy.uex' path='docs/doc[@for="HierarchyNode.OpenItem2"]/*' />
        public virtual void OpenItem(bool newFile, bool openWith, ref Guid logicalView, IntPtr punkDocDataExisting, out IVsWindowFrame windowFrame)
		{
            this.ProjectMgr.OnOpenItem(this.Url);

            windowFrame = null;
            Guid editorType = Guid.Empty;
            HierarchyNode.OpenItem(this.projectMgr.Site, newFile, openWith, 0, ref editorType, null, ref logicalView, punkDocDataExisting, (IVsHierarchy)this, this.hierarchyId, out windowFrame);

            if (windowFrame != null)
			{
                object var;
                NativeMethods.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var));
                this.docCookie = new IntPtr((int)var);
            }
        }
        private int Open(bool newFile, bool openWith, uint editorFlags, ref Guid editorType, string physicalView, ref Guid logicalView, IntPtr docDataExisting, out IVsWindowFrame windowFrame, WindowFrameShowAction windowFrameAction)
        {
            windowFrame = null;
            if(this.Node == null || this.Node.ProjectMgr == null || this.Node.ProjectMgr.IsClosed)
            {
                return VSConstants.E_FAIL;
            }

            Debug.Assert(this.Node != null, "No node has been initialized for the document manager");
            Debug.Assert(this.Node.ProjectMgr != null, "No project manager has been initialized for the document manager");
            Debug.Assert(this.Node is FileNode, "Node is not FileNode object");

            int returnValue = VSConstants.S_OK;
            string caption = this.GetOwnerCaption();
            string fullPath = this.GetFullPathForDocument();

            // Make sure that the file is on disk before we open the editor and display message if not found
            if(!((FileNode)this.Node).IsFileOnDisk(true))
            {
                // Inform clients that we have an invalid item (wrong icon)
                this.Node.OnInvalidateItems(this.Node.Parent);

                // Bail since we are not able to open the item
                // Do not return an error code otherwise an internal error message is shown. The scenario for this operation
                // normally is already a reaction to a dialog box telling that the item has been removed.
                return VSConstants.S_FALSE;
            }

            IVsUIShellOpenDocument uiShellOpenDocument = this.Node.ProjectMgr.Site.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;
            IOleServiceProvider serviceProvider = this.Node.ProjectMgr.Site.GetService(typeof(IOleServiceProvider)) as IOleServiceProvider;

            try
            {
                this.Node.ProjectMgr.OnOpenItem(fullPath);
                int result = VSConstants.E_FAIL;

                if(openWith)
                {
                    result = uiShellOpenDocument.OpenStandardEditor((uint)__VSOSEFLAGS.OSE_UseOpenWithDialog, fullPath, ref logicalView, caption, this.Node.ProjectMgr, this.Node.ID, docDataExisting, serviceProvider, out windowFrame);
                }
                else
                {
                    __VSOSEFLAGS openFlags = 0;
                    if(newFile)
                    {
                        openFlags |= __VSOSEFLAGS.OSE_OpenAsNewFile;
                    }

                    //NOTE: we MUST pass the IVsProject in pVsUIHierarchy and the itemid
                    // of the node being opened, otherwise the debugger doesn't work.
                    if(editorType != Guid.Empty)
                    {
                        result = uiShellOpenDocument.OpenSpecificEditor(editorFlags, fullPath, ref editorType, physicalView, ref logicalView, caption, this.Node.ProjectMgr, this.Node.ID, docDataExisting, serviceProvider, out windowFrame);
                    }
                    else
                    {
                        openFlags |= __VSOSEFLAGS.OSE_ChooseBestStdEditor;
                        result = uiShellOpenDocument.OpenStandardEditor((uint)openFlags, fullPath, ref logicalView, caption, this.Node.ProjectMgr, this.Node.ID, docDataExisting, serviceProvider, out windowFrame);
                    }
                }

                if(result != VSConstants.S_OK && result != VSConstants.S_FALSE && result != VSConstants.OLE_E_PROMPTSAVECANCELLED)
                {
                    ErrorHandler.ThrowOnFailure(result);
                }

                if(windowFrame != null)
                {
                    object var;

                    if(newFile)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out var));
                        IVsPersistDocData persistDocData = (IVsPersistDocData)var;
                        ErrorHandler.ThrowOnFailure(persistDocData.SetUntitledDocPath(fullPath));
                    }

                    var = null;
                    ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocCookie, out var));
                    this.Node.DocCookie = (uint)(int)var;

                    if(windowFrameAction == WindowFrameShowAction.Show)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.Show());
                    }
                    else if(windowFrameAction == WindowFrameShowAction.ShowNoActivate)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.ShowNoActivate());
                    }
                    else if(windowFrameAction == WindowFrameShowAction.Hide)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.Hide());
                    }
                }
            }
            catch(COMException e)
            {
                Trace.WriteLine("Exception e:" + e.Message);
                returnValue = e.ErrorCode;
                CloseWindowFrame(ref windowFrame);
            }

            return returnValue;
        }
        /// <summary>
        /// Gets the currently active text view(s) from Visual Studio.
        /// </summary>
        /// <returns>
        /// Zero, one or two active <see cref="ITextView"/> objects.
        /// </returns>
        /// <remarks>
        /// This method will return a single text view for a normal code window, or a pair of text
        /// views if the currently active text view is a difference view in side by side mode, with
        /// the first item being the side that currently has focus. If there is no active text view,
        /// an empty collection will be returned.
        /// </remarks>
        public CurrentTextViews GetCurrentTextViews()
        {
            ThreadHelper.ThrowIfNotOnUIThread();
            CurrentTextViews results = null;

            try {
                var monitorSelection = (IVsMonitorSelection)_serviceProvider.GetService(typeof(SVsShellMonitorSelection));
                if (monitorSelection == null)
                {
                    return(results);
                }

                object curDocument;
                if (ErrorHandler.Failed(monitorSelection.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_DocumentFrame, out curDocument)))
                {
                    return(results);
                }

                IVsWindowFrame frame = curDocument as IVsWindowFrame;
                if (frame == null)
                {
                    return(results);
                }

                object docView = null;
                if (ErrorHandler.Failed(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out docView)))
                {
                    return(results);
                }

                results = new CurrentTextViews {
                    DocumentView = docView
                };
                var textViews = new List <ITextView>();
                if (docView is IVsDifferenceCodeWindow)
                {
                    var diffWindow = (IVsDifferenceCodeWindow)docView;

                    switch (diffWindow.DifferenceViewer.ViewMode)
                    {
                    case DifferenceViewMode.Inline:
                        textViews.Add(diffWindow.DifferenceViewer.InlineView);
                        break;

                    case DifferenceViewMode.SideBySide:
                        switch (diffWindow.DifferenceViewer.ActiveViewType)
                        {
                        case DifferenceViewType.LeftView:
                            textViews.Add(diffWindow.DifferenceViewer.LeftView);
                            textViews.Add(diffWindow.DifferenceViewer.RightView);
                            break;

                        case DifferenceViewType.RightView:
                            textViews.Add(diffWindow.DifferenceViewer.RightView);
                            textViews.Add(diffWindow.DifferenceViewer.LeftView);
                            break;
                        }
                        textViews.Add(diffWindow.DifferenceViewer.LeftView);
                        break;

                    case DifferenceViewMode.RightViewOnly:
                        textViews.Add(diffWindow.DifferenceViewer.RightView);
                        break;
                    }
                }
                else if (docView is IVsCodeWindow)
                {
                    if (ErrorHandler.Failed(((IVsCodeWindow)docView).GetPrimaryView(out var textView)))
                    {
                        return(results);
                    }

                    var model = (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel));
                    Assumes.Present(model);

                    var adapterFactory = model.GetService <IVsEditorAdaptersFactoryService>();
                    var wpfTextView    = adapterFactory.GetWpfTextView(textView);
                    textViews.Add(wpfTextView);
                }

                results.TextViews = textViews;
                return(results);
            }
            catch (Exception e) {
                Log.Error(e, nameof(GetCurrentTextViews));
            }

            return(results);
        }