public static void addExtraFileReferencesToSelectedNode(TreeView treeView, string file)
{
if (treeView != null)
treeView.invokeOnThread(
() =>
{
addExtraFileReferencesToTreeNode(treeView.SelectedNode, file);
});
}
public static void addErrorsListToTreeView(TreeView tvCompilationErrors, StringBuilder sbErrorMessage)
{
tvCompilationErrors.invokeOnThread(
() =>
{
if (sbErrorMessage == null)
return;
tvCompilationErrors.Nodes.Clear();
addErrorsListToTreeView(sbErrorMessage.ToString(), tvCompilationErrors);
});
}
public static void addAssembliesWithUnitTestsToTreeView(List<string> assembliesWithUnitTests, TreeView treeView, bool clearLoadedList)
{
treeView.invokeOnThread(
() =>
{
if (clearLoadedList)
treeView.Nodes.Clear();
treeView.Tag = assembliesWithUnitTests;
foreach (var assembly in assembliesWithUnitTests)
treeView.Nodes.Add(assembly);
});
}
private void onSpringMvcMappingsTreeSelect(TreeView treeView)
{
treeView.invokeOnThread(
() =>
{
if (treeView.SelectedNode != null && treeView.SelectedNode.Tag != null)
{
if (treeView.SelectedNode.Tag is SpringMvcController)
showDetailsForSpringMvcController((SpringMvcController)treeView.SelectedNode.Tag);
}
});
}
public void onSpringMvcMappingsTreeViewSelect(TreeView treeView, bool openPageWhenControllerIsSelected)
{
treeView.invokeOnThread(
() =>
{
if (treeView.SelectedNode != null && treeView.SelectedNode.Tag != null)
{
if (treeView.SelectedNode.Tag is SpringMvcController)
showDetailsForSpringMvcController((SpringMvcController)treeView.SelectedNode.Tag, openPageWhenControllerIsSelected);
}
});
}
private static List<Assembly> getAssembliesToLoad(TreeView tvTreeView)
{
return (List<Assembly>)tvTreeView.invokeOnThread(
() =>
{
if (tvTreeView.Nodes.Count ==0)
return getDefaultLoadedAssemblies();
var assembliesToLoad = new List<Assembly>();
foreach(TreeNode treeNode in tvTreeView.Nodes)
if (treeNode.Checked && treeNode.Tag !=null && treeNode.Tag is Assembly)
assembliesToLoad.Add((Assembly)treeNode.Tag);
return assembliesToLoad;
});
}
public static void populateTreeNodeCollectionWithVariables(TreeView targetTreeView, TreeNodeCollection nodes, List<O2MDbgVariable> o2MDbgvariables)
{
targetTreeView.invokeOnThread(
() =>
{
nodes.Clear();
foreach (var o2MDbgvariable in o2MDbgvariables)
{
// var nameLvSubItem = new ListViewItem.ListViewSubItem()
var nodeText =
string.Format("{0} = {1} : {2}", o2MDbgvariable.name, o2MDbgvariable.value,
o2MDbgvariable.type);
var newTreeNode = O2Forms.newTreeNode(nodes, nodeText, 0, o2MDbgvariable);
if (o2MDbgvariable.complexType)
newTreeNode.Nodes.Add("DymmyNode");
}
});
}
public static void setToolTipText(TreeView treeView, TreeNode treeNode, string toolTipText)
{
treeView.invokeOnThread(
() => treeNode.ToolTipText = toolTipText);
}
public static void expandNodes(TreeView targetTreeView)
{
if (targetTreeView != null)
targetTreeView.invokeOnThread(
()=>
{
foreach(TreeNode node in targetTreeView.Nodes)
node.Expand();
});
}
public Thread loadAssesmblyDataIntoTreeView(Assembly aAssemblyToLoad, TreeView tvTargetTreeView,
Label lbLastMethodExecuted, bool bOnlyShowStaticMethods)
{
tvTargetTreeView.Visible = false;
tvTargetTreeView.Nodes.Clear();
tvTargetTreeView.Sorted = true;
int iTypesAdded = 0;
return O2Thread.mtaThread(() =>
{
try
{
var treeNodesToAdd = new List<TreeNode>();
foreach (Type tType in aAssemblyToLoad.GetTypes())
{
if ((iTypesAdded++) % 500 == 0)
PublicDI.log.info("{0} types processed", iTypesAdded);
//vars.set_(tType.Name, tType); // set global variable of compiled code
//Callbacks.raiseEvent_ScriptCompiledSuccessfully(tType.Name);
TreeNode tnType = O2Forms.newTreeNode(tType.Name, tType.Name, 1, tType);
foreach (
MethodInfo mMethod in
tType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly |
((bOnlyShowStaticMethods) ? BindingFlags.Static : BindingFlags.Static | BindingFlags.Instance)))
{
if (mMethod.Name == lbLastMethodExecuted.Text)
lbLastMethodExecuted.Tag = mMethod;
//TreeNode tnMethod = O2Forms.newTreeNode(mMethod.Name, mMethod.Name, 2, mMethod);
TreeNode tnMethod =
O2Forms.newTreeNode(
new FilteredSignature(mMethod).getReflectorView(),
mMethod.Name, 2, mMethod);
tnType.Nodes.Add(tnMethod);
}
if (tnType.Nodes.Count > 0)
treeNodesToAdd.Add(tnType);
//O2Forms.addNodeToTreeNodeCollection(tvTargetTreeView, tvTargetTreeView.Nodes, tnType); // thread safe way to add nodes
}
PublicDI.log.info("{0} types processed , now loading them into treeView", iTypesAdded);
tvTargetTreeView.invokeOnThread(() =>
{
foreach (var treeNode in treeNodesToAdd)
tvTargetTreeView.Nodes.Add(treeNode);
PublicDI.log.info("All nodes loaded");
if (tvTargetTreeView.Nodes.Count > 0)
tvTargetTreeView.Nodes[0].Expand();
tvTargetTreeView.Visible = true;
});
}
catch (Exception ex)
{
PublicDI.log.ex(ex, "in loadAssesmblyDataIntoTreeView");
}
});
//if (tvTargetTreeView.GetNodeCount(true) < 20)
// tvTargetTreeView.ExpandAll();
//tvTargetTreeView.Visible = true;
}
public static void addXLoadedRulesToTreeView(IEnumerable<ILoadedXRule> xLoadedRules, TreeView treeView, bool clearLoadedList)
{
treeView.invokeOnThread(
() =>
{
if (clearLoadedList)
treeView.Nodes.Clear();
treeView.Tag = xLoadedRules;
if (xLoadedRules != null)
foreach (var xLoadedRule in xLoadedRules)
{
var newTreeNode = O2Forms.newTreeNode(treeView.Nodes, xLoadedRule.ToString(), 0,
xLoadedRule);
foreach (var method in xLoadedRule.methods)
// only add methods that have no parameters
if (DI.reflection.getParametersType(method.Value).Count == 0)
O2Forms.newTreeNode(newTreeNode.Nodes, method.Key.Name, 0, method.Value);
}
});
}
public static void mapAssembliesIntoXRules(TreeView tvSource_Assemblies, TreeView tvTarget_XLoadedRules)
{
tvSource_Assemblies.invokeOnThread(
() =>
{
if (tvSource_Assemblies.Tag != null &&
tvSource_Assemblies.Tag is List<string>)
{
var xLoadedRules = mapUnitTestToXRules((List<string>)tvSource_Assemblies.Tag);
addXLoadedRulesToTreeView(xLoadedRules, tvTarget_XLoadedRules, true);
}
});
}
public static TreeNode getTreeNodeAtDroppedOverPoint(TreeView tvTreeView, int iDroppedX, int iDroppedY)
{
return tvTreeView.invokeOnThread(
() =>{
Point pPointToString = tvTreeView.PointToScreen(tvTreeView.Location);
int iAdjustedX = tvTreeView.Left + iDroppedX - pPointToString.X;
int iAdjustedY = tvTreeView.Top + iDroppedY - pPointToString.Y;
//PublicDI.log.info("x:{0} y:{1} - {2}, {3}", x, y, tvCurrentFilters.Left, tvCurrentFilters.Top);
return tvTreeView.GetNodeAt(iAdjustedX, iAdjustedY);
});
}
public static void loadInThread(List<TreeNode> rootNodes,TreeView tvSearchResults)
{
tvSearchResults.invokeOnThread(
() =>
{
tvSearchResults.Visible = false;
tvSearchResults.Nodes.Clear();
tvSearchResults.Nodes.AddRange(rootNodes.ToArray());
tvSearchResults.Visible = true;
});
}
public static TreeView selectTreeNodeAtDroppedOverPoint(TreeView tvTreeView, int iDroppedX, int iDroppedY)
{
return tvTreeView.invokeOnThread(
() =>{
TreeNode tnDraggedTarget = getTreeNodeAtDroppedOverPoint(tvTreeView, iDroppedX, iDroppedY);
if (tnDraggedTarget != null)
tvTreeView.SelectedNode = tnDraggedTarget;
return tvTreeView;
});
}
public static void setTreeNodeColor(TreeView treeView, TreeNode treeNode, Color color)
{
if (treeNode != null)
treeView.invokeOnThread(
() => treeNode.ForeColor = color);
}
// map this to a callback
private void tvControllers_AfterSelect(TreeView tvControllers)
{
tvControllers.invokeOnThread(
() =>
{
if (tvControllers.SelectedNode != null && tvControllers.SelectedNode.Tag != null)
{
if (tvControllers.SelectedNode.Tag is SpringMvcController)
{
showDetailsForSpringMvcController((SpringMvcController) tvControllers.SelectedNode.Tag);
}
else if (tvControllers.SelectedNode.Tag is ICirClass)
{
var cirClass = (ICirClass) tvControllers.SelectedNode.Tag;
cirFunctionDetails.viewCirClass(cirClass);
springMvcAutoBindClassesView.showClass(cirClass,springMvcMappings.cirData);
showFindingsDetailsForSpringMvcController(cirClass.Signature);
}
tvControllers.Focus();
}
});
}
private static Thread populateTreeViewUsingViewMode_byFunctionSignature(IEnumerable<string> lsList,
TreeView targetTreeView,
int namespaceDepthValue, string textFilter, int iMaxItemsToShow)
{
return O2Thread.mtaThread(
() =>
{
targetTreeView.invokeOnThread(() => targetTreeView.Visible = false);
try
{
var dItemsParsed = new Dictionary<String, FilteredSignature>();
foreach (String sItem in lsList)
{
//if (false == dItemsParsed.ContainsKey(sItem))
{
if (textFilter == "" || RegEx.findStringInString(sItem, textFilter))
dItemsParsed.Add(sItem, new FilteredSignature(sItem));
}
//else
// PublicDI.log.error("Something's wrong in showListOnTreeView, lsList had repeated key:{0}", sItem);
}
var dItemsBrokenByClassDepth = new Dictionary<String, List<FilteredSignature>>();
foreach (String sItem in lsList)
{
if (namespaceDepthValue == -1)
{
if (textFilter == "" || RegEx.findStringInString(sItem, textFilter))
if (dItemsParsed.ContainsKey(sItem))
// add node ASync and on the correct thread
O2Forms.addNodeToTreeNodeCollection(targetTreeView, targetTreeView.Nodes,
O2Forms.newTreeNode(
dItemsParsed[sItem].sSignature, sItem,
3, dItemsParsed[sItem]), iMaxItemsToShow);
}
else
{
if (dItemsParsed.ContainsKey(sItem))
{
String sClassNameToShow =
dItemsParsed[sItem].getClassName_Rev(namespaceDepthValue);
if (sClassNameToShow == "")
sClassNameToShow = dItemsParsed[sItem].sFunctionClass;
/* var sClassNameToConsolidate = (sClassNameToShow == "")
? dItemsParsed[sItem].sFunctionClass
: dItemsParsed[sItem].sFunctionClass.Replace(
sClassNameToShow, "");*/
if (false == dItemsBrokenByClassDepth.ContainsKey(sClassNameToShow))
dItemsBrokenByClassDepth.Add(sClassNameToShow, new List<FilteredSignature>());
//String sSignatureToShow = sClassNameToConsolidate + "__" + dItemsParsed[sItem].sFunctionNameAndParams;
dItemsBrokenByClassDepth[sClassNameToShow].Add(dItemsParsed[sItem]);
}
}
// add calculated results
// TreeNodeCollection tncToAddFunction_ = targetTreeView.Nodes;
}
foreach (String sClass in dItemsBrokenByClassDepth.Keys)
{
var filteredSignatures = dItemsBrokenByClassDepth[sClass];
TreeNode tnNewTreeNode = O2Forms.newTreeNode(sClass, sClass, 0,
filteredSignatures);
if (filteredSignatures.Count > 0)
tnNewTreeNode.Nodes.Add("DummyNode");
// add node ASync and on the correct thread
O2Forms.addNodeToTreeNodeCollection(targetTreeView, targetTreeView.Nodes, tnNewTreeNode, iMaxItemsToShow);
//tncToAddFunction.Add(tnNewTreeNode);
}
// remove empty nodes
/* if (false && bRemoveEmptyRootNodes && NamespaceDepthValue > -1)
{
var tnTreeNodesToRemove = new List<TreeNode>();
foreach (TreeNode tnTreeNode in tvTempTreeView.Nodes)
if (tnTreeNode.Nodes.Count == 0)
tnTreeNodesToRemove.Add(tnTreeNode);
foreach (TreeNode tnTreeNode in tnTreeNodesToRemove)
tvTempTreeView.Nodes.Remove(tnTreeNode);
}*/
var numberOfUniqueStrings = lsList.Count();
if (numberOfUniqueStrings > iMaxItemsToShow)
{
var message = string.Format("This view has more items that the current MaxToView. only showing the first {0} out of {1}", iMaxItemsToShow, numberOfUniqueStrings);
PublicDI.log.error(message);
targetTreeView.add_Node(message);
}
}
catch (Exception ex)
{
PublicDI.log.error("in populateTreeViewUsingViewMode_byFunctionSignature: {0}", ex.Message);
}
targetTreeView.invokeOnThread(
() =>
{
targetTreeView.Visible = true;
// the code below tries to solve a weird GUI problem that happens when there is only one child Node (which is invible until the user clicks on it))
if (targetTreeView.Nodes.Count == 1)
{
targetTreeView.Nodes[0].Expand();
// targetTreeView.SelectedNode = targetTreeView.Nodes[0];
//var dummyNode = targetTreeView.Nodes.Add("dUMMYN node");
//targetTreeView.Nodes.Remove(dummyNode);
}
});
});
}
