internal void SetActiveSession(SessionNode node) { uint oldItem = _activeSession; if (oldItem != VSConstants.VSITEMID_NIL) { _window.ExpandItem(this, _activeSession, EXPANDFLAGS.EXPF_UnBoldItem); } _activeSession = node.ItemId; _window.ExpandItem(this, _activeSession, EXPANDFLAGS.EXPF_BoldItem); }
public override int OnAfterOpenProject(IVsHierarchy hierarchy, int added) { // If this is our project, notify it that it has been opened. if (hierarchy.GetProject() != null) { var oaProject = hierarchy.GetProject() as OAProject; if (oaProject != null && oaProject.Project is ProjectNode) { ((ProjectNode)oaProject.Project).OnAfterProjectOpen(); } } // If this is a new project and our project. We use here that it is only our project that will implemnet the "internal" IBuildDependencyOnProjectContainer. if (added != 0 && hierarchy is IBuildDependencyUpdate) { IVsUIHierarchy uiHierarchy = hierarchy as IVsUIHierarchy; Debug.Assert(uiHierarchy != null, "The ProjectNode should implement IVsUIHierarchy"); if (uiHierarchy == null) { return(VSConstants.E_FAIL); } // Expand and select project node IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ServiceProvider, HierarchyNode.SolutionExplorer); if (uiWindow != null) { __VSHIERARCHYITEMSTATE state; uint stateAsInt; if (uiWindow.GetItemState(uiHierarchy, VSConstants.VSITEMID_ROOT, (uint)__VSHIERARCHYITEMSTATE.HIS_Expanded, out stateAsInt) == VSConstants.S_OK) { state = (__VSHIERARCHYITEMSTATE)stateAsInt; if (state != __VSHIERARCHYITEMSTATE.HIS_Expanded) { int hr; hr = uiWindow.ExpandItem(uiHierarchy, VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_ExpandParentsToShowItem); if (ErrorHandler.Failed(hr)) { Trace.WriteLine("Failed to expand project node"); } hr = uiWindow.ExpandItem(uiHierarchy, VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_SelectItem); if (ErrorHandler.Failed(hr)) { Trace.WriteLine("Failed to select project node"); } return(hr); } } } } return(VSConstants.S_OK); }
internal void SetActiveSession(SessionNode node) { int oldItem = _activeSession; if (oldItem != -1) { _window.ExpandItem(this, (uint)_activeSession, EXPANDFLAGS.EXPF_UnBoldItem); } _activeSession = _sessions.IndexOf(node); Debug.Assert(_activeSession != -1); _window.ExpandItem(this, (uint)_activeSession, EXPANDFLAGS.EXPF_BoldItem); }
/// <summary> /// Sets the expanded state of the folder. /// </summary> /// <param name="expanded">Flag that indicates the expanded state of the folder. /// This should be 'true' for expanded and 'false' for collapsed state.</param> protected void SetExpanded(bool expanded) { IsExpanded = expanded; SetProperty((int)__VSHPROPID.VSHPROPID_Expanded, expanded); // If we are in automation mode then skip the ui part if (Utilities.IsInAutomationFunction(ProjectMgr.Site)) { return; } IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(ProjectMgr.Site, SolutionExplorer); int result = uiWindow.ExpandItem(ProjectMgr, ID, expanded ? EXPANDFLAGS.EXPF_ExpandFolder : EXPANDFLAGS.EXPF_CollapseFolder); ErrorHandler.ThrowOnFailure(result); // then post the expand command to the shell. Folder verification and creation will // happen in the setlabel code... IVsUIShell shell = (IVsUIShell)ProjectMgr.GetService(typeof(IVsUIShell)); object dummy = null; Guid cmdGroup = VsMenus.guidStandardCommandSet97; result = shell.PostExecCommand(ref cmdGroup, (uint)(expanded ? VsCommands.Expand : VsCommands.Collapse), 0, ref dummy); ErrorHandler.ThrowOnFailure(result); }
/// <summary> /// Expands the view of Solution Explorer to show project items. /// </summary> public virtual void ExpandView() { if (this.node == null || this.node.ProjectMgr == null || this.node.ProjectMgr.IsClosed || this.node.ProjectMgr.Site == null) { throw new InvalidOperationException(); } UIThread.DoOnUIThread(delegate() { IVsExtensibility3 extensibility = this.Node.ProjectMgr.Site.GetService(typeof(IVsExtensibility)) as IVsExtensibility3; if (extensibility == null) { throw new InvalidOperationException(); } extensibility.EnterAutomationFunction(); try { IVsUIHierarchyWindow uiHierarchy = UIHierarchyUtilities.GetUIHierarchyWindow(this.node.ProjectMgr.Site, HierarchyNode.SolutionExplorer); if (uiHierarchy == null) { throw new InvalidOperationException(); } uiHierarchy.ExpandItem(node.ProjectMgr.InteropSafeIVsUIHierarchy, this.node.ID, EXPANDFLAGS.EXPF_ExpandFolder); } finally { extensibility.ExitAutomationFunction(); } }); }
private void RenameFolder(string newName) { // Do the rename (note that we only do the physical rename if the leaf name changed) string newPath = Path.Combine(this.Parent.VirtualNodeName, newName); if (String.Compare(Path.GetFileName(VirtualNodeName), newName, StringComparison.Ordinal) != 0) { this.RenameDirectory(Path.Combine(this.ProjectMgr.ProjectFolder, newPath)); } this.VirtualNodeName = newPath; this.ItemNode.Rename(VirtualNodeName); // Let all children know of the new path for (HierarchyNode child = this.FirstChild; child != null; child = child.NextSibling) { if (!(child is FolderNode)) { child.SetEditLabel(child.Caption); } else { FolderNode childFolderNode = (FolderNode)child; childFolderNode.RenameFolder(childFolderNode.Caption); } } // Some of the previous operation may have changed the selection so set it back to us IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectMgr.Site, SolutionExplorer); ErrorHandler.ThrowOnFailure(uiWindow.ExpandItem(this.ProjectMgr, this.ID, EXPANDFLAGS.EXPF_SelectItem)); }
/// <summary> /// Renames the file node for a case only change. /// </summary> /// <param name="newFileName">The new file name.</param> private void RenameCaseOnlyChange(string newFileName) { //Update the include for this item. string include = this.ItemNode.Item.UnevaluatedInclude; if (String.Compare(include, newFileName, StringComparison.OrdinalIgnoreCase) == 0) { this.ItemNode.Item.Xml.Include = newFileName; } else { string includeDir = Path.GetDirectoryName(include); this.ItemNode.Item.Xml.Include = Path.Combine(includeDir, newFileName); } this.ItemNode.RefreshProperties(); this.ReDraw(UIHierarchyElement.Caption); this.RenameChildNodes(this); // Refresh the property browser. IVsUIShell shell = this.ProjectMgr.Site.GetService(typeof(SVsUIShell)) as IVsUIShell; Debug.Assert(shell != null, "Could not get the ui shell from the project"); if (shell == null) { throw new InvalidOperationException(); } shell.RefreshPropertyBrowser(0); //Select the new node in the hierarchy IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectMgr.Site, SolutionExplorer); uiWindow.ExpandItem(this.ProjectMgr.InteropSafeIVsUIHierarchy, this.ID, EXPANDFLAGS.EXPF_SelectItem); }
public override int OnAfterOpenProject(IVsHierarchy hierarchy, int added) { // If this is a new project and our project. We use here that it is only our project that will implement the "internal" IBuildDependencyOnProjectContainer. ThreadHelper.ThrowIfNotOnUIThread(); if (added != 0 && hierarchy is IBuildDependencyUpdate) { IVsUIHierarchy uiHierarchy = hierarchy as IVsUIHierarchy; Debug.Assert(uiHierarchy != null, "The ProjectNode should implement IVsUIHierarchy"); if (uiHierarchy == null) { return(VSConstants.E_FAIL); } // Expand and select project node IServiceProvider provider = (IServiceProvider)this.ServiceProvider; IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(provider, HierarchyNode.SolutionExplorer); if (uiWindow != null) { __VSHIERARCHYITEMSTATE state; uint stateAsInt; if (uiWindow.GetItemState(uiHierarchy, VSConstants.VSITEMID_ROOT, (uint)__VSHIERARCHYITEMSTATE.HIS_Expanded, out stateAsInt) == VSConstants.S_OK) { state = (__VSHIERARCHYITEMSTATE)stateAsInt; if (state != __VSHIERARCHYITEMSTATE.HIS_Expanded) { int hr; hr = uiWindow.ExpandItem(uiHierarchy, VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_ExpandParentsToShowItem); if (ErrorHandler.Failed(hr)) { XSettings.LogMessage("Failed to expand project node"); } hr = uiWindow.ExpandItem(uiHierarchy, VSConstants.VSITEMID_ROOT, EXPANDFLAGS.EXPF_SelectItem); if (ErrorHandler.Failed(hr)) { XSettings.LogMessage("Failed to select project node"); } return(hr); } } } } return(VSConstants.S_OK); }
/// <summary> /// After a drop or paste, will use the dwEffects /// to determine whether we need to clean up the source nodes or not. If /// justCleanup is set, it only does the cleanup work. /// </summary> internal void CleanupSelectionDataObject(bool dropped, bool cut, bool moved, bool justCleanup) { if (this.ItemsDraggedOrCutOrCopied == null || this.ItemsDraggedOrCutOrCopied.Count == 0) { return; } try { IVsUIHierarchyWindow w = UIHierarchyUtilities.GetUIHierarchyWindow(this.site, HierarchyNode.SolutionExplorer); foreach (HierarchyNode node in this.ItemsDraggedOrCutOrCopied) { if ((moved && (cut || dropped) && !justCleanup)) { // do not close it if the doc is dirty or we do not own it bool isDirty, isOpen, isOpenedByUs; uint docCookie; IVsPersistDocData ppIVsPersistDocData; DocumentManager manager = node.GetDocumentManager(); if (manager != null) { manager.GetDocInfo(out isOpen, out isDirty, out isOpenedByUs, out docCookie, out ppIVsPersistDocData); if (isDirty || (isOpen && !isOpenedByUs)) { continue; } // close it if opened if (isOpen) { manager.Close(__FRAMECLOSE.FRAMECLOSE_NoSave); } } node.Remove(true); } else if (w != null) { ErrorHandler.ThrowOnFailure(w.ExpandItem((IVsUIHierarchy)this, node.ID, EXPANDFLAGS.EXPF_UnCutHighlightItem)); } } } finally { // Now delete the memory allocated by the packaging of datasources. // If we just did a cut, or we are told to cleanup, then we need to free the data object. Otherwise, we leave it // alone so that you can continue to paste the data in new locations. if (moved || cut || justCleanup) { this.ItemsDraggedOrCutOrCopied.Clear(); this.CleanAndFlushClipboard(); } this.dataObject = null; this.dropDataType = DropDataType.None; } }
private static void CollapseVsHierarchyItem(VsHierarchyItem vsHierarchyItem, IVsUIHierarchyWindow vsHierarchyWindow) { if (vsHierarchyItem == null || vsHierarchyWindow == null) { return; } vsHierarchyWindow.ExpandItem(vsHierarchyItem.UIHierarchy(), vsHierarchyItem.VsItemID, EXPANDFLAGS.EXPF_CollapseFolder); }
/// <summary> /// Makes sure the node is visible in the Solution Explorer by expanding all of it's parents. /// </summary> public void EnsureVisible() { // Get the Solution Explorer window. IVsUIHierarchyWindow solutionExplorer = Package.Instance.Context.SolutionExplorer; // Make sure the node is visible by expanding all of its parents. EXPANDFLAGS flags = EXPANDFLAGS.EXPF_ExpandParentsToShowItem; NativeMethods.ThrowOnFailure(solutionExplorer.ExpandItem(this.Hierarchy, this.HierarchyId, flags)); }
/// <summary> /// Expands the current node. /// </summary> public void Expand() { // Get the Solution Explorer window. IVsUIHierarchyWindow solutionExplorer = Package.Instance.Context.SolutionExplorer; // Expand or collapse the node in the Solution Explorer. EXPANDFLAGS flags = EXPANDFLAGS.EXPF_ExpandFolder; NativeMethods.ThrowOnFailure(solutionExplorer.ExpandItem(this.Hierarchy, this.HierarchyId, flags)); }
/// <summary> /// Performs the EXPANDFLAGS action on a node with nodeID. /// </summary> internal static void ManipulateNode(ProjectNode project, uint nodeID, EXPANDFLAGS flag) { IVsUIHierarchyWindow uiHierarchy = VsShellUtilities.GetUIHierarchyWindow(project.Site, HierarchyNode.SolutionExplorer); if (uiHierarchy == null) { return; } uiHierarchy.ExpandItem(project, nodeID, flag); }
private static void CollapseVsHierarchyItem(VsHierarchyItem vsHierarchyItem, IVsUIHierarchyWindow vsHierarchyWindow) { ThreadHelper.ThrowIfNotOnUIThread(); if (vsHierarchyItem == null || vsHierarchyWindow == null) { return; } vsHierarchyWindow.ExpandItem(AsVsUIHierarchy(vsHierarchyItem), vsHierarchyItem.VsItemID, EXPANDFLAGS.EXPF_CollapseFolder); }
private static void CollapseVsHierarchyItem(VsHierarchyItem vsHierarchyItem, IVsUIHierarchyWindow vsHierarchyWindow) { Debug.Assert(ThreadHelper.CheckAccess()); if (vsHierarchyItem == null || vsHierarchyWindow == null) { return; } vsHierarchyWindow.ExpandItem(vsHierarchyItem.UIHierarchy(), vsHierarchyItem.VsItemID, EXPANDFLAGS.EXPF_CollapseFolder); }
/// <summary> /// Expands the view of Solution Explorer to show project items. /// </summary> public virtual void ExpandView() { CheckProjectIsValid(); using (AutomationScope scope = new AutomationScope(this.Node.ProjectMgr.Site)) { IVsUIHierarchyWindow uiHierarchy = UIHierarchyUtilities.GetUIHierarchyWindow(this.node.ProjectMgr.Site, HierarchyNode.SolutionExplorer); Utilities.CheckNotNull(uiHierarchy); ErrorHandler.ThrowOnFailure(uiHierarchy.ExpandItem(this.node.ProjectMgr, this.node.ID, EXPANDFLAGS.EXPF_ExpandFolder)); } }
private static async Task CollapseVsHierarchyItemAsync(VsHierarchyItem vsHierarchyItem, IVsUIHierarchyWindow vsHierarchyWindow) { if (vsHierarchyItem == null || vsHierarchyWindow == null) { return; } await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); vsHierarchyWindow.ExpandItem(AsVsUIHierarchy(vsHierarchyItem), vsHierarchyItem.VsItemID, EXPANDFLAGS.EXPF_CollapseFolder); }
private void RenameFolder(string newName) { string newPath = Path.Combine(this.Parent.VirtualNodeName, newName); string newFullPath = Path.Combine(this.ProjectMgr.ProjectFolder, newPath); // Only do the physical rename if the leaf name changed if (String.Compare(Path.GetFileName(VirtualNodeName), newName, StringComparison.Ordinal) != 0) { // Verify that no directory/file already exists with the new name on disk. // If it does, just subsume that name if our directory is empty. if (Directory.Exists(newFullPath) || FSLib.Shim.FileSystem.SafeExists(newFullPath)) { // We can't delete our old directory as it is not empty if (Directory.EnumerateFileSystemEntries(this.Url).Any()) { ShowErrorMessage(SR.FolderCannotBeRenamed, newPath); return; } // Try to delete the old (empty) directory. // Note that we don't want to delete recursively in case a file was added between // when we checked and when we went to delete (potential race condition). Directory.Delete(this.Url, false); } else { this.RenameDirectory(newFullPath); } } this.VirtualNodeName = newPath; this.ItemNode.Rename(VirtualNodeName); // Let all children know of the new path for (HierarchyNode child = this.FirstChild; child != null; child = child.NextSibling) { if (!(child is FolderNode)) { child.SetEditLabel(child.Caption); } else { FolderNode childFolderNode = (FolderNode)child; childFolderNode.RenameFolder(childFolderNode.Caption); } } // Some of the previous operation may have changed the selection so set it back to us IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectMgr.Site, SolutionExplorer); ErrorHandler.ThrowOnFailure(uiWindow.ExpandItem(this.ProjectMgr.InteropSafeIVsUIHierarchy, this.ID, EXPANDFLAGS.EXPF_SelectItem)); }
// -------------------------------------------------------------------------------------------- /// <summary> /// Expands the specified hierarchy item. /// </summary> /// <param name="window">The hierarchy window hosting the item.</param> /// <param name="node">The hierarchy of the node to expand.</param> /// <param name="id">The id of the node.</param> /// <param name="flags">Flags specifying how to expand the node.</param> // -------------------------------------------------------------------------------------------- private static void ExpandItem(IVsUIHierarchyWindow window, IVsUIHierarchy node, uint id, EXPANDFLAGS flags) { if (window == null) { return; } if (node == null) { throw new ArgumentNullException("node"); } ErrorHandler.ThrowOnFailure(window.ExpandItem(node, id, flags)); }
private void CollapseHierarchyItems(IVsUIHierarchyWindow toolWindow, IVsHierarchy hierarchy, uint itemid, bool hierIsSolution , string[] captions) { IntPtr ptr; uint num2; Guid gUID = typeof(IVsHierarchy).GUID; if ((hierarchy.GetNestedHierarchy(itemid, ref gUID, out ptr, out num2) == 0) && (IntPtr.Zero != ptr)) { IVsHierarchy objectForIUnknown = Marshal.GetObjectForIUnknown(ptr) as IVsHierarchy; Marshal.Release(ptr); if (objectForIUnknown != null) { this.CollapseHierarchyItems(toolWindow, objectForIUnknown, num2, false, captions); } } else { object obj2; if (!hierIsSolution) { string canonicalname; object captionobj; hierarchy.GetProperty(itemid, (int)__VSHPROPID.VSHPROPID_Caption, out captionobj); var caption = (string)captionobj; if (captions.Contains(caption)) { hierarchy.GetCanonicalName(itemid, out canonicalname); ErrorHandler.ThrowOnFailure(toolWindow.ExpandItem(hierarchy as IVsUIHierarchy, itemid, EXPANDFLAGS.EXPF_CollapseFolder)); } } if (hierarchy.GetProperty(itemid, (int)__VSHPROPID.VSHPROPID_FirstVisibleChild, out obj2) == 0) { uint itemId = this.GetItemId(obj2); while (itemId != uint.MaxValue) { this.CollapseHierarchyItems(toolWindow, hierarchy, itemId, false, captions); int hr = hierarchy.GetProperty(itemId, (int)__VSHPROPID.VSHPROPID_NextVisibleSibling, out obj2); if (hr == 0) { itemId = this.GetItemId(obj2); } else { ErrorHandler.ThrowOnFailure(hr); return; } } } } }
/// <summary> /// Refreshes the solution explorer tree /// </summary> /// <param name="nodes">A list of nodes which were originally selected</param> /// <remarks> /// Refreshing the tree cancels the selection, the nodes list is used to restore the /// selection. The items on the list could have been changed/ recreated as a side /// effect of the operation, so the list of the nodes is re-mapped /// </remarks> public void RefreshSolutionExplorer(IEnumerable <ItemNode> nodes) { projectProxy.RefreshSolutionExplorer(); bool first = true; IVsUIHierarchyWindow explorer = GlobalServices.SolutionExplorer; if (explorer != null) { foreach (var node in itemList.RemapNodes(nodes)) { if (first) { explorer.ExpandItem(this, node.ItemId, EXPANDFLAGS.EXPF_SelectItem); first = false; } else { explorer.ExpandItem(this, node.ItemId, EXPANDFLAGS.EXPF_AddSelectItem); } } } }
/// <summary> /// Called by the shell when a node has been renamed from the GUI /// </summary> /// <param name="label"></param> /// <returns>E_NOTIMPL</returns> public override int SetEditLabel(string label) { HierarchyNode thisParentNode = this.Parent; this.ReferencedProjectName = label; this.OnInvalidateItems(thisParentNode); // select the reference node again IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectMgr.Site, SolutionExplorer); uiWindow.ExpandItem(this.ProjectMgr, this.ID, EXPANDFLAGS.EXPF_SelectItem); return(VSConstants.S_OK); }
/// <summary> /// Expands the view of Solution Explorer to show project items. /// </summary> public virtual void ExpandView() { CheckProjectIsValid(); ThreadHelper.JoinableTaskFactory.Run(async delegate { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); using (new AutomationScope(this.Node.ProjectMgr.Site)) { IVsUIHierarchyWindow uiHierarchy = UIHierarchyUtilities.GetUIHierarchyWindow(this.node.ProjectMgr.Site, HierarchyNode.SolutionExplorer); ErrorHandler.ThrowOnFailure(uiHierarchy.ExpandItem(this.node.ProjectMgr, this.node.ID, EXPANDFLAGS.EXPF_ExpandFolder)); } }); }
/// <summary> /// Tells the Solution Explorer to allow the user to start editing the node. /// </summary> public void StartNodeEdit() { // Get the Solution Explorer window. IVsUIHierarchyWindow solutionExplorer = Package.Instance.Context.SolutionExplorer; // Once we have the new name, we'll go into edit label mode on the node. Checks for // validity will happen in the SetCaption method. // First make sure the node is visible. this.EnsureVisible(); // Select the node in the Solution Explorer. this.Select(); // Edit the node's caption. NativeMethods.ThrowOnFailure(solutionExplorer.ExpandItem(this.Hierarchy, this.HierarchyId, EXPANDFLAGS.EXPF_EditItemLabel)); }
private void RenameFolder(string newName) { // Do the rename (note that we only do the physical rename if the leaf name changed) string newPath = Path.Combine(this.Parent.VirtualNodeName, newName); if (String.Compare(Path.GetFileName(VirtualNodeName), newName, StringComparison.Ordinal) != 0) { this.RenameDirectory(Path.Combine(this.ProjectMgr.ProjectFolder, newPath)); } this.VirtualNodeName = newPath; this.ItemNode.Rename(VirtualNodeName); ThreadHelper.ThrowIfNotOnUIThread(); // Let all children know of the new path for (HierarchyNode child = this.FirstChild; child != null; child = child.NextSibling) { FileNode childFileNode = child as FileNode; if (childFileNode != null && childFileNode.IsLink) { string linkPath = Path.Combine(newPath, child.Caption); childFileNode.RenameFileNode(child.Url, child.Url, linkPath, this.ID); } else if (!(child is FolderNode)) { child.SetEditLabel(child.Caption); } else { FolderNode childFolderNode = (FolderNode)child; childFolderNode.RenameFolder(childFolderNode.Caption); } } // Some of the previous operation may have changed the selection so set it back to us IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectMgr.Site, SolutionExplorer); // This happens in the context of renaming a folder. // Since we are already in solution explorer, it is extremely unlikely that we get a null return. // If we do, the consequences are minimal: the parent node will be selected instead of the // renamed node. if (uiWindow != null) { ErrorHandler.ThrowOnFailure(uiWindow.ExpandItem(this.ProjectMgr, this.ID, EXPANDFLAGS.EXPF_SelectItem)); } }
/// <summary> /// Expands the view of Solution Explorer to show project items. /// </summary> public virtual void ExpandView() { if (this.node == null || this.node.ProjectMgr == null || this.node.ProjectMgr.IsClosed || this.node.ProjectMgr.Site == null) { throw new InvalidOperationException(); } using (AutomationScope scope = new AutomationScope(this.Node.ProjectMgr.Site)) { IVsUIHierarchyWindow uiHierarchy = UIHierarchyUtilities.GetUIHierarchyWindow(this.node.ProjectMgr.Site, HierarchyNode.SolutionExplorer); if (uiHierarchy == null) { throw new InvalidOperationException(); } ErrorHandler.ThrowOnFailure(uiHierarchy.ExpandItem(this.node.ProjectMgr, this.node.ID, EXPANDFLAGS.EXPF_ExpandFolder)); } }
/// <summary> /// Expands the view of Solution Explorer to show project items. /// </summary> public virtual void ExpandView() { CheckProjectIsValid(); UIThread.DoOnUIThread(delegate() { using (AutomationScope scope = new AutomationScope(this.Node.ProjectMgr.Site)) { IVsUIHierarchyWindow uiHierarchy = UIHierarchyUtilities.GetUIHierarchyWindow(this.node.ProjectMgr.Site, HierarchyNode.SolutionExplorer); if (uiHierarchy == null) { throw new InvalidOperationException(); } ErrorHandler.ThrowOnFailure(uiHierarchy.ExpandItem(this.node.ProjectMgr, this.node.ID, EXPANDFLAGS.EXPF_ExpandFolder)); } }); }
protected virtual void RenameFolder(string newName) { // Do the rename (note that we only do the physical rename if the leaf name changed) string newPath = Path.Combine(this.Parent.VirtualNodeName, newName); if (!String.Equals(Path.GetFileName(VirtualNodeName), newName, StringComparison.Ordinal)) { this.RenameDirectory(Path.Combine(this.ProjectManager.ProjectFolder, newPath)); } this.VirtualNodeName = newPath; this.ItemNode.Rename(VirtualNodeName); // Let all children know of the new path for (HierarchyNode child = this.FirstChild; child != null; child = child.NextSibling) { FolderNode node = child as FolderNode; if (node == null) { child.SetEditLabel(child.Caption); } else { node.RenameFolder(node.Caption); } } // Some of the previous operation may have changed the selection so set it back to us IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectManager.Site, SolutionExplorer); // This happens in the context of renaming a folder. // Since we are already in solution explorer, it is extremely unlikely that we get a null return. // If we do, the consequences are minimal: the parent node will be selected instead of the // renamed node. if (uiWindow != null) { ErrorHandler.ThrowOnFailure(uiWindow.ExpandItem(this.ProjectManager.InteropSafeIVsUIHierarchy, this.Id, EXPANDFLAGS.EXPF_SelectItem)); } ProjectManager.ItemIdMap.UpdateCanonicalName(this); }
/// <summary> /// Selects all nodes of type T in the project. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="project"></param> /// <returns>The id's of the selected nodes.</returns> internal static T SelectAnyNodeOfType <T>(ProjectNode project) where T : HierarchyNode { IVsUIHierarchyWindow uiHierarchy = VsShellUtilities.GetUIHierarchyWindow(project.Site, HierarchyNode.SolutionExplorer); if (uiHierarchy == null) { return(null); } List <T> nodes = GetNodesOfType <T>(project); if (nodes.Count > 0) { uiHierarchy.ExpandItem(project, nodes[0].Id, EXPANDFLAGS.EXPF_SelectItem); return(nodes[0]); } return(null); }
/// <summary> /// Renames the file node for a case only change. /// </summary> /// <param name="newFileName">The new file name.</param> private void RenameCaseOnlyChange(string newFileName) { //Update the include for this item. string include = this.ItemNode.Item.EvaluatedInclude; if (String.Compare(include, newFileName, StringComparison.OrdinalIgnoreCase) == 0) { this.ItemNode.Item.Xml.Include = newFileName; } else { string includeDir = Path.GetDirectoryName(include); this.ItemNode.Item.Xml.Include = Path.Combine(includeDir, newFileName); } this.ItemNode.RefreshProperties(); this.ReDraw(UIHierarchyElement.Caption); this.RenameChildNodes(this); // Refresh the property browser. IVsUIShell shell = this.ProjectMgr.Site.GetService(typeof(SVsUIShell)) as IVsUIShell; Debug.Assert(shell != null, "Could not get the ui shell from the project"); if (shell == null) { throw new InvalidOperationException(); } ErrorHandler.ThrowOnFailure(shell.RefreshPropertyBrowser(0)); //Select the new node in the hierarchy IVsUIHierarchyWindow uiWindow = UIHierarchyUtilities.GetUIHierarchyWindow(this.ProjectMgr.Site, SolutionExplorer); // This happens in the context of renaming a file by case only (Table.sql -> table.sql) // Since we are already in solution explorer, it is extremely unlikely that we get a null return. if (uiWindow != null) { ErrorHandler.ThrowOnFailure(uiWindow.ExpandItem(this.ProjectMgr, this.ID, EXPANDFLAGS.EXPF_SelectItem)); } }
// -------------------------------------------------------------------------------------------- /// <summary> /// Expands the specified hierarchy item. /// </summary> /// <param name="window">The hierarchy window hosting the item.</param> /// <param name="node">The hierarchy of the node to expand.</param> /// <param name="id">The id of the node.</param> /// <param name="flags">Flags specifying how to expand the node.</param> // -------------------------------------------------------------------------------------------- private static void ExpandItem(IVsUIHierarchyWindow window, IVsUIHierarchy node, uint id, EXPANDFLAGS flags) { if (window == null) return; if (node == null) throw new ArgumentNullException("node"); ErrorHandler.ThrowOnFailure(window.ExpandItem(node, id, flags)); }