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);
}
