public static void populateTreeNodeWithAssessmentStats(TreeNode treeNode, O2Assessment o2Assessment,
int imageIndex)
{
O2Forms.newTreeNode(treeNode, "# Findings:" + getNumberOf_Findings(o2Assessment), imageIndex, null);
O2Forms.newTreeNode(treeNode, "# Smart Traces:" + getNumberOf_Findings_WithSmartTrace(o2Assessment),
imageIndex, null);
/* O2Forms.newTreeNode(treeNode, "File:" + Path.GetFileName(o2Assessment.lastOzasmtImportFile), imageIndex,
* null);
* O2Forms.newTreeNode(treeNode, "Size:" + o2Assessment.lastOzasmtImportFileSize, imageIndex, null);
* string importTimeString =
* ((o2Assessment.lastOzasmtImportTimeSpan.Hours > 0)
* ? o2Assessment.lastOzasmtImportTimeSpan.Hours + "h : "
* : "") +
* ((o2Assessment.lastOzasmtImportTimeSpan.Minutes > 0)
* ? o2Assessment.lastOzasmtImportTimeSpan.Minutes + "m : "
* : "") +
* ((o2Assessment.lastOzasmtImportTimeSpan.Seconds > 0)
* ? o2Assessment.lastOzasmtImportTimeSpan.Seconds + "s : "
* : "") +
* ((o2Assessment.lastOzasmtImportTimeSpan.Milliseconds > 0)
* ? o2Assessment.lastOzasmtImportTimeSpan.Milliseconds + "ms"
* : "");
* O2Forms.newTreeNode(treeNode, "Imported in: " + importTimeString, imageIndex, null);*/
}
public static bool showCodeSnippetForSelectedFunction(ICirFunction cirFunctionToProcess, bool showCodeSnippet, TreeView treeView, TreeNode currentTreeNode, TreeNode previousTreeNode)
{
if (cirFunctionToProcess.File != null && File.Exists(cirFunctionToProcess.File))
{
int fileStartLine;
if (Int32.TryParse(cirFunctionToProcess.FileLine, out fileStartLine))
{
int mappedLineNumber = ViewHelpers.GetMappedLineNumber(cirFunctionToProcess.FunctionName, cirFunctionToProcess.File, cirFunctionToProcess.FileLine, false, true);
if (mappedLineNumber > 0)
{
O2Forms.setTreeNodeColor(treeView, currentTreeNode, Color.DarkMagenta);
O2Forms.setTreeNodeColor(treeView, previousTreeNode, Color.DarkGreen);
if (showCodeSnippet)
{
mappedLineNumber--;
var fileLines = Files.getFileLines(cirFunctionToProcess.File);
var numberOfLinesAfter = fileLines.Count - mappedLineNumber;
var numberOfLinesToShow = (numberOfLinesAfter > 10) ? 10 : numberOfLinesAfter;
var linesToShow = fileLines.GetRange(mappedLineNumber, numberOfLinesToShow);
var codeSnippet = StringsAndLists.fromStringList_getText(linesToShow);
O2Forms.setToolTipText(treeView, currentTreeNode, codeSnippet);
}
else
{
O2Forms.setToolTipText(treeView, currentTreeNode, "");
}
return(true);
}
}
}
return(false);
}
void ascx_Breakpoints_onMessages(IO2Message o2Message)
{
//switch (o2Message.GetType().Name)
//{
// case "IM_SelectedTypeOrMethod":
// case "IM_O2MdbgActions":
// break;
if (o2Message is IM_SelectedTypeOrMethod)
{
O2Thread.mtaThread(() =>
{
string breakPointSignature =
DI.o2MDbg.BreakPoints.
getBreakpointSignatureFromO2SelectedTypeOrMethodMessage(
o2Message);
if (breakPointSignature != "")
{
O2Forms.setTextBoxValue_ThreadSafeWay(breakPointSignature,
tbBreakPointSignature);
}
}
);
}
/*else if (o2Message is IM_O2MdbgAction)
* {
* var o2MdbgAction = (IM_O2MdbgAction)o2Message;
* if (o2MdbgAction.o2MdbgAction == IM_O2MdbgActions.startDebugSession)
* setOnBreakpointEvent();
* }*/
}
public static TreeNode addCirFunctionToTreeNodeCollection(ICirFunctionCall functionCall, string treeNodeNamePrefix, TreeNodeCollection treeNodeCollection, bool addDummyChildNode)
{
if (functionCall == null || functionCall.cirFunction == null)
{
return(null);
}
var cirFunction = functionCall.cirFunction;
var treeNodeName = String.Format(" {0}{1} : {2}", treeNodeNamePrefix, cirFunction.FunctionName, cirFunction.ClassNameFunctionNameAndParameters);
var newTreeNode = O2Forms.newTreeNode(treeNodeCollection, treeNodeName, cirFunction.FunctionSignature, 0, functionCall);
if (addDummyChildNode)
{
newTreeNode.Nodes.Add(""); // Dummy node so that we have the plus sign
}
if (functionCall.fileName != null && functionCall.lineNumber > 0)
{
newTreeNode.ForeColor = System.Drawing.Color.DarkGreen;
}
else
{
newTreeNode.ForeColor = System.Drawing.Color.Red;
}
return(newTreeNode);
}
public static List <TreeNode> FromTreeViewCalculateViewForSpecificRootNode(String sRootNodeToTrace,
TreeView tvTracesData, String sKeyword,
TreeView tvRawData)
{
O2Timer tTimer = new O2Timer("Calculating Data TreeView for " + sKeyword).start();
//tvTargetTreeView.Nodes.Clear();
var ltnCalculatedTreeNodes = new List <TreeNode>();
var lsFunctionsInTrace = new List <string>();
TreeNode tnNewTreeNode = O2Forms.newTreeNode(tvTracesData.Nodes[sRootNodeToTrace].Text,
tvTracesData.Nodes[sRootNodeToTrace].Text, 0,
tvTracesData.Nodes[sRootNodeToTrace].Tag);
addNodesToView_recursive(tnNewTreeNode, tvTracesData.Nodes[sRootNodeToTrace], tvTracesData, sKeyword,
lsFunctionsInTrace, tvRawData);
if (tnNewTreeNode != null)
{
foreach (TreeNode tnTreeNode in tnNewTreeNode.Nodes)
{
ltnCalculatedTreeNodes.Add((TreeNode)tnTreeNode.Clone());
}
}
tTimer.stop();
if (tnNewTreeNode != null)
{
DI.log.info("Trace with {0}Data Calculated: It has {1} ({2}) Nodes (SubNodes)", sKeyword,
tnNewTreeNode.GetNodeCount(false), tnNewTreeNode.GetNodeCount(true));
}
return(ltnCalculatedTreeNodes);
}
/*private void btProcessLoadedFindings_Click(object sender, EventArgs e)
* {
* proccessLoadedFiles();
* cbShowRawData_CheckedChanged(null, null);
* cbShowSinksView_CheckedChanged(null, null);
* cbShowSourcesView_CheckedChanged(null, null);
* }*/
private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
{
if (tvAllTraces.SelectedNode != null)
{
TreeNode tnSelectedNode = tvAllTraces.SelectedNode;
if (tnSelectedNode.Tag != null)
{
var otdO2TraceBlock = (O2TraceBlock_OunceV6)tnSelectedNode.Tag;
DI.log.info(" Signature:{0}", otdO2TraceBlock.sSignature);
DI.log.info(" TraceRoot Text: {0}", otdO2TraceBlock.sTraceRootText);
DI.log.info(" Unique Name: {0}", otdO2TraceBlock.sUniqueName);
}
else
{
TreeNode tnRootNode = O2Forms.getRootNode(tnSelectedNode);
DI.log.debug("Root Node:{0}", tnRootNode);
DI.log.debug("Selected Node:{0}", tnSelectedNode);
foreach (TreeNode tnTreeNode in tvRawData.Nodes)
{
if (tnTreeNode.Text == tnSelectedNode.Text)
{
tnSelectedNode.Nodes.Add((TreeNode)tnTreeNode.Clone());
}
}
}
}
}
public void showSpringBeansInDataGrdView(SpringBeans sbSpringBeans)
{
dgvBeans.Columns.Clear();
foreach (var property in DI.reflection.getProperties(typeof(SpringMappingItem)))
{
O2Forms.addToDataGridView_Column(dgvBeans, property.Name, -1);
}
/*O2Forms.addToDataGridView_Column(dgvBeans, "bean", -1);
* O2Forms.addToDataGridView_Column(dgvBeans, "class", -1);
* O2Forms.addToDataGridView_Column(dgvBeans, "innerXml", -1);*/
foreach (SpringMappingItem spiSpringMappingItem in sbSpringBeans.dSpringMappingItems.Values)
{
var items = new List <object>();
foreach (var property in DI.reflection.getProperties(typeof(SpringMappingItem)))
{
items.Add(DI.reflection.getProperty(property.Name, spiSpringMappingItem));
}
O2Forms.addToDataGridView_Row(dgvBeans, null, items.ToArray());
/*
* new[]
* {
* spiSpringMappingItem.sBean, spiSpringMappingItem.sClass,
* spiSpringMappingItem.sInnerXml
* });*/
}
}
private void calculateStatsForModule(string moduleToProcess)
{
typesInModule = new List <Type>();
methodsInModule = new List <MethodInfo>();
MDbgModule module;
O2Thread.mtaThread(() =>
{
module = DI.o2MDbg.sessionData.getModule(moduleToProcess);
if (module != null)
{
foreach (Type typeInModule in module.Importer.DefinedTypes)
// if (false == typeInModule.IsInterface && false == typeInModule.IsAbstract) // these are not implemented in the original MDbg :(
{
typesInModule.Add(typeInModule);
foreach (MethodInfo methodInType in typeInModule.GetMethods())
{
methodsInModule.Add(methodInType);
}
}
}
O2Forms.setObjectTextValueThreadSafe(string.Format("{0} types in module {1}", typesInModule.Count, moduleToProcess), laNumberOfTypes);
O2Forms.setObjectTextValueThreadSafe(string.Format("{0} types in module {1}", methodsInModule.Count, moduleToProcess), laNumberOfMethods);
});
}
private void refreshTreeView()
{
this.invokeOnThread(
() =>
{
tvStrutsMappings.Nodes.Clear();
if (tvStrutsMappings.Tag != null && tvStrutsMappings.Tag is IStrutsMappings)
{
var strutsMappings = ((IStrutsMappings)tvStrutsMappings.Tag);
foreach (var actionServlet in strutsMappings.actionServlets)
{
var newNode = O2Forms.newTreeNode(tvStrutsMappings.Nodes, actionServlet.ToString(), 0,
actionServlet);
newNode.Nodes.Add("DummyNode");
}
foreach (var otherServlet in strutsMappings.otherServlets)
{
O2Forms.newTreeNode(tvStrutsMappings.Nodes, otherServlet);
}
tvStrutsMappings.white();
}
});
}
private void ascx_CustomRules_eShowCustomRulesDetails_MethodSignature(String sDbId, String sMethodSignature)
{
O2Forms.setObjectTextValueThreadSafe(sDbId, cbEditCustomRules_DbId);
O2Forms.setObjectTextValueThreadSafe(sDbId, lbCurrentMethodDbId);
O2Forms.setObjectTextValueThreadSafe(sMethodSignature, lbCurrentMethodSignature);
// updateRelatedActionObjectDataGridView(sVar);
}
/* private void onSelectedItemTreeViewBeforeExpand(TreeNode selectedTreeNode)
* {
* //return;
* if (selectedTreeNode != null && selectedTreeNode.Tag is ICirFunction)
* {
* selectedTreeNode.Nodes.Clear();
*
* /* var filteredSignature = (FilteredSignature)selectedTreeNode.Tag;
* var signature = filteredSignature.sOriginalSignature;
* if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(signature))
* {* /
* var cirFunction = (ICirFunction)selectedTreeNode.Tag;
* // makesCallToNode
* //var makesCallToNode = new TreeNode("Makes calls to:");
* foreach (var makesCallsTo in cirFunction.FunctionsCalledUniqueList)
* addCirFunctionToTreeNodeCollection(makesCallsTo, "=>", selectedTreeNode.Nodes);
* // isCalledByNode
*
* //var isCalledByNode = new TreeNode("Is called by:");
* foreach (var isCalledBy in cirFunction.FunctionIsCalledBy)
* addCirFunctionToTreeNodeCollection(isCalledBy, "<=", selectedTreeNode.Nodes);
* /* }
* else
* selectedTreeNode.Nodes.Add("Could not find the signature:" + signature);*/
/* var functionNode = new TreeNode("Function: " + cirFunction.FunctionName);
*
* // makesCallToNode
* var makesCallToNode = new TreeNode("Makes calls to:");
* foreach (var makesCallsTo in cirFunction.FunctionsCalledUniqueList)
* makesCallToNode.Nodes.Add(makesCallsTo.FunctionName);
* // isCalledByNode
* var isCalledByNode = new TreeNode("Is called by:");
* foreach (var isCalledBy in cirFunction.FunctionIsCalledBy)
* isCalledByNode.Nodes.Add(isCalledBy.FunctionName);
*
* functionNode.Nodes.Add(makesCallToNode);
* functionNode.Nodes.Add(isCalledByNode);
* tvSelectedItemInfo.Nodes.Add(functionNode);
* ;* /
* }
* }
*
*/
public void viewCirClass(ICirClass cirClass)
{
if (cirClass != null)
{
this.invokeOnThread(
() =>
{
showClassAttributes(cirClass);
laFunctionViewed.Text = cirClass.Signature;
rootCirFunction = null;
currentCirClass = cirClass;
tvFunctionIsCalledBy.Nodes.Clear();
tvFunctionMakesCallsTo.Nodes.Clear();
tvFunctionInfo.Nodes.Clear();
//tvClassSuperClasses
tvClassSuperClasses.Nodes.Clear();
ViewHelpers.addCirClassToTreeNodeCollection(cirClass, "", tvClassSuperClasses.Nodes,
cirClass.dSuperClasses.Count > 0);
O2Forms.expandNodes(tvClassSuperClasses);
//tvClassIsSuperClassedBy
tvClassIsSuperClassedBy.Nodes.Clear();
ViewHelpers.addCirClassToTreeNodeCollection(cirClass, "", tvClassIsSuperClassedBy.Nodes,
cirClass.dIsSuperClassedBy.Count > 0);
O2Forms.expandNodes(tvClassIsSuperClassedBy);
viewClassMethods(functionViewerForClassMethods, cirClass, cbViewInheritedMethods.Checked, cbIgnoreCoreObjectClass.Checked);
cbCirFunction_IsTainted.Checked = false;
});
}
}
public void showThreadsWithStackTrace()
{
var threads = DI.o2MDbg.sessionData.Threads;
tvExecutionArchive.add_Node(O2Forms.newTreeNode(itemId++.ToString(), "", 0, threads));
showThreadDetails(threads);
}
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);
}
}
}
}
});
}
/* private void dgvSearchResults_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
* {
* dgvSearchResults_SelectionChanged(null, null);
* }*/
private void dgvSearchResults_SelectionChanged(object sender, EventArgs e)
{
if (cbOpenSelectedItemInMainGUIWindow.Checked && dgvSearchResults.SelectedRows.Count == 1)
{
var tsrSearchResult = (TextSearchResult)dgvSearchResults.SelectedRows[0].Tag;
if (tsrSearchResult != null)
{
O2Messages.fileOrFolderSelected(tsrSearchResult.sFile, tsrSearchResult.iLineNumber + 1);
//asceSourceCodeEditor.gotoLine(tsrSearchResult.sFile, tsrSearchResult.iLineNumber + 1);
O2Thread.mtaThread(
() =>
{
Thread.Sleep(200);
var searchResultsForm = O2Forms.findParentThatHostsControl(this);
//var searchResultsForm = O2DockUtils.getO2DockContentForm("Search Results");
searchResultsForm.invokeOnThread(
() =>
{
searchResultsForm.Focus();
dgvSearchResults.Focus();
});
// DI.dO2LoadedO2DockContent[name].dockContent.invokeOnThread(
// () => { DI.dO2LoadedO2DockContent[name].dockContent.Focus(); });
});
}
}
}
public void createTreeNodesForLoadedSpringMvcControllers()
{
treeNodesForloadedSpingMvcControllers = new Dictionary <SpringMvcController, TreeNode>();
foreach (var springMvcController in loadedSpringMvcControllers)
{
if (springMvcController.JavaClassAndFunction != null)
{
var nodeText = springMvcController.HttpRequestUrl;
var newTreeNode = O2Forms.newTreeNode(nodeText, nodeText, 0, springMvcController);
//newTreeNode.Nodes.Add("HttpMappingParameter: " + springMvcController.HttpMappingParameter ?? "");
newTreeNode.Nodes.Add("HttpRequestMethod: " + springMvcController.HttpRequestMethod ??
"");
newTreeNode.Nodes.Add("HttpRequestUrl: " + springMvcController.HttpRequestUrl ?? "");
newTreeNode.Nodes.Add("HttpMappingParameter: " +
springMvcController.HttpMappingParameter ?? "");
//newTreeNode.Nodes.Add("JavaClass: " + springMvcController.JavaClass ?? "");
newTreeNode.Nodes.Add("JavaMethod: " + springMvcController.JavaClassAndFunction ?? "");
newTreeNode.Nodes.Add(string.Format("File (LineNumber): {0} ({1})", Path.GetFileName(springMvcController.FileName), springMvcController.LineNumber));
var httpMappingsParameters = new TreeNode("AutoWiredJavaObjects");
for (int parameterIndex = 0;
parameterIndex < springMvcController.AutoWiredJavaObjects.Count;
parameterIndex++)
{
var springMvcParameter =
springMvcController.AutoWiredJavaObjects[parameterIndex];
httpMappingsParameters.Nodes.Add(
SpringMvcUtils.getTreeNodeWithAutoWiredObject(cirData, springMvcController.JavaClassAndFunction, springMvcParameter, parameterIndex));
//httpMappingsParameters.Nodes.Add(childNodeText);
}
newTreeNode.Nodes.Add(httpMappingsParameters);
treeNodesForloadedSpingMvcControllers.Add(springMvcController, newTreeNode);
}
}
}
private void onLoad()
{
if (runOnLoad && DesignMode == false)
{
updateVisibilityOfSaveButton();
if (dgvFindingsDetails.Columns.Count == 0) // only do this once
{
O2Forms.addToDataGridView_Column(dgvFindingsDetails, "Name", 100);
O2Forms.addToDataGridView_Column(dgvFindingsDetails, "Value", -1);
dgvFindingsDetails.Columns[0].ReadOnly = true;
O2Forms.addToDataGridView_Column(dgvTraceDetails, "Name", 100);
O2Forms.addToDataGridView_Column(dgvTraceDetails, "Value", -1);
dgvTraceDetails.Columns[0].ReadOnly = true;
OzasmtMappedToWindowsForms.loadIntoToolStripCombox_O2TraceTypes(cbCurrentO2TraceType);
//newO2Finding();
runOnLoad = false;
ascxTraceTreeView.onTreeNodeAfterSelect += ascx_TraceTreeView_onTreeNodeAfterSelect;
ascxTraceTreeView.onTreeNodeAfterLabelEdit += ascxTraceView_onTreeNodeAfterLabelEdit;
}
}
}
public static void calculateO2TraceBlocksIntoTreeView(Dictionary <String, O2TraceBlock_OunceV6> dO2TraceBlock,
ref TreeView tvTargetTreeView)
{
DI.log.info("incalculateO2TraceBlocksIntoTreeView: {0}", dO2TraceBlock.Keys.Count);
O2Timer tTimer = new O2Timer("Calculating Raw Data TreeView").start();
tvTargetTreeView = new TreeView();
var itemsProcessed = 0;
var itemsToProcess = dO2TraceBlock.Keys.Count;
var updateInterval = 1000;
foreach (var sSignature in dO2TraceBlock.Keys)
{
if (itemsProcessed++ % updateInterval == 0)
{
DI.log.info("[{0}/{1}]", itemsProcessed, itemsToProcess);
}
O2TraceBlock_OunceV6 otdO2TraceBlockOunceV6 = dO2TraceBlock[sSignature];
//String sRootNodeText = String.Format("{0} {1} {2}", otdO2TraceBlockOunceV6.sSignature, System.IO.Path.GetFileName(otdO2TraceBlockOunceV6.sFile),otdO2TraceBlockOunceV6.sLineNumber);
String sRootNodeText = String.Format("{0} {1} {2}", otdO2TraceBlockOunceV6.sSignature,
otdO2TraceBlockOunceV6.sFile, otdO2TraceBlockOunceV6.sLineNumber);
TreeNode tnRootNode = O2Forms.newTreeNode(sRootNodeText, sRootNodeText, 0, otdO2TraceBlockOunceV6);
// handle Sinks
TreeNode tnSinks = O2Forms.newTreeNode("Sinks", "Sinks", 0, null);
foreach (AssessmentAssessmentFileFinding fFinding in otdO2TraceBlockOunceV6.dSinks.Keys)
{
String sSink = getUniqueSignature(fFinding, TraceType.Known_Sink,
otdO2TraceBlockOunceV6.dSinks[fFinding], true);
// analysis.Analysis.getSink(fFinding, otdO2TraceBlockOunceV6.dSinks[fFinding]);
if (!string.IsNullOrEmpty(sSink) || sSink != sRootNodeText)
{
TreeNode tnSink = O2Forms.newTreeNode(sSink, sSink, 0, null);
tnSinks.Nodes.Add(tnSink);
}
}
tnRootNode.Nodes.Add(tnSinks);
TreeNode tnSources = O2Forms.newTreeNode("Sources", "Sources", 0, null);
foreach (AssessmentAssessmentFileFinding fFinding in otdO2TraceBlockOunceV6.dSources.Keys)
{
String sSource = getUniqueSignature(fFinding, TraceType.Source,
otdO2TraceBlockOunceV6.dSources[fFinding], true);
if (sSource == "" || sSource == null || sSource != sRootNodeText)
{
TreeNode tnSource = O2Forms.newTreeNode(sSource, sSource, 0, null);
tnSources.Nodes.Add(tnSource);
}
}
tnRootNode.Nodes.Add(tnSources);
tvTargetTreeView.Nodes.Add(tnRootNode);
}
DI.log.info("[{0}/{1}]", itemsProcessed, itemsToProcess);
//tvTargetTreeView.Sort(); // removed for performance reasons
//tvAllTraces.Nodes.AddRange(tvRawData.Nodes);
//tvAllTraces = tvRawData;
tTimer.stop();
DI.log.info("Tree View with Raw Data Calculated: It has {0} ({1}) Nodes (SubNodes)",
tvTargetTreeView.GetNodeCount(false), tvTargetTreeView.GetNodeCount(true));
}
public void setCheckBox_Checked(int iCheckBoxId, bool bCheckedState)
{
// getCheckBox(iCheckBoxId).Checked = bCheckedState;
CheckBox cTargetCheckBox = getCheckBox(iCheckBoxId);
O2Forms.executeMethodThreadSafe(cTargetCheckBox, cTargetCheckBox, "set_Checked",
new object[] { bCheckedState });
}
private void btSelectDirectory_Click(object sender, EventArgs e)
{
tbCurrentDirectoryName.Text = tbCurrentDirectoryName.Text != "..."
? O2Forms.askUserForDirectory(DI.config.CurrentExecutableDirectory)
: O2Forms.askUserForDirectory(tbCurrentDirectoryName.Text);
refreshDirectoryView();
}
public void mapCommandNamesFromTreeNodes(TreeNodeCollection tncNodes)
{
dgvResolvedCommandName.Columns.Clear();
O2Forms.addToDataGridView_Column(dgvResolvedCommandName, "class", -1);
O2Forms.addToDataGridView_Column(dgvResolvedCommandName, "function", -1);
O2Forms.addToDataGridView_Column(dgvResolvedCommandName, "value", -1);
addToDataGridView_CommandMappingInTreeNode_Recursive(tncNodes, dgvResolvedCommandName);
}
public TreeNode getO2FindingTreeNode(IO2Finding o2Finding, string treeNodeText, string propertyUsed)
{
return(O2Forms.newTreeNode(treeNodeText, propertyUsed,
(o2Finding.o2Traces.Count > 0)
? icon_findingWithTrace
: icon_findingWithNoTrace
, o2Finding));
}
public static void populateTreeNodeWith_FormBeans(TreeNode treeNode, Dictionary <string, IStrutsConfig_FormBean> formBeans)
{
//treeNode.Nodes.Add("ASDASDA");
foreach (var formBean in formBeans)
{
O2Forms.newTreeNode(treeNode.Nodes, formBean.Key, 0, formBean.Value, true);
}
}
private void tvGLEE_NodesToGraph_KeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == '\b') //(char)Keys.Delete)
{
O2Forms.removeSelectedNodeFromTreeView(tvGLEE_NodesToGraph);
loadSmartTraceGraphInGleeViewer(rbGraphAllNodes.Checked);
}
}
private void tvFilteredFindings_DragOver(object sender, DragEventArgs e)
{
TreeNode tnDraggedTarget = O2Forms.getTreeNodeAtDroppedOverPoint(tvFilteredFindings, e.X, e.Y);
if (tnDraggedTarget != null)
{
tvFilteredFindings.SelectedNode = tnDraggedTarget;
}
}
public static void populateTreeNodeWith_ActionServlet(TreeNode treeNode, KStrutsMappings_ActionServlet strutsActionServet)
{
addNodeIfNonEmpty(treeNode, "url pattern", strutsActionServet.urlPattern);
addNodeIfNonEmpty(treeNode, "load on startup", strutsActionServet.loadOnStartUp);
addNodeIfNonEmpty(treeNode, "debug", strutsActionServet.debug);
addNodeIfNonEmpty(treeNode, "validate", strutsActionServet.validate);
addNodeIfNonEmpty(treeNode, "detail", strutsActionServet.detail);
addNodeIfNonEmpty(treeNode, "rule sets", strutsActionServet.ruleSets);
addNodeIfNonEmpty(treeNode, "application", strutsActionServet.application);
var currentUrlPattern =
(strutsActionServet.urlPattern[strutsActionServet.urlPattern.Length - 1] == '*')
? strutsActionServet.urlPattern.Substring(0, strutsActionServet.urlPattern.Length - 1)
: strutsActionServet.urlPattern;
foreach (var filter in strutsActionServet.filters)
{
if (filter.urlPattern == "/*" || filter.urlPattern.StartsWith(currentUrlPattern))
{
var nodeText =
string.Format("Filter: {0} --> {1} --> {2}",
filter.name, filter.urlPattern, filter.@class);
treeNode.Nodes.Add(nodeText);
}
}
/*treeNode.Nodes.Add("debug: " + strutsActionServet.debug);
*
* treeNode.Nodes.Add("detail: " + strutsActionServet.detail);
* treeNode.Nodes.Add("rule sets: " + strutsActionServet.ruleSets);
* treeNode.Nodes.Add("application: " + strutsActionServet.ruleSets);*/
foreach (var configFile in strutsActionServet.configFiles)
{
treeNode.Nodes.Add("config file: " + configFile);
}
foreach (var chainConfigFile in strutsActionServet.chainConfigFiles)
{
treeNode.Nodes.Add("chainConfig file: " + chainConfigFile);
}
if (strutsActionServet.controllers.Count > 0)
{
var controllersNode = O2Forms.newTreeNode(treeNode.Nodes, "controllers", 0,
strutsActionServet.controllers);
controllersNode.Nodes.Add("DummyNode");
}
if (strutsActionServet.formsBeans.Count > 0)
{
var controllersNode = O2Forms.newTreeNode(treeNode.Nodes, "form beans", 0,
strutsActionServet.formsBeans);
controllersNode.Nodes.Add("DummyNode");
}
}
public void saveCurrentList()
{
xmlFile = O2Forms.askUserForFileToSave(xmlFile.directoryName(), xmlFile.fileName());
if (xmlFile.valid())
{
syncProcessDetailsList();
processDetails.serialize(xmlFile);
}
}
public void refreshViews()
{
PublicDI.log.info("Refreshing Views and remaping assemblies");
assembliesLoaded = getAssembliesToLoad(tvExtraAssembliesToLoad);
O2Forms.loadTreeViewWith_AssembliesInCurrentAppDomain(tvExtraAssembliesToLoad, assembliesLoaded, true);
refreshLoadedAssembliesView();
refreshO2ObjectModelView(cbHideCSharpGeneratedMethods.Checked);
showFilteredMethods(null);
}
public void LoadFilesFromDirectory(String sDirectoryToLoad)
{
lbFilesInDirectory.Items.Clear();
O2Forms.loadListBoxWithFilesFromDir(lbFilesInDirectory, sDirectoryToLoad);
if (lbFilesInDirectory.Items.Count > 0)
{
lbFilesInDirectory.SelectedIndex = 0;
}
}
// public ICirDataAnalysis cirDataAnalysis { get; set; }
/*public static void viewCirFunctionSignature(string functionSignature, ICirDataAnalysis _cirDataAnalysis)
* {
* if (_cirDataAnalysis.dCirFunction_bySignature.ContainsKey(functionSignature))
* viewCirFunctionSignature(_cirDataAnalysis.dCirFunction_bySignature[functionSignature], _cirDataAnalysis);
* }*/
public void viewCirFunction(ICirFunction _rootCirFunction)
{
if (_rootCirFunction != null)
{
this.invokeOnThread(
() =>
{
showFunctionAttributes(_rootCirFunction);
laFunctionViewed.Text = _rootCirFunction.FunctionSignature;
rootCirFunction = _rootCirFunction;
currentCirClass = _rootCirFunction.ParentClass;
//tvFunctionIsCalledBy
tvFunctionIsCalledBy.Nodes.Clear();
ViewHelpers.addCirFunctionToTreeNodeCollection(rootCirFunction, "",
tvFunctionIsCalledBy.Nodes,
rootCirFunction.FunctionIsCalledBy.Count > 0);
O2Forms.expandNodes(tvFunctionIsCalledBy);
//tvFunctionMakesCallsTo
tvFunctionMakesCallsTo.Nodes.Clear();
ViewHelpers.addCirFunctionToTreeNodeCollection(rootCirFunction, "",
tvFunctionMakesCallsTo.Nodes,
rootCirFunction.FunctionsCalledUniqueList.Count > 0);
O2Forms.expandNodes(tvFunctionMakesCallsTo);
//tvFunctionInfo
tvFunctionInfo.Nodes.Clear();
ViewHelpers.addCirFunctionToTreeNodeCollection(rootCirFunction, "", tvFunctionInfo.Nodes,
rootCirFunction.FunctionsCalledUniqueList.Count > 0 || rootCirFunction.FunctionIsCalledBy.Count > 0);
O2Forms.expandNodes(tvFunctionInfo);
//tvClassSuperClasses
tvClassSuperClasses.Nodes.Clear();
if (rootCirFunction.ParentClass != null)
{
ViewHelpers.addCirClassToTreeNodeCollection(rootCirFunction.ParentClass, "", tvClassSuperClasses.Nodes,
rootCirFunction.ParentClass.dSuperClasses.Count > 0);
O2Forms.expandNodes(tvClassSuperClasses);
}
//tvClassSuperClasses
tvClassIsSuperClassedBy.Nodes.Clear();
if (rootCirFunction.ParentClass != null)
{
ViewHelpers.addCirClassToTreeNodeCollection(rootCirFunction.ParentClass, "", tvClassIsSuperClassedBy.Nodes,
rootCirFunction.ParentClass.dIsSuperClassedBy.Count > 0);
O2Forms.expandNodes(tvClassIsSuperClassedBy);
}
cbCirFunction_IsTainted.Checked = rootCirFunction.IsTainted;
viewClassMethods();
});
}
}
private void tvCurrentFilters_DragOver(object sender, DragEventArgs e)
{
// DI.log.info("x:{0} y:{1}", e.X, e.Y);
TreeNode tnDraggedTarget = O2Forms.getTreeNodeAtDroppedOverPoint(tvSearchFilters, e.X, e.Y);
if (tnDraggedTarget != null)
{
tvSearchFilters.SelectedNode = tnDraggedTarget;
}
}
