TouchPanel.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework.Input.Touch;
using Jypeli.Controls;
 
namespace Jypeli
{
    using XnaTouchPanel = Microsoft.Xna.Framework.Input.Touch.TouchPanel;
    using XnaGestureType = Microsoft.Xna.Framework.Input.Touch.GestureType;
 
    public delegate void TouchHandler( Touch touch );
    public delegate void TouchHandler<T>( Touch touch, T p );
    public delegate void TouchHandler<T1, T2>( Touch touch, T1 p1, T2 p2 );
    public delegate void TouchHandler<T1, T2, T3>( Touch touch, T1 p1, T2 p2, T3 p3 );
 
    public class TouchPanel : Controls.Controller
    {
        protected static readonly Predicate<Touch> AlwaysTrigger = delegate { return true; };
 
        private ScreenView screen;
        private TouchPanelCapabilities caps;
        private List<Touch> touches;
        private List<Touch> newTouches;
        private List<Gesture> gestures;
 
        private readonly SynchronousList<TouchListener> DownListeners = new SynchronousList<TouchListener>();
        private readonly SynchronousList<TouchListener> PressListeners = new SynchronousList<TouchListener>();
        private readonly SynchronousList<TouchListener> ReleaseListeners = new SynchronousList<TouchListener>();
        private readonly SynchronousList<TouchListener> GestureListeners = new SynchronousList<TouchListener>();
 
        private ListenContext _snipContext = null;
        private ListenContext _pinchContext = null;
 
        public bool IsConnected
        {
            get { return caps.IsConnected; }
        }
 
        public int ActiveChannels
        {
            get { return touches.Count + gestures.Count; }
        }
 
        public int NumTouches
        {
            get { return touches.Count; }
        }
 
        public int MaxTouches
        {
            get { return caps.MaximumTouchCount; }
        }
 
        public int NumGestures
        {
            get { return gestures.Count; }
        }
 
        public bool FollowSnipping
        {
            get { return _snipContext != null; }
            set
            {
                TouchHandler handler = delegate ( Touch t ) { Game.Instance.Camera.Position -= t.MovementOnWorld; };
                ContextHandler op = delegate ( ListenContext ctx ) { Listen( ButtonState.Down, handler, "Move around" ).InContext( ctx ); };
                setContext( ref _snipContext, value, op );
            }
        }
 
        public bool FollowPinching
        {
            get { return _pinchContext != null; }
            set
            {
                TouchHandler handler = delegate ( Touch t )
                {
                    Gesture g = (Gesture)t;
                    Game.Instance.Camera.Zoom( g.WorldDistanceAfter.Magnitude / g.WorldDistanceBefore.Magnitude );
                };
                ContextHandler op = delegate ( ListenContext ctx ) { ListenGesture( GestureType.Pinch, handler, "Zoom" ); };
                setContext( ref _pinchContext, value, op );
            }
        }
 
        delegate void ContextHandler( ListenContext ctx );
 
        private void setContext( ref ListenContext context, bool enable, ContextHandler operation )
        {
            if ( ( context != null ) == enable ) return;
            if ( enable )
            {
                context = Game.Instance.ControlContext.CreateSubcontext();
                context.Active = true;
                operation( context );
            }
            else
            {
                context.Destroy();
                context = null;
            }
        }
 
        internal TouchPanel( ScreenView screen )
        {
            this.screen = screen;
 
            try
            {
                this.caps = XnaTouchPanel.GetCapabilities();
            }
            catch (TypeLoadException)
            {
                this.caps = new TouchPanelCapabilities();
            }
 
            this.touches = new List<Touch>( caps.MaximumTouchCount );
            this.newTouches = new List<Touch>( caps.MaximumTouchCount );
        }
 
        private static bool IsBeingTouched( ScreenView screen, Vector touchOnScreen, GameObject obj )
        {
            if ( obj == null || obj.Layer == null || obj.IsDestroyed ) return false;
            return obj.IsInside( Game.Instance.Camera.ScreenToWorld( touchOnScreen, obj.Layer ) );
        }
 
