Wrapped Text Rendering. Menu dialogs.

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140811 ]
+    * New Font API, allows drawing strings with line-wrapping
+    * Added ability to Menu to show info dialogs
+
     [ 20140810 ]
     * Removed recursive Folder access method implementations
       into their own file

include/Font.h

 #ifndef _FONT_H_
 #define _FONT_H_
 
-typedef struct {
-    char *text;
-    unsigned int x;
-    unsigned int y;
-    int w;
-    int h;
-    float scale;
-    unsigned char color[4];
-} FontString;
+#include  <string>
 
 /*!
  * \brief Font interface
 
     virtual int initialize() = 0;
 
-    virtual void writeString(FontString &s) = 0;
+    virtual unsigned int widthText(float scale, std::string s) = 0;
 
     virtual void drawText(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], const char *s, ...)
-            __attribute__((format(printf, 6, 0)));
+            const unsigned char color[4], std::string s) = 0;
 
+    virtual unsigned int heightText(float scale, unsigned int maxWidth, std::string s) = 0;
+
+    virtual void drawTextWrapped(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], unsigned int maxWidth, std::string s) = 0;
+
+    // Implemented in Font.cpp using widthText & drawText
     virtual void drawTextCentered(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], unsigned int width, const char *s, ...)
-            __attribute__((format(printf, 7, 0)));
+            const unsigned char color[4], unsigned int width, std::string s);
 
 protected:
     bool mFontInit;

include/FontManager.h

 
     virtual int initialize();
 
-    virtual void writeString(FontString &s);
+    virtual unsigned int widthText(float scale, std::string s);
+
+    virtual void drawText(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], std::string s);
+
+    virtual unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
+
+    virtual void drawTextWrapped(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], unsigned int maxWidth, std::string s);
 
 private:
 

include/FontSDL.h

 
     virtual int initialize();
 
-    virtual void writeString(FontString &s);
+    virtual unsigned int widthText(float scale, std::string s);
+
+    virtual void drawText(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], std::string s);
+
+    virtual unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
+
+    virtual void drawTextWrapped(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], unsigned int maxWidth, std::string s);
 
 private:
     TTF_Font *mFont;

include/FontTRLE.h

 
     virtual int initialize();
 
-    virtual void writeString(FontString &s);
+    virtual unsigned int widthText(float scale, std::string s);
+
+    virtual void drawText(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], std::string s);
+
+    virtual unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
+
+    virtual void drawTextWrapped(unsigned int x, unsigned int y, float scale,
+            const unsigned char color[4], unsigned int maxWidth, std::string s);
 
 private:
 
     void loadLPS(const char *f);
-    void writeChar(unsigned int index, unsigned int xDraw, FontString &s);
+    void writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw,
+            float scale, const unsigned char color[4]);
 
     unsigned int mFontTexture;
 

include/Menu.h

 #ifndef _MENU_H_
 #define _MENU_H_
 
+#include <functional>
 #include <memory>
 
 #include "utils/Folder.h"
 
 private:
 
-    void play();
+    void loadOrOpen();
+    void showDialog(std::string msg, std::string btn1, std::string btn2,
+            std::function<int (bool state)> callback = std::function<int (bool)>());
+    void ackDialog();
+    void displayDialog();
 
     bool mVisible;
     long mCursor;
 
     Folder *mapFolder;
     bool hiddenState;
+
+    std::string dialogText;
+    std::string dialogButton1;
+    std::string dialogButton2;
+    bool dialogState;
+    std::function<int (bool state)> dialogFunction;
 };
 
 Menu &getMenu();

src/Console.cpp

     }
 
     // Draw status line
-    getFont().drawText(10, 10, 0.70f, BLUE,
-            "%s uptime %lus scroll %d%%", VERSION, systemTimerGet() / 1000, scrollIndicator);
+    std::ostringstream status;
+    status << VERSION << " uptime " << (systemTimerGet() / 1000) << "s scroll " << scrollIndicator << "%";
+    getFont().drawText(10, 10, 0.70f, BLUE, status.str());
 
     // Draw output log
     long end = lineCount;
 
     for (int i = 0; i < end; i++) {
         getFont().drawText(10, (unsigned int)((i + drawOffset) * lineSteps) + firstLine,
-                0.75f, BLUE, "%s", mHistory[i + historyOffset - mLineOffset].c_str());
+                0.75f, BLUE, mHistory.at(i + historyOffset - mLineOffset));
     }
 
     // Draw current input
-    getFont().drawText(10, inputLine, 0.75f, BLUE, "> %s", (mInputBuffer + mPartialInput).c_str());
+    getFont().drawText(10, inputLine, 0.75f, BLUE, "> " + mInputBuffer + mPartialInput);
 }
 
 void Console::handleKeyboard(KeyboardButton key, bool pressed) {

src/Font.cpp

  * \author xythobuz
  */
 
