jmGuiText.h

#ifndef JUGIMAP_GUI_TEXT_H
#define JUGIMAP_GUI_TEXT_H
 
#include <assert.h>
#include <algorithm>
#include <cmath>
#include <vector>
#include <map>
#include <array>
#include <string>
#include "../utf8cpp/utf8.h"
 
 
#include "jmGuiCommon.h"
#include "jmFont.h"
#include "jmCommon.h"
 
 
namespace jugimap{
    
 
 
class TextLibrary;
class TextBook;
class TextSequence;
class TextSprite;
class ComposedSprite;
class StandardSprite;
 
 
 
class UnicodeString
{
public:
 
    //std::string s;
 
    UnicodeString(){}
    UnicodeString(const std::string &_s);
 
    void Set(const std::string &_s);
    void Append(const std::string &_s);
    void Append(const UnicodeString &_us);
    void Append(int _code);
    void Clear();
    bool IsEmpty(){ return codes.empty(); }
    int GetLength(){ return codes.size(); }
 
    std::string ToStdString();
    std::string ToStdString(int _startIndex, int _endIndex=-1);
 
 
    std::vector<int> & GetCodes(){ return codes; }
 
private:
    std::vector<int>codes;
 
};
 
 
void VerifyAndFixUtf8string(std::string& str);
 
 
std::string GetSubstring(const std::string &text, int indexStart, int indexEnd, bool &endReached);
 
 
void GetStringUnicodes(const std::string &text, std::vector<int> &unicodes);
 
 
int GetStringNumberOfCharacters(const std::string &text);
 
 
 
class TextSegmentWord
{
public:
    std::string word;
    int nCharacters = 0;
 
    float width = -1;                       // width in pixels
    float height = -1;
 
    //std::string replacementKeyword;
    std::string originalWord;
    ColorRGBA color{255,255,255};
    Font * font = nullptr;                  // LINK
    float fFontHeight = 1.0;
 
    std::string button;
    //ColorRGBA buttonColor{255,255,255};
    ColorRGBA buttonColor_CO{200,0,0};
    //int offset = 0;
 
 
    //int horSpacing = 0;
    //int verSpacing = 0;
 
 
 
 
    enum Content{
        TEXT,
        //HOR_OFFSET,
        OFFSET,
        VER_SPACING,
        INDENT,
        TAB_SPACING
    };
 
    Content content = TEXT;
 
 
    void UpdateSize(bool _forceUpdate = false);
 
};
 
 
 
class TextSegment
{
public:
    friend class TextLibrary;
    friend class TextBook;
    friend class TextSequence;
 
 
    TextSegment(int _id) : id(_id)
    {
        currentColor = defaultColor;                    // index 0
        currentFont = defaultFont;                          // index 0
        currentIndent = defaultIndent;
        currentTabSpacing = defaultTabSpacing;
 
    }
 
    ~TextSegment();
 
 
    int GetId(){ return id; }
 
 
    std::vector<Parameter>& GetParameters() { return parameters; }
 
 
    bool Replace(const std::string &_searchedWord, const std::string &newWord);
 
 
    bool Contains(const std::string &_word, bool compareWithOriginalWord = false);
 
 
    void AddParagraph(const std::string &_text, ColorsLibrary &_colors, FontsLibrary &_fonts);
 
 
    std::vector<TextSegmentWord*> &GetWords(){ return words; }
    void SetWordSizesIfNeeded();
 
 
private:
    int id = 0;
    std::vector<TextSegmentWord*> words;
    std::vector<Parameter> parameters;
 
 
 
static ColorRGBA defaultColor;
static Font *defaultFont;
static ColorRGBA currentColor;
static Font *currentFont;
static std::string currentButton;
static ColorRGBA currentButtonColor;
static ColorRGBA currentButtonColor_CO;
//static int currentOffset;
static int defaultIndent;
static int defaultTabSpacing;
static int currentIndent;
static int currentTabSpacing;
 
 
    void ProcessAddingWord(TextSegmentWord *word, ColorsLibrary &colors, FontsLibrary &fonts);
 
};
 
 
class TextSequence
{
public:
 
    TextSequence(){}
    TextSequence(int _id) : id(_id){}
    ~TextSequence();
 
 
    int GetId(){ return id; }
 
 
    std::vector<TextSegment*>& GetTextSegments(){ return TextSegments; }
 
 
    std::vector<Parameter>& GetParameters() { return parameters; }
 
 
private:
    int id = 0;
    std::vector<TextSegment*>TextSegments;          // OWNED pointers
    std::vector<Parameter> parameters;
 
};
 
 
//=======================================================================================
 
 
class TextBook
{
public:
 
    TextBook(const std::string &_name) : name(_name){}
 
    TextBook(const TextBook &_src) = delete;
    TextBook(const TextBook &&_src) = delete;
    TextBook& operator=(const TextBook &_src) = delete;
 
 
    ~TextBook();
 
 
    std::string GetName(){ return name; }
 
 
    void LoadContent(const std::string &_filePath, ColorsLibrary &_colors, FontsLibrary &_fonts);
 
 
    bool AddTextSegment(TextSegment *_textSegment);
 
 
    bool AddTextSequence(TextSequence *_textSequence);
 
 
    std::vector<TextSegment*>& GetTextSegments(){ return TextSegments; }
 
 
    std::vector<TextSequence*>& GetTextSequences(){ return TextSequences; }
 
 
 
private:
    std::string name;
    std::vector<TextSegment*>TextSegments;              // OWNED pointers
    std::vector<TextSequence*>TextSequences;            // OWNED pointers
 
 
    void _ParseParametersIfDefined(std::string &text, std::vector<Parameter>&_parameters);
 
};
 
 
 
//========================================================================================================================
 
 
class TextLibrary
{
public:
    static std::string path;
    static std::string pathPrefix;
 
 
    ~TextLibrary();
 
 
    TextBook* CreateNewBook(const std::string  &_bookName);
 
 
    TextBook *FindBook(const std::string &_bookName);
 
 
    TextSegment *GetTextSegmentFromBook(const std::string &_bookName, int _segmentID);
 
 
private:
 
    std::vector<TextBook*>books;
 
};
 
 
extern TextLibrary textLibrary;
 
 
 
    
}
 
 
 
 
#endif