/// <summary> /// Add a routed event handler to all instances of a /// particular type inclusive of its sub-class types /// </summary> /// <remarks> /// The handlers added thus are also known as /// an class handlers <para/> /// <para/> /// /// Class handlers are invoked before the /// instance handlers. Also see /// <see cref="UIElement.AddHandler(RoutedEvent, Delegate)"/> <para/> /// Sub-class class handlers are invoked before /// the super-class class handlers <para/> /// <para/> /// /// Input parameters classType, <see cref="RoutedEvent"/> /// and handler cannot be null <para/> /// handledEventsToo input parameter when false means /// that listener does not care about already handled events. /// Hence the handler will not be invoked on the target if /// the RoutedEvent has already been /// <see cref="RoutedEventArgs.Handled"/> <para/> /// handledEventsToo input parameter when true means /// that the listener wants to hear about all events even if /// they have already been handled. Hence the handler will /// be invoked irrespective of the event being /// <see cref="RoutedEventArgs.Handled"/> /// </remarks> /// <param name="classType"> /// Target object type on which the handler will be invoked /// when the RoutedEvent is raised /// </param> /// <param name="routedEvent"> /// <see cref="RoutedEvent"/> for which the handler /// is attached /// </param> /// <param name="handler"> /// The handler that will be invoked on the target object /// when the RoutedEvent is raised /// </param> /// <param name="handledEventsToo"> /// Flag indicating whether or not the listener wants to /// hear about events that have already been handled /// </param> /// <ExternalAPI/> public static void RegisterClassHandler( Type classType, RoutedEvent routedEvent, Delegate handler, bool handledEventsToo) { if (classType == null) { throw new ArgumentNullException("classType"); } if (routedEvent == null) { throw new ArgumentNullException("routedEvent"); } if (handler == null) { throw new ArgumentNullException("handler"); } if (!typeof(UIElement).IsAssignableFrom(classType) && !typeof(ContentElement).IsAssignableFrom(classType) && !typeof(UIElement3D).IsAssignableFrom(classType)) { throw new ArgumentException(SR.Get(SRID.ClassTypeIllegal)); } if (!routedEvent.IsLegalHandler(handler)) { throw new ArgumentException(SR.Get(SRID.HandlerTypeIllegal)); } GlobalEventManager.RegisterClassHandler(classType, routedEvent, handler, handledEventsToo); }
/// <summary> /// Registers a <see cref="RoutedEvent"/> /// with the given parameters /// </summary> /// <remarks> /// <see cref="RoutedEvent.Name"/> must be /// unique within the <see cref="RoutedEvent.OwnerType"/> /// (super class types not considered when talking about /// uniqueness) and cannot be null <para/> /// <see cref="RoutedEvent.HandlerType"/> must be a /// type of delegate and cannot be null <para/> /// <see cref="RoutedEvent.OwnerType"/> must be any /// object type and cannot be null <para/> /// <para/> /// /// NOTE: Caller must be the static constructor of the /// <see cref="RoutedEvent.OwnerType"/> - /// enforced by stack walk /// </remarks> /// <param name="name"> /// <see cref="RoutedEvent.Name"/> /// </param> /// <param name="routingStrategy"> /// <see cref="RoutedEvent.RoutingStrategy"/> /// </param> /// <param name="handlerType"> /// <see cref="RoutedEvent.HandlerType"/> /// </param> /// <param name="ownerType"> /// <see cref="RoutedEvent.OwnerType"/> /// </param> /// <returns> /// The new registered <see cref="RoutedEvent"/> /// </returns> /// <ExternalAPI/> public static RoutedEvent RegisterRoutedEvent( string name, RoutingStrategy routingStrategy, Type handlerType, Type ownerType) { if (name == null) { throw new ArgumentNullException("name"); } if (routingStrategy != RoutingStrategy.Tunnel && routingStrategy != RoutingStrategy.Bubble && routingStrategy != RoutingStrategy.Direct) { throw new System.ComponentModel.InvalidEnumArgumentException("routingStrategy", (int)routingStrategy, typeof(RoutingStrategy)); } if (handlerType == null) { throw new ArgumentNullException("handlerType"); } if (ownerType == null) { throw new ArgumentNullException("ownerType"); } if (GlobalEventManager.GetRoutedEventFromName(name, ownerType, false) != null) { throw new ArgumentException(SR.Get(SRID.DuplicateEventName, name, ownerType)); } return(GlobalEventManager.RegisterRoutedEvent(name, routingStrategy, handlerType, ownerType)); }
/// <summary> /// Finds <see cref="RoutedEvent"/>s for the /// given <see cref="RoutedEvent.OwnerType"/> /// </summary> /// <remarks> /// More specifically finds /// <see cref="RoutedEvent"/>s starting /// on the <see cref="RoutedEvent.OwnerType"/> /// and looking at its super class types <para/> /// <para/> /// /// If no matches are found, this method returns null /// </remarks> /// <param name="ownerType"> /// <see cref="RoutedEvent.OwnerType"/> to start /// search with and follow through to super class types /// </param> /// <returns> /// Matching <see cref="RoutedEvent"/>s /// </returns> /// <ExternalAPI/> public static RoutedEvent[] GetRoutedEventsForOwner(Type ownerType) { if (ownerType == null) { throw new ArgumentNullException("ownerType"); } return(GlobalEventManager.GetRoutedEventsForOwner(ownerType)); }
private static void OnEventHandlersIterationCallback(ArrayList list, int key, object value) { RoutedEvent routedEvent = GlobalEventManager.EventFromGlobalIndex(key) as RoutedEvent; if (routedEvent != null && ((FrugalObjectList <RoutedEventHandlerInfo>)value).Count > 0) { list.Add(routedEvent); } }
// Constructor for a RoutedEvent (is internal // to the EventManager and is onvoked when a new // RoutedEvent is registered) internal RoutedEvent( string name, RoutingStrategy routingStrategy, Type handlerType, Type ownerType) { _name = name; _routingStrategy = routingStrategy; _handlerType = handlerType; _ownerType = ownerType; _globalIndex = GlobalEventManager.GetNextAvailableGlobalIndex(this); }
internal static RoutedEvent GetRoutedEventFromName(string name, Type ownerType) { if (name == null) { throw new ArgumentNullException("name"); } if (ownerType == null) { throw new ArgumentNullException("ownerType"); } return(GlobalEventManager.GetRoutedEventFromName(name, ownerType, true)); }
/// <summary> /// Associate another owner type with this event. /// </summary> /// <remarks> /// The owner type is used when resolving an event by name. /// </remarks> /// <param name="ownerType">Additional owner type</param> /// <returns>This event.</returns> public RoutedEvent AddOwner(Type ownerType) { GlobalEventManager.AddOwner(this, ownerType); return(this); }
/// <summary> /// Returns <see cref="RoutedEvent"/>s /// that have been registered so far /// </summary> /// <remarks> /// Also see /// <see cref="EventManager.RegisterRoutedEvent"/> /// <para/> /// <para/> /// /// NOTE: There may be more /// <see cref="RoutedEvent"/>s registered later /// </remarks> /// <returns> /// The <see cref="RoutedEvent"/>s /// that have been registered so far /// </returns> /// <ExternalAPI/> public static RoutedEvent[] GetRoutedEvents() { return(GlobalEventManager.GetRoutedEvents()); }
/// <summary> /// Constructor for EventPrivateKey /// </summary> public EventPrivateKey() { _globalIndex = GlobalEventManager.GetNextAvailableGlobalIndex(this); }