gui_style.h

Go to the documentation of this file.

// GUI Style System: defines the visual and layout properties of elements.
//
// Styles follow a CSS-like box model with margin, padding, and border.
// Each element can have layout styles (sizing, positioning, flex/grid properties)
// and visual styles (colors, gradients, borders, text styling) that vary by
// element state (hover, active, focused, selected, disabled).
//
// Styles are defined in .css theme files and managed by StyleManager/StyleSheet.
 
#pragma once
 
#include <gui_core/gui_base_types.h>
#include <gui_core/gui_hash.h>
#include <gui_core/gui_enum_operators.h>
#include <gui_core/style/gui_style_text.h>
#include <gui_core/style/gui_style_gradient.h>
#include <gui_core/graphics/gui_image.h>
 
#include <algorithm>
 
namespace tachyon
{
 
    class GradientManager;
    struct GradientHandle;
 
    // ------------------------------------------------------------------------
    // Style Indices
    // ------------------------------------------------------------------------
    enum class VisualColorStyleIndex : uint16_t { Invalid = 0 };
 
 
    // ------------------------------------------------------------------------
    // Element State
    // ------------------------------------------------------------------------

    enum class ElementState : uint8_t
    {
        None      = 0,
        Active    = 1 << 0,  
        Hover     = 1 << 1,  
        Focused   = 1 << 2,  
        Selected  = 1 << 3,  
        Selection = 1 << 4,  
        Disabled  = 1 << 5,  
        Invalid   = 1 << 6,
 
        VisualMask = Active | Hover | Focused | Selected | Selection | Disabled
    };
    TACHYON_ENUM_OPERATORS(ElementState)
 
    // ------------------------------------------------------------------------
    // Box Model Types
    // ------------------------------------------------------------------------
 
    
    struct BoxEdges
    {
        uint16_t top = 0;
        uint16_t right = 0;
        uint16_t bottom = 0;
        uint16_t left = 0;
 
        constexpr BoxEdges() = default;
        constexpr BoxEdges(uint16_t all) : top(all), right(all), bottom(all), left(all) {}
        constexpr BoxEdges(uint16_t vertical, uint16_t horizontal) 
            : top(vertical), right(horizontal), bottom(vertical), left(horizontal) {}

        constexpr BoxEdges(uint16_t t, uint16_t r, uint16_t b, uint16_t l) 
            : top(t), right(r), bottom(b), left(l) {}
 
        constexpr uint16_t Horizontal() const { return left + right; } 
        constexpr uint16_t Vertical() const { return top + bottom; }   
        constexpr bool IsZero() const { return top == 0 && right == 0 && bottom == 0 && left == 0; }
 
        bool operator==(const BoxEdges&) const noexcept = default;
    };

    struct BoxCorners
    {
        uint16_t topLeft = 0;
        uint16_t topRight = 0;
        uint16_t bottomRight = 0;
        uint16_t bottomLeft = 0;
 
        constexpr BoxCorners() = default;
        constexpr BoxCorners(uint16_t all)
            : topLeft(all), topRight(all), bottomRight(all), bottomLeft(all) {}

        constexpr BoxCorners(uint16_t tl, uint16_t tr, uint16_t br, uint16_t bl)
            : topLeft(tl), topRight(tr), bottomRight(br), bottomLeft(bl) {}

        constexpr bool IsZero() const 
        { 
            return topLeft == 0 && topRight == 0 && bottomRight == 0 && bottomLeft == 0; 
        }
 
        bool operator==(const BoxCorners&) const noexcept = default;
    };

    inline constexpr int kMaxBoxShadows = 2;
    inline constexpr int kMaxTextShadows = kMaxBoxShadows;

    struct BoxShadow
    {
        int16_t  x      = 0;     
        int16_t  y      = 0;     
        uint16_t blur   = 0;     
        int16_t  spread = 0;     
        color4b  color  {};      
        bool     inset  = false; 

