PushButton.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009-2011 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Tomi Karppinen, Tero Jäntti
 */

using System;
using Jypeli.Controls;
using Jypeli.WP7;
using Microsoft.Xna.Framework;

namespace Jypeli.Widgets
{
    public class PushButton : Label
    {
        private enum State
        {
            Released,
            Hover,
            LeftPressed,
            RightPressed
        }

        private ShapeCache leftSideShape;
        private ShapeCache topSideShape;
        private ShapeCache RightSideShape;
        private ShapeCache BottomSideShape;

        private ShapeCache leftSidePressedShape;
        private ShapeCache topSidePressedShape;
        private ShapeCache RightSidePressedShape;
        private ShapeCache BottomSidePressedShape;

        private Image imageReleased;
        private Image imagePressed;
        private Image imageHover;

        private State state = State.Released;

        private bool isPressed { get { return state == State.LeftPressed || state == State.RightPressed; } }

        private Color releasedColor;
        private Color hoverColor;
        private Color pressedColor;

        public Image ImageReleased 
        {
            get { return imageReleased; }
            set
            {
                imageReleased = value;
                if ( ! isPressed && !Game.Controls.Mouse.IsCursorOn(this) )
                    Image = value;
            }
        }

        public Image ImagePressed
        {
            get { return imagePressed; }
            set
            {
                imagePressed = value;
                if ( isPressed )
                    Image = value;
            }
        }

        public Image ImageHover
        {
            get { return imageHover; }
            set 
            {
                imageHover = value;
                if ( !isPressed && Game.Controls.Mouse.IsCursorOn( this ) )
                    Image = value;
            }
        }

        public override Vector Size
        {
            get
            {
                return base.Size;
            }
            set
            {
                base.Size = value;
                InitializeShape();
            }
        }

        public override Color Color
        {
            get
            {
                return base.Color;
            }
            set
            {
                releasedColor = value;
                hoverColor = Color.Lighter( value, 20 );
                pressedColor = Color.Darker( value, 20 );
                base.Color = value;
            }
        }

        public event Action Clicked;

        public event Action Pressed;

        public event Action Released;

        public event Action Down;

        public event Action RightClicked;


#if WINDOWS_PHONE
        State firstState = State.Released;

        void TouchPress( Touch touch )
        {
            if ( Pressed != null && (state == State.Hover || state == State.Released) )
                Pressed();

            firstState = State.LeftPressed;
            SetState( State.LeftPressed );
        }

        void TouchHover( Touch touch )
        {
            double touchX = touch.PositionOnScreen.X;
            double touchY = touch.PositionOnScreen.Y;

            if ( touchX >= Left && touchX <= Right && touchY >= Bottom && touchY <= Top )
            {
                if ( firstState == State.Released )
                    firstState = State.Hover;

                if ( state != firstState )
                    SetState( firstState );
            }
            else if ( Game.TouchPanel.NumTouches == 1 )
            {
                SetState( State.Released );
            }
        }

        void TouchRelease( Touch touch )
        {
            if ( Game.TouchPanel.NumTouches > 1 || firstState == State.Released )
                return;

            firstState = State.Released;
            SetState( State.Released );

            if ( Released != null )
                Released();
        }

        void TouchClick( Touch touch )
        {
            Click();
        }
#endif

        public PushButton( string text )
            : base(text)
        {
            Initialize();
        }

        public PushButton( Image image )
            : base( image )
        {
            Initialize();
            this.Image = image;
        }

        public PushButton( double width, double height )
            : base( width, height )
        {
            Initialize();
        }

        private void Initialize()
        {
            InitializeMargins();
            InitializeShape();
            Color = new Color( 70, 130, 180, 230 );
            TextColor = new Color( 250, 250, 250, 240 );
            AddedToGame += InitializeControls;
        }

        private void InitializeMargins()
        {
            XMargin = 15;
            YMargin = 10;
        }

        public PushButton( double width, double height, Image image )
            : this( width, height )
        {
            this.Image = image;
        }

        public PushButton( double width, double height, string text )
            : base( width, height, text )
        {
            Initialize();
        }

