gui_text_system.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>
#include <gui_core/gui_id.h>
#include <gui_core/gui_hash.h>
 
#include <gui_core/text/gui_numeric_field_config.h>
#include <gui_core/text/gui_numeric_type.h>
#include <gui_core/text/gui_text_converter.h>
 
#include <gui_core/input/gui_platform_input_handler.h>
 
#include <gui_core/style/gui_style.h>
#include <gui_core/style/gui_style_ref.h>
 
#include <bit>
#include <cstddef>
#include <stdint.h>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
namespace tachyon
{

    struct FontFaceSource
    {
        std::string_view           file;
        std::span<const std::byte> data;
    };
 
    // Forward declarations
    class GraphicsContext;
    class GUIStateManager;
    class IClipboard;
    class StyleManager;
    class ScrollManagement;
    class TextAtlasManager;
    enum class KeyAction : uint8_t;
    enum class MouseAction : uint8_t;
    enum class ElementFlags : uint32_t;
 
    // ------------------------------------------------------------------------
    // Icon Measurement Result
    // ------------------------------------------------------------------------
 
    struct IconMeasurement
    {
        int32_t width = 0;
        int32_t height = 0;
 
        constexpr int2 Size() const { return int2{ width, height }; }
        constexpr bool IsEmpty() const { return width == 0 && height == 0; }
    };
 
    // ------------------------------------------------------------------------
    // Text Measurement Result
    // ------------------------------------------------------------------------
    struct TextMeasurement
    {
        static constexpr int32_t kUnbounded = std::numeric_limits<int32_t>::max();
        
        int32_t minWidth = 0;   
        int32_t maxWidth = 0;   
        int32_t minHeight = 0;  
        int32_t maxHeight = 0;  
 
        constexpr int2 MinSize() const { return int2{ minWidth, minHeight }; }
        constexpr int2 MaxSize() const { return int2{ maxWidth, maxHeight }; }
        constexpr bool IsEmpty() const { return maxWidth == 0 && maxHeight == 0; }
    };
 
    // ------------------------------------------------------------------------
    // Text Wrap Context - Constraints for text measurement
    // ------------------------------------------------------------------------
 
    struct TextWrapContext
    {
        int32_t maxWidth = INT32_MAX;
        int32_t maxHeight = INT32_MAX;
        uint32_t maxLines = UINT32_MAX;
 
        bool operator==(const TextWrapContext&) const = default;
 
        inline uint64_t GetHashCode() const { return Hash::Calculate(*this); }
    };
 
    // ------------------------------------------------------------------------
    // Text Editing Behavior
    // ------------------------------------------------------------------------
 
    enum class TextEditBehavior : uint8_t
    {
        None = 0,
        ContinuousUpdate = 1 << 0,  
        Multiline = 1 << 1,         
        AcceptTabs = 1 << 2,        
        ReadOnly = 1 << 3           
    };
    TACHYON_ENUM_OPERATORS(TextEditBehavior)
 
        
    // ----------------------------------------------------------------------------------
    // ContentRun - Represents a run of either text or an icon for rich text registration
    // ----------------------------------------------------------------------------------
 
    
    struct LinkStyle
    {
        color4b     color      { 64, 148, 255, 255 };
        color4b     hoverColor { 128, 200, 255, 255 };
        MouseCursor cursor     = MouseCursor::Pointer; 
 
        bool operator==(const LinkStyle&) const noexcept = default;
    };

    struct ContentRun
    {
        static constexpr float kSizeAuto = -1.0f; 
 
        enum Type { Text, Icon };
        Type type;
 
        std::string_view text;   
        IconID           iconID; 
 
        float iconWidth  = kSizeAuto;   
        float iconHeight = kSizeAuto;   
 
        intptr_t contentId = 0;    
        bool     isLink    = false; 
        LinkStyle linkStyle;

        const TextStyle* textStyleOverride = nullptr;
 
        uint64_t GetHashCode() const
        {
            uint64_t hash = Hash::Calculate(type);
            if (type == Text)
            {
                hash = Hash::Combine(hash, Hash::Calculate(text));
            } else
            {
                if (iconID == IconID::Invalid)
                {
                    hash = Hash::Combine(hash, ((uint32_t)iconID), 0, 0);
                } else
                {
                    hash = Hash::Combine(hash, ((uint32_t)iconID), std::bit_cast<uint32_t>(iconWidth), std::bit_cast<uint32_t>(iconHeight));
                }
            }
            hash = Hash::Combine(hash, static_cast<uint64_t>(contentId), isLink ? 1u : 0u);
            if (isLink)
                hash = Hash::Combine(hash, Hash::Calculate(linkStyle.color), Hash::Calculate(linkStyle.hoverColor),
                                     Hash::Calculate(linkStyle.cursor));
            if (textStyleOverride)
                hash = Hash::Combine(hash, textStyleOverride->GetHashCode());
            return hash;
        }
    };
 
 
    // ------------------------------------------------------------------------
    // Abstract Text System Interface
    // ------------------------------------------------------------------------

