libgui/source/gui/GuiText.cpp

/****************************************************************************
 * Copyright (C) 2015 Dimok
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
#include <gui/GuiText.h>
#include <gui/FreeTypeGX.h>
#include <gui/video/CVideo.h>

FreeTypeGX *GuiText::presentFont = NULL;
int32_t GuiText::presetSize = 28;
float GuiText::presetInternalRenderingScale = 2.0f; //Lets render the font at the doubled size. This make it even smoother!
int32_t GuiText::presetMaxWidth = 0xFFFF;
int32_t GuiText::presetAlignment = ALIGN_CENTER | ALIGN_MIDDLE;
GX2ColorF32 GuiText::presetColor = (GX2ColorF32) {
        1.0f, 1.0f, 1.0f, 1.0f
};

#define TEXT_SCROLL_DELAY            6
#define TEXT_SCROLL_INITIAL_DELAY    10
#define MAX_LINES_TO_DRAW            10

/**
 * Constructor for the GuiText class.
 */

GuiText::GuiText() {
    text = NULL;
    size = presetSize;
    currentSize = size;
    color = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
    alpha = presetColor.a;
    alignment = presetAlignment;
    maxWidth = presetMaxWidth;
    wrapMode = 0;
    textWidth = 0;
    font = presentFont;
    linestodraw = MAX_LINES_TO_DRAW;
    textScrollPos = 0;
    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
    textScrollDelay = TEXT_SCROLL_DELAY;
    defaultBlur = 4.0f;
    blurGlowIntensity = 0.0f;
    blurAlpha = 0.0f;
    blurGlowColor = glm::vec4(0.0f);
    internalRenderingScale = presetInternalRenderingScale;
}

GuiText::GuiText(const char *t, int32_t s, const glm::vec4 &c) {
    text = NULL;
    size = s;
    currentSize = size;
    color = c;
    alpha = c[3];
    alignment = ALIGN_CENTER | ALIGN_MIDDLE;
    maxWidth = presetMaxWidth;
    wrapMode = 0;
    textWidth = 0;
    font = presentFont;
    linestodraw = MAX_LINES_TO_DRAW;
    textScrollPos = 0;
    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
    textScrollDelay = TEXT_SCROLL_DELAY;
    defaultBlur = 4.0f;
    blurGlowIntensity = 0.0f;
    blurAlpha = 0.0f;
    blurGlowColor = glm::vec4(0.0f);
    internalRenderingScale = presetInternalRenderingScale;

    if (t) {
        text = FreeTypeGX::charToWideChar(t);
        if (!text)
            return;

        textWidth = font->getWidth(text, currentSize);
    }
}

GuiText::GuiText(const wchar_t *t, int32_t s, const glm::vec4 &c) {
    text = NULL;
    size = s;
    currentSize = size;
    color = c;
    alpha = c[3];
    alignment = ALIGN_CENTER | ALIGN_MIDDLE;
    maxWidth = presetMaxWidth;
    wrapMode = 0;
    textWidth = 0;
    font = presentFont;
    linestodraw = MAX_LINES_TO_DRAW;
    textScrollPos = 0;
    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
    textScrollDelay = TEXT_SCROLL_DELAY;
    defaultBlur = 4.0f;
    blurGlowIntensity = 0.0f;
    blurAlpha = 0.0f;
    blurGlowColor = glm::vec4(0.0f);
    internalRenderingScale = presetInternalRenderingScale;

    if (t) {
        text = new(std::nothrow) wchar_t[wcslen(t) + 1];
        if (!text)
            return;

        wcscpy(text, t);

        textWidth = font->getWidth(text, currentSize);
    }
}

/**
 * Constructor for the GuiText class, uses presets
 */
GuiText::GuiText(const char *t) {
    text = NULL;
    size = presetSize;
    currentSize = size;
    color = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
    alpha = presetColor.a;
    alignment = presetAlignment;
    maxWidth = presetMaxWidth;
    wrapMode = 0;
    textWidth = 0;
    font = presentFont;
    linestodraw = MAX_LINES_TO_DRAW;
    textScrollPos = 0;
    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
    textScrollDelay = TEXT_SCROLL_DELAY;
    defaultBlur = 4.0f;
    blurGlowIntensity = 0.0f;
    blurAlpha = 0.0f;
    blurGlowColor = glm::vec4(0.0f);
    internalRenderingScale = presetInternalRenderingScale;

    if (t) {
        text = FreeTypeGX::charToWideChar(t);
        if (!text)
            return;

        textWidth = font->getWidth(text, currentSize);
    }
}


/**
 * Destructor for the GuiText class.
 */
GuiText::~GuiText() {
    if (text)
        delete[] text;
    text = NULL;

    clearDynamicText();
}

void GuiText::setText(const char *t) {
    if (text)
        delete[] text;
    text = NULL;

    clearDynamicText();

    textScrollPos = 0;
    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;

    if (t) {
        text = FreeTypeGX::charToWideChar(t);
        if (!text)
            return;

        textWidth = font->getWidth(text, currentSize);
    }
}

