gui_style_text.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <cstring>
#include <string_view>
 
namespace tachyon
{

    enum class TextID : uint32_t { Invalid = 0 };
    enum class IconID : uint32_t { Invalid = 0 };

    enum class FontID : uint32_t { Invalid = 0 };

    FontID FontIDFromName(std::string_view familyName);

    struct LanguageTag
    {
        char value[16] = {}; 
 
        LanguageTag() = default;
        explicit LanguageTag(std::string_view tag) noexcept
        {
            if (tag.size() < sizeof(value))
                std::memcpy(value, tag.data(), tag.size());
        }

        bool             empty() const noexcept { return value[0] == '\0'; }
        const char*      c_str() const noexcept { return value; }
        std::string_view view()  const noexcept { return value; }
        bool operator==(const LanguageTag& other) const noexcept { return view() == other.view(); }
    };
 
    
    enum class TextDirection : uint8_t
    {
        Auto,        
        LeftToRight,
        RightToLeft,
    };

    enum class TextWrap : uint8_t
    {
        NoWrap = 0, 
        Wrap,       
        WordChar,   
    };

    enum class TextAlign : uint8_t
    {
        Start = 0,  
        Center,     
        End,        
        Left,       
        Right,      
        Top,        
        Bottom,     
    };

    enum class TextBaseline : uint8_t
    {
        Alphabetic,   
        Ideographic,  
        Central,      
        Hanging,      
        Mathematical, 
        Middle,       
        TextTop,      
        TextBottom,   
        Max,          
    };

    enum class DecorationStyle : uint8_t
    {
        Solid = 0,  
        Double,     
        Dotted,     
        Dashed,     
        Wavy,       
    };

    enum class FontFamily : uint8_t
    {
        Default,    
        Emoji,      
        SansSerif,  
        Serif,      
        Monospace,  
        Math,       
    };

    enum class FontWeight : uint8_t
    {
        Normal,     
        Thin,       
        ExtraLight, 
        UltraLight, 
        Light,      
        Regular,    
        Medium,     
        DemiBold,   
        SemiBold,   
        Bold,       
        ExtraBold,  
        UltraBold,  
        Black,      
        Heavy,      
        ExtraBlack, 
        UltraBlack, 
    };

    enum class FontStyle : uint8_t
    {
        Normal = 0, 
        Italic,     
        Oblique,    
    };

    enum class FontStretch : uint8_t
    {
        Normal = 0,     
        UltraCondensed, 
        ExtraCondensed, 
        Condensed,      
        SemiCondensed,  
        SemiExpanded,   
        Expanded,       
        ExtraExpanded,  
        UltraExpanded,  
    };

    enum class LineHeight : uint8_t
    {
        Normal = 0,       
        MetricsRelative,  
        FontSizeRelative, 
        Absolute,         
    };

    enum class VerticalTrim : uint8_t
    {
        Default = 0,    
        CapToBaseline,  
    };

    enum class WordWrap : uint8_t
    {
        None,     
        Normal,   
        BreakWord 
    };

    enum class TextOverflow : uint8_t
    {
        Clip,     
        Ellipsis  
    };

    class TextLayoutStyle
    {
    public:
        TextDirection    textDirection       = TextDirection::Auto;     
        TextWrap         textWrapping        = TextWrap::NoWrap;        
        TextAlign        horizontalAlignment = TextAlign::Start;        
        TextAlign        verticalAlignment   = TextAlign::Start;
        TextBaseline     baseline            = TextBaseline::Alphabetic;
        TextOverflow     textOverflow        = TextOverflow::Clip;     
        WordWrap         wrapMode            = WordWrap::Normal;       
        VerticalTrim     verticalTrim        = VerticalTrim::Default;  
 
        uint64_t GetHashCode() const noexcept;
 
        inline bool operator==(const TextLayoutStyle& other) const noexcept
        {
            return textDirection       == other.textDirection &&
                   textWrapping        == other.textWrapping &&
                   horizontalAlignment == other.horizontalAlignment &&
                   verticalAlignment   == other.verticalAlignment &&
                   baseline            == other.baseline &&
                   verticalTrim        == other.verticalTrim &&
                   textOverflow        == other.textOverflow &&
                   wrapMode            == other.wrapMode;
        }
    };

    enum class DecorationLine : uint8_t
    {
        Under,   
        Bottom,  
        Over,    
        Through  
    };

    class TextDecoration
    {
    public:
        uint16_t        thickness = 0; 
        uint16_t        offset = 0;    
        DecorationStyle style = DecorationStyle::Solid; 
 
        uint64_t GetHashCode() const noexcept;
 
        inline bool operator==(const TextDecoration& other) const noexcept
        {
            if (thickness > 0)
            {
                if (other.thickness == 0) return false;
            } else
            {
                return other.thickness == 0; // if both are inactive other values are irrelevant
            }
            return style     == other.style &&
                   thickness == other.thickness &&
                   offset    == other.offset;
        }
    };

    class TextStyle
    {
    public:
        float                 fontSize       = 0;              
        float                 lineHeight     = 1.25f;
        float                 letterSpacing  = 0.0f;           
        float                 wordSpacing    = 0.0f;           
        FontFamily            family         = FontFamily::Default; 
        FontWeight            weight         = FontWeight::Normal;
        FontStyle             style          = FontStyle::Normal;
        FontStretch           stretch        = FontStretch::Normal;
        LineHeight            lineHeightType = LineHeight::FontSizeRelative; 
        FontID                fontId         = FontID::Invalid; 
        LanguageTag           language;
                              
        TextDecoration        throughLine; 
        TextDecoration        bottomLine;  
        TextDecoration        underLine;   
        TextDecoration        overLine;    
 
        uint64_t GetHashCode() const noexcept;
 
        bool operator==(const TextStyle& other) const noexcept
        {
            return family         == other.family &&
                   fontSize       == other.fontSize &&
                   weight         == other.weight &&
                   style          == other.style &&
                   stretch        == other.stretch &&
                   lineHeightType == other.lineHeightType &&
                   lineHeight     == other.lineHeight &&
                   letterSpacing  == other.letterSpacing &&
                   wordSpacing    == other.wordSpacing &&
                   fontId         == other.fontId &&
                   language       == other.language &&
                   throughLine    == other.throughLine &&
                   bottomLine     == other.bottomLine &&
                   underLine      == other.underLine &&
                   overLine       == other.overLine;
        }
        
        inline float CalcLineHeight() const
        {
            switch (lineHeightType)
            {
                case LineHeight::Absolute:         return lineHeight;
                case LineHeight::FontSizeRelative: return fontSize * lineHeight;
                case LineHeight::MetricsRelative:
                case LineHeight::Normal:
                default:                           return fontSize;
            }
        }
    };

}//namespace tachyon