        private static HoverState GetHoverState( Touch touch, GameObject obj )
        {
            bool prevOn = IsBeingTouched( Game.Screen, touch.PrevPositionOnScreen, obj );
            bool currOn = IsBeingTouched( Game.Screen, touch.PositionOnScreen, obj );
 
            if ( prevOn && currOn ) return HoverState.On;
            if ( !prevOn && !currOn ) return HoverState.Off;
            if ( !prevOn && currOn ) return HoverState.Enter;
            return HoverState.Exit;
        }
 
        private Predicate<Touch> MakeTriggerRule( GameObject obj, HoverState hover )
        {
            return delegate( Touch touch )
            {
                if ( obj == null || obj.IsDestroyed || obj.Layer == null ) return false;
                return GetHoverState( touch, obj ) == hover;
            };
        }
 
        public void Update()
        {
            UpdateTouches();
            UpdateGestures();
        }
 
        public void UpdateTouches()
        {
            var xnaTouches = XnaTouchPanel.GetState();
 
            for ( int i = 0; i < xnaTouches.Count; i++ )
            {
                Touch prevTouch = touches.Find( s => s.Id == xnaTouches[i].Id );
                Touch thisTouch = prevTouch != null ? prevTouch : new Touch( screen, xnaTouches[i] );
 
                newTouches.Add( thisTouch );
                DownListeners.ForEach( dl => dl.CheckAndInvoke( thisTouch ) );
 
                if ( prevTouch == null )
                {
                    // New touch
                    PressListeners.ForEach( dl => dl.CheckAndInvoke( thisTouch ) );
                }
                else
                {
                    // Existing touch
                    touches.Remove( thisTouch );
                    thisTouch.Update( xnaTouches[i] );
                }
            }
 
            for ( int i = 0; i < touches.Count; i++ )
            {
                // Released touch
                ReleaseListeners.ForEach( dl => dl.CheckAndInvoke( touches[i] ) );
            }
 
            DownListeners.UpdateChanges();
            PressListeners.UpdateChanges();
            ReleaseListeners.UpdateChanges();
 
            touches.Clear();
            var empty = touches;
            touches = newTouches;
            newTouches = empty;
        }
 
        public void UpdateGestures()
        {
            var samples = new List<Gesture>();
 
            if ( XnaTouchPanel.EnabledGestures == XnaGestureType.None )
                return;
 
            while ( XnaTouchPanel.IsGestureAvailable )
                samples.Add( new Gesture( XnaTouchPanel.ReadGesture() ) );
 
            this.GestureListeners.UpdateChanges();
            this.gestures = samples;
        }
 
        public void Clear()
        {
            DownListeners.Clear();
            PressListeners.Clear();
            ReleaseListeners.Clear();
            GestureListeners.Clear();
        }
 
        public IEnumerable<string> GetHelpTexts()
        {
            foreach ( var l in PressListeners )
            {
                if ( l.HelpText != null )
                    yield return String.Format( "TouchPanel Press", l.HelpText );
            }
 
            foreach ( var l in DownListeners )
            {
                if ( l.HelpText != null )
                    yield return String.Format( "TouchPanel Down", l.HelpText );
            }
 
            foreach ( var l in ReleaseListeners )
            {
                if ( l.HelpText != null )
                    yield return String.Format( "TouchPanel Release", l.HelpText );
            }
        }
        
        private SynchronousList<TouchListener> GetList( ButtonState state )
        {
            switch ( state )
            {
                case ButtonState.Down: return DownListeners;
                case ButtonState.Pressed: return PressListeners;
                case ButtonState.Released: return ReleaseListeners;
            }
 
            throw new ArgumentException( "Button state is not supported" );
        }
 
