Button.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using HoloToolkit.Unity.InputModule;
using System;
using System.Collections;
using UnityEngine;

namespace HoloToolkit.Unity.Buttons
{
    public abstract class Button : MonoBehaviour, IInputHandler, IPointerSpecificFocusable, IHoldHandler, IInputClickHandler
    {
        #region Public Members and Serialized Fields

        [Header("Basic Settings")]
        [SerializeField]
        [Tooltip("Current State of the Button")]
        private ButtonStateEnum buttonState = ButtonStateEnum.Observation;

        public ButtonStateEnum ButtonState
        {
            get { return buttonState; }
            set { buttonState = value; }
        }

        [SerializeField]
        [Tooltip("Filter for press info for click or press event")]
        private InteractionSourcePressInfo buttonPressFilter = InteractionSourcePressInfo.Select;

        public InteractionSourcePressInfo ButtonPressFilter
        {
            get { return buttonPressFilter; }
            set { buttonPressFilter = value; }
        }

        [SerializeField]
        [Tooltip("If RequireGaze, then looking away will deselect object")]
        private bool requireGaze = true;

        public bool RequireGaze
        {
            get { return requireGaze; }
            set { requireGaze = value; }
        }

        public event Action<ButtonStateEnum> StateChange;

        public event Action<GameObject> OnButtonPressed;

        public event Action<GameObject> OnButtonReleased;

        public event Action<GameObject> OnButtonClicked;

        public event Action<GameObject> OnButtonHeld;

        public event Action<GameObject> OnButtonCanceled;

        #endregion Public Members and Serialized Fields

        #region Private and Protected Members

        protected string _GizmoIcon;

        private bool lastHandVisible = false;

        private bool handVisible { get { return InputManager.Instance.DetectedInputSources.Count > 0; } }

        private bool focused = false;

        private bool isDisabled { get { return ButtonState == ButtonStateEnum.Disabled || !enabled; } }

        #endregion Private and Protected Members

        #region MonoBehaviour Functions

        private void LateUpdate()
        {
            if (!isDisabled && lastHandVisible != handVisible)
            {
                OnHandVisibleChange(handVisible);
            }
        }

        protected virtual void OnDisable()
        {
            if (ButtonState != ButtonStateEnum.Disabled)
            {
                OnStateChange(ButtonStateEnum.Observation);
            }
        }

        #endregion MonoBehaviour Functions

        #region Input Interface Functions

        public void OnInputDown(InputEventData eventData)
        {
            if (!isDisabled)
            {
                if (ButtonPressFilter == InteractionSourcePressInfo.None || ButtonPressFilter == eventData.PressType)
                {
                    DoButtonPressed();

                    eventData.Use();
                }
            }
        }

        public void OnInputUp(InputEventData eventData)
        {
            if (!isDisabled)
            {
                if (ButtonPressFilter == InteractionSourcePressInfo.None || ButtonPressFilter == eventData.PressType)
                {
                    DoButtonReleased();

                    eventData.Use();
                }
            }
        }

        public void OnInputClicked(InputClickedEventData eventData)
        {
            if (!isDisabled)
            {
                if (ButtonPressFilter == InteractionSourcePressInfo.None || ButtonPressFilter == eventData.PressType)
                {
                    DoButtonClicked();

                    eventData.Use();
                }
            }
        }


        public void OnHoldStarted(HoldEventData eventData)
        {
            if (!isDisabled)
            {
                DoButtonHeld();

                eventData.Use();
            }
        }

        public void OnHoldCompleted(HoldEventData eventData)
        {
            // No button event for OnHoldCompleted. State will be handled in OnInputUp.
        }

        public void OnHoldCanceled(HoldEventData eventData)
        {
            if (!isDisabled && ButtonState == ButtonStateEnum.Pressed)
            {
                DoButtonCanceled();

                eventData.Use();
            }
        }

        public void OnFocusEnter(PointerSpecificEventData eventData)
        {
            if (!isDisabled)
            {
                if (ButtonState != ButtonStateEnum.Pressed)
                {
                    OnStateChange(handVisible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted);
                }

                focused = true;

                eventData.Use();
            }
        }

