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;
        }

 /// <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 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);
     }
 }

 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;
 }

        /// <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 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;
 }

 public WpfXamlMember(RoutedEvent re, 
     EventInfo eventInfo,
     XamlSchemaContext schemaContext, 
     bool useV3Rules) 
     : base(eventInfo, schemaContext)
 { 
     RoutedEvent = re;
     _useV3Rules = useV3Rules;
     _underlyingMemberIsKnown = true;
 } 

 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 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);
        }

        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;
 }

        /// <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;
 }

		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);
			}
		}

		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);
			}
		}

        /// <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;
 }