void GuiText::setTextf(const char *format, ...) {
    if (!format) {
        setText((char *) NULL);
        return;
    }

    int32_t max_len = strlen(format) + 8192;
    char *tmp = new char[max_len];
    va_list va;
    va_start(va, format);
    if ((vsnprintf(tmp, max_len, format, va) >= 0) && tmp) {
        setText(tmp);
    }
    va_end(va);

    if (tmp)
        delete[] tmp;
}


void GuiText::setText(const wchar_t *t) {
    if (text)
        delete[] text;
    text = NULL;

    clearDynamicText();

    textScrollPos = 0;
    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;

    if (t) {
        text = new(std::nothrow) wchar_t[wcslen(t) + 1];
        if (!text)
            return;

        wcscpy(text, t);

        textWidth = font->getWidth(text, currentSize);
    }
}

void GuiText::clearDynamicText() {
    for (uint32_t i = 0; i < textDyn.size(); i++) {
        if (textDyn[i])
            delete[] textDyn[i];
    }
    textDyn.clear();
    textDynWidth.clear();
}

void GuiText::setPresets(int32_t sz, const glm::vec4 &c, int32_t w, int32_t a) {
    presetSize = sz;
    presetColor = (GX2ColorF32) {
            (float) c.r / 255.0f, (float) c.g / 255.0f, (float) c.b / 255.0f, (float) c.a / 255.0f
    };
    presetMaxWidth = w;
    presetAlignment = a;
}

void GuiText::setPresetFont(FreeTypeGX *f) {
    presentFont = f;
}

void GuiText::setFontSize(int32_t s) {
    size = s;
}

void GuiText::setMaxWidth(int32_t width, int32_t w) {
    maxWidth = width;
    wrapMode = w;

    if (w == SCROLL_HORIZONTAL) {
        textScrollPos = 0;
        textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
        textScrollDelay = TEXT_SCROLL_DELAY;
    }

    clearDynamicText();
}

void GuiText::setColor(const glm::vec4 &c) {
    color = c;
    alpha = c[3];
}

void GuiText::setBlurGlowColor(float blur, const glm::vec4 &c) {
    blurGlowColor = c;
    blurGlowIntensity = blur;
    blurAlpha = c[3];
}

int32_t GuiText::getTextWidth(int32_t ind) {
    if (ind < 0 || ind >= (int32_t) textDyn.size())
        return this->getTextWidth();

    return font->getWidth(textDyn[ind], currentSize);
}

const wchar_t *GuiText::getDynText(int32_t ind) {
    if (ind < 0 || ind >= (int32_t) textDyn.size())
        return text;

    return textDyn[ind];
}

/**
 * Change font
 */
bool GuiText::setFont(FreeTypeGX *f) {
    if (!f)
        return false;

    font = f;
    textWidth = font->getWidth(text, currentSize);
    return true;
}

std::string GuiText::toUTF8(void) const {
    if (!text)
        return std::string();

    char *pUtf8 = FreeTypeGX::wideCharToUTF8(text);
    if (!pUtf8)
        return std::string();

    std::string strOutput(pUtf8);

    delete[] pUtf8;

    return strOutput;
}

void GuiText::makeDottedText() {
    int32_t pos = textDyn.size();
    textDyn.resize(pos + 1);

    int32_t i = 0, currentWidth = 0;
    textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
    if (!textDyn[pos]) {
        textDyn.resize(pos);
        return;
    }

    while (text[i]) {
        currentWidth += font->getCharWidth(text[i], currentSize, i > 0 ? text[i - 1] : 0);
        if (currentWidth >= maxWidth && i > 2) {
            textDyn[pos][i - 2] = '.';
            textDyn[pos][i - 1] = '.';
            textDyn[pos][i] = '.';
            i++;
            break;
        }

        textDyn[pos][i] = text[i];

        i++;
    }
    textDyn[pos][i] = 0;
}

void GuiText::scrollText(uint32_t frameCount) {
    if (textDyn.size() == 0) {
        int32_t pos = textDyn.size();
        int32_t i = 0, currentWidth = 0;
        textDyn.resize(pos + 1);

        textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];
        if (!textDyn[pos]) {
            textDyn.resize(pos);
            return;
        }

        while (text[i] && currentWidth < maxWidth) {
            textDyn[pos][i] = text[i];

            currentWidth += font->getCharWidth(text[i], currentSize, i > 0 ? text[i - 1] : 0);

            ++i;
        }
        textDyn[pos][i] = 0;

        return;
    }

    if (frameCount % textScrollDelay != 0) {
        return;
    }

    if (textScrollInitialDelay) {
        --textScrollInitialDelay;
        return;
    }

    int32_t stringlen = wcslen(text);

    ++textScrollPos;
    if (textScrollPos > stringlen) {
        textScrollPos = 0;
        textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
    }

    int32_t ch = textScrollPos;
    int32_t pos = textDyn.size() - 1;

    if (!textDyn[pos])
        textDyn[pos] = new(std::nothrow) wchar_t[maxWidth];

    if (!textDyn[pos]) {
        textDyn.resize(pos);
        return;
    }

    int32_t i = 0, currentWidth = 0;

    while (currentWidth < maxWidth) {
        if (ch > stringlen - 1) {
            textDyn[pos][i++] = ' ';
            currentWidth += font->getCharWidth(L' ', currentSize, ch > 0 ? text[ch - 1] : 0);
            textDyn[pos][i++] = ' ';
            currentWidth += font->getCharWidth(L' ', currentSize, L' ');
            textDyn[pos][i++] = ' ';
            currentWidth += font->getCharWidth(L' ', currentSize, L' ');
            ch = 0;

            if (currentWidth >= maxWidth)
                break;
        }

        textDyn[pos][i] = text[ch];
        currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0);
        ++ch;
        ++i;
    }
    textDyn[pos][i] = 0;
}

