public MouseButtonEventArgs(RoutedEvent routedEvent, object originalSource, MouseDevice mouseDevice, int timestamp, Point absolutePosition, MouseButton changedButton, MouseButtonState buttonState, int clickCount) : base(routedEvent, originalSource, mouseDevice, timestamp, absolutePosition) { this.ChangedButton = changedButton; this.ButtonState = buttonState; this.ClickCount = clickCount; }
public MFTestResults UIElement_RaiseEvent_FocusChangedEvent_Test2() { MFTestResults testResult = MFTestResults.Pass; Log.Comment("Raising FocusChangedEventEvents and Verifying"); //addToEvtRoute = false; btnEvent = false; fcsEvent = true; _fcsEventCntr = 0; rEvents = new RoutedEvent[] { Buttons.GotFocusEvent, Buttons.LostFocusEvent }; for (int i = 0; i < rEvents.Length; i++) { mainWindow.Dispatcher.Invoke(new TimeSpan(0, 0, 5), new DispatcherOperationCallback(AddToHandler), rEvents[i]); FocusChangedEventArgs fcea = new FocusChangedEventArgs(null, DateTime.Now, mainWindow, mainWindow); fcea.RoutedEvent = rEvents[i]; mainWindow.Dispatcher.Invoke(new TimeSpan(0, 0, 5), new DispatcherOperationCallback(RaiseEvent), fcea); if (_fcsEventCntr != i + 1) { Log.Comment("FocusChangedEvent '" + rEvents[i].Name + "' event not raised"); testResult = MFTestResults.Fail; } } fcsEvent = false; return testResult; }
private static void AddRoutedEventHandler( Hashtable table, RoutedEvent routedEvent, RoutedEventHandler handler, bool handledEventsToo) { if (routedEvent == null || handler == null) { throw new ArgumentNullException(); } // Create a new RoutedEventHandler RoutedEventHandlerInfo routedEventHandlerInfo = new RoutedEventHandlerInfo(handler, handledEventsToo); // Get the entry corresponding to the given RoutedEvent ArrayList handlers = (ArrayList)table[routedEvent]; if (handlers == null) { table[routedEvent] = (handlers = new ArrayList()); } // Add the RoutedEventHandlerInfo to the list handlers.Add(routedEventHandlerInfo); }
public MFTestResults UIElement_RaiseEvent_ButtonEvent_Test1() { MFTestResults testResult = MFTestResults.Pass; Log.Comment("Raising ButtonEvents and Verifying"); //addToEvtRoute = false; btnEvent = true; fcsEvent = false; _btnEventCntr = 0; rEvents = new RoutedEvent[] { Buttons.ButtonDownEvent, Buttons.ButtonUpEvent, Buttons.PreviewButtonDownEvent, Buttons.PreviewButtonUpEvent}; for (int i = 0; i < rEvents.Length; i++) { //rEvent = rEvents[i]; mainWindow.Dispatcher.Invoke(new TimeSpan(0, 0, 5), new DispatcherOperationCallback(AddToHandler), rEvents[i]); ButtonEventArgs bea = new ButtonEventArgs(null, null, DateTime.Now, Hardware.Button.AppDefined1); bea.RoutedEvent = rEvents[i]; mainWindow.Dispatcher.Invoke(new TimeSpan(0, 0, 5), new DispatcherOperationCallback(RaiseEvent), bea); if (_btnEventCntr != i + 1) { Log.Comment("ButtonEvent '" + rEvents[i].Name + "' event not raised"); testResult = MFTestResults.Fail; } } btnEvent = false; return testResult; }
public static void AddHandler(object target, RoutedEvent routedEvent, Delegate handler, bool handledEventsToo) { if (null == target) throw new ArgumentNullException("target"); if (null == routedEvent) throw new ArgumentNullException("routedEvent"); if (null == handler) throw new ArgumentNullException("handler"); // RoutedEventKey key = routedEvent.Key; if (!routedEvents.ContainsKey(key)) throw new ArgumentException("Specified routed event is not registered.", "routedEvent"); RoutedEventInfo routedEventInfo = routedEvents[key]; bool needAddTarget = true; if (routedEventInfo.targetsList != null) { RoutedEventTargetInfo targetInfo = routedEventInfo.targetsList.FirstOrDefault(info => info.target == target); if (null != targetInfo) { if (targetInfo.handlersList == null) targetInfo.handlersList = new List<DelegateInfo>(); targetInfo.handlersList.Add(new DelegateInfo(handler, handledEventsToo)); needAddTarget = false; } } if (needAddTarget) { RoutedEventTargetInfo targetInfo = new RoutedEventTargetInfo(target); targetInfo.handlersList = new List<DelegateInfo>(); targetInfo.handlersList.Add(new DelegateInfo(handler, handledEventsToo)); if (routedEventInfo.targetsList == null) routedEventInfo.targetsList = new List<RoutedEventTargetInfo>(); routedEventInfo.targetsList.Add(targetInfo); } }
/// <summary> /// Initializes a new instance of the <see cref="PropertyValueChangedEventArgs"/> class. /// </summary> /// <param name="routedEvent">The routed event.</param> /// <param name="property">The property.</param> /// <param name="oldValue">The old value.</param> public PropertyValueChangedEventArgs(RoutedEvent routedEvent, PropertyItem property, object oldValue) : base(routedEvent, property) { Property = property; NewValue = property.PropertyValue; OldValue = oldValue; }
public MouseButtonEventArgs(object source, RoutedEvent routedEvent, Point rawPosition, MouseButtonState leftButton, MouseButtonState middleButton, MouseButtonState rightButton, MouseButton button, int clickCount = 1) : base(source, routedEvent, rawPosition, leftButton, middleButton, rightButton) { this.button = button; this.clickCount = clickCount; }
/// <summary> /// Initializes a new instance of the <see cref="UvmlRoutedEventHandlerMutator"/> class. /// </summary> /// <param name="revtID">The event which is being mutated.</param> /// <param name="revtHandler">The event handler to add to the event.</param> public UvmlRoutedEventHandlerMutator(RoutedEvent revtID, UvmlNode revtHandler) { Contract.Require(revtID, nameof(revtID)); Contract.Require(revtHandler, nameof(revtHandler)); this.revtID = revtID; this.revtHandler = revtHandler; }
public WpfXamlMember(RoutedEvent re, MethodInfo setter, XamlSchemaContext schemaContext, bool useV3Rules) : base(re.Name, setter, schemaContext) { RoutedEvent = re; _useV3Rules = useV3Rules; _underlyingMemberIsKnown = true; }
public WpfXamlMember(RoutedEvent re, EventInfo eventInfo, XamlSchemaContext schemaContext, bool useV3Rules) : base(eventInfo, schemaContext) { RoutedEvent = re; _useV3Rules = useV3Rules; _underlyingMemberIsKnown = true; }
public WpfXamlMember(RoutedEvent re, bool isAttachable) : base(re.Name, System.Windows.Markup.XamlReader.BamlSharedSchemaContext.GetXamlType(re.OwnerType), isAttachable) { RoutedEvent = re; _useV3Rules = true; _isBamlMember = true; _underlyingMemberIsKnown = false; }
public ScrollChangedEventArgs(RoutedEvent routedEvent, object originalSource, Point offset, Point offsetChange, Size extent, Point extentChange, Size viewport, Point viewportChange) : base(routedEvent, originalSource) { this.Offset = offset; this.OffsetChange = offsetChange; this.Extent = extent; this.ExtentChange = extentChange; this.Viewport = viewport; this.ViewportChange = viewportChange; }
/// <summary> /// Removes a handler for a routed event from the specified input element. /// </summary> /// <param name="dobj">The input element from which to remove the event handler.</param> /// <param name="routedEvent">A <see cref="RoutedEvent"/> that identifies the routed event for which to remove a handler.</param> /// <param name="handler">A delegate that represents the handler to remove from the element for the specified routed event.</param> public static void RemoveHandler(DependencyObject dobj, RoutedEvent routedEvent, Delegate handler) { var element = dobj as IInputElement; if (element != null) { element.RemoveHandler(routedEvent, handler); return; } throw new ArgumentException(PresentationStrings.NotAnInputElement.Format("dobj")); }
public void Tunneling_Event_Should_Tunnel() { var ev = new RoutedEvent("test", RoutingStrategies.Tunnel, typeof(RoutedEventArgs), typeof(TestInteractive)); var invoked = new List<string>(); EventHandler<RoutedEventArgs> handler = (s, e) => invoked.Add(((TestInteractive)s).Name); var target = CreateTree(ev, handler, RoutingStrategies.Bubble | RoutingStrategies.Tunnel); var args = new RoutedEventArgs(ev, target); target.RaiseEvent(args); Assert.Equal(new[] { "1", "2b" }, invoked); }
internal MouseButtonEventArgs(RoutedEvent routedEvent, MouseButton changedButton, MouseButtonState buttonState, int clickCount, System.Windows.Input.MouseButtonEventArgs args) : base(routedEvent) { this.ChangedButton = changedButton; this.ButtonState = buttonState; this.ClickCount = clickCount; this.originalMouseButtonEventArgs = args; }
public void Direct_Event_Should_Go_Straight_To_Source() { var ev = new RoutedEvent("test", RoutingStrategies.Direct, typeof(RoutedEventArgs), typeof(TestInteractive)); var invoked = new List<string>(); EventHandler<RoutedEventArgs> handler = (s, e) => invoked.Add(((TestInteractive)s).Name); var target = CreateTree(ev, handler, RoutingStrategies.Direct); var args = new RoutedEventArgs(ev, target); target.RaiseEvent(args); Assert.Equal(new[] { "2b" }, invoked); }
/// <inheritdoc/> void IRoutedEventRaisedNotificationSubscriber.ReceiveRoutedEventRaisedNotification(DependencyObject dobj, RoutedEvent evt, RoutedEventData data) { if (!data.Handled || handled) { Activate(dobj); if (setHandled) { data.Handled = true; } } }
public ContentShouldBeScrolledEventArgs( object source, RoutedEvent routedEvent, int? mostLeftVisibleX, int? mostRightVisibleX, int? mostTopVisibleY, int? mostBottomVisibleY) : base(source, routedEvent) { if (mostLeftVisibleX.HasValue && mostRightVisibleX.HasValue) throw new ArgumentException("Only one of X values can be specified"); if (mostTopVisibleY.HasValue && mostBottomVisibleY.HasValue) throw new ArgumentException("Only one of Y values can be specified"); this.mostLeftVisibleX = mostLeftVisibleX; this.mostRightVisibleX = mostRightVisibleX; this.mostTopVisibleY = mostTopVisibleY; this.mostBottomVisibleY = mostBottomVisibleY; }
public MouseDevice () { PreviewButtonPressEvent = new TunnelingEvent<MouseButtonEventArgs> (); ButtonPressEvent = new BubblingEvent<MouseButtonEventArgs> (); PreviewButtonReleaseEvent = new TunnelingEvent<MouseButtonEventArgs> (); ButtonReleaseEvent = new BubblingEvent<MouseButtonEventArgs> (); PreviewMotionNotifyEvent = new TunnelingEvent<MouseButtonEventArgs> (); MotionNotifyEvent = new BubblingEvent<MouseButtonEventArgs> (); MouseEnterEvent = new DirectEvent<EventArgs> (); MouseLeaveEvent = new DirectEvent<EventArgs> (); }
private static void AttachEvent(RoutedEvent e, PointerEventHandler Handler) { foreach (var item in Panels) { if (e == UIElement.PointerPressedEvent) item.PointerPressed += Handler; else if (e == UIElement.PointerEnteredEvent) item.PointerEntered += Handler; else if (e == UIElement.PointerExitedEvent) item.PointerExited += Handler; } foreach (var item in NonPanels) { item.AddHandler(e, Handler, true); } }
private static void DetachEvent(RoutedEvent e, PointerEventHandler Handler) { foreach (var item in Panels) { if (e == UIElement.PointerPressedEvent) item.PointerPressed -= Handler; else if (e == UIElement.PointerEnteredEvent) item.PointerEntered -= Handler; else if (e == UIElement.PointerExitedEvent) item.PointerExited -= Handler; } foreach (var item in NonPanels) { item.RemoveHandler(e, Handler); } }
/// <summary> /// constructor /// </summary> /// <param name="id">event id</param> /// <param name="action">UndoAction</param> /// <param name="changes">ReadOnlyCollection</param> public TextChangedEventArgs(RoutedEvent id, UndoAction action, ICollection<TextChange> changes) : base() { if (id == null) { throw new ArgumentNullException("id"); } if (action < UndoAction.None || action > UndoAction.Create) { throw new InvalidEnumArgumentException("action", (int)action, typeof(UndoAction)); } RoutedEvent=id; _undoAction = action; _changes = changes; }
public static RoutedEvent RegisterRoutedEvent(string name, RoutingStrategy routingStrategy, Type handlerType, Type ownerType) { if (string.IsNullOrEmpty(name)) throw new ArgumentException("name"); if (null == handlerType) throw new ArgumentNullException("handlerType"); if (null == ownerType) throw new ArgumentNullException("ownerType"); // RoutedEventKey key = new RoutedEventKey(name, ownerType); if (routedEvents.ContainsKey(key)) { throw new InvalidOperationException("This routed event is already registered."); } RoutedEvent routedEvent = new RoutedEvent(handlerType, name, ownerType, routingStrategy); RoutedEventInfo routedEventInfo = new RoutedEventInfo(routedEvent); routedEvents.Add(key, routedEventInfo); return routedEvent; }
public void Direct_Event_Should_Have_Route_Set_To_Direct() { var ev = new RoutedEvent("test", RoutingStrategies.Direct, typeof(RoutedEventArgs), typeof(TestInteractive)); bool called = false; EventHandler<RoutedEventArgs> handler = (s, e) => { Assert.Equal(RoutingStrategies.Direct, e.Route); called = true; }; var target = CreateTree(ev, handler, RoutingStrategies.Direct); var args = new RoutedEventArgs(ev, target); target.RaiseEvent(args); Assert.True(called); }
/// <summary> /// Adds the owner. /// </summary> /// <param name="routedEvent">The routed event.</param> /// <param name="ownerType">Type of the owner.</param> internal static void AddOwner(RoutedEvent routedEvent, Type ownerType) { if ((ownerType == typeof(DependencyObject)) || ownerType.IsSubclassOf(typeof(DependencyObject))) { List<RoutedEvent> list2; var type = DependencyObjectType.FromSystemTypeInternal(ownerType); var obj3 = dependencyTypedRoutedEventList[type]; if (obj3 == null) { list2 = new List<RoutedEvent>(); dependencyTypedRoutedEventList[type] = list2; } else { list2 = (List<RoutedEvent>)obj3; } if (!list2.Contains(routedEvent)) { list2.Add(routedEvent); } } else { List<RoutedEvent> list; object obj2 = null; if (ownerTypedRoutedEventList.ContainsKey(ownerType)) { obj2 = ownerTypedRoutedEventList[ownerType]; } if (obj2 == null) { list = new List<RoutedEvent>(); ownerTypedRoutedEventList[ownerType] = list; } else { list = (List<RoutedEvent>)obj2; } if (!list.Contains(routedEvent)) { list.Add(routedEvent); } } }
public void Bubbling_Class_Handlers_Should_Be_Called() { var ev = new RoutedEvent( "test", RoutingStrategies.Bubble | RoutingStrategies.Tunnel, typeof(RoutedEventArgs), typeof(TestInteractive)); var invoked = new List<string>(); EventHandler<RoutedEventArgs> handler = (s, e) => invoked.Add(((TestInteractive)s).Name); var target = this.CreateTree(ev, null, 0); ev.AddClassHandler(typeof(TestInteractive), handler, RoutingStrategies.Bubble); var args = new RoutedEventArgs(ev, target); target.RaiseEvent(args); Assert.Equal(new[] { "2b", "1" }, invoked); }
public void Bubbling_Subscription_Should_Not_Catch_Tunneling() { var ev = new RoutedEvent( "test", RoutingStrategies.Bubble | RoutingStrategies.Tunnel, typeof(RoutedEventArgs), typeof(TestInteractive)); var count = 0; EventHandler<RoutedEventArgs> handler = (s, e) => { Assert.Equal(RoutingStrategies.Bubble, e.Route); ++count; }; var target = this.CreateTree(ev, handler, RoutingStrategies.Bubble); var args = new RoutedEventArgs(ev, target); target.RaiseEvent(args); Assert.Equal(2, count); }
public ItemDeletingEventArgs(RoutedEvent itemDeletingEvent, object itemDeleting) : base(itemDeletingEvent) { _item = itemDeleting; }
private void RaiseRoutedEvent(RoutedEvent routedEvent) { var args = new RoutedEventArgs(routedEvent, this); RaiseEvent(args); }
public static void RaiseEvent(this FrameworkElement element, MouseButton mouseButton, RoutedEvent routedEvent) { MouseButtonEventArgs args = new MouseButtonEventArgs(Mouse.PrimaryDevice, 0, MouseButton.Left); args.RoutedEvent = UIElement.MouseLeftButtonDownEvent; args.Source = element; element.RaiseEvent(args); }
/// <summary> /// Creates a new <see cref="SearchEventArgs" />. /// </summary> /// <param name="routedEvent"></param> /// <param name="source">The source object</param> /// <param name="searchTerm">The term to search for</param> public SearchEventArgs(RoutedEvent routedEvent, object source, string searchTerm) : base(routedEvent, source) { SearchTerm = searchTerm; }
protected void BindEvent(UnityEvent source, RoutedEvent routedEvent) => eventHandlers.BindEvent(this, source, routedEvent);
protected void UnbindEvent(UnityEvent source, RoutedEvent routedEvent) => eventHandlers.UnbindEvent(source, routedEvent);
public ClockChoiceMadeEventArgs(ClockDisplayMode displayMode, RoutedEvent routedEvent) : base(routedEvent) { _displayMode = displayMode; }
public ClockChoiceMadeEventArgs(ClockDisplayMode displayMode, RoutedEvent routedEvent, object source) : base(routedEvent, source) { _displayMode = displayMode; }
public CollectionItemChangedEventArgs(IEnumerable array, IReadOnlyCollection <object> changes, EventType eventType, object?item, int index, RoutedEvent @event) : base(eventType, item, index, @event) { Objects = array; Changes = changes; }
public void Events_Should_Have_Route_Set() { var ev = new RoutedEvent( "test", RoutingStrategies.Bubble | RoutingStrategies.Tunnel, typeof(RoutedEventArgs), typeof(TestInteractive)); var invoked = new List<RoutingStrategies>(); EventHandler<RoutedEventArgs> handler = (s, e) => invoked.Add(e.Route); var target = CreateTree(ev, handler, RoutingStrategies.Bubble | RoutingStrategies.Tunnel); var args = new RoutedEventArgs(ev, target); target.RaiseEvent(args); Assert.Equal(new[] { RoutingStrategies.Tunnel, RoutingStrategies.Tunnel, RoutingStrategies.Bubble, RoutingStrategies.Bubble, }, invoked); }
public TextBoxValueChangedEventArgs(T oldValue, T newValue, bool isManual, bool isBusy, RoutedEvent routedEvent) : base(oldValue, newValue, routedEvent) { IsManual = isManual; IsBusy = isBusy; }
public CollectionChangeEventArgs(RoutedEvent routedEvent, Dictionary <object, int> dictionary) : base(routedEvent) { this.Dictionary = dictionary; }
public GifImageExceptionRoutedEventArgs(RoutedEvent routedEvent, object obj) : base(routedEvent, obj) { }
public MWKeyEventArgs(RoutedEvent routedEvent, Key key, ModifierKeys modifierKeys) : base(routedEvent) { Key = key; Modifiers = modifierKeys; }
private void OnRaiseEvent(RoutedEvent handler, MouseButtonEventArgs e) { e.RoutedEvent = handler; RaiseEvent(e); }
public CardModelEventArgs(DataNew.Entities.Card model, RoutedEvent routedEvent, object source) : base(routedEvent, source) { CardModel = model; }
private TestInteractive CreateTree( RoutedEvent ev, EventHandler<RoutedEventArgs> handler, RoutingStrategies handlerRoutes, bool handledEventsToo = false) { TestInteractive target; var tree = new TestInteractive { Name = "1", Children = new[] { new TestInteractive { Name = "2a", }, (target = new TestInteractive { Name = "2b", Children = new[] { new TestInteractive { Name = "3", }, }, }), } }; if (handler != null) { foreach (var i in tree.GetSelfAndVisualDescendents().Cast<Interactive>()) { i.AddHandler(ev, handler, handlerRoutes, handledEventsToo); } } return target; }
public NoteEventArgs(RoutedEvent routedEvent, Note note) : base(routedEvent) { this.Note = note; }
/// <summary> /// Initializes a new instance of the <see cref="ScheduledAppointmentEventArgs"/> class. Constructs a new custom /// ScheduledAppointmentEventArgs object using the parameters provided /// </summary> /// <param name="routedEvent">The routed event.</param> /// <param name="appointmentKey">The scheduled appointment.</param> public ScheduledAppointmentEventArgs(RoutedEvent routedEvent, IVisit appointmentKey) : base(routedEvent) { this.appointmentKey = appointmentKey; }
protected void RemoveHandler(RoutedEvent routedEvent, RoutedEventHandler handler) => eventHandlers.RemoveHandler(routedEvent, handler);
public GamePadEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source) { }
protected void AddHandler(RoutedEvent routedEvent, RoutedEventHandler handler) => eventHandlers.AddHandler(routedEvent, handler);
/// <summary> /// Helper function to create a RoutedPropertyChangedEventArgs from a DependencyPropertyChangedEventArgs. /// </summary> /// <typeparam name="T">The type for the RoutedPropertyChangedEventArgs.</typeparam> /// <param name="propertyEventArgs">The DependencyPropertyChangedEventArgs data source.</param> /// <param name="routedEvent">The routed event the property change is associated with.</param> /// <returns>The created event args, configured from the parameter.</returns> public static RoutedPropertyChangedEventArgs <T> CreateRoutedPropertyChangedEventArgs <T>(DependencyPropertyChangedEventArgs propertyEventArgs, RoutedEvent routedEvent) { RoutedPropertyChangedEventArgs <T> eventArgs = new RoutedPropertyChangedEventArgs <T>( (T)propertyEventArgs.OldValue, (T)propertyEventArgs.NewValue, routedEvent); return(eventArgs); }
public CollectionEventArgs(EventType eventType, RoutedEvent @event) : base(@event) { EventType = eventType; }
public PropertyViewItemEventArgs(RoutedEvent routedEvent, object source, PropertyViewItem container, object item) : base(routedEvent, source) { Container = container; Item = item; }
public MovementEventArgs(IReadOnlyCollection <IndexedObject> array, IReadOnlyCollection <IndexedObject> changes, EventType eventType, object?item, int index, RoutedEvent @event) : base(eventType, item, index, @event) { Objects = array; Changes = changes; }
/// <summary> /// Initializes a new instance of the <see cref="AvaloniaEventHandlerItem"/> class /// with the specified element name, element, event name, routed event, event information, /// event handler, and a value that indicates whether to register the handler such that /// it is invoked even when the event is marked handled in its event data. /// </summary> /// <param name="elementName">The name of the element that raises the event.</param> /// <param name="element">The element that raises the event.</param> /// <param name="eventName">The name of the event.</param> /// <param name="routedEvent">The routed event that is raised.</param> /// <param name="eventInfo">The information of the event that is raised</param> /// <param name="handler">The handler of the event.</param> /// <param name="handledEventsToo"> /// <c>true</c> to register the handler such that it is invoked even when the /// event is marked handled in its event data; <c>false</c> to register the /// handler with the default condition that it will not be invoked if the event /// is already marked handled. /// </param> public AvaloniaEventHandlerItem(string elementName, StyledElement element, string eventName, RoutedEvent routedEvent, EventInfo eventInfo, Delegate handler, bool handledEventsToo) : base(elementName, element, eventName, handler, handledEventsToo) { this.routedEvent = routedEvent; this.eventInfo = eventInfo; }
public RotateRoutedEventArgs(RoutedEvent routedEvent, Object source, List <RotateTransform> result) : base(routedEvent, source) { MyProperty = result;; }
public MoveRoutedEventArgs(RoutedEvent routedEvent, Object source, List <List <double> > result) : base(routedEvent, source) { MyProperty = result;; }
//Helper for Choice_Buttons public static RoutedEventHandlerInfo[] GetRoutedEventHandlers(UIElement element, RoutedEvent routedEvent) { // Get the EventHandlersStore instance which holds event handlers for the specified element. // The EventHandlersStore class is declared as internal. var eventHandlersStoreProperty = typeof(UIElement).GetProperty( "EventHandlersStore", BindingFlags.Instance | BindingFlags.NonPublic); object eventHandlersStore = eventHandlersStoreProperty.GetValue(element, null); // Invoke the GetRoutedEventHandlers method on the EventHandlersStore instance // for getting an array of the subscribed event handlers. var getRoutedEventHandlers = eventHandlersStore.GetType().GetMethod( "GetRoutedEventHandlers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); var routedEventHandlers = (RoutedEventHandlerInfo[])getRoutedEventHandlers.Invoke( eventHandlersStore, new object[] { routedEvent }); return(routedEventHandlers); }
public ReportTimeEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source) { }
/// <summary> /// Initializes a new instance of the <see cref="SelectionChangedEventArgs"/> class. /// </summary> /// <param name="routedEvent">The event being raised.</param> /// <param name="addedItems">The items added to the selection.</param> /// <param name="removedItems">The items removed from the selection.</param> public SelectionChangedEventArgs(RoutedEvent routedEvent, IList addedItems, IList removedItems) : base(routedEvent) { AddedItems = addedItems; RemovedItems = removedItems; }
public CollectionItemEventArgs(EventType eventType, object?item, int index, RoutedEvent @event) : base(eventType, @event) { Item = item; Index = index; }