        constexpr bool IsNone() const { return color.a == 0; }
        bool operator==(const BoxShadow&) const noexcept = default;
    };

    struct EdgeInset
    {
        static constexpr int16_t kAuto = std::numeric_limits<int16_t>::min();
 
        int16_t top    = kAuto;
        int16_t right  = kAuto;
        int16_t bottom = kAuto;
        int16_t left   = kAuto;
 
        constexpr EdgeInset() = default;
        constexpr EdgeInset(int16_t all) : top(all), right(all), bottom(all), left(all) {}
        constexpr EdgeInset(int16_t vertical, int16_t horizontal)
            : top(vertical), right(horizontal), bottom(vertical), left(horizontal) {}

        constexpr EdgeInset(int16_t t, int16_t r, int16_t b, int16_t l)
            : top(t), right(r), bottom(b), left(l) {}
 
        bool operator==(const EdgeInset&) const noexcept = default;
    };
 
    // ------------------------------------------------------------------------
    // Layout Properties
    // ------------------------------------------------------------------------

    enum class FlexDirection : uint8_t
    {
        Row,            
        RowReverse,     
        Column,         
        ColumnReverse   
    };

    enum class FlexWrap : uint8_t
    {
        NoWrap,         
        Wrap,           
        WrapReverse     
    };

    enum class AlignItems : uint8_t
    {
        Auto,           
        FlexStart,      
        FlexEnd,        
        Center,         
        Stretch         
    };

    enum class JustifyContent : uint8_t
    {
        FlexStart,      
        FlexEnd,        
        Center,         
        SpaceBetween,   
        SpaceAround,    
        SpaceEvenly     
    };

    enum class AlignContent : uint8_t
    {
        FlexStart,      
        FlexEnd,        
        Center,         
        Stretch,        
        SpaceBetween,   
        SpaceAround,    
        SpaceEvenly     
    };

    enum class PositionType : uint8_t
    {
        Relative,   
        Anchored,   
        Absolute,   
        Fixed,      
        Centered,   
        Sticky      
    };

    enum class Display : uint8_t
    {
        Flex,       
        Grid,       
        None        
    };

    enum class Overflow : uint8_t
    {
        Auto,       
        Hidden,     
        Visible     
    };

    enum class Visibility : uint8_t
    {
        Visible,    
        Collapsed   
    };

    enum class IconSide : uint8_t
    {
        None = 0,
 
        Left,
        Right,
        Top,
        Bottom
    };

    enum class AnchorPlacement : uint8_t
    {
        None = 0,
 
        // Horizontal
        OutsideLeft    = (1 << 0),
        CenterLeft     = (2 << 0),
        InsideLeft     = (3 << 0),
        CenterHorz     = (4 << 0),
        InsideRight    = (5 << 0),
        CenterRight    = (6 << 0),
        OutsideRight   = (7 << 0),
 
        HorizontalMask = (0xF << 0),
 
        // Vertical
        OutsideTop     = (1 << 4),
        CenterTop      = (2 << 4),
        InsideTop      = (3 << 4),
        CenterVert     = (4 << 4),
        InsideBottom   = (5 << 4),
        CenterBottom   = (6 << 4),
        OutsideBottom  = (7 << 4),
                       
        VerticalMask   = (0xF << 4),
 
        // Common combinations
        CenterCenter      = CenterHorz | CenterVert,
        
        InsideTopLeft      = InsideTop    | InsideLeft,
        InsideTopRight     = InsideTop    | InsideRight,
        InsideBottomLeft   = InsideBottom | InsideLeft,
        InsideBottomRight  = InsideBottom | InsideRight,
 
        OutsideTopLeft     = OutsideTop    | OutsideLeft,
        OutsideTopRight    = OutsideTop    | OutsideRight,
        OutsideBottomLeft  = OutsideBottom | OutsideLeft,
        OutsideBottomRight = OutsideBottom | OutsideRight,
    };
    TACHYON_ENUM_OPERATORS(AnchorPlacement);