void GuiText::wrapText() {
    if (textDyn.size() > 0) return;

    int32_t i = 0;
    int32_t ch = 0;
    int32_t linenum = 0;
    int32_t lastSpace = -1;
    int32_t lastSpaceIndex = -1;
    int32_t currentWidth = 0;

    while (text[ch] && linenum < linestodraw) {
        if (linenum >= (int32_t) textDyn.size()) {
            textDyn.resize(linenum + 1);
            textDyn[linenum] = new(std::nothrow) wchar_t[maxWidth];
            if (!textDyn[linenum]) {
                textDyn.resize(linenum);
                break;
            }
        }

        textDyn[linenum][i] = text[ch];
        textDyn[linenum][i + 1] = 0;

        currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0x0000);

        if (currentWidth >= maxWidth || (text[ch] == '\n')) {
            if (text[ch] == '\n') {
                lastSpace = -1;
                lastSpaceIndex = -1;
            } else if (lastSpace >= 0) {
                textDyn[linenum][lastSpaceIndex] = 0; // discard space, and everything after
                ch = lastSpace; // go backwards to the last space
                lastSpace = -1; // we have used this space
                lastSpaceIndex = -1;
            }

            if (linenum + 1 == linestodraw && text[ch + 1] != 0x0000) {
                if (i < 2)
                    i = 2;

                textDyn[linenum][i - 2] = '.';
                textDyn[linenum][i - 1] = '.';
                textDyn[linenum][i] = '.';
                textDyn[linenum][i + 1] = 0;
            }

            currentWidth = 0;
            ++linenum;
            i = -1;
        }
        if (text[ch] == ' ' && i >= 0) {
            lastSpace = ch;
            lastSpaceIndex = i;
        }
        ++ch;
        ++i;
    }
}

/**
 * Draw the text on screen
 */
void GuiText::draw(CVideo *pVideo) {
    if (!text)
        return;

    if (!isVisible())
        return;

    color[3] = getAlpha();
    blurGlowColor[3] = blurAlpha * getAlpha();

    float finalRenderingScale = 2.0f * internalRenderingScale;

    int32_t newSize = size * getScale() * finalRenderingScale;
    int32_t normal_size = size * getScale();

    if (newSize != currentSize) {
        currentSize = normal_size;

        if (text)
            textWidth = font->getWidth(text, normal_size);
    }

    float x_pos = getCenterX() * finalRenderingScale;
    float y_pos = getCenterY() * finalRenderingScale;

    if (maxWidth > 0 && maxWidth <= textWidth) {
        if (wrapMode == DOTTED) { // text dotted
            if (textDyn.size() == 0)
                makeDottedText();

            if (textDynWidth.size() != textDyn.size()) {
                textDynWidth.resize(textDyn.size());

                for (uint32_t i = 0; i < textDynWidth.size(); i++)
                    textDynWidth[i] = font->getWidth(textDyn[i], newSize);
            }


            if (textDyn.size() > 0)
                font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], newSize, color, alignment, textDynWidth[textDyn.size() - 1], defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
        } else if (wrapMode == SCROLL_HORIZONTAL) {
            scrollText(pVideo->getFrameCount());

            if (textDyn.size() > 0)
                font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], newSize, color, alignment, maxWidth * finalRenderingScale, defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);

        } else if (wrapMode == WRAP) {
            int32_t lineheight = newSize + 6;
            int32_t yoffset = 0;
            int32_t voffset = 0;

            if (textDyn.size() == 0)
                wrapText();

            if (textDynWidth.size() != textDyn.size()) {
                textDynWidth.resize(textDyn.size());

                for (uint32_t i = 0; i < textDynWidth.size(); i++)
                    textDynWidth[i] = font->getWidth(textDyn[i], newSize);
            }

            if (alignment & ALIGN_MIDDLE)
                voffset = (lineheight * (textDyn.size() - 1)) >> 1;

            for (uint32_t i = 0; i < textDyn.size(); i++) {
                font->drawText(pVideo, x_pos, y_pos + voffset + yoffset, getDepth(), textDyn[i], newSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
                yoffset -= lineheight;
            }
        }
    } else {
        uint16_t newtextWidth = font->getWidth(text, newSize);
        font->drawText(pVideo, x_pos, y_pos, getDepth(), text, newSize, color, alignment, newtextWidth, defaultBlur, blurGlowIntensity, blurGlowColor, finalRenderingScale);
    }
}