Пример #1
0
        /// <summary>
        /// Common method for handling platform names.
        /// </summary>
        /// <param name="celt">Specifies the requested number of platform names. If this number is unknown, celt can be zero.</param>
        /// <param name="names">On input, an allocated array to hold the number of platform names specified by celt. This parameter can also be null if the celt parameter is zero. On output, names contains platform names</param>
        /// <param name="actual">A count of the actual number of platform names returned.</param>
        /// <param name="platforms">An array of available platform names</param>
        /// <returns>A count of the actual number of platform names returned.</returns>
        /// <devremark>The platforms array is never null. It is assured by the callers.</devremark>
        private static int GetPlatforms(uint celt, string[] names, uint[] actual, string[] platforms)
        {
            Utilities.ArgumentNotNull("platforms", platforms);
            if (names == null)
            {
                if (actual == null || actual.Length == 0)
                {
                    throw new ArgumentException(SR.GetString(SR.InvalidParameter, CultureInfo.CurrentUICulture), "actual");
                }

                actual[0] = (uint)platforms.Length;
                return(VSConstants.S_OK);
            }

            //Degenarate case
            if (celt == 0)
            {
                if (actual != null && actual.Length != 0)
                {
                    actual[0] = (uint)platforms.Length;
                }

                return(VSConstants.S_OK);
            }

            uint returned = 0;

            for (int i = 0; i < platforms.Length && names.Length > returned; i++)
            {
                names[returned] = platforms[i];
                returned++;
            }

            if (actual != null && actual.Length != 0)
            {
                actual[0] = returned;
            }

            if (celt > returned)
            {
                return(VSConstants.S_FALSE);
            }

            return(VSConstants.S_OK);
        }
Пример #2
0
        /// <summary>
        /// Constructor.  Copy the base property descriptor and also hold a pointer
        /// to it for calling its overridden abstract methods.
        /// </summary>
        public DesignPropertyDescriptor(PropertyDescriptor prop)
            : base(prop)
        {
            Utilities.ArgumentNotNull("prop", prop);

            this.property = prop;

            DisplayNameAttribute attr = prop.Attributes[typeof(DisplayNameAttribute)] as DisplayNameAttribute;

            if (attr != null)
            {
                this.displayName = attr.DisplayName;
            }
            else
            {
                this.displayName = prop.Name;
            }
        }
Пример #3
0
        /// <summary>
        /// Constructor.  Inititialize member data.
        /// </summary>
        public IDEBuildLogger(IVsOutputWindowPane output, TaskProvider taskProvider, IVsHierarchy hierarchy)
        {
            Utilities.ArgumentNotNull("taskProvider", taskProvider);
            Utilities.ArgumentNotNull("hierarchy", hierarchy);

            Trace.WriteLineIf(Thread.CurrentThread.GetApartmentState() != ApartmentState.STA, "WARNING: IDEBuildLogger constructor running on the wrong thread.");

            IOleServiceProvider site;

            Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(hierarchy.GetSite(out site));

            this.taskProvider     = taskProvider;
            this.outputWindowPane = output;
            this.hierarchy        = hierarchy;
            this.serviceProvider  = new ServiceProvider(site);
            serviceProvider.GetUIThread().MustBeCalledFromUIThread();
            this.dispatcher = Dispatcher.CurrentDispatcher;
        }
Пример #4
0
        internal ProjectConfig(ProjectNode project, string configuration)
        {
            this.project    = project;
            this.configName = configuration;

            var flavoredCfgProvider = ProjectMgr.GetOuterInterface <IVsProjectFlavorCfgProvider>();

            Utilities.ArgumentNotNull("flavoredCfgProvider", flavoredCfgProvider);
            ErrorHandler.ThrowOnFailure(flavoredCfgProvider.CreateProjectFlavorCfg(this, out flavoredCfg));
            Utilities.ArgumentNotNull("flavoredCfg", flavoredCfg);

            // if the flavored object support XML fragment, initialize it
            IPersistXMLFragment persistXML = flavoredCfg as IPersistXMLFragment;

            if (null != persistXML)
            {
                this.project.LoadXmlFragment(persistXML, configName);
            }
        }