    enum class AnchorPlacementAxis : uint8_t
    {
        None       = 0,
        OutsideMin = 1, 
        CenterMin  = 2, 
        InsideMin  = 3, 
        Center     = 4, 
        InsideMax  = 5, 
        CenterMax  = 6, 
        OutsideMax = 7, 
    };

    constexpr AnchorPlacementAxis FlipAxis(AnchorPlacementAxis p)
    {
        switch (p)
        {
            case AnchorPlacementAxis::OutsideMin: return AnchorPlacementAxis::OutsideMax;
            case AnchorPlacementAxis::OutsideMax: return AnchorPlacementAxis::OutsideMin;
            case AnchorPlacementAxis::InsideMin:  return AnchorPlacementAxis::InsideMax;
            case AnchorPlacementAxis::InsideMax:  return AnchorPlacementAxis::InsideMin;
            case AnchorPlacementAxis::CenterMin:  return AnchorPlacementAxis::CenterMax;
            case AnchorPlacementAxis::CenterMax:  return AnchorPlacementAxis::CenterMin;
            default: return p;
        }
    }

    constexpr AnchorPlacementAxis GetHorizontalAxis(AnchorPlacement p) { return (AnchorPlacementAxis)((uint8_t)p & 0x0F); }
    constexpr AnchorPlacementAxis GetVerticalAxis(AnchorPlacement p)   { return (AnchorPlacementAxis)(((uint8_t)p >> 4) & 0x0F); }

    constexpr AnchorPlacement MakeAnchorPlacement(AnchorPlacementAxis h, AnchorPlacementAxis v)
    {
        return (AnchorPlacement)((uint8_t)h | ((uint8_t)v << 4));
    }
 
 
    // ------------------------------------------------------------------------
    // Flex Container Properties
    // ------------------------------------------------------------------------

    struct FlexProperties
    {
        static constexpr int16_t kAuto = -1; 
 
        uint16_t flexGrow = 0;   
        uint16_t flexShrink = 0; 
        int16_t  flexBasis = kAuto; 
 
        uint16_t gap = 0;  
 
        FlexDirection  direction      : 2 = FlexDirection::Row;          
        FlexWrap       wrap           : 2 = FlexWrap::NoWrap;            
        AlignItems     alignItems     : 3 = AlignItems::FlexStart;       
        JustifyContent justifyContent : 3 = JustifyContent::FlexStart;  
        AlignContent   alignContent   : 3 = AlignContent::FlexStart;     
 
        bool operator==(const FlexProperties&) const noexcept = default;
    };
 
    // ------------------------------------------------------------------------
    // Grid Track Definition
    // ------------------------------------------------------------------------

    struct GridTrack
    {
        enum class Type : uint8_t
        {
            Fixed,      
            Fractional, 
            Auto,       
            Default,    
        };
 
        Type  type = Type::Auto;
        float value = 1.0f;  
        float minPx = 0.0f;

        static constexpr GridTrack Auto()                  { return { .type = Type::Auto,       .value = 1.0f  }; }
        static constexpr GridTrack Fixed(float value)      { return { .type = Type::Fixed,      .value = value }; }
        static constexpr GridTrack Fractional(float value, float minPx = 0.0f)
                                                           { return { .type = Type::Fractional, .value = value, .minPx = minPx }; }

        static constexpr GridTrack Default()               { return { .type = Type::Default,    .value = 0.0f  }; }
 
        bool operator==(const GridTrack& other) const noexcept = default;
    };
 
    // ------------------------------------------------------------------------
    // Grid Container Properties
    // ------------------------------------------------------------------------
    
    struct GridAxisProperties
    {
        static constexpr int16_t kAuto = -1; 

        GridTrack track = GridTrack::Default();
 
        int16_t start{ kAuto }; 
        int16_t span{ 1 }; 
        int16_t gap{ 0 };  
 