-#include <stdio.h>
-#include <stdarg.h>
-
 #include "global.h"
 #include "utils/strings.h"
 #include "Window.h"
     mFontName = fullPath(font, 0);
 }
 
-void Font::drawText(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], const char *s, ...) {
-    FontString tempText;
-    va_list args;
-    va_start(args, s);
-
-    tempText.text = new char[256];
-    tempText.scale = scale;
-    tempText.w = 0;
-    tempText.h = 0;
-    tempText.x = x;
-    tempText.y = y;
-    tempText.color[0] = color[0];
-    tempText.color[1] = color[1];
-    tempText.color[2] = color[2];
-    tempText.color[3] = color[3];
-
-    vsnprintf(tempText.text, 256, s, args);
-    tempText.text[255] = '\0';
-    writeString(tempText);
-
-    delete [] tempText.text;
-    va_end(args);
-}
-
 void Font::drawTextCentered(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], unsigned int width, const char *s, ...) {
-    FontString tempText;
-    va_list args;
-    va_start(args, s);
-
-    tempText.text = new char[256];
-    tempText.scale = scale;
-    tempText.w = 0;
-    tempText.h = 0;
-    tempText.x = x;
-    tempText.y = y + getWindow().getHeight(); //! \fixme Ugly hack to hide first draw
-    tempText.color[0] = color[0];
-    tempText.color[1] = color[1];
-    tempText.color[2] = color[2];
-    tempText.color[3] = color[3];
-
-    vsnprintf(tempText.text, 256, s, args);
-    tempText.text[255] = '\0';
-    writeString(tempText);
-
-    tempText.x = (width / 2) - ((unsigned int)(tempText.w / 2));
-    tempText.y = y;
-    writeString(tempText);
-
-    delete [] tempText.text;
-    va_end(args);
+        const unsigned char color[4], unsigned int width, std::string s) {
+    drawText(x + ((width / 2) - (widthText(scale, s) / 2)), y, scale, color, s);
 }
 

src/FontManager.cpp

     return fonts.at(font)->initialize();
 }
 
-void FontManager::writeString(FontString &s) {
+unsigned int FontManager::widthText(float scale, std::string s) {
     assert(font != -1);
-    fonts.at(font)->writeString(s);
+    return fonts.at(font)->widthText(scale, s);
+}
+
+void FontManager::drawText(unsigned int x, unsigned int y, float scale,
+        const unsigned char color[4], std::string s) {
+    assert(font != -1);
+    fonts.at(font)->drawText(x, y, scale, color, s);
+}
+
+unsigned int FontManager::heightText(float scale, unsigned int maxWidth, std::string s) {
+    assert(font != -1);
+    return fonts.at(font)->heightText(scale, maxWidth, s);
+}
+
+void FontManager::drawTextWrapped(unsigned int x, unsigned int y, float scale,
+        const unsigned char color[4], unsigned int maxWidth, std::string s) {
+    assert(font != -1);
+    fonts.at(font)->drawTextWrapped(x, y, scale, color, maxWidth, s);
 }
 

src/FontSDL.cpp

     return 0;
 }
 
