MultiSelectWindow.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli.Controls;
using Jypeli.GameObjects;

namespace Jypeli.Widgets
{
    public class MultiSelectWindow : Window
    {
        static readonly Key[] keys = { Key.D1, Key.D2, Key.D3, Key.D4, Key.D5, Key.D6, Key.D7, Key.D8, Key.D9, Key.D0 };

        private int _defaultCancel = 0;
        private Listener _escListener = null;
        private Listener _xboxListener = null;
        private Listener _backListener = null;

        private int _selectedIndex = -1;
        private Color _selectedColor = Color.Black;
        private Color _selectionColor = Color.Cyan;
        private bool _buttonColorSet = false;
        private Font _font;

        private Dictionary<int, List<Action>> handlers = new Dictionary<int,List<Action>>();
        private int clickedButton = -1;

        public Label QuestionLabel;

        public PushButton[] Buttons { get; private set; }

        public Font Font
        {
            get
            {
                return this._font;
            }
            set
            {
                QuestionLabel.Font = value;

                for (int i = 0; i < Buttons.Length; i++)
                {
                    Buttons[i].Font = value;
                }
            }
        }

        public int DefaultCancel
        {
            get { return _defaultCancel; }
            set
            {
                _defaultCancel = value;
                if (Game.Instance != null) AddDefaultControls();
            }
        }

        public int SelectedIndex
        {
            get { return _selectedIndex; }
            set
            {
                if ( !IsAddedToGame ) RememberSelection = true;
                SelectButton( value );
            }
        }

        public PushButton SelectedButton
        {
            get { return _selectedIndex >= 0 || _selectedIndex >= Buttons.Length ? Buttons[_selectedIndex] : null; }
        }

        public override Color Color
        {
            get
            {
                return base.Color;
            }
            set
            {
                if (!_buttonColorSet) _setButtonColor(Color.Darker(value, 40));
                base.Color = value;
            }
        }

        public Color SelectionColor
        {
            get { return _selectionColor; }
            set
            {
                _selectionColor = value;
                SelectButton(_selectedIndex);
            }
        }

        public bool RememberSelection { get; set; }

        public event Action<int> ItemSelected;

        public MultiSelectWindow(string question, params string[] buttonTexts)
            : base()
        {
            if (buttonTexts.Length == 0) throw new InvalidOperationException("You must add at least one button");

            VerticalScrollLayout layout = new VerticalScrollLayout();
            layout.LeftPadding = layout.RightPadding = 20;
            layout.BottomPadding = 30;
            layout.Spacing = 20;
            this.Layout = layout;

            QuestionLabel = new Label(question);
            Add(QuestionLabel);

            this.Closed += CallButtonHandlers;

            Buttons = new PushButton[buttonTexts.Length];
            this._font = Font.Default;
            for (int i = 0; i < buttonTexts.Length; i++)
            {
                PushButton button = new PushButton(buttonTexts[i]);
                button.Tag = i;
                button.Clicked += new Action(delegate { ButtonClicked((int)button.Tag); });
#if WINDOWS_PHONE
            if ( Game.Instance.Phone.DisplayResolution == WP7.DisplayResolution.Large )
                button.TextScale = new Vector(2, 2);
#endif
                Add(button);
                Buttons[i] = button;
            }

            Game.AssertInitialized(delegate { AddControls(); AddDefaultControls(); });
            AddedToGame += delegate { SelectButton( (RememberSelection && _selectedIndex >= 0) ? _selectedIndex : 0 ); };
        }

        private void SelectButton(int p)
        {
#if !WINDOWS_PHONE
            UnselectButton();
            if (p < 0 || p >= Buttons.Length) return;

            _selectedIndex = p;
            _selectedColor = SelectedButton.Color;
            SelectedButton.Color = SelectionColor;
#endif
        }

        private void UnselectButton()
        {
            if (_selectedIndex < 0) return;
            SelectedButton.Color = _selectedColor;
            _selectedIndex = -1;
        }

        public void AddItemHandler(int item, Action handler)
        {
            if ( !handlers.ContainsKey(item) )
                handlers[item] = new List<Action>();

            handlers[item].Add( handler );
        }

        public void AddItemHandler<T1>(int item, Action<T1> handler, T1 p1)
        {
            if ( !handlers.ContainsKey( item ) )
                handlers[item] = new List<Action>();

            handlers[item].Add( delegate { handler( p1 ); } );
        }