        bool operator==(const GridAxisProperties&) const noexcept = default;
    };

    struct GridProperties
    {
        GridAxisProperties column{}; 
        GridAxisProperties row{};    
 
        JustifyContent justifyContent = JustifyContent::FlexStart;    
        AlignItems     alignItems     = AlignItems::Stretch;          
        JustifyContent justifyItems   = JustifyContent::FlexStart;    
        AlignItems     alignItemsSelf = AlignItems::Stretch;
 
        bool operator==(const GridProperties&) const noexcept = default;
    };
 
    // ------------------------------------------------------------------------
    // Container for layout type specific properties
    // ------------------------------------------------------------------------

    struct LayoutData
    {
        FlexProperties flex {}; 
        GridProperties grid {}; 
 
        static constexpr int32_t kAutoSize     = -1; 
        static constexpr int32_t kUnboundedMax = std::numeric_limits<int32_t>::max(); 
 
        int32_t width     = kAutoSize;     
        int32_t height    = kAutoSize;     
        int32_t minWidth  = 0;             
        int32_t maxWidth  = kUnboundedMax; 
        int32_t minHeight = 0;             
        int32_t maxHeight = kUnboundedMax; 
 
        bool operator==(const LayoutData&) const noexcept = default;
    };
 
    // ------------------------------------------------------------------------
    // Break Behavior (CSS break-after: auto | always | avoid | left | right)
    // ------------------------------------------------------------------------

    enum class BreakBehavior : uint8_t
    {
        Auto,        
        Always,      
        Before,      
        Avoid,       
    };
 
    // ------------------------------------------------------------------------
    // Mouse Cursor Types
    // ------------------------------------------------------------------------

    enum class MouseCursor : uint8_t
    {
        Default,        
        Text,           
        Wait,           
        Crosshair,      
        Pointer,        
        ColResize,      
        RowResize,      
        EwResize,       
        NsResize,       
        NwseResize,     
        NeswResize,     
        Move,           
        NotAllowed,     
 
        None,           
    };
 
    // ------------------------------------------------------------------------
    // Color Styles
    // ------------------------------------------------------------------------

    enum class ColorType : uint16_t
    {
        SolidColor               = 0, 
        StretchedTexture         = 1, 
        RepeatedTexture          = 2, 
        LinearGradient           = 3, 
        CircularAngularGradient  = 4, 
        EllipsoidAngularGradient = 5, 
        RadialGradient           = 6, 
        InterpolatedTriangle     = 7, 
        InterpolatedBox          = 8, 
        SDFGradient              = 9
    };
 
    class VisualColorStyle;
    class ColorStyle
    {
    public:
        static constexpr int16_t one = 15360; 
 
        Gradient  gradient{};                         
        short4    transformationX = { one, 0, 0, 0 }; 
        short4    transformationY = { 0, one, 0, 0 }; 
        ColorType type            = (ColorType)0; 
        short2    animSpeed       = { 0, 0 }; 

        void SetTransformation(float3 x, float3 y);
        void SetAnimSpeed(float x, float y = 0.0f);
        float3x2 GetTransformation() const;
        color4b GetFirstColor() const noexcept
        {
            return gradient.stopCount != 0 ? gradient.stops[0].GetColor4b() : color4b{ 0, 0, 0, 0 };
        }

        VisualColorStyle ToVisualStyle(GradientManager& gradientManager,
                                       ImageIndex textureIndex,
                                       GradientHandle& outHandle) const;
 

        static ColorStyle Create(color4b color);
        static ColorStyle Create(color4f color);
        static ColorStyle Create(color4b c0, color4b c1, ColorType type);
        static ColorStyle Create(color4f c0, color4f c1, ColorType type);
        static ColorStyle Create(color4b c0, color4b c1, color4b c2, ColorType type);
        static ColorStyle Create(color4f c0, color4f c1, color4f c2, ColorType type);
        static ColorStyle Create(color4b c0, color4b c1, color4b c2, color4b c3, ColorType type);
        static ColorStyle Create(color4f c0, color4f c1, color4f c2, color4f c3, ColorType type);
        static ColorStyle Create(Gradient gradient, ColorType type);
    };

