<Command Name="UIClick">
    <Trigger Button="MouseLeft" State="Released" />
    <Trigger Button="TouchPress" State="Released" />
    <Trigger Button="Space" State="Released" />
    <Trigger Button="GamePadA" State="Released" />
    <Trigger Button="GestureTap" State="Released" />
  </Command>

			Input.Commands["UIClick"].AddTrigger(new CommandTrigger
			{
				Button = InputButton.GestureTap,
				State = InputState.Released,
			});

        
        private static Point[] LastTouchPoint; // Stores a copy of the previous frame's touch/drag/pinch finger positions
        private static Point BuggyPos;         // Helps identify when Input.Touch.Touches[1] has invalid info

        private enum Gestures { None, Touching, Touched, Dragging, Dragged, Pinching, Pinched } // Possible gestures
        private static Gestures Gesture;       // Gesture currently being undertaken
        private static Gestures LastGesture;   // Saves a copy of the last active gesture for debugging purposes (Gesture will be Gestures.None between gestures)

        private static void ProcessTouches()
        {
            TouchData touch0 = Input.Touch.Touches[0]; // Shortcut
            TouchData touch1 = Input.Touch.Touches[1]; // Shortcut
            int currentTouches = 0;                    // A more accurate/helpful version of Input.Touch.ActiveTouches

            // Processes mouse movement as if it were a one-finger touch
            if (Input.Mouse.IsConnected)
            {
                if (Input.Mouse.LeftButtonIsPressed)
                {
                    currentTouches = 1;
                    touch0.Position = Input.Mouse.Position;
                }
            }
            else
            {
                if (touch0.State <= InputState.Released && touch1.State >= InputState.Pressed)
                {
                    // We are in a buggy situation where the user is apparently not touching with finger 0 but is touching with finger 1!
                    // Actually he's touching with neither
                    BuggyPos = touch1.Position;

                    // Since the user is, in fact, not touching the touchscreen, if we haven't closed off the Pinch gesture do it now
                    // Not convinced this is foolproof. I don't do anything off the back of Pinched so I haven't tested!
                    if (Gesture == Gestures.Pinching) Gesture = Gestures.Pinched;
                }
                else
                {
                    // Input.Touch.Touches[0] is reliable
                    if (touch0.State >= InputState.Pressed) currentTouches++;

                    // Input.Touch.Touches[1] is unreliable. 
                    // Only treat it as a real touch if BuggyPos is not set or the finger has definitely moved
                    if (touch1.State >= InputState.Pressed && (BuggyPos == Point.Zero || (touch1.Position != BuggyPos)))
                    {
                        currentTouches++;
                        BuggyPos = Point.Zero;
                    }
                }
            }

            // Process based on the gesture carried over from the previous frame plus the number of ActiveTouches this frame
            switch (Gesture)
            {
                case Gestures.None:
                    switch (currentTouches)
                    {
                        case 0: break;                              // Continuing to do nothing
                        case 1: Gesture = Gestures.Touching; break; // Gone from no fingers to one finger
                        case 2: Gesture = Gestures.Pinching; break; // Gone from no fingers to two fingers
                    }
                    break;
                case Gestures.Touching:
                    switch (currentTouches)
                    {
                        case 0: Gesture = Gestures.Touched; break;  // Gone from one finger to no fingers
                        case 1: if (touch0.Position != LastTouchPoint[0]) Gesture = Gestures.Dragging; break; // Finger has started moving
                        case 2: Gesture = Gestures.Pinching; break; // Gone from one fingers to two fingers
                    }
                    break;
                case Gestures.Dragging:
                    switch (currentTouches)
                    {
                        case 0: Gesture = Gestures.Dragged; break;  // Gone from one moving finger to no fingers
                        case 1: break;                              // Drag is still ongoing
                        case 2: Gesture = Gestures.Dragged; break;  // Gone from one fingers to two fingers - but we need to close out the drag event; next frame it will begin Pinching
                    }
                    break;
                case Gestures.Pinching:
                    switch (currentTouches)
                    {
                        case 0: Gesture = Gestures.Pinched; break; // Gone from two moving finger to no fingers
                        case 1: Gesture = Gestures.Pinched; break; // Gone from two fingers to one finger - but we need to close out the pinch event; next frame it will begin Touching
                        case 2: break;                             // Pinch is still ongoing
                    }
                    break;
            }

            var dragAmount = Point.Zero; // Set the amount of drag this frame
            float pinchAmount = 0;       // Set the amount of pinch this frame

            if (currentTouches == 1 && touch0.Position != LastTouchPoint[0])
            {
                dragAmount = touch0.Position - LastTouchPoint[0];
            }
            else
            {
                if (currentTouches == 2 && (touch0.Position != LastTouchPoint[0] || touch1.Position != LastTouchPoint[1]) && LastTouchPoint[0] != Point.Zero && LastTouchPoint[1] != Point.Zero)
                {
                    // Don't know if pinches are actually calculated this way but it works for my purposes!
                    var oldDistance = Point.Distance(LastTouchPoint[0], LastTouchPoint[1]);
                    var newDistance = Point.Distance(touch0.Position, touch1.Position);
                    pinchAmount = newDistance - oldDistance;
                }
            }

            // Record the current end position assuming it's a genuine touch
            if (currentTouches > 0) LastTouchPoint[0] = touch0.Position;
            if (currentTouches > 1) LastTouchPoint[1] = touch1.Position;

            // Go off and process any user code based on the current state of the gesture
            switch (Gesture)
            {
                case Gestures.Touching:
                    Touching();            // Process an ongoing touch event - eg. if held down for >1 second do something
                    break;
                case Gestures.Touched:
                    Touched();             // Process a completed touch event - ie. a click
                    break;
                case Gestures.Dragging:
                    Dragging(dragAmount);  // Process an ongoing drag event passing in the amount of drag this frame
                    break;
                case Gestures.Dragged:
                    Dragged(dragAmount);   // Process a completed drag event
                    break;
                case Gestures.Pinching:
                    Pinching(pinchAmount); // Process an ongoing pinch event passing in the amount of pinch this frame
                    break;
                case Gestures.Pinched:
                    Pinched(pinchAmount);  // Process a completed pinch event
                    break;
            }

            // Record the current gesture for debug info purposes
            if (Gesture != Gestures.None) LastGesture = Gesture;

            // If we have completed a touch/drag/pinch action this frame, reset the variables
            if (Gesture == Gestures.Touched || Gesture == Gestures.Dragged || Gesture == Gestures.Pinched)
            {
                Gesture = Gestures.None;
                LastTouchPoint[0] = Point.Zero;
                LastTouchPoint[1] = Point.Zero;
            }
        }