Console working.

Added quit command. Fixed bug in bufferString segfaulting with too big strings.

include/Console.h

 #ifndef _CONSOLE_H_
 #define _CONSOLE_H_
 
+#include <cstring>
+#include <vector>
+
 #include "Window.h"
 
 /*!
 
     bool isVisible();
 
+    void print(const char *s, ...) __attribute__((format(printf, 2, 3)));
+
     void display();
 
     void handleKeyboard(KeyboardButton key, bool pressed);
 private:
 
     bool mVisible;
+    char *mInputBuffer;
+    size_t mInputBufferPointer;
+    char *mPartialInput;
+    std::vector<char *> mHistory;
 };
 
 #endif

src/Console.cpp

 #include "config.h"
 #include "Console.h"
 #include "main.h"
+#include "utils/strings.h"
 #include "utils/time.h"
 
+#define INPUT_BUFFER_SIZE 255
+
 Console::Console() {
     mVisible = false;
+    mInputBuffer = new char[INPUT_BUFFER_SIZE + 1];
+    mInputBuffer[INPUT_BUFFER_SIZE] = '\0';
+    mInputBufferPointer = 0;
+    mPartialInput = NULL;
 }
 
 Console::~Console() {
+    if (mInputBuffer)
+        delete [] mInputBuffer;
+
+    if (mPartialInput)
+        delete [] mPartialInput;
+
+    while (mHistory.size() > 0) {
+        char *tmp = mHistory.back();
+        if (tmp != NULL)
+            delete [] tmp;
+        mHistory.pop_back();
+    }
 }
 
 void Console::setVisible(bool visible) {
     return mVisible;
 }
 
+void Console::print(const char *s, ...) {
+    va_list args;
+    va_start(args, s);
+    char *tmp = bufferString(s, args);
+    va_end(args);
+
+    if (tmp != NULL) {
+        mHistory.push_back(tmp);
+        printf("%s\n", tmp);
+    }
+}
+
 void Console::display() {
     Window *window = gOpenRaider->mWindow;
     unsigned char color[4] = {0xFF, 0xFF, 0xFF, 0xFF};
 
     if (mVisible) {
+        // Calculate line drawing geometry
+        // Depends on window height, so recalculate every time
+        unsigned int firstLine = 35;
+        unsigned int lastLine = (window->mHeight / 2) - 55;
+        unsigned int inputLine = (window->mHeight / 2) - 30;
+        unsigned int lineSteps = 20;
+        unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
+        while (((lineCount * lineSteps) + firstLine) < inputLine) {
+            lineSteps++;
+            lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
+        }
+
         // Draw half-transparent *overlay*
         glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
         glDisable(GL_TEXTURE_2D);
         glRecti(0, 0, window->mWidth, window->mHeight / 2);
         glEnable(GL_TEXTURE_2D);
 
-        gOpenRaider->mWindow->drawText(10, 10, 0.50f, color, "%lus uptime %s", systemTimerGet() / 1000, VERSION);
+        gOpenRaider->mWindow->drawText(10, 10, 0.70f, color, "%s uptime %lus", VERSION, systemTimerGet() / 1000);
+
+        // Draw output log
+        int end = lineCount;
+        int drawOffset = 0;
+        int historyOffset = 0;
+        if (mHistory.size() < lineCount) {
+            end = mHistory.size();
+            drawOffset = lineCount - mHistory.size();
+        } else if (lineCount < mHistory.size()) {
+            historyOffset = mHistory.size() - lineCount;
+        }
+        for (int i = 0; i < end; i++) {
+            gOpenRaider->mWindow->drawText(10, ((i + drawOffset) * lineSteps) + firstLine,
+                    0.75f, color, "%s", mHistory[i + historyOffset]);
+        }
+
+        // Draw current input
+        if ((mInputBufferPointer > 0) && (mInputBuffer[0] != '\0')) {
+            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, color, "> %s", mInputBuffer);
+        } else {
+            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, color, ">");
+        }
+
+        //! \todo display the current mPartialInput. The UTF-8 segfaults SDL-TTF, somehow?
     }
 }
 
 void Console::handleKeyboard(KeyboardButton key, bool pressed) {
     if (pressed && (key == enter)) {
+        // Execute entered command
+        if ((mInputBufferPointer > 0) && (mInputBuffer[0] != '\0')) {
+            mHistory.push_back(bufferString("> %s", mInputBuffer));
+            gOpenRaider->command(mInputBuffer);
+        }
+
+        // Clear partial and input buffer
+        mInputBufferPointer = 0;
+        mInputBuffer[0] = '\0';
+        if (mPartialInput != NULL) {
+            delete [] mPartialInput;
+            mPartialInput = NULL;
+        }
+    }
 
+    //! \fixme only deleting the last byte is not valid for non-ASCII UTF-8 strings
+    if (pressed && (key == backspace)) {
+        if (mInputBufferPointer > 0) {
+            mInputBufferPointer--;
+            mInputBuffer[mInputBufferPointer] = '\0';
+        }
     }
 }
 
 void Console::handleText(char *text, bool notFinished) {
-    printf("Got %s (%s)\n", text, (notFinished ? "not finished" : "finished"));
+    //printf("Text: %s (%s)\n", text, (notFinished ? "not finished" : "finished"));
+
+    if (!notFinished) {
+        // Finished entering character
+        // delete previous partial character, if present
+        if (mPartialInput != NULL) {
+            delete [] mPartialInput;
+        }
+
+        //! \fixme Temporary hack filtering the console activation key
+        if (text[0] == '`')
+            return;
+
+        // Append new input to buffer
+        size_t length = strlen(text);
+        if (length > 0) {
+            if (((INPUT_BUFFER_SIZE - mInputBufferPointer) < length)) {
+                printf("Console input buffer overflowed! (> %d)\n", INPUT_BUFFER_SIZE);
+                return;
+            }
+            strcpy((mInputBuffer + mInputBufferPointer), text);
+            mInputBufferPointer += length;
+            mInputBuffer[mInputBufferPointer] = '\0';
+        }
+    } else {
+        // Partial character received
+        mPartialInput = bufferString("%s", text);
+    }
 }
 

src/OpenRaider.cpp

     assert(config[0] != '\0');
 
     char *configFile = fullPath(config, 0);
-    printf("Loading config from \"%s\"...\n", configFile);
+    mConsole->print("Loading config from \"%s\"...", configFile);
 
     FILE *f = fopen(configFile, "r");
     if (f == NULL) {
-        printf("Could not open file!\n");
+        mConsole->print("Could not open file!");
         return -1;
     }
 
 
     if (strcmp(command, "set") == 0) {
         if (args->size() != 2) {
-            printf("Invalid use of set-command ");
+            mConsole->print("Invalid use of set-command ");
             printStringVector(args);
             printf("\n");
             return -2;
         }
     } else if (strcmp(command, "bind") == 0) {
         if (args->size() != 2) {
-            printf("Invalid use of bind-command ");
+            mConsole->print("Invalid use of bind-command ");
             printStringVector(args);
             printf("\n");
             return -3;
         } else {
             return bind(args->at(0), args->at(1));
         }
+    } else if (strcmp(command, "quit") == 0) {
+        exit(0);
     } else {
-        printf("Unknown command: %s ", command);
+        mConsole->print("Unknown command: %s ", command);
         printStringVector(args);
         printf("\n");
         return -1;
         // value has format like "\"1024x768\""
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
         if (sscanf(value, "\"%dx%d\"", &w, &h) != 2) {
-            printf("set-size-Error: Invalid value (%s)\n", value);
+            mConsole->print("set-size-Error: Invalid value (%s)", value);
             return -2;
         }
         mWindow->setSize(w, h);
     } else if (strcmp(var, "fullscreen") == 0) {
         bool fullscreen = false;
         if (readBool(value, &fullscreen) != 0) {
-            printf("set-fullscreen-Error: Invalid value (%s)\n", value);
+            mConsole->print("set-fullscreen-Error: Invalid value (%s)", value);
             return -3;
         }
         mWindow->setFullscreen(fullscreen);
     } else if (strcmp(var, "audio") == 0) {
         bool audio = false;
         if (readBool(value, &audio) != 0) {
-            printf("set-audio-Error: Invalid value (%s)\n", value);
+            mConsole->print("set-audio-Error: Invalid value (%s)", value);
             return -4;
         }
         mSound->setEnabled(audio);
     } else if (strcmp(var, "volume") == 0) {
         float vol = 1.0f;
         if (sscanf(value, "%f", &vol) != 1) {
-            printf("set-volume-Error: Invalid value (%s)\n", value);
+            mConsole->print("set-volume-Error: Invalid value (%s)", value);
             return -5;
         }
         mSound->setVolume(vol);
     } else if (strcmp(var, "mouse_x") == 0) {
         float sense = 1.0f;
         if (sscanf(value, "%f", &sense) != 1) {
-            printf("set-mouse_x-Error: Invalid value (%s)\n", value);
+            mConsole->print("set-mouse_x-Error: Invalid value (%s)", value);
             return -6;
         }
         //! \todo mouse support
     } else if (strcmp(var, "mouse_y") == 0) {
         float sense = 1.0f;
         if (sscanf(value, "%f", &sense) != 1) {
-            printf("set-mouse_y-Error: Invalid value (%s)\n", value);
+            mConsole->print("set-mouse_y-Error: Invalid value (%s)", value);
             return -7;
         }
         //! \todo mouse support
         }
         delete [] quotes;
     } else {
-        printf("set-Error: Unknown variable (%s = %s)\n", var, value);
+        mConsole->print("set-Error: Unknown variable (%s = %s)", var, value);
         return -1;
     }
 
     } else if (strcmp(tmp, "holster") == 0) {
         return bind(holster, key);
     } else {
-        printf("bind-Error: Unknown action (%s --> %s)\n", key, action);
+        mConsole->print("bind-Error: Unknown action (%s --> %s)", key, action);
         return -1;
     }
 }
             || ((c >= 'a') && (c <= 'z'))) {
             keyBindings[action] = (KeyboardButton)c;
         } else {
-            printf("bind-\'\'-Error: Unknown key (%s)\n", key);
+            mConsole->print("bind-\'\'-Error: Unknown key (%s)", key);
             return -1;
         }
     } else if ((key[0] == '\"') && (key[length - 1] == '\"')) {
         } else if (strcmp(tmp, "tab") == 0) {
             keyBindings[action] = tab;
         } else {
-            printf("bind-\"\"-Error: Unknown key (%s)\n", key);
+            mConsole->print("bind-\"\"-Error: Unknown key (%s)", key);
             delete [] tmp;
             return -2;
         }
         delete [] tmp;
     } else {
-        printf("bind-Error: Unknown key (%s)\n", key);
+        mConsole->print("bind-Error: Unknown key (%s)", key);
         return -3;
     }
     return 0;
                      || stringEndsWith(lowerPath, ".tr4")
                      || stringEndsWith(lowerPath, ".trc")) {
                     //if (m_tombraider.checkMime(fullPathMap) == 0) {
-                        // printf("Validated pak: '%s'\n", fullPathMap);
+                        // mConsole->print("Validated pak: '%s'", fullPathMap);
 
                         // Just load relative filename
                         mMapList.push_back(bufferString("%s", (fullPathMap + strlen(mPakDir))));
                     //} else {
-                    //    printf("ERROR: pak file '%s' not found or invalid\n", fullPathMap);
+                    //    mConsole->print("ERROR: pak file '%s' not found or invalid", fullPathMap);
                     //}
                 }
 
         }
         closedir(pakDir);
     } else {
-        printf("Could not open PAK dir %s!\n", dir);
+        mConsole->print("Could not open PAK dir %s!", dir);
     }
 }
 

src/main.cpp

 
     // Create globals
     atexit(cleanupHandler);
-    printf("Initializing " VERSION "\n");
+    printf("Initializing %s", VERSION);
     gOpenRaider = new OpenRaider();
 
     // Try to load a configuration
     gOpenRaider->initialize();
 
     // Enter Main loop
-    printf("Starting " VERSION "\n");
+    gOpenRaider->mConsole->print("Starting %s", VERSION);
     gOpenRaider->run();
 
     return 0;

src/utils/strings.cpp

     int sz = 60;
     int n;
     char *text;
+    va_list tmp;
 
     assert(string != NULL);
     assert(string[0] != '\0');
 
     text = new char[sz];
 
-    n = vsnprintf(text, sz, string, args);
+    va_copy(tmp, args);
+    n = vsnprintf(text, sz, string, tmp);
+    va_end(tmp);
 
     if (n < 0) {
         delete [] text;
     } else if (n >= sz) {
         sz = n + 1; // buffer too small
         delete [] text;
-        text = new char[sz];
-        n = vsnprintf(text, sz, string, args);
+        text = new char[sz + 1];
+        va_copy(tmp, args);
+        n = vsnprintf(text, sz, string, tmp);
+        va_end(tmp);
     }
 
     return text;
     // Make sure ends in "end" char
     if ((lenPath > 0) && (end != 0) && (dir[lenPath - 1] != end)) {
         dir[lenPath] = end;
-        dir[lenPath + 1] = 0;
+        dir[lenPath + 1] = '\0';
     } else {
-        dir[lenPath] = 0;
+        dir[lenPath] = '\0';
     }
 
     return dir;