1 files changed, 31 insertions, 37 deletions

diff --git a/src/libaudcore/eventqueue.cc b/src/libaudcore/eventqueue.cc
index c65a439..d084dc1 100644
--- a/src/libaudcore/eventqueue.cc
+++ b/src/libaudcore/eventqueue.cc
@@ -19,92 +19,86 @@
 
 #include "hook.h"
 
-#include <pthread.h>
 #include <string.h>
 
 #include "internal.h"
 #include "list.h"
 #include "mainloop.h"
 #include "objects.h"
+#include "threads.h"
 
 struct Event : public ListNode
 {
     String name;
     void * data;
-    void (* destroy) (void *);
+    void (*destroy)(void *);
 
-    Event (const char * name, void * data, EventDestroyFunc destroy) :
-        name (name),
-        data (data),
-        destroy (destroy) {}
+    Event(const char * name, void * data, EventDestroyFunc destroy)
+        : name(name), data(data), destroy(destroy)
+    {
+    }
 
-    ~Event ()
+    ~Event()
     {
         if (destroy)
-            destroy (data);
+            destroy(data);
     }
 };
 
-static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+static aud::mutex mutex;
 static List<Event> events;
 static QueuedFunc queued_events;
 
-static void events_execute (void *)
+static void events_execute(void *)
 {
-    pthread_mutex_lock (& mutex);
+    auto mh = mutex.take();
 
     Event * event;
-    while ((event = events.head ()))
+    while ((event = events.head()))
     {
-        events.remove (event);
+        events.remove(event);
 
-        pthread_mutex_unlock (& mutex);
+        mh.unlock();
 
-        hook_call (event->name, event->data);
+        hook_call(event->name, event->data);
         delete event;
 
-        pthread_mutex_lock (& mutex);
+        mh.lock();
     }
-
-    pthread_mutex_unlock (& mutex);
 }
 
-EXPORT void event_queue (const char * name, void * data, EventDestroyFunc destroy)
+EXPORT void event_queue(const char * name, void * data,
+                        EventDestroyFunc destroy)
 {
-    pthread_mutex_lock (& mutex);
+    auto mh = mutex.take();
 
-    if (! events.head ())
-        queued_events.queue (events_execute, nullptr);
+    if (!events.head())
+        queued_events.queue(events_execute, nullptr);
 
-    events.append (new Event (name, data, destroy));
-
-    pthread_mutex_unlock (& mutex);
+    events.append(new Event(name, data, destroy));
 }
 
-EXPORT void event_queue_cancel (const char * name, void * data)
+EXPORT void event_queue_cancel(const char * name, void * data)
 {
-    pthread_mutex_lock (& mutex);
+    auto mh = mutex.take();
 
-    Event * event = events.head ();
+    Event * event = events.head();
     while (event)
     {
-        Event * next = events.next (event);
+        Event * next = events.next(event);
 
-        if (! strcmp (event->name, name) && (! data || event->data == data))
+        if (!strcmp(event->name, name) && (!data || event->data == data))
         {
-            events.remove (event);
+            events.remove(event);
             delete event;
         }
 
         event = next;
     }
-
-    pthread_mutex_unlock (& mutex);
 }
 
-void event_queue_cancel_all ()
+void event_queue_cancel_all()
 {
-    pthread_mutex_lock (& mutex);
-    events.clear ();
-    pthread_mutex_unlock (& mutex);
+    auto mh = mutex.take();
+    events.clear();
 }