    class alignas(16) VisualColorStyle
    {
    public:
        static constexpr int16_t one = 15360; 
 
        short4     transformationX = { one, 0, 0, 0 }; 
        short4     transformationY = { 0, one, 0, 0 }; 
 
        ushort2    colorUV         = {}; 
        ColorType  type            = (ColorType)0;

        uint16_t   gradientPage    = 0;
 
        ImageIndex textureIndex    = ImageIndex::Invalid; 
 
        short2     animSpeed      = { 0, 0 }; 

        void SetTransformation(float3 x, float3 y);
        void SetAnimSpeed(float x, float y = 0.0f);
 
        uint64_t GetHashCode() const noexcept
        {
            return Hash::Combine(Hash::Calculate(transformationX),
                                 Hash::Calculate(transformationY),
                                 Hash::Calculate(textureIndex),
                                 Hash::Calculate(colorUV),
                                 Hash::Calculate(gradientPage),
                                 Hash::Calculate(type),
                                 Hash::Calculate(animSpeed));
        }
 
        bool operator==(const VisualColorStyle& other) const noexcept
        {
            return transformationX == other.transformationX &&
                   transformationY == other.transformationY &&
                   textureIndex == other.textureIndex &&
                   colorUV == other.colorUV &&
                   gradientPage == other.gradientPage &&
                   type == other.type &&
                   animSpeed == other.animSpeed;
        }

        static VisualColorStyle Create(GradientManager& gradientManager, color4b color, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4f color, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4b color1, color4b color2, ColorType type, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4f color1, color4f color2, ColorType type, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4b color1, color4b color2, color4b color3, ColorType type, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4f color1, color4f color2, color4f color3, ColorType type, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4b color1, color4b color2, color4b color3, color4b color4, ColorType type, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, color4f color1, color4f color2, color4f color3, color4f color4, ColorType type, GradientHandle& outHandle);
        static VisualColorStyle Create(GradientManager& gradientManager, Gradient gradient, ColorType type, GradientHandle& outHandle);
    };
 
 
    // ------------------------------------------------------------------------
    // Complete Style Definition
    // ------------------------------------------------------------------------

    enum class StateLayer : uint8_t
    {
        None,    
        Content, 
    };

    struct StyleState
    {
        TextStyle textStyle {}; 
 
        ColorStyle backgroundColor {};  
        ColorStyle borderColors[4] {};  
        ColorStyle textColor {};        
        ColorStyle iconColor {};        
        ColorStyle decorationColors[4] {};
        BoxShadow  boxShadow[kMaxBoxShadows] {}; 
        BoxShadow  textShadow[kMaxTextShadows] {};
        float      opacity = -1.0f;

        void SetBorderColor(const ColorStyle& c) { borderColors[0] = borderColors[1] = borderColors[2] = borderColors[3] = c; }
        void SetBorderColor(const ColorStyle& t, const ColorStyle& r, const ColorStyle& b, const ColorStyle& l)
        { 
            borderColors[0] = t; borderColors[1] = r; borderColors[2] = b; borderColors[3] = l;
        }
    };

    struct Style
    {
        static constexpr int16_t kAuto = -1;

        static constexpr int kStateCount = int(ElementState::Disabled) + 1;

        struct States
        {
            StyleState slots[kStateCount] {};
 
            StyleState&       operator[](ElementState state)       { return slots[size_t(state)]; }
            const StyleState& operator[](ElementState state) const { return slots[size_t(state)]; }
            StyleState&       operator[](int slot)                 { return slots[slot]; }
            const StyleState& operator[](int slot) const           { return slots[slot]; }
 
