1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * gmain.c: Main loop abstraction, timeouts, and idle functions
5 * Copyright 1998 Owen Taylor
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
30 #include <sys/types.h>
32 #ifdef HAVE_SYS_TIME_H
34 #endif /* HAVE_SYS_TIME_H */
35 #ifdef GLIB_HAVE_SYS_POLL_H
36 # include <sys/poll.h>
37 # undef events /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
38 # undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
39 #endif /* GLIB_HAVE_SYS_POLL_H */
42 #endif /* HAVE_UNISTD_H */
48 #endif /* NATIVE_WIN32 */
57 typedef struct _GTimeoutData GTimeoutData;
58 typedef struct _GSource GSource;
59 typedef struct _GPollRec GPollRec;
63 G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,
64 G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1)
93 /* Forward declarations */
95 static gint g_source_compare (GHook *a,
97 static void g_source_destroy_func (GHookList *hook_list,
99 static void g_main_poll (gint timeout,
100 gboolean use_priority,
102 static void g_main_add_poll_unlocked (gint priority,
105 static gboolean g_timeout_prepare (gpointer source_data,
106 GTimeVal *current_time,
108 static gboolean g_timeout_check (gpointer source_data,
109 GTimeVal *current_time);
110 static gboolean g_timeout_dispatch (gpointer source_data,
111 GTimeVal *current_time,
113 static gboolean g_idle_prepare (gpointer source_data,
114 GTimeVal *current_time,
116 static gboolean g_idle_check (gpointer source_data,
117 GTimeVal *current_time);
118 static gboolean g_idle_dispatch (gpointer source_data,
119 GTimeVal *current_time,
124 static GSList *pending_dispatches = NULL;
125 static GHookList source_list = { 0 };
126 static gint in_check_or_prepare = 0;
128 /* The following lock is used for both the list of sources
129 * and the list of poll records
131 G_LOCK_DECLARE_STATIC (main_loop);
133 static GSourceFuncs timeout_funcs =
141 static GSourceFuncs idle_funcs =
149 static GPollRec *poll_records = NULL;
150 static GPollRec *poll_free_list = NULL;
151 static GMemChunk *poll_chunk;
152 static guint n_poll_records = 0;
154 #ifdef G_THREADS_ENABLED
156 /* this pipe is used to wake up the main loop when a source is added.
158 static gint wake_up_pipe[2] = { -1, -1 };
159 #else /* NATIVE_WIN32 */
160 static HANDLE wake_up_semaphore = NULL;
161 #endif /* NATIVE_WIN32 */
162 static GPollFD wake_up_rec;
163 static gboolean poll_waiting = FALSE;
164 #endif /* G_THREADS_ENABLED */
167 static GPollFunc poll_func = (GPollFunc) poll;
168 #else /* !HAVE_POLL */
172 g_poll (GPollFD *fds, guint nfds, gint timeout)
174 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
183 for (f = fds; f < &fds[nfds]; ++f)
186 if (f->events & G_IO_IN)
187 if (f->fd == G_WIN32_MSG_HANDLE)
191 /* g_print ("g_poll: waiting for handle %#x\n", f->fd); */
192 handles[nhandles++] = (HANDLE) f->fd;
201 /* Waiting for messages, and maybe events */
204 if (timeout == INFINITE)
206 /* Waiting just for messages, infinite timeout
207 * -> Use PeekMessage, then WaitMessage
209 /* g_print ("WaitMessage, PeekMessage\n"); */
210 if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
211 ready = WAIT_OBJECT_0;
212 else if (!WaitMessage ())
213 g_warning ("g_poll: WaitMessage failed");
214 ready = WAIT_OBJECT_0;
216 else if (timeout == 0)
218 /* Waiting just for messages, zero timeout
221 /* g_print ("PeekMessage\n"); */
222 if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
223 ready = WAIT_OBJECT_0;
225 ready = WAIT_TIMEOUT;
229 /* Waiting just for messages, some timeout
230 * -> First try PeekMessage, then set a timer, wait for message,
231 * kill timer, use PeekMessage
233 /* g_print ("PeekMessage\n"); */
234 if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
235 ready = WAIT_OBJECT_0;
236 else if ((timer = SetTimer (NULL, 0, timeout, NULL)) == 0)
237 g_warning ("g_poll: SetTimer failed");
240 /* g_print ("WaitMessage\n"); */
242 KillTimer (NULL, timer);
243 if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
244 ready = WAIT_OBJECT_0;
246 ready = WAIT_TIMEOUT;
252 /* Wait for either message or event
253 * -> Use MsgWaitForMultipleObjects
255 /* g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
256 ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,
257 timeout, QS_ALLINPUT);
258 /* g_print("=%d\n", ready); */
259 if (ready == WAIT_FAILED)
260 g_warning ("g_poll: MsgWaitForMultipleObjects failed");
263 else if (nhandles == 0)
265 /* Wait for nothing (huh?) */
270 /* Wait for just events
271 * -> Use WaitForMultipleObjects
273 /* g_print ("WaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
274 ready = WaitForMultipleObjects (nhandles, handles, FALSE, timeout);
275 /* g_print("=%d\n", ready); */
276 if (ready == WAIT_FAILED)
277 g_warning ("g_poll: WaitForMultipleObjects failed");
280 for (f = fds; f < &fds[nfds]; ++f)
283 if (ready == WAIT_FAILED)
285 else if (poll_msgs >= 0 && ready == WAIT_OBJECT_0 + nhandles)
287 fds[poll_msgs].revents |= G_IO_IN;
289 else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
290 for (f = fds; f < &fds[nfds]; ++f)
292 if ((f->events & G_IO_IN)
293 && f->fd == (gint) handles[ready - WAIT_OBJECT_0])
295 f->revents |= G_IO_IN;
296 /* g_print ("event %#x\n", f->fd); */
297 ResetEvent ((HANDLE) f->fd);
301 if (ready == WAIT_TIMEOUT)
307 #else /* !NATIVE_WIN32 */
309 /* The following implementation of poll() comes from the GNU C Library.
310 * Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
313 #include <string.h> /* for bzero on BSD systems */
315 #ifdef HAVE_SYS_SELECT_H
316 #include <sys/select.h>
317 #endif /* HAVE_SYS_SELECT_H_ */
320 # define SELECT_MASK fd_set
321 #else /* !NO_FD_SET */
323 typedef long fd_mask;
326 # define SELECT_MASK void
328 # define SELECT_MASK int
329 # endif /* !_IBMR2 */
330 #endif /* !NO_FD_SET */
333 g_poll (GPollFD *fds,
338 SELECT_MASK rset, wset, xset;
347 for (f = fds; f < &fds[nfds]; ++f)
350 if (f->events & G_IO_IN)
351 FD_SET (f->fd, &rset);
352 if (f->events & G_IO_OUT)
353 FD_SET (f->fd, &wset);
354 if (f->events & G_IO_PRI)
355 FD_SET (f->fd, &xset);
356 if (f->fd > maxfd && (f->events & (G_IO_IN|G_IO_OUT|G_IO_PRI)))
360 tv.tv_sec = timeout / 1000;
361 tv.tv_usec = (timeout % 1000) * 1000;
363 ready = select (maxfd + 1, &rset, &wset, &xset,
364 timeout == -1 ? NULL : &tv);
366 for (f = fds; f < &fds[nfds]; ++f)
371 if (FD_ISSET (f->fd, &rset))
372 f->revents |= G_IO_IN;
373 if (FD_ISSET (f->fd, &wset))
374 f->revents |= G_IO_OUT;
375 if (FD_ISSET (f->fd, &xset))
376 f->revents |= G_IO_PRI;
383 #endif /* !NATIVE_WIN32 */
385 static GPollFunc poll_func = g_poll;
386 #endif /* !HAVE_POLL */
388 /* Hooks for adding to the main loop */
390 /* Use knowledge of insert_sorted algorithm here to make
391 * sure we insert at the end of equal priority items
394 g_source_compare (GHook *a,
397 GSource *source_a = (GSource *)a;
398 GSource *source_b = (GSource *)b;
400 return (source_a->priority < source_b->priority) ? -1 : 1;
403 /* HOLDS: main_loop_lock */
405 g_source_destroy_func (GHookList *hook_list,
408 GSource *source = (GSource*) hook;
409 GDestroyNotify destroy;
411 G_UNLOCK (main_loop);
413 destroy = hook->destroy;
415 destroy (hook->data);
417 destroy = ((GSourceFuncs*) hook->func)->destroy;
419 destroy (source->source_data);
425 g_source_add (gint priority,
426 gboolean can_recurse,
428 gpointer source_data,
430 GDestroyNotify notify)
437 if (!source_list.is_setup)
438 g_hook_list_init (&source_list, sizeof(GSource));
440 source_list.hook_destroy = g_source_destroy_func;
442 source = (GSource *)g_hook_alloc (&source_list);
443 source->priority = priority;
444 source->source_data = source_data;
445 source->hook.func = funcs;
446 source->hook.data = user_data;
447 source->hook.destroy = notify;
449 g_hook_insert_sorted (&source_list,
454 source->hook.flags |= G_SOURCE_CAN_RECURSE;
456 return_val = source->hook.hook_id;
458 #ifdef G_THREADS_ENABLED
459 /* Now wake up the main loop if it is waiting in the poll() */
463 poll_waiting = FALSE;
465 write (wake_up_pipe[1], "A", 1);
467 ReleaseSemaphore (wake_up_semaphore, 1, NULL);
471 G_UNLOCK (main_loop);
477 g_source_remove (guint tag)
481 g_return_val_if_fail (tag > 0, FALSE);
485 hook = g_hook_get (&source_list, tag);
487 g_hook_destroy_link (&source_list, hook);
489 G_UNLOCK (main_loop);
495 g_source_remove_by_user_data (gpointer user_data)
501 hook = g_hook_find_data (&source_list, TRUE, user_data);
503 g_hook_destroy_link (&source_list, hook);
505 G_UNLOCK (main_loop);
511 g_source_find_source_data (GHook *hook,
514 GSource *source = (GSource *)hook;
516 return (source->source_data == data);
520 g_source_remove_by_source_data (gpointer source_data)
526 hook = g_hook_find (&source_list, TRUE,
527 g_source_find_source_data, source_data);
529 g_hook_destroy_link (&source_list, hook);
531 G_UNLOCK (main_loop);
537 g_source_find_funcs_user_data (GHook *hook,
542 return hook->func == d[0] && hook->data == d[1];
546 g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
552 g_return_val_if_fail (funcs != NULL, FALSE);
559 hook = g_hook_find (&source_list, TRUE,
560 g_source_find_funcs_user_data, d);
562 g_hook_destroy_link (&source_list, hook);
564 G_UNLOCK (main_loop);
570 g_get_current_time (GTimeVal *result)
574 g_return_if_fail (result != NULL);
576 /*this is required on alpha, there the timeval structs are int's
577 not longs and a cast only would fail horribly*/
578 gettimeofday (&r, NULL);
579 result->tv_sec = r.tv_sec;
580 result->tv_usec = r.tv_usec;
582 /* Avoid calling time() except for the first time.
583 * GetTickCount() should be pretty fast and low-level?
584 * I could also use ftime() but it seems unnecessarily overheady.
586 static DWORD start_tick = 0;
587 static time_t start_time;
591 g_return_if_fail (result != NULL);
595 start_tick = GetTickCount ();
599 tick = GetTickCount ();
601 result->tv_sec = (tick - start_tick) / 1000 + start_time;
602 result->tv_usec = ((tick - start_tick) % 1000) * 1000;
606 /* Running the main loop */
608 /* HOLDS: main_loop_lock */
610 g_main_dispatch (GTimeVal *current_time)
612 while (pending_dispatches != NULL)
614 gboolean need_destroy;
615 GSource *source = pending_dispatches->data;
618 tmp_list = pending_dispatches;
619 pending_dispatches = g_slist_remove_link (pending_dispatches, pending_dispatches);
620 g_slist_free_1 (tmp_list);
622 if (G_HOOK_IS_VALID (source))
624 gboolean was_in_call;
625 gpointer hook_data = source->hook.data;
626 gpointer source_data = source->source_data;
627 gboolean (*dispatch) (gpointer,
631 dispatch = ((GSourceFuncs *) source->hook.func)->dispatch;
633 was_in_call = G_HOOK_IN_CALL (source);
634 source->hook.flags |= G_HOOK_FLAG_IN_CALL;
636 G_UNLOCK (main_loop);
637 need_destroy = ! dispatch (source_data,
643 source->hook.flags &= ~G_HOOK_FLAG_IN_CALL;
645 if (need_destroy && G_HOOK_IS_VALID (source))
646 g_hook_destroy_link (&source_list, (GHook *) source);
649 g_hook_unref (&source_list, (GHook*) source);
653 /* g_main_iterate () runs a single iteration of the mainloop, or,
654 * if !dispatch checks to see if any sources need dispatching.
655 * basic algorithm for dispatch=TRUE:
657 * 1) while the list of currently pending sources is non-empty,
658 * we call (*dispatch) on those that are !IN_CALL or can_recurse,
659 * removing sources from the list after each returns.
660 * the return value of (*dispatch) determines whether the source
661 * itself is kept alive.
663 * 2) call (*prepare) for sources that are not yet SOURCE_READY and
664 * are !IN_CALL or can_recurse. a return value of TRUE determines
665 * that the source would like to be dispatched immediatedly, it
666 * is then flagged as SOURCE_READY.
668 * 3) poll with the pollfds from all sources at the priority of the
669 * first source flagged as SOURCE_READY. if there are any sources
670 * flagged as SOURCE_READY, we use a timeout of 0 or the minimum
671 * of all timouts otherwise.
673 * 4) for each source !IN_CALL or can_recurse, if SOURCE_READY or
674 * (*check) returns true, add the source to the pending list.
675 * once one source returns true, stop after checking all sources
678 * 5) while the list of currently pending sources is non-empty,
679 * call (*dispatch) on each source, removing the source
684 g_main_iterate (gboolean block,
688 GTimeVal current_time ={ 0, 0 };
690 gint current_priority = 0;
692 gboolean retval = FALSE;
694 g_return_val_if_fail (!block || dispatch, FALSE);
696 g_get_current_time (¤t_time);
700 /* If recursing, finish up current dispatch, before starting over */
701 if (pending_dispatches)
704 g_main_dispatch (¤t_time);
706 G_UNLOCK (main_loop);
711 /* Prepare all sources */
713 timeout = block ? -1 : 0;
715 hook = g_hook_first_valid (&source_list, TRUE);
718 GSource *source = (GSource *)hook;
719 gint source_timeout = -1;
721 if ((n_ready > 0) && (source->priority > current_priority))
723 g_hook_unref (&source_list, hook);
726 if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
728 hook = g_hook_next_valid (&source_list, hook, TRUE);
732 in_check_or_prepare++;
733 if (hook->flags & G_SOURCE_READY ||
734 ((GSourceFuncs *) hook->func)->prepare (source->source_data,
738 in_check_or_prepare--;
741 hook->flags |= G_SOURCE_READY;
742 g_hook_unref (&source_list, hook);
743 G_UNLOCK (main_loop);
749 hook->flags |= G_SOURCE_READY;
751 current_priority = source->priority;
756 in_check_or_prepare--;
758 if (source_timeout >= 0)
761 timeout = source_timeout;
763 timeout = MIN (timeout, source_timeout);
766 hook = g_hook_next_valid (&source_list, hook, TRUE);
769 /* poll(), if necessary */
771 g_main_poll (timeout, n_ready > 0, current_priority);
773 /* Check to see what sources need to be dispatched */
777 hook = g_hook_first_valid (&source_list, TRUE);
780 GSource *source = (GSource *)hook;
782 if ((n_ready > 0) && (source->priority > current_priority))
784 g_hook_unref (&source_list, hook);
787 if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
789 hook = g_hook_next_valid (&source_list, hook, TRUE);
793 in_check_or_prepare++;
794 if (hook->flags & G_SOURCE_READY ||
795 ((GSourceFuncs *) hook->func)->check (source->source_data,
798 in_check_or_prepare--;
801 hook->flags &= ~G_SOURCE_READY;
802 g_hook_ref (&source_list, hook);
803 pending_dispatches = g_slist_prepend (pending_dispatches, source);
804 current_priority = source->priority;
809 g_hook_unref (&source_list, hook);
810 G_UNLOCK (main_loop);
816 in_check_or_prepare--;
818 hook = g_hook_next_valid (&source_list, hook, TRUE);
821 /* Now invoke the callbacks */
823 if (pending_dispatches)
825 pending_dispatches = g_slist_reverse (pending_dispatches);
826 g_main_dispatch (¤t_time);
830 G_UNLOCK (main_loop);
835 /* See if any events are pending
838 g_main_pending (void)
840 return in_check_or_prepare ? FALSE : g_main_iterate (FALSE, FALSE);
843 /* Run a single iteration of the mainloop. If block is FALSE,
847 g_main_iteration (gboolean block)
849 if (in_check_or_prepare)
851 g_warning ("g_main_iteration(): called recursively from within a source's check() or "
852 "prepare() member, iteration not possible");
856 return g_main_iterate (block, TRUE);
860 g_main_new (gboolean is_running)
864 loop = g_new0 (GMainLoop, 1);
865 loop->is_running = is_running != FALSE;
871 g_main_run (GMainLoop *loop)
873 g_return_if_fail (loop != NULL);
875 if (in_check_or_prepare)
877 g_warning ("g_main_run(): called recursively from within a source's check() or "
878 "prepare() member, iteration not possible");
882 loop->is_running = TRUE;
883 while (loop->is_running)
884 g_main_iterate (TRUE, TRUE);
888 g_main_quit (GMainLoop *loop)
890 g_return_if_fail (loop != NULL);
892 loop->is_running = FALSE;
896 g_main_destroy (GMainLoop *loop)
898 g_return_if_fail (loop != NULL);
904 g_main_is_running (GMainLoop *loop)
906 g_return_val_if_fail (loop != NULL, FALSE);
908 return loop->is_running;
911 /* HOLDS: main_loop_lock */
913 g_main_poll (gint timeout,
914 gboolean use_priority,
922 #ifdef G_THREADS_ENABLED
924 if (wake_up_pipe[0] < 0)
926 if (pipe (wake_up_pipe) < 0)
927 g_error ("Cannot create pipe main loop wake-up: %s\n",
930 wake_up_rec.fd = wake_up_pipe[0];
931 wake_up_rec.events = G_IO_IN;
932 g_main_add_poll_unlocked (0, &wake_up_rec);
935 if (wake_up_semaphore == NULL)
937 if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
938 g_error ("Cannot create wake-up semaphore: %d", GetLastError ());
939 wake_up_rec.fd = (gint) wake_up_semaphore;
940 wake_up_rec.events = G_IO_IN;
941 g_main_add_poll_unlocked (0, &wake_up_rec);
945 fd_array = g_new (GPollFD, n_poll_records);
947 pollrec = poll_records;
949 while (pollrec && (!use_priority || priority >= pollrec->priority))
951 fd_array[i].fd = pollrec->fd->fd;
952 fd_array[i].events = pollrec->fd->events;
953 fd_array[i].revents = 0;
955 pollrec = pollrec->next;
958 #ifdef G_THREADS_ENABLED
961 G_UNLOCK (main_loop);
963 (*poll_func) (fd_array, npoll, timeout);
966 #ifdef G_THREADS_ENABLED
971 read (wake_up_pipe[0], &c, 1);
975 poll_waiting = FALSE;
978 pollrec = poll_records;
982 pollrec->fd->revents = fd_array[i].revents;
983 pollrec = pollrec->next;
991 g_main_add_poll (GPollFD *fd,
995 g_main_add_poll_unlocked (priority, fd);
996 G_UNLOCK (main_loop);
999 /* HOLDS: main_loop_lock */
1001 g_main_add_poll_unlocked (gint priority,
1004 GPollRec *lastrec, *pollrec, *newrec;
1007 poll_chunk = g_mem_chunk_create (GPollRec, 32, G_ALLOC_ONLY);
1011 newrec = poll_free_list;
1012 poll_free_list = newrec->next;
1015 newrec = g_chunk_new (GPollRec, poll_chunk);
1018 newrec->priority = priority;
1021 pollrec = poll_records;
1022 while (pollrec && priority >= pollrec->priority)
1025 pollrec = pollrec->next;
1029 lastrec->next = newrec;
1031 poll_records = newrec;
1033 newrec->next = pollrec;
1039 g_main_remove_poll (GPollFD *fd)
1041 GPollRec *pollrec, *lastrec;
1046 pollrec = poll_records;
1050 if (pollrec->fd == fd)
1052 if (lastrec != NULL)
1053 lastrec->next = pollrec->next;
1055 poll_records = pollrec->next;
1057 pollrec->next = poll_free_list;
1058 poll_free_list = pollrec;
1064 pollrec = pollrec->next;
1067 G_UNLOCK (main_loop);
1071 g_main_set_poll_func (GPollFunc func)
1077 poll_func = (GPollFunc) poll;
1079 poll_func = (GPollFunc) g_poll;
1086 g_timeout_prepare (gpointer source_data,
1087 GTimeVal *current_time,
1091 GTimeoutData *data = source_data;
1093 msec = (data->expiration.tv_sec - current_time->tv_sec) * 1000 +
1094 (data->expiration.tv_usec - current_time->tv_usec) / 1000;
1096 *timeout = (msec <= 0) ? 0 : msec;
1102 g_timeout_check (gpointer source_data,
1103 GTimeVal *current_time)
1105 GTimeoutData *data = source_data;
1107 return (data->expiration.tv_sec < current_time->tv_sec) ||
1108 ((data->expiration.tv_sec == current_time->tv_sec) &&
1109 (data->expiration.tv_usec <= current_time->tv_usec));
1113 g_timeout_dispatch (gpointer source_data,
1114 GTimeVal *current_time,
1117 GTimeoutData *data = source_data;
1119 if (data->callback(user_data))
1121 guint seconds = data->interval / 1000;
1122 guint msecs = data->interval - seconds * 1000;
1124 data->expiration.tv_sec = current_time->tv_sec + seconds;
1125 data->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
1126 if (data->expiration.tv_usec >= 1000000)
1128 data->expiration.tv_usec -= 1000000;
1129 data->expiration.tv_sec++;
1138 g_timeout_add_full (gint priority,
1140 GSourceFunc function,
1142 GDestroyNotify notify)
1146 GTimeoutData *timeout_data = g_new (GTimeoutData, 1);
1148 timeout_data->interval = interval;
1149 timeout_data->callback = function;
1150 g_get_current_time (&timeout_data->expiration);
1152 seconds = timeout_data->interval / 1000;
1153 msecs = timeout_data->interval - seconds * 1000;
1155 timeout_data->expiration.tv_sec += seconds;
1156 timeout_data->expiration.tv_usec += msecs * 1000;
1157 if (timeout_data->expiration.tv_usec >= 1000000)
1159 timeout_data->expiration.tv_usec -= 1000000;
1160 timeout_data->expiration.tv_sec++;
1163 return g_source_add (priority, FALSE, &timeout_funcs, timeout_data, data, notify);
1167 g_timeout_add (guint32 interval,
1168 GSourceFunc function,
1171 return g_timeout_add_full (G_PRIORITY_DEFAULT,
1172 interval, function, data, NULL);
1175 /* Idle functions */
1178 g_idle_prepare (gpointer source_data,
1179 GTimeVal *current_time,
1187 g_idle_check (gpointer source_data,
1188 GTimeVal *current_time)
1194 g_idle_dispatch (gpointer source_data,
1195 GTimeVal *current_time,
1198 GSourceFunc func = source_data;
1200 return func (user_data);
1204 g_idle_add_full (gint priority,
1205 GSourceFunc function,
1207 GDestroyNotify notify)
1209 g_return_val_if_fail (function != NULL, 0);
1211 return g_source_add (priority, FALSE, &idle_funcs, function, data, notify);
1215 g_idle_add (GSourceFunc function,
1218 return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
1222 g_idle_remove_by_data (gpointer data)
1224 return g_source_remove_by_funcs_user_data (&idle_funcs, data);