TextBase.hpp

Go to the documentation of this file.

#pragma once

#include <etk/Color.hpp>

#include <ewol/debug.hpp>
#include <ewol/compositing/Compositing.hpp>
#include <ewol/compositing/Drawing.hpp>
#include <ewol/resource/TexturedFont.hpp>
#include <exml/exml.hpp>
#include <string>

namespace ewol {
    namespace compositing {
        class TextDecoration {
            public:
                etk::Color<> m_colorBg; 
                etk::Color<> m_colorFg; 
                enum ewol::font::mode m_mode; 
                TextDecoration() {
                    m_colorBg = etk::color::blue;
                    m_colorBg = etk::color::green;
                    m_mode = ewol::font::Regular;
                }
        };
        
        enum aligneMode {
            alignDisable,
            alignRight,
            alignLeft,
            alignCenter,
            alignJustify
        };
        
        class TextBase : public ewol::Compositing {
            protected:
                ewol::compositing::Drawing m_vectorialDraw; 
            public:
                virtual ewol::compositing::Drawing& getDrawing() {
                    return m_vectorialDraw;
                };
            protected:
                int32_t m_nbCharDisplayed; 
                vec3 m_sizeDisplayStart; 
                vec3 m_sizeDisplayStop; 
                bool m_needDisplay; 
                vec3 m_position; 
                vec3 m_clippingPosStart; 
                vec3 m_clippingPosStop; 
                bool m_clippingEnable; 
            protected:
                etk::Color<> m_defaultColorFg; 
                etk::Color<> m_defaultColorBg; 
            protected:
                etk::Color<> m_color; 
                etk::Color<> m_colorBg; 
                etk::Color<> m_colorCursor; 
                etk::Color<> m_colorSelection; 
            protected:
                enum ewol::font::mode m_mode; 
                bool m_kerning; 
                char32_t m_previousCharcode; 
            protected:
                float m_startTextpos; 
                float m_stopTextPos; 
                enum aligneMode m_alignement; 
            protected:
                ememory::SharedPtr<gale::resource::Program> m_GLprogram; 
                int32_t m_GLPosition; 
                int32_t m_GLMatrix; 
                int32_t m_GLColor; 
                int32_t m_GLtexture; 
                int32_t m_GLtexID; 
                int32_t m_GLtextWidth; 
                int32_t m_GLtextHeight; 
            protected:
                int32_t m_selectionStartPos; 
                int32_t m_cursorPos; 
            protected: // Text
                std::vector<vec3 > m_coord; 
                std::vector<vec2 > m_coordTex; 
                std::vector<etk::Color<float> > m_coordColor; 
            public:
                virtual void loadProgram(const std::string& _shaderName);
            public:
                TextBase(const std::string& _shaderName = "{ewol}DATA:text.prog", bool _loadProgram = true);
                virtual ~TextBase();
            public: // Derived function
                void translate(const vec3& _vect);
                void rotate(const vec3& _vect, float _angle);
                void scale(const vec3& _vect);
            public:
                void draw(bool _disableDepthTest=true) {
                    drawD(_disableDepthTest);
                }
                void draw(const mat4& _transformationMatrix, bool _enableDepthTest=false) {
                    drawMT(_transformationMatrix, _enableDepthTest);
                }
                virtual void drawD(bool _disableDepthTest) = 0;
                virtual void drawMT(const mat4& _transformationMatrix, bool _enableDepthTest) = 0;
                virtual void clear();
                virtual void reset();
                const vec3& getPos() {
                    return m_position;
                };
                void setPos(const vec3& _pos);
                inline void setPos(const vec2& _pos) {
                    setPos(vec3(_pos.x(),_pos.y(),0));
                };
                void setRelPos(const vec3& _pos);
                inline void setRelPos(const vec2& _pos) {
                    setRelPos(vec3(_pos.x(),_pos.y(),0));
                };
                void setDefaultColorBg(const etk::Color<>& _color) {
                    m_defaultColorBg = _color;
                }
                void setDefaultColorFg(const etk::Color<>& _color) {
                    m_defaultColorFg = _color;
                }
                void setColor(const etk::Color<>& _color) {
                    m_color = _color;
                };
                void setColorBg(const etk::Color<>& _color);
                void setClippingWidth(const vec3& _pos, const vec3& _width) {
                    setClipping(_pos, _pos+_width);
                }
                void setClippingWidth(const vec2& _pos, const vec2& _width) {
                    setClipping(_pos, _pos+_width);
                };
                void setClipping(const vec3& _pos, const vec3& _posEnd);
                void setClipping(const vec2& _pos, const vec2& _posEnd) {
                    setClipping(vec3(_pos.x(),_pos.y(),-1), vec3(_posEnd.x(),_posEnd.y(),1) );
                };
                // TODO : Rename setClippingActivity
                void setClippingMode(bool _newMode);
                virtual void setFontSize(int32_t _fontSize) = 0;
                virtual void setFontName(const std::string& _fontName) = 0;
                virtual void setFont(std::string _fontName, int32_t _fontSize) = 0;
                virtual void setFontMode(enum ewol::font::mode _mode) = 0;
                enum ewol::font::mode getFontMode() {
                    return m_mode;
                };
                virtual float getHeight() = 0;
                virtual float getSize() = 0;
                virtual ewol::GlyphProperty * getGlyphPointer(char32_t _charcode) = 0;
                void setFontBold(bool _status);
                void setFontItalic(bool _status);
                void setKerningMode(bool _newMode);
                void print(const std::string& _text);
                void print(const std::u32string& _text);
                void printDecorated(const std::string& _text);
                void printDecorated(const std::u32string& _text);
                void printHTML(const std::string& _text);
                void printHTML(const std::u32string& _text);
                void print(const std::string& _text, const std::vector<TextDecoration>& _decoration);
                void print(const std::u32string& _text, const std::vector<TextDecoration>& _decoration);
                virtual void printChar(const char32_t& _charcode) = 0;
                void forceLineReturn();
            protected:
                void parseHtmlNode(const exml::Element& _element);
            public:
                void setTextAlignement(float _startTextpos, float _stopTextPos, enum ewol::compositing::aligneMode _alignement=ewol::compositing::alignDisable);
                void disableAlignement();
                enum ewol::compositing::aligneMode getAlignement();
                vec3 calculateSizeHTML(const std::string& _text);
                vec3 calculateSizeHTML(const std::u32string& _text);
                vec3 calculateSizeDecorated(const std::string& _text);
                vec3 calculateSizeDecorated(const std::u32string& _text);
                vec3 calculateSize(const std::string& _text);
                vec3 calculateSize(const std::u32string& _text);
                inline vec3 calculateSize(const char32_t& _charcode) {
                    return calculateSizeChar(_charcode);
                };
            protected:
                virtual vec3 calculateSizeChar(const char32_t& _charcode) = 0;
            public:
                void printCursor(bool _isInsertMode, float _cursorSize = 20.0f);
            protected:
                bool extrapolateLastId(const std::string& _text, const int32_t _start, int32_t& _stop, int32_t& _space, int32_t& _freeSpace);
                bool extrapolateLastId(const std::u32string& _text, const int32_t _start, int32_t& _stop, int32_t& _space, int32_t& _freeSpace);
            protected:
                // this section is reserved for HTML parsing and display:
                std::u32string m_htmlCurrrentLine; 
                std::vector<TextDecoration> m_htmlDecoration; 
                TextDecoration m_htmlDecoTmp; 

                void htmlAddData(const std::u32string& _data);
                void htmlFlush();
            public:
                void disableCursor();
                void setCursorPos(int32_t _cursorPos);
                void setCursorSelection(int32_t _cursorPos, int32_t _selectionStartPos);
                void setSelectionColor(const etk::Color<>& _color);
                void setCursorColor(const etk::Color<>& _color);
        };
    }
}