private void CreateModuleTree(LibraryNode root, LibraryNode current, IScopeNode scope, string namePrefix, ModuleId moduleId) { if ((null == root) || (null == scope) || (null == scope.NestedScopes)) { return; } foreach (IScopeNode subItem in scope.NestedScopes) { LibraryNode newNode = CreateLibraryNode(subItem, namePrefix, moduleId.Hierarchy, moduleId.ItemID); string newNamePrefix = namePrefix; // The classes are always added to the root node, the functions to the // current node. if ((newNode.NodeType & LibraryNodeType.Classes) != LibraryNodeType.None) { // Classes are always added to the root. root.AddNode(newNode); newNamePrefix = namePrefix + newNode.Name + "."; } else { current.AddNode(newNode); } // Now use recursion to get the other types. CreateModuleTree(root, newNode, subItem, newNamePrefix, moduleId); } }
public PythonFileLibraryNode(LibraryNode parent, HierarchyNode hierarchy, string name, string filename) : base(parent, name, filename, LibraryNodeType.Namespaces, children: new PythonFileChildren((FileNode)hierarchy)) { _hierarchy = hierarchy; ((PythonFileChildren)Children)._parent = this; }
internal void RemoveNode(LibraryNode node) { lock (this) { _root = _root.Clone(); _root.RemoveNode(node); _updateCount++; } }
internal void AddNode(LibraryNode node) { lock (this) { // re-create root node here because we may have handed out the node before and don't want to mutate it's list. _root = _root.Clone(); _root.AddNode(node); _updateCount++; } }
private static LibraryNodeType GetLibraryNodeType(CompletionResult value, LibraryNode parent) { switch (value.MemberType) { case PythonMemberType.Class: return(LibraryNodeType.Classes); case PythonMemberType.Function: //if (parent is PythonFileLibraryNode) { // return LibraryNodeType.Classes | LibraryNodeType.Members; //} return(LibraryNodeType.Members); default: return(LibraryNodeType.Members); } }
/// <summary> /// Called by derived class when a file has been parsed. The caller should /// provide the LibraryTask received from the OnNewFile call and an IScopeNode /// which represents the contents of the library. /// /// It is safe to call this method from any thread. /// </summary> protected void FileParsed(LibraryTask task, IScopeNode scope) { var project = task.ModuleID.Hierarchy as IProject; HierarchyNode fileNode = null; if (project != null) { fileNode = ((ProjectSmuggler)project.Project).Project.NodeFromItemId(task.ModuleID.ItemID); } LibraryNode module = CreateFileLibraryNode( fileNode, System.IO.Path.GetFileName(task.FileName), task.FileName, LibraryNodeType.PhysicalContainer ); // TODO: Creating the module tree should be done lazily as needed // Currently we replace the entire tree and rely upon the libraries // update count to invalidate the whole thing. We could do this // finer grained and only update the changed nodes. But then we // need to make sure we're not mutating lists which are handed out. CreateModuleTree(module, module, scope, task.FileName + ":", task.ModuleID); if (null != task.ModuleID) { LibraryNode previousItem = null; lock (_files) { if (_files.TryGetValue(task.ModuleID, out previousItem)) { _files.Remove(task.ModuleID); } } _library.RemoveNode(previousItem); } _library.AddNode(module); if (null != task.ModuleID) { lock (_files) { _files.Add(task.ModuleID, module); } } }
public PythonLibraryNode(LibraryNode parent, CompletionResult value, IVsHierarchy hierarchy, uint itemId, IList <LibraryNode> children) : base(parent, value.Name, value.Name, hierarchy, itemId, GetLibraryNodeType(value, parent), children: children) { _value = value; bool hasLocation = false; foreach (var completion in value.Values) { if (completion.locations.MaybeEnumerate().Any()) { hasLocation = true; } } if (hasLocation) { CanGoToSource = true; } }
private void OnDeleteFile(object sender, HierarchyEventArgs args) { IVsHierarchy hierarchy = sender as IVsHierarchy; if (null == hierarchy) { return; } ModuleId id = new ModuleId(hierarchy, args.ItemID); LibraryNode node = null; lock (_files) { if (_files.TryGetValue(id, out node)) { _files.Remove(id); } } if (null != node) { _library.RemoveNode(node); } }
public override LibraryNode CreateFileLibraryNode(LibraryNode parent, HierarchyNode hierarchy, string name, string filename) { return(new PythonFileLibraryNode(parent, hierarchy, hierarchy.Caption, filename)); }
public PythonLibraryNode(LibraryNode parent, IScopeNode scope, string namePrefix, IVsHierarchy hierarchy, uint itemId) : base(parent, scope, namePrefix, hierarchy, itemId) { }
protected override LibraryNode CreateLibraryNode(LibraryNode parent, IScopeNode subItem, string namePrefix, IVsHierarchy hierarchy, uint itemid) { return(new PythonLibraryNode(parent, subItem, namePrefix, hierarchy, itemid)); }
public int GetList2(uint ListType, uint flags, VSOBSEARCHCRITERIA2[] pobSrch, out IVsSimpleObjectList2 ppIVsSimpleObjectList2) { ICustomSearchListProvider listProvider; if (pobSrch != null && pobSrch.Length > 0) { if ((listProvider = pobSrch[0].pIVsNavInfo as ICustomSearchListProvider) != null) { switch ((_LIB_LISTTYPE)ListType) { case _LIB_LISTTYPE.LLT_NAMESPACES: ppIVsSimpleObjectList2 = listProvider.GetSearchList(); break; default: ppIVsSimpleObjectList2 = null; return(VSConstants.E_FAIL); } } else { if (pobSrch[0].eSrchType == VSOBSEARCHTYPE.SO_ENTIREWORD && ListType == (uint)_LIB_LISTTYPE.LLT_MEMBERS) { string srchText = pobSrch[0].szName; int colonIndex; if ((colonIndex = srchText.LastIndexOf(':')) != -1) { string filename = srchText.Substring(0, srchText.LastIndexOf(':')); foreach (var item in _root.Children) { if (item.FullName == filename) { ppIVsSimpleObjectList2 = item.DoSearch(pobSrch[0]); if (ppIVsSimpleObjectList2 != null) { return(VSConstants.S_OK); } } } } ppIVsSimpleObjectList2 = null; return(VSConstants.E_FAIL); } else if (pobSrch[0].eSrchType == VSOBSEARCHTYPE.SO_SUBSTRING && ListType == (uint)_LIB_LISTTYPE.LLT_NAMESPACES) { var lib = new LibraryNode("Search results " + pobSrch[0].szName, "Search results " + pobSrch[0].szName, LibraryNodeType.Package); foreach (var item in SearchNodes(pobSrch[0], new SimpleObjectList <LibraryNode>(), _root).Children) { lib.Children.Add(item); } ppIVsSimpleObjectList2 = lib; return(VSConstants.S_OK); } else { ppIVsSimpleObjectList2 = null; return(VSConstants.E_FAIL); } } } else { ppIVsSimpleObjectList2 = _root as IVsSimpleObjectList2; } return(VSConstants.S_OK); }
public Library(Guid libraryGuid) { _guid = libraryGuid; _root = new LibraryNode(String.Empty, String.Empty, LibraryNodeType.Package); }
private static SimpleObjectList <LibraryNode> SearchNodes(VSOBSEARCHCRITERIA2 srch, SimpleObjectList <LibraryNode> list, LibraryNode curNode) { foreach (var child in curNode.Children) { if (child.Name.IndexOf(srch.szName, StringComparison.OrdinalIgnoreCase) != -1) { list.Children.Add(child.Clone(child.Name)); } SearchNodes(srch, list, child); } return(list); }
public PythonFileLibraryNode(LibraryNode parent, HierarchyNode hierarchy, string name, string filename, LibraryNodeType libraryNodeType) : base(parent, name, filename, libraryNodeType) { _hierarchy = hierarchy; }