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)
439 g_hook_list_init (&source_list, sizeof (GSource));
441 source_list.hook_destroy = G_HOOK_DEFERRED_DESTROY;
442 source_list.hook_free = g_source_destroy_func;
445 source = (GSource*) g_hook_alloc (&source_list);
446 source->priority = priority;
447 source->source_data = source_data;
448 source->hook.func = funcs;
449 source->hook.data = user_data;
450 source->hook.destroy = notify;
452 g_hook_insert_sorted (&source_list,
457 source->hook.flags |= G_SOURCE_CAN_RECURSE;
459 return_val = source->hook.hook_id;
461 #ifdef G_THREADS_ENABLED
462 /* Now wake up the main loop if it is waiting in the poll() */
466 poll_waiting = FALSE;
468 write (wake_up_pipe[1], "A", 1);
470 ReleaseSemaphore (wake_up_semaphore, 1, NULL);
474 G_UNLOCK (main_loop);
480 g_source_remove (guint tag)
484 g_return_val_if_fail (tag > 0, FALSE);
488 hook = g_hook_get (&source_list, tag);
490 g_hook_destroy_link (&source_list, hook);
492 G_UNLOCK (main_loop);
498 g_source_remove_by_user_data (gpointer user_data)
504 hook = g_hook_find_data (&source_list, TRUE, user_data);
506 g_hook_destroy_link (&source_list, hook);
508 G_UNLOCK (main_loop);
514 g_source_find_source_data (GHook *hook,
517 GSource *source = (GSource *)hook;
519 return (source->source_data == data);
523 g_source_remove_by_source_data (gpointer source_data)
529 hook = g_hook_find (&source_list, TRUE,
530 g_source_find_source_data, source_data);
532 g_hook_destroy_link (&source_list, hook);
534 G_UNLOCK (main_loop);
540 g_source_find_funcs_user_data (GHook *hook,
545 return hook->func == d[0] && hook->data == d[1];
549 g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
555 g_return_val_if_fail (funcs != NULL, FALSE);
562 hook = g_hook_find (&source_list, TRUE,
563 g_source_find_funcs_user_data, d);
565 g_hook_destroy_link (&source_list, hook);
567 G_UNLOCK (main_loop);
573 g_get_current_time (GTimeVal *result)
577 g_return_if_fail (result != NULL);
579 /*this is required on alpha, there the timeval structs are int's
580 not longs and a cast only would fail horribly*/
581 gettimeofday (&r, NULL);
582 result->tv_sec = r.tv_sec;
583 result->tv_usec = r.tv_usec;
585 /* Avoid calling time() except for the first time.
586 * GetTickCount() should be pretty fast and low-level?
587 * I could also use ftime() but it seems unnecessarily overheady.
589 static DWORD start_tick = 0;
590 static time_t start_time;
594 g_return_if_fail (result != NULL);
598 start_tick = GetTickCount ();
602 tick = GetTickCount ();
604 result->tv_sec = (tick - start_tick) / 1000 + start_time;
605 result->tv_usec = ((tick - start_tick) % 1000) * 1000;
609 /* Running the main loop */
611 /* HOLDS: main_loop_lock */
613 g_main_dispatch (GTimeVal *current_time)
615 while (pending_dispatches != NULL)
617 gboolean need_destroy;
618 GSource *source = pending_dispatches->data;
621 tmp_list = pending_dispatches;
622 pending_dispatches = g_slist_remove_link (pending_dispatches, pending_dispatches);
623 g_slist_free_1 (tmp_list);
625 if (G_HOOK_IS_VALID (source))
627 gboolean was_in_call;
628 gpointer hook_data = source->hook.data;
629 gpointer source_data = source->source_data;
630 gboolean (*dispatch) (gpointer,
634 dispatch = ((GSourceFuncs *) source->hook.func)->dispatch;
636 was_in_call = G_HOOK_IN_CALL (source);
637 source->hook.flags |= G_HOOK_FLAG_IN_CALL;
639 G_UNLOCK (main_loop);
640 need_destroy = ! dispatch (source_data,
646 source->hook.flags &= ~G_HOOK_FLAG_IN_CALL;
648 if (need_destroy && G_HOOK_IS_VALID (source))
649 g_hook_destroy_link (&source_list, (GHook *) source);
652 g_hook_unref (&source_list, (GHook*) source);
656 /* g_main_iterate () runs a single iteration of the mainloop, or,
657 * if !dispatch checks to see if any sources need dispatching.
658 * basic algorithm for dispatch=TRUE:
660 * 1) while the list of currently pending sources is non-empty,
661 * we call (*dispatch) on those that are !IN_CALL or can_recurse,
662 * removing sources from the list after each returns.
663 * the return value of (*dispatch) determines whether the source
664 * itself is kept alive.
666 * 2) call (*prepare) for sources that are not yet SOURCE_READY and
667 * are !IN_CALL or can_recurse. a return value of TRUE determines
668 * that the source would like to be dispatched immediatedly, it
669 * is then flagged as SOURCE_READY.
671 * 3) poll with the pollfds from all sources at the priority of the
672 * first source flagged as SOURCE_READY. if there are any sources
673 * flagged as SOURCE_READY, we use a timeout of 0 or the minimum
674 * of all timouts otherwise.
676 * 4) for each source !IN_CALL or can_recurse, if SOURCE_READY or
677 * (*check) returns true, add the source to the pending list.
678 * once one source returns true, stop after checking all sources
681 * 5) while the list of currently pending sources is non-empty,
682 * call (*dispatch) on each source, removing the source
687 g_main_iterate (gboolean block,
691 GTimeVal current_time ={ 0, 0 };
693 gint current_priority = 0;
695 gboolean retval = FALSE;
697 g_return_val_if_fail (!block || dispatch, FALSE);
699 g_get_current_time (¤t_time);
703 /* If recursing, finish up current dispatch, before starting over */
704 if (pending_dispatches)
707 g_main_dispatch (¤t_time);
709 G_UNLOCK (main_loop);
714 /* Prepare all sources */
716 timeout = block ? -1 : 0;
718 hook = g_hook_first_valid (&source_list, TRUE);
721 GSource *source = (GSource *)hook;
722 gint source_timeout = -1;
724 if ((n_ready > 0) && (source->priority > current_priority))
726 g_hook_unref (&source_list, hook);
729 if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
731 hook = g_hook_next_valid (&source_list, hook, TRUE);
735 in_check_or_prepare++;
736 if (hook->flags & G_SOURCE_READY ||
737 ((GSourceFuncs *) hook->func)->prepare (source->source_data,
741 in_check_or_prepare--;
744 hook->flags |= G_SOURCE_READY;
745 g_hook_unref (&source_list, hook);
746 G_UNLOCK (main_loop);
752 hook->flags |= G_SOURCE_READY;
754 current_priority = source->priority;
759 in_check_or_prepare--;
761 if (source_timeout >= 0)
764 timeout = source_timeout;
766 timeout = MIN (timeout, source_timeout);
769 hook = g_hook_next_valid (&source_list, hook, TRUE);
772 /* poll(), if necessary */
774 g_main_poll (timeout, n_ready > 0, current_priority);
776 /* Check to see what sources need to be dispatched */
780 hook = g_hook_first_valid (&source_list, TRUE);
783 GSource *source = (GSource *)hook;
785 if ((n_ready > 0) && (source->priority > current_priority))
787 g_hook_unref (&source_list, hook);
790 if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
792 hook = g_hook_next_valid (&source_list, hook, TRUE);
796 in_check_or_prepare++;
797 if (hook->flags & G_SOURCE_READY ||
798 ((GSourceFuncs *) hook->func)->check (source->source_data,
801 in_check_or_prepare--;
804 hook->flags &= ~G_SOURCE_READY;
805 g_hook_ref (&source_list, hook);
806 pending_dispatches = g_slist_prepend (pending_dispatches, source);
807 current_priority = source->priority;
812 g_hook_unref (&source_list, hook);
813 G_UNLOCK (main_loop);
819 in_check_or_prepare--;
821 hook = g_hook_next_valid (&source_list, hook, TRUE);
824 /* Now invoke the callbacks */
826 if (pending_dispatches)
828 pending_dispatches = g_slist_reverse (pending_dispatches);
829 g_main_dispatch (¤t_time);
833 G_UNLOCK (main_loop);
838 /* See if any events are pending
841 g_main_pending (void)
843 return in_check_or_prepare ? FALSE : g_main_iterate (FALSE, FALSE);
846 /* Run a single iteration of the mainloop. If block is FALSE,
850 g_main_iteration (gboolean block)
852 if (in_check_or_prepare)
854 g_warning ("g_main_iteration(): called recursively from within a source's check() or "
855 "prepare() member, iteration not possible");
859 return g_main_iterate (block, TRUE);
863 g_main_new (gboolean is_running)
867 loop = g_new0 (GMainLoop, 1);
868 loop->is_running = is_running != FALSE;
874 g_main_run (GMainLoop *loop)
876 g_return_if_fail (loop != NULL);
878 if (in_check_or_prepare)
880 g_warning ("g_main_run(): called recursively from within a source's check() or "
881 "prepare() member, iteration not possible");
885 loop->is_running = TRUE;
886 while (loop->is_running)
887 g_main_iterate (TRUE, TRUE);
891 g_main_quit (GMainLoop *loop)
893 g_return_if_fail (loop != NULL);
895 loop->is_running = FALSE;
899 g_main_destroy (GMainLoop *loop)
901 g_return_if_fail (loop != NULL);
907 g_main_is_running (GMainLoop *loop)
909 g_return_val_if_fail (loop != NULL, FALSE);
911 return loop->is_running;
914 /* HOLDS: main_loop_lock */
916 g_main_poll (gint timeout,
917 gboolean use_priority,
925 #ifdef G_THREADS_ENABLED
927 if (wake_up_pipe[0] < 0)
929 if (pipe (wake_up_pipe) < 0)
930 g_error ("Cannot create pipe main loop wake-up: %s\n",
933 wake_up_rec.fd = wake_up_pipe[0];
934 wake_up_rec.events = G_IO_IN;
935 g_main_add_poll_unlocked (0, &wake_up_rec);
938 if (wake_up_semaphore == NULL)
940 if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
941 g_error ("Cannot create wake-up semaphore: %d", GetLastError ());
942 wake_up_rec.fd = (gint) wake_up_semaphore;
943 wake_up_rec.events = G_IO_IN;
944 g_main_add_poll_unlocked (0, &wake_up_rec);
948 fd_array = g_new (GPollFD, n_poll_records);
950 pollrec = poll_records;
952 while (pollrec && (!use_priority || priority >= pollrec->priority))
954 fd_array[i].fd = pollrec->fd->fd;
955 fd_array[i].events = pollrec->fd->events;
956 fd_array[i].revents = 0;
958 pollrec = pollrec->next;
961 #ifdef G_THREADS_ENABLED
964 G_UNLOCK (main_loop);
966 (*poll_func) (fd_array, npoll, timeout);
969 #ifdef G_THREADS_ENABLED
974 read (wake_up_pipe[0], &c, 1);
978 poll_waiting = FALSE;
981 pollrec = poll_records;
985 pollrec->fd->revents = fd_array[i].revents;
986 pollrec = pollrec->next;
994 g_main_add_poll (GPollFD *fd,
998 g_main_add_poll_unlocked (priority, fd);
999 G_UNLOCK (main_loop);
1002 /* HOLDS: main_loop_lock */
1004 g_main_add_poll_unlocked (gint priority,
1007 GPollRec *lastrec, *pollrec, *newrec;
1010 poll_chunk = g_mem_chunk_create (GPollRec, 32, G_ALLOC_ONLY);
1014 newrec = poll_free_list;
1015 poll_free_list = newrec->next;
1018 newrec = g_chunk_new (GPollRec, poll_chunk);
1021 newrec->priority = priority;
1024 pollrec = poll_records;
1025 while (pollrec && priority >= pollrec->priority)
1028 pollrec = pollrec->next;
1032 lastrec->next = newrec;
1034 poll_records = newrec;
1036 newrec->next = pollrec;
1042 g_main_remove_poll (GPollFD *fd)
1044 GPollRec *pollrec, *lastrec;
1049 pollrec = poll_records;
1053 if (pollrec->fd == fd)
1055 if (lastrec != NULL)
1056 lastrec->next = pollrec->next;
1058 poll_records = pollrec->next;
1060 pollrec->next = poll_free_list;
1061 poll_free_list = pollrec;
1067 pollrec = pollrec->next;
1070 G_UNLOCK (main_loop);
1074 g_main_set_poll_func (GPollFunc func)
1080 poll_func = (GPollFunc) poll;
1082 poll_func = (GPollFunc) g_poll;
1089 g_timeout_prepare (gpointer source_data,
1090 GTimeVal *current_time,
1094 GTimeoutData *data = source_data;
1096 msec = (data->expiration.tv_sec - current_time->tv_sec) * 1000 +
1097 (data->expiration.tv_usec - current_time->tv_usec) / 1000;
1099 *timeout = (msec <= 0) ? 0 : msec;
1105 g_timeout_check (gpointer source_data,
1106 GTimeVal *current_time)
1108 GTimeoutData *data = source_data;
1110 return (data->expiration.tv_sec < current_time->tv_sec) ||
1111 ((data->expiration.tv_sec == current_time->tv_sec) &&
1112 (data->expiration.tv_usec <= current_time->tv_usec));
1116 g_timeout_dispatch (gpointer source_data,
1117 GTimeVal *current_time,
1120 GTimeoutData *data = source_data;
1122 if (data->callback (user_data))
1124 guint seconds = data->interval / 1000;
1125 guint msecs = data->interval - seconds * 1000;
1127 data->expiration.tv_sec = current_time->tv_sec + seconds;
1128 data->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
1129 if (data->expiration.tv_usec >= 1000000)
1131 data->expiration.tv_usec -= 1000000;
1132 data->expiration.tv_sec++;
1141 g_timeout_add_full (gint priority,
1143 GSourceFunc function,
1145 GDestroyNotify notify)
1149 GTimeoutData *timeout_data = g_new (GTimeoutData, 1);
1151 timeout_data->interval = interval;
1152 timeout_data->callback = function;
1153 g_get_current_time (&timeout_data->expiration);
1155 seconds = timeout_data->interval / 1000;
1156 msecs = timeout_data->interval - seconds * 1000;
1158 timeout_data->expiration.tv_sec += seconds;
1159 timeout_data->expiration.tv_usec += msecs * 1000;
1160 if (timeout_data->expiration.tv_usec >= 1000000)
1162 timeout_data->expiration.tv_usec -= 1000000;
1163 timeout_data->expiration.tv_sec++;
1166 return g_source_add (priority, FALSE, &timeout_funcs, timeout_data, data, notify);
1170 g_timeout_add (guint32 interval,
1171 GSourceFunc function,
1174 return g_timeout_add_full (G_PRIORITY_DEFAULT,
1175 interval, function, data, NULL);
1178 /* Idle functions */
1181 g_idle_prepare (gpointer source_data,
1182 GTimeVal *current_time,
1190 g_idle_check (gpointer source_data,
1191 GTimeVal *current_time)
1197 g_idle_dispatch (gpointer source_data,
1198 GTimeVal *current_time,
1201 GSourceFunc func = source_data;
1203 return func (user_data);
1207 g_idle_add_full (gint priority,
1208 GSourceFunc function,
1210 GDestroyNotify notify)
1212 g_return_val_if_fail (function != NULL, 0);
1214 return g_source_add (priority, FALSE, &idle_funcs, function, data, notify);
1218 g_idle_add (GSourceFunc function,
1221 return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
1225 g_idle_remove_by_data (gpointer data)
1227 return g_source_remove_by_funcs_user_data (&idle_funcs, data);