private void ExportMethodNode(MethodTreeNode rootNode)
{
if (rootNode == null)
{
CommonMethod.ErrorMsgBox("没有选择需要输出的模型节点");
return;
}
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.Filter = filter;
if (dlg.ShowDialog() == true)
{
//在temp目录中创建rfdi目录
string rfdiDir = Path.Combine(Path.GetTempPath(), "rfdi_nodeExport");
if (!Directory.Exists(rfdiDir))
{
Directory.CreateDirectory(rfdiDir);
}
CreateZipFileTree(rootNode, rfdiDir);
if (File.Exists(dlg.FileName)) //如果压缩文件存在，删除该文件
{
File.Delete(dlg.FileName);
}
using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(dlg.FileName, Encoding.GetEncoding(SettingData.UTF8)))
{
zip.AddDirectory(rfdiDir);
zip.Save();
}
Directory.Delete(rfdiDir, true);
}
}
//根据内容来选择, 药品名 - 厂家 - 包装
public bool SelectNode(DrugInfo infoToFind)
{
MethodTreeNode chemicalInfo = rootItem.Children.Find(item => item.Name == infoToFind.chemicalName);
if (chemicalInfo == null)
{
return(false);
}
MethodTreeNode productInfo = chemicalInfo.Children.Find(item => item.Name == infoToFind.productUnit);
if (productInfo == null)
{
return(false);
}
MethodTreeNode packInfo = productInfo.Children.Find(item => item.Name == infoToFind.package);
if (packInfo == null)
{
return(false);
}
if (packInfo.Method != infoToFind.ramanMethod)
{
return(false);
}
packInfo.IsExpanded = true;
packInfo.IsSelected = true;
return(true);
}
public MethodInfo Method(MethodDefinition methodDefinition)
{
if (_methodCorrespondence.ContainsKey(methodDefinition))
{
return(_methodCorrespondence[methodDefinition]);
}
var methodInfo = new MethodInfo
{
Text = MethodTreeNode.GetText(methodDefinition, MainWindow.Instance.CurrentLanguage) as string,
Name = methodDefinition.Name,
FullName = methodDefinition.FullName,
Icon = MethodTreeNode.GetIcon(methodDefinition),
IsInternal = methodDefinition.IsAssembly,
IsPrivate = methodDefinition.IsPrivate,
IsPublic = methodDefinition.IsPublic,
IsProtected = methodDefinition.IsFamily,
IsProtectedAndInternal = methodDefinition.IsFamilyAndAssembly,
IsProtectedOrInternal = methodDefinition.IsFamilyOrAssembly,
IsVirtual = methodDefinition.IsVirtual,
IsSpecialName = methodDefinition.IsSpecialName,
IsOverride = IsOverride(methodDefinition),
IsStatic = methodDefinition.IsStatic,
IsFinal = methodDefinition.IsFinal,
MemberReference = methodDefinition
};
_methodCorrespondence.Add(methodDefinition, methodInfo);
return(methodInfo);
}
/// <summary>
/// 样品检测时搜索当前药品模型信息
/// </summary>
/// <param name="chemicalName">药品名称</param>
/// <param name="packageName">包装名称</param>
/// <returns></returns>
public MethodTreeNode SearchFromNewSample(string chemicalName, string packageName)
{
MethodTreeNode chemidcalNode = SearchCurNode(rootItem, chemicalName, false);
if (chemidcalNode == null)
{
return(null);
}
MethodTreeNode packageNode = SearchCurNode(chemidcalNode, packageName, false);
if (packageNode == null)
{
return(chemidcalNode);
}
if (packageNode.Children != null && packageNode.Children.Count > 0)
{
ExpandTreeNode(packageNode, true);
MethodTreeNode firstNode = packageNode.Children[0];
firstNode.IsSelected = true;
return(firstNode);
}
else
{
return(null);
}
}
private void treeDatabase_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (e != null && e.NewValue != null)
{
SelectedNode = e.NewValue as MethodTreeNode;
}
else
{
SelectedNode = null;
}
if (SelectedNode == null || SelectedNode.Method == null)
{
txtMethodName.Text = null;
panelScanParameter.SetScanParameter(null);
}
else
{
txtMethodName.Text = SelectedNode.Method.methodFile;
panelScanParameter.SetScanParameter(SelectedNode.Method.scanPara);
}
RoutedEventArgs args = new RoutedEventArgs();
args.RoutedEvent = MethodSelectEvent;
args.Source = this;
RaiseEvent(args);
}
public override TreeViewNodeFilterResult GetFilterResult(MethodDef method)
{
if (showPublicApi() && !MethodTreeNode.IsPublicAPIInternal(method))
{
return(new TreeViewNodeFilterResult(FilterResult.Hidden, false));
}
return(base.GetFilterResult(method));
}
//导出模型树
private bool CreateZipFileTree(MethodTreeNode currentNode, string parentDirectory)
{
if (currentNode == null)
{
return(true);
}
//创建当前节点的目录, 从1开始顺序增加
string nodename = (currentNode.Name == null) ? "TREEVIEW_ROOT" : currentNode.Name;
int index = 1;
//去除文件名中非法字符，防止错误
char[] badchar = new char[] { '〃', '／', ':', '?', '〈', '〉', '*', '\\' };
foreach (char st in badchar)
{
nodename = nodename.Replace(st, '-');
}
string nodedir = Path.Combine(parentDirectory, nodename);
while (Directory.Exists(nodedir)) //为了防止目录名称重复，在重复的目录后面增加序号
{
nodedir = Path.Combine(parentDirectory, nodename + index);
index++;
}
Directory.CreateDirectory(nodedir);
//在当前节点目录下用methodnode.name记录本节点的名称
string namefile = Path.Combine(nodedir, "methodnode.name");
StreamWriter writer = new StreamWriter(namefile, false, Encoding.GetEncoding(SettingData.UTF8));
writer.WriteLine(nodename);
writer.Close();
//是模型信息, 需要拷贝相应的模型文件和引用光谱文件，并做相应处理
if (currentNode.Method != null)
{
if (CopyMethodFiles(currentNode.Method, nodedir) == false)
{
return(false);
}
}
//是模型节点，继续处理下一级节点
if (currentNode.Children != null)
{
foreach (MethodTreeNode node in currentNode.Children)
{
if (CreateZipFileTree(node, nodedir) == false)
{
return(false);
}
}
}
return(true);
}
void Search(DnSpyFile ownerModule, TypeDef type, MethodDef method)
{
var res = filter.GetFilterResult(method);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
ImplMap im;
if (res.IsMatch && (IsMatch(method.Name, method) || ((im = method.ImplMap) != null && (IsMatch(im.Name, im) || IsMatch(im.Module == null ? null : im.Module.Name, null)))))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
return;
}
res = filter.GetFilterResultParamDefs(method);
if (res.FilterResult != FilterResult.Hidden)
{
foreach (var pd in method.ParamDefs)
{
res = filter.GetFilterResult(method, pd);
if (res.FilterResult == FilterResult.Hidden)
{
continue;
}
if (res.IsMatch && IsMatch(pd.Name, pd))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
return;
}
}
}
SearchBody(ownerModule, type, method);
}
protected override void Write(ITextOutput output, Language language)
{
if (hidesParent)
{
output.Write('(', TextTokenType.Operator);
output.Write("hides", TextTokenType.Text);
output.Write(')', TextTokenType.Operator);
output.WriteSpace();
}
Language.TypeToString(output, analyzedMethod.DeclaringType, true);
output.Write('.', TextTokenType.Operator);
MethodTreeNode.Write(output, analyzedMethod, Language);
}
//展开或者收缩一个Node
private void ExpandTreeNode(MethodTreeNode parentData, bool expand)
{
if (parentData == null)
{
return;
}
foreach (MethodTreeNode item in parentData.Children)
{
item.IsExpanded = expand;
ExpandTreeNode(item, expand);
}
}
void Search(LoadedAssembly ownerModule, TypeDef type, MethodDef method)
{
var res = filter.GetFilterResult(method);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (res.IsMatch && IsMatch(method.Name, method))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
return;
}
res = filter.GetFilterResultParamDefs(method);
if (res.FilterResult != FilterResult.Hidden)
{
foreach (var pd in method.ParamDefs)
{
res = filter.GetFilterResult(method, pd);
if (res.FilterResult == FilterResult.Hidden)
{
continue;
}
if (res.IsMatch && IsMatch(pd.Name, pd))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
return;
}
}
}
SearchBody(ownerModule, type, method);
}
private void btnImport_Click(object sender, RoutedEventArgs e)
{
if (treeMethod.SelectedNode == null || treeMethod.SelectedNode.Method != null)
{
CommonMethod.ErrorMsgBox("请选择类型节点后再导入模型");
return;
}
MethodTreeNode importNode = ImportMethodPackageFile();
if (importNode == null)
{
return;
}
treeMethod.AddNodeFromPackage(treeMethod.SelectedNode, importNode);
}
//删除节点
public void DeleteNode(MethodTreeNode delNode)
{
if (delNode == null || delNode.Parent == null || delNode == rootItem)
{
return;
}
//从数据库中删除
using (DBConnection db = new DBConnection())
{
db.DeleteTreeNode(delNode);
}
delNode.Parent.Children.Remove(delNode);
treeDatabase.Items.Refresh();
}
MethodDefSettingsCommand(MethodTreeNode methodNode, MethodDefOptions options)
{
this.methodNode = methodNode;
this.newOptions = options;
this.origOptions = new MethodDefOptions(methodNode.MethodDefinition);
this.origParentNode = (ILSpyTreeNode)methodNode.Parent;
this.origParentChildIndex = this.origParentNode.Children.IndexOf(methodNode);
Debug.Assert(this.origParentChildIndex >= 0);
if (this.origParentChildIndex < 0)
{
throw new InvalidOperationException();
}
this.nameChanged = origOptions.Name != newOptions.Name;
}
public MethodTreeNode FindNodeWithMethodInfo(MethodTreeNode parent, MethodInfo info)
{
if (info == null || parent == null)
{
return(null);
}
if (parent.Method != null)
{
//比较Raman方法
if (String.Compare(parent.Method.methodFile, info.methodFile, true) == 0)
{
//比较组分
if (parent.Method.components.Count == info.components.Count)
{
bool found = false;
for (int i = 0; i < parent.Method.components.Count; i++) //查看是否有不相同的组分
{
if (!parent.Method.components[i].IsSameComponent(info.components[i]))
{
found = true;
break;
}
}
if (!found) //没找到不同，表示已经找到该方法
{
return(parent);
}
}
}
}
if (parent.Children != null)
{
foreach (MethodTreeNode childnode in parent.Children)
{
MethodTreeNode foundnode = FindNodeWithMethodInfo(childnode, info);
if (foundnode != null)
{
return(foundnode);
}
}
}
return(null);
}
//编辑时的确认按钮
private void gridOkCancel_OKClicked(object sender, RoutedEventArgs e)
{
MethodTreeNode newNode = null;
switch (newNodeType)
{
case 0: //新增同级目录
case 1: //新增子目录
if (txtItemName.Text == null || txtItemName.Text.Trim() == "")
{
CommonMethod.ErrorMsgBox("请输入类型节点的名称");
return;
}
newNode = new MethodTreeNode();
newNode.Name = txtItemName.Text;
treeMethod.AddNode(newNode, false); //永远是增加下一层节点
break;
case 2: //新增模型信息
if (!methodPanel.UpdateData())
{
return;
}
newNode = new MethodTreeNode();
newNode.Method = newMethodInfo;
treeMethod.AddNode(newNode, false); //永远是增加下一层节点
break;
case 3: //修改当前目录
SelectedNode.Name = txtItemName.Text;
treeMethod.ModifyNode(SelectedNode);
break;
case 4: //修改当前模型信息
methodPanel.UpdateData();
SelectedNode.Method = newMethodInfo;
treeMethod.ModifyNode(SelectedNode);
break;
}
NodeSelectChanged();
}
//搜索父目录中排列在当前目录后面的目录（index+1）
private MethodTreeNode SearchParent(MethodTreeNode curNode, string searchStr)
{
if (curNode.Parent == null)
{
return(null);
}
int index = curNode.Parent.Children.IndexOf(curNode); //当前目录的序号
for (int i = index + 1; i < curNode.Parent.Children.Count; i++) //从下一个开始搜索
{
MethodTreeNode foundNode = SearchCurNode(curNode.Parent.Children[i], searchStr, true);
if (foundNode != null)
{
return(foundNode);
}
}
return(SearchParent(curNode.Parent, searchStr));
}
//增加节点或者模型
public void AddNode(MethodTreeNode newNode, bool sameLevel)
{
if (SelectedNode == null)
{
newNode.Parent = rootItem;
newNode.parentID = 0;
rootItem.Children.Add(newNode);
}
else
{
if (sameLevel)
{
newNode.Parent = SelectedNode.Parent;
newNode.parentID = SelectedNode.parentID;
SelectedNode.Parent.Children.Add(newNode);
}
else
{
newNode.Parent = SelectedNode;
newNode.parentID = SelectedNode.ID;
SelectedNode.Children.Add(newNode);
}
}
newNode.IsExpanded = true;
newNode.IsSelected = true;
treeDatabase.Items.Refresh();
//插入到数据库中
using (DBConnection db = new DBConnection())
{
if (newNode.Method == null) //插入树节点
{
db.InsertTreeNode(newNode);
}
else //插入模型信息
{
newNode.Method.nodeID = newNode.parentID;
db.InsertMethodInfo(newNode.Method);
}
}
}
//修改节点
public void ModifyNode(MethodTreeNode modifyNode)
{
if (modifyNode == rootItem)
{
return;
}
//从数据库中删除
using (DBConnection db = new DBConnection())
{
if (modifyNode.Method == null)
{
db.UpdateTreeNode(modifyNode);
}
else
{
db.UpdateMethodInfo(modifyNode.Method);
}
}
}
MethodDefSettingsCommand(MethodTreeNode methodNode, MethodDefOptions options)
{
this.methodNode = methodNode;
this.newOptions = options;
this.origOptions = new MethodDefOptions(methodNode.MethodDef);
this.origParentNode = (ILSpyTreeNode)methodNode.Parent;
this.origParentChildIndex = this.origParentNode.Children.IndexOf(methodNode);
Debug.Assert(this.origParentChildIndex >= 0);
if (this.origParentChildIndex < 0)
{
throw new InvalidOperationException();
}
this.nameChanged = origOptions.Name != newOptions.Name;
if (this.nameChanged)
{
this.memberRefInfos = RefFinder.FindMemberRefsToThisModule(ILSpyTreeNode.GetModule(methodNode)).Where(a => RefFinder.MethodEqualityComparerInstance.Equals(a, methodNode.MethodDef)).Select(a => new Field.MemberRefInfo(a)).ToArray();
}
}
/// <summary>
/// 将nodeToAdd下面的节点加载到parentNode下
/// </summary>
/// <param name="parentNode">父节点</param>
/// <param name="packageNode">打包的节点</param>
public void AddNodeFromPackage(MethodTreeNode parentNode, MethodTreeNode packageNode)
{
//将packageNode下面的节点添加到数据库中，不包含packageNode本身，以防止从ROOT导出的节点不能添加到ROOT下面
foreach (MethodTreeNode subnode in packageNode.Children)
{
InsertNodeToDatabase(parentNode, subnode);
}
if (packageNode.Method != null) //只是模型节点
{
parentNode.Children.Add(packageNode);
}
else //是类型节点，放到当前类型节点下面
{
parentNode.Children.AddRange(packageNode.Children);
}
treeDatabase.Items.Refresh();
parentNode.IsExpanded = true;
}
private MethodTreeNode SearchNodeFromInfo(MethodTreeNode parentItem, DrugInfo infoToFind)
{
if (parentItem == null || infoToFind == null)
{
return(null);
}
if (parentItem.Method == infoToFind.ramanMethod)
{
return(parentItem);
}
foreach (MethodTreeNode subItem in parentItem.Children)
{
MethodTreeNode subNode = SearchNodeFromInfo(subItem, infoToFind);
if (subNode != null)
{
return(subNode);
}
}
return(null);
}
public DatabaseTree()
{
InitializeComponent();
if ((bool)DesignerProperties.IsInDesignModeProperty.GetMetadata(typeof(DependencyObject)).DefaultValue == false) //设计模式不可用
{
rootItem = SettingData.rootMethodTreeNode;
}
else
{
rootItem = new MethodTreeNode();
}
rootItem.parentID = 0;
//新建临时根节点tempRootItem，让rootItem成为tempRootItem的唯一子节点，在树图中显示rootItem，这样方便操作
MethodTreeNode tempRootItem = new MethodTreeNode();
rootItem.Name = "ROOT";
tempRootItem.Children.Add(rootItem);
treeDatabase.ItemsSource = tempRootItem.Children;
}
//在当前目录及其子目录下搜索内容, useIndexOf:True=包含字符串，False=等于字符串
private MethodTreeNode SearchCurNode(MethodTreeNode curNode, string searchStr, bool useIndexOf)
{
if (useIndexOf)
{
if (curNode.Name.IndexOf(searchStr, 0, StringComparison.OrdinalIgnoreCase) >= 0)
{
return(curNode);
}
}
else
{
//模型名称前面有可能会包含001-这样的字符
string realName;
int i = curNode.Name.IndexOf('-');
if (i < 6 && i < curNode.Name.Length - 1)
{
realName = curNode.Name.Substring(i + 1);
}
else
{
realName = curNode.Name;
}
if (realName.Equals(searchStr, StringComparison.OrdinalIgnoreCase) == true)
{
return(curNode);
}
}
foreach (MethodTreeNode node in curNode.Children)
{
MethodTreeNode foundNode = SearchCurNode(node, searchStr, useIndexOf);
if (foundNode != null)
{
return(foundNode);
}
}
return(null);
}
/// <summary>
/// 将节点数添加到数据库中，同时更新ID和parentID
/// </summary>
/// <param name="parentNode">父节点</param>
/// <param name="nodeToInsert">当前需要添加的节点</param>
private void InsertNodeToDatabase(MethodTreeNode parentNode, MethodTreeNode nodeToInsert)
{
nodeToInsert.parentID = parentNode.ID;
nodeToInsert.Parent = parentNode;
using (DBConnection db = new DBConnection())
{
if (nodeToInsert.Method != null) //如果包含模型信息，需要插入模型信息表
{
nodeToInsert.Method.nodeID = parentNode.ID; //指明这是属于nodetToInsert的方法信息
db.InsertMethodInfo(nodeToInsert.Method);
}
else
{
db.InsertTreeNode(nodeToInsert); //插入节点信息表
}
}
foreach (MethodTreeNode subnode in nodeToInsert.Children)
{
InsertNodeToDatabase(nodeToInsert, subnode);
}
}
IBitmap GetIcon(IEntity member)
{
switch (member)
{
case ITypeDefinition t:
return(TypeTreeNode.GetIcon(t));
case IField f:
return(FieldTreeNode.GetIcon(f));
case IProperty p:
return(PropertyTreeNode.GetIcon(p));
case IMethod m:
return(MethodTreeNode.GetIcon(m));
case IEvent e:
return(EventTreeNode.GetIcon(e));
default:
throw new NotSupportedException(member?.GetType() + " not supported!");
}
}
void PerformSearch(TypeDefinition type)
{
if (searchMode == SearchMode_Type && IsMatch(type.Name))
{
AddResult(new SearchResult {
Member = type,
Image = TypeTreeNode.GetIcon(type),
Name = language.TypeToString(type, includeNamespace: false),
LocationImage = type.DeclaringType != null ? TypeTreeNode.GetIcon(type.DeclaringType) : Images.Namespace,
Location = type.DeclaringType != null ? language.TypeToString(type.DeclaringType, includeNamespace: true) : type.Namespace
});
}
foreach (TypeDefinition nestedType in type.NestedTypes)
{
PerformSearch(nestedType);
}
if (searchMode == SearchMode_Type)
{
return;
}
foreach (FieldDefinition field in type.Fields)
{
if (IsMatch(field))
{
AddResult(new SearchResult {
Member = field,
Image = FieldTreeNode.GetIcon(field),
Name = field.Name,
LocationImage = TypeTreeNode.GetIcon(type),
Location = language.TypeToString(type, includeNamespace: true)
});
}
}
foreach (PropertyDefinition property in type.Properties)
{
if (IsMatch(property))
{
AddResult(new SearchResult {
Member = property,
Image = PropertyTreeNode.GetIcon(property),
Name = property.Name,
LocationImage = TypeTreeNode.GetIcon(type),
Location = language.TypeToString(type, includeNamespace: true)
});
}
}
foreach (EventDefinition ev in type.Events)
{
if (IsMatch(ev))
{
AddResult(new SearchResult {
Member = ev,
Image = EventTreeNode.GetIcon(ev),
Name = ev.Name,
LocationImage = TypeTreeNode.GetIcon(type),
Location = language.TypeToString(type, includeNamespace: true)
});
}
}
foreach (MethodDefinition method in type.Methods)
{
switch (method.SemanticsAttributes)
{
case MethodSemanticsAttributes.Setter:
case MethodSemanticsAttributes.Getter:
case MethodSemanticsAttributes.AddOn:
case MethodSemanticsAttributes.RemoveOn:
case MethodSemanticsAttributes.Fire:
continue;
}
if (IsMatch(method))
{
AddResult(new SearchResult {
Member = method,
Image = MethodTreeNode.GetIcon(method),
Name = method.Name,
LocationImage = TypeTreeNode.GetIcon(type),
Location = language.TypeToString(type, includeNamespace: true)
});
}
}
}
public StatementCompiler(MethodTreeNode node)
{
this.node = node;
}
void SearchBody(DnSpyFile ownerModule, TypeDef type, MethodDef method, out bool loadedBody)
{
loadedBody = false;
CilBody body;
var res = filter.GetFilterResultLocals(method);
if (res.FilterResult != FilterResult.Hidden)
{
body = method.Body;
if (body == null)
{
return; // Return immediately. All code here depends on a non-null body
}
loadedBody = true;
foreach (var local in body.Variables)
{
res = filter.GetFilterResult(method, local);
if (res.FilterResult == FilterResult.Hidden)
{
continue;
}
if (res.IsMatch && IsMatch(local.Name, local))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
return;
}
}
}
res = filter.GetFilterResultBody(method);
if (res.FilterResult == FilterResult.Hidden)
{
return;
}
if (!res.IsMatch)
{
return;
}
body = method.Body;
if (body == null)
{
return; // Return immediately. All code here depends on a non-null body
}
loadedBody = true;
foreach (var instr in body.Instructions)
{
object operand;
// Only check numbers and strings. Don't pass in any type of operand to IsMatch()
switch (instr.OpCode.Code)
{
case Code.Ldc_I4_M1: operand = -1; break;
case Code.Ldc_I4_0: operand = 0; break;
case Code.Ldc_I4_1: operand = 1; break;
case Code.Ldc_I4_2: operand = 2; break;
case Code.Ldc_I4_3: operand = 3; break;
case Code.Ldc_I4_4: operand = 4; break;
case Code.Ldc_I4_5: operand = 5; break;
case Code.Ldc_I4_6: operand = 6; break;
case Code.Ldc_I4_7: operand = 7; break;
case Code.Ldc_I4_8: operand = 8; break;
case Code.Ldc_I4:
case Code.Ldc_I4_S:
case Code.Ldc_R4:
case Code.Ldc_R8:
case Code.Ldstr: operand = instr.Operand; break;
default: operand = null; break;
}
if (operand != null && IsMatch(null, operand))
{
onMatch(new SearchResult {
Language = language,
Object = method,
NameObject = method,
TypeImageInfo = MethodTreeNode.GetImageInfo(method, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
DnSpyFile = ownerModule,
});
break;
}
}
}
protected override int CompareMethods(PropertyTreeNode x, MethodTreeNode y)
{
return(CompareByName(x, y));
}
void onReportOpened(object sender, EventArgs e)
{
BeginUpdate();
ICoverageReport report = serviceContainer.GetService<ICoverageReportService>().Report;
foreach (IAssembly assembly in report.GetAssemblies())
{
AssemblyTreeNode asmNode = new AssemblyTreeNode(assembly);
Nodes.Add(asmNode);
foreach (IClass dType in assembly.GetTypes())
{
TreeNode namespaceNode = GetNamespaceNode(asmNode, dType);
ClassTreeNode classNode = new ClassTreeNode(dType);
namespaceNode.Nodes.Add(classNode);
Dictionary<string, PropertyTreeNode> props = new Dictionary<string, PropertyTreeNode>();
foreach (IMethod md in dType.GetMethods())
{
if (!Methods.isSpecial(md.Flags))
{
AddMethodTreeNode(classNode, md);
continue;
}
//has special meaning
MdSpecial mdSpecial = Methods.getMdSpecial(md.Name);
if (mdSpecial == MdSpecial.Unknown)
{
AddMethodTreeNode(classNode, md);
continue;
}
string propName = Methods.getMdSpecialName(md.Name);
PropertyTreeNode propertyNode;
if (!props.TryGetValue(propName, out propertyNode))
{
propertyNode = new PropertyTreeNode(propName);
props[propName] = propertyNode;
classNode.Nodes.Add(propertyNode);
}
MethodTreeNode mdNode = new MethodTreeNode(md);
mdNode.MethodName = mdSpecial.ToString().ToLowerInvariant();
switch (mdSpecial)
{
case MdSpecial.Get:
mdNode.ImageIndex = ImageSelector.forPropertyGet(md);
mdNode.SelectedImageIndex = ImageSelector.forPropertyGet(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Remove:
mdNode.ImageIndex = ImageSelector.forEventRemove(md);
mdNode.SelectedImageIndex = ImageSelector.forEventRemove(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Set:
mdNode.ImageIndex = ImageSelector.forPropertySet(md);
mdNode.SelectedImageIndex = ImageSelector.forPropertySet(md);
propertyNode.Setter = mdNode;
break;
case MdSpecial.Add:
mdNode.ImageIndex = ImageSelector.forEventAdd(md);
mdNode.SelectedImageIndex = ImageSelector.forEventAdd(md);
propertyNode.Setter = mdNode;
break;
}
}
foreach (KeyValuePair<string, PropertyTreeNode> kv in props)
{
if (kv.Value.Getter != null) kv.Value.Nodes.Add(kv.Value.Getter);
if (kv.Value.Setter != null) kv.Value.Nodes.Add(kv.Value.Setter);
}
}
asmNode.UpdateCoverageInfo();
}
EndUpdate();
}
private static void AddMethodTreeNode(TreeNode classNode, IMethod md)
{
MethodTreeNode mNode = new MethodTreeNode(md);
classNode.Nodes.Add(mNode);
if (md.CoveredVariants.Length > 1)
{
foreach (ICoveredVariant bData in md.CoveredVariants)
mNode.Nodes.Add(new BlockVariantTreeNode(bData));
}
}
MethodBodySettingsCommand(MethodTreeNode methodNode, MethodBodyOptions options)
{
this.methodNode = methodNode;
this.newOptions = options;
this.origMethodBody = methodNode.MethodDefinition.MethodBody;
}
void OnReportOpened(object sender, EventArgs e)
{
BeginUpdate();
var report = serviceContainer.getService<IReportService>().Report;
foreach (var assembly in report.Assemblies)
{
var asmNode = new AssemblyTreeNode(assembly);
Nodes.Add(asmNode);
foreach (var dType in assembly.Types)
{
var namespaceNode = GetNamespaceNode(asmNode, dType);
var classNode = new ClassTreeNode(dType);
namespaceNode.Nodes.Add(classNode);
var props = new Dictionary<string, PropertyTreeNode>();
foreach (var md in dType.Methods)
{
if (!Methods.IsSpecial(md.Flags))
{
AddMethodTreeNode(classNode, md);
continue;
}
//has special meaning
var mdSpecial = Methods.GetMdSpecial(md.Name);
if (mdSpecial == MdSpecial.Unknown)
{
AddMethodTreeNode(classNode, md);
continue;
}
var propName = Methods.GetMdSpecialName(md.Name);
PropertyTreeNode propertyNode;
if (!props.TryGetValue(propName, out propertyNode))
{
propertyNode = new PropertyTreeNode(propName);
props[propName] = propertyNode;
classNode.Nodes.Add(propertyNode);
}
var mdNode = new MethodTreeNode(md)
{
//MethodName = mdSpecial.ToString().ToLowerInvariant()
};
switch (mdSpecial)
{
case MdSpecial.Get:
mdNode.ImageIndex = ImageSelector.ForPropertyGet(md);
mdNode.SelectedImageIndex = ImageSelector.ForPropertyGet(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Remove:
mdNode.ImageIndex = ImageSelector.ForEventRemove(md);
mdNode.SelectedImageIndex = ImageSelector.ForEventRemove(md);
propertyNode.Getter = mdNode;
break;
case MdSpecial.Set:
mdNode.ImageIndex = ImageSelector.ForPropertySet(md);
mdNode.SelectedImageIndex = ImageSelector.ForPropertySet(md);
propertyNode.Setter = mdNode;
break;
case MdSpecial.Add:
mdNode.ImageIndex = ImageSelector.ForEventAdd(md);
mdNode.SelectedImageIndex = ImageSelector.ForEventAdd(md);
propertyNode.Setter = mdNode;
break;
}
}
foreach (var kv in props)
{
if (kv.Value.Getter != null) kv.Value.Nodes.Add(kv.Value.Getter);
if (kv.Value.Setter != null) kv.Value.Nodes.Add(kv.Value.Setter);
}
}
asmNode.UpdateCoverageInfo();
}
EndUpdate();
}
