gui_default_handlers.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/input/gui_input_state.h>
#include <gui_core/input/gui_input_handler_func.h>
#include <gui_core/input/gui_pointer_drag.h>
 
#include <gui_core/state/gui_state_manager.h>
 
#include <gui_core/style/gui_style_ref.h>
#include <gui_core/style/gui_style_text.h>           // TextID, IconID (used by value)
 
#include <gui_core/text/gui_numeric_field_config.h>
 
#include <gui_controls/gui_type_dimensions.h>
#include <gui_controls/gui_widget_state_types.h>
 
#include <algorithm>
#include <cmath>
#include <vector>
#include <memory>
#include <stdint.h>
#include <type_traits>
 
namespace tachyon
{
 
    class ElementStorage;
    class ITextSystem;
    class StyleManager;

    inline bool IsActivationKey(const ElementEvent& event)
    {
        if (event.type != EventType::KeyDown) return false;
        return event.state.lastKey == tachyon::KeyCode::Return ||
               event.state.lastKey == tachyon::KeyCode::Return2 ||
               event.state.lastKey == tachyon::KeyCode::KeyPadEnter ||
               event.state.lastKey == tachyon::KeyCode::Space;
    }
    
    
    bool TextEditorUsesKey(const InputState& state, bool readOnly);

    EventHandler MakeTextBoxHandler(GUIStateManager& guiStateManager);
 

    struct SizerState
    {
        PointerDrag        drag;                              
        ID                 previousFocusID     = ID::Invalid(); 
        ID                 previousTextFocusID = ID::Invalid();
        int                startSize = 0;                     
        DoubleClickTracker clicks;                            
    };

