protected override void OnInput(object sender, InputEventArgs e)
 {
     if (this._gestureStarted)
     {
         base.OnInput(sender, e);
     }
 }

        public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
        {
            var args = inputEventArgs as KeyEventArgs;

            if ((args == null) || !IsDefinedKey(args.Key))
            {
                return false;
            }
            Debug.WriteLine("Modifiers: " + Keyboard.Modifiers);

            if (IsTooLongFromLastKey() || IsWrongModifiers() || IsWrongKey(args.Key))
            {
                currentKeyIndex = 0;
                return false;
            }

            ++currentKeyIndex;

            if (IsMatchingContinued())
            {
                lastPress = DateTime.Now;
                inputEventArgs.Handled = true;
                return false;
            }

            currentKeyIndex = 0;
            Debug.WriteLine("Match completed!");
            return true;
        }

        public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
        {
            if (this._index >= this._gestures.Count) this._index = 0;

            KeyEventArgs e = inputEventArgs as KeyEventArgs;
            if (e == null || IsIgnorableKey(e.Key, e.KeyboardDevice.Modifiers))
            {
                return false;
            }

            if (this._index > 0 && (DateTime.Now - this._lastKeyPress) > _keyPressInterval)
            {
                this._index = 0;
            }

            if (this._gestures[this._index].Matches(targetElement, inputEventArgs))
            {
                this._lastKeyPress = DateTime.Now;
                this._index++;
                inputEventArgs.Handled = true;
                return (this._index == this._gestures.Count);
            }
            else
            {
                this._index = 0;
                return false;
            }
        }

 private void Button_PreviewCSEDown(object sender, InputEventArgs e)
 {
     items.IndexOf(files[0]);
     MainLibraryStack.SelectedIndex = items.IndexOf(files[0]);
     //items.Remove(files[1]);
     //items.Insert(0, files[1]);
 }

        public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
        {
            var args = inputEventArgs as KeyEventArgs;

            // Don't execute input binding in case focus is on a textbox
            if ((inputEventArgs.Device.Target is TextBoxBase || inputEventArgs.Device.Target is WebBrowser)
                && !(modifers == ModifierKeys.Control || modifers == ModifierKeys.Alt))
                return false;

            if (args == null)
                return false;

            bool match;

            if (useModifiers)
                match = args.Key == key && args.KeyboardDevice.Modifiers == modifers;
            else
            {
                match = (args.Key == key && args.KeyboardDevice.Modifiers == ModifierKeys.None);

                // To not interfere with multiple key gestures
                if (previous == Key.G || previous == Key.N || previous == Key.A)
                    match = false;
            }

            previous = args.Key;

            return match;
        }

 protected override bool IsDeviceValid(bool? wasValid, InputEventArgs args)
 {
     var motionDevice = args.Device as MotionTrackingDevice;
     if (motionDevice != null)
         motionDevice.ShouldPromoteToTouch = true;
     return true;
 }

 ///
 /// When overridden in a derived class, determines whether the specified matches the input associated with the specified object.
 ///
 /// The target of the command.
 /// The input event data to compare this gesture to.
 ///
 /// true if the gesture matches the input; otherwise, false.
 ///
 public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
 {
     KeyEventArgs args = inputEventArgs as KeyEventArgs;
     if (args != null)
         return (Key == args.Key);
     else
         return false;
 }

 private void LeftSlideClick(object sender, InputEventArgs e)
 {
     imageIndex--;
     if (imageIndex < 1) {
         imageIndex = 8;
     }
     SlideShow(imageIndex);
     timer.Interval = new TimeSpan(0, 0, 4);
 }

 private void RightSlideClick(object sender, InputEventArgs e)
 {
     imageIndex++;
     if (imageIndex > 8) {
         imageIndex = 1;
     }
     SlideShow(imageIndex);
     timer.Interval = new TimeSpan(0, 0, 4);
 }

 public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
 {
     var action = GetExtendedMouseAction(inputEventArgs);
     if (action != null && extendedMouseAction == action.Value)
     {
         return Modifiers == Keyboard.Modifiers;
     }
     return base.Matches(targetElement, inputEventArgs);
 }

        public StagingAreaInputItem PushInput(InputEventArgs input,
                                              StagingAreaInputItem promote) // Note: this should be a bool, and always use the InputItem available on these args. 
        {
            if(!_allowAccessToStagingArea)
            {
                throw new InvalidOperationException(SR.Get(SRID.NotAllowedToAccessStagingArea)); 
            }
 
            return this.UnsecureInputManager.PushInput(input, promote); 
        }

 private void LayoutRoot_TouchDown(object sender, InputEventArgs e)
 {
     var yi = DataContext as YearItem;
     if (yi == null)
         return;
     yi.Orientation = e.Device.GetOrientation(null) + 90;
     yi.Position = e.Device.GetPosition(null);
     yi.Position.X -= 100;
     yi.Position.Y -= 50;
     (DataContext as YearItem).ShowText = true;
 }

        public void badgeDoubleTap(object sender, InputEventArgs e)
        {
            RaiseEvent(new RoutedEventArgs(RequestLargeViewEvent));
            if(e!=null)
                e.Handled = true;
            //var ap = DataContext as ArgPoint;
            //var id = ap.Id;
            //var zoomedAp = DbCtx.Get().ArgPoint.FirstOrDefault(ap0 => ap0.Id == id);

            //var zoom = new ZoomWindow(zoomedAp);
            //zoom.ShowDialog();
        }

 public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
 {
     if (m_hackMode)
     {
         KeyEventArgs args = inputEventArgs as KeyEventArgs;
         return args != null && Keyboard.Modifiers == ModifierKeys.None && this.Key == args.Key;
     }
     else
     {
         return base.Matches(targetElement, inputEventArgs);
     }
 }

        public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
        {
            // Don't execute input binding in case focus is on a textbox
            if ((inputEventArgs.Device.Target is TextBoxBase || inputEventArgs.Device.Target is WebBrowser)
                && !(modifiers == ModifierKeys.Control || modifiers == ModifierKeys.Alt))
                return false;

            var args = inputEventArgs as KeyEventArgs;

            if ((args == null) || !IsDefinedKey(args.Key))
            {
                return false;
            }

            if (_currentKeyIndex != 0 && ((DateTime.Now - _lastKeyPress) > _maximumDelayBetweenKeyPresses))
            {
                //took too long to press next key so reset
                _currentKeyIndex = 0;
                return false;
            }

            //the modifier only needs to be held down for the first keystroke, but you could also require that the modifier be held down for every keystroke
            if (_currentKeyIndex == 0 && Modifiers != Keyboard.Modifiers)
            {
                //wrong modifiers
                _currentKeyIndex = 0;
                return false;
            }

            if (_keys[_currentKeyIndex] != args.Key)
            {
                //wrong key
                _currentKeyIndex = 0;
                return false;
            }

            ++_currentKeyIndex;

            if (_currentKeyIndex != _keys.Count)
            {
                //still matching
                _lastKeyPress = DateTime.Now;
                inputEventArgs.Handled = true;
                return false;
            }

            //match complete
            _currentKeyIndex = 0;
            return true;
        }

 public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
 {
     if (inputEventArgs is MouseButtonEventArgs)
     {
         MouseButtonEventArgs args = (MouseButtonEventArgs)inputEventArgs;
         switch (ExtraMouseAction)
         {
             case ExtraMouseAction.Back :
                 return args.ChangedButton == MouseButton.XButton1;
             case ExtraMouseAction.Next :
                 return args.ChangedButton == MouseButton.XButton2;
         }
     }
     return false;
 }

 private static ExtendedMouseAction? GetExtendedMouseAction(InputEventArgs inputEventArgs)
 {
     var mouseButtonEventArgs = inputEventArgs as MouseButtonEventArgs;
     if (mouseButtonEventArgs != null)
     {
         switch (mouseButtonEventArgs.ChangedButton)
         {
             case MouseButton.XButton1:
                 return ExtendedMouseAction.XButton1Click;
             case MouseButton.XButton2:
                 return ExtendedMouseAction.XButton2Click;
         }
     }
     return null;
 }

        protected override bool IsDeviceValid(bool? wasValid, InputEventArgs args)
        {
            var motionDevice = args.Device as MotionTrackingDevice;
            if (motionDevice == null)
                return NotifyTransition(wasValid, motionDevice, true);
            if (motionDevice.Session == null)
                return NotifyTransition(wasValid, motionDevice, false);

            Vector3D vector = motionDevice.Session.Position - motionDevice.Session.ShoulderPosition;

            if (Math.Abs(vector.Z) > MinimumDistance)
                return NotifyTransition(wasValid, motionDevice, true);

            return NotifyTransition(wasValid, motionDevice, false);
        }

 /// <summary>
 /// On a TouchDown event check whether the MediaElement is
 /// playing or paused and respond by performing the inverse.
 /// </summary>
 void Media_TouchDown(object sender, InputEventArgs e)
 {
     if (paused)
     {
         BeginStoryboard(Resources["Play"] as Storyboard);
         Media.Play();
         paused = false;
     }
     else
     {
         BeginStoryboard(Resources["Pause"] as Storyboard);
         Media.Pause();
         paused = true;
     }
 }

 public override bool Matches(object targetElement, InputEventArgs inputEventArgs)
 {
     if (!base.Matches(targetElement, inputEventArgs)) return false;
     if (!(inputEventArgs is MouseWheelEventArgs)) return false;
     var args = (MouseWheelEventArgs)inputEventArgs;
     switch (Direction)
     {
         case WheelDirection.None:
             return args.Delta == 0;
         case WheelDirection.Up:
             return args.Delta > 0;
         case WheelDirection.Down:
             return args.Delta < 0;
         default:
             return false;
     }
 }