        private void InitializeControls()
        {
            Game.Controls.Mouse.ListenOn( this, MouseButton.Left, ButtonState.Pressed, Press, null, MouseButton.Left ).InContext( this );
            Game.Controls.Mouse.Listen( MouseButton.Left, ButtonState.Released, Release, null ).InContext( this );

            Game.Controls.Mouse.ListenOn( this, MouseButton.Right, ButtonState.Pressed, Press, null, MouseButton.Right ).InContext( this );
            Game.Controls.Mouse.Listen( MouseButton.Right, ButtonState.Released, Release, null ).InContext( this );

            // workaround for ButtonState.Release not always working inside a window
            Game.Controls.Mouse.ListenOn( this, MouseButton.Left, ButtonState.Released, Release, null ).InContext( this );

            Game.Controls.Mouse.ListenMovement( 1.0, CheckHover, null ).InContext( this );

#if WINDOWS_PHONE
            Game.Instance.TouchPanel.ListenOn( this, ButtonState.Pressed, TouchPress, null ).InContext( this );
            Game.Instance.TouchPanel.Listen( ButtonState.Down, TouchHover, null ).InContext( this );
            Game.Instance.TouchPanel.ListenOn( this, ButtonState.Released, TouchRelease, null ).InContext( this );
            Game.Instance.TouchPanel.Listen( ButtonState.Released, TouchRelease, null ).InContext( this );
            Game.Instance.TouchPanel.ListenOn(  this, ButtonState.Released, TouchClick, null ).InContext( this );
#endif
        }

        private void InitializeShape()
        {
            //double edgeSize = Math.Min( Width, Height ) / 5;
            double edgeSize = 5;
            double relativeHorizontalSize = edgeSize / Width;
            double relativeVerticalSize = edgeSize / Height;

            Vector topLeftOuter = new Vector( -0.5, 0.5 );
            Vector topLeftInner = new Vector( -0.5 + relativeHorizontalSize, 0.5 - relativeVerticalSize );
            Vector bottomLeftOuter = new Vector( -0.5, -0.5 );
            Vector bottomLeftInner = new Vector( -0.5 + relativeHorizontalSize, -0.5 + relativeVerticalSize );
            Vector topRightOuter = new Vector( 0.5, 0.5 );
            Vector topRightInner = new Vector( 0.5 - relativeHorizontalSize, 0.5 - relativeVerticalSize );
            Vector bottomRightOuter = new Vector( 0.5, -0.5 );
            Vector bottomRightInner = new Vector( 0.5 - relativeHorizontalSize, -0.5 + relativeVerticalSize );

            IndexTriangle[] triangles = { new IndexTriangle(0, 1, 2), new IndexTriangle(1, 3, 2), };

            Vector[] leftSideVertices = { topLeftOuter, topLeftInner, bottomLeftOuter, bottomLeftInner, };
            Vector[] topSideVertices = { topLeftOuter, topRightOuter, topLeftInner, topRightInner, };
            Vector[] rightSideVertices = { topRightOuter, bottomRightOuter, topRightInner, bottomRightInner, };
            Vector[] bottomSideVertices = { bottomRightOuter, bottomLeftOuter, bottomRightInner, bottomLeftInner, };

            leftSideShape = new ShapeCache( leftSideVertices, triangles );
            topSideShape = new ShapeCache( topSideVertices, triangles );
            RightSideShape = new ShapeCache( rightSideVertices, triangles );
            BottomSideShape = new ShapeCache( bottomSideVertices, triangles );

            const double scale = 1.4;

            topLeftOuter = new Vector( -0.5, 0.5 );
            topLeftInner = new Vector( -0.5 + relativeHorizontalSize / scale, 0.5 - relativeVerticalSize / scale );
            bottomLeftOuter = new Vector( -0.5, -0.5 );
            bottomLeftInner = new Vector( -0.5 + relativeHorizontalSize / scale, -0.5 + relativeVerticalSize * scale );
            topRightOuter = new Vector( 0.5, 0.5 );
            topRightInner = new Vector( 0.5 - relativeHorizontalSize * scale, 0.5 - relativeVerticalSize / scale );
            bottomRightOuter = new Vector( 0.5, -0.5 );
            bottomRightInner = new Vector( 0.5 - relativeHorizontalSize * scale, -0.5 + relativeVerticalSize * scale );

            Vector[] leftSidePressedVertices = { topLeftOuter, topLeftInner, bottomLeftOuter, bottomLeftInner, };
            Vector[] topSidePressedVertices = { topLeftOuter, topRightOuter, topLeftInner, topRightInner, };
            Vector[] rightSidePressedVertices = { topRightOuter, bottomRightOuter, topRightInner, bottomRightInner, };
            Vector[] bottomSidePressedVertices = { bottomRightOuter, bottomLeftOuter, bottomRightInner, bottomLeftInner, };

            leftSidePressedShape = new ShapeCache( leftSidePressedVertices, triangles );
            topSidePressedShape = new ShapeCache( topSidePressedVertices, triangles );
            RightSidePressedShape = new ShapeCache( rightSidePressedVertices, triangles );
            BottomSidePressedShape = new ShapeCache( bottomSidePressedVertices, triangles );
        }

