#include "event_glib.h"
#include "debug.h"
#include "callback.h"
+#include "plugin.h"
static GMainLoop *loop;
}
static struct event_watch *
-event_glib_add_watch(int fd, int w, struct callback *cb)
+event_glib_add_watch(void *fd, enum event_watch_cond cond, struct callback *cb)
{
struct event_watch *ret=g_new0(struct event_watch, 1);
- ret->iochan = g_io_channel_unix_new(fd);
- ret->source = g_io_add_watch(ret->iochan, G_IO_IN | G_IO_ERR | G_IO_HUP, event_glib_call_watch, (gpointer)cb);
+ int flags=0;
+ ret->iochan = g_io_channel_unix_new(GPOINTER_TO_INT(fd));
+ switch (cond) {
+ case event_watch_cond_read:
+ flags=G_IO_IN;
+ break;
+ case event_watch_cond_write:
+ flags=G_IO_OUT;
+ break;
+ case event_watch_cond_except:
+ flags=G_IO_ERR|G_IO_HUP;
+ break;
+ }
+ ret->source = g_io_add_watch(ret->iochan, flags, event_glib_call_watch, (gpointer)cb);
return ret;
}
static void
event_glib_remove_watch(struct event_watch *ev)
{
- GError *error = NULL;
+ if (! ev)
+ return;
g_source_remove(ev->source);
- g_io_channel_shutdown(ev->iochan, 0, &error);
+ g_io_channel_unref(ev->iochan);
g_free(ev);
}
struct event_timeout {
guint source;
+ struct callback *cb;
};
static gboolean
-event_glib_call_timeout_single(gpointer t)
+event_glib_call_timeout_single(struct event_timeout *ev)
{
- struct callback *cb=t;
- callback_call_0(cb);
+ callback_call_0(ev->cb);
+ g_free(ev);
return FALSE;
}
static gboolean
-event_glib_call_timeout_multi(gpointer t)
+event_glib_call_timeout_multi(struct event_timeout *ev)
{
- struct callback *cb=t;
- callback_call_0(cb);
+ callback_call_0(ev->cb);
return TRUE;
}
event_glib_add_timeout(int timeout, int multi, struct callback *cb)
{
struct event_timeout *ret=g_new0(struct event_timeout, 1);
- ret->source = g_timeout_add(timeout, multi ? (GSourceFunc)event_glib_call_timeout_multi : (GSourceFunc)event_glib_call_timeout_single, (gpointer)cb);
+ ret->cb=cb;
+ ret->source = g_timeout_add(timeout, multi ? (GSourceFunc)event_glib_call_timeout_multi : (GSourceFunc)event_glib_call_timeout_single, (gpointer)ret);
return ret;
}
static void
event_glib_remove_timeout(struct event_timeout *ev)
{
+ if (! ev)
+ return;
g_source_remove(ev->source);
g_free(ev);
}
+struct event_idle {
+ guint source;
+ struct callback *cb;
+};
+
+static gboolean
+event_glib_call_idle(struct event_idle *ev)
+{
+ callback_call_0(ev->cb);
+ return TRUE;
+}
+
static struct event_idle *
-event_glib_add_idle(struct callback *cb)
+event_glib_add_idle(int priority, struct callback *cb)
{
- return NULL;
+ struct event_idle *ret=g_new0(struct event_idle, 1);
+ ret->cb=cb;
+ ret->source = g_idle_add_full(priority+100, (GSourceFunc)event_glib_call_idle, (gpointer)ret, NULL);
+ return ret;
}
static void
event_glib_remove_idle(struct event_idle *ev)
{
+ if (! ev)
+ return;
+ g_source_remove(ev->source);
+ g_free(ev);
+}
+
+static void
+event_glib_call_callback(struct callback_list *cb)
+{
+/*
+ Idea for implementation:
+ Create a pipe then use add_watch
+ add callback to a queue
+ from here write to the pipe to wakeup the pool
+ then from the gui thread process the callback queue
+*/
}
static struct event_methods event_glib_methods = {
event_glib_remove_timeout,
event_glib_add_idle,
event_glib_remove_idle,
+ event_glib_call_callback,
};
-static void
+struct event_priv {
+};
+
+static struct event_priv*
event_glib_new(struct event_methods *meth)
{
*meth=event_glib_methods;
+ return (struct event_priv *)event_glib_new;
}
void