    class ITextSystem : public IPlatformInputHandler
    {
    public:
        virtual ~ITextSystem() = default;
 
        struct TextEditUpdate
        {
            bool textChanged = false;
            bool textCommitted = false;
 
            constexpr bool HasUpdate() const
            {
                return textChanged || textCommitted;
            }
        };
 
        // -------------------- Initialization --------------------

        virtual void SetFontDirectory(std::string_view directory) = 0;

        virtual void SetFallbackFontDirectory(std::string_view directory) = 0;
 
        virtual bool Initialize(GraphicsContext* graphicsContext, StyleManager* styleManager,
                                TextAtlasManager* textAtlasManager,
                                GUIStateManager* guiStateManager, IClipboard* clipboard) = 0;
        virtual void Shutdown() = 0;
        virtual void Update() = 0;

        virtual void BeginFrame(int2 screenMousePos, MouseButtons mouseButtons, uint32_t timeMs) = 0;

        virtual void BeginAtlasRecord(ID /*scopeId*/) {}
        virtual void EndAtlasRecord() {}
        virtual bool ReplayAtlasTouches(ID /*scopeId*/) { return true; }
 
        // -------------------- Font Registration --------------------

        virtual void SetLanguage(std::string_view languageTag) = 0;

        virtual FontID RegisterFontFamily(std::string_view familyName, std::span<const FontFaceSource> faces) = 0;
        FontID RegisterFontFamily(std::string_view familyName, std::span<const std::string_view> faceFiles)
        {
            std::vector<FontFaceSource> faces;
            faces.reserve(faceFiles.size());
            for (std::string_view file : faceFiles)
                faces.push_back(FontFaceSource{ .file = file });
            return RegisterFontFamily(familyName, faces);
        }
 
        // -------------------- Text Registration --------------------

        virtual TextID RegisterText(ID elementId, IconID iconId, std::string_view text, StyleRef styleIndex, ElementState state) = 0;
        TextID RegisterText(ID elementId, std::string_view text, StyleRef styleIndex, ElementState state) { return RegisterText(elementId, IconID::Invalid, text, styleIndex, state); }
        
        virtual TextID RegisterEditableText(ID elementId, std::string& text, TextEditBehavior behavior, StyleRef styleIndex, ElementState state, bool& wasModified,
                                            const ITextValidator* validator = nullptr) = 0;

        virtual std::string* ValueEditText(ID elementId, bool& started) = 0;

        template<typename T, typename Converter = TextConverter<T>>
        TextID RegisterEditableValue(ID elementId, T& value, TextEditBehavior behavior, StyleRef styleIndex, ElementState state, bool& wasModified,
                                     const Converter& converter = DefaultTextConverter<T>())
        {
            bool started = false;
            std::string* editText = ValueEditText(elementId, started);
            std::string shownText;
            if (editText == nullptr)
                shownText = converter.Format(value, /*editing*/ false);
            else if (started)
                *editText = converter.Format(value, /*editing*/ true);
            std::string& text = editText ? *editText : shownText;
 
            bool edited = false;
            const TextID textId = RegisterEditableText(elementId, text, behavior, styleIndex, state, edited, &converter);
            if (edited && converter.Parse(text, value))
                wasModified = true;
            return textId;
        }

        template<typename T>
        TextID RegisterEditableNumber(ID elementId, T& value, TextEditBehavior behavior, StyleRef styleIndex, ElementState state, bool& wasModified, NumericFieldConfig<T> config = {})
        {
            bool edited = false;
            const TextID textId = RegisterEditableValue(elementId, value, behavior, styleIndex, state, edited);
            if (edited)
            {
                wasModified = true;
                value = std::clamp(value, config.minVal, config.maxVal);
            }
            return textId;
        }

        virtual void SetTextColor(TextID textId, VisualColorStyleIndex color) = 0;

        virtual void SetCaretColor(VisualColorStyleIndex color) = 0;
        virtual void SetUndoHistory(class UndoHistory* history) = 0;

