public AnalyzedEventTreeNode(EventDef analyzedEvent, bool hidesParent = false) {
			if (analyzedEvent == null)
				throw new ArgumentNullException("analyzedEvent");
			this.analyzedEvent = analyzedEvent;
			this.hidesParent = hidesParent;
			this.LazyLoading = true;
		}

        public AnalyzedEventOverridesTreeNode(EventDef analyzedEvent)
        {
            if (analyzedEvent == null)
                throw new ArgumentNullException("analyzedEvent");

            this.analyzedEvent = analyzedEvent;
        }

		public InterfaceEventImplementedByNode(EventDef analyzedEvent) {
			if (analyzedEvent == null)
				throw new ArgumentNullException("analyzedEvent");

			this.analyzedEvent = analyzedEvent;
			this.analyzedMethod = this.analyzedEvent.AddMethod ?? this.analyzedEvent.RemoveMethod;
		}

 public AnalyzedEventTreeNode(EventDef analyzedEvent, string prefix = "")
 {
     if (analyzedEvent == null)
         throw new ArgumentNullException("analyzedEvent");
     this.analyzedEvent = analyzedEvent;
     this.prefix = prefix;
     this.LazyLoading = true;
 }

		public DeletedEventUpdater(ModuleDocumentNode modNode, EventDef originalEvent) {
			ownerNode = modNode.Context.DocumentTreeView.FindNode(originalEvent);
			if (ownerNode == null)
				throw new InvalidOperationException();
			parentNode = ownerNode.TreeNode.Parent.Data;
			ownerType = originalEvent.DeclaringType;
			@event = originalEvent;
		}

		public EditedEventUpdater(ModuleDocumentNode modNode, EventDef originalEvent, EventDefOptions eventDefOptions) {
			ownerNode = modNode.Context.DocumentTreeView.FindNode(originalEvent);
			if (ownerNode == null)
				throw new InvalidOperationException();
			@event = originalEvent;
			originalEventDefOptions = new EventDefOptions(originalEvent);
			newEventDefOptions = eventDefOptions;
		}

		public static ITextOutput Write(ITextOutput output, EventDef ev, Language language) {
			output.Write(UIUtils.CleanUpIdentifier(ev.Name), TextTokenHelper.GetTextTokenType(ev));
			output.WriteSpace();
			output.Write(':', TextTokenType.Operator);
			output.WriteSpace();
			language.TypeToString(output, ev.EventType, false, ev);
			ev.MDToken.WriteSuffixString(output);
			return output;
		}

		public EventDefOptions(EventDef evt) {
			this.Attributes = evt.Attributes;
			this.Name = evt.Name;
			this.EventType = evt.EventType;
			this.AddMethod = evt.AddMethod;
			this.InvokeMethod = evt.InvokeMethod;
			this.RemoveMethod = evt.RemoveMethod;
			this.OtherMethods.AddRange(evt.OtherMethods);
			this.CustomAttributes.AddRange(evt.CustomAttributes);
		}

        public AnalyzedEventFiredByTreeNode(EventDef analyzedEvent)
        {
            if (analyzedEvent == null)
                throw new ArgumentNullException("analyzedEvent");

            this.analyzedEvent = analyzedEvent;

            this.eventBackingField = GetBackingField(analyzedEvent);
            this.eventFiringMethod = analyzedEvent.EventType.ResolveTypeDef().Methods.First(md => md.Name == "Invoke");
        }

		public EventDefOptions(EventDef evt) {
			Attributes = evt.Attributes;
			Name = evt.Name;
			EventType = evt.EventType;
			AddMethod = evt.AddMethod;
			InvokeMethod = evt.InvokeMethod;
			RemoveMethod = evt.RemoveMethod;
			OtherMethods.AddRange(evt.OtherMethods);
			CustomAttributes.AddRange(evt.CustomAttributes);
		}

		public EventFiredByNode(EventDef analyzedEvent) {
			if (analyzedEvent == null)
				throw new ArgumentNullException(nameof(analyzedEvent));

			this.analyzedEvent = analyzedEvent;

			eventBackingField = GetBackingField(analyzedEvent);
			var eventType = analyzedEvent.EventType.ResolveTypeDef();
			if (eventType != null)
				eventFiringMethod = eventType.Methods.First(md => md.Name == "Invoke");
		}

		public EventDef CopyTo(EventDef evt) {
			evt.Attributes = this.Attributes;
			evt.Name = this.Name ?? UTF8String.Empty;
			evt.EventType = this.EventType;
			evt.AddMethod = this.AddMethod;
			evt.InvokeMethod = this.InvokeMethod;
			evt.RemoveMethod = this.RemoveMethod;
			evt.OtherMethods.Clear();
			evt.OtherMethods.AddRange(this.OtherMethods);
			evt.CustomAttributes.Clear();
			evt.CustomAttributes.AddRange(CustomAttributes);
			return evt;
		}

		public EventTreeNode(EventDef ev) {
			if (ev == null)
				throw new ArgumentNullException("ev");
			this.ev = ev;

			if (ev.AddMethod != null)
				this.Children.Add(new MethodTreeNode(ev.AddMethod));
			if (ev.RemoveMethod != null)
				this.Children.Add(new MethodTreeNode(ev.RemoveMethod));
			if (ev.InvokeMethod != null)
				this.Children.Add(new MethodTreeNode(ev.InvokeMethod));
			if (ev.HasOtherMethods) {
				foreach (var m in ev.OtherMethods)
					this.Children.Add(new MethodTreeNode(m));
			}
		}

		static MemberIcon GetMemberIcon(EventDef eventDef) {
			MethodDef method = eventDef.AddMethod ?? eventDef.RemoveMethod;
			if (method == null)
				return MemberIcon.Event;

			var access = MethodTreeNode.GetMemberAccess(method);
			if (method.IsStatic) {
				switch (access) {
				case MemberAccess.Public: return MemberIcon.StaticEvent;
				case MemberAccess.Private: return MemberIcon.StaticEventPrivate;
				case MemberAccess.Protected: return MemberIcon.StaticEventProtected;
				case MemberAccess.Internal: return MemberIcon.StaticEventInternal;
				case MemberAccess.CompilerControlled: return MemberIcon.StaticEventCompilerControlled;
				case MemberAccess.ProtectedInternal: return MemberIcon.StaticEventProtectedInternal;
				default:
					Debug.Fail("Invalid MemberAccess");
					goto case MemberAccess.Public;
				}
			}

			if (method.IsVirtual) {
				switch (access) {
				case MemberAccess.Public: return MemberIcon.VirtualEvent;
				case MemberAccess.Private: return MemberIcon.VirtualEventPrivate;
				case MemberAccess.Protected: return MemberIcon.VirtualEventProtected;
				case MemberAccess.Internal: return MemberIcon.VirtualEventInternal;
				case MemberAccess.CompilerControlled: return MemberIcon.VirtualEventCompilerControlled;
				case MemberAccess.ProtectedInternal: return MemberIcon.VirtualEventProtectedInternal;
				default:
					Debug.Fail("Invalid MemberAccess");
					goto case MemberAccess.Public;
				}
			}

			switch (access) {
			case MemberAccess.Public: return MemberIcon.Event;
			case MemberAccess.Private: return MemberIcon.EventPrivate;
			case MemberAccess.Protected: return MemberIcon.EventProtected;
			case MemberAccess.Internal: return MemberIcon.EventInternal;
			case MemberAccess.CompilerControlled: return MemberIcon.EventCompilerControlled;
			case MemberAccess.ProtectedInternal: return MemberIcon.EventProtectedInternal;
			default:
				Debug.Fail("Invalid MemberAccess");
				goto case MemberAccess.Public;
			}
		}

        public override void DecompileEvent(EventDef ev, ITextOutput output, DecompilationOptions options)
        {
            StartKeywordBlock(output, ".event", ev);

            if (ev.AddMethod != null) {
                StartKeywordBlock(output, ".add", ev.AddMethod);
                EndKeywordBlock(output);
            }

            if (ev.InvokeMethod != null) {
                StartKeywordBlock(output, ".invoke", ev.InvokeMethod);
                EndKeywordBlock(output);
            }

            if (ev.RemoveMethod != null) {
                StartKeywordBlock(output, ".remove", ev.RemoveMethod);
                EndKeywordBlock(output);
            }

            EndKeywordBlock(output);
        }

        public static IEnumerable<EventDef> FindBaseEvents(EventDef eventDef)
        {
            if (eventDef == null)
                yield break;

            var eventType = eventDef.EventType.ToTypeSig();

            foreach (var baseType in BaseTypes(eventDef.DeclaringType)) {
                var baseTypeDef = baseType.Resolve();
                if (baseTypeDef == null)
                    continue;
                foreach (var baseEvent in baseTypeDef.Events) {
                    if (MatchEvent(baseEvent, Resolve(baseEvent.EventType.ToTypeSig(), baseType), eventDef, eventType) &&
                        IsVisibleFromDerived(baseEvent, eventDef.DeclaringType)) {
                        yield return baseEvent;
                        var anyEventAccessor = baseEvent.AddMethod ?? baseEvent.RemoveMethod;
                        if (anyEventAccessor != null && anyEventAccessor.IsNewSlot == anyEventAccessor.IsVirtual)
                            yield break;
                    }
                }
            }
        }

        public TreeNode NewEvent(EventDef @event)
        {
            TreeNode node = NewNode(String.Format("{0}: {1}", @event.Name, "EventHandler"));

            node.Tag = @event;
            node.ImageIndex = node.SelectedImageIndex = 15;

            if (@event.AddMethod != null)
            {
                node.Nodes.Add(NewMethod(@event.AddMethod));
            }

            if (@event.RemoveMethod != null)
            {
                node.Nodes.Add(NewMethod(@event.RemoveMethod));
            }

            if (@event.InvokeMethod != null)
            {
                node.Nodes.Add(NewMethod(@event.InvokeMethod));
            }

            foreach (MethodDef method in @event.OtherMethods)
            {
                node.Nodes.Add(NewMethod(method));
            }

            return node;
        }

        void Search(IDnSpyFile ownerModule, TypeDef type, EventDef evt)
        {
            var res = options.Filter.GetResult(evt);
            if (res.FilterType == FilterType.Hide)
                return;
            CheckCustomAttributes(ownerModule, evt, type);

            if (res.IsMatch && IsMatch(evt.Name, evt)) {
                options.OnMatch(new SearchResult {
                    Context = options.Context,
                    Object = evt,
                    NameObject = evt,
                    ObjectImageReference = options.DotNetImageManager.GetImageReference(evt),
                    LocationObject = type,
                    LocationImageReference = options.DotNetImageManager.GetImageReference(type),
                    DnSpyFile = ownerModule,
                });
            }
        }

 /// <summary>
 /// Looks up the event node corresponding to the event definition.
 /// Returns null if no matching node is found.
 /// </summary>
 public EventTreeNode FindEventNode(EventDef def)
 {
     if (def == null)
         return null;
     TypeTreeNode typeNode = FindTypeNode(def.DeclaringType);
     if (typeNode == null)
         return null;
     typeNode.EnsureChildrenFiltered();
     return typeNode.Children.OfType<EventTreeNode>().FirstOrDefault(m => m.EventDefinition == def);
 }

		public static bool CanShow(EventDef ev) {
			return GetBackingField(ev) != null;
		}