gui_element.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/style/gui_style.h>
#include <gui_core/style/gui_style_ref.h>
 
#include <gui_core/layout/gui_constraints.h>
 
#include <gui_core/elements/gui_element_flags.h>
 
#include <gui_core/input/gui_input_handler_func.h>
 
#include <gui_core/gui_id.h>
#include <gui_core/gui_base_types.h>
#include <gui_core/gui_enum_operators.h>
 
#include <functional>
#include <vector>
 
namespace tachyon
{
 
    class GUIRenderer;
    class ElementStorage;
    class CustomDrawContext;
 
    // ------------------------------------------------------------------------
    // Element - Core element data
    // ------------------------------------------------------------------------
 
    struct Element
    {
        ID id = ID::Invalid();

        EventHandler eventHandler;
 
        TextID textID = TextID::Invalid;
        IconID iconID = IconID::Invalid;
 
        StyleRef styleRef {};
        int16_t monitorIndex = -1; 
        ElementFlags flags = ElementFlags::None;
        ElementState state = ElementState::None;
 
        ImageIndex backgroundImage = ImageIndex::Invalid;
        VisualColorStyleIndex colorStyleIndex {};
    };
 
    // ------------------------------------------------------------------------
    // ElementRect
    // ------------------------------------------------------------------------
 
    struct ElementRect
    {
        IntRect rect {};          
        IntRect innerRect {};     
        IntRect clipRect {};      
        IntRect contentBounds {}; 
        int2 scrollOffset{};
 
        LayoutOverride  constraints;
 
        const LayoutStyle* layoutStyle{nullptr};

        float3x2 contentTransform;
 
        int16_t monitorIndex = -1; 
        ElementFlags flags = ElementFlags::None;
        Display display{};
        uint16_t wrapLineIndex = 0; 
        int16_t  minContentWidth = 0;
        int32_t  anchorTargetX = 0;
    };

    using CustomDrawCallback = std::function<void(CustomDrawContext& ctx)>;
 
    class PostLayoutContext;

    using PostLayoutCallback = std::function<void(PostLayoutContext& ctx)>;
 
    // ------------------------------------------------------------------------
    // HierarchyInfo
    // ------------------------------------------------------------------------
 
    struct HierarchyInfo
    {
        inline static constexpr HierarchyInfo Initialize(uint32_t parentIndex)
        {
            return HierarchyInfo
            {
                .parentIndex      = parentIndex,
                .nextSiblingIndex = HierarchyInfo::kInvalidNextIndex,
                .childOffset      = 0,
                .childCount       = 0
            };
        }
 
        static constexpr uint32_t kInvalidNextIndex = std::numeric_limits<uint32_t>::max();
 
        uint32_t parentIndex = 0;                      
        uint32_t nextSiblingIndex = kInvalidNextIndex; 
        uint32_t childOffset = 0;                      
        uint32_t childCount = 0;
    };
 
    // ------------------------------------------------------------------------
    // ElementRef - Identifies an element by (depth, index)
    // ------------------------------------------------------------------------

    struct ElementRef
    {
        uint32_t depth = 0;
        
        uint32_t index = 0; 
 
        inline constexpr bool IsRoot() const { return depth == 0; }
        inline constexpr bool IsValid() const { return depth != std::numeric_limits<uint32_t>::max() && index != std::numeric_limits<uint32_t>::max(); }
        static constexpr ElementRef Invalid() { return ElementRef{ std::numeric_limits<uint32_t>::max() , std::numeric_limits<uint32_t>::max() }; }
        inline bool operator==(const ElementRef& rhs) const { return depth == rhs.depth && index == rhs.index; }
        inline bool operator!=(const ElementRef& rhs) const { return !(*this == rhs); }

        inline uint64_t HashCode() const noexcept
        {
            return (static_cast<uint64_t>(depth) << 32) | static_cast<uint64_t>(index);
        }
    };

    struct IndexRange
    {
        uint32_t begin = 0;
        uint32_t end   = 0; 
        
        inline bool Empty() const { return end == begin; }
        inline uint32_t Size() const { return end - begin; }
 
        bool operator==(const IndexRange& rhs) const = default;
        bool operator!=(const IndexRange& rhs) const = default;
    };

    struct ElementMove
    {
        struct Rotation { uint32_t depth, begin, mid, end; }; // std::rotate(begin, mid, end)
        std::vector<Rotation> rotations;
        uint32_t childDepth = 0;          
        uint32_t siblingsBegin = 0;       
        uint32_t siblingsEnd = 0;

        ElementRef Remap(ElementRef ref) const
        {
            for (const Rotation& r : rotations)
            {
                if (ref.depth != r.depth || ref.index < r.begin || ref.index >= r.end) continue;
                ref.index = (ref.index < r.mid) ? ref.index + (r.end - r.mid) : ref.index - (r.mid - r.begin);
            }
            return ref;
        }
    };

    struct PostDrawEntry
    {
        CustomDrawCallback callback;
        ElementRef         ownerRef;                   
        uint32_t           nextIndex = UINT32_MAX;     
    };

    struct ElementCustomDraw
    {
        CustomDrawCallback callback;                       
        uint32_t           afterHead = UINT32_MAX;         
        uint32_t           afterTail = UINT32_MAX;         
 
        IntRect            afterDrawClipRectScreen     = {};  
        IntRect            afterDrawElementRectLayout  = {};  
        IntRect            afterDrawInnerRectLayout    = {};  
        float3x2           afterDrawRenderTransform    = {};  
        float4             afterDrawPixelRect          = {};  
        IntRect            afterDrawSnappedRect        = {};  
        float              afterDrawOpacity            = 1.0f; 
    };

} // namespace tachyon