1 files changed, 180 insertions, 215 deletions

diff --git a/navit/graphics/sdl/event_sdl.c b/navit/graphics/sdl/event_sdl.c
index 28fe4fafb..454e9eb06 100644
--- a/navit/graphics/sdl/event_sdl.c
+++ b/navit/graphics/sdl/event_sdl.c
@@ -19,7 +19,7 @@
 
 #include <glib.h>
 #include <poll.h>
-#include <SDL/SDL.h>
+#include "SDL.h"
 #include <pthread.h>
 #include <signal.h>
 #include "config.h"
@@ -43,301 +43,266 @@ static struct event_idle *event_sdl_add_idle(int, struct callback *);
 static void event_sdl_remove_idle(struct event_idle *);
 static void event_sdl_call_callback(struct callback_list *);
 
-static Uint32
-sdl_timer_callback(Uint32 interval, void* param)
-{
-   struct event_timeout *timeout=(struct event_timeout*)param;
+static Uint32 sdl_timer_callback(Uint32 interval, void* param) {
+    struct event_timeout *timeout=(struct event_timeout*)param;
 
-   dbg(lvl_debug,"timer(%p) multi(%d) interval(%d) fired\n", param, timeout->multi, interval);
+    dbg(lvl_debug,"timer(%p) multi(%d) interval(%d) fired", param, timeout->multi, interval);
 
-   SDL_Event event;
-   SDL_UserEvent userevent;
+    SDL_Event event;
+    SDL_UserEvent userevent;
 
-   userevent.type = SDL_USEREVENT;
-   userevent.code = SDL_USEREVENT_CODE_TIMER;
-   userevent.data1 = timeout->cb;
-   userevent.data2 = NULL;
+    userevent.type = SDL_USEREVENT;
+    userevent.code = SDL_USEREVENT_CODE_TIMER;
+    userevent.data1 = timeout->cb;
+    userevent.data2 = NULL;
 
-   event.type = SDL_USEREVENT;
-   event.user = userevent;
+    event.type = SDL_USEREVENT;
+    event.user = userevent;
 
-   SDL_PushEvent (&event);
+    SDL_PushEvent (&event);
 
-   if (timeout->multi == 0) {
-      timeout->id = 0;
-      return 0; // cancel timer
-   }
-   return interval; // reactivate timer
+    if (timeout->multi == 0) {
+        timeout->id = 0;
+        return 0; // cancel timer
+    }
+    return interval; // reactivate timer
 }
 
 /* SDL Mainloop */
 
-static void
-event_sdl_main_loop_run(void)
-{
-   graphics_sdl_idle(NULL);
-   event_sdl_watch_stopthread();
+static void event_sdl_main_loop_run(void) {
+    graphics_sdl_idle(NULL);
+    event_sdl_watch_stopthread();
 }
 
-static void
-event_sdl_main_loop_quit(void)
-{
-   quit_event_loop = 1;
+static void event_sdl_main_loop_quit(void) {
+    quit_event_loop = 1;
 }
 
 /* Watch */
 
-void
-event_sdl_watch_thread (GPtrArray *watch_list)
-{
-   struct pollfd *pfds = g_new0 (struct pollfd, watch_list->len);
-   struct event_watch *ew;
-   int ret;
-   int idx;
+void event_sdl_watch_thread (GPtrArray *watch_list) {
+    struct pollfd *pfds = g_new0 (struct pollfd, watch_list->len);
+    struct event_watch *ew;
+    int ret;
+    int idx;
 
-   for (idx = 0; idx < watch_list->len; idx++ ) {
-      ew = g_ptr_array_index (watch_list, idx);
-      g_memmove (&pfds[idx], ew->pfd, sizeof(struct pollfd));
-   }
+    for (idx = 0; idx < watch_list->len; idx++ ) {
+        ew = g_ptr_array_index (watch_list, idx);
+        g_memmove (&pfds[idx], ew->pfd, sizeof(struct pollfd));
+    }
 
-   while ((ret = ppoll(pfds, watch_list->len, NULL, NULL)) > 0) {
-      for (idx = 0; idx < watch_list->len; idx++ ) {
-	 if (pfds[idx].revents == pfds[idx].events) {	/* The requested event happened, notify mainloop! */
-	    ew = g_ptr_array_index (watch_list, idx);
-	    dbg(lvl_debug,"watch(%p) event(%d) encountered\n", ew, pfds[idx].revents);
+    while ((ret = ppoll(pfds, watch_list->len, NULL, NULL)) > 0) {
+        for (idx = 0; idx < watch_list->len; idx++ ) {
+            if (pfds[idx].revents == pfds[idx].events) {	/* The requested event happened, notify mainloop! */
+                ew = g_ptr_array_index (watch_list, idx);
+                dbg(lvl_debug,"watch(%p) event(%d) encountered", ew, pfds[idx].revents);
 
-	    SDL_Event event;
-	    SDL_UserEvent userevent;
+                SDL_Event event;
+                SDL_UserEvent userevent;
 
-	    userevent.type = SDL_USEREVENT;
-	    userevent.code = SDL_USEREVENT_CODE_WATCH;
-	    userevent.data1 = ew->cb;
-	    userevent.data2 = NULL;
+                userevent.type = SDL_USEREVENT;
+                userevent.code = SDL_USEREVENT_CODE_WATCH;
+                userevent.data1 = ew->cb;
+                userevent.data2 = NULL;
 
-	    event.type = SDL_USEREVENT;
-	    event.user = userevent;
+                event.type = SDL_USEREVENT;
+                event.user = userevent;
 
-	    SDL_PushEvent (&event);
-	 }
-      }
-   }
+                SDL_PushEvent (&event);
+            }
+        }
+    }
 
-   g_free(pfds);
+    g_free(pfds);
 
-   pthread_exit(0);
+    pthread_exit(0);
 }
 
-static void
-event_sdl_watch_startthread(GPtrArray *watch_list)
-{
-   dbg(lvl_debug,"enter\n");
-   if (sdl_watch_thread)
-      event_sdl_watch_stopthread();
+static void event_sdl_watch_startthread(GPtrArray *watch_list) {
+    dbg(lvl_debug,"enter");
+    if (sdl_watch_thread)
+        event_sdl_watch_stopthread();
 
-   int ret;
-   ret = pthread_create (&sdl_watch_thread, NULL, (void *)event_sdl_watch_thread, (void *)watch_list);
+    int ret;
+    ret = pthread_create (&sdl_watch_thread, NULL, (void *)event_sdl_watch_thread, (void *)watch_list);
 
-   dbg_assert (ret == 0);
+    dbg_assert (ret == 0);
 }
 
-static void
-event_sdl_watch_stopthread()
-{
-   dbg(lvl_debug,"enter\n");
-   if (sdl_watch_thread) {
-      /* Notify the watch thread that the list of FDs will change */
-      pthread_kill(sdl_watch_thread, SIGUSR1);
-      pthread_join(sdl_watch_thread, NULL);
-      sdl_watch_thread = 0;
-   }
+static void event_sdl_watch_stopthread() {
+    dbg(lvl_debug,"enter");
+    if (sdl_watch_thread) {
+        /* Notify the watch thread that the list of FDs will change */
+        pthread_kill(sdl_watch_thread, SIGUSR1);
+        pthread_join(sdl_watch_thread, NULL);
+        sdl_watch_thread = 0;
+    }
 }
 
-static struct event_watch *
-event_sdl_add_watch(int fd, enum event_watch_cond cond, struct callback *cb)
-{
-   dbg(lvl_debug,"fd(%d) cond(%x) cb(%x)\n", fd, cond, cb);
+static struct event_watch *event_sdl_add_watch(int fd, enum event_watch_cond cond, struct callback *cb) {
+    dbg(lvl_debug,"fd(%d) cond(%x) cb(%x)", fd, cond, cb);
 
-   event_sdl_watch_stopthread();
+    event_sdl_watch_stopthread();
 
-   if (!sdl_watch_list)
-      sdl_watch_list = g_ptr_array_new();
+    if (!sdl_watch_list)
+        sdl_watch_list = g_ptr_array_new();
 
-   struct event_watch *new_ew = g_new0 (struct event_watch, 1);
-   struct pollfd *pfd = g_new0 (struct pollfd, 1);
+    struct event_watch *new_ew = g_new0 (struct event_watch, 1);
+    struct pollfd *pfd = g_new0 (struct pollfd, 1);
 
-   pfd->fd = fd;
+    pfd->fd = fd;
 
-   /* Modify watchlist here */
-   switch (cond) {
-      case event_watch_cond_read:
-	 pfd->events = POLLIN;
-	 break;
-      case event_watch_cond_write:
-	 pfd->events = POLLOUT;
-	 break;
-      case event_watch_cond_except:
-	 pfd->events = POLLERR|POLLHUP;
-	 break;
-   }
+    /* Modify watchlist here */
+    switch (cond) {
+    case event_watch_cond_read:
+        pfd->events = POLLIN;
+        break;
+    case event_watch_cond_write:
+        pfd->events = POLLOUT;
+        break;
+    case event_watch_cond_except:
+        pfd->events = POLLERR|POLLHUP;
+        break;
+    }
 
-   new_ew->pfd = (struct pollfd*) pfd;
-   new_ew->cb = cb;
+    new_ew->pfd = (struct pollfd*) pfd;
+    new_ew->cb = cb;
 
-   g_ptr_array_add (sdl_watch_list, (gpointer)new_ew);
+    g_ptr_array_add (sdl_watch_list, (gpointer)new_ew);
 
-   event_sdl_watch_startthread(sdl_watch_list);
+    event_sdl_watch_startthread(sdl_watch_list);
 
-   return new_ew;
+    return new_ew;
 }
 
-static void
-event_sdl_remove_watch(struct event_watch *ew)
-{
-   dbg(lvl_debug,"enter %p\n",ew);
+static void event_sdl_remove_watch(struct event_watch *ew) {
+    dbg(lvl_debug,"enter %p",ew);
 
-   event_sdl_watch_stopthread();
+    event_sdl_watch_stopthread();
 
-   g_ptr_array_remove (sdl_watch_list, ew);
-   g_free (ew->pfd);
-   g_free (ew);
+    g_ptr_array_remove (sdl_watch_list, ew);
+    g_free (ew->pfd);
+    g_free (ew);
 
-   if (sdl_watch_list->len > 0)
-      event_sdl_watch_startthread(sdl_watch_list);
+    if (sdl_watch_list->len > 0)
+        event_sdl_watch_startthread(sdl_watch_list);
 }
 
 /* Timeout */
 
-static struct event_timeout *
-event_sdl_add_timeout(int timeout, int multi, struct callback *cb)
-{
-   struct event_timeout * ret = g_new0(struct event_timeout, 1);
-   if(!ret) {
-      dbg(lvl_error,"g_new0 failed\n");
-      return ret;
-   }
-   dbg(lvl_debug,"timer(%p) multi(%d) interval(%d) cb(%p) added\n",ret, multi, timeout, cb);
-   ret->multi = multi;
-   ret->cb = cb;
-   ret->id = SDL_AddTimer(timeout, sdl_timer_callback, ret);
-
-   return ret;
+static struct event_timeout *event_sdl_add_timeout(int timeout, int multi, struct callback *cb) {
+    struct event_timeout * ret = g_new0(struct event_timeout, 1);
+    if(!ret) {
+        dbg(lvl_error,"g_new0 failed");
+        return ret;
+    }
+    dbg(lvl_debug,"timer(%p) multi(%d) interval(%d) cb(%p) added",ret, multi, timeout, cb);
+    ret->multi = multi;
+    ret->cb = cb;
+    ret->id = SDL_AddTimer(timeout, sdl_timer_callback, ret);
+
+    return ret;
 }
 
-static void
-event_sdl_remove_timeout(struct event_timeout *to)
-{
-   dbg(lvl_info,"enter %p\n", to);
-   if(to)
-   {
-      /* do not SDL_RemoveTimer if oneshot timer has already fired */
-      int ret = to->id == 0 ? SDL_TRUE : SDL_RemoveTimer(to->id);
-
-      if (ret == SDL_FALSE)
-	 dbg(lvl_error,"SDL_RemoveTimer (%p) failed\n", to->id);
-
-      g_free(to);
-      dbg(lvl_debug,"timer(%p) removed\n", to);
-   }
+static void event_sdl_remove_timeout(struct event_timeout *to) {
+    dbg(lvl_info,"enter %p", to);
+    if(to) {
+        /* do not SDL_RemoveTimer if oneshot timer has already fired */
+        int ret = to->id == 0 ? SDL_TRUE : SDL_RemoveTimer(to->id);
+
+        if (ret == SDL_FALSE)
+            dbg(lvl_error,"SDL_RemoveTimer (%p) failed", to->id);
+
+        g_free(to);
+        dbg(lvl_debug,"timer(%p) removed", to);
+    }
 }
 
 /* Idle */
 
 /* sort ptr_array by priority, increasing order */
-static gint
-sdl_sort_idle_tasks(gconstpointer parama, gconstpointer paramb)
-{
-   struct idle_task *a = (struct idle_task *)parama;
-   struct idle_task *b = (struct idle_task *)paramb;
-   if (a->priority < b->priority)
-      return -1;
-   if (a->priority > b->priority)
-      return 1;
-   return 0;
+static gint sdl_sort_idle_tasks(gconstpointer parama, gconstpointer paramb) {
+    struct idle_task *a = (struct idle_task *)parama;
+    struct idle_task *b = (struct idle_task *)paramb;
+    if (a->priority < b->priority)
+        return -1;
+    if (a->priority > b->priority)
+        return 1;
+    return 0;
 }
 
-static struct event_idle *
-event_sdl_add_idle(int priority, struct callback *cb)
-{
-   dbg(lvl_debug,"add idle priority(%d) cb(%p)\n", priority, cb);
+static struct event_idle *event_sdl_add_idle(int priority, struct callback *cb) {
+    dbg(lvl_debug,"add idle priority(%d) cb(%p)", priority, cb);
 
-   struct idle_task *task = g_new0(struct idle_task, 1);
-   task->priority = priority;
-   task->cb = cb;
+    struct idle_task *task = g_new0(struct idle_task, 1);
+    task->priority = priority;
+    task->cb = cb;
 
-   g_ptr_array_add(idle_tasks, (gpointer)task);
+    g_ptr_array_add(idle_tasks, (gpointer)task);
 
-   if (idle_tasks->len < 2)
-   {
-      SDL_Event event;
-      SDL_UserEvent userevent;
+    if (idle_tasks->len < 2) {
+        SDL_Event event;
+        SDL_UserEvent userevent;
 
-      dbg(lvl_debug,"poking eventloop because of new idle_events\n");
+        dbg(lvl_debug,"poking eventloop because of new idle_events");
 
-      userevent.type = SDL_USEREVENT;
-      userevent.code = SDL_USEREVENT_CODE_IDLE_EVENT;
-      userevent.data1 = NULL;
-      userevent.data2 = NULL;
+        userevent.type = SDL_USEREVENT;
+        userevent.code = SDL_USEREVENT_CODE_IDLE_EVENT;
+        userevent.data1 = NULL;
+        userevent.data2 = NULL;
 
-      event.type = SDL_USEREVENT;
-      event.user = userevent;
+        event.type = SDL_USEREVENT;
+        event.user = userevent;
 
-      SDL_PushEvent (&event);
-   }
-   else	// more than one entry => sort the list
-      g_ptr_array_sort(idle_tasks, sdl_sort_idle_tasks);
+        SDL_PushEvent (&event);
+    } else	// more than one entry => sort the list
+        g_ptr_array_sort(idle_tasks, sdl_sort_idle_tasks);
 
-   return (struct event_idle *)task;
+    return (struct event_idle *)task;
 }
 
-static void
-event_sdl_remove_idle(struct event_idle *task)
-{
-   dbg(lvl_debug,"remove task(%p)\n", task);
-   g_ptr_array_remove(idle_tasks, (gpointer)task);
+static void event_sdl_remove_idle(struct event_idle *task) {
+    dbg(lvl_debug,"remove task(%p)", task);
+    g_ptr_array_remove(idle_tasks, (gpointer)task);
 }
 
 /* callback */
 
-static void
-event_sdl_call_callback(struct callback_list *cbl)
-{
-   dbg(lvl_debug,"call_callback cbl(%p)\n",cbl);
-   SDL_Event event;
-   SDL_UserEvent userevent;
+static void event_sdl_call_callback(struct callback_list *cbl) {
+    dbg(lvl_debug,"call_callback cbl(%p)",cbl);
+    SDL_Event event;
+    SDL_UserEvent userevent;
 
-   userevent.type = SDL_USEREVENT;
-   userevent.code = SDL_USEREVENT_CODE_CALL_CALLBACK;
-   userevent.data1 = cbl;
-   userevent.data2 = NULL;
+    userevent.type = SDL_USEREVENT;
+    userevent.code = SDL_USEREVENT_CODE_CALL_CALLBACK;
+    userevent.data1 = cbl;
+    userevent.data2 = NULL;
 
-   event.type = SDL_USEREVENT;
-   event.user = userevent;
+    event.type = SDL_USEREVENT;
+    event.user = userevent;
 
-   SDL_PushEvent (&event);
+    SDL_PushEvent (&event);
 }
 
 static struct event_methods event_sdl_methods = {
-   event_sdl_main_loop_run,
-   event_sdl_main_loop_quit,
-   event_sdl_add_watch,
-   event_sdl_remove_watch,
-   event_sdl_add_timeout,
-   event_sdl_remove_timeout,
-   event_sdl_add_idle,
-   event_sdl_remove_idle,
-   event_sdl_call_callback,
+    event_sdl_main_loop_run,
+    event_sdl_main_loop_quit,
+    event_sdl_add_watch,
+    event_sdl_remove_watch,
+    event_sdl_add_timeout,
+    event_sdl_remove_timeout,
+    event_sdl_add_idle,
+    event_sdl_remove_idle,
+    event_sdl_call_callback,
 };
 
-static struct event_priv *
-event_sdl_new(struct event_methods* methods)
-{
-   idle_tasks = g_ptr_array_new();
-   *methods = event_sdl_methods;
-   return NULL;
+static struct event_priv *event_sdl_new(struct event_methods* methods) {
+    idle_tasks = g_ptr_array_new();
+    *methods = event_sdl_methods;
+    return NULL;
 }
 
-void
-event_sdl_register(void)
-{
-   plugin_register_category_event("sdl", event_sdl_new);
+void event_sdl_register(void) {
+    plugin_register_category_event("sdl", event_sdl_new);
 }