Ejemplo n.º 1
0
        public IDisposable AddClassHandler(
            Type targetType,
            EventHandler <RoutedEventArgs> handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false)
        {
            return(Raised.Subscribe(args =>
            {
                var sender = args.Item1;
                var e = args.Item2;

                if (targetType.GetTypeInfo().IsAssignableFrom(sender.GetType().GetTypeInfo()) &&
                    ((e.Route == RoutingStrategies.Direct) || (e.Route & routes) != 0) &&
                    (!e.Handled || handledEventsToo))
                {
                    try
                    {
                        handler.DynamicInvoke(sender, e);
                    }
                    catch (TargetInvocationException ex)
                    {
                        // Unwrap the inner exception.
                        ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
                    }
                }
            }));
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Adds a handler for the specified routed event.
        /// </summary>
        /// <param name="routedEvent">The routed event.</param>
        /// <param name="handler">The handler.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
        /// <returns>A disposable that terminates the event subscription.</returns>
        public IDisposable AddHandler(
            RoutedEvent routedEvent,
            Delegate handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false)
        {
            Contract.Requires <ArgumentNullException>(routedEvent != null);
            Contract.Requires <ArgumentNullException>(handler != null);

            List <EventSubscription> subscriptions;

            if (!_eventHandlers.TryGetValue(routedEvent, out subscriptions))
            {
                subscriptions = new List <EventSubscription>();
                _eventHandlers.Add(routedEvent, subscriptions);
            }

            var sub = new EventSubscription
            {
                Handler       = handler,
                Routes        = routes,
                AlsoIfHandled = handledEventsToo,
            };

            subscriptions.Add(sub);

            return(Disposable.Create(() => subscriptions.Remove(sub)));
        }
Ejemplo n.º 3
0
 /// <summary>
 /// Adds a handler for the specified routed event.
 /// </summary>
 /// <typeparam name="TEventArgs">The type of the event's args.</typeparam>
 /// <param name="routedEvent">The routed event.</param>
 /// <param name="handler">The handler.</param>
 /// <param name="routes">The routing strategies to listen to.</param>
 /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
 /// <returns>A disposable that terminates the event subscription.</returns>
 public IDisposable AddHandler <TEventArgs>(
     RoutedEvent <TEventArgs> routedEvent,
     EventHandler <TEventArgs> handler,
     RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
     bool handledEventsToo    = false) where TEventArgs : RoutedEventArgs
 {
     return(AddHandler(routedEvent, (Delegate)handler, routes, handledEventsToo));
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Adds a handler for the specified routed event.
 /// </summary>
 /// <typeparam name="TEventArgs">The type of the event's args.</typeparam>
 /// <param name="routedEvent">The routed event.</param>
 /// <param name="handler">The handler.</param>
 /// <param name="routes">The routing strategies to listen to.</param>
 /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
 public void AddHandler <TEventArgs>(
     RoutedEvent <TEventArgs> routedEvent,
     EventHandler <TEventArgs> handler,
     RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
     bool handledEventsToo    = false) where TEventArgs : RoutedEventArgs
 {
     routedEvent = routedEvent ?? throw new ArgumentNullException(nameof(routedEvent));
     handler     = handler ?? throw new ArgumentNullException(nameof(handler));
Ejemplo n.º 5
0
        public EventChainLink(object handler, bool handled, RoutingStrategies route)
        {
            Contract.Requires <ArgumentNullException>(handler != null);

            this.Handler = handler;
            this.Handled = handled;
            this.Route   = route;
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Registers a RoutedEvent with the given details
        /// </summary>
        /// <typeparam name="TOwner"></typeparam>
        /// <typeparam name="TEventArgs"></typeparam>
        /// <param name="name"></param>
        /// <param name="routingStrategy"></param>
        /// <returns></returns>
        public static RoutedEvent <TEventArgs> Register <TOwner, TEventArgs>(
            string name,
            RoutingStrategies routingStrategy)
            where TEventArgs : RoutedEventArgs
        {
            Contract.Requires <ArgumentNullException>(name != null);

            return(new RoutedEvent <TEventArgs>(name, routingStrategy, typeof(TOwner)));
        }
Ejemplo n.º 7
0
        public static RoutedEvent <TEventArgs> Register <TEventArgs>(
            string name,
            RoutingStrategies routingStrategy,
            Type ownerType)
            where TEventArgs : RoutedEventArgs
        {
            Contract.Requires <NullReferenceException>(name != null);

            return(new RoutedEvent <TEventArgs>(name, routingStrategy, ownerType));
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Adds a handler for the specified routed event and returns a disposable that can terminate the event subscription.
        /// </summary>
        /// <typeparam name="TEventArgs">The type of the event's args.</typeparam>
        /// <param name="o">Target for adding given event handler.</param>
        /// <param name="routedEvent">The routed event.</param>
        /// <param name="handler">The handler.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
        /// <returns>A disposable that terminates the event subscription.</returns>
        public static IDisposable AddDisposableHandler <TEventArgs>(this IInteractive o, RoutedEvent <TEventArgs> routedEvent,
                                                                    EventHandler <TEventArgs> handler,
                                                                    RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
                                                                    bool handledEventsToo    = false) where TEventArgs : RoutedEventArgs
        {
            o.AddHandler(routedEvent, handler, routes, handledEventsToo);

            return(Disposable.Create(
                       (instance: o, handler, routedEvent),
                       state => state.instance.RemoveHandler(state.routedEvent, state.handler)));
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Adds a handler to the route.
        /// </summary>
        /// <param name="target">The target on which the event should be raised.</param>
        /// <param name="handler">The handler for the event.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">
        /// If true the handler will be raised even when the routed event is marked as handled.
        /// </param>
        /// <param name="adapter">
        /// An optional adapter which if supplied, will be called with <paramref name="handler"/>
        /// and the parameters for the event. This adapter can be used to avoid calling
        /// `DynamicInvoke` on the handler.
        /// </param>
        public void Add(
            IInteractive target,
            Delegate handler,
            RoutingStrategies routes,
            bool handledEventsToo = false,
            Action <Delegate, object, RoutedEventArgs>?adapter = null)
        {
            target  = target ?? throw new ArgumentNullException(nameof(target));
            handler = handler ?? throw new ArgumentNullException(nameof(handler));

            _route ??= new PooledList <RouteItem>(16);
            _route.Add(new RouteItem(target, handler, adapter, routes, handledEventsToo));
        }
Ejemplo n.º 10
0
 public RouteItem(
     IInteractive target,
     Delegate?handler,
     Action <Delegate, object, RoutedEventArgs>?adapter,
     RoutingStrategies routes,
     bool handledEventsToo)
 {
     Target           = target;
     Handler          = handler;
     Adapter          = adapter;
     Routes           = routes;
     HandledEventsToo = handledEventsToo;
 }
 /// <summary>
 /// Gets an observable for a <see cref="RoutedEvent{TEventArgs}"/>.
 /// </summary>
 /// <param name="o">The object to listen for events on.</param>
 /// <param name="routedEvent">The routed event.</param>
 /// <param name="routes">The routing strategies to listen to.</param>
 /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
 /// <returns>
 /// An observable which fires each time the event is raised.
 /// </returns>
 public static IObservable <TEventArgs> GetObservable <TEventArgs>(
     this IInteractive o,
     RoutedEvent <TEventArgs> routedEvent,
     RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
     bool handledEventsToo    = false)
     where TEventArgs : RoutedEventArgs
 {
     return(Observable.Create <TEventArgs>(x => o.AddHandler(
                                               routedEvent,
                                               (_, e) => x.OnNext(e),
                                               routes,
                                               handledEventsToo)));
 }
Ejemplo n.º 12
0
        public static RoutedEvent <TEventArgs> Register <TEventArgs>(
            string name,
            RoutingStrategies routingStrategy,
            Type ownerType)
            where TEventArgs : RoutedEventArgs
        {
            Contract.Requires <ArgumentNullException>(name != null);

            var routedEvent = new RoutedEvent <TEventArgs>(name, routingStrategy, ownerType);

            RoutedEventRegistry.Instance.Register(ownerType, routedEvent);
            return(routedEvent);
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Adds a handler for the specified routed event.
        /// </summary>
        /// <param name="routedEvent">The routed event.</param>
        /// <param name="handler">The handler.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
        public void AddHandler(
            RoutedEvent routedEvent,
            Delegate handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false)
        {
            routedEvent = routedEvent ?? throw new ArgumentNullException(nameof(routedEvent));
            handler     = handler ?? throw new ArgumentNullException(nameof(handler));

            var subscription = new EventSubscription(handler, routes, handledEventsToo);

            AddEventSubscription(routedEvent, subscription);
        }
Ejemplo n.º 14
0
        public IDisposable AddClassHandler <TTarget>(
            Action <TTarget, TEventArgs> handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false) where TTarget : class, IInteractive
        {
            void Adapter(object?sender, RoutedEventArgs e)
            {
                if (sender is TTarget target && e is TEventArgs args)
                {
                    handler(target, args);
                }
            }

            return(AddClassHandler(typeof(TTarget), Adapter, routes, handledEventsToo));
        }
Ejemplo n.º 15
0
        public RoutedEvent(
            string name,
            RoutingStrategies routingStrategies,
            Type eventArgsType,
            Type ownerType)
        {
            Contract.Requires <ArgumentNullException>(name != null);
            Contract.Requires <ArgumentNullException>(eventArgsType != null);
            Contract.Requires <ArgumentNullException>(ownerType != null);
            Contract.Requires <InvalidCastException>(typeof(RoutedEventArgs).GetTypeInfo().IsAssignableFrom(eventArgsType.GetTypeInfo()));

            EventArgsType     = eventArgsType;
            Name              = name;
            OwnerType         = ownerType;
            RoutingStrategies = routingStrategies;
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Gets an observable for a <see cref="RoutedEvent{TEventArgs}"/>.
        /// </summary>
        /// <param name="o">The object to listen for events on.</param>
        /// <param name="routedEvent">The routed event.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
        /// <returns>
        /// An observable which fires each time the event is raised.
        /// </returns>
        public static IObservable <TEventArgs> GetObservable <TEventArgs>(
            this IInteractive o,
            RoutedEvent <TEventArgs> routedEvent,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false)
            where TEventArgs : RoutedEventArgs
        {
            o           = o ?? throw new ArgumentNullException(nameof(o));
            routedEvent = routedEvent ?? throw new ArgumentNullException(nameof(routedEvent));

            return(Observable.Create <TEventArgs>(x => o.AddDisposableHandler(
                                                      routedEvent,
                                                      (_, e) => x.OnNext(e),
                                                      routes,
                                                      handledEventsToo)));
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Adds a handler for the specified routed event.
        /// </summary>
        /// <param name="routedEvent">The routed event.</param>
        /// <param name="handler">The handler.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
        /// <returns>A disposable that terminates the event subscription.</returns>
        public IDisposable AddHandler(
            RoutedEvent routedEvent,
            Delegate handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false)
        {
            Contract.Requires <ArgumentNullException>(routedEvent != null);
            Contract.Requires <ArgumentNullException>(handler != null);

            var subscription = new EventSubscription
            {
                Handler       = handler,
                Routes        = routes,
                AlsoIfHandled = handledEventsToo,
            };

            return(AddEventSubscription(routedEvent, subscription));
        }
Ejemplo n.º 18
0
        public IDisposable AddClassHandler <TTarget>(
            Func <TTarget, Action <TEventArgs> > handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false)
            where TTarget : class, IInteractive
        {
            EventHandler <RoutedEventArgs> adapter = (sender, e) =>
            {
                var target = sender as TTarget;
                var args   = e as TEventArgs;

                if (target != null && args != null)
                {
                    handler(target)(args);
                }
            };

            return(AddClassHandler(typeof(TTarget), adapter, routes, handledEventsToo));
        }
Ejemplo n.º 19
0
        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);
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Adds a handler for the specified routed event.
        /// </summary>
        /// <typeparam name="TEventArgs">The type of the event's args.</typeparam>
        /// <param name="routedEvent">The routed event.</param>
        /// <param name="handler">The handler.</param>
        /// <param name="routes">The routing strategies to listen to.</param>
        /// <param name="handledEventsToo">Whether handled events should also be listened for.</param>
        /// <returns>A disposable that terminates the event subscription.</returns>
        public IDisposable AddHandler <TEventArgs>(
            RoutedEvent <TEventArgs> routedEvent,
            EventHandler <TEventArgs> handler,
            RoutingStrategies routes = RoutingStrategies.Direct | RoutingStrategies.Bubble,
            bool handledEventsToo    = false) where TEventArgs : RoutedEventArgs
        {
            Contract.Requires <ArgumentNullException>(routedEvent != null);
            Contract.Requires <ArgumentNullException>(handler != null);

            // EventHandler delegate is not covariant, this forces us to create small wrapper
            // that will cast our type erased instance and invoke it.
            Type eventArgsType = routedEvent.EventArgsType;

            if (!s_invokeHandlerCache.TryGetValue(eventArgsType, out var invokeAdapter))
            {
                void InvokeAdapter(Delegate baseHandler, object sender, RoutedEventArgs args)
                {
                    var typedHandler = (EventHandler <TEventArgs>)baseHandler;
                    var typedArgs    = (TEventArgs)args;

                    typedHandler(sender, typedArgs);
                }

                invokeAdapter = InvokeAdapter;

                s_invokeHandlerCache.Add(eventArgsType, invokeAdapter);
            }

            var subscription = new EventSubscription
            {
                InvokeAdapter = invokeAdapter,
                Handler       = handler,
                Routes        = routes,
                AlsoIfHandled = handledEventsToo,
            };

            return(AddEventSubscription(routedEvent, subscription));
        }
Ejemplo n.º 21
0
 public void AddToChain(object handler, bool handled, RoutingStrategies route)
 {
     AddToChain(new EventChainLink(handler, handled, route));
 }
Ejemplo n.º 22
0
 public MetadataTestClass(string name, RoutingStrategies routingStrategies, Type eventArgsType, Type ownerType) : base(name, routingStrategies, eventArgsType, ownerType)
 {
 }
Ejemplo n.º 23
0
 static public void Register(this Control item, RoutedEvent routed_event, FunctionSyncro function, RoutingStrategies routes = RoutingStrategies.Bubble)
 {
     item.AddHandler(routed_event, function.GetRoutedEventHandler <RoutedEventArgs>(), routes);
 }
Ejemplo n.º 24
0
 public RoutedEvent(string name, RoutingStrategies routingStrategies, Type ownerType)
     : base(name, routingStrategies, typeof(TEventArgs), ownerType)
 {
 }
Ejemplo n.º 25
0
 public void AddClassHandler(Type type, EventHandler <RoutedEventArgs> handler, RoutingStrategies routes)
 {
     _subscriptions.Add(new ClassEventSubscription
     {
         TargetType = type,
         Handler    = handler,
         Routes     = routes,
     });
 }
Ejemplo n.º 26
0
 public RoutedEvent(string name, RoutingStrategies routingStrategies, Type ownerType)
     : base(name, routingStrategies, typeof(TEventArgs), ownerType)
 {
     Contract.Requires <ArgumentNullException>(name != null);
     Contract.Requires <ArgumentNullException>(ownerType != null);
 }
Ejemplo n.º 27
0
 public EventChainLink(object handler, bool handled, RoutingStrategies route)
 {
     Handler = handler ?? throw new ArgumentNullException(nameof(handler));
     Handled = handled;
     Route   = route;
 }
Ejemplo n.º 28
0
        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;
        }
Ejemplo n.º 29
0
 public static RoutedEvent Register <TOwner, TEventArgs>(string name, RoutingStrategies routing)
     where TEventArgs : RoutedEventArgs
 {
     return(RoutedEvent.Register <TOwner, TEventArgs>(name, routing));
 }