static SelectionCanvas()
 {
     FigureSelectedEvent =
         EventManager.RegisterRoutedEvent("FigureSelected", RoutingStrategy.Bubble, typeof(FigureSelectedEventHandler), typeof(SelectionCanvas));
     FiguresUpdatedEvent =
         EventManager.RegisterRoutedEvent("FigureUpdated", RoutingStrategy.Bubble, typeof(FiguresUpdatedEventHandler), typeof(SelectionCanvas));
 }

 protected ExecutionConnectionDragEventArgs(RoutedEvent routedEvent, object source, object node, object executionConnection, object executionConnector) :
     base(routedEvent, source)
 {
     this.node = node;
     this.draggedOutExecutionConnector = executionConnector;
     this.executionConnection = executionConnection;
 }

 private EventTriggerHandler(FrameworkElement element, RoutedEvent routedEvent, IEnumerable<ITriggerAction> actions, BaseValueSource valueSource)
 {
     this.element = element;
     this.routedEvent = routedEvent;
     this.actions = actions;
     this.valueSource = valueSource;
 }

 public static void RaiseKeyboardEvent(this UIElement self, RoutedEvent evt, Key key)
 {
     self.RaiseEvent(new KeyEventArgs(Keyboard.PrimaryDevice, new FakePresentationSource(), 0, key)
     {
         RoutedEvent = evt
     });
 }

        // Registers a RoutedEvent with the given details
        // NOTE: The Name must be unique within the given OwnerType
        internal static RoutedEvent RegisterRoutedEvent(
            string name,
            RoutingStrategy routingStrategy,
            Type handlerType,
            Type ownerType)
        {
            Debug.Assert(GetRoutedEventFromName(name, ownerType, false) == null, 
                                "RoutedEvent name must be unique within a given OwnerType");

            lock (Synchronized)
            {
                // Create a new RoutedEvent
                // Requires GlobalLock to access _countRoutedEvents
                RoutedEvent routedEvent = new RoutedEvent(
                    name, 
                    routingStrategy, 
                    handlerType, 
                    ownerType);
                
                // Increment the count for registered RoutedEvents
                // Requires GlobalLock to access _countRoutedEvents
                _countRoutedEvents++;

                AddOwner(routedEvent, ownerType);

                return routedEvent;
            }
        }

		static BrushComboBox()
		{
			SelectedIndexProperty = DependencyProperty.Register("SelectedIndex", typeof(int), typeof(BrushComboBox));
			SelectedItemProperty = DependencyProperty.Register("SelectedItem", typeof(SolidColorBrush), typeof(BrushComboBox));
            ColorChangedEvent = EventManager.RegisterRoutedEvent("ColorChanged", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(BrushComboBox));
            IsEmptyColorProperty = DependencyProperty.Register("IsEmptyColor", typeof(bool), typeof(BrushComboBox));
		}

 public RoutedIdentifiedEventArgs(RoutedEvent e, ClientIdentity clientId, object source)
     : base(e, source)
 {
     if (clientId == null)
         throw new NotSupportedException("clientId cannot be null.");
     this.ClientId = clientId;
 }

 public RoutedDependencyPropertyChangedEventArgs(RoutedEvent routedEvent, DependencyProperty dependencyProperty, object oldValue, object newValue)
 {
     RoutedEvent = routedEvent;
     DependencyProperty = dependencyProperty;
     OldValue = oldValue;
     NewValue = newValue;
 }

        /// <summary>
        /// Static constructor for the <see cref="NavigationPanelItem"/> 
        /// class registering dependency properties and events.
        /// </summary>
        static NavigationPanelItem()
        {
            DefaultStyleKeyProperty.OverrideMetadata(typeof(NavigationPanelItem), new FrameworkPropertyMetadata(typeof(NavigationPanelItem)));

            NavigationPanelItemNameProperty = DependencyProperty.Register(
                "NavigationPanelItemName", typeof(string), typeof(NavigationPanelItem));

            ImageLocationProperty = DependencyProperty.Register(
                "ImageLocation", typeof(string), typeof(NavigationPanelItem));

            NavigationListProperty = DependencyProperty.Register(
                "NavigationList", typeof(List<NavigationList>), typeof(NavigationList), new FrameworkPropertyMetadata(new List<NavigationList>()));

            IsSelectedProperty = DependencyProperty.Register(
                "IsSelected", typeof(bool), typeof(NavigationPanelItem));

            CommandProperty = DependencyProperty.Register(
                "Command", typeof(ICommand), typeof(NavigationPanelItem));

            CommandParameterProperty = DependencyProperty.Register(
                "CommandParameter", typeof(object), typeof(NavigationPanelItem));

            CommandTargetProperty = DependencyProperty.Register(
                "CommandTarget", typeof(UIElement), typeof(NavigationPanelItem));

            ItemClickedEvent = EventManager.RegisterRoutedEvent(
                "ItemClicked", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(NavigationPanelItem));
        }

        public DialogClosingEventArgs(DialogSession session, object parameter, RoutedEvent routedEvent, object source) : base(routedEvent, source)
        {
            if (session == null) throw new ArgumentNullException(nameof(session));
            Session = session;

            Parameter = parameter;            
        }

 protected ConnectionDragEventArgs(RoutedEvent routedEvent, object source,
     ElementItem elementItem, ConnectorItem sourceConnectorItem)
     : base(routedEvent, source)
 {
     _elementItem = elementItem;
     _sourceConnectorItem = sourceConnectorItem;
 }

 public PageChangedEventArgs(RoutedEvent EventToRaise, int OldPage, int NewPage, int TotalPages)
     : base(EventToRaise)
 {
     _OldPage = OldPage;
     _NewPage = NewPage;
     _TotalPages = TotalPages;
 }

        static CommandSelector()
        {
            CommandProperty = DependencyProperty.Register(
                "Command",
                typeof(ICommand),
                typeof(CommandSelector),
                new FrameworkPropertyMetadata(OnCommandChanged) {
                    BindsTwoWayByDefault = true
                }
            );

            CommandsSourceProperty = DependencyProperty.Register(
                "CommandsSource",
                typeof(object),
                typeof(CommandSelector),
                new PropertyMetadata(OnCommandsSourceChanged)
            );

            FilterProperty = DependencyProperty.Register(
                "Filter",
                typeof(object),
                typeof(CommandSelector),
                new PropertyMetadata(null, OnFilterChanged)
            );

            CommandChangedEvent = EventManager.RegisterRoutedEvent(
                "CommandChanged",
                RoutingStrategy.Bubble,
                typeof(RoutedPropertyChangedEventHandler<ICommand>),
                typeof(CommandSelector)
            );
        }

        public static void RemoveHandler(DependencyObject element, RoutedEvent routedEvent, Delegate handler)
        {
            if (element == null) { throw new ArgumentNullException("element"); }

            var uie = element as UIElement;
            if (uie != null)
            {
                uie.RemoveHandler(routedEvent, handler);
            }
            else
            {
                var ce = element as ContentElement;
                if (ce != null)
                {
                    ce.RemoveHandler(routedEvent, handler);
                }
                else
                {
                    var u3d = element as UIElement3D;
                    if (u3d != null)
                        u3d.RemoveHandler(routedEvent, handler);
                    else
                        throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Invalid element {0}.", element.GetType()));
                }
            }
        }

 protected ConnectionDragEventArgs(RoutedEvent routedEvent, object source, object node, object connection, object connector) :
     base(routedEvent, source)
 {
     this.node = node;
     this.draggedOutConnector = connector;
     this.connection = connection;
 }

 internal static void RemoveWeakHandler(
     this UIElement source,
     RoutedEvent routedEvent,
     EventHandler<RoutedEventArgs> handler)
 {
     switch (routedEvent.Name)
     {
         case nameof(UIElement.GotKeyboardFocus):
             GotKeyboardFocusEventManager.RemoveHandler(source, handler);
             break;
         case nameof(UIElement.MouseUp):
             MouseUpEventManager.RemoveHandler(source, handler);
             break;
         case nameof(UIElement.PreviewMouseLeftButtonDown):
             PreviewMouseLeftButtonDownEventManager.RemoveHandler(source, handler);
             break;
         case nameof(UIElement.MouseLeftButtonDown):
             MouseLeftButtonDownEventManager.RemoveHandler(source, handler);
             break;
         case nameof(Control.MouseDoubleClick):
             MouseDoubleClickEventManager.RemoveHandler(source, handler);
             break;
         default:
             throw new ArgumentOutOfRangeException();
     }
 }

		static void RaiseCaptureEvent(Contact contact, RoutedEvent routedEvent, DependencyObject source, long timestamp)
		{
			ContactEventArgs args = new ContactEventArgs(contact, timestamp);
			args.RoutedEvent = routedEvent;
			args.Source = source;
			MultitouchLogic.RaiseEvent(source, args);
		}

 public CommentRoutedEventArgs(RoutedEvent routedEvent, Comment c, CommentUC control, bool requiresDataRecontext)
     : base(routedEvent)
 {
     Comment = c;
     CommentControl = control;
     this.RequiresDataRecontext = requiresDataRecontext;
 }

 static TimelineBar()
 {
     // events
     TimelineSelectedEvent = EventManager.RegisterRoutedEvent(
         "TimelineSelected", RoutingStrategy.Bubble,
         typeof(RoutedEventHandler), typeof(TimelineBar));
 }

        public DragablzDragDeltaEventArgs(RoutedEvent routedEvent, object source, DragablzItem dragablzItem, DragDeltaEventArgs dragDeltaEventArgs) 
            : base(routedEvent, source, dragablzItem)
        {
            if (dragDeltaEventArgs == null) throw new ArgumentNullException("dragDeltaEventArgs");

            _dragDeltaEventArgs = dragDeltaEventArgs;
        }