//------------------------------------------------------------------------------
// outputText() -- Text output routines
//------------------------------------------------------------------------------
void BitmapFont::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;
// Set the base
glListBase(getBase());
// output the text
if (vf) {
// Vertical text
for (int i = 0; i < nn; i++) {
glRasterPos2d( x, (y - float(i)*getLineSpacing()) );
glCallLists(1, GL_UNSIGNED_BYTE, &cbuf[i]);
}
}
else {
// Normal text
glRasterPos2d(x,y);
glCallLists(nn, GL_UNSIGNED_BYTE, cbuf);
}
}
void gtAction::setParaStyleAttributes(gtParagraphStyle *pstyle, ParagraphStyle& style)
{
double linesp;
int flags = pstyle->getFlags();
style.erase();
style.setName(pstyle->getName());
if (pstyle->getAutoLineSpacing())
linesp = getLineSpacing(pstyle->getFont()->getSize());
else
linesp = pstyle->getLineSpacing();
style.setLineSpacingMode(pstyle->isAdjToBaseline() ? ParagraphStyle::BaselineGridLineSpacing : ParagraphStyle::FixedLineSpacing);
style.setLineSpacing(linesp);
if (flags & gtParagraphStyle::alignmentWasSet)
style.setAlignment(static_cast<ParagraphStyle::AlignmentType>(pstyle->getAlignment()));
if (flags & gtParagraphStyle::indentWasSet)
style.setLeftMargin(pstyle->getIndent());
if (flags & gtParagraphStyle::firstIndentWasSet)
style.setFirstIndent(pstyle->getFirstLineIndent());
if (flags & gtParagraphStyle::spaceAboveWasSet)
style.setGapBefore(pstyle->getSpaceAbove());
if (flags & gtParagraphStyle::spaceBelowWasSet)
style.setGapAfter(pstyle->getSpaceBelow());
if (flags & gtParagraphStyle::tabValueWasSet)
style.setTabValues(*pstyle->getTabValues());
if (flags & gtParagraphStyle::dropCapWasSet)
style.setHasDropCap(pstyle->hasDropCap());
if (flags & gtParagraphStyle::dropCapHeightWasSet)
style.setDropCapLines(pstyle->getDropCapHeight());
/*vg.setDropCapOffset(0);*/
}
void TableOfReal_drawAsNumbers (TableOfReal me, Graphics graphics, long rowmin, long rowmax, int iformat, int precision) {
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, 0.5, my numberOfColumns + 0.5, 0, 1);
double leftMargin = getLeftMargin (graphics); // not earlier!
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_BOTTOM);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
if (my columnLabels && my columnLabels [icol] && my columnLabels [icol] [0])
Graphics_text (graphics, icol, 1, my columnLabels [icol]);
}
for (long irow = rowmin; irow <= rowmax; irow ++) {
double y = 1 - lineSpacing * (irow - rowmin + 0.6);
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
if (my rowLabels && my rowLabels [irow] && my rowLabels [irow] [0])
Graphics_text (graphics, 0.5 - leftMargin, y, my rowLabels [irow]);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
wchar_t text [40];
print4 (text, my data [irow] [icol], iformat, 0, precision);
Graphics_text (graphics, icol, y, text);
}
}
if (maxTextHeight) {
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * leftMargin;
Graphics_line (graphics, left, 1, my numberOfColumns + 0.5, 1);
}
Graphics_unsetInner (graphics);
}
void EditDistanceTable_drawEditOperations (EditDistanceTable me, Graphics graphics) {
const char32 *oinsertion = U"i", *insertion = U"*", *odeletion = U"d", *deletion = U"*", *osubstitution = U"s", *oequal = U"";
Graphics_setWindow (graphics, 0.5, my warpingPath -> pathLength - 0.5, 0, 1); // pathLength-1 symbols
double lineSpacing = getLineSpacing (graphics);
double ytarget = 1 - lineSpacing, ysource = ytarget - 2 * lineSpacing, yoper = ysource - lineSpacing;
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_BOTTOM);
for (long i = 2; i <= my warpingPath -> pathLength; i++) {
structPairOfInteger p = my warpingPath -> path[i], p1 = my warpingPath -> path[i - 1];
double x = i - 1;
if (p.x == p1.x) { // insertion
Graphics_text (graphics, x, ytarget, my rowLabels[p.y]);
Graphics_text (graphics, x, ysource, deletion);
Graphics_text (graphics, x, yoper, oinsertion);
} else if (p.y == p1.y) { // deletion
Graphics_text (graphics, x, ytarget, insertion);
Graphics_text (graphics, x, ysource, my columnLabels[p.x]);
Graphics_text (graphics, x, yoper, odeletion);
} else { // substitution ?
Graphics_text (graphics, x, ytarget, my rowLabels[p.y]);
Graphics_text (graphics, x, ysource, my columnLabels[p.x]);
Graphics_text (graphics, x, yoper, (Melder_equ (my rowLabels[p.y], my columnLabels[p.x]) ? oequal : osubstitution));
}
Graphics_line (graphics, x, ysource + lineSpacing, x, ytarget - 0.1 * lineSpacing);
}
}
//------------------------------------------------------------------------------
// 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 double getMaxColumnLabelHeight (TableOfReal me, Graphics graphics, long colmin, long colmax) {
double maxHeight = 0.0, lineSpacing = getLineSpacing (graphics);
if (! my columnLabels) return 0.0;
fixRows (me, & colmin, & colmax);
for (long icol = colmin; icol <= colmax; icol ++) if (my columnLabels [icol] && my columnLabels [icol] [0]) {
if (! maxHeight) maxHeight = lineSpacing;
}
return maxHeight;
}
void EditDistanceTable_draw (EditDistanceTable me, Graphics graphics, int iformat, int precision, double angle) {
long rowmin = 1, rowmax = my numberOfRows;
Graphics_setInner (graphics);
Graphics_setWindow (graphics, 0.5, my numberOfColumns + 0.5, 0, 1);
double leftMargin = getLeftMargin (graphics); // not earlier!
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double y = 1 + 0.1 * lineSpacing;
autoNUMmatrix<bool> onPath (1, my numberOfRows, 1, my numberOfColumns);
for (long i = 1; i <= my warpingPath -> pathLength; i++) {
structPairOfInteger poi = my warpingPath -> path[i];
onPath[poi.y] [poi.x] = true;
}
for (long irow = my numberOfRows; irow > 0; irow --) {
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
if (my rowLabels && my rowLabels [irow] && my rowLabels [irow] [0])
Graphics_text (graphics, 0.5 - leftMargin, y, my rowLabels [irow]);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
char text [40];
print4 (text, my data [irow] [icol], iformat, 0, precision);
Graphics_setBold (graphics, onPath[irow][icol]);
Graphics_text (graphics, icol, y, Melder_peek8to32 (text));
if (onPath[irow][icol]) {
Graphics_rectangle (graphics, icol-0.5, icol+0.5, y - 0.5*lineSpacing, y + 0.5*lineSpacing);
}
}
y -= lineSpacing;
Graphics_setBold (graphics, false);
}
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * leftMargin;
Graphics_line (graphics, left, y, my numberOfColumns + 0.5, y);
Graphics_setTextRotation (graphics, angle);
if (angle < 0) {
y -= 0.3*lineSpacing;
Graphics_setTextAlignment (graphics, Graphics_LEFT, Graphics_HALF);
} else if (angle > 0) {
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
y -= 0.3*lineSpacing;
} else {
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_TOP);
}
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
if (my columnLabels && my columnLabels [icol] && my columnLabels [icol] [0])
Graphics_text (graphics, icol, y, my columnLabels [icol]);
}
Graphics_setTextRotation (graphics, 0);
y -= lineSpacing;
Graphics_line (graphics, 0.5, y, 0.5, 1 + 0.5 * lineSpacing);
Graphics_unsetInner (graphics);
}
void TableOfReal_drawVerticalLines (TableOfReal me, Graphics graphics, long rowmin, long rowmax) {
long colmin = 1, colmax = my numberOfColumns;
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, 0, 1);
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
if (maxTextWidth > 0.0) colmin -= 1;
for (long col = colmin + 1; col <= colmax; col ++)
Graphics_line (graphics, col - 0.5, 1 + maxTextHeight, col - 0.5, 1 - lineSpacing * (rowmax - rowmin + 1));
Graphics_unsetInner (graphics);
}
/*************************************************************************
draws wrapped text
*************************************************************************/
size_t Font::drawWrappedText(const String& text, const Rect& draw_area, float z, const Rect& clip_rect, TextFormatting fmt, const ColourRect& colours, float x_scale, float y_scale)
{
size_t line_count = 0;
Rect dest_area(draw_area);
float wrap_width = draw_area.getWidth();
String whitespace = TextUtils::DefaultWhitespace;
String thisLine, thisWord;
size_t currpos = 0;
// get first word.
currpos += getNextWord(text, currpos, thisLine);
// while there are words left in the string...
while (String::npos != text.find_first_not_of(whitespace, currpos))
{
// get next word of the string...
currpos += getNextWord(text, currpos, thisWord);
// if the new word would make the string too long
if ((getTextExtent(thisLine, x_scale) + getTextExtent(thisWord, x_scale)) > wrap_width)
{
// output what we had until this new word
line_count += drawText(thisLine, dest_area, z, clip_rect, fmt, colours, x_scale, y_scale);
// remove whitespace from next word - it will form start of next line
thisWord = thisWord.substr(thisWord.find_first_not_of(whitespace));
// reset for a new line.
thisLine.clear();
// update y co-ordinate for next line
dest_area.d_top += getLineSpacing(y_scale);
}
// add the next word to the line
thisLine += thisWord;
}
// Last line is left aligned
TextFormatting last_fmt = (fmt == Justified ? LeftAligned : fmt);
// output last bit of string
line_count += drawText(thisLine, dest_area, z, clip_rect, last_fmt, colours, x_scale, y_scale);
return line_count;
}
void TableOfReal_drawTopAndBottomLines (TableOfReal me, Graphics graphics, long rowmin, long rowmax) {
long colmin = 1, colmax = my numberOfColumns;
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, 0, 1);
double lineSpacing = getLineSpacing (graphics);
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * lineSpacing;
double right = colmax + 0.5;
double top = 1 + maxTextHeight;
double bottom = 1 - lineSpacing * (rowmax - rowmin + 1);
Graphics_line (graphics, left, top, right, top);
Graphics_line (graphics, left, bottom, right, bottom);
Graphics_unsetInner (graphics);
}
void FtglPixmapFont::outputText(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
FTGLPixmapFont* ftgl1 = static_cast<FTGLPixmapFont*>(FTGL());
if (ftgl1 != nullptr) {
if (vf) {
// Vertical text
char cc[2];
cc[1] = '\0';
GLdouble rpos[4];
glGetDoublev(GL_CURRENT_RASTER_POSITION, rpos);
for (int i = 0; i < nn; i++) {
cc[0] = cbuf[i];
glRasterPos2d( rpos[0], (rpos[1] - static_cast<float>(i)*getLineSpacing()) );
ftgl1->Render(cc);
}
}
else {
// Normal text
ftgl1->Render(cbuf);
}
}
else {
if (isMessageEnabled(MSG_ERROR)) {
std::cerr << "FtglPixmapFont::outputText() - no pixmap font available" << std::endl;
}
}
}
void TableOfReal_drawAsNumbers_if (TableOfReal me, Graphics graphics, long rowmin, long rowmax, int iformat, int precision,
const wchar_t *conditionFormula, Interpreter interpreter)
{
try {
autoMatrix original = TableOfReal_to_Matrix (me);
autoMatrix conditions = original.clone ();
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, 0.5, my numberOfColumns + 0.5, 0, 1);
double leftMargin = getLeftMargin (graphics); // not earlier!
double lineSpacing = getLineSpacing (graphics); // not earlier!
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
Matrix_formula (original.peek(), conditionFormula, interpreter, conditions.peek());
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_BOTTOM);
for (long icol = 1; icol <= my numberOfColumns; icol ++) {
if (my columnLabels && my columnLabels [icol] && my columnLabels [icol] [0])
Graphics_text (graphics, icol, 1, my columnLabels [icol]);
}
for (long irow = rowmin; irow <= rowmax; irow ++) {
double y = 1 - lineSpacing * (irow - rowmin + 0.6);
Graphics_setTextAlignment (graphics, Graphics_RIGHT, Graphics_HALF);
if (my rowLabels && my rowLabels [irow] && my rowLabels [irow] [0])
Graphics_text (graphics, 0.5 - leftMargin, y, my rowLabels [irow]);
Graphics_setTextAlignment (graphics, Graphics_CENTRE, Graphics_HALF);
for (long icol = 1; icol <= my numberOfColumns; icol ++) if (conditions -> z [irow] [icol] != 0.0) {
wchar_t text [40];
print4 (text, my data [irow] [icol], iformat, 0, precision);
Graphics_text (graphics, icol, y, text);
}
}
if (maxTextHeight) {
double left = 0.5;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * leftMargin;
Graphics_line (graphics, left, 1, my numberOfColumns + 0.5, 1);
}
Graphics_unsetInner (graphics);
} catch (MelderError) {
Melder_throw (me, ": numbers not drawn.");
}
}
void TableOfReal_drawHorizontalLines (TableOfReal me, Graphics graphics, long rowmin, long rowmax) {
long colmin = 1, colmax = my numberOfColumns;
fixRows (me, & rowmin, & rowmax);
Graphics_setInner (graphics);
Graphics_setWindow (graphics, colmin - 0.5, colmax + 0.5, 0, 1);
double lineSpacing = getLineSpacing (graphics);
double maxTextWidth = getMaxRowLabelWidth (me, graphics, rowmin, rowmax);
double maxTextHeight = getMaxColumnLabelHeight (me, graphics, 1, my numberOfColumns);
double left = 0.5;
double top = rowmin;
if (maxTextWidth > 0.0) left -= maxTextWidth + 2 * lineSpacing;
if (maxTextHeight > 0.0) rowmin -= 1;
double right = colmax + 0.5;
for (long irow = rowmin; irow < rowmax; irow ++) {
double y = 1 - lineSpacing * (irow - top + 1);
Graphics_line (graphics, left, y, right, y);
}
Graphics_unsetInner (graphics);
}
//------------------------------------------------------------------------------
// Pixmap Font functions
// FtglPixmapFont::outputText() -- FTGLPixmapFont output routines
//------------------------------------------------------------------------------
void FtglPixmapFont::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
FTGLPixmapFont* ftgl1 = (FTGLPixmapFont*)FTGL();
if (ftgl1 != 0) {
if (vf) {
// Vertical text
char cc[2];
cc[1] = '\0';
for (int i = 0; i < nn; i++) {
cc[0] = cbuf[i];
glRasterPos2d( x, (y - float(i)*getLineSpacing()) );
ftgl1->Render(cc);
}
}
else {
// Normal text
glRasterPos2d(x,y);
ftgl1->Render(cbuf);
}
}
else {
if (isMessageEnabled(MSG_ERROR)) {
std::cerr << "FTGLPixmapFont::outputText() - no Pixmap font available" << std::endl;
}
}
}
unsigned int Label::drawText(Form* form) const
{
if (_viewportClipBounds.width <= 0 || _viewportClipBounds.height <= 0)
return 0;
// Draw the text.
if (_text.size() > 0 && _font)
{
Control::State state = getState();
float fontSize = getFontSize(state);
SpriteBatch* batch = _font->getSpriteBatch(fontSize);
startBatch(form, batch);
_font->drawText(_text.c_str(), _textBounds, _textColor, fontSize, getTextAlignment(state), true, getTextDrawingFlags(state), _viewportClipBounds,
getCharacterSpacing(state), getLineSpacing(state));
finishBatch(form, batch);
return 1;
}
return 0;
}
Int32 TextDomArea::getScrollableUnitIncrement(const Pnt2f& VisibleRectTopLeft, const Pnt2f& VisibleRectBottomRight, const UInt32& orientation, const Int32& direction)
{
if(getFont() != NULL)
{
UInt16 MajorAxis;
if(orientation == ScrollBar::VERTICAL_ORIENTATION)
{
MajorAxis = 1;
}
else
{
MajorAxis = 0;
}
Pnt2f TopLeft, BottomRight;
getFont()->getBounds("A", TopLeft, BottomRight);
return BottomRight[MajorAxis] - TopLeft[MajorAxis] + (MajorAxis==1?getLineSpacing():0);
}
else
{
return Inherited::getScrollableUnitIncrement(VisibleRectTopLeft, VisibleRectBottomRight, orientation, direction);
}
}
void Label::updateBounds()
{
if (_autoSize != AUTO_SIZE_NONE && _font)
{
// Measure bounds based only on normal state so that bounds updates are not always required on state changes.
// This is a trade-off for functionality vs performance, but changing the size of UI controls on hover/focus/etc
// is a pretty bad practice so we'll prioritize performance here.
if (_autoSize & AUTO_SIZE_WIDTH)
{
float w, h;
_font->measureText(_text.c_str(), getFontSize(NORMAL), getTextDrawingFlags(NORMAL), &w, &h, getCharacterSpacing(NORMAL), getLineSpacing(NORMAL));
setWidthInternal(ceilf(w + getBorder(NORMAL).left + getBorder(NORMAL).right + getPadding().left + getPadding().right));
if (_autoSize & AUTO_SIZE_HEIGHT)
setHeightInternal(ceilf(h + getBorder(NORMAL).top + getBorder(NORMAL).bottom + getPadding().top + getPadding().bottom));
}
else // _autoSize & AUTO_SIZE_HEIGHT
{
GP_ASSERT(_autoSize & AUTO_SIZE_HEIGHT);
// recalculate height due to word wrapping
float h = getFontSize(NORMAL);
if (_textBounds.width > 0.0f)
{
gameplay::Rectangle clipBounds(_textBounds.width, FLT_MAX);
gameplay::Rectangle out;
_font->measureText(_text.c_str(), clipBounds, getFontSize(NORMAL), getTextDrawingFlags(NORMAL), &out, getTextAlignment(NORMAL),
true, true, getCharacterSpacing(NORMAL), getLineSpacing(NORMAL));
h = out.height;
}
setHeightInternal(ceilf(h + getBorder(NORMAL).top + getBorder(NORMAL).bottom + getPadding().top + getPadding().bottom));
}
}
Control::updateBounds();
}
//------------------------------------------------------------------------------
// 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;
}
}
}
/*************************************************************************
Renders text on the display. Return number of lines output.
*************************************************************************/
size_t Font::drawText(const String& text, const Rect& draw_area, float z, const Rect& clip_rect, TextFormatting fmt, const ColourRect& colours, float x_scale, float y_scale)
{
size_t thisCount;
size_t lineCount = 0;
float y_base = draw_area.d_top + getBaseline(y_scale);
Rect tmpDrawArea(
PixelAligned(draw_area.d_left),
PixelAligned(draw_area.d_top),
PixelAligned(draw_area.d_right),
PixelAligned(draw_area.d_bottom)
);
size_t lineStart = 0, lineEnd = 0;
String currLine;
while (lineEnd < text.length())
{
if ((lineEnd = text.find_first_of('\n', lineStart)) == String::npos)
lineEnd = text.length();
currLine = text.substr(lineStart, lineEnd - lineStart);
lineStart = lineEnd + 1; // +1 to skip \n char
switch(fmt)
{
case LeftAligned:
drawTextLine(currLine, Vector3(tmpDrawArea.d_left, y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case RightAligned:
drawTextLine(currLine, Vector3(tmpDrawArea.d_right - getTextExtent(currLine, x_scale), y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case Centred:
drawTextLine(currLine, Vector3(PixelAligned(tmpDrawArea.d_left + ((tmpDrawArea.getWidth() - getTextExtent(currLine, x_scale)) / 2.0f)), y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case Justified:
// new function in order to keep drawTextLine's signature unchanged
drawTextLineJustified(currLine, draw_area, Vector3(tmpDrawArea.d_left, y_base, z), clip_rect, colours, x_scale, y_scale);
thisCount = 1;
y_base += getLineSpacing(y_scale);
break;
case WordWrapLeftAligned:
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, LeftAligned, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
case WordWrapRightAligned:
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, RightAligned, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
case WordWrapCentred:
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, Centred, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
case WordWrapJustified:
// no change needed
thisCount = drawWrappedText(currLine, tmpDrawArea, z, clip_rect, Justified, colours, x_scale, y_scale);
tmpDrawArea.d_top += thisCount * getLineSpacing(y_scale);
break;
default:
throw InvalidRequestException("Font::drawText - Unknown or unsupported TextFormatting value specified.");
}
lineCount += thisCount;
}
// should not return 0
return ceguimax(lineCount, (size_t)1);
}