Пример #5
0
        /// <summary>
        /// Get reference to IVsUIHierarchyWindow interface from guid persistence slot.
        /// </summary>
        /// <param name="serviceProvider">The service provider.</param>
        /// <param name="persistenceSlot">Unique identifier for a tool window created using IVsUIShell::CreateToolWindow.
        /// The caller of this method can use predefined identifiers that map to tool windows if those tool windows
        /// are known to the caller. </param>
        /// <returns>A reference to an IVsUIHierarchyWindow interface.</returns>
        public static IVsUIHierarchyWindow GetUIHierarchyWindow(IServiceProvider serviceProvider, Guid persistenceSlot)
        {
            Utilities.ArgumentNotNull("serviceProvider", serviceProvider);

            IVsUIShell shell = serviceProvider.GetService(typeof(SVsUIShell)) as IVsUIShell;

            Utilities.CheckNotNull(shell, "Could not get the UI shell from the project");

            object         pvar;
            IVsWindowFrame frame;

            if (ErrorHandler.Succeeded(shell.FindToolWindow(0, ref persistenceSlot, out frame)) &&
                ErrorHandler.Succeeded(frame.GetProperty((int)__VSFPROPID.VSFPROPID_DocView, out pvar)))
            {
                return(pvar as IVsUIHierarchyWindow);
            }

            return(null);
        }
Пример #6
0
        /// <summary>
        /// Gets the active configuration name.
        /// </summary>
        /// <param name="automationObject">The automation object.</param>
        /// <returns>The name of the active configuartion.</returns>
        internal static string GetActiveConfigurationName(EnvDTE.Project automationObject)
        {
            Utilities.ArgumentNotNull("automationObject", automationObject);

            string currentConfigName = string.Empty;

            if (automationObject.ConfigurationManager != null)
            {
                try {
                    EnvDTE.Configuration activeConfig = automationObject.ConfigurationManager.ActiveConfiguration;
                    if (activeConfig != null)
                    {
                        currentConfigName = activeConfig.ConfigurationName;
                    }
                } catch (COMException ex) {
                    Debug.WriteLine("Failed to get active configuration because of {0}", ex);
                }
            }
            return(currentConfigName);
        }
Пример #7
0
        /// <summary>
        /// Overridden from the Logger class.
        /// </summary>
        public override void Initialize(IEventSource eventSource)
        {
            Utilities.ArgumentNotNull("eventSource", eventSource);

            this.taskQueue   = new ConcurrentQueue <Func <ErrorTask> >();
            this.outputQueue = new ConcurrentQueue <OutputQueueEntry>();

            eventSource.BuildStarted      += new BuildStartedEventHandler(BuildStartedHandler);
            eventSource.BuildFinished     += new BuildFinishedEventHandler(BuildFinishedHandler);
            eventSource.ProjectStarted    += new ProjectStartedEventHandler(ProjectStartedHandler);
            eventSource.ProjectFinished   += new ProjectFinishedEventHandler(ProjectFinishedHandler);
            eventSource.TargetStarted     += new TargetStartedEventHandler(TargetStartedHandler);
            eventSource.TargetFinished    += new TargetFinishedEventHandler(TargetFinishedHandler);
            eventSource.TaskStarted       += new TaskStartedEventHandler(TaskStartedHandler);
            eventSource.TaskFinished      += new TaskFinishedEventHandler(TaskFinishedHandler);
            eventSource.CustomEventRaised += new CustomBuildEventHandler(CustomHandler);
            eventSource.ErrorRaised       += new BuildErrorEventHandler(ErrorRaisedHandler);
            eventSource.WarningRaised     += new BuildWarningEventHandler(WarningHandler);
            eventSource.MessageRaised     += new BuildMessageEventHandler(MessageHandler);
        }
