std::list<UString> BitmapFont::wordWrapText(const UString &Text, int MaxWidth)
{
int txtwidth;
std::list<UString> lines = Text.splitlist("\n");
std::list<UString> wrappedLines;
for (UString str : lines)
{
txtwidth = getFontWidth(str);
if (txtwidth > MaxWidth)
{
auto remainingChunks = str.splitlist(" ");
UString currentLine;
while (!remainingChunks.empty())
{
UString currentTestLine;
if (currentLine != "")
currentTestLine = currentLine + " ";
auto ¤tChunk = remainingChunks.front();
currentTestLine += currentChunk;
auto estimatedLength = getFontWidth(currentTestLine);
if (estimatedLength < MaxWidth)
{
currentLine = currentTestLine;
remainingChunks.pop_front();
}
else
{
if (currentLine == "")
{
LogWarning("No break in line \"%s\" found - this will probably overflow "
"the control",
currentTestLine);
currentLine = currentTestLine;
remainingChunks.pop_front();
}
else
{
wrappedLines.push_back(currentLine);
currentLine = "";
}
}
}
if (currentLine != "")
wrappedLines.push_back(currentLine);
}
else
{
wrappedLines.push_back(str);
}
}
return wrappedLines;
}
static void modeMessageInit(DisplayInternalInfo& displayInternalInfo, const void* param) {
HT1632Class& HT1632 = displayInternalInfo.ht1632;
if (param != nullptr) {
snprintf(modeMessageData.msg, sizeof(modeMessageData.msg), "%s", (const char*) param);
} else if (modeMessageData.modeMsgsIndex >= (ModeMsgsIndex) 0 && modeMessageData.modeMsgsIndex < modeMsgsIndexLast) {
strncpy(modeMessageData.msg, modeMessageMsgs[modeMessageData.modeMsgsIndex], sizeof(modeMessageData.msg));
}
// runtime
modeMessageData.wd = HT1632.getTextWidth(modeMessageData.msg,
getFontWidth(modeMessageData.font),
getFontHeight(modeMessageData.font));
}
//------------------------------------------------------------------------------
// Outline Font functions
// FtglOutlineFont::outputText() -- FTGLOutlineFont output routines
//------------------------------------------------------------------------------
void FtglOutlineFont::outputText(const double x, const double y, const char* txt, const int n, const bool vf, const bool)
{
// Make sure we have characters to print
if (n <= 0) return;
// Make sure we have a loaded font
if (isNotLoaded()) {
loadFont();
if (isNotLoaded()) throw new ExpInvalidFont();
}
// Prepare the output text
char cbuf[MSG_BUF_LEN];
int nn = xferChars(cbuf,MSG_BUF_LEN,txt,n);
if (nn <= 0) return;
// Output the text
FTGLOutlineFont* ftgl1 = static_cast<FTGLOutlineFont*>(FTGL());
if (ftgl1 != nullptr) {
glPushMatrix();
glTranslated(x, y, 0.0);
glScalef(static_cast<GLfloat>(getFontWidth()), static_cast<GLfloat>(getFontHeight()), 1.0f);
if (vf) {
// Vertical text
GLdouble dy = getLineSpacing();
if (getFontHeight() != 0.0) dy = getLineSpacing() / getFontHeight();
char cc[2];
cc[1] = '\0';
for (int i = 0; i < nn; i++) {
cc[0] = cbuf[i];
ftgl1->Render(cc);
glTranslated(0.0, -dy, 0.0);
}
}
else {
// Normal text
ftgl1->Render(cbuf);
}
glPopMatrix();
}
else {
if (isMessageEnabled(MSG_ERROR)) {
std::cerr << "FtglOutlineFont::outputText() - no outline font available" << std::endl;
}
}
}
static void drawBackgroundMessages(DisplayInternalInfo& displayInternalInfo) {
HT1632Class& HT1632 = displayInternalInfo.ht1632;
int boardId, i, j;
for (i=0; i < BACKGROUND_MESSAGE_COUNT; ++i) {
if (backgroundMessage[i].enabled == false) continue;
if (willAnimate(&backgroundMessage[i].animation) == false) continue;
for (j=0; j < BUFFER_SECONDARY; ++j) {
switch (backgroundMessage[i].displayColor) {
case displayColorGreen: boardId = 0; break;
case displayColorRed: boardId = 1; break;
case displayColorYellow: // fall thru...
default: boardId = j; break;
}
HT1632.drawTarget(BUFFER_BOARD(boardId+1));
HT1632.drawText(backgroundMessage[i].msg, backgroundMessage[i].x, backgroundMessage[i].y,
getFontData(backgroundMessage[i].font),
getFontWidth(backgroundMessage[i].font),
getFontHeight(backgroundMessage[i].font),
getFontGlyphStep(backgroundMessage[i].font));
if (backgroundMessage[i].displayColor != displayColorYellow) break;
}
}
}
//------------------------------------------------------------------------------
// Halo Font functions
// FtglHaloFont::outputText() -- FtglHaloFont output routines
//------------------------------------------------------------------------------
void FtglHaloFont::outputText(const double x, const double y, const char* txt, const int n, const bool vf, const bool rf)
{
GLfloat ocolor[4];
glGetFloatv(GL_CURRENT_COLOR, ocolor);
// Make sure we have characters to print
if (n <= 0) return;
// Make sure we have a loaded font
if (isNotLoaded()) {
loadFont();
if (isNotLoaded()) throw new ExpInvalidFont();
}
// Prepare the output text
char cbuf[MSG_BUF_LEN];
int nn = xferChars(cbuf,MSG_BUF_LEN,txt,n);
if (nn <= 0) return;
if (haloColor != nullptr) Graphic::lcColor3(haloColor->red(), haloColor->green(), haloColor->blue());
// default to black if we have no color specified
else glColor3f(0,0,0);
// now render the outline font over it!
if (!rf) {
if (outline != nullptr) {
glPushMatrix();
glTranslated(x, y, -0.01f);
// get our current linewidth
GLfloat lw = 0;
glGetFloatv(GL_LINE_WIDTH, &lw);
glLineWidth(linewidth);
glScalef(static_cast<GLfloat>(getFontWidth()), static_cast<GLfloat>(getFontHeight()), 1.0f);
if (vf) {
// Vertical text
GLdouble dy = getLineSpacing();
if (getFontHeight() != 0.0) dy = getLineSpacing() / getFontHeight();
char cc[2];
cc[1] = '\0';
for (int i = 0; i < nn; i++) {
cc[0] = cbuf[i];
outline->Render(cc);
glTranslated(0.0, -dy, 0.0);
}
}
else {
// Normal text
outline->Render(cbuf);
}
glLineWidth(lw);
glPopMatrix();
}
else {
if (isMessageEnabled(MSG_ERROR)) {
std::cerr << "FtglHaloFont::outputText() - no outline font available" << std::endl;
}
}
}
glColor4fv(ocolor);
// output the text
FTGLPolygonFont* ftgl1 = static_cast<FTGLPolygonFont*>(FTGL());
if (ftgl1 != nullptr) {
glPushMatrix();
glTranslated(x, y, 0.0);
glScalef(static_cast<GLfloat>(getFontWidth()), static_cast<GLfloat>(getFontHeight()), 1.0f);
if (vf) {
// Vertical text
GLdouble dy = getLineSpacing();
if (getFontHeight() != 0.0) dy = getLineSpacing() / getFontHeight();
char cc[2];
cc[1] = '\0';
for (int i = 0; i < nn; i++) {
cc[0] = cbuf[i];
ftgl1->Render(cc);
glTranslated(0.0, -dy, 0.0);
}
}
else {
// Normal text
ftgl1->Render(cbuf);
}
glPopMatrix();
}
else {
if (isMessageEnabled(MSG_ERROR)) {
std::cerr << "FtglPolygonFont::outputText() - no Polygon font available" << std::endl;
}
}
}
static void modeMessageFast(DisplayInternalInfo& displayInternalInfo) {
int boardId, i;
HT1632Class& HT1632 = displayInternalInfo.ht1632;
HT1632.clearAll();
const int currColorEffect = modeMessageDataColorEffect % 3;
for (i=0; i < BUFFER_SECONDARY; ++i) {
if (modeMessageData.blinkBlankInEffect) break; // blinkBlankInEffect in effect? If so, write no chars
switch (modeMessageData.displayColor) {
case displayColorGreen: boardId = 0; break;
case displayColorRed: boardId = 1; break;
case displayColorYellow: boardId = i; break;
case displayColorAlternate: // fall thru
default: boardId = currColorEffect == 2 ? i : currColorEffect; break;
}
HT1632.drawTarget(BUFFER_BOARD(boardId+1));
// if bouncing, make sure sure y is within range
const int wantedY = modeMessageData.currYFactor / INCREMENT_Y_SCALE;
const int adjustedY = modeMessageData.incrementY ? getAdjustedTextY(modeMessageData.font, wantedY) : wantedY;
HT1632.drawText(modeMessageData.msg,
modeMessageData.incrementX ? (OUT_SIZE - modeMessageData.currX) : modeMessageData.currX /*x*/,
adjustedY /*y*/,
getFontData(modeMessageData.font),
getFontWidth(modeMessageData.font),
getFontHeight(modeMessageData.font),
getFontGlyphStep(modeMessageData.font));
if (modeMessageData.displayColor == displayColorAlternate && currColorEffect == 2) continue;
if (modeMessageData.displayColor != displayColorYellow) break;
}
drawBackgroundMessages(displayInternalInfo);
drawBackgroundImgs(displayInternalInfo);
// confetti
if (modeMessageData.confetti > 0) {
for (boardId=0; boardId < BUFFER_SECONDARY; ++boardId) {
HT1632.drawTarget(BUFFER_BOARD(boardId+1));
for (int xx = 0, yy = (int) getRandomNumber(modeMessageData.confetti); xx <= yy ; ++xx) {
HT1632.setPixel( (int) getRandomNumber(OUT_SIZE), (int) getRandomNumber(COM_SIZE));
}
}
}
HT1632.renderAll();
// text wrap
if (modeMessageData.incrementX && ++modeMessageData.currX >= (modeMessageData.wd + OUT_SIZE)) {
modeMessageData.currX = 0;
++modeMessageDataColorEffect;
if (modeMessageData.alternateFont) {
modeMessageData.font = getNextFont(modeMessageData.font);
modeMessageData.wd = HT1632.getTextWidth(modeMessageData.msg,
getFontWidth(modeMessageData.font),
getFontHeight(modeMessageData.font));
}
// repeats?
if (modeMessageData.repeats != ~0) {
// mode exit (1 of 2)
if (--modeMessageData.repeats < 0) {
modeMessageData.repeats = ~0; // avoid getting here again...
if (modeMessageData.completedCallback != nullptr) {
(*(modeMessageData.completedCallback))(displayInternalInfo, modeMessageData.completedCallbackParam);
return;
}
}
}
}
// Y (bounce effect)
if (modeMessageData.incrementY != 0) {
modeMessageData.currYFactor += modeMessageData.incrementY;
const int maxY = COM_SIZE - getFontHeight(modeMessageData.font);
if (modeMessageData.incrementY < 0 && modeMessageData.currYFactor < 0) {
modeMessageData.incrementY *= -1;
} else if (modeMessageData.incrementY > 0 && (modeMessageData.currYFactor >= maxY * INCREMENT_Y_SCALE)) {
modeMessageData.incrementY *= -1;
if (!modeMessageData.incrementX) {
++modeMessageDataColorEffect;
if (modeMessageData.alternateFont) {
modeMessageData.font = getNextFont(modeMessageData.font);
// modeMessageData.wd = HT1632.getTextWidth(modeMessageData.msg,
// getFontWidth(modeMessageData.font),
// getFontHeight(modeMessageData.font));
}
}
}
}
}
