Added class RoutedEvent handlers.

Perspex.Controls/Button.cs

@@ -7,6 +7,7 @@
 namespace Perspex.Controls
 {
     using System;
+    using Perspex.Input;
     using Perspex.Interactivity;
 
     public class Button : ContentControl
@@ -19,30 +20,6 @@ namespace Perspex.Controls
             FocusableProperty.OverrideDefaultValue(typeof(Button), true);
         }
 
-        public Button()
-        {
-            this.PointerPressed += (s, e) =>
-            {
-                this.Classes.Add(":pressed");
-                e.Device.Capture(this);
-            };
-
-            this.PointerReleased += (s, e) =>
-            {
-                e.Device.Capture(null);
-                this.Classes.Remove(":pressed");
-
-                if (this.Classes.Contains(":pointerover"))
-                {
-                    RoutedEventArgs click = new RoutedEventArgs
-                    {
-                        RoutedEvent = ClickEvent,
-                    };
-                    this.RaiseEvent(click);
-                }
-            };
-        }
-
         public event EventHandler<RoutedEventArgs> Click
         {
             add { this.AddHandler(ClickEvent, value); }
@@ -58,5 +35,42 @@ namespace Perspex.Controls
         {
             return base.ArrangeOverride(finalSize);
         }
+
+        protected virtual void OnClick()
+        {
+        }
+
+        protected override void OnPointerPressed(PointerPressEventArgs e)
+        {
+            base.OnPointerPressed(e);
+
+            this.Classes.Add(":pressed");
+            e.Device.Capture(this);
+        }
+
+        protected override void OnPointerReleased(PointerEventArgs e)
+        {
+            base.OnPointerReleased(e);
+
+            e.Device.Capture(null);
+            this.Classes.Remove(":pressed");
+
+            if (this.Classes.Contains(":pointerover"))
+            {
+                this.RaiseClickEvent();
+            }
+        }
+
+        private void RaiseClickEvent()
+        {
+            this.OnClick();
+
+            RoutedEventArgs click = new RoutedEventArgs
+            {
+                RoutedEvent = ClickEvent,
+            };
+
+            this.RaiseEvent(click);
+        }
     }
 }

Perspex.Controls/Primitives/Thumb.cs

@@ -23,11 +23,11 @@ namespace Perspex.Controls.Primitives
 
         private Point? lastPoint;
 
-        public Thumb()
+        static Thumb()
         {
-            this.DragStarted += (_, e) => this.OnDragStarted(e);
+            DragStartedEvent.AddClassHandler<Thumb>(x => x.OnDragStarted);
-            this.DragDelta += (_, e) => this.OnDragDelta(e);
+            DragDeltaEvent.AddClassHandler<Thumb>(x => x.OnDragDelta);
-            this.DragCompleted += (_, e) => this.OnDragCompleted(e);
+            DragCompletedEvent.AddClassHandler<Thumb>(x => x.OnDragCompleted);
         }
 
         public event EventHandler<VectorEventArgs> DragStarted

Perspex.Controls/Primitives/ToggleButton.cs

@@ -20,7 +20,6 @@ namespace Perspex.Controls.Primitives
 
         public ToggleButton()
         {
-            this.Click += (s, e) => this.Toggle();
         }
 
         public bool IsChecked
@@ -29,6 +28,11 @@ namespace Perspex.Controls.Primitives
             set { this.SetValue(IsCheckedProperty, value); }
         }
 