Пример #8
0
        public int Next(uint elements, IVsDependency[] dependencies, out uint elementsFetched)
        {
            elementsFetched = 0;
            Utilities.ArgumentNotNull("dependencies", dependencies);

            uint fetched = 0;
            var  count   = this.dependencyList.Count;

            while (this.nextIndex < count && elements > 0 && fetched < count)
            {
                dependencies[fetched] = this.dependencyList[(int)this.nextIndex];
                this.nextIndex++;
                fetched++;
                elements--;
            }

            elementsFetched = fetched;

            // Did we get 'em all?
            return(elements == 0 ? VSConstants.S_OK : VSConstants.S_FALSE);
        }
Пример #9
0
        /// <summary>
        /// Updates the caption for all windows associated to the document.
        /// </summary>
        /// <param name="site">The service provider.</param>
        /// <param name="caption">The new caption.</param>
        /// <param name="docData">The IUnknown interface to a document data object associated with a registered document.</param>
        public static void UpdateCaption(IServiceProvider site, string caption, IntPtr docData)
        {
            Utilities.ArgumentNotNull("site", site);

            if (string.IsNullOrEmpty(caption))
            {
                throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty), "caption");
            }

            var uiShell = site.GetService(typeof(SVsUIShell)) as IVsUIShell;

            // We need to tell the windows to update their captions.
            IEnumWindowFrames windowFramesEnum;

            ErrorHandler.ThrowOnFailure(uiShell.GetDocumentWindowEnum(out windowFramesEnum));
            var  windowFrames = new IVsWindowFrame[1];
            uint fetched;

            while (windowFramesEnum.Next(1, windowFrames, out fetched) == VSConstants.S_OK && fetched == 1)
            {
                var    windowFrame = windowFrames[0];
                object data;
                ErrorHandler.ThrowOnFailure(windowFrame.GetProperty((int)__VSFPROPID.VSFPROPID_DocData, out data));
                var ptr = Marshal.GetIUnknownForObject(data);
                try
                {
                    if (ptr == docData)
                    {
                        ErrorHandler.ThrowOnFailure(windowFrame.SetProperty((int)__VSFPROPID.VSFPROPID_OwnerCaption, caption));
                    }
                }
                finally
                {
                    if (ptr != IntPtr.Zero)
                    {
                        Marshal.Release(ptr);
                    }
                }
            }
        }
Пример #10
0
        /// <summary>
        /// Retrieves the common property pages. The NodeProperties is the BrowseObject and that will be called to support
        /// configuration independent properties.
        /// </summary>
        /// <param name="pages">The pages to return.</param>
        private void GetCommonPropertyPages(CAUUID[] pages)
        {
            // We do not check whether the supportsProjectDesigner is set to false on the ProjectNode.
            // We rely that the caller knows what to call on us.
            Utilities.ArgumentNotNull("pages", pages);

            if (pages.Length == 0)
            {
                throw new ArgumentException(SR.GetString(SR.InvalidParameter), "pages");
            }

            // Only the project should show the property page the rest should show the project properties.
            if (this.node != null && (this.node is ProjectNode))
            {
                // Retrieve the list of guids from hierarchy properties.
                // Because a flavor could modify that list we must make sure we are calling the outer most implementation of IVsHierarchy
                string       guidsList = String.Empty;
                IVsHierarchy hierarchy = HierarchyNode.ProjectMgr.GetOuterInterface <IVsHierarchy>();
                object       variant   = null;
                ErrorHandler.ThrowOnFailure(hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID2.VSHPROPID_PropertyPagesCLSIDList, out variant));
                guidsList = (string)variant;

                Guid[] guids = Utilities.GuidsArrayFromSemicolonDelimitedStringOfGuids(guidsList);
                if (guids == null || guids.Length == 0)
                {
                    pages[0]        = new CAUUID();
                    pages[0].cElems = 0;
                }
                else
                {
                    pages[0] = PackageUtilities.CreateCAUUIDFromGuidArray(guids);
                }
            }
            else
            {
                pages[0]        = new CAUUID();
                pages[0].cElems = 0;
            }
        }