        public void OnFocusExit(PointerSpecificEventData eventData)
        {
            if (!isDisabled)
            {
                // If we require gaze, we should always reset the state and send a canceled if currently pressed.
                if (RequireGaze)
                {
                    if (ButtonState == ButtonStateEnum.Pressed)
                    {
                        DoButtonCanceled();
                    }

                    OnStateChange(handVisible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation);
                }
                // If we don't require gaze, we should only reset if we aren't currently in a pressed state.
                else if (ButtonState != ButtonStateEnum.Pressed)
                {
                    OnStateChange(handVisible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation);
                }

                focused = false;

                eventData.Use();
            }
        }

        #endregion Input Interface Functions

        #region Button Functions

        protected void DoButtonPressed()
        {
            OnStateChange(ButtonStateEnum.Pressed);

            if (OnButtonPressed != null)
            {
                OnButtonPressed(gameObject);
            }

            if (!RequireGaze)
            {
                // Push to the modal stack, so we'll receive a released/clicked event even if focus has left.
                InputManager.Instance.PushModalInputHandler(gameObject);
            }
        }

        protected void DoButtonReleased()
        {
            ResetButtonState();

            if (OnButtonReleased != null)
            {
                OnButtonReleased(gameObject);
            }
        }

        protected void DoButtonClicked()
        {
            if (OnButtonClicked != null)
            {
                OnButtonClicked(gameObject);
            }
        }

        protected void DoButtonHeld()
        {
            if (OnButtonHeld != null)
            {
                OnButtonHeld(gameObject);
            }
        }

        protected void DoButtonCanceled()
        {
            ResetButtonState();

            if (OnButtonCanceled != null)
            {
                OnButtonCanceled(gameObject);
            }
        }

        public virtual void OnHandVisibleChange(bool visible)
        {
            lastHandVisible = visible;

            ButtonStateEnum newState = ButtonState;

            switch (ButtonState)
            {
                case ButtonStateEnum.Interactive:
                {
                    newState = visible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation;
                    break;
                }
                case ButtonStateEnum.Targeted:
                {
                    newState = visible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted;
                    break;
                }
                case ButtonStateEnum.Observation:
                {
                    newState = visible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation;
                    break;
                }
                case ButtonStateEnum.ObservationTargeted:
                {
                    newState = visible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted;
                    break;
                }
                case ButtonStateEnum.Pressed:
                {
                    newState = visible ? ButtonStateEnum.Pressed : focused ? ButtonStateEnum.ObservationTargeted : ButtonStateEnum.Observation;
                    break;
                }
            }

            OnStateChange(newState);
        }

        public virtual void OnStateChange(ButtonStateEnum newState)
        {
            ButtonState = newState;

            // Send out the action/event for the state change.
            if (StateChange != null)
            {
                StateChange(newState);
            }
        }

        #endregion Button Functions

        #region Helper Functions

        public void TriggerClicked()
        {
            DoButtonPressed();

            StartCoroutine(DelayedRelease(0.2f));
        }

        private IEnumerator DelayedRelease(float delay)
        {
            yield return new WaitForSeconds(delay);
            DoButtonReleased();
            DoButtonClicked();
        }

        private void ResetButtonState()
        {
            if (!RequireGaze && ButtonState == ButtonStateEnum.Pressed)
            {
                // Pop from the modal stack as long as gaze is not required (if it is, we never pushed)
                // and the button state is currently pressed (if it isn't, we never pushed).
                InputManager.Instance.PopModalInputHandler();
            }

            ButtonStateEnum newState;

            if (focused)
            {
                newState = handVisible ? ButtonStateEnum.Targeted : ButtonStateEnum.ObservationTargeted;
            }
            else
            {
                newState = handVisible ? ButtonStateEnum.Interactive : ButtonStateEnum.Observation;
            }

            OnStateChange(newState);
        }

        #endregion Helper Functions
    }
}