Added main loop, started event handling

include/Config.h.in

 #define DEFAULT_CONFIG_FILE "OpenRaider.init"
 #define DEFAULT_WIDTH 640
 #define DEFAULT_HEIGHT 480
+
+#define MAXIMUM_FPS 100

include/OpenRaider.h

 
     int initialize();
 
+    void run();
+
+    void cleanup();
+
 private:
+    bool mInit;
+    bool mRunning;
     Window *mWindow;
 };
 

include/Window.h

 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
+#include <ctime>
+
 typedef struct {
     char *text;
     unsigned int x;
 
     virtual int initialize() = 0;
 
+    virtual void eventHandling() = 0;
+
     virtual void writeString(WindowString *s) = 0;
 
+    virtual void delay(clock_t ms) = 0;
+
     virtual void swapBuffersGL() = 0;
 
     virtual void resizeGL(unsigned int w, unsigned int h);
+
+    virtual void cleanup() = 0;
 };
 
 #endif

include/WindowSDL.h

 
     virtual int initialize();
 
+    virtual void eventHandling();
+
     virtual void writeString(WindowString *s);
 
+    virtual void delay(clock_t ms);
+
     virtual void swapBuffersGL();
 
+    virtual void cleanup();
+
 private:
     bool mInit;
     char *mDriver;

include/utils/time.h

 #ifndef _UTILS_TIME_H_
 #define _UTILS_TIME_H_
 
+#include <ctime>
+
 /*!
  * \brief Read the system timer
  * \returns number of ticks
  */
-unsigned int systemTimerGet();
+clock_t systemTimerGet();
 
 /*!
  * \brief Reset the system timer

src/OpenRaider.cpp

 
 #include "WindowSDL.h"
 
+#include "config.h"
 #include "utils/strings.h"
+#include "utils/time.h"
 #include "OpenRaider.h"
 
 OpenRaider::OpenRaider() {
+    mInit = false;
+    mRunning = false;
     mWindow = NULL;
 }
 
 
 int OpenRaider::initialize() {
     assert(mWindow == NULL);
+    assert(mInit == false);
+    assert(mRunning == false);
 
     mWindow = new WindowSDL();
-    mWindow->initialize();
+    if (mWindow->initialize() != 0)
+        return -1;
+
+    mInit = true;
 
     return 0;
 }
 
+void OpenRaider::run() {
+    assert(mInit == true);
+    assert(mRunning == false);
+
+    mRunning = true;
+    while (mRunning) {
+        clock_t startTime = systemTimerGet();
+
+        mWindow->eventHandling();
+
+        clock_t stopTime = systemTimerGet();
+        mWindow->delay((1000 / MAXIMUM_FPS) - (stopTime - startTime));
+    }
+}
+
+void OpenRaider::cleanup() {
+    mWindow->cleanup();
+}
+

src/WindowSDL.cpp

 void WindowSDL::setDriver(const char *driver) {
     assert(driver != NULL);
     assert(driver[0] != '\0');
+    assert(mInit == false);
 
     mDriver = bufferString("%s", driver);
 }
 }
 
 int WindowSDL::initialize() {
+    assert(mInit == false);
+
     if (SDL_Init(SDL_INIT_VIDEO) != 0) {
-        printf("SDL Error: %s\n", SDL_GetError());
+        printf("SDL_Init Error: %s\n", SDL_GetError());
         return -1;
     }
 
 #ifndef __APPLE__
     assert(mDriver != NULL);
     assert(mDriver[0] != '\0');
+
     if (SDL_GL_LoadLibrary(mDriver) < 0) {
         SDL_ClearError();
         if (SDL_GL_LoadLibrary("libGL.so") < 0) {
             SDL_ClearError();
             if (SDL_GL_LoadLibrary("libGL.so.1") < 0) {
                 printf("Could not load OpenGL driver!\n");
-                printf("SDL Error: %s\n", SDL_GetError());
+                printf("SDL_GL_LoadLibrary Error: %s\n", SDL_GetError());
                 return -2;
             }
         }
         || (SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5) != 0)
         || (SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16) != 0)
         || (SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) != 0)) {
-        printf("SDL Error: %s\n", SDL_GetError());
+        printf("SDL_GL_SetAttribute Error: %s\n", SDL_GetError());
         mInit = false;
         return -3;
     }
     mWindow = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                 mWidth, mHeight, flags);
     if (mWindow == NULL) {
-        printf("SDL Error: %s\n", SDL_GetError());
+        printf("SDL_CreateWindow Error: %s\n", SDL_GetError());
         mInit = false;
         return -4;
     }
 
     mGLContext = SDL_GL_CreateContext(mWindow);
     if (mGLContext == NULL) {
-        printf("SDL Error: %s\n", SDL_GetError());
+        printf("SDL_GL_CreateContext Error: %s\n", SDL_GetError());
         mInit = false;
         return -5;
     }
     return 0;
 }
 
+void WindowSDL::eventHandling() {
+    SDL_Event event;
+
+    assert(mInit == true);
+
+    while(SDL_PollEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+                exit(0);
+                break;
+
+            case SDL_MOUSEMOTION:
+
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+            case SDL_MOUSEBUTTONUP:
+
+                break;
+
+            case SDL_KEYDOWN:
+            case SDL_KEYUP:
+
+                break;
+
+            case SDL_WINDOWEVENT:
+                if (event.window.event == SDL_WINDOWEVENT_RESIZED)
+                    setSize(event.window.data1, event.window.data2);
+                break;
+        }
+    }
+}
+
 void WindowSDL::writeString(WindowString *s) {
     assert(s != NULL);
     assert(s->text != NULL);
 
 }
 
+void WindowSDL::delay(clock_t ms) {
+    assert(mInit == true);
+
+    SDL_Delay(ms);
+}
+
 void WindowSDL::swapBuffersGL() {
+    assert(mInit == true);
+
     SDL_GL_SwapWindow(mWindow);
 }
 
+void WindowSDL::cleanup() {
+    if (mInit) {
+        //SDL_QuitSubSystem(SDL_OPENGL);
+        SDL_Quit();
+    }
+}
+

src/main.cpp

 OpenRaider *gOpenRaider = NULL;
 
 void cleanupHandler() {
-    if (gOpenRaider)
+    if (gOpenRaider) {
+        gOpenRaider->cleanup();
         delete gOpenRaider;
+    }
 }
 
 int main(int argc, char *argv[]) {
     // Initialize the "subsystems"
     gOpenRaider->initialize();
 
+    // Enter Main loop
+    printf("Starting " VERSION "\n");
+    gOpenRaider->run();
+
     return 0;
 }
 

src/utils/time.cpp

  * \author xythobuz
  */
 
-#include <ctime>
-
 #include "utils/time.h"
 
 #define CLOCKS_PER_MS (CLOCKS_PER_SEC / 1000)
 clock_t system_timer_start;
 clock_t system_timer_stop;
 
-unsigned int systemTimerGet() {
+clock_t systemTimerGet() {
     system_timer_stop = clock();
     return (system_timer_stop - system_timer_start) / CLOCKS_PER_MS;
 }