Пример #11
0
        int IPropertyPage.TranslateAccelerator(MSG[] pMsg)
        {
            Utilities.ArgumentNotNull("pMsg", pMsg);

            var msg = pMsg[0];

            var message = Message.Create(msg.hwnd, (int)msg.message, msg.wParam, msg.lParam);

            var target = Control.FromChildHandle(message.HWnd);

            if (target != null && target.PreProcessMessage(ref message))
            {
                // handled the message
                pMsg[0].message = (uint)message.Msg;
                pMsg[0].wParam  = message.WParam;
                pMsg[0].lParam  = message.LParam;

                return(VSConstants.S_OK);
            }

            return(VSConstants.S_FALSE);
        }
Пример #12
0
        internal ProjectConfig(ProjectNode project, string configuration)
        {
            this.project = project;

            if (configuration.Contains("|"))
            { // If configuration is in the form "<Configuration>|<Platform>"
                string[] configStrArray = configuration.Split('|');
                if (2 == configStrArray.Length)
                {
                    this.configName   = configStrArray[0];
                    this.platformName = configStrArray[1];
                }
                else
                {
                    throw new Exception(string.Format(CultureInfo.InvariantCulture, "Invalid configuration format: {0}", configuration));
                }
            }
            else
            { // If configuration is in the form "<Configuration>"
                this.configName = configuration;
            }

            var flavoredCfgProvider = ProjectMgr.GetOuterInterface <IVsProjectFlavorCfgProvider>();

            Utilities.ArgumentNotNull("flavoredCfgProvider", flavoredCfgProvider);
            ErrorHandler.ThrowOnFailure(flavoredCfgProvider.CreateProjectFlavorCfg(this, out flavoredCfg));
            Utilities.ArgumentNotNull("flavoredCfg", flavoredCfg);

            // if the flavored object support XML fragment, initialize it
            IPersistXMLFragment persistXML = flavoredCfg as IPersistXMLFragment;

            if (null != persistXML)
            {
                this.project.LoadXmlFragment(persistXML, configName, platformName);
            }
        }
Пример #13
0
        /// <summary>
        /// Builds an ImageHandler object from an ImageList object.
        /// </summary>
        public ImageHandler(ImageList list)
        {
            Utilities.ArgumentNotNull("list", list);

            imageList = list;
        }
Пример #14
0
 /// <summary>
 /// Builds an ImageHandler object from a Stream providing the bitmap that
 /// stores the images for the image list.
 /// </summary>
 public ImageHandler(Stream resourceStream)
 {
     Utilities.ArgumentNotNull("resourceStream", resourceStream);
     imageList = Utilities.GetImageList(resourceStream);
 }
        public PropertiesEditorLauncher(ServiceProvider serviceProvider)
        {
            Utilities.ArgumentNotNull("serviceProvider", serviceProvider);

            this.serviceProvider = serviceProvider;
        }
Пример #16
0
 protected DocumentManager(HierarchyNode node)
 {
     Utilities.ArgumentNotNull(nameof(node), node);
     this.node = node;
 }
Пример #17
0
        internal ProjectElement(ProjectNode project)
        {
            Utilities.ArgumentNotNull("project", project);

            _itemProject = project;
        }
Пример #18
0
        internal ProjectElement(ProjectNode project)
        {
            Utilities.ArgumentNotNull(nameof(project), project);

            this._itemProject = project;
        }
Пример #19
0
        /// <summary>
        /// Builds an ImageHandler object from an ImageList object.
        /// </summary>
        public ImageHandler(ImageList list)
        {
            Utilities.ArgumentNotNull(nameof(list), list);

            this.imageList = list;
        }
Пример #20
0
 internal NodeProperties(HierarchyNode node)
 {
     Utilities.ArgumentNotNull("node", node);
     this.node = node;
 }