        virtual std::string_view GetText(TextID textId) const = 0;
 

        virtual TextID RegisterRichText(ID elementId, const std::span<ContentRun>& contentRuns,
                                        StyleRef styleIndex, ElementState state) = 0;

        virtual TextID RegisterEditableRichText(ID elementId, const std::span<ContentRun>& contentRuns,
                                                TextEditBehavior behavior, StyleRef styleIndex,
                                                ElementState state, bool& wasModified) = 0;

        virtual TextID GetTextID(ID elementId) const = 0;
 
        // -------------------- Text Measurement (for layout) --------------------

        virtual TextMeasurement GetTextMeasurement(TextID textId) const = 0;

        virtual TextMeasurement MeasureText(TextID textId, const TextWrapContext& wrapContext) const = 0;

        virtual int32_t GetTextHeightWithoutIcon(TextID textId) const = 0;
 
        // -------------------- Text Rendering --------------------

        virtual void RenderText(TextID textId, IntRect rect, IntRect innerRect, IntRect clipRect, float pixelScale = 1.f,
                                const float3x2& screenToLayout = float3x2::Identity()) = 0;

        virtual std::optional<MouseCursor> LinkCursorAt(ID elementId, int32_t localX, int32_t localY) const = 0;

        virtual intptr_t HitTestContent(TextID textId, int32_t localX, int32_t localY) const = 0;

        virtual void SetHoveredContent(TextID textId, intptr_t contentId) = 0;
 
 
 
        // -------------------- Icon Measurement --------------------

        virtual IconMeasurement GetIconMeasurement(IconID iconId) const = 0;

        virtual IconMeasurement MeasureIcon(IconID iconId) const = 0;
 
        // -------------------- Icon Registration --------------------

        virtual bool IsValidIcon(IconID iconId) const = 0;

        virtual IconID RegisterIconFromSVG(const char* name, const char* svg_data, size_t svg_size) = 0;

        virtual IconID RegisterIconFromSVGFile(const char* path) = 0;

        virtual IconID RegisterIconFromPixels(const char* name, uint2 size, std::span<const uint8_t> rgba) = 0;

        virtual void UnregisterIcon(IconID iconId) = 0;
 
        // -------------------- Icon Rendering --------------------

        virtual void RenderIcon(IconID iconId, IntRect rect, IntRect clipRect, VisualColorStyleIndex tint,
                                std::span<const VisualShadow> shadows = {}) = 0;
 
 
 
        // -------------------- Editor Input Handling --------------------
        virtual void OnKeyboard(ID windowId, KeyCode key, int repeat, KeyModifier modifiers, KeyAction action) = 0;

        virtual void OnMouseMove(ID windowId, tachyon::int2 screenPos, MouseButtons button, KeyModifier modifiers) = 0;

        virtual void OnMouseButton(ID windowId, tachyon::int2 screenPos, MouseButtons button, KeyModifier modifiers, MouseAction action) = 0;

        virtual void OnMouseScroll(ID windowId, tachyon::int2 screenPos, tachyon::float2 scrollOffset, KeyModifier modifiers) = 0;

        virtual void SwitchTextEditor(ID from, ID to) = 0;

        virtual bool DoesTextEditorAcceptTabs(ID elementId) const = 0;

        virtual bool IsTextEditor(ID elementId) const = 0;

        virtual void RequestSelectAll(ID elementId) = 0;

        virtual TextEditUpdate ConsumeTextEditUpdate(TextID textId, std::string& outText) = 0;

        virtual bool UpdateText(TextID textId, std::string_view text) = 0;

        virtual std::string Copy() = 0;

        virtual std::string Cut() = 0;

        virtual void Paste(std::string_view text) = 0;

        virtual bool IsHoveringSelectedText(ID textEditorId, ID windowId, tachyon::int2 screenSpace) const = 0;

        virtual bool TryGetTextDragCursor(ID windowId, tachyon::int2 screenSpace, MouseCursor& outCursor) const = 0;

        virtual bool TryGetTextDragHoverTarget(ID windowId, tachyon::int2 screenSpace, ID& outTargetId) const = 0;
 
        // -------------------- Cache Management --------------------

        virtual void ClearCache() = 0;
 
        // -------------------- Cursor Visibility --------------------

        virtual void EnsureCursorVisible(ID textEditorId) = 0;

        virtual std::optional<IntRect> GetCursorRect(ID textEditorId) = 0;

        virtual std::optional<IntRect> GetCaretScreenRect() const = 0;
    };

} // namespace tachyon