    EventHandler MakeHorizontalSizerHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage,
                                            int& sizeValue, int minSize, int maxSize,
                                            std::function<void(int)> onChanged = nullptr,
                                            std::function<int()> onAutoSize = nullptr,
                                            bool invertMouseDelta = false, float pixelsPerUnit = 1.0f);

    EventHandler MakeVerticalSizerHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage,
                                          int& sizeValue, int minSize, int maxSize,
                                          std::function<void(int)> onChanged = nullptr,
                                          std::function<int()> onAutoSize = nullptr,
                                          bool invertMouseDelta = false, float pixelsPerUnit = 1.0f);

    struct SliderState
    {
        PointerDrag drag;               
        float startValue = 0.0f;        
        bool  editMode   = false;       
    };

    enum class SliderPress : uint8_t { Edit, Jump };

    EventHandler MakeSliderHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage,
                                   float* value, int elementWidth,
                                   std::function<void()> onChanged = nullptr,
                                   float minVal = 0.0f, float maxVal = 1.0f,
                                   SliderPress press = SliderPress::Edit);

    struct DragLabelState
    {
        PointerDrag drag;   
    };

    EventHandler MakeDraggableLabelHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage);

    EventHandler MakeLabelHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage);

    struct LabelGroupVisualState {
        int32_t* sharedWidth;              
        int32_t  minWidth;                 
        int32_t  maxWidth;                 
        bool* edgeHovered;                 
        bool* edgeDragging;                
        std::vector<TextID>* labelTextIDs; 
        ITextSystem* textSystem;           
        const StyleManager* styleManager;  
        StyleRef labelStyleRef;
    };

    EventHandler MakeGroupLabelHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage, LabelGroupVisualState groupVisual);
    EventHandler MakeGroupDraggableLabelHandler(GUIStateManager& guiStateManager, const ElementStorage& elementStorage, LabelGroupVisualState groupVisual);

    EventHandler MakeButtonHandler(GUIStateManager& guiStateManager, std::function<void()> onClick);

    EventHandler MakeMouseWheelScrollHandler(ScrollManagement& scrollManagement, float wheelStep);

    struct ScrollbarDragState
    {
        PointerDrag drag;            
        int thumbGrabOffset = 0;     
        int startScroll     = 0;     
    };

    constexpr int32_t kScrollbarMinThumbLength = 20;

    EventHandler MakeScrollbarHandler(GUIStateManager& guiStateManager,
                                      ElementStorage& elementStorage,
                                      ID containerID, bool vertical,
                                      int32_t trackLength = 0);

    EventHandler MakeDragSourceHandler(GUIStateManager& guiStateManager,
                                       uint32_t payloadType,
                                       std::function<uintptr_t()> getPayloadValue = nullptr,
                                       std::function<std::any()> getPayload = nullptr,
                                       DragVisualizer sourceVisualizer = {});

    EventHandler MakeDropTargetHandler(uint32_t acceptedPayloadType,
                                       std::function<void(uintptr_t payloadValue, ID sourceID)> onDrop,
                                       std::function<bool(uintptr_t payloadValue)> canDrop = nullptr);
    
 
    
    inline double LabelDragSpeedScale(const InputState& state)
    {
        double speed = 1.0;
        if ((state.modifiers & KeyModifier::Control) != KeyModifier::None) speed = 0.1;
        if ((state.modifiers & KeyModifier::Shift)   != KeyModifier::None) speed = 10.0;
        return speed;
    }

    template<typename T>
    inline EventHandler ReportingChanges(GUIStateManager& guiStateManager, T* value, EventHandler inner)
    {
        return [&guiStateManager, value, inner = std::move(inner)](ElementEvent&& event) -> bool
        {
            const T  before = *value;
            const ID id     = event.id;
            const bool used = inner(std::move(event));
            if (!(*value == before))
                guiStateManager.Interaction().SetClicked(id);
            return used;
        };
    }

    template<typename T>
    inline EventHandler MakeNumericalBoxHandler(GUIStateManager& guiStateManager, T& value, NumericFieldConfig<T> config = {})
    {
        struct LabelDragSnapshot { T startValue{}; };
 
        return [&guiStateManager, &value, config](ElementEvent&& event)->bool
        {
            auto& store = guiStateManager.GetElementDataStore();
            switch (event.type)
            {
                case EventType::MouseDown:
                    if (event.state.LeftPressed())
                    {
                        guiStateManager.Interaction().SetFocusID(event.id);
                        guiStateManager.TextEditorFocus().Set(event.id);
                        return true;
                    }
                    break;
 
                case EventType::KeyDown:
                case EventType::KeyUp:
                case EventType::TextInput:
                    if (guiStateManager.Interaction().GetFocusedID() == event.id && !event.state.consumed)
                        return event.type == EventType::TextInput ? !event.state.textInput.empty()
                                                                  : TextEditorUsesKey(event.state, /*readOnly*/ false);
                    break;
 
                case EventType::LabelDragBegin:
                {
                    auto& snapshot = store.GetOrCreate<LabelDragSnapshot>(event.id);
                    snapshot.startValue = value;
                    if constexpr (std::is_floating_point_v<T>)
                        if (!std::isfinite(snapshot.startValue)) { snapshot.startValue = T(0); value = T(0); }
                    return true;
                }
 
                case EventType::LabelDrag:
                {
                    auto* snapshot = store.Get<LabelDragSnapshot>(event.id);
                    if (!snapshot) return false;
                    T newVal = config.Calculate(static_cast<int32_t>(event.state.scroll.x), LabelDragSpeedScale(event.state), snapshot->startValue);
                    value = newVal;
                    return true;
                }
 
                case EventType::LabelDragEnd:
                    return true;
 
                case EventType::LabelDragCancel:
                    if (auto* snapshot = store.Get<LabelDragSnapshot>(event.id))
                        value = snapshot->startValue;
                    return true;
 
                default:
                    break;
            }
 
            return false;
        };
    }
 
 

    template<typename T>
    inline EventHandler MakeMultiDimDragHandler(GUIStateManager& guiStateManager, T& value,
        NumericFieldConfig<typename TypeDimensions<T>::ComponentType> config = {})
    {
        using ComponentT = std::remove_reference_t<decltype(TypeDimensions<T>::GetComponent(value, 0))>;
 
        // Value at drag start; in the element data store since handlers are rebuilt every frame.
        struct Snapshot { T startValue{}; };
 
        return [&guiStateManager, &value, config](ElementEvent&& event) -> bool
        {
            auto& store = guiStateManager.GetElementDataStore();
            switch (event.type)
            {
                case EventType::LabelDragBegin:
                {
                    auto& snapshot = store.GetOrCreate<Snapshot>(event.id);
                    snapshot.startValue = value;
                    if constexpr (std::is_floating_point_v<ComponentT>)
                        for (int i = 0; i < TypeDimensions<T>::dimensions; i++)
                        {
                            ComponentT& comp = TypeDimensions<T>::GetComponent(value, i);
                            ComponentT& startComp = TypeDimensions<T>::GetComponent(snapshot.startValue, i);
                            if (!std::isfinite(startComp)) { startComp = ComponentT(0); comp = ComponentT(0); }
                        }
                    return true;
                }
 
                case EventType::LabelDrag:
                {
                    auto* snapshot = store.Get<Snapshot>(event.id);
                    if (!snapshot) return false;
                    double speed = LabelDragSpeedScale(event.state);
                    for (int i = 0; i < TypeDimensions<T>::dimensions; i++)
                    {
                        ComponentT& comp = TypeDimensions<T>::GetComponent(value, i);
                        ComponentT startComp = TypeDimensions<T>::GetComponent(snapshot->startValue, i);
                        comp = config.Calculate(static_cast<int32_t>(event.state.scroll.x), speed, startComp);
                    }
                    return true;
                }
 
                case EventType::LabelDragEnd:
                    return true;
 
                case EventType::LabelDragCancel:
                    if (auto* snapshot = store.Get<Snapshot>(event.id))
                        value = snapshot->startValue;
                    return true;
 
                default:
                    break;
            }
            return false;
        };
    }

}