Пример #21
0
        /// <summary>
        /// Rename document in the running document table from oldName to newName.
        /// </summary>
        /// <param name="provider">The service provider.</param>
        /// <param name="oldName">Full path to the old name of the document.</param>
        /// <param name="newName">Full path to the new name of the document.</param>
        /// <param name="newItemId">The new item id of the document</param>
        public static void RenameDocument(IServiceProvider site, string oldName, string newName, uint newItemId)
        {
            Utilities.ArgumentNotNull("site", site);

            if (String.IsNullOrEmpty(oldName))
            {
                throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "oldName");
            }

            if (String.IsNullOrEmpty(newName))
            {
                throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty, CultureInfo.CurrentUICulture), "newName");
            }

            IVsRunningDocumentTable pRDT = site.GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;
            IVsUIShellOpenDocument  doc  = site.GetService(typeof(SVsUIShellOpenDocument)) as IVsUIShellOpenDocument;

            if (pRDT == null || doc == null)
            {
                return;
            }

            IVsHierarchy pIVsHierarchy;
            uint         itemId;
            IntPtr       docData;
            uint         uiVsDocCookie;

            ErrorHandler.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldName, out pIVsHierarchy, out itemId, out docData, out uiVsDocCookie));

            if (docData != IntPtr.Zero)
            {
                try
                {
                    IntPtr pUnk = Marshal.GetIUnknownForObject(pIVsHierarchy);
                    Guid   iid  = typeof(IVsHierarchy).GUID;
                    IntPtr pHier;
                    Marshal.QueryInterface(pUnk, ref iid, out pHier);
                    try
                    {
                        ErrorHandler.ThrowOnFailure(pRDT.RenameDocument(oldName, newName, pHier, newItemId));
                    }
                    catch (Exception)
                    {
                        int i = 0;
                    }
                    finally
                    {
                        if (pHier != IntPtr.Zero)
                        {
                            Marshal.Release(pHier);
                        }
                        if (pUnk != IntPtr.Zero)
                        {
                            Marshal.Release(pUnk);
                        }
                    }
                }
                finally
                {
                    Marshal.Release(docData);
                }
            }
        }
Пример #22
0
        /// <summary>
        /// Rename document in the running document table from oldName to newName.
        /// </summary>
        /// <param name="provider">The service provider.</param>
        /// <param name="oldName">Full path to the old name of the document.</param>
        /// <param name="newName">Full path to the new name of the document.</param>
        /// <param name="newItemId">The new item id of the document</param>
        public static void RenameDocument(IServiceProvider site, string oldName, string newName, uint newItemId)
        {
            Utilities.ArgumentNotNull("site", site);

            if (string.IsNullOrEmpty(oldName))
            {
                throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty), "oldName");
            }

            if (string.IsNullOrEmpty(newName))
            {
                throw new ArgumentException(SR.GetString(SR.ParameterCannotBeNullOrEmpty), "newName");
            }

            if (newItemId == VSConstants.VSITEMID_NIL)
            {
                throw new ArgumentNullException("newItemId");
            }

            var pRDT = site.GetService(typeof(SVsRunningDocumentTable)) as IVsRunningDocumentTable;

            if (pRDT == null)
            {
                return;
            }

            IVsHierarchy pIVsHierarchy;
            uint         itemId;
            IntPtr       docData;
            uint         uiVsDocCookie;

            ErrorHandler.ThrowOnFailure(pRDT.FindAndLockDocument((uint)_VSRDTFLAGS.RDT_NoLock, oldName, out pIVsHierarchy, out itemId, out docData, out uiVsDocCookie));

            if (docData != IntPtr.Zero && pIVsHierarchy != null)
            {
                try
                {
                    var    pUnk = Marshal.GetIUnknownForObject(pIVsHierarchy);
                    var    iid  = typeof(IVsHierarchy).GUID;
                    IntPtr pHier;
                    Marshal.QueryInterface(pUnk, ref iid, out pHier);
                    try
                    {
                        ErrorHandler.ThrowOnFailure(pRDT.RenameDocument(oldName, newName, pHier, newItemId));
                    }
                    finally
                    {
                        if (pHier != IntPtr.Zero)
                        {
                            Marshal.Release(pHier);
                        }
                        if (pUnk != IntPtr.Zero)
                        {
                            Marshal.Release(pUnk);
                        }
                    }
                }
                finally
                {
                    Marshal.Release(docData);
                }
            }
        }