            StyleState*       begin()       { return slots; }
            StyleState*       end()         { return slots + kStateCount; }
            const StyleState* begin() const { return slots; }
            const StyleState* end() const   { return slots + kStateCount; }
        };
 
        States          states {};              
        TextLayoutStyle textLayoutStyle {};     
 
        BoxEdges        margin{};       
        BoxEdges        padding{};      
        BoxEdges        borderWidths{}; 
        BoxCorners      borderRadius{}; 
        float           borderDashSize   = 0.0f; 
        float           borderDashOffset = 0.0f; 
        BoxShadow       focusRing {};            
        StateLayer      stateLayer = StateLayer::None;
 
        LayoutData      layoutData {}; 
 
        uint16_t        iconTextGap = 0; 
        uint16_t        iconSize    = 0; 
        int16_t         iconOffsetY = 0; 
 
        ImageIndex      textureIndex = ImageIndex::Invalid; 
        Display         display      : 3 = Display::Flex;       
        Visibility      visibility   : 2 = Visibility::Visible; 
        Overflow        overflowX    : 2 = Overflow::Auto;      
        Overflow        overflowY    : 2 = Overflow::Auto;      
        IconSide        iconSide     : 3 = IconSide::Left;      
        AlignItems      alignSelf      : 3 = AlignItems::Auto; 
        BreakBehavior   breakBehavior  : 2 = BreakBehavior::Auto; 
        bool            clampScroll    : 1 = true;  

        constexpr void SetOverflow(Overflow o) noexcept { overflowX = o; overflowY = o; }
 
        MouseCursor     cursor = MouseCursor::Default; 
    };
 
 
    // ------------------------------------------------------------------------
    // Optimized Runtime Styles
    // ------------------------------------------------------------------------

    struct LayoutStyle
    {
        static constexpr int16_t kAuto = -1;
 
        BoxEdges        margin{};       
        BoxEdges        padding{};      
        BoxEdges        borderWidths{}; 
 
        LayoutData      layoutData{};   
        TextLayoutStyle textLayoutStyle{}; 
 
        uint16_t        iconTextGap = 0; 
        uint16_t        iconSize    = 0; 
        int16_t         iconOffsetY = 0; 
 
        // Display
        Display         display      : 3 = Display::Flex;          
        Visibility      visibility   : 2 = Visibility::Visible;    
        Overflow        overflowX    : 2 = Overflow::Visible;      
        Overflow        overflowY    : 2 = Overflow::Visible;      
        IconSide        iconSide     : 3 = IconSide::Left;         
        AlignItems      alignSelf      : 3 = AlignItems::Auto; 
        BreakBehavior   breakBehavior  : 2 = BreakBehavior::Auto;  
        bool            clampScroll    : 1 = true;  
 
        MouseCursor     cursor = MouseCursor::Default; 

        uint64_t GetHashCode() const noexcept
        {
            const auto& ld = layoutData;
            return Hash::Combine(margin, padding, borderWidths,
                                 ld.width, ld.height, ld.minWidth, ld.maxWidth, ld.minHeight, ld.maxHeight,
                                 iconTextGap, iconSize, iconOffsetY,
                                 uint8_t(display), uint8_t(visibility), uint8_t(overflowX), uint8_t(overflowY),
                                 uint8_t(alignSelf), cursor, textLayoutStyle.GetHashCode());
        }
 
        bool operator==(const LayoutStyle &other) const noexcept = default;

        constexpr bool IsInFlow() const
        {
            return display != Display::None && 
                   visibility != Visibility::Collapsed;
        }

        constexpr bool IsFlexContainer() const
        {
            return display == Display::Flex;
        }

        constexpr int16_t GetMinWidth() const
        {
            return margin.Horizontal() + borderWidths.Horizontal() + padding.Horizontal();
        }

        constexpr int16_t GetMinHeight() const
        {
            return margin.Vertical() + borderWidths.Vertical() + padding.Vertical();
        }

