gui_style_manager.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/style/gui_gradient_manager.h>
 
#include <stdint.h>
#include <deque>
#include <vector>
#include <unordered_map>
 
namespace tachyon
{
 
 

    using VisualBoxStyleStates = VisualBoxStyle[Style::kStateCount];
    using VisualTextStyleStates = VisualTextStyle[Style::kStateCount];

    struct TextOverride
    {
        FontID      font = FontID::Invalid; 
        LanguageTag language;               
    };

    enum class StyleUnits : uint8_t { Css, Pixels };

    class StyleManager
    {
    public:
        explicit StyleManager(GradientManager& gm) noexcept;

        StyleRef FallbackStyle() const noexcept { return m_fallbackStyle; }
        ~StyleManager();

        StyleRef Register(const Style &s, StyleUnits units = StyleUnits::Css) noexcept;

        struct ChildStyleRefs { StyleRef first, last, only; };
        StyleRef RegisterWithChildStyles(const Style& s, const Style& first, const Style& last, const Style& only,
                                         StyleUnits units = StyleUnits::Css) noexcept;
        const ChildStyleRefs* GetChildStyles(LayoutStyleIndex index) const noexcept;
        bool HasChildStyles() const noexcept { return !m_childStyles.empty(); }
        Style     ToPixels(const Style &s) const noexcept;
        TextStyle ToPixels(const TextStyle &t) const noexcept;

        void  SetUIScale(float scale) noexcept { m_uiScale = scale > 0.0f ? scale : 1.0f; }
        float GetUIScale() const noexcept { return m_uiScale; } 
        int32_t Px(int32_t cssPx) const noexcept { return int32_t(Px(float(cssPx))); }
        float   Px(float cssPx) const noexcept; 

        StyleRef WithTextOverride(StyleRef base, const TextOverride& textOverride) noexcept;

        StyleRef WithFlexWrap(StyleRef base, FlexWrap wrap) noexcept;

        StyleRef WithTextOf(StyleRef base, StyleRef from, tachyon::ElementState state, bool padding = true) noexcept;

        const LayoutStyle*           GetLayoutStyle(LayoutStyleIndex index) const noexcept;
        const VisualColorStyle*      GetVisualColorStyle(VisualColorStyleIndex index) const noexcept;
        const VisualBoxStyleStates*  GetVisualBoxStyles(VisualBoxStyleIndex index) const noexcept;
        const VisualBoxStyle*        GetVisualBoxStyle(VisualBoxStyleIndex index, tachyon::ElementState state) const noexcept;
        const VisualBoxStyle*        GetSelectionVisualBoxStyle(VisualBoxStyleIndex index, tachyon::ElementState state = tachyon::ElementState::None) const noexcept;
        const VisualTextStyle*       GetSelectionVisualTextStyle(VisualTextStyleIndex index, tachyon::ElementState state = tachyon::ElementState::None) const noexcept;
        const VisualTextStyleStates* GetVisualTextStyles(VisualTextStyleIndex index) const noexcept;
        const VisualTextStyle*       GetVisualTextStyle(VisualTextStyleIndex index, tachyon::ElementState state) const noexcept;
        const VisualShadowStyle*     GetVisualShadowStyle(uint32_t gpuStyleIndex) const noexcept;
        VisualBoxStyleIndex RegisterOutline(BoxEdges widths, BoxCorners radius, color4b color) noexcept;
        static void ApplyStateLayer(Style& style) noexcept;
        float                        GetOpacity(uint32_t gpuStyleIndex) const noexcept;
        const VisualBoxStyle*        GetVisualBoxStyleAt(uint32_t gpuStyleIndex) const noexcept;
        bool                         IsBoxBackgroundOpaque(uint32_t gpuStyleIndex) const noexcept;

        inline size_t LayoutStyleCount() const noexcept { return m_layoutStyles.size(); }
 
        inline size_t VisualBoxStyleCount() const noexcept { return m_visualBoxStyles.size() / Style::kStateCount; }
 
        inline size_t VisualTextStyleCount() const noexcept { return m_visualTextStyles.size() / Style::kStateCount; }
 
        inline size_t VisualColorStyleCount() const noexcept { return m_visualColorStyles.size(); }
 