Пример #23
0
        protected virtual int QueryStatusSelection(Guid cmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText, CommandOrigin commandOrigin)
        {
            if (IsClosed)
            {
                return((int)OleConstants.OLECMDERR_E_NOTSUPPORTED);
            }

            if (cmdGroup == Guid.Empty)
            {
                return((int)OleConstants.OLECMDERR_E_UNKNOWNGROUP);
            }

            Utilities.ArgumentNotNull("prgCmds", prgCmds);

            uint cmd = prgCmds[0].cmdID;
            QueryStatusResult queryResult = QueryStatusResult.NOTSUPPORTED;

            // For now ask this node (that is the project node) to disable or enable a node.
            // This is an optimization. Why should we ask each node for its current state? They all are in the same state.
            // Also please note that we return QueryStatusResult.INVISIBLE instead of just QueryStatusResult.SUPPORTED.
            // The reason is that if the project has nested projects, then providing just QueryStatusResult.SUPPORTED is not enough.
            // What will happen is that the nested project will show grayed commands that belong to this project and does not belong to the nested project. (like special commands implemented by subclassed projects).
            // The reason is that a special command comes in that is not handled because we are in debug mode. Then VsCore asks the nested project can you handle it.
            // The nested project does not know about it, thus it shows it on the nested project as grayed.
            if (this.DisableCmdInCurrentMode(cmdGroup, cmd))
            {
                queryResult = QueryStatusResult.SUPPORTED | QueryStatusResult.INVISIBLE;
            }
            else
            {
                bool handled = false;

                if (commandOrigin == CommandOrigin.OleCommandTarget)
                {
                    queryResult = this.QueryStatusCommandFromOleCommandTarget(cmdGroup, cmd, out handled);
                }

                if (!handled)
                {
                    IList <HierarchyNode> selectedNodes = GetSelectedNodes();

                    // Want to disable in multiselect case.
                    if (selectedNodes != null && selectedNodes.Count > 1)
                    {
                        queryResult = this.DisableCommandOnNodesThatDoNotSupportMultiSelection(cmdGroup, cmd, selectedNodes, out handled);
                    }

                    // Now go and do the job on the nodes.
                    if (!handled)
                    {
                        queryResult = this.QueryStatusSelectionOnNodes(selectedNodes, cmdGroup, cmd, pCmdText);
                    }
                }
            }

            // Process the results set in the QueryStatusResult
            if (queryResult != QueryStatusResult.NOTSUPPORTED)
            {
                // Set initial value
                prgCmds[0].cmdf = (uint)OLECMDF.OLECMDF_SUPPORTED;

                if ((queryResult & QueryStatusResult.ENABLED) != 0)
                {
                    prgCmds[0].cmdf |= (uint)OLECMDF.OLECMDF_ENABLED;
                }

                if ((queryResult & QueryStatusResult.INVISIBLE) != 0)
                {
                    prgCmds[0].cmdf |= (uint)OLECMDF.OLECMDF_INVISIBLE;
                }

                if ((queryResult & QueryStatusResult.LATCHED) != 0)
                {
                    prgCmds[0].cmdf |= (uint)OLECMDF.OLECMDF_LATCHED;
                }

                return(VSConstants.S_OK);
            }

            return((int)OleConstants.OLECMDERR_E_NOTSUPPORTED);
        }
Пример #24
0
        public ExtensibilityEventsDispatcher(ProjectNode /*!*/ project)
        {
            Utilities.ArgumentNotNull("project", project);

            this._project = project;
        }
Пример #25
0
        public ExtensibilityEventsDispatcher(ProjectNode project)
        {
            Utilities.ArgumentNotNull(nameof(project), project);

            this._project = project;
        }
Пример #26
0
 /// <summary>
 /// Builds an ImageHandler object from a Stream providing the bitmap that
 /// stores the images for the image list.
 /// </summary>
 public ImageHandler(Stream resourceStream)
 {
     Utilities.ArgumentNotNull(nameof(resourceStream), resourceStream);
     this.imageList = Utilities.GetImageList(resourceStream);
 }