        public void AddItemHandler<T1, T2>(int item, Action<T1, T2> handler, T1 p1, T2 p2)
        {
            if ( !handlers.ContainsKey( item ) )
                handlers[item] = new List<Action>();

            handlers[item].Add( delegate { handler( p1, p2 ); } );
        }

        public void AddItemHandler<T1, T2, T3>(int item, Action<T1, T2, T3> handler, T1 p1, T2 p2, T3 p3)
        {
            if ( !handlers.ContainsKey( item ) )
                handlers[item] = new List<Action>();

            handlers[item].Add( delegate { handler( p1, p2, p3 ); } );
        }

        public void RemoveItemHandler(int item, Action handler)
        {
            if ( !handlers.ContainsKey( item ) )
                return;

            handlers[item].Remove( handler );
        }

        private void _setButtonColor(Color color)
        {
            for (int i = 0; i < Buttons.Length; i++)
            {
                Buttons[i].Color = color;
            }

            // Re-set the color for selected item and reselect it
            _selectedColor = color;
            SelectButton(_selectedIndex);
        }

        public void SetButtonColor(Color color)
        {
            _setButtonColor(color);
            _buttonColorSet = true;
        }

        public void SetButtonTextColor(Color color)
        {
            for (int i = 0; i < Buttons.Length; i++)
            {
                Buttons[i].TextColor = color;
            }
        }

        void AddControls()
        {
            for (int i = 0; i < Math.Min(Buttons.Length, keys.Length); i++)
            {
                Jypeli.Game.Instance.Keyboard.Listen(keys[i], ButtonState.Pressed, ButtonClicked, null, i).InContext(this);
            }

            Handler selectPrev = delegate { SelectButton(_selectedIndex > 0 ? _selectedIndex - 1 : Buttons.Length - 1); };
            Handler selectNext = delegate { SelectButton(_selectedIndex < Buttons.Length - 1 ? _selectedIndex + 1 : 0); };
            Handler confirmSelect = delegate { SelectedButton.Click(); };

            Jypeli.Game.Instance.Keyboard.Listen(Key.Up, ButtonState.Pressed, selectPrev, null).InContext(this);
            Jypeli.Game.Instance.Keyboard.Listen(Key.Down, ButtonState.Pressed, selectNext, null).InContext(this);
            Jypeli.Game.Instance.Keyboard.Listen(Key.Enter, ButtonState.Pressed, confirmSelect, null).InContext(this);

            Jypeli.Game.Instance.ControllerOne.Listen(Button.DPadUp, ButtonState.Pressed, selectPrev, null).InContext(this);
            Jypeli.Game.Instance.ControllerOne.Listen(Button.DPadDown, ButtonState.Pressed, selectNext, null).InContext(this);
            Jypeli.Game.Instance.ControllerOne.Listen(Button.A, ButtonState.Pressed, confirmSelect, null).InContext(this);
        }

        void AddDefaultControls()
        {
            if (_backListener != null) Jypeli.Game.Instance.PhoneBackButton.Remove(_backListener);
            if (_escListener != null) Jypeli.Game.Instance.Keyboard.Remove(_escListener);
            if (_xboxListener != null) Jypeli.Game.Instance.Keyboard.Remove(_xboxListener);

            if (_defaultCancel >= 0 && _defaultCancel < Buttons.Length)
            {
                _backListener = Jypeli.Game.Instance.PhoneBackButton.Listen(Buttons[_defaultCancel].Click, null).InContext(this);
                _escListener = Jypeli.Game.Instance.Keyboard.Listen(Key.Escape, ButtonState.Pressed, Buttons[_defaultCancel].Click, null).InContext(this);
                _xboxListener = Jypeli.Game.Instance.ControllerOne.Listen(Button.B, ButtonState.Pressed, Buttons[_defaultCancel].Click, null).InContext(this);
            }
        }

        void ButtonClicked(int index)
        {
            clickedButton = index;
            Close();
        }

        void CallButtonHandlers( Window window )
        {
            if ( clickedButton < 0 || clickedButton >= Buttons.Length )
                return;

            if ( handlers.ContainsKey( clickedButton ) )
                handlers[clickedButton].ForEach( handler => handler() );

            if ( ItemSelected != null )
                ItemSelected( clickedButton );
        }
    }
}