        inline int32_t GetBorderBoxWidth(LayoutStyleIndex layoutStyleIndex) const noexcept
        {
            const tachyon::LayoutStyle* ls = GetLayoutStyle(layoutStyleIndex);
            return ls == nullptr ? 0 : ls->GetBorderBoxWidth();
        }
 
    public:
        bool AreVisualColorStylesModified() const noexcept { return visualColorStylesModified; }

        void ResetVisualColorStylesModified() noexcept { visualColorStylesModified = false; }
 

        bool AreVisualBoxStylesModified() const noexcept { return visualBoxStylesModified; }

        void ResetVisualBoxStylesModified() noexcept { visualBoxStylesModified = false; }
 

        std::span<const tachyon::VisualBoxStyle> GetVisualBoxStylesSpan() noexcept { return m_visualBoxStyles; }

        std::span<const tachyon::VisualColorStyle> GetVisualColorStylesSpan() noexcept { return m_visualColorStyles; }

        VisualColorStyleIndex RegisterVisualColorStyle(const VisualColorStyle& s,
                                                       GradientHandle incomingHandle) noexcept;

        VisualColorStyleIndex RegisterColorStyle(const ColorStyle& s,
                                                 ImageIndex textureIndex = ImageIndex::Invalid) noexcept;
 
        // ---- On-demand (runtime-mutable) color style management ----

        VisualColorStyleIndex CreateColorStyle(const ColorStyle& s) noexcept;

        void UpdateColorStyle(VisualColorStyleIndex idx, const ColorStyle& s) noexcept;

        void DestroyColorStyle(VisualColorStyleIndex idx) noexcept;

        void ClearAll() noexcept;

        uint32_t Generation() const noexcept { return m_generation; }

        GradientManager& GetGradientManager() noexcept { return m_gradientManager; }
 
    private:
        float m_uiScale = 1.0f;
        StyleRef m_fallbackStyle {};
        void RegisterFallbackStyle() noexcept;
        StyleRef RegisterImpl(const Style& s, StyleUnits units, bool distinct) noexcept;
        std::unordered_map<uint32_t, ChildStyleRefs> m_childStyles;   
        VisualColorStyleIndex TryDedupVisualColorStyle(const VisualColorStyle& s,
                                                       uint64_t hash) const noexcept;
        LayoutStyleIndex RegisterLayoutStyle(const LayoutStyle& layoutStyle, bool distinct) noexcept;
        VisualTextStyleIndex RegisterVisualTextStyles(const VisualTextStyle (&states)[Style::kStateCount],
                                                      uint64_t hash) noexcept;
        uint16_t RegisterShadows(const BoxShadow (&layers)[kMaxBoxShadows], const BoxShadow& ring, BoxCorners radius,
                                 float opacity) noexcept;
 
        GradientManager&             m_gradientManager;
        uint32_t                     m_generation = 0;
        std::unordered_map<uint64_t, VisualTextStyleIndex> m_textOverrides; 
        std::unordered_map<uint64_t, StyleRef> m_textOfVariants;            

        std::deque<LayoutStyle>       m_layoutStyles;
        std::vector<VisualBoxStyle>   m_visualBoxStyles;
        std::vector<bool>             m_opaqueBoxBackgrounds; 
        std::vector<VisualTextStyle>  m_visualTextStyles;
        std::vector<VisualColorStyle> m_visualColorStyles;
        std::vector<VisualShadowStyle> m_visualShadowStyles; 
        struct Outline { BoxEdges widths; BoxCorners radius; color4b color; VisualBoxStyleIndex index; };
        std::vector<Outline>           m_outlines;           

        std::vector<GradientHandle>   m_visualColorStyleHandles;
 
        bool visualColorStylesModified = false;
        bool visualBoxStylesModified = false;

        std::unordered_map<uint64_t, std::vector<LayoutStyleIndex>>      m_layoutHashMap;
        std::unordered_map<uint64_t, std::vector<VisualBoxStyleIndex>>   m_visualBoxHashMap;
        std::unordered_map<uint64_t, std::vector<VisualTextStyleIndex>>  m_visualTextHashMap;
        std::unordered_map<uint64_t, std::vector<VisualColorStyleIndex>> m_visualColorHashMap;

        std::vector<VisualColorStyleIndex> m_freeColorStyleSlots;
    };

}