public virtual void Search(TypeDefinition type, Language language, Action <SearchResult> addResult)
{
Add(type.Fields, type, language, addResult, IsMatch, FieldTreeNode.GetIcon);
Add(type.Properties, type, language, addResult, IsMatch, p => PropertyTreeNode.GetIcon(p));
Add(type.Events, type, language, addResult, IsMatch, EventTreeNode.GetIcon);
Add(type.Methods.Where(NotSpecialMethod), type, language, addResult, IsMatch, MethodTreeNode.GetIcon);
}
public PropertyInfo Property(PropertyDefinition propertyDefinition)
{
if (_propertyCorrespondence.ContainsKey(propertyDefinition))
{
return(_propertyCorrespondence[propertyDefinition]);
}
var propertyInfo = new PropertyInfo
{
Text = PropertyTreeNode.GetText(propertyDefinition, MainWindow.Instance.CurrentLanguage) as string,
Name = propertyDefinition.Name,
FullName = propertyDefinition.FullName,
Icon = PropertyTreeNode.GetIcon(propertyDefinition),
IsVirtual = propertyDefinition.GetMethod != null && propertyDefinition.GetMethod.IsVirtual ||
propertyDefinition.SetMethod != null && propertyDefinition.SetMethod.IsVirtual,
IsOverride = propertyDefinition.GetMethod != null &&
propertyDefinition.GetMethod.IsVirtual &&
!propertyDefinition.GetMethod.IsNewSlot ||
propertyDefinition.SetMethod != null &&
propertyDefinition.SetMethod.IsVirtual &&
!propertyDefinition.SetMethod.IsNewSlot,
IsStatic = propertyDefinition.GetMethod != null && propertyDefinition.GetMethod.IsStatic ||
propertyDefinition.SetMethod != null && propertyDefinition.SetMethod.IsStatic,
IsFinal = propertyDefinition.GetMethod != null && propertyDefinition.GetMethod.IsFinal ||
propertyDefinition.SetMethod != null && propertyDefinition.SetMethod.IsFinal,
MemberReference = propertyDefinition
};
AdjustPropertyVisibility(propertyInfo, propertyDefinition);
_propertyCorrespondence.Add(propertyDefinition, propertyInfo);
return(propertyInfo);
}
// Updates the parent properties- size or acl or both. If all required properties have been updated for the parent then recursively move up the tree and keep doing the same
private void UpdateParentProperty(PropertyTreeNode currentNode, bool firstTurn)
{
if (currentNode.CheckAndUpdateParentProperties(_manager.GetAclProperty, _manager.GetSizeProperty, firstTurn))
{
if (PropertyManager.PropertyJobLog.IsDebugEnabled)
{
var pn = currentNode.ParentNode;
PropertyManager.PropertyJobLog.Debug(
$"{JobType()}.UpdateParentPorperty, JobEntryName: {_currentNode.FullPath}, ParentNode: {pn.FullPath}, AllChildPropertiesUpdated{(_manager.GetSizeProperty ? $", TotFiles: {pn.TotChildFiles}, TotDirecs: {pn.TotChildDirec}, Totsizes: {pn.TotChildSize}" : string.Empty)}{(_manager.GetAclProperty ? $", IsAclSameForAllChilds: {pn.AllChildSameAcl}" : string.Empty)}");
}
// Everything below currentNode.ParentNode is done- now put job for dumping
EnqueueWritingJobForAllChilds(currentNode.ParentNode);
if (currentNode.ParentNode.DepthLevel == 0)
{
_manager.ConsumerQueue.Add(new PoisonJob());
}
else
{
UpdateParentProperty(currentNode.ParentNode, false);
}
}
else
{
if (PropertyManager.PropertyJobLog.IsDebugEnabled)
{
var pn = currentNode.ParentNode;
PropertyManager.PropertyJobLog.Debug(
$"{JobType()}.UpdateParentPorperty, JobEntryNode: {_currentNode.FullPath}, ParentNode: {pn.FullPath}{(_manager.GetSizeProperty ? $", TotChildSizeDone: {pn.GetNumChildDirectoryProcessed()}/{pn.ChildDirectoryNodes.Count}, TotFiles: {pn.TotChildFiles}, TotDirecs: {pn.TotChildDirec}, Totsizes: {pn.TotChildSize}" : string.Empty)}{(_manager.GetAclProperty ? $", TotChildSizeDone: {pn.GetNumChildsAclProcessed()}/{pn.ChildDirectoryNodes.Count + pn.ChildFileNodes.Count}, IsAclSameForAllChilds: {pn.AllChildSameAcl}" : string.Empty)}");
}
}
}
public override TreeViewNodeFilterResult GetFilterResult(PropertyDef prop)
{
if (showPublicApi() && !PropertyTreeNode.IsPublicAPIInternal(prop))
{
return(new TreeViewNodeFilterResult(FilterResult.Hidden, false));
}
return(base.GetFilterResult(prop));
}
/// <summary>
/// Adds a new properties node.
/// </summary>
/// <param name="label">Node label.</param>
/// <returns>Newly created control</returns>
public Properties Add(string label)
{
PropertyTreeNode node = new PropertyTreeNode(this);
node.Text = label;
return(node.Properties);
}
/// <summary>
/// Handles the splitter moved event.
/// </summary>
/// <param name="control">Event source.</param>
protected virtual void OnSplitterMoved(ControlBase control, EventArgs args)
{
LabelWidth = m_SplitterBar.ActualLeft - Padding.Left;
PropertyTreeNode node = Parent as PropertyTreeNode;
if (node != null)
{
node.PropertyTree.LabelWidth = LabelWidth;
}
}
/// <summary>
/// Adds a new properties node.
/// </summary>
/// <param name="label">Node label.</param>
/// <returns>Newly created control</returns>
public PropertyTable Add(string label, int startingbarposition = 80)
{
PropertyTreeNode node = new PropertyTreeNode(this);
node.Text = label;
PropertyTable props = new PropertyTable(node, startingbarposition);
props.Dock = Dock.Fill;
props.AutoSizeToContents = true;
node.Table = props;
return(props);
}
/// <summary>
/// Opens the node and all child nodes.
/// </summary>
public void ExpandAll()
{
foreach (ControlBase child in Children)
{
PropertyTreeNode node = child as PropertyTreeNode;
if (node == null)
{
continue;
}
node.Open();
}
}
/// <summary>
/// Adds a new properties node.
/// </summary>
/// <param name="label">Node label.</param>
/// <returns>Newly created control</returns>
public Properties Add(String label)
{
TreeNode node = new PropertyTreeNode(this);
node.Text = label;
node.Dock = Pos.Top;
Properties props = new Properties(node);
props.Dock = Pos.Top;
return(props);
}
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, analyzedProperty.DeclaringType, true);
output.Write('.', TextTokenType.Operator);
PropertyTreeNode.Write(output, analyzedProperty, Language, isIndexer);
}
/// <summary>
/// Adds a new properties node.
/// </summary>
/// <param name="label">Node label.</param>
/// <returns>Newly created control</returns>
public Properties Add(string label)
{
TreeNode node = new PropertyTreeNode(this)
{
Text = label,
Dock = Pos.Top
};
Properties props = new Properties(node)
{
Dock = Pos.Top
};
return(props);
}
private void LoadProperty(TreeNode parentNode, PropertyInfo ptd)
{
TreeNode n;
if (ptd.CanWrite)
{
n = new PropertyTreeNode(ptd, true);
parentNode.Nodes.Add(n);
}
else
{
n = new PropertyTreeNode(ptd, false);
parentNode.Nodes.Add(n);
}
}
PropertyDefSettingsCommand(PropertyTreeNode propNode, PropertyDefOptions options)
{
this.propNode = propNode;
this.newOptions = options;
this.origOptions = new PropertyDefOptions(propNode.PropertyDefinition);
this.origParentNode = (ILSpyTreeNode)propNode.Parent;
this.origParentChildIndex = this.origParentNode.Children.IndexOf(propNode);
Debug.Assert(this.origParentChildIndex >= 0);
if (this.origParentChildIndex < 0)
{
throw new InvalidOperationException();
}
this.nameChanged = origOptions.Name != newOptions.Name;
}
// Updates the parent properties- size or acl or both. If all required properties have been updated for the parent then recursively move up the tree and keep doing the same
private void UpdateParentProperty(PropertyTreeNode currentNode, bool firstTurn)
{
if (currentNode.CheckAndUpdateParentProperties(_manager.GetAclProperty, _manager.GetSizeProperty, firstTurn))
{
// Everything below currentNode.ParentNode is done- now put job for dumping
EnqueueWritingJobForAllChilds(currentNode.ParentNode);
if (currentNode.ParentNode.DepthLevel == 0)
{
_manager.ConsumerQueue.Add(new PoisonJob());
}
else
{
UpdateParentProperty(currentNode.ParentNode, false);
}
}
}
void Search(LoadedAssembly ownerModule, TypeDef type, PropertyDef prop) {
var res = filter.GetFilterResult(prop);
if (res.FilterResult == FilterResult.Hidden)
return;
if (res.IsMatch && IsMatch(prop.Name, prop)) {
onMatch(new SearchResult {
Language = language,
Object = prop,
NameObject = prop,
TypeImageInfo = PropertyTreeNode.GetImageInfo(prop, BackgroundType.Search),
LocationObject = type,
LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
LoadedAssembly = ownerModule,
});
}
}
private static void TestTreeNode(PropertyTreeNode node, int recurseLevel)
{
GetExpectedOutput(_oneLevelDirCount, _oneLevelFileCnt, recurseLevel, _oneFileSize, out var expectedFileCount, out var expectedDirCount, out var expectedFileSize);
Assert.IsTrue(node.TotChildFiles == expectedFileCount);
Assert.IsTrue(node.TotChildDirec == expectedDirCount);
Assert.IsTrue(node.TotChildSize == expectedFileSize);
if (recurseLevel > 0)
{
Assert.IsTrue(node.DirectChildFiles == _oneLevelFileCnt);
Assert.IsTrue(node.DirectChildDirec == _oneLevelDirCount);
Assert.IsTrue(node.DirectChildSize == _oneLevelFileCnt * _oneFileSize);
}
foreach (var dirNode in node.ChildDirectoryNodes)
{
TestTreeNode(dirNode, recurseLevel - 1);
}
}
private Node Variable()
{
// VARIABLE_DEF VARIABLE ASSIGN
Token variable = Match(TokenType.VARIABLE);
VariableNode varNode = new VariableNode(variable.Position, variable.Text);
TokenType next = LookAhead(1);
if (next == TokenType.LBRACKET)
{
SourcePosition pos = Match(TokenType.LBRACKET).Position;
Node key = Expression();
Match(TokenType.RBRACKET);
return(new LookupNode(pos, varNode, key));
}
else if (LookAhead(1) == TokenType.PERIOD)
{
Match(TokenType.PERIOD);
PropertyTreeNode propertyTree = new PropertyTreeNode(varNode.Position, varNode, Property());
if (LookAhead(1) == TokenType.END_STATEMENT)
{
Match(TokenType.END_STATEMENT);
}
return(propertyTree);
}
else if (LookAhead(1) == TokenType.COLON)
{
PropertyNode property = new PropertyNode(variable.Position, variable.Text);
Match(TokenType.COLON);
Node value = Expression();
if (LookAhead(1) == TokenType.COMMA)
{
Match(TokenType.COMMA);
}
return(new AssignNode(property.Position, property, value, true));
}
else
{
return(varNode);
}
}
// Once all childs have updated the parent properties, put jobs for dumping the properties of the childs of that parent
private void EnqueueWritingJobForAllChilds(PropertyTreeNode currentNode)
{
try
{
if (currentNode.DepthLevel > _manager.MaxDepth - 1)
{
return;
}
// Do not show the children's acl information since parent has a consistent acl and user want to see consistent acl only
bool skipChildAclOuput = _manager.GetAclProperty && _manager.DisplayConsistentAclTree && currentNode.AllChildSameAcl;
// If we are viewing acl only then no need to show the children since parent has consistent acl
if (skipChildAclOuput && !_manager.GetSizeProperty)
{
return;
}
foreach (var dirNode in currentNode.ChildDirectoryNodes)
{
dirNode.SkipAclOutput = skipChildAclOuput;
_manager.ConsumerQueue.Add(new DumpFilePropertyJob(_manager, dirNode));
}
// For files: If user is viewing sizes only then only show files if user has explicitly specified DisplayFiles.
// If acl then show files if it is necessary to show acl infromation for files
if (_manager.DisplayFiles || _manager.GetAclProperty && !skipChildAclOuput)
{
foreach (var fileNode in currentNode.ChildFileNodes)
{
fileNode.SkipAclOutput = skipChildAclOuput;
_manager.ConsumerQueue.Add(new DumpFilePropertyJob(_manager, fileNode));
}
}
}
finally
{
if (!_manager.DontDeleteChildNodes)
{
currentNode.ChildDirectoryNodes = null;
currentNode.ChildFileNodes = null;
}
}
}
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(TypeDef 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.String
});
}
foreach (TypeDef nestedType in type.NestedTypes)
{
PerformSearch(nestedType);
}
if (searchMode == SearchMode_Type)
{
return;
}
foreach (FieldDef 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 (PropertyDef 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 (EventDef 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 (MethodDef method in type.Methods)
{
if (Decompiler.DnlibExtensions.HasSemantics(method))
{
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)
});
}
}
}
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)
});
}
}
}
CreatePropertyDefCommand(TypeTreeNode ownerNode, PropertyDefOptions options)
{
this.ownerNode = ownerNode;
this.propNode = new PropertyTreeNode(options.CreatePropertyDef(ownerNode.TypeDefinition.Module));
}
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();
}
internal DumpFilePropertyJob(PropertyManager manager, PropertyTreeNode node) : base(node.DepthLevel)
{
_manager = manager;
_currentNode = node;
}
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();
}
protected override int CompareMethods(PropertyTreeNode x, MethodTreeNode y)
{
return(1);
}
public void OnProperty(PropertyTreeNode node)
{
Level = 1;
}
protected abstract int CompareMethods(PropertyTreeNode x, PropertyTreeNode y);
protected override int CompareMethods(PropertyTreeNode x, MethodTreeNode y)
{
return(CompareByName(x, y));
}
internal EnumerateAndGetPropertyJob(PropertyTreeNode node, PropertyManager manager) : base((node.Type == DirectoryEntryType.DIRECTORY ? 1 << 31 : 0) + node.DepthLevel)
{
_currentNode = node;
_manager = manager;
}