-void FontSDL::writeString(FontString &s) {
+unsigned int FontSDL::widthText(float scale, std::string s) {
     assert(mFontInit == true);
-    assert(s.text != NULL);
 
-    SDL_Color color;
-    color.r = s.color[0];
-    color.g = s.color[1];
-    color.b = s.color[2];
-    color.a = s.color[3];
+    int w;
+    if (TTF_SizeUTF8(mFont, s.c_str(), &w, NULL) != 0) {
+        printf("TTF_SizeUTF8 Error: %s\n", TTF_GetError());
+        return s.length() * 15 * scale;
+    }
+    return w * scale;
+}
+
+void FontSDL::drawText(unsigned int x, unsigned int y, float scale,
+        const unsigned char color[4], std::string s) {
+    assert(mFontInit == true);
+    assert(s.length() > 0);
 
-    SDL_Surface *surface = TTF_RenderUTF8_Blended(mFont, s.text, color);
+    SDL_Color col;
+    col.r = color[0];
+    col.g = color[1];
+    col.b = color[2];
+    col.a = color[3];
+
+    SDL_Surface *surface = TTF_RenderUTF8_Blended(mFont, s.c_str(), col);
     if (surface == NULL) {
         printf("TTF_RenderUTF8_Blended Error: %s\n", TTF_GetError());
         return;
     }
 
-    s.w = (int)((float)surface->w * s.scale);
-    s.h = (int)((float)surface->h * s.scale);
+    int w = (int)((float)surface->w * scale);
+    int h = (int)((float)surface->h * scale);
+
+    GLenum textureFormat;
+    if (surface->format->BytesPerPixel == 4) {
+        if (surface->format->Rmask == 0x000000FF)
+            textureFormat = GL_RGBA;
+        else
+            textureFormat = GL_BGRA_EXT;
+    } else {
+        if (surface->format->Rmask == 0x000000FF)
+            textureFormat = GL_RGB;
+        else
+            textureFormat = GL_BGR_EXT;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, mFontTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0, textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
+    SDL_FreeSurface(surface);
+
+    GLuint xMin = x;
+    GLuint yMin = y;
+    GLuint xMax = xMin + w;
+    GLuint yMax = yMin + h;
+
+    glColor4ubv(color);
+
+    glBegin(GL_QUADS);
+    glTexCoord2f(0.0f, 0.0f);
+    glVertex2i(xMin, yMin);
+
+    glTexCoord2f(0.0f, 1.0f);
+    glVertex2i(xMin, yMax);
+
+    glTexCoord2f(1.0f, 1.0f);
+    glVertex2i(xMax, yMax);
+
+    glTexCoord2f(1.0f, 0.0f);
+    glVertex2i(xMax, yMin);
+    glEnd();
+}
+
+unsigned int FontSDL::heightText(float scale, unsigned int maxWidth, std::string s) {
+    assert(mFontInit == true);
+    assert(s.length() > 0);
+    assert(maxWidth > 0);
+
+    SDL_Color col;
+    SDL_Surface *surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
+    if (surface == NULL) {
+        printf("TTF_RenderUTF8_Blended_Wrapped Error: %s\n", TTF_GetError());
+        return 0;
+    }
+    int h = surface->h * scale;
+    SDL_FreeSurface(surface);
+    return h;
+}
+
+void FontSDL::drawTextWrapped(unsigned int x, unsigned int y, float scale,
+        const unsigned char color[4], unsigned int maxWidth, std::string s) {
+    assert(mFontInit == true);
+    assert(s.length() > 0);
+    assert(maxWidth > 0);
+
+    SDL_Color col;
+    col.r = color[0];
+    col.g = color[1];
+    col.b = color[2];
+    col.a = color[3];
+
+    SDL_Surface *surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
+    if (surface == NULL) {
+        printf("TTF_RenderUTF8_Blended_Wrapped Error: %s\n", TTF_GetError());
+        return;
+    }
+
+    int w = (int)((float)surface->w * scale);
+    int h = (int)((float)surface->h * scale);
 
     GLenum textureFormat;
     if (surface->format->BytesPerPixel == 4) {
     glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0, textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
     SDL_FreeSurface(surface);
 
-    GLuint xMin = s.x;
-    GLuint yMin = s.y;
-    GLuint xMax = xMin + s.w;
-    GLuint yMax = yMin + s.h;
+    GLuint xMin = x;
+    GLuint yMin = y;
+    GLuint xMax = xMin + w;
+    GLuint yMax = yMin + h;
 
-    glColor4ubv(s.color);
+    glColor4ubv(color);
 
     glBegin(GL_QUADS);
     glTexCoord2f(0.0f, 0.0f);

src/FontTRLE.cpp

 
 #define SCALING 2.0f
 
-void FontTRLE::writeChar(unsigned int index, unsigned int xDraw, FontString &s) {
-    int width = (int)(((float)offsets[index][2]) * s.scale * SCALING);
-    int height = (int)(((float)offsets[index][3]) * s.scale * SCALING);
-    int offset = (int)(((float)offsets[index][4]) * s.scale * SCALING);
+void FontTRLE::writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw,
+        float scale, const unsigned char color[4]) {
+    assert(mFontInit == true);
+
+    int width = (int)(((float)offsets[index][2]) * scale * SCALING);
+    int height = (int)(((float)offsets[index][3]) * scale * SCALING);
+    int offset = (int)(((float)offsets[index][4]) * scale * SCALING);
 
     // screen coordinates
     int xMin = xDraw;
-    int yMin = s.y + offset + (int)(10.0f * s.scale * SCALING);
+    int yMin = ((int)yDraw) + offset + (int)(10.0f * scale * SCALING);
     int xMax = xMin + width;
     int yMax = yMin + height;
 
 
     // draw
     glBindTexture(GL_TEXTURE_2D, mFontTexture);
-    glColor4f(s.color[0] * 256.0f, s.color[1] * 256.0f, s.color[2] * 256.0f, s.color[3] * 256.0f);
+    glColor4f(color[0] * 256.0f, color[1] * 256.0f, color[2] * 256.0f, color[3] * 256.0f);
     glBegin(GL_QUADS);
     glTexCoord2f(txMin, tyMin);
     glVertex2i(xMin, yMin);
     glEnd();
 }
 
-void FontTRLE::writeString(FontString &s) {
+unsigned int FontTRLE::widthText(float scale, std::string s) {
+    assert(mFontInit == true);
+    assert(s.length() > 0);
+
+    unsigned int width = 0;
+    for (unsigned int i = 0; i < s.length(); i++) {
+        // index into offset table
+        int index = s[i] - '!';
+
+        if (index == -1) // space
+            width += (unsigned int)(14.0f * scale * SCALING);
+
+        if ((index < 0) || (index > 105))
+            continue; // skip unprintable chars
+
+        width += (float)(offsets[index][2] + 1) * scale * SCALING; // glyph width
+    }
+
+    return width;
+}
+
+void FontTRLE::drawText(unsigned int x, unsigned int y, float scale,
+        const unsigned char color[4], std::string s) {
+    assert(mFontInit == true);
+    assert(s.length() > 0);
+
+    for (unsigned int i = 0; i < s.length(); i++) {
+        // index into offset table
+        int index = s[i] - '!';
+
+        if (index == -1) // space
+            x += (unsigned int)(14.0f * scale * SCALING);
+
+        if ((index < 0) || (index > 105))
+            continue; // skip unprintable chars
+
+        writeChar((unsigned int)index, x, y, scale, color);
+        x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
+    }
+}
+
+unsigned int FontTRLE::heightText(float scale, unsigned int maxWidth, std::string s) {
     assert(mFontInit == true);
-    assert(s.text != NULL);
+    assert(s.length() > 0);
 
-    unsigned int x = s.x;
-    unsigned int y = 0;
+    unsigned int x = 0;
+    unsigned int yMax = 0;
+    unsigned int yReturn = 0;
 
-    for (unsigned int i = 0; s.text[i] != '\0'; i++) {
+    for (unsigned int i = 0; i < s.length(); i++) {
         // index into offset table
-        int index = s.text[i] - '!';
+        int index = s[i] - '!';
 
         if (index == -1) // space
-            x += (unsigned int)(14.0f * s.scale * SCALING);
+            x += (unsigned int)(14.0f * scale * SCALING);
 
         if ((index < 0) || (index > 105))
             continue; // skip unprintable chars
 
-        writeChar((unsigned int)index, x, s);
-        x += (int)((float)(offsets[index][2] + 1) * s.scale * SCALING); // width
+        if (yMax < (unsigned int)(((float)offsets[index][3]) * scale * SCALING))
+            yMax = (unsigned int)(((float)offsets[index][3]) * scale * SCALING);
 
-        if (y < (unsigned int)(((float)offsets[index][3]) * s.scale * SCALING))
-            y = (unsigned int)(((float)offsets[index][3]) * s.scale * SCALING);
+        x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
+        if (x > maxWidth) {
+            // go to the next line
+            yReturn += yMax + 2;
+            yMax = 0;
+            x = (int)((float)(offsets[index][2] + 1) * scale * SCALING);
+        }
     }
 
-    s.w = x - s.x;
-    s.h = y;
+    return yReturn + yMax + 2;
+}
+
+void FontTRLE::drawTextWrapped(unsigned int x, unsigned int y, float scale,
+        const unsigned char color[4], unsigned int maxWidth, std::string s) {
+    assert(mFontInit == true);
+    assert(s.length() > 0);
+
+    unsigned int xStart = x;
+    unsigned int yMax = 0;
+
+    for (unsigned int i = 0; i < s.length(); i++) {
+        // index into offset table
+        int index = s[i] - '!';
+
+        if (index == -1) // space
+            x += (unsigned int)(14.0f * scale * SCALING);
+
+        if ((index < 0) || (index > 105))
+            continue; // skip unprintable chars
+
+        if (yMax < (unsigned int)(((float)offsets[index][3]) * scale * SCALING))
+            yMax = (unsigned int)(((float)offsets[index][3]) * scale * SCALING);
+
+        x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
+        if ((x - xStart) > maxWidth) {
+            // go to the next line
+            y += yMax + 2;
+            yMax = 0;
+            x = xStart;
+        } else {
+            x -= (int)((float)(offsets[index][2] + 1) * scale * SCALING);
+        }
+
+        writeChar((unsigned int)index, x, y, scale, color);
+        x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
+    }
 }
 

src/Menu.cpp

     mMin = 0;
     mapFolder = nullptr;
     hiddenState = false;
+    dialogState = false;
 }
 
 Menu::~Menu() {
     if (!mVisible)
         return;
 
-    // Draw half-transparent *overlay*
+    // Draw half-transparent overlay
     glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
     glDisable(GL_TEXTURE_2D);
     glRecti(0, 0, (GLint)getWindow().getWidth(), (GLint)getWindow().getHeight());
     glEnable(GL_TEXTURE_2D);
 
     // Draw heading
-    getFont().drawTextCentered(0, 10, 1.2f, BLUE, getWindow().getWidth(), "%s", VERSION);
+    getFont().drawTextCentered(0, 10, 1.2f, BLUE, getWindow().getWidth(), VERSION);
 
     // Estimate displayable number of items
     int items = (getWindow().getHeight() - 60) / 25;
             getFont().drawText(25, 50, 0.75f, (mCursor == i) ? RED : BLUE, "..");
         } else {
             getFont().drawText(25, (unsigned int)(50 + (25 * (i - mMin))), 0.75f,
-                (mCursor == i) ? RED : BLUE, "%s",
+                (mCursor == i) ? RED : BLUE,
                 ((i - 1) < mapFolder->folderCount()) ?
-                    (mapFolder->getFolder(i - 1).getName() + "/").c_str()
-                    : mapFolder->getFile(i - 1 - mapFolder->folderCount()).getName().c_str());
+                    (mapFolder->getFolder(i - 1).getName() + "/")
+                    : mapFolder->getFile(i - 1 - mapFolder->folderCount()).getName());
         }
     }
+
+    displayDialog();
 }
 
-void Menu::play() {
+void Menu::loadOrOpen() {
     if (mCursor == 0) {
         if (initialize(mapFolder->getParent().getPath()) != 0) {
-            //! \todo Display something if an error occurs
+            showDialog("Error reading parent folder!", "OK", "");
         }
     } else if ((mCursor - 1) < mapFolder->folderCount()) {
         if (initialize(mapFolder->getFolder(mCursor - 1).getPath()) != 0) {
-            //! \todo Display something if an error occurs
+            showDialog("Error reading subfolder!", "OK", "");
         }
     } else {
         std::string tmp = "load ";
         if (getOpenRaider().command(tmp.c_str()) == 0) {
             setVisible(false);
         } else {
-            //! \todo Display something if an error occurs
+            showDialog("Error loading map!", "OK", "");
         }
     }
 }
     if (!pressed)
         return;
 
+    if (dialogText.length() > 0) {
+        if (dialogButton2.length() == 0) {
+            if (key == enterKey) {
+                ackDialog();
+            }
+        } else {
+            if (key == enterKey) {
+                ackDialog();
+            } else if (key == leftKey) {
+                dialogState = !dialogState;
+            } else if (key == rightKey) {
+                dialogState = !dialogState;
+            } else if (key == upKey) {
+                dialogState = !dialogState;
+            } else if (key == downKey) {
+                dialogState = !dialogState;
+            }
+        }
+        return;
+    }
+
     assert(mapFolder != nullptr);
     int items = (getWindow().getHeight() - 60) / 25;
 
         else
             mCursor = 0;
     } else if (key == enterKey) {
-        play();
+        loadOrOpen();
     } else if (key == dotKey) {
         hiddenState = !hiddenState;
         initialize(mapFolder->getPath());
     if (released || (button != leftmouseKey))
         return;
 
-    if ((y >= 50) && (y <= (unsigned int)(50 + (25 * items)))) {
+    if (dialogText.length() > 0) {
+        //!< \todo Allow mouse usage of Menu dialogs!
+        return;
+    }
+
+    if ((y >= 50) && (y <= (unsigned int)(50 + (25 * items)))
+            && ((mMin + (y / 25)) <= (mapFolder->folderCount() + mapFolder->fileCount() + 2))) {
         y -= 50;
         if (mCursor == (mMin + (y / 25)))
-            play();
+            loadOrOpen();
         else
             mCursor = mMin + (y / 25);
     }
 }
 
 void Menu::handleMouseScroll(int xrel, int yrel) {
+    if (dialogText.length() > 0)
+        return;
+
     assert((xrel != 0) || (yrel != 0));
     assert(mapFolder != nullptr);
     int items = (getWindow().getHeight() - 60) / 25;
     }
 }
 
+void Menu::showDialog(std::string msg, std::string btn1, std::string btn2,
+        std::function<int (bool state)> callback) {
+    // Only show one dialog at a time
+    assert(dialogText.length() == 0);
+    assert(dialogButton1.length() == 0);
+    assert(dialogButton2.length() == 0);
+
+    assert(msg.length() > 0);
+    assert(btn1.length() > 0);
+
+    dialogText = msg;
+    dialogButton1 = btn1;
+    dialogButton2 = btn2;
+    dialogState = false;
+    dialogFunction = callback;
+
+    getConsole() << dialogText << Console::endl;
+}
+
+void Menu::ackDialog() {
+    dialogText = "";
+    dialogButton1 = "";
+    dialogButton2 = "";
+
+    if (dialogFunction) {
+        int error = dialogFunction(dialogState);
+        if (error != 0) {
+            showDialog("Error processing dialog callback!", "OK", "");
+        }
+    }
+
+    dialogState = false;
+}
+
+void Menu::displayDialog() {
+    if (dialogText.length() > 0) {
+        unsigned int wMax = ((unsigned int)(getWindow().getWidth() * 0.66f));
+
+        unsigned int w0 = getFont().widthText(1.0f, dialogText) + 20;
+        if (w0 > wMax)
+            w0 = wMax;
+        unsigned int h0 =  getFont().heightText(1.0f, w0, dialogText) + 10;
+
+        assert(dialogButton1.length() > 0);
+        unsigned int w1 = getFont().widthText(1.0f, dialogButton1) + 20;
+        if (w1 > wMax)
+            w1 = wMax;
+        unsigned int h1 = getFont().heightText(1.0f, w1, dialogButton1) + 10;
+
+        unsigned int wOverlay = wMax, hOverlay, w2 = 0, h2 = 0;
+
+        if (dialogButton2.length() > 0) {
+            // Show text and two buttons
+            w2 = getFont().widthText(1.0f, dialogButton2) + 20;
+            if (w2 > wMax)
+                w2 = wMax;
+            h2 = getFont().heightText(1.0f, w2, dialogButton2) + 10;
+
+            if (w0 > (w1 + w2)) {
+                if (w0 < wMax) {
+                    wOverlay = w0;
+                }
+            } else if (w0 < (w1 + w2)) {
+                if ((w1 + w2) < wMax) {
+                    wOverlay = (w1 + w2);
+                }
+            }
+
+            if ((w1 + w2) <= wMax) {
+                hOverlay = h0 + ((h1 + h2) / 2);
+            } else {
+                hOverlay = h0 + h1 + h2;
+            }
+        } else {
+            // Show text and one button
+            if (w0 > w1) {
+                if (w0 < wMax) {
+                    wOverlay = w0;
+                }
+            } else if (w0 < w1) {
+                if (w1 < wMax) {
+                    wOverlay = w1;
+                }
+            }
+
+            hOverlay = h0 + h1;
+        }
+
+        unsigned int xOverlay = (getWindow().getWidth() - wOverlay) / 2;
+        unsigned int yOverlay = (getWindow().getHeight() - hOverlay) / 2;
+
+        glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
+        glDisable(GL_TEXTURE_2D);
+        glRecti(xOverlay, yOverlay, xOverlay + wOverlay, yOverlay + hOverlay);
+        glEnable(GL_TEXTURE_2D);
+
+        getFont().drawTextWrapped(xOverlay + 10, yOverlay + 5, 1.0f, BLUE, w0, dialogText);
+        if (dialogButton2.length() > 0) {
+            if ((w1 + w2) <= wMax) {
+                getFont().drawTextWrapped(xOverlay + 10, yOverlay + 10 + h0, 1.0f,
+                    dialogState ? BLUE : RED, w1, dialogButton1);
+                getFont().drawTextWrapped(xOverlay + 10 + w1, yOverlay + 10 + h0,
+                    1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
+            } else {
+                getFont().drawTextWrapped((getWindow().getWidth() - w1) / 2,
+                    yOverlay + 10 + h0, 1.0f, dialogState ? BLUE : RED, w1, dialogButton1);
+                getFont().drawTextWrapped((getWindow().getWidth() - w2) / 2,
+                    yOverlay + 10 + h0 + h1, 1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
+            }
+        } else {
+            getFont().drawTextWrapped((getWindow().getWidth() - w1) / 2,
+                    yOverlay + 10 + h0, 1.0f, RED, w1, dialogButton1);
+        }
+    }
+}
+

src/OpenRaider.cpp

 
 #include <cstdio>
 #include <cstring>
+#include <sstream>
 
 #include "global.h"
 #include "Console.h"
     getMenu().display();
 
     // Draw FPS counter
-    if (mFPS)
-        getFont().drawText(10, getWindow().getHeight() - 20, 0.5f, BLUE, "%dFPS", fps);
+    if (mFPS) {
+        std::ostringstream fpsText;
+        fpsText << fps << "FPS";
+        getFont().drawText(10, getWindow().getHeight() - 20, 0.5f, BLUE, fpsText.str());
+    }
 
 #ifdef DEBUG
     // Draw debug infos
     if (getGame().isLoaded() && (!getMenu().isVisible())) {
         for (int i = 0; i < 3; i++) {
-            getFont().drawText(10, getWindow().getHeight() - ((4 - i) * 20), 0.5f, BLUE, "%.2f (%.2f)",
-                getGame().getLara().getPos(i) / 256.0f, getGame().getLara().getAngle(i));
+            std::ostringstream axis;
+            axis << getGame().getLara().getPos(i) / 256.0f << " (" << getGame().getLara().getAngle(i) << ")";
+            getFont().drawText(10, getWindow().getHeight() - ((4 - i) * 20), 0.5f, BLUE, axis.str());
         }
     }
 #endif