Created UI windowing interface

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140901 ]
+    * Created abstract UI class handling “windows” like menu and console. Windows
+      can be stacked arbitrarily. The top most gets keyboard/mouse/action events.
+
     [ 20140831 ]
     * Moved command specific code from OpenRaider to static Command methods
 

include/Console.h

 #include <sstream>
 #include <vector>
 
+#include "UI.h"
+
 /*!
  * \brief Console 'overlay'
  */
-class Console {
+class Console : public UI {
 public:
 
-    /*!
-     * \brief Constructs an object of Console
-     */
     Console();
-
-    void setVisible(bool visible);
-
-    bool isVisible();
+    ~Console();
 
     template<typename T>
     Console &operator<<(const T t) {
         return (*this);
     }
 
-    void display();
-
-    void handleKeyboard(KeyboardButton key, bool pressed);
-
-    void handleText(char *text, bool notFinished);
-
-    void handleMouseScroll(int xrel, int yrel);
+    virtual void moveToTop();
+    virtual void makeInvisible();
+    virtual void display();
+    virtual void handleKeyboard(KeyboardButton key, bool pressed);
+    virtual void handleText(char *text, bool notFinished);
+    virtual void handleMouseScroll(int xrel, int yrel);
 
     const static char endl = '\n';
 
 
     void moveInHistory(bool up);
 
-    bool mVisible;
     std::string mInputBuffer;
     std::string mPartialInput;
     std::vector<std::string> mHistory;

include/Game.h

 #include <vector>
 
 #include "Entity.h"
+#include "UI.h"
 #include "TombRaider.h"
 
 /*!
  * \brief Game abstraction
  */
-class Game {
+class Game : public UI {
 public:
 
     Game();
-
     ~Game();
 
     int initialize();
 
     void destroy();
 
-    void handleAction(ActionEvents action, bool isFinished);
-
-    void handleMouseMotion(int xrel, int yrel);
+    virtual void display();
+    virtual void handleAction(ActionEvents action, bool isFinished);
+    virtual void handleMouseMotion(int xrel, int yrel);
+    virtual void moveToTop() { }
+    virtual void makeInvisible() { }
 
     unsigned int getTextureStart();
     unsigned int getTextureOffset();

include/Menu.h

 
 #include <functional>
 
+#include "UI.h"
+
 /*!
  * \brief Menu 'overlay'
  */
-class Menu {
+class Menu : public UI {
 public:
 
     virtual ~Menu() { }
 
-    virtual void setVisible(bool visible);
-
-    virtual bool isVisible();
-
     virtual int initialize() = 0;
 
-    virtual void display() = 0;
-
-    virtual void handleKeyboard(KeyboardButton key, bool pressed) = 0;
-
-    virtual void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) = 0;
-
-    virtual void handleMouseScroll(int xrel, int yrel) = 0;
-
 protected:
 
     virtual void showDialog(std::string msg, std::string btn1, std::string btn2,
 
     virtual void displayDialog();
 
-    bool mVisible;
     bool dialogState;
     std::string dialogText;
     std::string dialogButton1;

include/MenuFolder.h

     virtual int initialize();
 
     virtual void display();
-
     virtual void handleKeyboard(KeyboardButton key, bool pressed);
-
     virtual void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
-
     virtual void handleMouseScroll(int xrel, int yrel);
 
 private:

include/OpenRaider.h

     void run();
     void frame();
 
-    void handleKeyboard(KeyboardButton key, bool pressed);
-    void handleText(char *text, bool notFinished);
-    void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
-    void handleMouseMotion(int xrel, int yrel);
-    void handleMouseScroll(int xrel, int yrel);
-
     //! \fixme should be private
     char *mBaseDir;
     char *mPakDir;

include/UI.h

+/*!
+ * \file include/UI.h
+ * \brief Abstract UI interface
+ *
+ * \author xythobuz
+ */
+
+#ifndef _UI_H_
+#define _UI_H_
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+class UI {
+public:
+    virtual ~UI();
+
+    virtual void display();
+    virtual void handleKeyboard(KeyboardButton key, bool pressed);
+    virtual void handleText(char *text, bool notFinished);
+    virtual void handleAction(ActionEvents action, bool isFinished);
+    virtual void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
+    virtual void handleMouseMotion(int xrel, int yrel);
+    virtual void handleMouseScroll(int xrel, int yrel);
+
+    virtual bool isOnTop();
+    virtual void moveToTop();
+    virtual void makeInvisible();
+
+    static void addWindow(UI* window);
+    static void removeWindow(UI *window);
+    static void displayInOrder();
+    static void passKeyboard(KeyboardButton key, bool pressed);
+    static void passText(char *text, bool notFinished);
+    static void passMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
+    static void passMouseMotion(int xrel, int yrel);
+    static void passMouseScroll(int xrel, int yrel);
+
+protected:
+    long zPos;
+
+private:
+    static void findInList(UI *w, std::function<void (unsigned long i)> func);
+    static bool isOnTop(unsigned long windowID);
+    static void moveToTop(unsigned long windowID);
+    static void makeInvisible(unsigned long windowID);
+    static bool compareUIs(UI* a, UI* b);
+
+    static std::vector<UI*> windows;
+};
+
+#endif
+

include/Window.h

 
     virtual void setTextInput(bool on) = 0;
 
+    virtual bool getTextInput() = 0;
+
     virtual void delay(unsigned int ms) = 0;
 
     virtual void swapBuffersGL() = 0;
     bool mInit;
     bool mFullscreen;
     bool mMousegrab;
+    bool mTextInput;
     unsigned int mWidth;
     unsigned int mHeight;
 };

include/WindowSDL.h

 
     virtual void setTextInput(bool on);
 
+    virtual bool getTextInput();
+
     virtual void delay(unsigned int ms);
 
     virtual void swapBuffersGL();
 private:
     SDL_Window *mWindow;      //!< This is the pointer to the SDL surface
     SDL_GLContext mGLContext; //!< The OpenGL Context
-
-    bool mTextInput;
 };
 
 #endif

src/CMakeLists.txt

 set (SRCS ${SRCS} "StaticMesh.cpp")
 set (SRCS ${SRCS} "TextureManager.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
+set (SRCS ${SRCS} "UI.cpp")
 set (SRCS ${SRCS} "ViewVolume.cpp")
 set (SRCS ${SRCS} "Window.cpp")
 set (SRCS ${SRCS} "World.cpp")

src/Console.cpp

 #include "Console.h"
 
 Console::Console() {
-    mVisible = false;
+    zPos = -1;
     mHistoryPointer = 0;
     mLineOffset = 0;
+
+    UI::addWindow(this);
 }
 
-void Console::setVisible(bool visible) {
-    mVisible = visible;
-    getWindow().setTextInput(mVisible);
+Console::~Console() {
+    UI::removeWindow(this);
 }
 
-bool Console::isVisible() {
-    return mVisible;
+void Console::moveToTop() {
+    if (!getWindow().getTextInput())
+        getWindow().setTextInput(true);
+
+    UI::moveToTop();
 }
 
-#define LINE_GEOMETRY(window) \
-    unsigned int firstLine = 35; \
-    unsigned int lastLine = (window.getHeight() / 2) - 55; \
-    unsigned int inputLine = (window.getHeight() / 2) - 30; \
-    unsigned int lineSteps = 20; \
-    unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps; \
-    while (((lineCount * lineSteps) + firstLine) < inputLine) { \
-        lineSteps++; \
-        lineCount = (lastLine - firstLine + lineSteps) / lineSteps; \
-    }
+void Console::makeInvisible() {
+    if (getWindow().getTextInput())
+        getWindow().setTextInput(false);
 
-void Console::display() {
-    if (!mVisible)
-        return;
+    UI::makeInvisible();
+}
 
+void Console::display() {
     // Calculate line drawing geometry
     // Depends on window height, so recalculate every time
-    LINE_GEOMETRY(getWindow());
+    unsigned int firstLine = 35;
+    unsigned int lastLine = (::getWindow().getHeight() / 2) - 55;
+    unsigned int inputLine = (::getWindow().getHeight() / 2) - 30;
+    unsigned int lineSteps = 20;
+    unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
+    while (((lineCount * lineSteps) + firstLine) < inputLine) {
+        lineSteps++;
+        lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
+    }
+
+    ::getWindow().glEnter2D();
 
     // Draw half-transparent *overlay*
     glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
     glDisable(GL_TEXTURE_2D);
-    glRecti(0, 0, getWindow().getWidth(), getWindow().getHeight() / 2);
+    glRecti(0, 0, ::getWindow().getWidth(), ::getWindow().getHeight() / 2);
     glEnable(GL_TEXTURE_2D);
 
     unsigned long scrollIndicator;
 
     // Draw current input
     getFont().drawText(10, inputLine, 0.75f, BLUE, "> " + mInputBuffer + mPartialInput);
+
+    ::getWindow().glExit2D();
 }
 
 void Console::handleKeyboard(KeyboardButton key, bool pressed) {
 
 void Console::handleMouseScroll(int xrel, int yrel) {
     assert((xrel != 0) || (yrel != 0));
-    LINE_GEOMETRY(getWindow());
+
+    // Calculate line drawing geometry
+    // Depends on window height, so recalculate every time
+    unsigned int firstLine = 35;
+    unsigned int lastLine = (::getWindow().getHeight() / 2) - 55;
+    unsigned int inputLine = (::getWindow().getHeight() / 2) - 30;
+    unsigned int lineSteps = 20;
+    unsigned int lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
+    while (((lineCount * lineSteps) + firstLine) < inputLine) {
+        lineSteps++;
+        lineCount = (lastLine - firstLine + lineSteps) / lineSteps;
+    }
 
     if (mHistory.size() > lineCount) {
         if (yrel > 0) {

src/Game.cpp

 #endif
 
 Game::Game() {
+    zPos = 0;
     mLoaded = false;
     mLara = -1;
     mTextureStart = 0;
     mTextureOffset = 0;
+
+    UI::addWindow(this);
 }
 
 Game::~Game() {
     destroy();
+
+    UI::removeWindow(this);
 }
 
 unsigned int Game::getTextureStart() {
     return 0;
 }
 
+void Game::display() {
+    getRender().display();
+}
+
 void Game::destroy() {
     mLoaded = false;
     mLara = -1;

src/Menu.cpp

 #include "Window.h"
 #include "Menu.h"
 
-void Menu::setVisible(bool visible) {
-    mVisible = visible;
-}
-
-bool Menu::isVisible() {
-    return mVisible;
-}
-
 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
 
 void Menu::displayDialog() {
     if (dialogText.length() > 0) {
-        unsigned int wMax = ((unsigned int)(getWindow().getWidth() * 0.66f));
+        unsigned int wMax = ((unsigned int)(::getWindow().getWidth() * 0.66f));
 
         unsigned int w0 = getFont().widthText(1.0f, dialogText) + 20;
         if (w0 > wMax)
             hOverlay = h0 + h1;
         }
 
-        unsigned int xOverlay = (getWindow().getWidth() - wOverlay) / 2;
-        unsigned int yOverlay = (getWindow().getHeight() - hOverlay) / 2;
+        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);
                 getFont().drawTextWrapped(xOverlay + 10 + w1, yOverlay + 10 + h0,
                     1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
             } else {
-                getFont().drawTextWrapped((getWindow().getWidth() - w1) / 2,
+                getFont().drawTextWrapped((::getWindow().getWidth() - w1) / 2,
                     yOverlay + 10 + h0, 1.0f, dialogState ? BLUE : RED, w1, dialogButton1);
-                getFont().drawTextWrapped((getWindow().getWidth() - w2) / 2,
+                getFont().drawTextWrapped((::getWindow().getWidth() - w2) / 2,
                     yOverlay + 10 + h0 + h1, 1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
             }
         } else {
-            getFont().drawTextWrapped((getWindow().getWidth() - w1) / 2,
+            getFont().drawTextWrapped((::getWindow().getWidth() - w1) / 2,
                     yOverlay + 10 + h0, 1.0f, RED, w1, dialogButton1);
         }
     }

src/MenuFolder.cpp

 #include "MenuFolder.h"
 
 MenuFolder::MenuFolder() {
-    mVisible = false;
+    zPos = -1;
     mCursor = 0;
     mMin = 0;
     mapFolder = nullptr;
     hiddenState = false;
     dialogState = false;
+
+    UI::addWindow(this);
 }
 
 MenuFolder::~MenuFolder() {
     delete mapFolder;
     mapFolder = nullptr;
+
+    UI::removeWindow(this);
 }
 
 int MenuFolder::initialize() {
 }
 
 void MenuFolder::display() {
-    if (!mVisible)
-        return;
+    ::getWindow().glEnter2D();
 
     // 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());
+    glRecti(0, 0, (GLint)::getWindow().getWidth(), (GLint)::getWindow().getHeight());
     glEnable(GL_TEXTURE_2D);
 
     // Draw heading
-    getFont().drawTextCentered(0, 10, 1.2f, BLUE, getWindow().getWidth(), VERSION);
+    getFont().drawTextCentered(0, 10, 1.2f, BLUE, ::getWindow().getWidth(), VERSION);
 
     // Estimate displayable number of items
-    int items = (getWindow().getHeight() - 60) / 25;
+    int items = (::getWindow().getHeight() - 60) / 25;
 
     // Print list of "..", folders, files
     for (long i = mMin; (i < (mMin + items))
     }
 
     displayDialog();
+
+    ::getWindow().glExit2D();
 }
 
 void MenuFolder::loadOrOpen() {
         tmp += mapFolder->getFile((unsigned long)mCursor - 1 - mapFolder->folderCount()).getPath();
         int error = getOpenRaider().command(tmp.c_str());
         if (error == 0) {
-            setVisible(false);
+            makeInvisible();
         } else {
             std::ostringstream err;
             err << "Error loading map: " << error << "!";
         return;
 
     assert(mapFolder != nullptr);
-    int items = (getWindow().getHeight() - 60) / 25;
+    int items = (::getWindow().getHeight() - 60) / 25;
 
     if (key == upKey) {
         if (mCursor > 0)
     if (handleMouseClickDialog(x, y, button, released))
         return;
 
-    int items = (getWindow().getHeight() - 60) / 25;
+    int items = (::getWindow().getHeight() - 60) / 25;
 
     if (released || (button != leftmouseKey))
         return;
 
     assert((xrel != 0) || (yrel != 0));
     assert(mapFolder != nullptr);
-    int items = (getWindow().getHeight() - 60) / 25;
+    int items = (::getWindow().getHeight() - 60) / 25;
 
     if ((mapFolder->folderCount() + mapFolder->fileCount() + 1) > items) {
         if (yrel < 0) {

src/OpenRaider.cpp

     mFPS = true;
 #endif
 
-    getMenu().setVisible(true);
+    getMenu().moveToTop();
     systemTimerReset();
 
     return 0;
     // Get keyboard and mouse input
     getWindow().eventHandling();
 
-    // Draw game scene
-    getRender().display();
+    UI::displayInOrder();
 
-    // Draw 2D overlays (console and menu)
     getWindow().glEnter2D();
 
-    getConsole().display();
-    getMenu().display();
-
     // Draw FPS counter
     if (mFPS) {
         std::ostringstream fpsText;
 
 #ifdef DEBUG
     // Draw debug infos
-    if (getGame().isLoaded() && (!getMenu().isVisible())) {
+    if (getGame().isLoaded() && (!getMenu().isOnTop())) {
         for (int i = 0; i < 3; i++) {
             std::ostringstream axis;
             axis << getGame().getLara().getPos(i) / 256.0f << " (" << getGame().getLara().getAngle(i) << ")";
     }
 }
 
-void OpenRaider::handleKeyboard(KeyboardButton key, bool pressed) {
-    assert(key < unknownKey);
-    assert(mRunning == true);
-
-    if ((keyBindings[menuAction] == key) && pressed) {
-        getMenu().setVisible(!getMenu().isVisible());
-    } else if (!getMenu().isVisible()) {
-        if ((keyBindings[consoleAction] == key) && pressed) {
-            getConsole().setVisible(!getConsole().isVisible());
-        } else if (!getConsole().isVisible()) {
-            for (int i = forwardAction; i < ActionEventCount; i++) {
-                if (keyBindings[i] == key) {
-                    getGame().handleAction((ActionEvents)i, !pressed);
-                }
-            }
-        } else {
-            getConsole().handleKeyboard(key, pressed);
-        }
-    } else {
-        getMenu().handleKeyboard(key, pressed);
-    }
-
-    bool mousegrab = !(getMenu().isVisible() || getConsole().isVisible());
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
-}
-
-void OpenRaider::handleText(char *text, bool notFinished) {
-    assert(text != NULL);
-    assert(text[0] != '\0');
-    assert(mRunning == true);
-
-    if ((getConsole().isVisible()) && (!getMenu().isVisible())) {
-        getConsole().handleText(text, notFinished);
-    }
-
-    bool mousegrab = !(getMenu().isVisible() || getConsole().isVisible());
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
-}
-
-void OpenRaider::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
-    assert(button < unknownKey);
-    assert(mRunning == true);
-
-    if (getMenu().isVisible()) {
-        getMenu().handleMouseClick(x, y, button, released);
-    } else if (!getConsole().isVisible()) {
-        for (int i = forwardAction; i < ActionEventCount; i++) {
-            if (keyBindings[i] == button) {
-                getGame().handleAction((ActionEvents)i, released);
-            }
-        }
-    }
-
-    bool mousegrab = !(getMenu().isVisible() || getConsole().isVisible());
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
-}
-
-void OpenRaider::handleMouseMotion(int xrel, int yrel) {
-    assert((xrel != 0) || (yrel != 0));
-    assert(mRunning == true);
-
-    if ((!getConsole().isVisible()) && (!getMenu().isVisible())) {
-        getGame().handleMouseMotion(xrel, yrel);
-    }
-
-    bool mousegrab = !(getMenu().isVisible() || getConsole().isVisible());
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
-}
-
-void OpenRaider::handleMouseScroll(int xrel, int yrel) {
-    assert((xrel != 0) || (yrel != 0));
-    assert(mRunning == true);
-
-    if (getMenu().isVisible()) {
-        getMenu().handleMouseScroll(xrel, yrel);
-    } else if (getConsole().isVisible()) {
-        getConsole().handleMouseScroll(xrel, yrel);
-    }
-
-    bool mousegrab = !(getMenu().isVisible() || getConsole().isVisible());
-    if (mousegrab != getWindow().getMousegrab())
-        getWindow().setMousegrab(mousegrab);
-}
-

src/UI.cpp

+/*!
+ * \file src/UI.cpp
+ * \brief UI interface manager
+ *
+ * \author xythobuz
+ */
+
+#include <algorithm>
+
+#include "global.h"
+#include "Console.h"
+#include "Menu.h"
+#include "OpenRaider.h"
+#include "Window.h"
+#include "UI.h"
+
+std::vector<UI*> UI::windows;
+
+UI::~UI() {
+}
+
+void UI::display() { }
+void UI::handleKeyboard(KeyboardButton key, bool pressed) { }
+void UI::handleText(char *text, bool notFinished) { }
+void UI::handleAction(ActionEvents action, bool isFinished) { }
+void UI::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) { }
+void UI::handleMouseMotion(int xrel, int yrel) { }
+void UI::handleMouseScroll(int xrel, int yrel) { }
+
+void UI::addWindow(UI* window) {
+    windows.push_back(window);
+}
+
+void UI::removeWindow(UI *window) {
+    findInList(window, [](unsigned long i){
+        windows.erase(windows.begin() + i);
+    });
+}
+
+bool UI::compareUIs(UI* a, UI* b) {
+    return a->zPos < b->zPos;
+}
+
+bool UI::isOnTop(unsigned long windowID) {
+    assert(windowID < windows.size());
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    unsigned long maxPos = (unsigned long)(maxIterator - windows.begin());
+    return (maxPos == windowID);
+}
+
+void UI::moveToTop(unsigned long windowID) {
+    assert(windowID < windows.size());
+
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    long max = (*maxIterator)->zPos;
+    unsigned long maxPos = (unsigned long)(maxIterator - windows.begin());
+
+    if (maxPos != windowID) {
+        windows.at(windowID)->zPos = max + 1;
+    }
+}
+
+void UI::makeInvisible(unsigned long windowID) {
+    assert(windowID < windows.size());
+    windows.at(windowID)->zPos = -1;
+}
+
+void UI::findInList(UI *w, std::function<void (unsigned long i)> func) {
+    for (unsigned long i = 0; i < windows.size(); i++) {
+        auto UIptr = &(*windows.at(i));
+        if (w == UIptr) {
+            func(i);
+            return;
+        }
+    }
+
+    assert(false); // called UI was not registered
+}
+
+bool UI::isOnTop() {
+    bool top = false;
+    findInList(this, [&](unsigned long i) {
+        top = UI::isOnTop(i);
+    });
+    return top;
+}
+
+void UI::moveToTop() {
+    findInList(this, [](unsigned long i) {
+        UI::moveToTop(i);
+    });
+}
+
+void UI::makeInvisible() {
+    findInList(this, [](unsigned long i) {
+        UI::makeInvisible(i);
+    });
+}
+
+void UI::passKeyboard(KeyboardButton key, bool pressed) {
+    if (pressed) {
+        if (getOpenRaider().keyBindings[menuAction] == key) {
+            if (getMenu().isOnTop()) {
+                getMenu().makeInvisible();
+            } else {
+                getMenu().moveToTop();
+            }
+        } else if (getOpenRaider().keyBindings[consoleAction] == key) {
+            if (getConsole().isOnTop()) {
+                getConsole().makeInvisible();
+            } else {
+                getConsole().moveToTop();
+            }
+        }
+    }
+
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleKeyboard(key, pressed);
+
+    for (int i = forwardAction; i < ActionEventCount; i++) {
+        if (getOpenRaider().keyBindings[i] == key) {
+            (*maxIterator)->handleAction((ActionEvents)i, !pressed);
+        }
+    }
+
+    bool mousegrab = (*maxIterator)->zPos == 0;
+    if (mousegrab != getWindow().getMousegrab())
+        getWindow().setMousegrab(mousegrab);
+}
+
+void UI::passText(char *text, bool notFinished) {
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleText(text, notFinished);
+}
+
+void UI::passMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleMouseClick(x, y, button, released);
+
+    for (int i = forwardAction; i < ActionEventCount; i++) {
+        if (getOpenRaider().keyBindings[i] == button) {
+            (*maxIterator)->handleAction((ActionEvents)i, released);
+        }
+    }
+}
+
+void UI::passMouseMotion(int xrel, int yrel) {
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleMouseMotion(xrel, yrel);
+}
+
+void UI::passMouseScroll(int xrel, int yrel) {
+    auto maxIterator = std::max_element(windows.begin(), windows.end(), compareUIs);
+    (*maxIterator)->handleMouseScroll(xrel, yrel);
+}
+
+void UI::displayInOrder() {
+    std::sort(windows.begin(), windows.end(), compareUIs);
+    for (auto &x : windows) {
+        if (x->zPos >= 0) {
+            x->display();
+        }
+    }
+}
+

src/WindowSDL.cpp

 #include <ctime>
 
 #include "global.h"
-#include "OpenRaider.h"
+#include "UI.h"
 #include "utils/strings.h"
 #include "WindowSDL.h"
 
     while(SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_MOUSEMOTION:
-                getOpenRaider().handleMouseMotion(event.motion.xrel, event.motion.yrel);
+                UI::passMouseMotion(event.motion.xrel, event.motion.yrel);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
                     button = fifthmouseKey;
                 else
                     button = unknownKey;
-                getOpenRaider().handleMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
+                UI::passMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
                 break;
 
             case SDL_MOUSEWHEEL:
                 if ((event.wheel.x != 0) || (event.wheel.y != 0))
-                    getOpenRaider().handleMouseScroll(event.wheel.x, event.wheel.y);
+                    UI::passMouseScroll(event.wheel.x, event.wheel.y);
                 break;
 
             case SDL_TEXTINPUT:
             case SDL_TEXTEDITING:
                 if (event.text.text != NULL)
-                    getOpenRaider().handleText(event.text.text, (event.type == SDL_TEXTEDITING));
+                    UI::passText(event.text.text, (event.type == SDL_TEXTEDITING));
                 break;
 
             case SDL_KEYDOWN:
                         break;
 
                 }
-                getOpenRaider().handleKeyboard(key, (event.type == SDL_KEYDOWN));
+                UI::passKeyboard(key, (event.type == SDL_KEYDOWN));
                 break;
 
             case SDL_WINDOWEVENT:
         SDL_StopTextInput();
 }
 
+bool WindowSDL::getTextInput() {
+    assert(mInit == true);
+    return mTextInput;
+}
+
 void WindowSDL::delay(unsigned int ms) {
     assert(mInit == true);
 

src/commands/CommandEngine.cpp

 
 void CommandScreenshot::printHelp() {
     getConsole() << "sshot-Command Usage:" << Console::endl;
-    getConsole() << "  sshot [console|menu]" << Console::endl;
+    getConsole() << "  sshot [console|menu] [console|menu]" << Console::endl;
     getConsole() << "Add console/menu to capture them too" << Console::endl;
 }
 
     filename += VERSION_SHORT;
 
     bool console = false, menu = false;
-    std::string temp;
-    args >> temp;
-    if (temp.compare("console") == 0)
-        console = true;
-    if (temp.compare("menu") == 0)
-        menu = true;
-
-    if (!console) {
-        getConsole().setVisible(false);
-        if (menu)
-            getMenu().setVisible(true);
-        getOpenRaider().frame();
-        getOpenRaider().frame(); // Double buffered
-    }
+    std::string temp, temp2;
+    args >> temp >> temp2;
+
+    getConsole().makeInvisible();
+    getMenu().makeInvisible();
+
+    if (temp == "console")
+        getConsole().moveToTop();
+    else if (temp == "menu")
+        getMenu().moveToTop();
 
+    if (temp2 == "console")
+        getConsole().moveToTop();
+    else if (temp2 == "menu")
+        getMenu().moveToTop();
+
+    getOpenRaider().frame();
+    getOpenRaider().frame(); // Double buffered
     getRender().screenShot(filename.c_str());
 
-    if (!console) {
-        getConsole().setVisible(true);
-        if (menu)
-            getMenu().setVisible(false);
-    }
+    getMenu().makeInvisible();
+    getConsole().moveToTop();
 
     getConsole() << "Screenshot stored..." << Console::endl;
     return 0;