        private void SetState( State state )
        {
            this.state = state;

            switch ( state )
            {
                case State.Hover:
                    base.Color = hoverColor;
                    if ( ImageHover != null )
                        Image = ImageHover;
                    break;
                case State.RightPressed:
                case State.LeftPressed:
                    base.Color = pressedColor;
                    if ( ImagePressed != null )
                        ImagePressed = ImagePressed;
                    break;
                default:
                    base.Color = releasedColor;
                    if ( ImageReleased != null )
                        Image = ImageReleased;
                    break;
            }
        }

        public void Click()
        {
            if ( Clicked != null )
                Clicked();
        }

        public void RightClick()
        {
            if ( RightClicked != null )
                RightClicked();
        }

        public void AddShortcut( Key key )
        {
            Jypeli.Game.Instance.Keyboard.Listen( key, ButtonState.Pressed, Click, null ).InContext( this );
        }

        public void AddShortcut( Button button )
        {
            for ( int i = 0; i < Jypeli.Game.Controls.GameControllers.Length; i++ )
                AddShortcut( i, button );
        }

        public void AddShortcut( int player, Button button )
        {
            Jypeli.Game.Controls.GameControllers[player].Listen( button, ButtonState.Pressed, Click, null ).InContext( this );
        }

        private void Press( MouseButton button )
        {
            if ( state != State.Hover && state != State.Released )
                return;

            if ( button == MouseButton.Left )
                SetState( State.LeftPressed );
            else if ( button == MouseButton.Right )
                SetState( State.RightPressed );

            if ( Pressed != null )
                Pressed();
        }

        private void Release()
        {
            if ( state != State.LeftPressed && state != State.RightPressed )
                return;

            bool wasLeft = state == State.LeftPressed;
            bool wasRight = state == State.RightPressed;
            bool cursorOn = Game.Controls.Mouse.IsCursorOn( this );

            if ( cursorOn )
            {
                SetState(State.Hover);

                if ( wasLeft ) Click();
                else if ( wasRight ) RightClick();
            }
            else
            {
                SetState( State.Released );
            }

            if ( Released != null )
                Released();
        }

        private void CheckHover( AnalogState state )
        {
            if ( isPressed )
                return;

            SetState( Game.Controls.Mouse.IsCursorOn( this ) ? State.Hover : State.Released );
        }

        protected override void Draw( Matrix parentTransformation, Matrix transformation )
        {
            base.Draw( parentTransformation, transformation );

            if ( Image == null )
            {
                Color color1 = Color.Lighter( Color, 20 );
                Color color2 = Color.Darker( Color, 20 );

                ShapeCache left = leftSideShape;
                ShapeCache top = topSideShape;
                ShapeCache right = RightSideShape;
                ShapeCache bottom = BottomSideShape;

                if ( isPressed )
                {
                    color1 = Color.Darker( Color, 20 );
                    color2 = Color.Lighter( Color, 20 );
                    left = leftSidePressedShape;
                    top = topSidePressedShape;
                    right = RightSidePressedShape;
                    bottom = BottomSidePressedShape;
                }

                Renderer.DrawFilledShape( left, ref transformation, color1 );
                Renderer.DrawFilledShape( top, ref transformation, color1 );
                Renderer.DrawFilledShape( right, ref transformation, color2 );
                Renderer.DrawFilledShape( bottom, ref transformation, color2 );
            }
        }

        public override void Update( Time time )
        {
            if ( Down != null && ( state == State.LeftPressed || state == State.RightPressed ) )
            {
                Down();
            }

            base.Update( time );
        }
    }
}