private void CreateMembersTree(LibraryNode current, XTypeDefinition scope, XSharpModuleId moduleId) { if (null == scope || XSolution.IsClosing) { return; } foreach (XMemberDefinition member in scope.Members) { XSharpLibraryNode newNode = new XSharpLibraryNode(member, "", moduleId.Hierarchy, moduleId.ItemID); // The classes are always added to the root node, the functions to the // current node. if ((newNode.NodeType & LibraryNode.LibraryNodeType.Members) != LibraryNode.LibraryNodeType.None) { current.AddNode(newNode); newNode.parent = current; lock (files) { files.Add(moduleId, newNode); } } } }
internal void AddNode(LibraryNode node) { lock (this) { root.AddNode(node); } }
protected IVsSimpleObjectList2 FilterView(LibraryNodeType filterType) { return(ThreadHelper.JoinableTaskFactory.Run(async delegate { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); LibraryNode filtered = null; if (filteredView.TryGetValue(filterType, out filtered)) { return filtered as IVsSimpleObjectList2; } filtered = this.Clone(); for (int i = 0; i < filtered.children.Count;) { if (0 == (filtered.children[i].type & filterType)) { filtered.children.RemoveAt(i); } else { i += 1; } } filteredView.Add(filterType, filtered); return filtered as IVsSimpleObjectList2; })); }
internal void RemoveNode(LibraryNode node) { lock (this) { //root = new LibraryNode(root); root.RemoveNode(node); } }
internal void RemoveNode(LibraryNode node) { lock (children) { children.Remove(node); } filteredView = new Dictionary <LibraryNodeType, LibraryNode>(); updateCount += 1; }
/// <summary> /// Search the Childrens of the currentRoot, to see if some are containing strSearchCriteria. /// If the Children has some childrens..., then call FillRoot recursively. /// </summary> /// <param name="tmpRoot">The current upper level, where corresponding Childrens must be added</param> /// <param name="elementTypes">What kind of Children are we looking for</param> /// <param name="strSearchCriteria">What are we looking for</param> /// <param name="currentRoot">The node to look after</param> private void FillRoot(LibraryNode tmpRoot, List <LibraryNode.LibraryNodeType> elementTypes, string strSearchCriteria, LibraryNode currentRoot) { foreach (LibraryNode node in currentRoot.children) { if (elementTypes.Contains(node.NodeType) && node.Name.ToLower().Contains(strSearchCriteria.ToLower())) { tmpRoot.children.Add(node.Clone()); } if (node.children.Count > 0) { FillRoot(tmpRoot, elementTypes, strSearchCriteria, node); } } }
public LibraryNode SearchNameSpace(string nsName) { LibraryNode result = null; // result = children.Find( delegate(LibraryNode nd) { return(String.Compare(nd.Name, nsName) == 0); } ); // return(result); }
/// <summary> /// Search for a class, whose Fully Qualified Name is known /// </summary> /// <param name="fqName">The Fully Qualified Name class to search for</param> /// <returns></returns> public LibraryNode SearchClass(string fqName) { LibraryNode result = null; // result = children.Find( delegate(LibraryNode nd) { return((String.Compare(nd.Name, fqName) == 0) && ((nd.NodeType & LibraryNode.LibraryNodeType.Classes) != LibraryNode.LibraryNodeType.None)); } ); // return(result); }
public LibraryNode SearchNameSpace(string nsName) { LibraryNode result = null; // result = children.Find( delegate(LibraryNode nd) { return((String.Compare(nd.Name, nsName, true) == 0) && ((nd.NodeType & LibraryNode.LibraryNodeType.Namespaces) != LibraryNode.LibraryNodeType.None)); } ); // return(result); }
private void CreateGlobalTree(LibraryNode globalScope, IList <XMemberDefinition> XMembers, XSharpModuleId moduleId) { if (XSolution.IsClosing) { return; } foreach (XMemberDefinition member in XMembers) { XSharpLibraryNode newNode = new XSharpLibraryNode(member, "", moduleId.Hierarchy, moduleId.ItemID); // Functions ? if ((newNode.NodeType & LibraryNode.LibraryNodeType.Members) != LibraryNode.LibraryNodeType.None) { globalScope.AddNode(newNode); newNode.parent = globalScope; lock (files) { files.Add(moduleId, newNode); } } } }
public LibraryNode(LibraryNode node) { this.capabilities = node.capabilities; this.contextMenuID = node.contextMenuID; this.displayData = node.displayData; this.name = node.name; this.tooltip = node.tooltip; this.type = node.type; this.children = new List <LibraryNode>(); foreach (LibraryNode child in node.children) { children.Add(child); } this.clipboardFormats = new List <VSOBJCLIPFORMAT>(); foreach (VSOBJCLIPFORMAT format in node.clipboardFormats) { clipboardFormats.Add(format); } this.filteredView = new Dictionary <LibraryNodeType, LibraryNode>(); this.updateCount = node.updateCount; }
private void CreateGlobalTree(LibraryNode current, XTypeDefinition scope, XSharpModuleId moduleId) { if (null == scope || XSolution.IsClosing) { return; } foreach (XMemberDefinition member in scope.XMembers) { XSharpLibraryNode newNode = new XSharpLibraryNode(member, "", moduleId.Hierarchy, moduleId.ItemID); // Functions ? if ((newNode.NodeType & LibraryNode.LibraryNodeType.Members) != LibraryNode.LibraryNodeType.None) { current.AddNode(newNode); newNode.parent = current; lock (files) { files.Add(moduleId, newNode); } } } }
internal LibraryNode SearchHierarchy(IVsHierarchy hierarchy) { LibraryNode found = null; lock (this) { foreach (LibraryNode nd in root.children) { if (nd is XSharpLibraryNode) { XSharpLibraryNode vln = (XSharpLibraryNode)nd; if (hierarchy.Equals(vln.ownerHierarchy)) { found = nd; break; } } } } return(found); }
protected IVsSimpleObjectList2 FilterView(LibraryNodeType filterType) { LibraryNode filtered = null; if (filteredView.TryGetValue(filterType, out filtered)) { return(filtered as IVsSimpleObjectList2); } filtered = this.Clone(); for (int i = 0; i < filtered.children.Count;) { if (0 == (filtered.children[i].type & filterType)) { filtered.children.RemoveAt(i); } else { i += 1; } } filteredView.Add(filterType, filtered); return(filtered as IVsSimpleObjectList2); }
private LibraryNode SearchNodes(uint elementType, string strSearchCriteria) { List <LibraryNode.LibraryNodeType> nType = new List <LibraryNode.LibraryNodeType>(); if (elementType == (uint)_LIB_LISTTYPE.LLT_HIERARCHY) { nType.Add(LibraryNode.LibraryNodeType.Hierarchy); } else if (elementType == (uint)_LIB_LISTTYPE.LLT_NAMESPACES) { nType.Add(LibraryNode.LibraryNodeType.Namespaces); } else if (elementType == (uint)_LIB_LISTTYPE.LLT_MEMBERS) { nType.Add(LibraryNode.LibraryNodeType.Classes); nType.Add(LibraryNode.LibraryNodeType.Members); } LibraryNode tmpRoot = new LibraryNode("", LibraryNode.LibraryNodeType.Package); // FillRoot(tmpRoot, nType, strSearchCriteria, root); // return(tmpRoot); }
/// <summary> /// Search for a class, whose Fully Qualified Name is known /// </summary> /// <param name="fqName">The Fully Qualified Name class to search for</param> /// <returns></returns> public LibraryNode SearchClass(string fqName) { LibraryNode result = null; // result = children.Find( delegate(LibraryNode nd) { return((String.Compare(nd.Name, fqName) == 0) && ((nd.NodeType & LibraryNode.LibraryNodeType.Classes) != LibraryNode.LibraryNodeType.None)); } ); if (result == null) { foreach (XSharpLibraryNode child in children) { result = child.SearchClass(fqName); if (result != null) { break; } } } return(result); }
private void CreateModuleTree(XSharpLibraryProject prjNode, XFile scope, XSharpModuleId moduleId) { if ((null == scope)) { return; } if (!scope.HasCode) { return; } // Retrieve all Types var elements = scope.TypeList; if (elements == null) { return; } // // First search for NameSpaces foreach (KeyValuePair <string, XType> pair in elements) { XType xType = pair.Value; if (xType.Kind == Kind.Namespace) { // Does that NameSpave already exist ? // Search for the corresponding NameSpace XSharpLibraryNode newNode; LibraryNode nsNode = prjNode.SearchNameSpace(xType.Name); if (nsNode is XSharpLibraryNode) { newNode = (XSharpLibraryNode)nsNode; newNode.Depends(moduleId.ItemID); } else { newNode = new XSharpLibraryNode(xType, "", moduleId.Hierarchy, moduleId.ItemID); // NameSpaces are always added to the root. prjNode.AddNode(newNode); newNode.parent = prjNode; } // Handle Global Scope here // It contains Function/Procedure/etc... if (newNode.Name == "(Global Scope)") { CreateGlobalTree(newNode, xType, moduleId); } lock (files) { files.Add(moduleId, newNode); } } } // Now, look for Classes foreach (KeyValuePair <string, XType> pair in elements) { XType xType = pair.Value; // Is it a kind of Type ? if ((xType.Kind.IsType())) { string nSpace = prjNode.DefaultNameSpace; if (!String.IsNullOrEmpty(xType.NameSpace)) { nSpace = xType.NameSpace; } // Search for the corresponding NameSpace LibraryNode nsNode = prjNode.SearchNameSpace(nSpace); if (nsNode is XSharpLibraryNode) { XSharpLibraryNode xsNSNode = (XSharpLibraryNode)nsNode; // So the Class node will belong to that NameSpace Node // Now, try to check if such Type already exist XSharpLibraryNode newNode; LibraryNode newTmpNode; newTmpNode = xsNSNode.SearchClass(xType.Name); if (newTmpNode is XSharpLibraryNode) { newNode = (XSharpLibraryNode)newTmpNode; newNode.Depends(moduleId.ItemID); } else { newNode = new XSharpLibraryNode(xType, "", moduleId.Hierarchy, moduleId.ItemID); nsNode.AddNode(newNode); newNode.parent = nsNode; } // Insert Members CreateMembersTree(newNode, xType, moduleId); // lock (files) { files.Add(moduleId, newNode); } } else { // Not found !? } } } }
private void CreateModuleTree(XSharpLibraryProject prjNode, XFile scope, XSharpModuleId moduleId) { if (null == scope || XSolution.IsClosing) { return; } if (!scope.HasCode) { return; } // Retrieve all Types // !!! WARNING !!! The XFile object (scope) comes from the DataBase // We should retrieve TypeList from the DataBase..... var namespaces = XSharpModel.XDatabase.GetNamespacesInFile(scope.Id.ToString()); if (namespaces == null) { return; } // var elements = XDbResultHelpers.BuildTypesInFile(scope, namespaces); // First search for NameSpaces foreach (XTypeDefinition xType in elements) { if (xType.Kind == Kind.Namespace) { // Does that NameSpace already exist ? // Search for the corresponding NameSpace XSharpLibraryNode newNode; LibraryNode nsNode = prjNode.SearchNameSpace(xType.Name); if (nsNode is XSharpLibraryNode) { newNode = (XSharpLibraryNode)nsNode; newNode.Depends(moduleId.ItemID); } else { newNode = new XSharpLibraryNode(xType, "", moduleId.Hierarchy, moduleId.ItemID); // NameSpaces are always added to the root. prjNode.AddNode(newNode); newNode.parent = prjNode; } // Handle Global Scope here // It contains Function/Procedure/etc... if (newNode.Name == "(Global Scope)") { CreateGlobalTree(newNode, xType, moduleId); } lock (files) { files.Add(moduleId, newNode); } } } // Retrieve Classes from the file var types = XSharpModel.XDatabase.GetTypesInFile(scope.Id.ToString()); if (types == null) { return; } elements = XDbResultHelpers.BuildFullTypesInFile(scope, types); // Now, look for Classes foreach (XTypeDefinition xType in elements) { // Is it a kind of Type ? if ((xType.Kind.IsType())) { string nSpace = prjNode.DefaultNameSpace; if (!String.IsNullOrEmpty(xType.Namespace)) { nSpace = xType.Namespace; } // Search for the corresponding NameSpace LibraryNode nsNode = prjNode.SearchNameSpace(nSpace); if (nsNode == null) { nsNode = prjNode.SearchClass(nSpace); } if (nsNode is XSharpLibraryNode) { XSharpLibraryNode xsNSNode = (XSharpLibraryNode)nsNode; // So the Class node will belong to that NameSpace Node // Now, try to check if such Type already exist XSharpLibraryNode newNode; LibraryNode newTmpNode; newTmpNode = xsNSNode.SearchClass(xType.Name); if (newTmpNode is XSharpLibraryNode) { newNode = (XSharpLibraryNode)newTmpNode; newNode.Depends(moduleId.ItemID); } else { newNode = new XSharpLibraryNode(xType, "", moduleId.Hierarchy, moduleId.ItemID); nsNode.AddNode(newNode); newNode.parent = nsNode; } // // Insert Members CreateMembersTree(newNode, xType, moduleId); // lock (files) { files.Add(moduleId, newNode); } } else { // Not found !? } } } }
/// <summary> /// Main function of the parsing thread. /// This function waits on the queue of the parsing requests and build the parsing tree for /// a specific file. The resulting tree is built using LibraryNode objects so that it can /// be used inside the class view or object browser. /// </summary> private void UpdateTreeThread() { const int waitTimeout = 500; // Define the array of events this function is interest in. WaitHandle[] eventsToWait = new WaitHandle[] { requestPresent, shutDownStarted }; // Execute the tasks. while (true) { // Wait for a task or a shutdown request. int waitResult = WaitHandle.WaitAny(eventsToWait, waitTimeout, false); if (waitResult == 1) { // The shutdown of this component is started, so exit the thread. return; } if (waitResult == WaitHandle.WaitTimeout) { continue; } // LibraryTask task = null; lock (requests) { if (0 != requests.Count) { task = requests.Dequeue(); } if (0 == requests.Count) { requestPresent.Reset(); } } if (null == task) { continue; } // XFile scope = null; if (System.IO.File.Exists(task.FileName)) { scope = XSharpModel.XSolution.FindFile(task.FileName); if (scope == null || (!scope.HasCode)) { continue; } } // If the file already exist lock (files) { // These are the existing Modules XSharpModuleId[] aTmp = new XSharpModuleId[files.Keys.Count]; files.Keys.CopyTo(aTmp, 0); // Does this module already exist ? XSharpModuleId found = Array.Find <XSharpModuleId>(aTmp, (x => x.Equals(task.ModuleID))); if (found != null) { // Doesn't it have the same members? if (found.ContentHashCode == task.ModuleID.ContentHashCode) { continue; } // HashSet <XSharpLibraryNode> values = null; // Ok, now remove ALL nodes for that key if (files.TryGetValue(task.ModuleID, out values)) { foreach (XSharpLibraryNode node in values) { if (node.Freeing(task.ModuleID.ItemID) == 0) { if (node.parent != null) { node.parent.RemoveNode(node); } } } // and then remove the key files.Remove(task.ModuleID); } } // LibraryNode prjNode = this.library.SearchHierarchy(task.ModuleID.Hierarchy); if (prjNode is XSharpLibraryProject) { // CreateModuleTree((XSharpLibraryProject)prjNode, scope, task.ModuleID); // prjNode.updateCount += 1; //this.prjNode.AddNode(node); //library.AddNode(node); this.library.Refresh(); } } } }
public void UnregisterHierarchy(IVsHierarchy hierarchy) { if ((null == hierarchy) || !hierarchies.ContainsKey(hierarchy)) { return; } // Retrieve the listener for that Tree/Hierarchy HierarchyListener listener = hierarchies[hierarchy]; if (null != listener) { listener.Dispose(); } hierarchies.Remove(hierarchy); if (0 == hierarchies.Count) { UnregisterRDTEvents(); } // Now remove all nodes // for all files lock (files) { XSharpModuleId[] keys = new XSharpModuleId[files.Keys.Count]; // Get all Keys (ModuleId) files.Keys.CopyTo(keys, 0); foreach (XSharpModuleId id in keys) { // The file is owned by the Hierarchy ? if (hierarchy.Equals(id.Hierarchy)) { HashSet <XSharpLibraryNode> values = null; // Ok, now remove ALL nodes for that key if (files.TryGetValue(id, out values)) { foreach (XSharpLibraryNode node in values) { if (node.parent != null) { node.parent.RemoveNode(node); } } } // and then remove the key files.Remove(id); } } } // LibraryNode prjNode = this.library.SearchHierarchy(hierarchy); if (prjNode is XSharpLibraryProject) { library.RemoveNode(prjNode); } #if TEXTCHANGELISTENER // Remove the document listeners. uint[] docKeys = new uint[documents.Keys.Count]; documents.Keys.CopyTo(docKeys, 0); foreach (uint id in docKeys) { TextLineEventListener docListener = documents[id]; if (hierarchy.Equals(docListener.FileID.Hierarchy)) { documents.Remove(id); docListener.Dispose(); } } #endif }
public Library(Guid libraryGuid) { this.guid = libraryGuid; root = new LibraryNode("", LibraryNode.LibraryNodeType.Package); }