        constexpr short2 GetMinSize() const 
        { 
            return { GetMinWidth(), GetMinHeight() }; 
        }

        IntRect GetPaddingBoxContentRect(const IntRect& borderBox) const
        {
            int16_t left   = borderWidths.left   + padding.left;
            int16_t right  = borderWidths.right  + padding.right;
            int16_t top    = borderWidths.top    + padding.top;
            int16_t bottom = borderWidths.bottom + padding.bottom;
 
            int16_t w = std::max<int16_t>(0, static_cast<uint16_t>(borderBox.w - static_cast<uint32_t>(left + right)));
            int16_t h = std::max<int16_t>(0, static_cast<uint16_t>(borderBox.h - static_cast<uint32_t>(top + bottom)));
 
            return IntRect
            {
                int16_t(borderBox.x + left),
                int16_t(borderBox.y + top),
                w, h
            };
        }

        IntRect GetContentRect(const IntRect& outer) const
        {
            int16_t left   = margin.left   + borderWidths.left   + padding.left;
            int16_t right  = margin.right  + borderWidths.right  + padding.right;
            int16_t top    = margin.top    + borderWidths.top    + padding.top;
            int16_t bottom = margin.bottom + borderWidths.bottom + padding.bottom;
 
            int16_t w = std::max<int16_t>(0, static_cast<int16_t>(outer.w - static_cast<int32_t>(left + right)));
            int16_t h = std::max<int16_t>(0, static_cast<int16_t>(outer.h - static_cast<int32_t>(top + bottom)));
 
            return IntRect
            { 
                int16_t(outer.x + left), 
                int16_t(outer.y + top), 
                w, h 
            };
        }

        IntRect GetBorderRect(const IntRect& outer) const
        {
            int16_t w = std::max<int16_t>(0, static_cast<int16_t>(outer.w - margin.Horizontal()));
            int16_t h = std::max<int16_t>(0, static_cast<int16_t>(outer.h - margin.Vertical()));
 
            return IntRect
            { 
                int16_t(outer.x + margin.left), 
                int16_t(outer.y + margin.top), 
                w, h 
            };
        }

        IntRect GetPaddingRect(const IntRect& outer) const
        {
            int16_t l = margin.left   + borderWidths.left;
            int16_t r = margin.right  + borderWidths.right;
            int16_t t = margin.top    + borderWidths.top;
            int16_t b = margin.bottom + borderWidths.bottom;
 
            int16_t w = std::max<int16_t>(0, static_cast<int16_t>(outer.w - static_cast<int32_t>(l + r)));
            int16_t h = std::max<int16_t>(0, static_cast<int16_t>(outer.h - static_cast<int32_t>(t + b)));
 
            return IntRect
            { 
                int16_t(outer.x + l), 
                int16_t(outer.y + t), 
                w, h 
            };
        }

        inline int32_t GetBorderBoxWidth() const noexcept
        {
            return (int32_t)(padding.Horizontal() + borderWidths.Horizontal());
        }
    };

    struct VisualShadow
    {
        int16_t               x      = 0; 
        int16_t               y      = 0;
        uint16_t              blur   = 0;
        int16_t               spread = 0;
        VisualColorStyleIndex color  = VisualColorStyleIndex::Invalid;

        constexpr bool IsNone() const { return color == VisualColorStyleIndex::Invalid; }
        bool operator==(const VisualShadow&) const noexcept = default;
    };

    struct VisualShadowStyle
    {
        VisualShadow layers[kMaxBoxShadows] {}; 
        VisualShadow ring {};                   
        uint32_t     insetRing = 0; 
        float        opacity   = -1.0f; 
 
        bool operator==(const VisualShadowStyle&) const noexcept = default;
    };

    struct alignas(16) VisualBoxStyle
    {
        BoxEdges   borderWidths{};                                          
        BoxCorners borderRadius{};                                          

