* MT safe
*/
+#include "config.h"
+
#include "glib.h"
+#include <sys/types.h>
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif /* HAVE_SYS_TIME_H */
+#ifdef GLIB_HAVE_SYS_POLL_H
+# include <sys/poll.h>
+# undef events /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
+# undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
+#endif /* GLIB_HAVE_SYS_POLL_H */
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
#include <errno.h>
-#include "config.h"
+
+#ifdef NATIVE_WIN32
+#define STRICT
+#include <windows.h>
+#endif /* NATIVE_WIN32 */
+
+#ifdef _MSC_VER
+#include <fcntl.h>
+#include <io.h>
+#endif /* _MSC_VER */
/* Types */
-typedef struct _GIdleData GIdleData;
typedef struct _GTimeoutData GTimeoutData;
typedef struct _GSource GSource;
typedef struct _GPollRec GPollRec;
struct _GMainLoop
{
- gboolean flag;
-};
-
-struct _GIdleData
-{
- GSourceFunc callback;
+ gboolean is_running;
};
struct _GTimeoutData
/* Forward declarations */
+static gint g_source_compare (GHook *a,
+ GHook *b);
+static void g_source_destroy_func (GHookList *hook_list,
+ GHook *hook);
static void g_main_poll (gint timeout,
gboolean use_priority,
gint priority);
-static void g_main_add_unlocking_poll (gint priority,
+static void g_main_add_poll_unlocked (gint priority,
GPollFD *fd);
static gboolean g_timeout_prepare (gpointer source_data,
static GSList *pending_dispatches = NULL;
static GHookList source_list = { 0 };
+static gint in_check_or_prepare = 0;
/* The following lock is used for both the list of sources
* and the list of poll records
*/
G_LOCK_DECLARE_STATIC (main_loop);
-static GSourceFuncs timeout_funcs = {
+static GSourceFuncs timeout_funcs =
+{
g_timeout_prepare,
g_timeout_check,
g_timeout_dispatch,
- (GDestroyNotify)g_free
+ g_free,
};
-static GSourceFuncs idle_funcs = {
+static GSourceFuncs idle_funcs =
+{
g_idle_prepare,
g_idle_check,
g_idle_dispatch,
- (GDestroyNotify)g_free
+ NULL,
};
static GPollRec *poll_records = NULL;
static GMemChunk *poll_chunk;
static guint n_poll_records = 0;
+#ifdef G_THREADS_ENABLED
+#ifndef NATIVE_WIN32
/* this pipe is used to wake up the main loop when a source is added.
*/
static gint wake_up_pipe[2] = { -1, -1 };
+#else /* NATIVE_WIN32 */
+static HANDLE wake_up_semaphore = NULL;
+#endif /* NATIVE_WIN32 */
static GPollFD wake_up_rec;
static gboolean poll_waiting = FALSE;
+#endif /* G_THREADS_ENABLED */
#ifdef HAVE_POLL
static GPollFunc poll_func = (GPollFunc) poll;
#else /* !HAVE_POLL */
+#ifdef NATIVE_WIN32
+
+static gint
+g_poll (GPollFD *fds, guint nfds, gint timeout)
+{
+ HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+ GPollFD *f;
+ DWORD ready;
+ MSG msg;
+ UINT timer;
+ LONG prevcnt;
+ gint poll_msgs = -1;
+ gint nhandles = 0;
+
+ for (f = fds; f < &fds[nfds]; ++f)
+ if (f->fd >= 0)
+ {
+ if (f->events & G_IO_IN)
+ if (f->fd == G_WIN32_MSG_HANDLE)
+ poll_msgs = f - fds;
+ else
+ {
+ /* g_print ("g_poll: waiting for handle %#x\n", f->fd); */
+ handles[nhandles++] = (HANDLE) f->fd;
+ }
+ }
+
+ if (timeout == -1)
+ timeout = INFINITE;
+
+ if (poll_msgs >= 0)
+ {
+ /* Waiting for messages, and maybe events */
+ if (nhandles == 0)
+ {
+ if (timeout == INFINITE)
+ {
+ /* Waiting just for messages, infinite timeout
+ * -> Use PeekMessage, then WaitMessage
+ */
+ /* g_print ("WaitMessage, PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else if (!WaitMessage ())
+ g_warning ("g_poll: WaitMessage failed");
+ ready = WAIT_OBJECT_0;
+ }
+ else if (timeout == 0)
+ {
+ /* Waiting just for messages, zero timeout
+ * -> Use PeekMessage
+ */
+ /* g_print ("PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else
+ ready = WAIT_TIMEOUT;
+ }
+ else
+ {
+ /* Waiting just for messages, some timeout
+ * -> First try PeekMessage, then set a timer, wait for message,
+ * kill timer, use PeekMessage
+ */
+ /* g_print ("PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else if ((timer = SetTimer (NULL, 0, timeout, NULL)) == 0)
+ g_warning ("g_poll: SetTimer failed");
+ else
+ {
+ /* g_print ("WaitMessage\n"); */
+ WaitMessage ();
+ KillTimer (NULL, timer);
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else
+ ready = WAIT_TIMEOUT;
+ }
+ }
+ }
+ else
+ {
+ /* Wait for either message or event
+ * -> Use MsgWaitForMultipleObjects
+ */
+ /* g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
+ ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,
+ timeout, QS_ALLINPUT);
+ /* g_print("=%d\n", ready); */
+ if (ready == WAIT_FAILED)
+ g_warning ("g_poll: MsgWaitForMultipleObjects failed");
+ }
+ }
+ else if (nhandles == 0)
+ {
+ /* Wait for nothing (huh?) */
+ return 0;
+ }
+ else
+ {
+ /* Wait for just events
+ * -> Use WaitForMultipleObjects
+ */
+ /* g_print ("WaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
+ ready = WaitForMultipleObjects (nhandles, handles, FALSE, timeout);
+ /* g_print("=%d\n", ready); */
+ if (ready == WAIT_FAILED)
+ g_warning ("g_poll: WaitForMultipleObjects failed");
+ }
+
+ for (f = fds; f < &fds[nfds]; ++f)
+ f->revents = 0;
+
+ if (ready == WAIT_FAILED)
+ return -1;
+ else if (poll_msgs >= 0 && ready == WAIT_OBJECT_0 + nhandles)
+ {
+ fds[poll_msgs].revents |= G_IO_IN;
+ }
+ else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
+ for (f = fds; f < &fds[nfds]; ++f)
+ {
+ if ((f->events & G_IO_IN)
+ && f->fd == (gint) handles[ready - WAIT_OBJECT_0])
+ {
+ f->revents |= G_IO_IN;
+ /* g_print ("event %#x\n", f->fd); */
+ ResetEvent ((HANDLE) f->fd);
+ }
+ }
+
+ if (ready == WAIT_TIMEOUT)
+ return 0;
+ else
+ return 1;
+}
+
+#else /* !NATIVE_WIN32 */
/* The following implementation of poll() comes from the GNU C Library.
* Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
#ifndef NO_FD_SET
# define SELECT_MASK fd_set
-#else /* !NO_FD_SET */
+#else /* !NO_FD_SET */
# ifndef _AIX
typedef long fd_mask;
-# endif
-# if defined(_IBMR2)
+# endif /* _AIX */
+# ifdef _IBMR2
# define SELECT_MASK void
-# else
+# else /* !_IBMR2 */
# define SELECT_MASK int
-# endif
-#endif /* !NO_FD_SET */
+# endif /* !_IBMR2 */
+#endif /* !NO_FD_SET */
static gint
-g_poll (GPollFD *fds, guint nfds, gint timeout)
+g_poll (GPollFD *fds,
+ guint nfds,
+ gint timeout)
{
struct timeval tv;
SELECT_MASK rset, wset, xset;
return ready;
}
+
+#endif /* !NATIVE_WIN32 */
+
static GPollFunc poll_func = g_poll;
#endif /* !HAVE_POLL */
return (source_a->priority < source_b->priority) ? -1 : 1;
}
+/* HOLDS: main_loop lock */
+static void
+g_source_destroy_func (GHookList *hook_list,
+ GHook *hook)
+{
+ GSource *source = (GSource*) hook;
+ GDestroyNotify destroy;
+
+ G_UNLOCK (main_loop);
+
+ destroy = hook->destroy;
+ if (destroy)
+ destroy (hook->data);
+
+ destroy = ((GSourceFuncs*) hook->func)->destroy;
+ if (destroy)
+ destroy (source->source_data);
+
+ G_LOCK (main_loop);
+}
+
guint
g_source_add (gint priority,
gboolean can_recurse,
G_LOCK (main_loop);
if (!source_list.is_setup)
- g_hook_list_init (&source_list, sizeof(GSource));
+ {
+ g_hook_list_init (&source_list, sizeof (GSource));
- source = (GSource *)g_hook_alloc (&source_list);
+ source_list.hook_destroy = G_HOOK_DEFERRED_DESTROY;
+ source_list.hook_free = g_source_destroy_func;
+ }
+
+ source = (GSource*) g_hook_alloc (&source_list);
source->priority = priority;
source->source_data = source_data;
source->hook.func = funcs;
return_val = source->hook.hook_id;
+#ifdef G_THREADS_ENABLED
/* Now wake up the main loop if it is waiting in the poll() */
if (poll_waiting)
{
poll_waiting = FALSE;
+#ifndef NATIVE_WIN32
write (wake_up_pipe[1], "A", 1);
+#else
+ ReleaseSemaphore (wake_up_semaphore, 1, NULL);
+#endif
}
-
+#endif
G_UNLOCK (main_loop);
return return_val;
}
-void
+gboolean
g_source_remove (guint tag)
{
GHook *hook;
+ g_return_val_if_fail (tag > 0, FALSE);
+
G_LOCK (main_loop);
hook = g_hook_get (&source_list, tag);
if (hook)
- {
- GSource *source = (GSource *)hook;
-
- ((GSourceFuncs *) source->hook.func)->destroy (source->source_data);
- g_hook_destroy_link (&source_list, hook);
- }
+ g_hook_destroy_link (&source_list, hook);
G_UNLOCK (main_loop);
+
+ return hook != NULL;
}
-void
+gboolean
g_source_remove_by_user_data (gpointer user_data)
{
GHook *hook;
hook = g_hook_find_data (&source_list, TRUE, user_data);
if (hook)
- {
- GSource *source = (GSource *)hook;
-
- ((GSourceFuncs *) source->hook.func)->destroy (source->source_data);
- g_hook_destroy_link (&source_list, hook);
- }
+ g_hook_destroy_link (&source_list, hook);
G_UNLOCK (main_loop);
+
+ return hook != NULL;
}
static gboolean
return (source->source_data == data);
}
-void
+gboolean
g_source_remove_by_source_data (gpointer source_data)
{
GHook *hook;
hook = g_hook_find (&source_list, TRUE,
g_source_find_source_data, source_data);
if (hook)
- {
- GSource *source = (GSource *)hook;
+ g_hook_destroy_link (&source_list, hook);
- ((GSourceFuncs *) source->hook.func)->destroy (source->source_data);
- g_hook_destroy_link (&source_list, hook);
- }
+ G_UNLOCK (main_loop);
+
+ return hook != NULL;
+}
+
+static gboolean
+g_source_find_funcs_user_data (GHook *hook,
+ gpointer data)
+{
+ gpointer *d = data;
+
+ return hook->func == d[0] && hook->data == d[1];
+}
+
+gboolean
+g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
+ gpointer user_data)
+{
+ gpointer d[2];
+ GHook *hook;
+
+ g_return_val_if_fail (funcs != NULL, FALSE);
+
+ G_LOCK (main_loop);
+
+ d[0] = funcs;
+ d[1] = user_data;
+
+ hook = g_hook_find (&source_list, TRUE,
+ g_source_find_funcs_user_data, d);
+ if (hook)
+ g_hook_destroy_link (&source_list, hook);
G_UNLOCK (main_loop);
+
+ return hook != NULL;
}
void
g_get_current_time (GTimeVal *result)
{
+#ifndef _MSC_VER
+ struct timeval r;
+ g_return_if_fail (result != NULL);
+
+ /*this is required on alpha, there the timeval structs are int's
+ not longs and a cast only would fail horribly*/
+ gettimeofday (&r, NULL);
+ result->tv_sec = r.tv_sec;
+ result->tv_usec = r.tv_usec;
+#else
+ /* Avoid calling time() except for the first time.
+ * GetTickCount() should be pretty fast and low-level?
+ * I could also use ftime() but it seems unnecessarily overheady.
+ */
+ static DWORD start_tick = 0;
+ static time_t start_time;
+ DWORD tick;
+ time_t t;
+
g_return_if_fail (result != NULL);
+
+ if (start_tick == 0)
+ {
+ start_tick = GetTickCount ();
+ time (&start_time);
+ }
- gettimeofday ((struct timeval *) result, NULL);
+ tick = GetTickCount ();
+
+ result->tv_sec = (tick - start_tick) / 1000 + start_time;
+ result->tv_usec = ((tick - start_tick) % 1000) * 1000;
+#endif
}
/* Running the main loop */
if (G_HOOK_IS_VALID (source))
{
+ gboolean was_in_call;
gpointer hook_data = source->hook.data;
gpointer source_data = source->source_data;
gboolean (*dispatch) (gpointer,
dispatch = ((GSourceFuncs *) source->hook.func)->dispatch;
+ was_in_call = G_HOOK_IN_CALL (source);
source->hook.flags |= G_HOOK_FLAG_IN_CALL;
G_UNLOCK (main_loop);
hook_data);
G_LOCK (main_loop);
- source->hook.flags &= ~G_HOOK_FLAG_IN_CALL;
+ if (!was_in_call)
+ source->hook.flags &= ~G_HOOK_FLAG_IN_CALL;
- if (need_destroy)
+ if (need_destroy && G_HOOK_IS_VALID (source))
g_hook_destroy_link (&source_list, (GHook *) source);
}
- g_hook_unref (&source_list, (GHook *)source);
+ g_hook_unref (&source_list, (GHook*) source);
}
}
-/* Run a single iteration of the mainloop, or, if !dispatch
- * check to see if any events need dispatching, but don't
- * run the loop.
+/* g_main_iterate () runs a single iteration of the mainloop, or,
+ * if !dispatch checks to see if any sources need dispatching.
+ * basic algorithm for dispatch=TRUE:
+ *
+ * 1) while the list of currently pending sources is non-empty,
+ * we call (*dispatch) on those that are !IN_CALL or can_recurse,
+ * removing sources from the list after each returns.
+ * the return value of (*dispatch) determines whether the source
+ * itself is kept alive.
+ *
+ * 2) call (*prepare) for sources that are not yet SOURCE_READY and
+ * are !IN_CALL or can_recurse. a return value of TRUE determines
+ * that the source would like to be dispatched immediatedly, it
+ * is then flagged as SOURCE_READY.
+ *
+ * 3) poll with the pollfds from all sources at the priority of the
+ * first source flagged as SOURCE_READY. if there are any sources
+ * flagged as SOURCE_READY, we use a timeout of 0 or the minimum
+ * of all timouts otherwise.
+ *
+ * 4) for each source !IN_CALL or can_recurse, if SOURCE_READY or
+ * (*check) returns true, add the source to the pending list.
+ * once one source returns true, stop after checking all sources
+ * at that priority.
+ *
+ * 5) while the list of currently pending sources is non-empty,
+ * call (*dispatch) on each source, removing the source
+ * after the call.
+ *
*/
static gboolean
g_main_iterate (gboolean block,
gboolean dispatch)
{
GHook *hook;
- GTimeVal current_time;
- gint nready = 0;
+ GTimeVal current_time ={ 0, 0 };
+ gint n_ready = 0;
gint current_priority = 0;
gint timeout;
gboolean retval = FALSE;
g_main_dispatch (¤t_time);
G_UNLOCK (main_loop);
+
return TRUE;
}
while (hook)
{
GSource *source = (GSource *)hook;
- GHook *tmp;
- gint source_timeout;
+ gint source_timeout = -1;
- if ((nready > 0) && (source->priority > current_priority))
- break;
- if (!(hook->flags & G_SOURCE_CAN_RECURSE) && G_HOOK_IN_CALL (hook))
+ if ((n_ready > 0) && (source->priority > current_priority))
{
- hook = g_hook_next_valid (hook, TRUE);
+ g_hook_unref (&source_list, hook);
+ break;
+ }
+ if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
+ {
+ hook = g_hook_next_valid (&source_list, hook, TRUE);
continue;
}
- g_hook_ref (&source_list, hook);
+ if (!(hook->flags & G_SOURCE_READY))
+ {
+ gboolean (*prepare) (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+
+ prepare = ((GSourceFuncs *) hook->func)->prepare;
+ in_check_or_prepare++;
+ G_UNLOCK (main_loop);
+
+ if ((*prepare) (source->source_data, ¤t_time, &source_timeout))
+ hook->flags |= G_SOURCE_READY;
+
+ G_LOCK (main_loop);
+ in_check_or_prepare--;
+ }
- if (((GSourceFuncs *)hook->func)->prepare (source->source_data,
- ¤t_time,
- &source_timeout))
+ if (hook->flags & G_SOURCE_READY)
{
if (!dispatch)
{
g_hook_unref (&source_list, hook);
G_UNLOCK (main_loop);
+
return TRUE;
}
else
{
- hook->flags |= G_SOURCE_READY;
- nready++;
+ n_ready++;
current_priority = source->priority;
timeout = 0;
}
timeout = MIN (timeout, source_timeout);
}
- tmp = g_hook_next_valid (hook, TRUE);
-
- g_hook_unref (&source_list, hook);
- hook = tmp;
+ hook = g_hook_next_valid (&source_list, hook, TRUE);
}
/* poll(), if necessary */
- g_main_poll (timeout, nready > 0, current_priority);
+ g_main_poll (timeout, n_ready > 0, current_priority);
/* Check to see what sources need to be dispatched */
- nready = 0;
+ n_ready = 0;
hook = g_hook_first_valid (&source_list, TRUE);
while (hook)
{
GSource *source = (GSource *)hook;
- GHook *tmp;
- if ((nready > 0) && (source->priority > current_priority))
- break;
- if (!(hook->flags & G_SOURCE_CAN_RECURSE) && G_HOOK_IN_CALL (hook))
+ if ((n_ready > 0) && (source->priority > current_priority))
{
- hook = g_hook_next_valid (hook, TRUE);
+ g_hook_unref (&source_list, hook);
+ break;
+ }
+ if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
+ {
+ hook = g_hook_next_valid (&source_list, hook, TRUE);
continue;
}
- g_hook_ref (&source_list, hook);
+ if (!(hook->flags & G_SOURCE_READY))
+ {
+ gboolean (*check) (gpointer source_data,
+ GTimeVal *current_time);
+
+ check = ((GSourceFuncs *) hook->func)->check;
+ in_check_or_prepare++;
+ G_UNLOCK (main_loop);
+
+ if ((*check) (source->source_data, ¤t_time))
+ hook->flags |= G_SOURCE_READY;
+
+ G_LOCK (main_loop);
+ in_check_or_prepare--;
+ }
- if ((hook->flags & G_SOURCE_READY) ||
- ((GSourceFuncs *)hook->func)->check (source->source_data,
- ¤t_time))
+ if (hook->flags & G_SOURCE_READY)
{
if (dispatch)
{
g_hook_ref (&source_list, hook);
pending_dispatches = g_slist_prepend (pending_dispatches, source);
current_priority = source->priority;
- nready++;
+ n_ready++;
}
else
{
g_hook_unref (&source_list, hook);
G_UNLOCK (main_loop);
+
return TRUE;
}
}
- tmp = g_hook_next_valid (hook, TRUE);
-
- g_hook_unref (&source_list, hook);
- hook = tmp;
+ hook = g_hook_next_valid (&source_list, hook, TRUE);
}
/* Now invoke the callbacks */
/* See if any events are pending
*/
gboolean
-g_main_pending ()
+g_main_pending (void)
{
- return g_main_iterate (FALSE, FALSE);
+ return in_check_or_prepare ? FALSE : g_main_iterate (FALSE, FALSE);
}
/* Run a single iteration of the mainloop. If block is FALSE,
gboolean
g_main_iteration (gboolean block)
{
- return g_main_iterate (block, TRUE);
+ if (in_check_or_prepare)
+ {
+ g_warning ("g_main_iteration(): called recursively from within a source's check() or "
+ "prepare() member or from a second thread, iteration not possible");
+ return FALSE;
+ }
+ else
+ return g_main_iterate (block, TRUE);
}
-GMainLoop *
-g_main_new ()
+GMainLoop*
+g_main_new (gboolean is_running)
{
- GMainLoop *result = g_new (GMainLoop, 1);
- result->flag = FALSE;
+ GMainLoop *loop;
- return result;
+ loop = g_new0 (GMainLoop, 1);
+ loop->is_running = is_running != FALSE;
+
+ return loop;
}
void
g_main_run (GMainLoop *loop)
{
- loop->flag = FALSE;
- while (!loop->flag)
+ g_return_if_fail (loop != NULL);
+
+ if (in_check_or_prepare)
+ {
+ g_warning ("g_main_run(): called recursively from within a source's check() or "
+ "prepare() member or from a second thread, iteration not possible");
+ return;
+ }
+
+ loop->is_running = TRUE;
+ while (loop->is_running)
g_main_iterate (TRUE, TRUE);
}
void
g_main_quit (GMainLoop *loop)
{
- loop->flag = TRUE;
+ g_return_if_fail (loop != NULL);
+
+ loop->is_running = FALSE;
}
void
g_main_destroy (GMainLoop *loop)
{
+ g_return_if_fail (loop != NULL);
+
g_free (loop);
}
+gboolean
+g_main_is_running (GMainLoop *loop)
+{
+ g_return_val_if_fail (loop != NULL, FALSE);
+
+ return loop->is_running;
+}
+
/* HOLDS: main_loop_lock */
static void
-g_main_poll (gint timeout, gboolean use_priority, gint priority)
+g_main_poll (gint timeout,
+ gboolean use_priority,
+ gint priority)
{
- GPollFD *fd_array = g_new (GPollFD, n_poll_records);
+ GPollFD *fd_array;
GPollRec *pollrec;
gint i;
gint npoll;
-
+#ifdef G_THREADS_ENABLED
+#ifndef NATIVE_WIN32
if (wake_up_pipe[0] < 0)
{
if (pipe (wake_up_pipe) < 0)
g_error ("Cannot create pipe main loop wake-up: %s\n",
- g_strerror(errno));
+ g_strerror (errno));
wake_up_rec.fd = wake_up_pipe[0];
wake_up_rec.events = G_IO_IN;
- g_main_add_unlocking_poll (0, &wake_up_rec);
+ g_main_add_poll_unlocked (0, &wake_up_rec);
}
-
+#else
+ if (wake_up_semaphore == NULL)
+ {
+ if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
+ g_error ("Cannot create wake-up semaphore: %d", GetLastError ());
+ wake_up_rec.fd = (gint) wake_up_semaphore;
+ wake_up_rec.events = G_IO_IN;
+ g_main_add_poll_unlocked (0, &wake_up_rec);
+ }
+#endif
+#endif
+ fd_array = g_new (GPollFD, n_poll_records);
+
pollrec = poll_records;
i = 0;
while (pollrec && (!use_priority || priority >= pollrec->priority))
pollrec = pollrec->next;
i++;
}
-
+#ifdef G_THREADS_ENABLED
poll_waiting = TRUE;
-
+#endif
G_UNLOCK (main_loop);
npoll = i;
(*poll_func) (fd_array, npoll, timeout);
G_LOCK (main_loop);
+#ifdef G_THREADS_ENABLED
if (!poll_waiting)
{
+#ifndef NATIVE_WIN32
gchar c;
read (wake_up_pipe[0], &c, 1);
+#endif
}
else
poll_waiting = FALSE;
+#endif
pollrec = poll_records;
i = 0;
}
void
-g_main_add_poll (gint priority,
- GPollFD *fd)
+g_main_add_poll (GPollFD *fd,
+ gint priority)
{
G_LOCK (main_loop);
- g_main_add_unlocking_poll (priority, fd);
+ g_main_add_poll_unlocked (priority, fd);
G_UNLOCK (main_loop);
}
/* HOLDS: main_loop_lock */
static void
-g_main_add_unlocking_poll (gint priority,
- GPollFD *fd)
+g_main_add_poll_unlocked (gint priority,
+ GPollFD *fd)
{
GPollRec *lastrec, *pollrec, *newrec;
poll_func = func;
else
#ifdef HAVE_POLL
- poll_func = (GPollFunc)poll;
+ poll_func = (GPollFunc) poll;
#else
- poll_func = (GPollFunc)g_poll;
+ poll_func = (GPollFunc) g_poll;
#endif
}
{
GTimeoutData *data = source_data;
- if (data->callback(user_data))
+ if (data->callback (user_data))
{
- data->expiration.tv_sec = current_time->tv_sec;
- data->expiration.tv_usec = current_time->tv_usec + data->interval * 1000;
+ guint seconds = data->interval / 1000;
+ guint msecs = data->interval - seconds * 1000;
+
+ data->expiration.tv_sec = current_time->tv_sec + seconds;
+ data->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
if (data->expiration.tv_usec >= 1000000)
{
data->expiration.tv_usec -= 1000000;
gpointer data,
GDestroyNotify notify)
{
+ guint seconds;
+ guint msecs;
GTimeoutData *timeout_data = g_new (GTimeoutData, 1);
timeout_data->interval = interval;
timeout_data->callback = function;
g_get_current_time (&timeout_data->expiration);
- timeout_data->expiration.tv_usec += timeout_data->interval * 1000;
+ seconds = timeout_data->interval / 1000;
+ msecs = timeout_data->interval - seconds * 1000;
+
+ timeout_data->expiration.tv_sec += seconds;
+ timeout_data->expiration.tv_usec += msecs * 1000;
if (timeout_data->expiration.tv_usec >= 1000000)
{
timeout_data->expiration.tv_usec -= 1000000;
GSourceFunc function,
gpointer data)
{
- return g_timeout_add_full (0, interval, function, data, NULL);
+ return g_timeout_add_full (G_PRIORITY_DEFAULT,
+ interval, function, data, NULL);
}
/* Idle functions */
GTimeVal *current_time,
gpointer user_data)
{
- GIdleData *data = source_data;
+ GSourceFunc func = source_data;
- return (*data->callback)(user_data);
+ return func (user_data);
}
guint
-g_idle_add_full (gint priority,
+g_idle_add_full (gint priority,
GSourceFunc function,
gpointer data,
GDestroyNotify notify)
{
- GIdleData *idle_data = g_new (GIdleData, 1);
+ g_return_val_if_fail (function != NULL, 0);
- idle_data->callback = function;
-
- return g_source_add (priority, FALSE, &idle_funcs, idle_data, data, notify);
+ return g_source_add (priority, FALSE, &idle_funcs, function, data, notify);
}
guint
g_idle_add (GSourceFunc function,
gpointer data)
{
- return g_idle_add_full (0, function, data, NULL);
+ return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
+}
+
+gboolean
+g_idle_remove_by_data (gpointer data)
+{
+ return g_source_remove_by_funcs_user_data (&idle_funcs, data);
}
projects / platform / upstream / glib.git / blobdiff