+        protected override void OnClick()
+        {
+            this.Toggle();
+        }
+
         protected virtual void Toggle()
         {
             this.IsChecked = !this.IsChecked;

Perspex.Input/InputElement.cs

@@ -56,26 +56,23 @@ namespace Perspex.Input
         public static readonly RoutedEvent<PointerEventArgs> PointerReleasedEvent =
             RoutedEvent.Register<InputElement, PointerEventArgs>("PointerReleased", RoutingStrategy.Bubble);
 
-        public static readonly RoutedEvent<PointerEventArgs> PointerWheelChangedEvent =
+        public static readonly RoutedEvent<PointerWheelEventArgs> PointerWheelChangedEvent =
-            RoutedEvent.Register<InputElement, PointerEventArgs>("PointerWheelChanged", RoutingStrategy.Bubble);
+            RoutedEvent.Register<InputElement, PointerWheelEventArgs>("PointerWheelChanged", RoutingStrategy.Bubble);
 
         static InputElement()
         {
             IsEnabledProperty.Changed.Subscribe(IsEnabledChanged);
-        }
 
-        public InputElement()
+            GotFocusEvent.AddClassHandler<InputElement>(x => x.OnGotFocus);
-        {
+            LostFocusEvent.AddClassHandler<InputElement>(x => x.OnLostFocus);
-            this.GotFocus += (_, e) => this.OnGotFocus(e);
+            KeyDownEvent.AddClassHandler<InputElement>(x => x.OnKeyDown);
-            this.LostFocus += (_, e) => this.OnLostFocus(e);
+            PreviewKeyDownEvent.AddClassHandler<InputElement>(x => x.OnPreviewKeyDown);
-            this.KeyDown += (_, e) => this.OnKeyDown(e);
+            PointerEnterEvent.AddClassHandler<InputElement>(x => x.OnPointerEnter);
-            this.PreviewKeyDown += (_, e) => this.OnPreviewKeyDown(e);
+            PointerLeaveEvent.AddClassHandler<InputElement>(x => x.OnPointerLeave);
-            this.PointerEnter += (_, e) => this.OnPointerEnter(e);
+            PointerMovedEvent.AddClassHandler<InputElement>(x => x.OnPointerMoved);
-            this.PointerLeave += (_, e) => this.OnPointerLeave(e);
+            PointerPressedEvent.AddClassHandler<InputElement>(x => x.OnPointerPressed);
-            this.PointerMoved += (_, e) => this.OnPointerMoved(e);
+            PointerReleasedEvent.AddClassHandler<InputElement>(x => x.OnPointerReleased);
-            this.PointerPressed += (_, e) => this.OnPointerPressed(e);
+            PointerWheelChangedEvent.AddClassHandler<InputElement>(x => x.OnPointerWheelChanged);
-            this.PointerReleased += (_, e) => this.OnPointerReleased(e);
-            this.PointerWheelChanged += (_, e) => this.OnPointerWheelChanged(e);
         }
 
         public event EventHandler<RoutedEventArgs> GotFocus

Perspex.Interactivity/Interactive.cs

@@ -116,6 +116,8 @@ namespace Perspex.Interactivity
 
             List<Delegate> delegates;
 
+            e.RoutedEvent.InvokeRaised(this, e);
+
             if (this.eventHandlers.TryGetValue(e.RoutedEvent, out delegates))
             {
                 foreach (Delegate handler in delegates)

Perspex.Interactivity/RoutedEvent.cs

@@ -7,6 +7,7 @@
 namespace Perspex.Interactivity
 {
     using System;
+    using System.Linq.Expressions;
     using System.Reflection;
 
     public enum RoutingStrategy
@@ -60,6 +61,8 @@ namespace Perspex.Interactivity
             private set; 
         }
 
+        public event EventHandler<RoutedEventArgs> Raised;
+
         public static RoutedEvent<TEventArgs> Register<TOwner, TEventArgs>(
             string name,
             RoutingStrategy routingStrategy)
@@ -81,6 +84,14 @@ namespace Perspex.Interactivity
 
             return new RoutedEvent<TEventArgs>(name, routingStrategy, ownerType);
         }
+
+        internal void InvokeRaised(object sender, RoutedEventArgs e)
+        {
+            if (this.Raised != null)
+            {
+                this.Raised(sender, e);
+            }
+        }
     }
 
     public class RoutedEvent<TEventArgs> : RoutedEvent
@@ -93,5 +104,19 @@ namespace Perspex.Interactivity
             Contract.Requires<NullReferenceException>(ownerType != null);
             Contract.Requires<InvalidCastException>(typeof(IInteractive).GetTypeInfo().IsAssignableFrom(ownerType.GetTypeInfo()));
         }
+
+        public void AddClassHandler<TTarget>(Func<TTarget, Action<TEventArgs>> handler) where TTarget : class
+        {
+            this.Raised += (s, e) =>
+            {
+                var target = s as TTarget;
+                var args = e as TEventArgs;
+
+                if (target != null)
+                {
+                    handler(target)(args);
+                }
+            };
+        }
     }
 }