Example #1
0
        public EventInfo Event(EventDefinition eventDefinition)
        {
            if (_eventCorrespondence.ContainsKey(eventDefinition))
            {
                return(_eventCorrespondence[eventDefinition]);
            }

            var eventInfo = new EventInfo
            {
                Text                   = EventTreeNode.GetText(eventDefinition, MainWindow.Instance.CurrentLanguage) as string,
                Name                   = eventDefinition.Name,
                FullName               = eventDefinition.FullName,
                Icon                   = EventTreeNode.GetIcon(eventDefinition),
                IsInternal             = eventDefinition.AddMethod.IsAssembly,
                IsPrivate              = eventDefinition.AddMethod.IsPrivate,
                IsPublic               = eventDefinition.AddMethod.IsPublic,
                IsProtected            = eventDefinition.AddMethod.IsFamily,
                IsProtectedAndInternal = eventDefinition.AddMethod.IsFamilyAndAssembly,
                IsProtectedOrInternal  = eventDefinition.AddMethod.IsFamilyOrAssembly,
                IsStatic               = eventDefinition.AddMethod.IsStatic,
                MemberReference        = eventDefinition
            };

            _eventCorrespondence.Add(eventDefinition, eventInfo);

            return(eventInfo);
        }
 public override TreeViewNodeFilterResult GetFilterResult(EventDef evt)
 {
     if (showPublicApi() && !EventTreeNode.IsPublicAPIInternal(evt))
     {
         return(new TreeViewNodeFilterResult(FilterResult.Hidden, false));
     }
     return(base.GetFilterResult(evt));
 }
Example #3
0
 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, analyzedEvent.DeclaringType, true);
     output.Write('.', TextTokenType.Operator);
     EventTreeNode.Write(output, analyzedEvent, Language);
 }
Example #4
0
        EventDefSettingsCommand(EventTreeNode eventNode, EventDefOptions options)
        {
            this.eventNode   = eventNode;
            this.newOptions  = options;
            this.origOptions = new EventDefOptions(eventNode.EventDef);

            this.origParentNode       = (ILSpyTreeNode)eventNode.Parent;
            this.origParentChildIndex = this.origParentNode.Children.IndexOf(eventNode);
            Debug.Assert(this.origParentChildIndex >= 0);
            if (this.origParentChildIndex < 0)
            {
                throw new InvalidOperationException();
            }

            this.nameChanged = origOptions.Name != newOptions.Name;
        }
Example #5
0
		void Search(LoadedAssembly ownerModule, TypeDef type, EventDef evt) {
			var res = filter.GetFilterResult(evt);
			if (res.FilterResult == FilterResult.Hidden)
				return;

			if (res.IsMatch && IsMatch(evt.Name, evt)) {
				onMatch(new SearchResult {
					Language = language,
					Object = evt,
					NameObject = evt,
					TypeImageInfo = EventTreeNode.GetImageInfo(evt, BackgroundType.Search),
					LocationObject = type,
					LocationImageInfo = TypeTreeNode.GetImageInfo(type, BackgroundType.Search),
					LoadedAssembly = ownerModule,
				});
			}
		}
Example #6
0
        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!");
            }
        }
Example #7
0
 CreateEventDefCommand(TypeTreeNode ownerNode, EventDefOptions options)
 {
     this.ownerNode = ownerNode;
     this.eventNode = new EventTreeNode(options.CreateEventDef(ownerNode.TypeDef.Module));
 }
Example #8
0
            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)
                        });
                    }
                }
            }
Example #9
0
        private void LoadEvent(TreeNode parentNode, EventInfo evnt)
        {
            TreeNode n = new EventTreeNode(evnt);

            parentNode.Nodes.Add(n);
        }
Example #10
0
            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)
                        });
                    }
                }
            }