        private Listener AddListener( SynchronousList<TouchListener> list, Predicate<Touch> rule, string helpText, Delegate handler, params object[] args )
        {
            var l = new TouchListener( rule, Game.Instance.ControlContext, helpText, handler, args );
            list.Add( l );
            return l;
        }
 
        private Listener AddGestureListener( Predicate<Gesture> rule, string helpText, Delegate handler, params object[] args )
        {
            Predicate<Touch> touchRule = ( Touch t ) => t is Gesture && rule( (Gesture)t );
            var l = new TouchListener( touchRule, Game.Instance.ControlContext, helpText, handler, args );
            GestureListeners.Add( l );
            return l;
        }
 
        public Listener Listen( ButtonState state, TouchHandler handler, string helpText )
        {
            return AddListener( GetList( state ), AlwaysTrigger, helpText, handler );
        }
 
        public Listener Listen<T>( ButtonState state, TouchHandler handler, string helpText, T p )
        {
            return AddListener( GetList( state ), AlwaysTrigger, helpText, handler, p );
        }
 
        public Listener Listen<T1, T2>( ButtonState state, TouchHandler handler, string helpText, T1 p1, T2 p2 )
        {
            return AddListener( GetList( state ), AlwaysTrigger, helpText, handler, p1, p2 );
        }
 
        public Listener Listen<T1, T2, T3>( ButtonState state, TouchHandler handler, string helpText, T1 p1, T2 p2, T3 p3 )
        {
            return AddListener( GetList( state ), AlwaysTrigger, helpText, handler, p1, p2, p3 );
        }
 
        public Listener ListenOn( GameObject obj, HoverState hoverstate, ButtonState buttonstate, TouchHandler handler, string helpText )
        {
            Predicate<Touch> rule = MakeTriggerRule( obj, hoverstate );
            return AddListener( GetList( buttonstate ), rule, helpText, handler );
        }
 
        public Listener ListenOn<T>( GameObject obj, HoverState hoverstate, ButtonState buttonstate, TouchHandler<T> handler, string helpText, T p )
        {
            Predicate<Touch> rule = MakeTriggerRule( obj, hoverstate );
            return AddListener( GetList( buttonstate ), rule, helpText, handler, p );
        }
 
        public Listener ListenOn<T1, T2>( GameObject obj, HoverState hoverstate, ButtonState buttonstate, TouchHandler<T1, T2> handler, string helpText, T1 p1, T2 p2 )
        {
            Predicate<Touch> rule = MakeTriggerRule( obj, hoverstate );
            return AddListener( GetList( buttonstate ), rule, helpText, handler, p1, p2 );
        }
 
        public Listener ListenOn<T1, T2, T3>( GameObject obj, HoverState hoverstate, ButtonState buttonstate, TouchHandler<T1, T2, T3> handler, string helpText, T1 p1, T2 p2, T3 p3 )
        {
            Predicate<Touch> rule = MakeTriggerRule( obj, hoverstate );
            return AddListener( GetList( buttonstate ), rule, helpText, handler, p1, p2, p3 );
        }
 
        public Listener ListenOn( GameObject obj, ButtonState buttonstate, TouchHandler handler, string helpText )
        {
            return ListenOn( obj, HoverState.On, buttonstate, handler, helpText );
        }
 
        public Listener ListenOn<T>( GameObject obj, ButtonState buttonstate, TouchHandler<T> handler, string helpText, T p )
        {
            return ListenOn( obj, HoverState.On, buttonstate, handler, helpText, p );
        }
 
        public Listener ListenOn<T1, T2>( GameObject obj, ButtonState buttonstate, TouchHandler<T1, T2> handler, string helpText, T1 p1, T2 p2 )
        {
            return ListenOn( obj, HoverState.On, buttonstate, handler, helpText, p1, p2 );
        }
 
        public Listener ListenOn<T1, T2, T3>( GameObject obj, ButtonState buttonstate, TouchHandler<T1, T2, T3> handler, string helpText, T1 p1, T2 p2, T3 p3 )
        {
            return ListenOn( obj, HoverState.On, buttonstate, handler, helpText, p1, p2, p3 );
        }
 