        VisualColorStyleIndex borderColorIndex[4] = {
            VisualColorStyleIndex::Invalid, VisualColorStyleIndex::Invalid,
            VisualColorStyleIndex::Invalid, VisualColorStyleIndex::Invalid
        };                                                                  // 8 bytes
        VisualColorStyleIndex backgroundColorIndex = VisualColorStyleIndex::Invalid; 
        uint16_t borderDashSize   = 0;                                     
        uint16_t borderDashOffset = 0;                                     
        uint16_t shadowIndex      = 0;
        // Total: 32 bytes

        uint64_t GetHashCode() const noexcept
        {
            return Hash::Combine(Hash::Calculate(borderWidths),
                                 Hash::Calculate(borderRadius),
                                 Hash::Calculate(borderColorIndex[0]),
                                 Hash::Calculate(borderColorIndex[1]),
                                 Hash::Calculate(borderColorIndex[2]),
                                 Hash::Calculate(borderColorIndex[3]),
                                 Hash::Calculate(backgroundColorIndex),
                                 Hash::Calculate(borderDashSize),
                                 Hash::Calculate(borderDashOffset),
                                 Hash::Calculate(shadowIndex));
        }
 
        bool operator==(const VisualBoxStyle& other) const noexcept
        {
            return borderWidths == other.borderWidths &&
                   borderRadius == other.borderRadius &&
                   borderColorIndex[0] == other.borderColorIndex[0] &&
                   borderColorIndex[1] == other.borderColorIndex[1] &&
                   borderColorIndex[2] == other.borderColorIndex[2] &&
                   borderColorIndex[3] == other.borderColorIndex[3] &&
                   backgroundColorIndex == other.backgroundColorIndex &&
                   borderDashSize   == other.borderDashSize &&
                   borderDashOffset == other.borderDashOffset &&
                   shadowIndex      == other.shadowIndex;
        }
    };

    struct VisualTextStyle
    {
        TextStyle             textStyle {};       
        VisualColorStyleIndex textColorIndex = VisualColorStyleIndex::Invalid; 
        VisualColorStyleIndex iconColorIndex = VisualColorStyleIndex::Invalid; 
        VisualColorStyleIndex decorationColorIndex[4] { VisualColorStyleIndex::Invalid, VisualColorStyleIndex::Invalid,
                                                        VisualColorStyleIndex::Invalid, VisualColorStyleIndex::Invalid };
        uint16_t              iconTextGap = 0; 
        uint16_t              iconSize    = 0; 
        int16_t               iconOffsetY = 0; 
        IconSide              iconSide = IconSide::Left; 
        VisualShadow          textShadows[kMaxTextShadows] {}; 
 
        uint64_t GetHashCode() const noexcept
        {
            return Hash::Combine(Hash::CalculateBytes(textShadows, sizeof(textShadows)),
                                 Hash::CalculateBytes(decorationColorIndex, sizeof(decorationColorIndex)),
                                 textStyle.GetHashCode(),
                                 Hash::Calculate(textColorIndex),
                                 Hash::Calculate(iconColorIndex),
                                 Hash::Calculate(iconTextGap),
                                 Hash::Calculate(iconSize),
                                 Hash::Calculate(iconOffsetY),
                                 Hash::Calculate(iconSide));
        }
 
        bool operator==(const VisualTextStyle& other) const noexcept
        {
            return textStyle         == other.textStyle &&
                   textColorIndex    == other.textColorIndex &&
                   iconColorIndex    == other.iconColorIndex &&
                   std::ranges::equal(decorationColorIndex, other.decorationColorIndex) &&
                   iconTextGap       == other.iconTextGap &&
                   iconSize          == other.iconSize &&
                   iconOffsetY       == other.iconOffsetY &&
                   iconSide          == other.iconSide &&
                   std::ranges::equal(textShadows, other.textShadows);
        }
    };

}