Text.h

Go to the documentation of this file.

#pragma once

#include "Color.h"
#include "Font.h"
#include "GraphicsModel.h"
#include <string>
#include <utility>
#include <regex>

namespace rose {

    static constexpr std::string_view CallPattern = "[A-Z]+[0-9][A-Z]+";
    static constexpr std::string_view FloatPattern = "([+-]?([0-9]+([.][0-9]*)?|[.][0-9]+))?";

    struct PointSize {
        int pointSize{};
        PointSize() : pointSize(0) {}
        explicit PointSize(int size) : pointSize(size) {}
    };

    struct FontName {
        std::string fontName;
        FontName() : fontName() {}
        explicit FontName(std::string  name) : fontName(std::move(name)) {}
        FontName& operator=(const FontName& name) {
            fontName = name.fontName;
            return *this;
        }
    };

    class Text {
    public:
        enum RenderStyle{
            Blended,        
            Shaded,         
            Solid           
        };

        enum Status {
            OK,                             
            TextEmpty,                      
            FontError,                      
            SurfaceError,                   
            TextureError,                   
        };

    protected:
        std::string mText{};                
        std::string mSuffix{};              
        color::RGBA mTextFgColor;           
        color::RGBA mTextBgColor;           
        color::RGBA mCaretColor{};          
        color::RGBA mRegexFail{};           
        color::RGBA mDataSaved{};           
        float mCaretAlpha{0.f};             
        RenderStyle mRenderStyle{Blended};  
        std::string mFontName;              
        std::shared_ptr<_TTF_Font> mFont{}; 
        int mPointSize;                     
        gm::Texture mTexture{};             
        Size mTextSize{};                   
        Status mStatus{OK};                 
        int mCaretLocation{0};              
        bool mEditingActive{false};         

        bool mEditable{false};              
        bool mTextValidated{true};          
        bool mSaveToSettings{false};        
        int mMaxSize{0};                    
        char eM{'N'};                       
        std::unique_ptr<std::regex> mValidationPattern{};   

        void setEditingMode(bool editing, int carret);

    public:
        Text();
        virtual ~Text() = default;

        Text(const Text &) = delete;
        Text(Text &&) = delete;
        Text& operator=(const Text &) = delete;
        Text& operator=(Text &&) = delete;

        Status createTextureBlended(gm::Context &context);

        void setPointSize(int pointSize) {
            mPointSize = pointSize;
        }

        void setFontName(const std::string &fontName) {
            mFontName = fontName;
        }

        bool setText(const std::string &text) {
            if (mText != text) {
                mText = text;
                textUpdated();
                return true;
            }
            return false;
        }

        bool textUpdated();

        void setSuffix(const std::string &suffix) {
            mSuffix = suffix;
        }

        void setTextMaxSize(int maxSize, char em = '\0') {
            mMaxSize = maxSize;
            if (em)
                eM = em;
        }

        void setTextValidationPattern(const std::string& regex) {
            mValidationPattern = std::make_unique<std::regex>(regex);
        }
    };
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, rose::PointSize pointSize) {
    static_assert(std::is_base_of_v<rose::Text,WidgetClass>, "WidgetClass must be derived from rose::Text." );
    widget->setPointSize(pointSize.pointSize);
    return widget;
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, rose::FontName fontName) {
    static_assert(std::is_base_of_v<rose::Text,WidgetClass>, "WidgetClass must be derived from rose::Text." );
    widget->setFontName(fontName.fontName);
    return widget;
}