public new bool ProcessTouch(GestureSample gesture)
        {
            Point localGesturePoint = Spotlight.TranslateScreenVectorToWorldPoint(gesture.Position);

            if (!CanRespond()) return false;

            if (RespondsToWorldTouch(localGesturePoint) || IsFirstResponder())
            {

                switch (gesture.GestureType)
                {
                    case GestureType.FreeDrag:
                        SetCenter(localGesturePoint);
                        BecomeFirstResponder();
                        break;
                    case GestureType.DragComplete:
                        ResignFirstResponder();
                        break;
                    default:
                        return false;
                }
                return true;
            }

            return false;
        }

 public bool InteractGesture(GestureSample gesture)
 {
     bool ret = false;
     ret |= m_centerButton.InteractGesture(gesture);
     ret |= m_contextMenu.InteractGesture(gesture);
     return ret;
 }

        /// <summary>
        /// Process a touch gesture and return an indicator of whether or not the user has advanced past this cutscene.
        /// This is abberant behavior from our usual application paradigm because a cutscene it treated as a special case. 
        /// </summary>
        /// <param name="gesture"></param>
        /// <returns>true if the user has touched the Continue button. False otherwise. </returns>
        public override bool ProcessTouch(GestureSample gesture)
        {
            if (continueButton.ProcessTouch(gesture))
            {
                return true;
            }

            switch (gesture.GestureType)
            {
                case GestureType.FreeDrag:
                    offset -= gesture.Delta;
                    motionTarget = Vector2.Zero;
                    EnforceBoundaries();
                    return false;
                case GestureType.Flick:
                    Vector2 normal = gesture.Delta;
                    normal.Normalize();
                    motionTarget = offset - (normal * 200);
                    return false;
                case GestureType.Tap:
                    motionTarget = Vector2.Zero;
                    return false;
                default:
                    return false;

            }
        }

        public void RespondToTouch(GestureSample gesture)
        {
            //if (gesture.GestureType == GestureType.Flick)
            //{
            //    var move = new Vector2(MathHelper.Clamp(gesture.Delta.X, -flickLimit, flickLimit), MathHelper.Clamp(gesture.Delta.Y, -flickLimit, flickLimit));
            //    Body.ApplyLinearImpulse(ConvertUnits.ToSimUnits(move * 50));
            //}

            if (gesture.GestureType == GestureType.Tap)
            {
                if (currentJumpCount >= consecutiveJumps)
                {
                    //return;
                }

                lastJumpTime = DateTime.Now;
                currentJumpCount++;

                if (!isOnGround)
                {
                    //Body.ResetDynamics();
                }
                sphere.Body.ApplyForce(new Vector2(0, -jumpForce));
                //isOnGround = false;
            }
        }

        public static void Update()
        {
            m_Gesture = TouchPanel.IsGestureAvailable ? TouchPanel.ReadGesture() : new GestureSample();

            if (CurrentTouchCollection.Count > 0)
            {
                OldTouchCollection = CurrentTouchCollection;
            }

            CurrentTouchCollection = TouchPanel.GetState();

                    if (CurrentTouchCollection.Count > 0)
                    {
                        while (TouchPanel.IsGestureAvailable)
                        {
                            TouchPanel.ReadGesture();
                        }
                    }

            #if !Windows
            m_LastKeyboardState = m_CurrentKeyboardState;
            m_CurrentKeyboardState = Keyboard.GetState();

            m_LastMouseState = m_CurrentMouseState;
            m_CurrentMouseState = Mouse.GetState();
            #endif
        }

        public bool InteractGesture(GestureSample gesture)
        {
            foreach (TextScreenObject contextMenuItem in m_contextMenuItems)
                if (contextMenuItem.InteractGesture(gesture))
                    return true;

            return false;
        }

 public GestureDefinition(GestureType theGestureType, Rectangle theGestureArea)
 {
     Gesture = new GestureSample(theGestureType, new TimeSpan(0),
                                 Vector2.Zero, Vector2.Zero,
                                 Vector2.Zero, Vector2.Zero);
     Type = theGestureType;
     CollisionArea = theGestureArea;
 }

        public new bool ProcessTouch(GestureSample gesture)
        {
            if (gesture.GestureType != GestureType.FreeDrag) return false;
            if (hidden || !Contains(gesture.Position)) return false;

            SetCenter(gesture.Position);

            return true;
        }

 public void InteractGesture(GestureSample gesture)
 {
     if (gesture.GestureType == GestureType.Tap
         && gesture.Position.X < m_textPosition.X + WarlockGame.m_spriteFont.MeasureString(m_buttonText).X && gesture.Position.X > m_textPosition.X
         && gesture.Position.Y < m_textPosition.Y + WarlockGame.m_spriteFont.MeasureString(m_buttonText).Y && gesture.Position.Y > m_textPosition.Y)
     {
         Execute();
     }
 }

        public override bool ProcessTouch(GestureSample gesture)
        {
            if (hidden) return false;
            if (!base.ProcessTouch(gesture)) return false; //Easy out

            if (gesture.GestureType != GestureType.Tap) return false;

            SetSelected(true);
            return true;
        }

 /// <summary>
 /// Process the Single Tag into a Gesture
 /// </summary>
 /// <param name='e'>
 /// If set to <c>true</c> e.
 /// </param>
 public override bool OnSingleTapConfirmed(MotionEvent e)
 {
     if ((TouchPanel.EnabledGestures & GestureType.Tap) != 0)
     {
         var gs = new GestureSample(GestureType.Tap, activity.Game.TargetElapsedTime,
             new Vector2(e.GetX(), e.GetY()), Vector2.Zero, Vector2.Zero, Vector2.Zero);
         TouchPanel.GestureList.Enqueue(gs);
     }
     return base.OnSingleTapConfirmed (e);
 }

        internal IMessage Create(GestureSample gestureSample)
        {
            switch (gestureSample.GestureType)
            {
                case GestureType.Tap:
                    return new Message<TapGesture>(new TapGesture(gestureSample));
            }

            return null;
        }

        private Vector2 ComputeVelocity(GestureSample gesture)
        {
            Vector2 diff = _currentPosition - _startPosition;

            float magnitude = Math.Min(diff.Length(), 100) * 5;
            diff.Normalize();
            Vector2 result = diff * magnitude;

            return result;
        }

 public bool InteractGesture(GestureSample gesture)
 {
     if (gesture.GestureType == GestureType.Tap
         && gesture.Position.X < ExitButton.X + WarlockGame.TextureDictionary["leavecity"].Width && gesture.Position.X > ExitButton.X
         && gesture.Position.Y < ExitButton.Y + WarlockGame.TextureDictionary["leavecity"].Height && gesture.Position.Y > ExitButton.Y)
     {
         Execute();
         return true;
     }
     return false;
 }

        public Vector2 EndShooting(GestureSample gesture)
        {
            Vector2 velocity = ComputeVelocity(gesture);

            _startShootingTime = default(TimeSpan);
            _startPosition = default(Vector2);

            State = GameState.Idle;

            return velocity;
        }

        public void Update(GestureSample gesture)
        {
            if (State == GameState.Idle)
            {
                _startShootingTime = gesture.Timestamp;
                _startPosition = new Vector2(gesture.Position.X, gesture.Position.Y);
                State = GameState.Shooting;
            }

            _currentPosition = new Vector2(gesture.Position.X, gesture.Position.Y);
        }

        /// <summary>
        /// A helper function which automatically calls GetScaleFactor and GetTranslationDelta and applies them to the
        /// given object position and scale. You can either use this function or call GetScaleFactor and GetTranslationDelta
        /// manually. This function assumes that the origin of your object is at its center, and that the position
        /// given is in screen-space.
        /// </summary>
        /// <param name="gesture">The gesture sample containing the pinch gesture data. The GestureType must be
        /// GestureType.Pinch.</param>
        /// <param name="objectPos">The current position of your object, in screen-space.</param>
        /// <param name="objectScale">The current scale of your object.</param>
        public static void ApplyPinchZoom(GestureSample gesture, ref Vector2 objectPos, ref float objectScale)
        {
            System.Diagnostics.Debug.Assert(gesture.GestureType == GestureType.Pinch);

            float scaleFactor = PinchZoom.GetScaleFactor(gesture.Position, gesture.Position2,
                gesture.Delta, gesture.Delta2);
            Vector2 translationDelta = PinchZoom.GetTranslationDelta(gesture.Position, gesture.Position2,
                gesture.Delta, gesture.Delta2, objectPos, scaleFactor);

            objectScale *= scaleFactor;
            objectPos += translationDelta;
        }

 public virtual bool InteractGesture(GestureSample gesture)
 {
     if (TapDelegate != null
         && gesture.GestureType == GestureType.Tap
         && gesture.Position.X < ScreenPosition.X + Size.X && gesture.Position.X > ScreenPosition.X
         && gesture.Position.Y < ScreenPosition.Y + Size.Y && gesture.Position.Y > ScreenPosition.Y)
     {
         TapDelegate();
         return true;
     }
     return false;
 }

		/// <summary>
		/// convert the DoubleTapEvent to a Gesture
		/// </summary>
		/// <param name='e'>
		/// If set to <c>true</c> e.
		/// </param>
		public override bool OnDoubleTap (MotionEvent e)
		{
			if ((TouchPanel.EnabledGestures & GestureType.DoubleTap) != 0)
			{				
				Vector2 positon = new Vector2(e.GetX(), e.GetY());
				AndroidGameActivity.Game.Window.UpdateTouchPosition(ref positon);
				var gs = new GestureSample(GestureType.DoubleTap, AndroidGameActivity.Game.TargetElapsedTime, 
					positon, Vector2.Zero, Vector2.Zero, Vector2.Zero);
				TouchPanel.GestureList.Enqueue(gs);
			}
			return base.OnDoubleTap (e);
		}

        /// <summary>
        /// Call this to initialize a Behaviour with data supplied in a file.
        /// </summary>
        /// <param name="fileName">The file to load from.</param>
        public override void LoadContent(String fileName)
        {
            base.LoadContent(fileName);

            mGesture = new GestureSample();

            mFxMenuSelect = GameObjectManager.pInstance.pContentManager.Load<SoundEffect>("Audio\\FX\\MenuSelect");

            mGameRestartMsg = new Player.OnGameRestartMessage();
            mGetCurrentStateMsg = new Player.GetCurrentStateMessage();
            mGetCurrentHitCountMsg = new HitCountDisplay.GetCurrentHitCountMessage();
        }