        public Listener ListenGesture( GestureType type, TouchHandler handler, string helpText )
        {
            XnaTouchPanel.EnabledGestures |= (XnaGestureType)type;
            return AddGestureListener( ( Gesture g ) => g.GestureType == type, helpText, handler );
        }
 
        public Listener ListenGestureOn( GameObject obj, HoverState hoverstate, GestureType type, TouchHandler handler, string helpText )
        {
            Predicate<Touch> hover = MakeTriggerRule( obj, hoverstate );
            return AddGestureListener( (Gesture g) => g.GestureType == type && hover(g), helpText, handler );
        }
 
        public Listener ListenGestureOn( GameObject obj, GestureType type, TouchHandler handler, string helpText )
        {
            return ListenGestureOn( obj, HoverState.On, type, handler, helpText );
        }
 
        public Listener ListenGesture<T1>( GestureType type, TouchHandler handler, string helpText, T1 p1 )
        {
            XnaTouchPanel.EnabledGestures |= (XnaGestureType)type;
            return AddGestureListener( ( Gesture g ) => g.GestureType == type, helpText, handler, p1 );
        }
 
        public Listener ListenGestureOn<T1>( GameObject obj, HoverState hoverstate, GestureType type, TouchHandler handler, string helpText, T1 p1 )
        {
            Predicate<Touch> hover = MakeTriggerRule( obj, hoverstate );
            return AddGestureListener( ( Gesture g ) => g.GestureType == type && hover( g ), helpText, handler, p1 );
        }
 
        public Listener ListenGestureOn<T1>( GameObject obj, GestureType type, TouchHandler handler, string helpText, T1 p1 )
        {
            return ListenGestureOn( obj, HoverState.On, type, handler, helpText, p1 );
        }
 
        public Listener ListenGesture<T1, T2>( GestureType type, TouchHandler handler, string helpText, T1 p1, T2 p2 )
        {
            XnaTouchPanel.EnabledGestures |= (XnaGestureType)type;
            return AddGestureListener( ( Gesture g ) => g.GestureType == type, helpText, handler, p1, p2 );
        }
 
        public Listener ListenGestureOn<T1, T2>( GameObject obj, HoverState hoverstate, GestureType type, TouchHandler handler, string helpText, T1 p1, T2 p2 )
        {
            Predicate<Touch> hover = MakeTriggerRule( obj, hoverstate );
            return AddGestureListener( ( Gesture g ) => g.GestureType == type && hover( g ), helpText, handler, p1, p2 );
        }
 
        public Listener ListenGestureOn<T1, T2>( GameObject obj, GestureType type, TouchHandler handler, string helpText, T1 p1, T2 p2 )
        {
            return ListenGestureOn( obj, HoverState.On, type, handler, helpText, p1 );
        }
 
        public Listener ListenGesture<T1, T2, T3>( GestureType type, TouchHandler handler, string helpText, T1 p1, T2 p2, T3 p3 )
        {
            XnaTouchPanel.EnabledGestures |= (XnaGestureType)type;
            return AddGestureListener( ( Gesture g ) => g.GestureType == type, helpText, handler, p1, p2 );
        }
 
        public Listener ListenGestureOn<T1, T2, T3>( GameObject obj, HoverState hoverstate, GestureType type, TouchHandler handler, string helpText, T1 p1, T2 p2, T3 p3 )
        {
            Predicate<Touch> hover = MakeTriggerRule( obj, hoverstate );
            return AddGestureListener( ( Gesture g ) => g.GestureType == type && hover( g ), helpText, handler, p1, p2 );
        }
 
        public Listener ListenGestureOn<T1, T2, T3>( GameObject obj, GestureType type, TouchHandler handler, string helpText, T1 p1, T2 p2, T3 p3 )
        {
            return ListenGestureOn( obj, HoverState.On, type, handler, helpText, p1 );
        }
    }
}