HandledUIDropdown.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace Testing
{
    /// <summary>
    /// Wraps Dropdown but adds the ability to intercept UI Events, ex: OnSubmit, OnPointerDown, etc.
    /// 
    /// Simply add a handler for a given OnEvent UI call that returns true to 
    /// consider the event 'handled' and not forward it to the base Dropdown class.
    /// 
    /// Any event without a handler, or where the handler returns false will
    /// pass the event on to the base class as normal.
    /// </summary>
    public class HandledUIDropdown : Dropdown
    {
        // Handlers - If set, these control if a given OnUIEVENT(...) call is forwarded to the base class's OnUIEVENT(...)

        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<BaseEventData, bool> handleSubmit;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<BaseEventData, bool> handleCancel;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<BaseEventData, bool> handleSelect;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<BaseEventData, bool> handleDeselect;

        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<PointerEventData, bool> handlePointerUp;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<PointerEventData, bool> handlePointerDown;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<PointerEventData, bool> handlePointerClick;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<PointerEventData, bool> handlePointerEnter;
        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<PointerEventData, bool> handlePointerExit;

        /// <summary>Return true if the event has been 'handled' so won't be passed on to internal dropdown logic.</summary>
        public System.Func<AxisEventData, bool> handleMove;


        // Decide if an event should be forwarded to a callback, based on if the handler handled it
        protected void ForwardEvent<T>(T eventData, System.Func<T, bool> handler, System.Action<T> callback)
        {
            // Call the callback if no handler is provided, or if the handler has not already handled the event
            if (handler == null || handler(eventData) == false)
                callback(eventData);
        }


        // Base Events

        public override void OnSelect(BaseEventData data)
        {
            ForwardEvent(data, handleSelect, base.OnSelect);
        }
        public override void OnDeselect(BaseEventData data)
        {
            ForwardEvent(data, handleDeselect, base.OnDeselect);
        }

        public override void OnSubmit(BaseEventData data)
        {
            ForwardEvent(data, handleSubmit, base.OnSubmit);
        }
        public override void OnCancel(BaseEventData data)
        {
            ForwardEvent(data, handleCancel, base.OnCancel);
        }


        // Pointer Events

        public override void OnPointerDown(PointerEventData data)
        {
            ForwardEvent(data, handlePointerDown, base.OnPointerDown);
        }
        public override void OnPointerUp(PointerEventData data)
        {
            ForwardEvent(data, handlePointerUp, base.OnPointerUp);
        }
        public override void OnPointerClick(PointerEventData data)
        {
            ForwardEvent(data, handlePointerClick, base.OnPointerClick);
        }
        public override void OnPointerEnter(PointerEventData data)
        {
            ForwardEvent(data, handlePointerEnter, base.OnPointerEnter);
        }
        public override void OnPointerExit(PointerEventData data)
        {
            ForwardEvent(data, handlePointerExit, base.OnPointerExit);
        }


        // Axis Events

        public override void OnMove(AxisEventData data)
        {
            ForwardEvent(data, handleMove, base.OnMove);
        }
    }
}