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 Lesser 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 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser 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.
24 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
25 * file for a list of people on the GLib Team. See the ChangeLog
26 * files for a list of changes. These files are distributed with
27 * GLib at ftp://ftp.gtk.org/pub/gtk/.
35 #include "glibconfig.h"
37 /* Uncomment the next line (and the corresponding line in gpoll.c) to
38 * enable debugging printouts if the environment variable
39 * G_MAIN_POLL_DEBUG is set to some value.
41 /* #define G_MAIN_POLL_DEBUG */
44 /* Always enable debugging printout on Windows, as it is more often
47 #define G_MAIN_POLL_DEBUG
51 #include "glib-unix.h"
54 #include <sys/eventfd.h>
59 #include <sys/types.h>
62 #ifdef HAVE_SYS_TIME_H
64 #endif /* HAVE_SYS_TIME_H */
67 #endif /* HAVE_UNISTD_H */
74 #endif /* G_OS_WIN32 */
77 #include <sys/socket.h>
79 #endif /* G_OS_BEOS */
84 #include "giochannel.h"
88 #include "gstrfuncs.h"
89 #include "gtestutils.h"
95 #ifdef G_MAIN_POLL_DEBUG
100 #include "gmain-internal.h"
101 #include "glib-private.h"
105 * @title: The Main Event Loop
106 * @short_description: manages all available sources of events
108 * The main event loop manages all the available sources of events for
109 * GLib and GTK+ applications. These events can come from any number of
110 * different types of sources such as file descriptors (plain files,
111 * pipes or sockets) and timeouts. New types of event sources can also
112 * be added using g_source_attach().
114 * To allow multiple independent sets of sources to be handled in
115 * different threads, each source is associated with a #GMainContext.
116 * A GMainContext can only be running in a single thread, but
117 * sources can be added to it and removed from it from other threads.
119 * Each event source is assigned a priority. The default priority,
120 * #G_PRIORITY_DEFAULT, is 0. Values less than 0 denote higher priorities.
121 * Values greater than 0 denote lower priorities. Events from high priority
122 * sources are always processed before events from lower priority sources.
124 * Idle functions can also be added, and assigned a priority. These will
125 * be run whenever no events with a higher priority are ready to be processed.
127 * The #GMainLoop data type represents a main event loop. A GMainLoop is
128 * created with g_main_loop_new(). After adding the initial event sources,
129 * g_main_loop_run() is called. This continuously checks for new events from
130 * each of the event sources and dispatches them. Finally, the processing of
131 * an event from one of the sources leads to a call to g_main_loop_quit() to
132 * exit the main loop, and g_main_loop_run() returns.
134 * It is possible to create new instances of #GMainLoop recursively.
135 * This is often used in GTK+ applications when showing modal dialog
136 * boxes. Note that event sources are associated with a particular
137 * #GMainContext, and will be checked and dispatched for all main
138 * loops associated with that GMainContext.
140 * GTK+ contains wrappers of some of these functions, e.g. gtk_main(),
141 * gtk_main_quit() and gtk_events_pending().
143 * <refsect2><title>Creating new source types</title>
144 * <para>One of the unusual features of the #GMainLoop functionality
145 * is that new types of event source can be created and used in
146 * addition to the builtin type of event source. A new event source
147 * type is used for handling GDK events. A new source type is created
148 * by <firstterm>deriving</firstterm> from the #GSource structure.
149 * The derived type of source is represented by a structure that has
150 * the #GSource structure as a first element, and other elements specific
151 * to the new source type. To create an instance of the new source type,
152 * call g_source_new() passing in the size of the derived structure and
153 * a table of functions. These #GSourceFuncs determine the behavior of
154 * the new source type.</para>
155 * <para>New source types basically interact with the main context
156 * in two ways. Their prepare function in #GSourceFuncs can set a timeout
157 * to determine the maximum amount of time that the main loop will sleep
158 * before checking the source again. In addition, or as well, the source
159 * can add file descriptors to the set that the main context checks using
160 * g_source_add_poll().</para>
162 * <refsect2><title>Customizing the main loop iteration</title>
163 * <para>Single iterations of a #GMainContext can be run with
164 * g_main_context_iteration(). In some cases, more detailed control
165 * of exactly how the details of the main loop work is desired, for
166 * instance, when integrating the #GMainLoop with an external main loop.
167 * In such cases, you can call the component functions of
168 * g_main_context_iteration() directly. These functions are
169 * g_main_context_prepare(), g_main_context_query(),
170 * g_main_context_check() and g_main_context_dispatch().</para>
171 * <para>The operation of these functions can best be seen in terms
172 * of a state diagram, as shown in <xref linkend="mainloop-states"/>.</para>
173 * <figure id="mainloop-states"><title>States of a Main Context</title>
174 * <graphic fileref="mainloop-states.gif" format="GIF"></graphic>
178 * On Unix, the GLib mainloop is incompatible with fork(). Any program
179 * using the mainloop must either exec() or exit() from the child
180 * without returning to the mainloop.
185 typedef struct _GTimeoutSource GTimeoutSource;
186 typedef struct _GChildWatchSource GChildWatchSource;
187 typedef struct _GUnixSignalWatchSource GUnixSignalWatchSource;
188 typedef struct _GPollRec GPollRec;
189 typedef struct _GSourceCallback GSourceCallback;
193 G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,
194 G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1)
197 typedef struct _GMainWaiter GMainWaiter;
205 typedef struct _GMainDispatch GMainDispatch;
207 struct _GMainDispatch
210 GSList *dispatching_sources; /* stack of current sources */
213 #ifdef G_MAIN_POLL_DEBUG
214 gboolean _g_main_poll_debug = FALSE;
219 /* The following lock is used for both the list of sources
220 * and the list of poll records
230 GPtrArray *pending_dispatches;
231 gint timeout; /* Timeout for current iteration */
234 GSource *source_list;
235 gint in_check_or_prepare;
237 GPollRec *poll_records, *poll_records_tail;
238 guint n_poll_records;
239 GPollFD *cached_poll_array;
240 guint cached_poll_array_size;
246 /* Flag indicating whether the set of fd's changed during a poll */
247 gboolean poll_changed;
252 gboolean time_is_fresh;
255 struct _GSourceCallback
260 GDestroyNotify notify;
265 GMainContext *context;
270 struct _GTimeoutSource
278 struct _GChildWatchSource
285 #else /* G_OS_WIN32 */
286 gboolean child_exited;
287 #endif /* G_OS_WIN32 */
290 struct _GUnixSignalWatchSource
305 struct _GSourcePrivate
307 GSList *child_sources;
308 GSource *parent_source;
311 #define LOCK_CONTEXT(context) g_mutex_lock (&context->mutex)
312 #define UNLOCK_CONTEXT(context) g_mutex_unlock (&context->mutex)
313 #define G_THREAD_SELF g_thread_self ()
315 #define SOURCE_DESTROYED(source) (((source)->flags & G_HOOK_FLAG_ACTIVE) == 0)
316 #define SOURCE_BLOCKED(source) (((source)->flags & G_HOOK_FLAG_IN_CALL) != 0 && \
317 ((source)->flags & G_SOURCE_CAN_RECURSE) == 0)
319 #define SOURCE_UNREF(source, context) \
321 if ((source)->ref_count > 1) \
322 (source)->ref_count--; \
324 g_source_unref_internal ((source), (context), TRUE); \
328 /* Forward declarations */
330 static void g_source_unref_internal (GSource *source,
331 GMainContext *context,
333 static void g_source_destroy_internal (GSource *source,
334 GMainContext *context,
336 static void g_source_set_priority_unlocked (GSource *source,
337 GMainContext *context,
339 static void g_main_context_poll (GMainContext *context,
344 static void g_main_context_add_poll_unlocked (GMainContext *context,
347 static void g_main_context_remove_poll_unlocked (GMainContext *context,
350 static gboolean g_timeout_prepare (GSource *source,
352 static gboolean g_timeout_check (GSource *source);
353 static gboolean g_timeout_dispatch (GSource *source,
354 GSourceFunc callback,
356 static gboolean g_child_watch_prepare (GSource *source,
358 static gboolean g_child_watch_check (GSource *source);
359 static gboolean g_child_watch_dispatch (GSource *source,
360 GSourceFunc callback,
362 static void g_child_watch_finalize (GSource *source);
364 static void g_unix_signal_handler (int signum);
365 static gboolean g_unix_signal_watch_prepare (GSource *source,
367 static gboolean g_unix_signal_watch_check (GSource *source);
368 static gboolean g_unix_signal_watch_dispatch (GSource *source,
369 GSourceFunc callback,
371 static void g_unix_signal_watch_finalize (GSource *source);
373 static gboolean g_idle_prepare (GSource *source,
375 static gboolean g_idle_check (GSource *source);
376 static gboolean g_idle_dispatch (GSource *source,
377 GSourceFunc callback,
380 static GMainContext *glib_worker_context;
382 G_LOCK_DEFINE_STATIC (main_loop);
383 static GMainContext *default_main_context;
388 /* UNIX signals work by marking one of these variables then waking the
389 * worker context to check on them and dispatch accordingly.
391 static volatile gchar unix_signal_pending[NSIG];
392 static volatile gboolean any_unix_signal_pending;
394 /* Guards all the data below */
395 G_LOCK_DEFINE_STATIC (unix_signal_lock);
396 static GSList *unix_signal_watches;
397 static GSList *unix_child_watches;
399 static GSourceFuncs g_unix_signal_funcs =
401 g_unix_signal_watch_prepare,
402 g_unix_signal_watch_check,
403 g_unix_signal_watch_dispatch,
404 g_unix_signal_watch_finalize
406 #endif /* !G_OS_WIN32 */
407 G_LOCK_DEFINE_STATIC (main_context_list);
408 static GSList *main_context_list = NULL;
410 GSourceFuncs g_timeout_funcs =
418 GSourceFuncs g_child_watch_funcs =
420 g_child_watch_prepare,
422 g_child_watch_dispatch,
423 g_child_watch_finalize
426 GSourceFuncs g_idle_funcs =
435 * g_main_context_ref:
436 * @context: a #GMainContext
438 * Increases the reference count on a #GMainContext object by one.
440 * Returns: the @context that was passed in (since 2.6)
443 g_main_context_ref (GMainContext *context)
445 g_return_val_if_fail (context != NULL, NULL);
446 g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL);
448 g_atomic_int_inc (&context->ref_count);
454 poll_rec_list_free (GMainContext *context,
457 g_slice_free_chain (GPollRec, list, next);
461 * g_main_context_unref:
462 * @context: a #GMainContext
464 * Decreases the reference count on a #GMainContext object by one. If
465 * the result is zero, free the context and free all associated memory.
468 g_main_context_unref (GMainContext *context)
471 g_return_if_fail (context != NULL);
472 g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
474 if (!g_atomic_int_dec_and_test (&context->ref_count))
477 G_LOCK (main_context_list);
478 main_context_list = g_slist_remove (main_context_list, context);
479 G_UNLOCK (main_context_list);
481 source = context->source_list;
484 GSource *next = source->next;
485 g_source_destroy_internal (source, context, FALSE);
489 g_mutex_clear (&context->mutex);
491 g_ptr_array_free (context->pending_dispatches, TRUE);
492 g_free (context->cached_poll_array);
494 poll_rec_list_free (context, context->poll_records);
496 g_wakeup_free (context->wakeup);
497 g_cond_clear (&context->cond);
503 * g_main_context_new:
505 * Creates a new #GMainContext structure.
507 * Return value: the new #GMainContext
510 g_main_context_new (void)
512 static gsize initialised;
513 GMainContext *context;
515 if (g_once_init_enter (&initialised))
517 #ifdef G_MAIN_POLL_DEBUG
518 if (getenv ("G_MAIN_POLL_DEBUG") != NULL)
519 _g_main_poll_debug = TRUE;
522 g_once_init_leave (&initialised, TRUE);
525 context = g_new0 (GMainContext, 1);
527 g_mutex_init (&context->mutex);
528 g_cond_init (&context->cond);
530 context->owner = NULL;
531 context->waiters = NULL;
533 context->ref_count = 1;
535 context->next_id = 1;
537 context->source_list = NULL;
539 context->poll_func = g_poll;
541 context->cached_poll_array = NULL;
542 context->cached_poll_array_size = 0;
544 context->pending_dispatches = g_ptr_array_new ();
546 context->time_is_fresh = FALSE;
548 context->wakeup = g_wakeup_new ();
549 g_wakeup_get_pollfd (context->wakeup, &context->wake_up_rec);
550 g_main_context_add_poll_unlocked (context, 0, &context->wake_up_rec);
552 G_LOCK (main_context_list);
553 main_context_list = g_slist_append (main_context_list, context);
555 #ifdef G_MAIN_POLL_DEBUG
556 if (_g_main_poll_debug)
557 g_print ("created context=%p\n", context);
560 G_UNLOCK (main_context_list);
566 * g_main_context_default:
568 * Returns the global default main context. This is the main context
569 * used for main loop functions when a main loop is not explicitly
570 * specified, and corresponds to the "main" main loop. See also
571 * g_main_context_get_thread_default().
573 * Return value: (transfer none): the global default main context.
576 g_main_context_default (void)
582 if (!default_main_context)
584 default_main_context = g_main_context_new ();
585 #ifdef G_MAIN_POLL_DEBUG
586 if (_g_main_poll_debug)
587 g_print ("default context=%p\n", default_main_context);
591 G_UNLOCK (main_loop);
593 return default_main_context;
597 free_context (gpointer data)
599 GMainContext *context = data;
601 g_main_context_release (context);
603 g_main_context_unref (context);
607 free_context_stack (gpointer data)
609 g_queue_free_full((GQueue *) data, (GDestroyNotify) free_context);
612 static GPrivate thread_context_stack = G_PRIVATE_INIT (free_context_stack);
615 * g_main_context_push_thread_default:
616 * @context: a #GMainContext, or %NULL for the global default context
618 * Acquires @context and sets it as the thread-default context for the
619 * current thread. This will cause certain asynchronous operations
620 * (such as most <link linkend="gio">gio</link>-based I/O) which are
621 * started in this thread to run under @context and deliver their
622 * results to its main loop, rather than running under the global
623 * default context in the main thread. Note that calling this function
624 * changes the context returned by
625 * g_main_context_get_thread_default(), <emphasis>not</emphasis> the
626 * one returned by g_main_context_default(), so it does not affect the
627 * context used by functions like g_idle_add().
629 * Normally you would call this function shortly after creating a new
630 * thread, passing it a #GMainContext which will be run by a
631 * #GMainLoop in that thread, to set a new default context for all
632 * async operations in that thread. (In this case, you don't need to
633 * ever call g_main_context_pop_thread_default().) In some cases
634 * however, you may want to schedule a single operation in a
635 * non-default context, or temporarily use a non-default context in
636 * the main thread. In that case, you can wrap the call to the
637 * asynchronous operation inside a
638 * g_main_context_push_thread_default() /
639 * g_main_context_pop_thread_default() pair, but it is up to you to
640 * ensure that no other asynchronous operations accidentally get
641 * started while the non-default context is active.
643 * Beware that libraries that predate this function may not correctly
644 * handle being used from a thread with a thread-default context. Eg,
645 * see g_file_supports_thread_contexts().
650 g_main_context_push_thread_default (GMainContext *context)
653 gboolean acquired_context;
655 acquired_context = g_main_context_acquire (context);
656 g_return_if_fail (acquired_context);
658 if (context == g_main_context_default ())
661 g_main_context_ref (context);
663 stack = g_private_get (&thread_context_stack);
666 stack = g_queue_new ();
667 g_private_set (&thread_context_stack, stack);
670 g_queue_push_head (stack, context);
674 * g_main_context_pop_thread_default:
675 * @context: a #GMainContext object, or %NULL
677 * Pops @context off the thread-default context stack (verifying that
678 * it was on the top of the stack).
683 g_main_context_pop_thread_default (GMainContext *context)
687 if (context == g_main_context_default ())
690 stack = g_private_get (&thread_context_stack);
692 g_return_if_fail (stack != NULL);
693 g_return_if_fail (g_queue_peek_head (stack) == context);
695 g_queue_pop_head (stack);
697 g_main_context_release (context);
699 g_main_context_unref (context);
703 * g_main_context_get_thread_default:
705 * Gets the thread-default #GMainContext for this thread. Asynchronous
706 * operations that want to be able to be run in contexts other than
707 * the default one should call this method or
708 * g_main_context_ref_thread_default() to get a #GMainContext to add
709 * their #GSource<!-- -->s to. (Note that even in single-threaded
710 * programs applications may sometimes want to temporarily push a
711 * non-default context, so it is not safe to assume that this will
712 * always return %NULL if you are running in the default thread.)
714 * If you need to hold a reference on the context, use
715 * g_main_context_ref_thread_default() instead.
717 * Returns: (transfer none): the thread-default #GMainContext, or
718 * %NULL if the thread-default context is the global default context.
723 g_main_context_get_thread_default (void)
727 stack = g_private_get (&thread_context_stack);
729 return g_queue_peek_head (stack);
735 * g_main_context_ref_thread_default:
737 * Gets the thread-default #GMainContext for this thread, as with
738 * g_main_context_get_thread_default(), but also adds a reference to
739 * it with g_main_context_ref(). In addition, unlike
740 * g_main_context_get_thread_default(), if the thread-default context
741 * is the global default context, this will return that #GMainContext
742 * (with a ref added to it) rather than returning %NULL.
744 * Returns: (transfer full): the thread-default #GMainContext. Unref
745 * with g_main_context_unref() when you are done with it.
750 g_main_context_ref_thread_default (void)
752 GMainContext *context;
754 context = g_main_context_get_thread_default ();
756 context = g_main_context_default ();
757 return g_main_context_ref (context);
760 /* Hooks for adding to the main loop */
764 * @source_funcs: structure containing functions that implement
765 * the sources behavior.
766 * @struct_size: size of the #GSource structure to create.
768 * Creates a new #GSource structure. The size is specified to
769 * allow creating structures derived from #GSource that contain
770 * additional data. The size passed in must be at least
771 * <literal>sizeof (GSource)</literal>.
773 * The source will not initially be associated with any #GMainContext
774 * and must be added to one with g_source_attach() before it will be
777 * Return value: the newly-created #GSource.
780 g_source_new (GSourceFuncs *source_funcs,
785 g_return_val_if_fail (source_funcs != NULL, NULL);
786 g_return_val_if_fail (struct_size >= sizeof (GSource), NULL);
788 source = (GSource*) g_malloc0 (struct_size);
790 source->source_funcs = source_funcs;
791 source->ref_count = 1;
793 source->priority = G_PRIORITY_DEFAULT;
795 source->flags = G_HOOK_FLAG_ACTIVE;
797 /* NULL/0 initialization for all other fields */
802 /* Holds context's lock
805 g_source_list_add (GSource *source,
806 GMainContext *context)
808 GSource *tmp_source, *last_source;
810 if (source->priv && source->priv->parent_source)
812 /* Put the source immediately before its parent */
813 tmp_source = source->priv->parent_source;
814 last_source = source->priv->parent_source->prev;
819 tmp_source = context->source_list;
820 while (tmp_source && tmp_source->priority <= source->priority)
822 last_source = tmp_source;
823 tmp_source = tmp_source->next;
827 source->next = tmp_source;
829 tmp_source->prev = source;
831 source->prev = last_source;
833 last_source->next = source;
835 context->source_list = source;
838 /* Holds context's lock
841 g_source_list_remove (GSource *source,
842 GMainContext *context)
845 source->prev->next = source->next;
847 context->source_list = source->next;
850 source->next->prev = source->prev;
857 g_source_attach_unlocked (GSource *source,
858 GMainContext *context)
863 source->context = context;
864 result = source->source_id = context->next_id++;
867 g_source_list_add (source, context);
869 tmp_list = source->poll_fds;
872 g_main_context_add_poll_unlocked (context, source->priority, tmp_list->data);
873 tmp_list = tmp_list->next;
878 tmp_list = source->priv->child_sources;
881 g_source_attach_unlocked (tmp_list->data, context);
882 tmp_list = tmp_list->next;
891 * @source: a #GSource
892 * @context: (allow-none): a #GMainContext (if %NULL, the default context will be used)
894 * Adds a #GSource to a @context so that it will be executed within
895 * that context. Remove it by calling g_source_destroy().
897 * Return value: the ID (greater than 0) for the source within the
901 g_source_attach (GSource *source,
902 GMainContext *context)
906 g_return_val_if_fail (source->context == NULL, 0);
907 g_return_val_if_fail (!SOURCE_DESTROYED (source), 0);
910 context = g_main_context_default ();
912 LOCK_CONTEXT (context);
914 result = g_source_attach_unlocked (source, context);
916 /* If another thread has acquired the context, wake it up since it
917 * might be in poll() right now.
919 if (context->owner && context->owner != G_THREAD_SELF)
920 g_wakeup_signal (context->wakeup);
922 UNLOCK_CONTEXT (context);
928 g_source_destroy_internal (GSource *source,
929 GMainContext *context,
933 LOCK_CONTEXT (context);
935 if (!SOURCE_DESTROYED (source))
938 gpointer old_cb_data;
939 GSourceCallbackFuncs *old_cb_funcs;
941 source->flags &= ~G_HOOK_FLAG_ACTIVE;
943 old_cb_data = source->callback_data;
944 old_cb_funcs = source->callback_funcs;
946 source->callback_data = NULL;
947 source->callback_funcs = NULL;
951 UNLOCK_CONTEXT (context);
952 old_cb_funcs->unref (old_cb_data);
953 LOCK_CONTEXT (context);
956 if (!SOURCE_BLOCKED (source))
958 tmp_list = source->poll_fds;
961 g_main_context_remove_poll_unlocked (context, tmp_list->data);
962 tmp_list = tmp_list->next;
966 if (source->priv && source->priv->child_sources)
968 /* This is safe because even if a child_source finalizer or
969 * closure notify tried to modify source->priv->child_sources
970 * from outside the lock, it would fail since
971 * SOURCE_DESTROYED(source) is now TRUE.
973 tmp_list = source->priv->child_sources;
976 g_source_destroy_internal (tmp_list->data, context, TRUE);
977 g_source_unref_internal (tmp_list->data, context, TRUE);
978 tmp_list = tmp_list->next;
980 g_slist_free (source->priv->child_sources);
981 source->priv->child_sources = NULL;
984 g_source_unref_internal (source, context, TRUE);
988 UNLOCK_CONTEXT (context);
993 * @source: a #GSource
995 * Removes a source from its #GMainContext, if any, and mark it as
996 * destroyed. The source cannot be subsequently added to another
1000 g_source_destroy (GSource *source)
1002 GMainContext *context;
1004 g_return_if_fail (source != NULL);
1006 context = source->context;
1009 g_source_destroy_internal (source, context, FALSE);
1011 source->flags &= ~G_HOOK_FLAG_ACTIVE;
1016 * @source: a #GSource
1018 * Returns the numeric ID for a particular source. The ID of a source
1019 * is a positive integer which is unique within a particular main loop
1020 * context. The reverse
1021 * mapping from ID to source is done by g_main_context_find_source_by_id().
1023 * Return value: the ID (greater than 0) for the source
1026 g_source_get_id (GSource *source)
1030 g_return_val_if_fail (source != NULL, 0);
1031 g_return_val_if_fail (source->context != NULL, 0);
1033 LOCK_CONTEXT (source->context);
1034 result = source->source_id;
1035 UNLOCK_CONTEXT (source->context);
1041 * g_source_get_context:
1042 * @source: a #GSource
1044 * Gets the #GMainContext with which the source is associated.
1045 * Calling this function on a destroyed source is an error.
1047 * Return value: (transfer none): the #GMainContext with which the
1048 * source is associated, or %NULL if the context has not
1049 * yet been added to a source.
1052 g_source_get_context (GSource *source)
1054 g_return_val_if_fail (!SOURCE_DESTROYED (source), NULL);
1056 return source->context;
1060 * g_source_add_poll:
1061 * @source:a #GSource
1062 * @fd: a #GPollFD structure holding information about a file
1063 * descriptor to watch.
1065 * Adds a file descriptor to the set of file descriptors polled for
1066 * this source. This is usually combined with g_source_new() to add an
1067 * event source. The event source's check function will typically test
1068 * the @revents field in the #GPollFD struct and return %TRUE if events need
1072 g_source_add_poll (GSource *source,
1075 GMainContext *context;
1077 g_return_if_fail (source != NULL);
1078 g_return_if_fail (fd != NULL);
1079 g_return_if_fail (!SOURCE_DESTROYED (source));
1081 context = source->context;
1084 LOCK_CONTEXT (context);
1086 source->poll_fds = g_slist_prepend (source->poll_fds, fd);
1090 if (!SOURCE_BLOCKED (source))
1091 g_main_context_add_poll_unlocked (context, source->priority, fd);
1092 UNLOCK_CONTEXT (context);
1097 * g_source_remove_poll:
1098 * @source:a #GSource
1099 * @fd: a #GPollFD structure previously passed to g_source_add_poll().
1101 * Removes a file descriptor from the set of file descriptors polled for
1105 g_source_remove_poll (GSource *source,
1108 GMainContext *context;
1110 g_return_if_fail (source != NULL);
1111 g_return_if_fail (fd != NULL);
1112 g_return_if_fail (!SOURCE_DESTROYED (source));
1114 context = source->context;
1117 LOCK_CONTEXT (context);
1119 source->poll_fds = g_slist_remove (source->poll_fds, fd);
1123 if (!SOURCE_BLOCKED (source))
1124 g_main_context_remove_poll_unlocked (context, fd);
1125 UNLOCK_CONTEXT (context);
1130 * g_source_add_child_source:
1131 * @source:a #GSource
1132 * @child_source: a second #GSource that @source should "poll"
1134 * Adds @child_source to @source as a "polled" source; when @source is
1135 * added to a #GMainContext, @child_source will be automatically added
1136 * with the same priority, when @child_source is triggered, it will
1137 * cause @source to dispatch (in addition to calling its own
1138 * callback), and when @source is destroyed, it will destroy
1139 * @child_source as well. (@source will also still be dispatched if
1140 * its own prepare/check functions indicate that it is ready.)
1142 * If you don't need @child_source to do anything on its own when it
1143 * triggers, you can call g_source_set_dummy_callback() on it to set a
1144 * callback that does nothing (except return %TRUE if appropriate).
1146 * @source will hold a reference on @child_source while @child_source
1147 * is attached to it.
1152 g_source_add_child_source (GSource *source,
1153 GSource *child_source)
1155 GMainContext *context;
1157 g_return_if_fail (source != NULL);
1158 g_return_if_fail (child_source != NULL);
1159 g_return_if_fail (!SOURCE_DESTROYED (source));
1160 g_return_if_fail (!SOURCE_DESTROYED (child_source));
1161 g_return_if_fail (child_source->context == NULL);
1162 g_return_if_fail (child_source->priv == NULL || child_source->priv->parent_source == NULL);
1164 context = source->context;
1167 LOCK_CONTEXT (context);
1170 source->priv = g_slice_new0 (GSourcePrivate);
1171 if (!child_source->priv)
1172 child_source->priv = g_slice_new0 (GSourcePrivate);
1174 source->priv->child_sources = g_slist_prepend (source->priv->child_sources,
1175 g_source_ref (child_source));
1176 child_source->priv->parent_source = source;
1177 g_source_set_priority_unlocked (child_source, NULL, source->priority);
1181 UNLOCK_CONTEXT (context);
1182 g_source_attach (child_source, context);
1187 * g_source_remove_child_source:
1188 * @source:a #GSource
1189 * @child_source: a #GSource previously passed to
1190 * g_source_add_child_source().
1192 * Detaches @child_source from @source and destroys it.
1197 g_source_remove_child_source (GSource *source,
1198 GSource *child_source)
1200 GMainContext *context;
1202 g_return_if_fail (source != NULL);
1203 g_return_if_fail (child_source != NULL);
1204 g_return_if_fail (child_source->priv != NULL && child_source->priv->parent_source == source);
1205 g_return_if_fail (!SOURCE_DESTROYED (source));
1206 g_return_if_fail (!SOURCE_DESTROYED (child_source));
1208 context = source->context;
1211 LOCK_CONTEXT (context);
1213 source->priv->child_sources = g_slist_remove (source->priv->child_sources, child_source);
1214 g_source_destroy_internal (child_source, context, TRUE);
1215 g_source_unref_internal (child_source, context, TRUE);
1218 UNLOCK_CONTEXT (context);
1222 * g_source_set_callback_indirect:
1223 * @source: the source
1224 * @callback_data: pointer to callback data "object"
1225 * @callback_funcs: functions for reference counting @callback_data
1226 * and getting the callback and data
1228 * Sets the callback function storing the data as a refcounted callback
1229 * "object". This is used internally. Note that calling
1230 * g_source_set_callback_indirect() assumes
1231 * an initial reference count on @callback_data, and thus
1232 * @callback_funcs->unref will eventually be called once more
1233 * than @callback_funcs->ref.
1236 g_source_set_callback_indirect (GSource *source,
1237 gpointer callback_data,
1238 GSourceCallbackFuncs *callback_funcs)
1240 GMainContext *context;
1241 gpointer old_cb_data;
1242 GSourceCallbackFuncs *old_cb_funcs;
1244 g_return_if_fail (source != NULL);
1245 g_return_if_fail (callback_funcs != NULL || callback_data == NULL);
1247 context = source->context;
1250 LOCK_CONTEXT (context);
1252 old_cb_data = source->callback_data;
1253 old_cb_funcs = source->callback_funcs;
1255 source->callback_data = callback_data;
1256 source->callback_funcs = callback_funcs;
1259 UNLOCK_CONTEXT (context);
1262 old_cb_funcs->unref (old_cb_data);
1266 g_source_callback_ref (gpointer cb_data)
1268 GSourceCallback *callback = cb_data;
1270 callback->ref_count++;
1275 g_source_callback_unref (gpointer cb_data)
1277 GSourceCallback *callback = cb_data;
1279 callback->ref_count--;
1280 if (callback->ref_count == 0)
1282 if (callback->notify)
1283 callback->notify (callback->data);
1289 g_source_callback_get (gpointer cb_data,
1294 GSourceCallback *callback = cb_data;
1296 *func = callback->func;
1297 *data = callback->data;
1300 static GSourceCallbackFuncs g_source_callback_funcs = {
1301 g_source_callback_ref,
1302 g_source_callback_unref,
1303 g_source_callback_get,
1307 * g_source_set_callback:
1308 * @source: the source
1309 * @func: a callback function
1310 * @data: the data to pass to callback function
1311 * @notify: a function to call when @data is no longer in use, or %NULL.
1313 * Sets the callback function for a source. The callback for a source is
1314 * called from the source's dispatch function.
1316 * The exact type of @func depends on the type of source; ie. you
1317 * should not count on @func being called with @data as its first
1320 * Typically, you won't use this function. Instead use functions specific
1321 * to the type of source you are using.
1324 g_source_set_callback (GSource *source,
1327 GDestroyNotify notify)
1329 GSourceCallback *new_callback;
1331 g_return_if_fail (source != NULL);
1333 new_callback = g_new (GSourceCallback, 1);
1335 new_callback->ref_count = 1;
1336 new_callback->func = func;
1337 new_callback->data = data;
1338 new_callback->notify = notify;
1340 g_source_set_callback_indirect (source, new_callback, &g_source_callback_funcs);
1345 * g_source_set_funcs:
1346 * @source: a #GSource
1347 * @funcs: the new #GSourceFuncs
1349 * Sets the source functions (can be used to override
1350 * default implementations) of an unattached source.
1355 g_source_set_funcs (GSource *source,
1356 GSourceFuncs *funcs)
1358 g_return_if_fail (source != NULL);
1359 g_return_if_fail (source->context == NULL);
1360 g_return_if_fail (source->ref_count > 0);
1361 g_return_if_fail (funcs != NULL);
1363 source->source_funcs = funcs;
1367 g_source_set_priority_unlocked (GSource *source,
1368 GMainContext *context,
1373 source->priority = priority;
1377 /* Remove the source from the context's source and then
1378 * add it back so it is sorted in the correct place
1380 g_source_list_remove (source, source->context);
1381 g_source_list_add (source, source->context);
1383 if (!SOURCE_BLOCKED (source))
1385 tmp_list = source->poll_fds;
1388 g_main_context_remove_poll_unlocked (context, tmp_list->data);
1389 g_main_context_add_poll_unlocked (context, priority, tmp_list->data);
1391 tmp_list = tmp_list->next;
1396 if (source->priv && source->priv->child_sources)
1398 tmp_list = source->priv->child_sources;
1401 g_source_set_priority_unlocked (tmp_list->data, context, priority);
1402 tmp_list = tmp_list->next;
1408 * g_source_set_priority:
1409 * @source: a #GSource
1410 * @priority: the new priority.
1412 * Sets the priority of a source. While the main loop is being run, a
1413 * source will be dispatched if it is ready to be dispatched and no
1414 * sources at a higher (numerically smaller) priority are ready to be
1418 g_source_set_priority (GSource *source,
1421 GMainContext *context;
1423 g_return_if_fail (source != NULL);
1425 context = source->context;
1428 LOCK_CONTEXT (context);
1429 g_source_set_priority_unlocked (source, context, priority);
1431 UNLOCK_CONTEXT (source->context);
1435 * g_source_get_priority:
1436 * @source: a #GSource
1438 * Gets the priority of a source.
1440 * Return value: the priority of the source
1443 g_source_get_priority (GSource *source)
1445 g_return_val_if_fail (source != NULL, 0);
1447 return source->priority;
1451 * g_source_set_can_recurse:
1452 * @source: a #GSource
1453 * @can_recurse: whether recursion is allowed for this source
1455 * Sets whether a source can be called recursively. If @can_recurse is
1456 * %TRUE, then while the source is being dispatched then this source
1457 * will be processed normally. Otherwise, all processing of this
1458 * source is blocked until the dispatch function returns.
1461 g_source_set_can_recurse (GSource *source,
1462 gboolean can_recurse)
1464 GMainContext *context;
1466 g_return_if_fail (source != NULL);
1468 context = source->context;
1471 LOCK_CONTEXT (context);
1474 source->flags |= G_SOURCE_CAN_RECURSE;
1476 source->flags &= ~G_SOURCE_CAN_RECURSE;
1479 UNLOCK_CONTEXT (context);
1483 * g_source_get_can_recurse:
1484 * @source: a #GSource
1486 * Checks whether a source is allowed to be called recursively.
1487 * see g_source_set_can_recurse().
1489 * Return value: whether recursion is allowed.
1492 g_source_get_can_recurse (GSource *source)
1494 g_return_val_if_fail (source != NULL, FALSE);
1496 return (source->flags & G_SOURCE_CAN_RECURSE) != 0;
1501 * g_source_set_name:
1502 * @source: a #GSource
1503 * @name: debug name for the source
1505 * Sets a name for the source, used in debugging and profiling.
1506 * The name defaults to #NULL.
1508 * The source name should describe in a human-readable way
1509 * what the source does. For example, "X11 event queue"
1510 * or "GTK+ repaint idle handler" or whatever it is.
1512 * It is permitted to call this function multiple times, but is not
1513 * recommended due to the potential performance impact. For example,
1514 * one could change the name in the "check" function of a #GSourceFuncs
1515 * to include details like the event type in the source name.
1520 g_source_set_name (GSource *source,
1523 g_return_if_fail (source != NULL);
1525 /* setting back to NULL is allowed, just because it's
1526 * weird if get_name can return NULL but you can't
1530 g_free (source->name);
1531 source->name = g_strdup (name);
1535 * g_source_get_name:
1536 * @source: a #GSource
1538 * Gets a name for the source, used in debugging and profiling.
1539 * The name may be #NULL if it has never been set with
1540 * g_source_set_name().
1542 * Return value: the name of the source
1546 g_source_get_name (GSource *source)
1548 g_return_val_if_fail (source != NULL, NULL);
1550 return source->name;
1554 * g_source_set_name_by_id:
1555 * @tag: a #GSource ID
1556 * @name: debug name for the source
1558 * Sets the name of a source using its ID.
1560 * This is a convenience utility to set source names from the return
1561 * value of g_idle_add(), g_timeout_add(), etc.
1566 g_source_set_name_by_id (guint tag,
1571 g_return_if_fail (tag > 0);
1573 source = g_main_context_find_source_by_id (NULL, tag);
1577 g_source_set_name (source, name);
1583 * @source: a #GSource
1585 * Increases the reference count on a source by one.
1587 * Return value: @source
1590 g_source_ref (GSource *source)
1592 GMainContext *context;
1594 g_return_val_if_fail (source != NULL, NULL);
1596 context = source->context;
1599 LOCK_CONTEXT (context);
1601 source->ref_count++;
1604 UNLOCK_CONTEXT (context);
1609 /* g_source_unref() but possible to call within context lock
1612 g_source_unref_internal (GSource *source,
1613 GMainContext *context,
1616 gpointer old_cb_data = NULL;
1617 GSourceCallbackFuncs *old_cb_funcs = NULL;
1619 g_return_if_fail (source != NULL);
1621 if (!have_lock && context)
1622 LOCK_CONTEXT (context);
1624 source->ref_count--;
1625 if (source->ref_count == 0)
1627 old_cb_data = source->callback_data;
1628 old_cb_funcs = source->callback_funcs;
1630 source->callback_data = NULL;
1631 source->callback_funcs = NULL;
1635 if (!SOURCE_DESTROYED (source))
1636 g_warning (G_STRLOC ": ref_count == 0, but source was still attached to a context!");
1637 g_source_list_remove (source, context);
1640 if (source->source_funcs->finalize)
1643 UNLOCK_CONTEXT (context);
1644 source->source_funcs->finalize (source);
1646 LOCK_CONTEXT (context);
1649 g_free (source->name);
1650 source->name = NULL;
1652 g_slist_free (source->poll_fds);
1653 source->poll_fds = NULL;
1657 g_slice_free (GSourcePrivate, source->priv);
1658 source->priv = NULL;
1664 if (!have_lock && context)
1665 UNLOCK_CONTEXT (context);
1670 UNLOCK_CONTEXT (context);
1672 old_cb_funcs->unref (old_cb_data);
1675 LOCK_CONTEXT (context);
1681 * @source: a #GSource
1683 * Decreases the reference count of a source by one. If the
1684 * resulting reference count is zero the source and associated
1685 * memory will be destroyed.
1688 g_source_unref (GSource *source)
1690 g_return_if_fail (source != NULL);
1692 g_source_unref_internal (source, source->context, FALSE);
1696 * g_main_context_find_source_by_id:
1697 * @context: a #GMainContext (if %NULL, the default context will be used)
1698 * @source_id: the source ID, as returned by g_source_get_id().
1700 * Finds a #GSource given a pair of context and ID.
1702 * Return value: (transfer none): the #GSource if found, otherwise, %NULL
1705 g_main_context_find_source_by_id (GMainContext *context,
1710 g_return_val_if_fail (source_id > 0, NULL);
1712 if (context == NULL)
1713 context = g_main_context_default ();
1715 LOCK_CONTEXT (context);
1717 source = context->source_list;
1720 if (!SOURCE_DESTROYED (source) &&
1721 source->source_id == source_id)
1723 source = source->next;
1726 UNLOCK_CONTEXT (context);
1732 * g_main_context_find_source_by_funcs_user_data:
1733 * @context: a #GMainContext (if %NULL, the default context will be used).
1734 * @funcs: the @source_funcs passed to g_source_new().
1735 * @user_data: the user data from the callback.
1737 * Finds a source with the given source functions and user data. If
1738 * multiple sources exist with the same source function and user data,
1739 * the first one found will be returned.
1741 * Return value: (transfer none): the source, if one was found, otherwise %NULL
1744 g_main_context_find_source_by_funcs_user_data (GMainContext *context,
1745 GSourceFuncs *funcs,
1750 g_return_val_if_fail (funcs != NULL, NULL);
1752 if (context == NULL)
1753 context = g_main_context_default ();
1755 LOCK_CONTEXT (context);
1757 source = context->source_list;
1760 if (!SOURCE_DESTROYED (source) &&
1761 source->source_funcs == funcs &&
1762 source->callback_funcs)
1764 GSourceFunc callback;
1765 gpointer callback_data;
1767 source->callback_funcs->get (source->callback_data, source, &callback, &callback_data);
1769 if (callback_data == user_data)
1772 source = source->next;
1775 UNLOCK_CONTEXT (context);
1781 * g_main_context_find_source_by_user_data:
1782 * @context: a #GMainContext
1783 * @user_data: the user_data for the callback.
1785 * Finds a source with the given user data for the callback. If
1786 * multiple sources exist with the same user data, the first
1787 * one found will be returned.
1789 * Return value: (transfer none): the source, if one was found, otherwise %NULL
1792 g_main_context_find_source_by_user_data (GMainContext *context,
1797 if (context == NULL)
1798 context = g_main_context_default ();
1800 LOCK_CONTEXT (context);
1802 source = context->source_list;
1805 if (!SOURCE_DESTROYED (source) &&
1806 source->callback_funcs)
1808 GSourceFunc callback;
1809 gpointer callback_data = NULL;
1811 source->callback_funcs->get (source->callback_data, source, &callback, &callback_data);
1813 if (callback_data == user_data)
1816 source = source->next;
1819 UNLOCK_CONTEXT (context);
1826 * @tag: the ID of the source to remove.
1828 * Removes the source with the given id from the default main context.
1830 * a #GSource is given by g_source_get_id(), or will be returned by the
1831 * functions g_source_attach(), g_idle_add(), g_idle_add_full(),
1832 * g_timeout_add(), g_timeout_add_full(), g_child_watch_add(),
1833 * g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full().
1835 * See also g_source_destroy(). You must use g_source_destroy() for sources
1836 * added to a non-default main context.
1838 * Return value: %TRUE if the source was found and removed.
1841 g_source_remove (guint tag)
1845 g_return_val_if_fail (tag > 0, FALSE);
1847 source = g_main_context_find_source_by_id (NULL, tag);
1849 g_source_destroy (source);
1851 return source != NULL;
1855 * g_source_remove_by_user_data:
1856 * @user_data: the user_data for the callback.
1858 * Removes a source from the default main loop context given the user
1859 * data for the callback. If multiple sources exist with the same user
1860 * data, only one will be destroyed.
1862 * Return value: %TRUE if a source was found and removed.
1865 g_source_remove_by_user_data (gpointer user_data)
1869 source = g_main_context_find_source_by_user_data (NULL, user_data);
1872 g_source_destroy (source);
1880 * g_source_remove_by_funcs_user_data:
1881 * @funcs: The @source_funcs passed to g_source_new()
1882 * @user_data: the user data for the callback
1884 * Removes a source from the default main loop context given the
1885 * source functions and user data. If multiple sources exist with the
1886 * same source functions and user data, only one will be destroyed.
1888 * Return value: %TRUE if a source was found and removed.
1891 g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
1896 g_return_val_if_fail (funcs != NULL, FALSE);
1898 source = g_main_context_find_source_by_funcs_user_data (NULL, funcs, user_data);
1901 g_source_destroy (source);
1909 * g_get_current_time:
1910 * @result: #GTimeVal structure in which to store current time.
1912 * Equivalent to the UNIX gettimeofday() function, but portable.
1914 * You may find g_get_real_time() to be more convenient.
1917 g_get_current_time (GTimeVal *result)
1922 g_return_if_fail (result != NULL);
1924 /*this is required on alpha, there the timeval structs are int's
1925 not longs and a cast only would fail horribly*/
1926 gettimeofday (&r, NULL);
1927 result->tv_sec = r.tv_sec;
1928 result->tv_usec = r.tv_usec;
1933 g_return_if_fail (result != NULL);
1935 GetSystemTimeAsFileTime (&ft);
1936 memmove (&time64, &ft, sizeof (FILETIME));
1938 /* Convert from 100s of nanoseconds since 1601-01-01
1939 * to Unix epoch. Yes, this is Y2038 unsafe.
1941 time64 -= G_GINT64_CONSTANT (116444736000000000);
1944 result->tv_sec = time64 / 1000000;
1945 result->tv_usec = time64 % 1000000;
1952 * Queries the system wall-clock time.
1954 * This call is functionally equivalent to g_get_current_time() except
1955 * that the return value is often more convenient than dealing with a
1958 * You should only use this call if you are actually interested in the real
1959 * wall-clock time. g_get_monotonic_time() is probably more useful for
1960 * measuring intervals.
1962 * Returns: the number of microseconds since January 1, 1970 UTC.
1967 g_get_real_time (void)
1971 g_get_current_time (&tv);
1973 return (((gint64) tv.tv_sec) * 1000000) + tv.tv_usec;
1977 static ULONGLONG (*g_GetTickCount64) (void) = NULL;
1978 static guint32 g_win32_tick_epoch = 0;
1980 G_GNUC_INTERNAL void
1981 g_clock_win32_init (void)
1985 g_GetTickCount64 = NULL;
1986 kernel32 = GetModuleHandle ("KERNEL32.DLL");
1987 if (kernel32 != NULL)
1988 g_GetTickCount64 = (void *) GetProcAddress (kernel32, "GetTickCount64");
1989 g_win32_tick_epoch = ((guint32)GetTickCount()) >> 31;
1994 * g_get_monotonic_time:
1996 * Queries the system monotonic time, if available.
1998 * On POSIX systems with clock_gettime() and <literal>CLOCK_MONOTONIC</literal> this call
1999 * is a very shallow wrapper for that. Otherwise, we make a best effort
2000 * that probably involves returning the wall clock time (with at least
2001 * microsecond accuracy, subject to the limitations of the OS kernel).
2003 * It's important to note that POSIX <literal>CLOCK_MONOTONIC</literal> does
2004 * not count time spent while the machine is suspended.
2006 * On Windows, "limitations of the OS kernel" is a rather substantial
2007 * statement. Depending on the configuration of the system, the wall
2008 * clock time is updated as infrequently as 64 times a second (which
2009 * is approximately every 16ms). Also, the on XP (not on Vista or later)
2010 * the monitonic clock is locally monotonic, but may differ in exact
2011 * value between processes due to timer wrap handling.
2013 * Returns: the monotonic time, in microseconds
2018 g_get_monotonic_time (void)
2020 #ifdef HAVE_CLOCK_GETTIME
2021 /* librt clock_gettime() is our first choice */
2024 #ifdef CLOCK_MONOTONIC
2025 clock_gettime (CLOCK_MONOTONIC, &ts);
2027 clock_gettime (CLOCK_REALTIME, &ts);
2030 /* In theory monotonic time can have any epoch.
2032 * glib presently assumes the following:
2034 * 1) The epoch comes some time after the birth of Jesus of Nazareth, but
2035 * not more than 10000 years later.
2037 * 2) The current time also falls sometime within this range.
2039 * These two reasonable assumptions leave us with a maximum deviation from
2040 * the epoch of 10000 years, or 315569520000000000 seconds.
2042 * If we restrict ourselves to this range then the number of microseconds
2043 * will always fit well inside the constraints of a int64 (by a factor of
2046 * If you actually hit the following assertion, probably you should file a
2047 * bug against your operating system for being excessively silly.
2049 g_assert (G_GINT64_CONSTANT (-315569520000000000) < ts.tv_sec &&
2050 ts.tv_sec < G_GINT64_CONSTANT (315569520000000000));
2052 return (((gint64) ts.tv_sec) * 1000000) + (ts.tv_nsec / 1000);
2054 #elif defined (G_OS_WIN32)
2058 /* There are four of sources for the monotonic on windows:
2060 * Three are based on a (1 msec accuracy, but only read periodically) clock chip:
2061 * - GetTickCount (GTC)
2062 * 32bit msec counter, updated each ~15msec, wraps in ~50 days
2063 * - GetTickCount64 (GTC64)
2064 * Same as GetTickCount, but extended to 64bit, so no wrap
2065 * Only availible in Vista or later
2066 * - timeGetTime (TGT)
2067 * similar to GetTickCount by default: 15msec, 50 day wrap.
2068 * availible in winmm.dll (thus known as the multi media timers)
2069 * However apps can raise the system timer clock frequency using timeBeginPeriod()
2070 * increasing the accuracy up to 1 msec, at a cost in general system performancs
2073 * One is based on high precision clocks:
2074 * - QueryPrecisionCounter (QPC)
2075 * This has much higher accuracy, but is not guaranteed monotonic, and
2076 * has lots of complications like clock jumps and different times on different
2077 * cpus. It also has lower long term accuracy (i.e. it will drift compared to
2078 * the low precision clocks.
2080 * Additionally, the precision availible in the timer-based wakeup such as
2081 * MsgWaitForMultipleObjectsEx (which is what the mainloop is based on) is based
2082 * on the TGT resolution, so by default it is ~15msec, but can be increased by apps.
2084 * The QPC timer has too many issues to be used as is. The only way it could be used
2085 * is to use it to interpolate the lower precision clocks. Firefox does something like
2087 * https://bugzilla.mozilla.org/show_bug.cgi?id=363258
2089 * However this seems quite complicated, so we're not doing this right now.
2091 * The approach we take instead is to use the TGT timer, extenting it to 64bit
2092 * either by using the GTC64 value, or if that is not availible, a process local
2093 * time epoch that we increment when we detect a timer wrap (assumes that we read
2094 * the time at least once every 50 days).
2097 * - We have a globally consistent monotonic clock on Vista and later
2098 * - We have a locally monotonic clock on XP
2099 * - Apps that need higher precision in timeouts and clock reads can call
2100 * timeBeginPeriod() to increase it as much as they want
2103 if (g_GetTickCount64 != NULL)
2105 guint32 ticks_as_32bit;
2107 ticks = g_GetTickCount64 ();
2108 ticks32 = timeGetTime();
2110 /* GTC64 and TGT are sampled at different times, however they
2111 * have the same base and source (msecs since system boot).
2112 * They can differ with as much as -16 to +16 msecs.
2113 * We can't just inject the low bits into the 64bit counter
2114 * as one of the counters can have wrapped in 32bit space and
2115 * the other not. Instead we calulate the signed differece
2116 * in 32bit space and apply that difference to the 64bit counter.
2118 ticks_as_32bit = (guint32)ticks;
2120 /* We could do some 2s complement hack, but we play it safe */
2121 if (ticks32 - ticks_as_32bit <= G_MAXINT32)
2122 ticks += ticks32 - ticks_as_32bit;
2124 ticks -= ticks_as_32bit - ticks32;
2130 epoch = g_atomic_int_get (&g_win32_tick_epoch);
2132 /* Must read ticks after the epoch, then we're guaranteed
2133 that the ticks value we read is higher or equal to any
2134 previous ones that lead to the writing of the epoch. */
2135 ticks32 = timeGetTime();
2137 /* We store the msb of the current time as the lsb
2138 * of the epoch. Comparing these bits lets us detect when
2139 * the 32bit counter has wrapped so we can increase the
2141 * This will work as long as this function is called at
2142 * least once every ~24 days, which is half the wrap time
2143 * of a 32bit msec counter. I think this is pretty likely.
2145 * Note that g_win32_tick_epoch is a process local state,
2146 * so the monotonic clock will not be the same between
2149 if ((ticks32 >> 31) != (epoch & 1))
2152 g_atomic_int_set (&g_win32_tick_epoch, epoch);
2156 ticks = (guint64)ticks32 | ((guint64)epoch) << 31;
2159 return ticks * 1000;
2161 #else /* !HAVE_CLOCK_GETTIME && ! G_OS_WIN32*/
2163 /* It may look like we are discarding accuracy on Windows (since its
2164 * current time is expressed in 100s of nanoseconds) but according to
2165 * many sources, the time is only updated 64 times per second, so
2166 * microsecond accuracy is more than enough.
2170 g_get_current_time (&tv);
2172 return (((gint64) tv.tv_sec) * 1000000) + tv.tv_usec;
2177 g_main_dispatch_free (gpointer dispatch)
2179 g_slice_free (GMainDispatch, dispatch);
2182 /* Running the main loop */
2184 static GMainDispatch *
2187 static GPrivate depth_private = G_PRIVATE_INIT (g_main_dispatch_free);
2188 GMainDispatch *dispatch;
2190 dispatch = g_private_get (&depth_private);
2194 dispatch = g_slice_new0 (GMainDispatch);
2195 g_private_set (&depth_private, dispatch);
2204 * Returns the depth of the stack of calls to
2205 * g_main_context_dispatch() on any #GMainContext in the current thread.
2206 * That is, when called from the toplevel, it gives 0. When
2207 * called from within a callback from g_main_context_iteration()
2208 * (or g_main_loop_run(), etc.) it returns 1. When called from within
2209 * a callback to a recursive call to g_main_context_iteration(),
2210 * it returns 2. And so forth.
2212 * This function is useful in a situation like the following:
2213 * Imagine an extremely simple "garbage collected" system.
2216 * static GList *free_list;
2219 * allocate_memory (gsize size)
2221 * gpointer result = g_malloc (size);
2222 * free_list = g_list_prepend (free_list, result);
2227 * free_allocated_memory (void)
2230 * for (l = free_list; l; l = l->next);
2232 * g_list_free (free_list);
2240 * g_main_context_iteration (NULL, TRUE);
2241 * free_allocated_memory();
2245 * This works from an application, however, if you want to do the same
2246 * thing from a library, it gets more difficult, since you no longer
2247 * control the main loop. You might think you can simply use an idle
2248 * function to make the call to free_allocated_memory(), but that
2249 * doesn't work, since the idle function could be called from a
2250 * recursive callback. This can be fixed by using g_main_depth()
2254 * allocate_memory (gsize size)
2256 * FreeListBlock *block = g_new (FreeListBlock, 1);
2257 * block->mem = g_malloc (size);
2258 * block->depth = g_main_depth ();
2259 * free_list = g_list_prepend (free_list, block);
2260 * return block->mem;
2264 * free_allocated_memory (void)
2268 * int depth = g_main_depth ();
2269 * for (l = free_list; l; );
2271 * GList *next = l->next;
2272 * FreeListBlock *block = l->data;
2273 * if (block->depth > depth)
2275 * g_free (block->mem);
2277 * free_list = g_list_delete_link (free_list, l);
2285 * There is a temptation to use g_main_depth() to solve
2286 * problems with reentrancy. For instance, while waiting for data
2287 * to be received from the network in response to a menu item,
2288 * the menu item might be selected again. It might seem that
2289 * one could make the menu item's callback return immediately
2290 * and do nothing if g_main_depth() returns a value greater than 1.
2291 * However, this should be avoided since the user then sees selecting
2292 * the menu item do nothing. Furthermore, you'll find yourself adding
2293 * these checks all over your code, since there are doubtless many,
2294 * many things that the user could do. Instead, you can use the
2295 * following techniques:
2300 * Use gtk_widget_set_sensitive() or modal dialogs to prevent
2301 * the user from interacting with elements while the main
2302 * loop is recursing.
2307 * Avoid main loop recursion in situations where you can't handle
2308 * arbitrary callbacks. Instead, structure your code so that you
2309 * simply return to the main loop and then get called again when
2310 * there is more work to do.
2315 * Return value: The main loop recursion level in the current thread
2320 GMainDispatch *dispatch = get_dispatch ();
2321 return dispatch->depth;
2325 * g_main_current_source:
2327 * Returns the currently firing source for this thread.
2329 * Return value: (transfer none): The currently firing source or %NULL.
2334 g_main_current_source (void)
2336 GMainDispatch *dispatch = get_dispatch ();
2337 return dispatch->dispatching_sources ? dispatch->dispatching_sources->data : NULL;
2341 * g_source_is_destroyed:
2342 * @source: a #GSource
2344 * Returns whether @source has been destroyed.
2346 * This is important when you operate upon your objects
2347 * from within idle handlers, but may have freed the object
2348 * before the dispatch of your idle handler.
2352 * idle_callback (gpointer data)
2354 * SomeWidget *self = data;
2356 * GDK_THREADS_ENTER (<!-- -->);
2357 * /<!-- -->* do stuff with self *<!-- -->/
2358 * self->idle_id = 0;
2359 * GDK_THREADS_LEAVE (<!-- -->);
2361 * return G_SOURCE_REMOVE;
2365 * some_widget_do_stuff_later (SomeWidget *self)
2367 * self->idle_id = g_idle_add (idle_callback, self);
2371 * some_widget_finalize (GObject *object)
2373 * SomeWidget *self = SOME_WIDGET (object);
2375 * if (self->idle_id)
2376 * g_source_remove (self->idle_id);
2378 * G_OBJECT_CLASS (parent_class)->finalize (object);
2382 * This will fail in a multi-threaded application if the
2383 * widget is destroyed before the idle handler fires due
2384 * to the use after free in the callback. A solution, to
2385 * this particular problem, is to check to if the source
2386 * has already been destroy within the callback.
2390 * idle_callback (gpointer data)
2392 * SomeWidget *self = data;
2394 * GDK_THREADS_ENTER ();
2395 * if (!g_source_is_destroyed (g_main_current_source ()))
2397 * /<!-- -->* do stuff with self *<!-- -->/
2399 * GDK_THREADS_LEAVE ();
2405 * Return value: %TRUE if the source has been destroyed
2410 g_source_is_destroyed (GSource *source)
2412 return SOURCE_DESTROYED (source);
2415 /* Temporarily remove all this source's file descriptors from the
2416 * poll(), so that if data comes available for one of the file descriptors
2417 * we don't continually spin in the poll()
2419 /* HOLDS: source->context's lock */
2421 block_source (GSource *source)
2425 g_return_if_fail (!SOURCE_BLOCKED (source));
2427 tmp_list = source->poll_fds;
2430 g_main_context_remove_poll_unlocked (source->context, tmp_list->data);
2431 tmp_list = tmp_list->next;
2435 /* HOLDS: source->context's lock */
2437 unblock_source (GSource *source)
2441 g_return_if_fail (!SOURCE_BLOCKED (source)); /* Source already unblocked */
2442 g_return_if_fail (!SOURCE_DESTROYED (source));
2444 tmp_list = source->poll_fds;
2447 g_main_context_add_poll_unlocked (source->context, source->priority, tmp_list->data);
2448 tmp_list = tmp_list->next;
2452 /* HOLDS: context's lock */
2454 g_main_dispatch (GMainContext *context)
2456 GMainDispatch *current = get_dispatch ();
2459 for (i = 0; i < context->pending_dispatches->len; i++)
2461 GSource *source = context->pending_dispatches->pdata[i];
2463 context->pending_dispatches->pdata[i] = NULL;
2466 source->flags &= ~G_SOURCE_READY;
2468 if (!SOURCE_DESTROYED (source))
2470 gboolean was_in_call;
2471 gpointer user_data = NULL;
2472 GSourceFunc callback = NULL;
2473 GSourceCallbackFuncs *cb_funcs;
2475 gboolean need_destroy;
2477 gboolean (*dispatch) (GSource *,
2480 GSList current_source_link;
2482 dispatch = source->source_funcs->dispatch;
2483 cb_funcs = source->callback_funcs;
2484 cb_data = source->callback_data;
2487 cb_funcs->ref (cb_data);
2489 if ((source->flags & G_SOURCE_CAN_RECURSE) == 0)
2490 block_source (source);
2492 was_in_call = source->flags & G_HOOK_FLAG_IN_CALL;
2493 source->flags |= G_HOOK_FLAG_IN_CALL;
2496 cb_funcs->get (cb_data, source, &callback, &user_data);
2498 UNLOCK_CONTEXT (context);
2501 /* The on-stack allocation of the GSList is unconventional, but
2502 * we know that the lifetime of the link is bounded to this
2503 * function as the link is kept in a thread specific list and
2504 * not manipulated outside of this function and its descendants.
2505 * Avoiding the overhead of a g_slist_alloc() is useful as many
2506 * applications do little more than dispatch events.
2508 * This is a performance hack - do not revert to g_slist_prepend()!
2510 current_source_link.data = source;
2511 current_source_link.next = current->dispatching_sources;
2512 current->dispatching_sources = ¤t_source_link;
2513 need_destroy = ! dispatch (source,
2516 g_assert (current->dispatching_sources == ¤t_source_link);
2517 current->dispatching_sources = current_source_link.next;
2521 cb_funcs->unref (cb_data);
2523 LOCK_CONTEXT (context);
2526 source->flags &= ~G_HOOK_FLAG_IN_CALL;
2528 if ((source->flags & G_SOURCE_CAN_RECURSE) == 0 &&
2529 !SOURCE_DESTROYED (source))
2530 unblock_source (source);
2532 /* Note: this depends on the fact that we can't switch
2533 * sources from one main context to another
2535 if (need_destroy && !SOURCE_DESTROYED (source))
2537 g_assert (source->context == context);
2538 g_source_destroy_internal (source, context, TRUE);
2542 SOURCE_UNREF (source, context);
2545 g_ptr_array_set_size (context->pending_dispatches, 0);
2548 /* Holds context's lock */
2549 static inline GSource *
2550 next_valid_source (GMainContext *context,
2553 GSource *new_source = source ? source->next : context->source_list;
2557 if (!SOURCE_DESTROYED (new_source))
2559 new_source->ref_count++;
2563 new_source = new_source->next;
2567 SOURCE_UNREF (source, context);
2573 * g_main_context_acquire:
2574 * @context: a #GMainContext
2576 * Tries to become the owner of the specified context.
2577 * If some other thread is the owner of the context,
2578 * returns %FALSE immediately. Ownership is properly
2579 * recursive: the owner can require ownership again
2580 * and will release ownership when g_main_context_release()
2581 * is called as many times as g_main_context_acquire().
2583 * You must be the owner of a context before you
2584 * can call g_main_context_prepare(), g_main_context_query(),
2585 * g_main_context_check(), g_main_context_dispatch().
2587 * Return value: %TRUE if the operation succeeded, and
2588 * this thread is now the owner of @context.
2591 g_main_context_acquire (GMainContext *context)
2593 gboolean result = FALSE;
2594 GThread *self = G_THREAD_SELF;
2596 if (context == NULL)
2597 context = g_main_context_default ();
2599 LOCK_CONTEXT (context);
2601 if (!context->owner)
2603 context->owner = self;
2604 g_assert (context->owner_count == 0);
2607 if (context->owner == self)
2609 context->owner_count++;
2613 UNLOCK_CONTEXT (context);
2619 * g_main_context_release:
2620 * @context: a #GMainContext
2622 * Releases ownership of a context previously acquired by this thread
2623 * with g_main_context_acquire(). If the context was acquired multiple
2624 * times, the ownership will be released only when g_main_context_release()
2625 * is called as many times as it was acquired.
2628 g_main_context_release (GMainContext *context)
2630 if (context == NULL)
2631 context = g_main_context_default ();
2633 LOCK_CONTEXT (context);
2635 context->owner_count--;
2636 if (context->owner_count == 0)
2638 context->owner = NULL;
2640 if (context->waiters)
2642 GMainWaiter *waiter = context->waiters->data;
2643 gboolean loop_internal_waiter = (waiter->mutex == &context->mutex);
2644 context->waiters = g_slist_delete_link (context->waiters,
2646 if (!loop_internal_waiter)
2647 g_mutex_lock (waiter->mutex);
2649 g_cond_signal (waiter->cond);
2651 if (!loop_internal_waiter)
2652 g_mutex_unlock (waiter->mutex);
2656 UNLOCK_CONTEXT (context);
2660 * g_main_context_wait:
2661 * @context: a #GMainContext
2662 * @cond: a condition variable
2663 * @mutex: a mutex, currently held
2665 * Tries to become the owner of the specified context,
2666 * as with g_main_context_acquire(). But if another thread
2667 * is the owner, atomically drop @mutex and wait on @cond until
2668 * that owner releases ownership or until @cond is signaled, then
2669 * try again (once) to become the owner.
2671 * Return value: %TRUE if the operation succeeded, and
2672 * this thread is now the owner of @context.
2675 g_main_context_wait (GMainContext *context,
2679 gboolean result = FALSE;
2680 GThread *self = G_THREAD_SELF;
2681 gboolean loop_internal_waiter;
2683 if (context == NULL)
2684 context = g_main_context_default ();
2686 loop_internal_waiter = (mutex == &context->mutex);
2688 if (!loop_internal_waiter)
2689 LOCK_CONTEXT (context);
2691 if (context->owner && context->owner != self)
2696 waiter.mutex = mutex;
2698 context->waiters = g_slist_append (context->waiters, &waiter);
2700 if (!loop_internal_waiter)
2701 UNLOCK_CONTEXT (context);
2702 g_cond_wait (cond, mutex);
2703 if (!loop_internal_waiter)
2704 LOCK_CONTEXT (context);
2706 context->waiters = g_slist_remove (context->waiters, &waiter);
2709 if (!context->owner)
2711 context->owner = self;
2712 g_assert (context->owner_count == 0);
2715 if (context->owner == self)
2717 context->owner_count++;
2721 if (!loop_internal_waiter)
2722 UNLOCK_CONTEXT (context);
2728 * g_main_context_prepare:
2729 * @context: a #GMainContext
2730 * @priority: location to store priority of highest priority
2731 * source already ready.
2733 * Prepares to poll sources within a main loop. The resulting information
2734 * for polling is determined by calling g_main_context_query ().
2736 * Return value: %TRUE if some source is ready to be dispatched
2740 g_main_context_prepare (GMainContext *context,
2745 gint current_priority = G_MAXINT;
2748 if (context == NULL)
2749 context = g_main_context_default ();
2751 LOCK_CONTEXT (context);
2753 context->time_is_fresh = FALSE;
2755 if (context->in_check_or_prepare)
2757 g_warning ("g_main_context_prepare() called recursively from within a source's check() or "
2758 "prepare() member.");
2759 UNLOCK_CONTEXT (context);
2764 /* If recursing, finish up current dispatch, before starting over */
2765 if (context->pending_dispatches)
2768 g_main_dispatch (context, ¤t_time);
2770 UNLOCK_CONTEXT (context);
2775 /* If recursing, clear list of pending dispatches */
2777 for (i = 0; i < context->pending_dispatches->len; i++)
2779 if (context->pending_dispatches->pdata[i])
2780 SOURCE_UNREF ((GSource *)context->pending_dispatches->pdata[i], context);
2782 g_ptr_array_set_size (context->pending_dispatches, 0);
2784 /* Prepare all sources */
2786 context->timeout = -1;
2788 source = next_valid_source (context, NULL);
2791 gint source_timeout = -1;
2793 if ((n_ready > 0) && (source->priority > current_priority))
2795 SOURCE_UNREF (source, context);
2798 if (SOURCE_BLOCKED (source))
2801 if (!(source->flags & G_SOURCE_READY))
2804 gboolean (*prepare) (GSource *source,
2807 prepare = source->source_funcs->prepare;
2808 context->in_check_or_prepare++;
2809 UNLOCK_CONTEXT (context);
2811 result = (*prepare) (source, &source_timeout);
2813 LOCK_CONTEXT (context);
2814 context->in_check_or_prepare--;
2818 GSource *ready_source = source;
2820 while (ready_source)
2822 ready_source->flags |= G_SOURCE_READY;
2823 ready_source = ready_source->priv ? ready_source->priv->parent_source : NULL;
2828 if (source->flags & G_SOURCE_READY)
2831 current_priority = source->priority;
2832 context->timeout = 0;
2835 if (source_timeout >= 0)
2837 if (context->timeout < 0)
2838 context->timeout = source_timeout;
2840 context->timeout = MIN (context->timeout, source_timeout);
2844 source = next_valid_source (context, source);
2847 UNLOCK_CONTEXT (context);
2850 *priority = current_priority;
2852 return (n_ready > 0);
2856 * g_main_context_query:
2857 * @context: a #GMainContext
2858 * @max_priority: maximum priority source to check
2859 * @timeout_: (out): location to store timeout to be used in polling
2860 * @fds: (out caller-allocates) (array length=n_fds): location to
2861 * store #GPollFD records that need to be polled.
2862 * @n_fds: length of @fds.
2864 * Determines information necessary to poll this main loop.
2866 * Return value: the number of records actually stored in @fds,
2867 * or, if more than @n_fds records need to be stored, the number
2868 * of records that need to be stored.
2871 g_main_context_query (GMainContext *context,
2880 LOCK_CONTEXT (context);
2882 pollrec = context->poll_records;
2884 while (pollrec && max_priority >= pollrec->priority)
2886 /* We need to include entries with fd->events == 0 in the array because
2887 * otherwise if the application changes fd->events behind our back and
2888 * makes it non-zero, we'll be out of sync when we check the fds[] array.
2889 * (Changing fd->events after adding an FD wasn't an anticipated use of
2890 * this API, but it occurs in practice.) */
2893 fds[n_poll].fd = pollrec->fd->fd;
2894 /* In direct contradiction to the Unix98 spec, IRIX runs into
2895 * difficulty if you pass in POLLERR, POLLHUP or POLLNVAL
2896 * flags in the events field of the pollfd while it should
2897 * just ignoring them. So we mask them out here.
2899 fds[n_poll].events = pollrec->fd->events & ~(G_IO_ERR|G_IO_HUP|G_IO_NVAL);
2900 fds[n_poll].revents = 0;
2903 pollrec = pollrec->next;
2907 context->poll_changed = FALSE;
2911 *timeout = context->timeout;
2913 context->time_is_fresh = FALSE;
2916 UNLOCK_CONTEXT (context);
2922 * g_main_context_check:
2923 * @context: a #GMainContext
2924 * @max_priority: the maximum numerical priority of sources to check
2925 * @fds: (array length=n_fds): array of #GPollFD's that was passed to
2926 * the last call to g_main_context_query()
2927 * @n_fds: return value of g_main_context_query()
2929 * Passes the results of polling back to the main loop.
2931 * Return value: %TRUE if some sources are ready to be dispatched.
2934 g_main_context_check (GMainContext *context,
2944 LOCK_CONTEXT (context);
2946 if (context->in_check_or_prepare)
2948 g_warning ("g_main_context_check() called recursively from within a source's check() or "
2949 "prepare() member.");
2950 UNLOCK_CONTEXT (context);
2954 if (context->wake_up_rec.events)
2955 g_wakeup_acknowledge (context->wakeup);
2957 /* If the set of poll file descriptors changed, bail out
2958 * and let the main loop rerun
2960 if (context->poll_changed)
2962 UNLOCK_CONTEXT (context);
2966 pollrec = context->poll_records;
2970 if (pollrec->fd->events)
2971 pollrec->fd->revents = fds[i].revents;
2973 pollrec = pollrec->next;
2977 source = next_valid_source (context, NULL);
2980 if ((n_ready > 0) && (source->priority > max_priority))
2982 SOURCE_UNREF (source, context);
2985 if (SOURCE_BLOCKED (source))
2988 if (!(source->flags & G_SOURCE_READY))
2991 gboolean (*check) (GSource *source);
2993 check = source->source_funcs->check;
2995 context->in_check_or_prepare++;
2996 UNLOCK_CONTEXT (context);
2998 result = (*check) (source);
3000 LOCK_CONTEXT (context);
3001 context->in_check_or_prepare--;
3005 GSource *ready_source = source;
3007 while (ready_source)
3009 ready_source->flags |= G_SOURCE_READY;
3010 ready_source = ready_source->priv ? ready_source->priv->parent_source : NULL;
3015 if (source->flags & G_SOURCE_READY)
3017 source->ref_count++;
3018 g_ptr_array_add (context->pending_dispatches, source);
3022 /* never dispatch sources with less priority than the first
3023 * one we choose to dispatch
3025 max_priority = source->priority;
3029 source = next_valid_source (context, source);
3032 UNLOCK_CONTEXT (context);
3038 * g_main_context_dispatch:
3039 * @context: a #GMainContext
3041 * Dispatches all pending sources.
3044 g_main_context_dispatch (GMainContext *context)
3046 LOCK_CONTEXT (context);
3048 if (context->pending_dispatches->len > 0)
3050 g_main_dispatch (context);
3053 UNLOCK_CONTEXT (context);
3056 /* HOLDS context lock */
3058 g_main_context_iterate (GMainContext *context,
3065 gboolean some_ready;
3066 gint nfds, allocated_nfds;
3067 GPollFD *fds = NULL;
3069 UNLOCK_CONTEXT (context);
3071 if (!g_main_context_acquire (context))
3073 gboolean got_ownership;
3075 LOCK_CONTEXT (context);
3080 got_ownership = g_main_context_wait (context,
3088 LOCK_CONTEXT (context);
3090 if (!context->cached_poll_array)
3092 context->cached_poll_array_size = context->n_poll_records;
3093 context->cached_poll_array = g_new (GPollFD, context->n_poll_records);
3096 allocated_nfds = context->cached_poll_array_size;
3097 fds = context->cached_poll_array;
3099 UNLOCK_CONTEXT (context);
3101 g_main_context_prepare (context, &max_priority);
3103 while ((nfds = g_main_context_query (context, max_priority, &timeout, fds,
3104 allocated_nfds)) > allocated_nfds)
3106 LOCK_CONTEXT (context);
3108 context->cached_poll_array_size = allocated_nfds = nfds;
3109 context->cached_poll_array = fds = g_new (GPollFD, nfds);
3110 UNLOCK_CONTEXT (context);
3116 g_main_context_poll (context, timeout, max_priority, fds, nfds);
3118 some_ready = g_main_context_check (context, max_priority, fds, nfds);
3121 g_main_context_dispatch (context);
3123 g_main_context_release (context);
3125 LOCK_CONTEXT (context);
3131 * g_main_context_pending:
3132 * @context: a #GMainContext (if %NULL, the default context will be used)
3134 * Checks if any sources have pending events for the given context.
3136 * Return value: %TRUE if events are pending.
3139 g_main_context_pending (GMainContext *context)
3144 context = g_main_context_default();
3146 LOCK_CONTEXT (context);
3147 retval = g_main_context_iterate (context, FALSE, FALSE, G_THREAD_SELF);
3148 UNLOCK_CONTEXT (context);
3154 * g_main_context_iteration:
3155 * @context: a #GMainContext (if %NULL, the default context will be used)
3156 * @may_block: whether the call may block.
3158 * Runs a single iteration for the given main loop. This involves
3159 * checking to see if any event sources are ready to be processed,
3160 * then if no events sources are ready and @may_block is %TRUE, waiting
3161 * for a source to become ready, then dispatching the highest priority
3162 * events sources that are ready. Otherwise, if @may_block is %FALSE
3163 * sources are not waited to become ready, only those highest priority
3164 * events sources will be dispatched (if any), that are ready at this
3165 * given moment without further waiting.
3167 * Note that even when @may_block is %TRUE, it is still possible for
3168 * g_main_context_iteration() to return %FALSE, since the the wait may
3169 * be interrupted for other reasons than an event source becoming ready.
3171 * Return value: %TRUE if events were dispatched.
3174 g_main_context_iteration (GMainContext *context, gboolean may_block)
3179 context = g_main_context_default();
3181 LOCK_CONTEXT (context);
3182 retval = g_main_context_iterate (context, may_block, TRUE, G_THREAD_SELF);
3183 UNLOCK_CONTEXT (context);
3190 * @context: (allow-none): a #GMainContext (if %NULL, the default context will be used).
3191 * @is_running: set to %TRUE to indicate that the loop is running. This
3192 * is not very important since calling g_main_loop_run() will set this to
3195 * Creates a new #GMainLoop structure.
3197 * Return value: a new #GMainLoop.
3200 g_main_loop_new (GMainContext *context,
3201 gboolean is_running)
3206 context = g_main_context_default();
3208 g_main_context_ref (context);
3210 loop = g_new0 (GMainLoop, 1);
3211 loop->context = context;
3212 loop->is_running = is_running != FALSE;
3213 loop->ref_count = 1;
3220 * @loop: a #GMainLoop
3222 * Increases the reference count on a #GMainLoop object by one.
3224 * Return value: @loop
3227 g_main_loop_ref (GMainLoop *loop)
3229 g_return_val_if_fail (loop != NULL, NULL);
3230 g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, NULL);
3232 g_atomic_int_inc (&loop->ref_count);
3238 * g_main_loop_unref:
3239 * @loop: a #GMainLoop
3241 * Decreases the reference count on a #GMainLoop object by one. If
3242 * the result is zero, free the loop and free all associated memory.
3245 g_main_loop_unref (GMainLoop *loop)
3247 g_return_if_fail (loop != NULL);
3248 g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
3250 if (!g_atomic_int_dec_and_test (&loop->ref_count))
3253 g_main_context_unref (loop->context);
3259 * @loop: a #GMainLoop
3261 * Runs a main loop until g_main_loop_quit() is called on the loop.
3262 * If this is called for the thread of the loop's #GMainContext,
3263 * it will process events from the loop, otherwise it will
3267 g_main_loop_run (GMainLoop *loop)
3269 GThread *self = G_THREAD_SELF;
3271 g_return_if_fail (loop != NULL);
3272 g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
3274 if (!g_main_context_acquire (loop->context))
3276 gboolean got_ownership = FALSE;
3278 /* Another thread owns this context */
3279 LOCK_CONTEXT (loop->context);
3281 g_atomic_int_inc (&loop->ref_count);
3283 if (!loop->is_running)
3284 loop->is_running = TRUE;
3286 while (loop->is_running && !got_ownership)
3287 got_ownership = g_main_context_wait (loop->context,
3288 &loop->context->cond,
3289 &loop->context->mutex);
3291 if (!loop->is_running)
3293 UNLOCK_CONTEXT (loop->context);
3295 g_main_context_release (loop->context);
3296 g_main_loop_unref (loop);
3300 g_assert (got_ownership);
3303 LOCK_CONTEXT (loop->context);
3305 if (loop->context->in_check_or_prepare)
3307 g_warning ("g_main_loop_run(): called recursively from within a source's "
3308 "check() or prepare() member, iteration not possible.");
3312 g_atomic_int_inc (&loop->ref_count);
3313 loop->is_running = TRUE;
3314 while (loop->is_running)
3315 g_main_context_iterate (loop->context, TRUE, TRUE, self);
3317 UNLOCK_CONTEXT (loop->context);
3319 g_main_context_release (loop->context);
3321 g_main_loop_unref (loop);
3326 * @loop: a #GMainLoop
3328 * Stops a #GMainLoop from running. Any calls to g_main_loop_run()
3329 * for the loop will return.
3331 * Note that sources that have already been dispatched when
3332 * g_main_loop_quit() is called will still be executed.
3335 g_main_loop_quit (GMainLoop *loop)
3337 g_return_if_fail (loop != NULL);
3338 g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
3340 LOCK_CONTEXT (loop->context);
3341 loop->is_running = FALSE;
3342 g_wakeup_signal (loop->context->wakeup);
3344 g_cond_broadcast (&loop->context->cond);
3346 UNLOCK_CONTEXT (loop->context);
3350 * g_main_loop_is_running:
3351 * @loop: a #GMainLoop.
3353 * Checks to see if the main loop is currently being run via g_main_loop_run().
3355 * Return value: %TRUE if the mainloop is currently being run.
3358 g_main_loop_is_running (GMainLoop *loop)
3360 g_return_val_if_fail (loop != NULL, FALSE);
3361 g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, FALSE);
3363 return loop->is_running;
3367 * g_main_loop_get_context:
3368 * @loop: a #GMainLoop.
3370 * Returns the #GMainContext of @loop.
3372 * Return value: (transfer none): the #GMainContext of @loop
3375 g_main_loop_get_context (GMainLoop *loop)
3377 g_return_val_if_fail (loop != NULL, NULL);
3378 g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, NULL);
3380 return loop->context;
3383 /* HOLDS: context's lock */
3385 g_main_context_poll (GMainContext *context,
3391 #ifdef G_MAIN_POLL_DEBUG
3397 GPollFunc poll_func;
3399 if (n_fds || timeout != 0)
3401 #ifdef G_MAIN_POLL_DEBUG
3402 if (_g_main_poll_debug)
3404 g_print ("polling context=%p n=%d timeout=%d\n",
3405 context, n_fds, timeout);
3406 poll_timer = g_timer_new ();
3410 LOCK_CONTEXT (context);
3412 poll_func = context->poll_func;
3414 UNLOCK_CONTEXT (context);
3415 if ((*poll_func) (fds, n_fds, timeout) < 0 && errno != EINTR)
3418 g_warning ("poll(2) failed due to: %s.",
3419 g_strerror (errno));
3421 /* If g_poll () returns -1, it has already called g_warning() */
3425 #ifdef G_MAIN_POLL_DEBUG
3426 if (_g_main_poll_debug)
3428 LOCK_CONTEXT (context);
3430 g_print ("g_main_poll(%d) timeout: %d - elapsed %12.10f seconds",
3433 g_timer_elapsed (poll_timer, NULL));
3434 g_timer_destroy (poll_timer);
3435 pollrec = context->poll_records;
3437 while (pollrec != NULL)
3442 if (fds[i].fd == pollrec->fd->fd &&
3443 pollrec->fd->events &&
3446 g_print (" [" G_POLLFD_FORMAT " :", fds[i].fd);
3447 if (fds[i].revents & G_IO_IN)
3449 if (fds[i].revents & G_IO_OUT)
3451 if (fds[i].revents & G_IO_PRI)
3453 if (fds[i].revents & G_IO_ERR)
3455 if (fds[i].revents & G_IO_HUP)
3457 if (fds[i].revents & G_IO_NVAL)
3463 pollrec = pollrec->next;
3467 UNLOCK_CONTEXT (context);
3470 } /* if (n_fds || timeout != 0) */
3474 * g_main_context_add_poll:
3475 * @context: a #GMainContext (or %NULL for the default context)
3476 * @fd: a #GPollFD structure holding information about a file
3477 * descriptor to watch.
3478 * @priority: the priority for this file descriptor which should be
3479 * the same as the priority used for g_source_attach() to ensure that the
3480 * file descriptor is polled whenever the results may be needed.
3482 * Adds a file descriptor to the set of file descriptors polled for
3483 * this context. This will very seldom be used directly. Instead
3484 * a typical event source will use g_source_add_poll() instead.
3487 g_main_context_add_poll (GMainContext *context,
3492 context = g_main_context_default ();
3494 g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3495 g_return_if_fail (fd);
3497 LOCK_CONTEXT (context);
3498 g_main_context_add_poll_unlocked (context, priority, fd);
3499 UNLOCK_CONTEXT (context);
3502 /* HOLDS: main_loop_lock */
3504 g_main_context_add_poll_unlocked (GMainContext *context,
3508 GPollRec *prevrec, *nextrec;
3509 GPollRec *newrec = g_slice_new (GPollRec);
3511 /* This file descriptor may be checked before we ever poll */
3514 newrec->priority = priority;
3516 prevrec = context->poll_records_tail;
3518 while (prevrec && priority < prevrec->priority)
3521 prevrec = prevrec->prev;
3525 prevrec->next = newrec;
3527 context->poll_records = newrec;
3529 newrec->prev = prevrec;
3530 newrec->next = nextrec;
3533 nextrec->prev = newrec;
3535 context->poll_records_tail = newrec;
3537 context->n_poll_records++;
3539 context->poll_changed = TRUE;
3541 /* Now wake up the main loop if it is waiting in the poll() */
3542 g_wakeup_signal (context->wakeup);
3546 * g_main_context_remove_poll:
3547 * @context:a #GMainContext
3548 * @fd: a #GPollFD descriptor previously added with g_main_context_add_poll()
3550 * Removes file descriptor from the set of file descriptors to be
3551 * polled for a particular context.
3554 g_main_context_remove_poll (GMainContext *context,
3558 context = g_main_context_default ();
3560 g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3561 g_return_if_fail (fd);
3563 LOCK_CONTEXT (context);
3564 g_main_context_remove_poll_unlocked (context, fd);
3565 UNLOCK_CONTEXT (context);
3569 g_main_context_remove_poll_unlocked (GMainContext *context,
3572 GPollRec *pollrec, *prevrec, *nextrec;
3575 pollrec = context->poll_records;
3579 nextrec = pollrec->next;
3580 if (pollrec->fd == fd)
3582 if (prevrec != NULL)
3583 prevrec->next = nextrec;
3585 context->poll_records = nextrec;
3587 if (nextrec != NULL)
3588 nextrec->prev = prevrec;
3590 context->poll_records_tail = prevrec;
3592 g_slice_free (GPollRec, pollrec);
3594 context->n_poll_records--;
3601 context->poll_changed = TRUE;
3603 /* Now wake up the main loop if it is waiting in the poll() */
3604 g_wakeup_signal (context->wakeup);
3608 * g_source_get_current_time:
3609 * @source: a #GSource
3610 * @timeval: #GTimeVal structure in which to store current time.
3612 * This function ignores @source and is otherwise the same as
3613 * g_get_current_time().
3615 * Deprecated: 2.28: use g_source_get_time() instead
3618 g_source_get_current_time (GSource *source,
3621 g_get_current_time (timeval);
3625 * g_source_get_time:
3626 * @source: a #GSource
3628 * Gets the time to be used when checking this source. The advantage of
3629 * calling this function over calling g_get_monotonic_time() directly is
3630 * that when checking multiple sources, GLib can cache a single value
3631 * instead of having to repeatedly get the system monotonic time.
3633 * The time here is the system monotonic time, if available, or some
3634 * other reasonable alternative otherwise. See g_get_monotonic_time().
3636 * Returns: the monotonic time in microseconds
3641 g_source_get_time (GSource *source)
3643 GMainContext *context;
3646 g_return_val_if_fail (source->context != NULL, 0);
3648 context = source->context;
3650 LOCK_CONTEXT (context);
3652 if (!context->time_is_fresh)
3654 context->time = g_get_monotonic_time ();
3655 context->time_is_fresh = TRUE;
3658 result = context->time;
3660 UNLOCK_CONTEXT (context);
3666 * g_main_context_set_poll_func:
3667 * @context: a #GMainContext
3668 * @func: the function to call to poll all file descriptors
3670 * Sets the function to use to handle polling of file descriptors. It
3671 * will be used instead of the poll() system call
3672 * (or GLib's replacement function, which is used where
3673 * poll() isn't available).
3675 * This function could possibly be used to integrate the GLib event
3676 * loop with an external event loop.
3679 g_main_context_set_poll_func (GMainContext *context,
3683 context = g_main_context_default ();
3685 g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3687 LOCK_CONTEXT (context);
3690 context->poll_func = func;
3692 context->poll_func = g_poll;
3694 UNLOCK_CONTEXT (context);
3698 * g_main_context_get_poll_func:
3699 * @context: a #GMainContext
3701 * Gets the poll function set by g_main_context_set_poll_func().
3703 * Return value: the poll function
3706 g_main_context_get_poll_func (GMainContext *context)
3711 context = g_main_context_default ();
3713 g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL);
3715 LOCK_CONTEXT (context);
3716 result = context->poll_func;
3717 UNLOCK_CONTEXT (context);
3723 * g_main_context_wakeup:
3724 * @context: a #GMainContext
3726 * If @context is currently waiting in a poll(), interrupt
3727 * the poll(), and continue the iteration process.
3730 g_main_context_wakeup (GMainContext *context)
3733 context = g_main_context_default ();
3735 g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3737 g_wakeup_signal (context->wakeup);
3741 * g_main_context_is_owner:
3742 * @context: a #GMainContext
3744 * Determines whether this thread holds the (recursive)
3745 * ownership of this #GMainContext. This is useful to
3746 * know before waiting on another thread that may be
3747 * blocking to get ownership of @context.
3749 * Returns: %TRUE if current thread is owner of @context.
3754 g_main_context_is_owner (GMainContext *context)
3759 context = g_main_context_default ();
3761 LOCK_CONTEXT (context);
3762 is_owner = context->owner == G_THREAD_SELF;
3763 UNLOCK_CONTEXT (context);
3771 g_timeout_set_expiration (GTimeoutSource *timeout_source,
3772 gint64 current_time)
3774 timeout_source->expiration = current_time +
3775 (guint64) timeout_source->interval * 1000;
3777 if (timeout_source->seconds)
3780 static gint timer_perturb = -1;
3782 if (timer_perturb == -1)
3785 * we want a per machine/session unique 'random' value; try the dbus
3786 * address first, that has a UUID in it. If there is no dbus, use the
3787 * hostname for hashing.
3789 const char *session_bus_address = g_getenv ("DBUS_SESSION_BUS_ADDRESS");
3790 if (!session_bus_address)
3791 session_bus_address = g_getenv ("HOSTNAME");
3792 if (session_bus_address)
3793 timer_perturb = ABS ((gint) g_str_hash (session_bus_address)) % 1000000;
3798 /* We want the microseconds part of the timeout to land on the
3799 * 'timer_perturb' mark, but we need to make sure we don't try to
3800 * set the timeout in the past. We do this by ensuring that we
3801 * always only *increase* the expiration time by adding a full
3802 * second in the case that the microsecond portion decreases.
3804 timeout_source->expiration -= timer_perturb;
3806 remainder = timeout_source->expiration % 1000000;
3807 if (remainder >= 1000000/4)
3808 timeout_source->expiration += 1000000;
3810 timeout_source->expiration -= remainder;
3811 timeout_source->expiration += timer_perturb;
3816 g_timeout_prepare (GSource *source,
3819 GTimeoutSource *timeout_source = (GTimeoutSource *) source;
3820 gint64 now = g_source_get_time (source);
3822 if (now < timeout_source->expiration)
3824 /* Round up to ensure that we don't try again too early */
3825 *timeout = (timeout_source->expiration - now + 999) / 1000;
3834 g_timeout_check (GSource *source)
3836 GTimeoutSource *timeout_source = (GTimeoutSource *) source;
3837 gint64 now = g_source_get_time (source);
3839 return timeout_source->expiration <= now;
3843 g_timeout_dispatch (GSource *source,
3844 GSourceFunc callback,
3847 GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3852 g_warning ("Timeout source dispatched without callback\n"
3853 "You must call g_source_set_callback().");
3857 again = callback (user_data);
3860 g_timeout_set_expiration (timeout_source, g_source_get_time (source));
3866 * g_timeout_source_new:
3867 * @interval: the timeout interval in milliseconds.
3869 * Creates a new timeout source.
3871 * The source will not initially be associated with any #GMainContext
3872 * and must be added to one with g_source_attach() before it will be
3875 * The interval given is in terms of monotonic time, not wall clock
3876 * time. See g_get_monotonic_time().
3878 * Return value: the newly-created timeout source
3881 g_timeout_source_new (guint interval)
3883 GSource *source = g_source_new (&g_timeout_funcs, sizeof (GTimeoutSource));
3884 GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3886 timeout_source->interval = interval;
3887 g_timeout_set_expiration (timeout_source, g_get_monotonic_time ());
3893 * g_timeout_source_new_seconds:
3894 * @interval: the timeout interval in seconds
3896 * Creates a new timeout source.
3898 * The source will not initially be associated with any #GMainContext
3899 * and must be added to one with g_source_attach() before it will be
3902 * The scheduling granularity/accuracy of this timeout source will be
3905 * The interval given in terms of monotonic time, not wall clock time.
3906 * See g_get_monotonic_time().
3908 * Return value: the newly-created timeout source
3913 g_timeout_source_new_seconds (guint interval)
3915 GSource *source = g_source_new (&g_timeout_funcs, sizeof (GTimeoutSource));
3916 GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3918 timeout_source->interval = 1000 * interval;
3919 timeout_source->seconds = TRUE;
3921 g_timeout_set_expiration (timeout_source, g_get_monotonic_time ());
3928 * g_timeout_add_full:
3929 * @priority: the priority of the timeout source. Typically this will be in
3930 * the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
3931 * @interval: the time between calls to the function, in milliseconds
3932 * (1/1000ths of a second)
3933 * @function: function to call
3934 * @data: data to pass to @function
3935 * @notify: function to call when the timeout is removed, or %NULL
3937 * Sets a function to be called at regular intervals, with the given
3938 * priority. The function is called repeatedly until it returns
3939 * %FALSE, at which point the timeout is automatically destroyed and
3940 * the function will not be called again. The @notify function is
3941 * called when the timeout is destroyed. The first call to the
3942 * function will be at the end of the first @interval.
3944 * Note that timeout functions may be delayed, due to the processing of other
3945 * event sources. Thus they should not be relied on for precise timing.
3946 * After each call to the timeout function, the time of the next
3947 * timeout is recalculated based on the current time and the given interval
3948 * (it does not try to 'catch up' time lost in delays).
3950 * This internally creates a main loop source using g_timeout_source_new()
3951 * and attaches it to the main loop context using g_source_attach(). You can
3952 * do these steps manually if you need greater control.
3954 * The interval given in terms of monotonic time, not wall clock time.
3955 * See g_get_monotonic_time().
3957 * Return value: the ID (greater than 0) of the event source.
3958 * Rename to: g_timeout_add
3961 g_timeout_add_full (gint priority,
3963 GSourceFunc function,
3965 GDestroyNotify notify)
3970 g_return_val_if_fail (function != NULL, 0);
3972 source = g_timeout_source_new (interval);
3974 if (priority != G_PRIORITY_DEFAULT)
3975 g_source_set_priority (source, priority);
3977 g_source_set_callback (source, function, data, notify);
3978 id = g_source_attach (source, NULL);
3979 g_source_unref (source);
3986 * @interval: the time between calls to the function, in milliseconds
3987 * (1/1000ths of a second)
3988 * @function: function to call
3989 * @data: data to pass to @function
3991 * Sets a function to be called at regular intervals, with the default
3992 * priority, #G_PRIORITY_DEFAULT. The function is called repeatedly
3993 * until it returns %FALSE, at which point the timeout is automatically
3994 * destroyed and the function will not be called again. The first call
3995 * to the function will be at the end of the first @interval.
3997 * Note that timeout functions may be delayed, due to the processing of other
3998 * event sources. Thus they should not be relied on for precise timing.
3999 * After each call to the timeout function, the time of the next
4000 * timeout is recalculated based on the current time and the given interval
4001 * (it does not try to 'catch up' time lost in delays).
4003 * If you want to have a timer in the "seconds" range and do not care
4004 * about the exact time of the first call of the timer, use the
4005 * g_timeout_add_seconds() function; this function allows for more
4006 * optimizations and more efficient system power usage.
4008 * This internally creates a main loop source using g_timeout_source_new()
4009 * and attaches it to the main loop context using g_source_attach(). You can
4010 * do these steps manually if you need greater control.
4012 * The interval given is in terms of monotonic time, not wall clock
4013 * time. See g_get_monotonic_time().
4015 * Return value: the ID (greater than 0) of the event source.
4018 g_timeout_add (guint32 interval,
4019 GSourceFunc function,
4022 return g_timeout_add_full (G_PRIORITY_DEFAULT,
4023 interval, function, data, NULL);
4027 * g_timeout_add_seconds_full:
4028 * @priority: the priority of the timeout source. Typically this will be in
4029 * the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
4030 * @interval: the time between calls to the function, in seconds
4031 * @function: function to call
4032 * @data: data to pass to @function
4033 * @notify: function to call when the timeout is removed, or %NULL
4035 * Sets a function to be called at regular intervals, with @priority.
4036 * The function is called repeatedly until it returns %FALSE, at which
4037 * point the timeout is automatically destroyed and the function will
4038 * not be called again.
4040 * Unlike g_timeout_add(), this function operates at whole second granularity.
4041 * The initial starting point of the timer is determined by the implementation
4042 * and the implementation is expected to group multiple timers together so that
4043 * they fire all at the same time.
4044 * To allow this grouping, the @interval to the first timer is rounded
4045 * and can deviate up to one second from the specified interval.
4046 * Subsequent timer iterations will generally run at the specified interval.
4048 * Note that timeout functions may be delayed, due to the processing of other
4049 * event sources. Thus they should not be relied on for precise timing.
4050 * After each call to the timeout function, the time of the next
4051 * timeout is recalculated based on the current time and the given @interval
4053 * If you want timing more precise than whole seconds, use g_timeout_add()
4056 * The grouping of timers to fire at the same time results in a more power
4057 * and CPU efficient behavior so if your timer is in multiples of seconds
4058 * and you don't require the first timer exactly one second from now, the
4059 * use of g_timeout_add_seconds() is preferred over g_timeout_add().
4061 * This internally creates a main loop source using
4062 * g_timeout_source_new_seconds() and attaches it to the main loop context
4063 * using g_source_attach(). You can do these steps manually if you need
4066 * The interval given is in terms of monotonic time, not wall clock
4067 * time. See g_get_monotonic_time().
4069 * Return value: the ID (greater than 0) of the event source.
4071 * Rename to: g_timeout_add_seconds
4075 g_timeout_add_seconds_full (gint priority,
4077 GSourceFunc function,
4079 GDestroyNotify notify)
4084 g_return_val_if_fail (function != NULL, 0);
4086 source = g_timeout_source_new_seconds (interval);
4088 if (priority != G_PRIORITY_DEFAULT)
4089 g_source_set_priority (source, priority);
4091 g_source_set_callback (source, function, data, notify);
4092 id = g_source_attach (source, NULL);
4093 g_source_unref (source);
4099 * g_timeout_add_seconds:
4100 * @interval: the time between calls to the function, in seconds
4101 * @function: function to call
4102 * @data: data to pass to @function
4104 * Sets a function to be called at regular intervals with the default
4105 * priority, #G_PRIORITY_DEFAULT. The function is called repeatedly until
4106 * it returns %FALSE, at which point the timeout is automatically destroyed
4107 * and the function will not be called again.
4109 * This internally creates a main loop source using
4110 * g_timeout_source_new_seconds() and attaches it to the main loop context
4111 * using g_source_attach(). You can do these steps manually if you need
4112 * greater control. Also see g_timeout_add_seconds_full().
4114 * Note that the first call of the timer may not be precise for timeouts
4115 * of one second. If you need finer precision and have such a timeout,
4116 * you may want to use g_timeout_add() instead.
4118 * The interval given is in terms of monotonic time, not wall clock
4119 * time. See g_get_monotonic_time().
4121 * Return value: the ID (greater than 0) of the event source.
4126 g_timeout_add_seconds (guint interval,
4127 GSourceFunc function,
4130 g_return_val_if_fail (function != NULL, 0);
4132 return g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, interval, function, data, NULL);
4135 /* Child watch functions */
4140 g_child_watch_prepare (GSource *source,
4148 g_child_watch_check (GSource *source)
4150 GChildWatchSource *child_watch_source;
4151 gboolean child_exited;
4153 child_watch_source = (GChildWatchSource *) source;
4155 child_exited = child_watch_source->poll.revents & G_IO_IN;
4162 * Note: We do _not_ check for the special value of STILL_ACTIVE
4163 * since we know that the process has exited and doing so runs into
4164 * problems if the child process "happens to return STILL_ACTIVE(259)"
4165 * as Microsoft's Platform SDK puts it.
4167 if (!GetExitCodeProcess (child_watch_source->pid, &child_status))
4169 gchar *emsg = g_win32_error_message (GetLastError ());
4170 g_warning (G_STRLOC ": GetExitCodeProcess() failed: %s", emsg);
4173 child_watch_source->child_status = -1;
4176 child_watch_source->child_status = child_status;
4179 return child_exited;
4183 g_child_watch_finalize (GSource *source)
4187 #else /* G_OS_WIN32 */
4190 wake_source (GSource *source)
4192 GMainContext *context;
4194 /* This should be thread-safe:
4196 * - if the source is currently being added to a context, that
4197 * context will be woken up anyway
4199 * - if the source is currently being destroyed, we simply need not
4202 * - the memory for the source will remain valid until after the
4203 * source finalize function was called (which would remove the
4204 * source from the global list which we are currently holding the
4207 * - the GMainContext will either be NULL or point to a live
4210 * - the GMainContext will remain valid since we hold the
4211 * main_context_list lock
4213 * Since we are holding a lot of locks here, don't try to enter any
4214 * more GMainContext functions for fear of dealock -- just hit the
4215 * GWakeup and run. Even if that's safe now, it could easily become
4216 * unsafe with some very minor changes in the future, and signal
4217 * handling is not the most well-tested codepath.
4219 G_LOCK(main_context_list);
4220 context = source->context;
4222 g_wakeup_signal (context->wakeup);
4223 G_UNLOCK(main_context_list);
4227 dispatch_unix_signals (void)
4231 /* clear this first incase another one arrives while we're processing */
4232 any_unix_signal_pending = FALSE;
4234 G_LOCK(unix_signal_lock);
4236 /* handle GChildWatchSource instances */
4237 if (unix_signal_pending[SIGCHLD])
4239 unix_signal_pending[SIGCHLD] = FALSE;
4241 /* The only way we can do this is to scan all of the children.
4243 * The docs promise that we will not reap children that we are not
4244 * explicitly watching, so that ties our hands from calling
4245 * waitpid(-1). We also can't use siginfo's si_pid field since if
4246 * multiple SIGCHLD arrive at the same time, one of them can be
4247 * dropped (since a given UNIX signal can only be pending once).
4249 for (node = unix_child_watches; node; node = node->next)
4251 GChildWatchSource *source = node->data;
4253 if (!source->child_exited)
4255 if (waitpid (source->pid, &source->child_status, WNOHANG) > 0)
4257 source->child_exited = TRUE;
4259 wake_source ((GSource *) source);
4265 /* handle GUnixSignalWatchSource instances */
4266 for (node = unix_signal_watches; node; node = node->next)
4268 GUnixSignalWatchSource *source = node->data;
4270 if (!source->pending)
4272 if (unix_signal_pending[source->signum])
4274 unix_signal_pending[source->signum] = FALSE;
4275 source->pending = TRUE;
4277 wake_source ((GSource *) source);
4282 G_UNLOCK(unix_signal_lock);
4286 g_child_watch_prepare (GSource *source,
4289 GChildWatchSource *child_watch_source;
4291 child_watch_source = (GChildWatchSource *) source;
4293 return child_watch_source->child_exited;
4297 g_child_watch_check (GSource *source)
4299 GChildWatchSource *child_watch_source;
4301 child_watch_source = (GChildWatchSource *) source;
4303 return child_watch_source->child_exited;
4307 g_unix_signal_watch_prepare (GSource *source,
4310 GUnixSignalWatchSource *unix_signal_source;
4312 unix_signal_source = (GUnixSignalWatchSource *) source;
4314 return unix_signal_source->pending;
4318 g_unix_signal_watch_check (GSource *source)
4320 GUnixSignalWatchSource *unix_signal_source;
4322 unix_signal_source = (GUnixSignalWatchSource *) source;
4324 return unix_signal_source->pending;
4328 g_unix_signal_watch_dispatch (GSource *source,
4329 GSourceFunc callback,
4332 GUnixSignalWatchSource *unix_signal_source;
4334 unix_signal_source = (GUnixSignalWatchSource *) source;
4338 g_warning ("Unix signal source dispatched without callback\n"
4339 "You must call g_source_set_callback().");
4343 (callback) (user_data);
4345 unix_signal_source->pending = FALSE;
4351 ensure_unix_signal_handler_installed_unlocked (int signum)
4353 static sigset_t installed_signal_mask;
4354 static gboolean initialized;
4355 struct sigaction action;
4359 sigemptyset (&installed_signal_mask);
4360 g_get_worker_context ();
4364 if (sigismember (&installed_signal_mask, signum))
4367 sigaddset (&installed_signal_mask, signum);
4369 action.sa_handler = g_unix_signal_handler;
4370 sigemptyset (&action.sa_mask);
4371 action.sa_flags = SA_RESTART | SA_NOCLDSTOP;
4372 sigaction (signum, &action, NULL);
4376 _g_main_create_unix_signal_watch (int signum)
4379 GUnixSignalWatchSource *unix_signal_source;
4381 source = g_source_new (&g_unix_signal_funcs, sizeof (GUnixSignalWatchSource));
4382 unix_signal_source = (GUnixSignalWatchSource *) source;
4384 unix_signal_source->signum = signum;
4385 unix_signal_source->pending = FALSE;
4387 G_LOCK (unix_signal_lock);
4388 ensure_unix_signal_handler_installed_unlocked (signum);
4389 unix_signal_watches = g_slist_prepend (unix_signal_watches, unix_signal_source);
4390 if (unix_signal_pending[signum])
4391 unix_signal_source->pending = TRUE;
4392 unix_signal_pending[signum] = FALSE;
4393 G_UNLOCK (unix_signal_lock);
4399 g_unix_signal_watch_finalize (GSource *source)
4401 G_LOCK (unix_signal_lock);
4402 unix_signal_watches = g_slist_remove (unix_signal_watches, source);
4403 G_UNLOCK (unix_signal_lock);
4407 g_child_watch_finalize (GSource *source)
4409 G_LOCK (unix_signal_lock);
4410 unix_child_watches = g_slist_remove (unix_child_watches, source);
4411 G_UNLOCK (unix_signal_lock);
4414 #endif /* G_OS_WIN32 */
4417 g_child_watch_dispatch (GSource *source,
4418 GSourceFunc callback,
4421 GChildWatchSource *child_watch_source;
4422 GChildWatchFunc child_watch_callback = (GChildWatchFunc) callback;
4424 child_watch_source = (GChildWatchSource *) source;
4428 g_warning ("Child watch source dispatched without callback\n"
4429 "You must call g_source_set_callback().");
4433 (child_watch_callback) (child_watch_source->pid, child_watch_source->child_status, user_data);
4435 /* We never keep a child watch source around as the child is gone */
4442 g_unix_signal_handler (int signum)
4444 unix_signal_pending[signum] = TRUE;
4445 any_unix_signal_pending = TRUE;
4447 g_wakeup_signal (glib_worker_context->wakeup);
4450 #endif /* !G_OS_WIN32 */
4453 * g_child_watch_source_new:
4454 * @pid: process to watch. On POSIX the pid of a child process. On
4455 * Windows a handle for a process (which doesn't have to be a child).
4457 * Creates a new child_watch source.
4459 * The source will not initially be associated with any #GMainContext
4460 * and must be added to one with g_source_attach() before it will be
4463 * Note that child watch sources can only be used in conjunction with
4464 * <literal>g_spawn...</literal> when the %G_SPAWN_DO_NOT_REAP_CHILD
4467 * Note that on platforms where #GPid must be explicitly closed
4468 * (see g_spawn_close_pid()) @pid must not be closed while the
4469 * source is still active. Typically, you will want to call
4470 * g_spawn_close_pid() in the callback function for the source.
4472 * Note further that using g_child_watch_source_new() is not
4473 * compatible with calling <literal>waitpid(-1)</literal> in
4474 * the application. Calling waitpid() for individual pids will
4477 * Return value: the newly-created child watch source
4482 g_child_watch_source_new (GPid pid)
4484 GSource *source = g_source_new (&g_child_watch_funcs, sizeof (GChildWatchSource));
4485 GChildWatchSource *child_watch_source = (GChildWatchSource *)source;
4487 child_watch_source->pid = pid;
4490 child_watch_source->poll.fd = (gintptr) pid;
4491 child_watch_source->poll.events = G_IO_IN;
4493 g_source_add_poll (source, &child_watch_source->poll);
4494 #else /* G_OS_WIN32 */
4495 G_LOCK (unix_signal_lock);
4496 ensure_unix_signal_handler_installed_unlocked (SIGCHLD);
4497 unix_child_watches = g_slist_prepend (unix_child_watches, child_watch_source);
4498 if (waitpid (pid, &child_watch_source->child_status, WNOHANG) > 0)
4499 child_watch_source->child_exited = TRUE;
4500 G_UNLOCK (unix_signal_lock);
4501 #endif /* G_OS_WIN32 */
4507 * g_child_watch_add_full:
4508 * @priority: the priority of the idle source. Typically this will be in the
4509 * range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
4510 * @pid: process to watch. On POSIX the pid of a child process. On
4511 * Windows a handle for a process (which doesn't have to be a child).
4512 * @function: function to call
4513 * @data: data to pass to @function
4514 * @notify: function to call when the idle is removed, or %NULL
4516 * Sets a function to be called when the child indicated by @pid
4517 * exits, at the priority @priority.
4519 * If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
4520 * you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
4521 * the spawn function for the child watching to work.
4523 * Note that on platforms where #GPid must be explicitly closed
4524 * (see g_spawn_close_pid()) @pid must not be closed while the
4525 * source is still active. Typically, you will want to call
4526 * g_spawn_close_pid() in the callback function for the source.
4528 * GLib supports only a single callback per process id.
4530 * This internally creates a main loop source using
4531 * g_child_watch_source_new() and attaches it to the main loop context
4532 * using g_source_attach(). You can do these steps manually if you
4533 * need greater control.
4535 * Return value: the ID (greater than 0) of the event source.
4537 * Rename to: g_child_watch_add
4541 g_child_watch_add_full (gint priority,
4543 GChildWatchFunc function,
4545 GDestroyNotify notify)
4550 g_return_val_if_fail (function != NULL, 0);
4552 source = g_child_watch_source_new (pid);
4554 if (priority != G_PRIORITY_DEFAULT)
4555 g_source_set_priority (source, priority);
4557 g_source_set_callback (source, (GSourceFunc) function, data, notify);
4558 id = g_source_attach (source, NULL);
4559 g_source_unref (source);
4565 * g_child_watch_add:
4566 * @pid: process id to watch. On POSIX the pid of a child process. On
4567 * Windows a handle for a process (which doesn't have to be a child).
4568 * @function: function to call
4569 * @data: data to pass to @function
4571 * Sets a function to be called when the child indicated by @pid
4572 * exits, at a default priority, #G_PRIORITY_DEFAULT.
4574 * If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
4575 * you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
4576 * the spawn function for the child watching to work.
4578 * Note that on platforms where #GPid must be explicitly closed
4579 * (see g_spawn_close_pid()) @pid must not be closed while the
4580 * source is still active. Typically, you will want to call
4581 * g_spawn_close_pid() in the callback function for the source.
4583 * GLib supports only a single callback per process id.
4585 * This internally creates a main loop source using
4586 * g_child_watch_source_new() and attaches it to the main loop context
4587 * using g_source_attach(). You can do these steps manually if you
4588 * need greater control.
4590 * Return value: the ID (greater than 0) of the event source.
4595 g_child_watch_add (GPid pid,
4596 GChildWatchFunc function,
4599 return g_child_watch_add_full (G_PRIORITY_DEFAULT, pid, function, data, NULL);
4603 /* Idle functions */
4606 g_idle_prepare (GSource *source,
4615 g_idle_check (GSource *source)
4621 g_idle_dispatch (GSource *source,
4622 GSourceFunc callback,
4627 g_warning ("Idle source dispatched without callback\n"
4628 "You must call g_source_set_callback().");
4632 return callback (user_data);
4636 * g_idle_source_new:
4638 * Creates a new idle source.
4640 * The source will not initially be associated with any #GMainContext
4641 * and must be added to one with g_source_attach() before it will be
4642 * executed. Note that the default priority for idle sources is
4643 * %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
4644 * have a default priority of %G_PRIORITY_DEFAULT.
4646 * Return value: the newly-created idle source
4649 g_idle_source_new (void)
4653 source = g_source_new (&g_idle_funcs, sizeof (GSource));
4654 g_source_set_priority (source, G_PRIORITY_DEFAULT_IDLE);
4661 * @priority: the priority of the idle source. Typically this will be in the
4662 * range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
4663 * @function: function to call
4664 * @data: data to pass to @function
4665 * @notify: function to call when the idle is removed, or %NULL
4667 * Adds a function to be called whenever there are no higher priority
4668 * events pending. If the function returns %FALSE it is automatically
4669 * removed from the list of event sources and will not be called again.
4671 * This internally creates a main loop source using g_idle_source_new()
4672 * and attaches it to the main loop context using g_source_attach().
4673 * You can do these steps manually if you need greater control.
4675 * Return value: the ID (greater than 0) of the event source.
4676 * Rename to: g_idle_add
4679 g_idle_add_full (gint priority,
4680 GSourceFunc function,
4682 GDestroyNotify notify)
4687 g_return_val_if_fail (function != NULL, 0);
4689 source = g_idle_source_new ();
4691 if (priority != G_PRIORITY_DEFAULT_IDLE)
4692 g_source_set_priority (source, priority);
4694 g_source_set_callback (source, function, data, notify);
4695 id = g_source_attach (source, NULL);
4696 g_source_unref (source);
4703 * @function: function to call
4704 * @data: data to pass to @function.
4706 * Adds a function to be called whenever there are no higher priority
4707 * events pending to the default main loop. The function is given the
4708 * default idle priority, #G_PRIORITY_DEFAULT_IDLE. If the function
4709 * returns %FALSE it is automatically removed from the list of event
4710 * sources and will not be called again.
4712 * This internally creates a main loop source using g_idle_source_new()
4713 * and attaches it to the main loop context using g_source_attach().
4714 * You can do these steps manually if you need greater control.
4716 * Return value: the ID (greater than 0) of the event source.
4719 g_idle_add (GSourceFunc function,
4722 return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
4726 * g_idle_remove_by_data:
4727 * @data: the data for the idle source's callback.
4729 * Removes the idle function with the given data.
4731 * Return value: %TRUE if an idle source was found and removed.
4734 g_idle_remove_by_data (gpointer data)
4736 return g_source_remove_by_funcs_user_data (&g_idle_funcs, data);
4740 * g_main_context_invoke:
4741 * @context: (allow-none): a #GMainContext, or %NULL
4742 * @function: function to call
4743 * @data: data to pass to @function
4745 * Invokes a function in such a way that @context is owned during the
4746 * invocation of @function.
4748 * If @context is %NULL then the global default main context — as
4749 * returned by g_main_context_default() — is used.
4751 * If @context is owned by the current thread, @function is called
4752 * directly. Otherwise, if @context is the thread-default main context
4753 * of the current thread and g_main_context_acquire() succeeds, then
4754 * @function is called and g_main_context_release() is called
4757 * In any other case, an idle source is created to call @function and
4758 * that source is attached to @context (presumably to be run in another
4759 * thread). The idle source is attached with #G_PRIORITY_DEFAULT
4760 * priority. If you want a different priority, use
4761 * g_main_context_invoke_full().
4763 * Note that, as with normal idle functions, @function should probably
4764 * return %FALSE. If it returns %TRUE, it will be continuously run in a
4765 * loop (and may prevent this call from returning).
4770 g_main_context_invoke (GMainContext *context,
4771 GSourceFunc function,
4774 g_main_context_invoke_full (context,
4776 function, data, NULL);
4780 * g_main_context_invoke_full:
4781 * @context: (allow-none): a #GMainContext, or %NULL
4782 * @priority: the priority at which to run @function
4783 * @function: function to call
4784 * @data: data to pass to @function
4785 * @notify: a function to call when @data is no longer in use, or %NULL.
4787 * Invokes a function in such a way that @context is owned during the
4788 * invocation of @function.
4790 * This function is the same as g_main_context_invoke() except that it
4791 * lets you specify the priority incase @function ends up being
4792 * scheduled as an idle and also lets you give a #GDestroyNotify for @data.
4794 * @notify should not assume that it is called from any particular
4795 * thread or with any particular context acquired.
4800 g_main_context_invoke_full (GMainContext *context,
4802 GSourceFunc function,
4804 GDestroyNotify notify)
4806 g_return_if_fail (function != NULL);
4809 context = g_main_context_default ();
4811 if (g_main_context_is_owner (context))
4813 while (function (data));
4820 GMainContext *thread_default;
4822 thread_default = g_main_context_get_thread_default ();
4824 if (!thread_default)
4825 thread_default = g_main_context_default ();
4827 if (thread_default == context && g_main_context_acquire (context))
4829 while (function (data));
4831 g_main_context_release (context);
4840 source = g_idle_source_new ();
4841 g_source_set_priority (source, priority);
4842 g_source_set_callback (source, function, data, notify);
4843 g_source_attach (source, context);
4844 g_source_unref (source);
4850 glib_worker_main (gpointer data)
4854 g_main_context_iteration (glib_worker_context, TRUE);
4857 if (any_unix_signal_pending)
4858 dispatch_unix_signals ();
4862 return NULL; /* worst GCC warning message ever... */
4866 g_get_worker_context (void)
4868 static gsize initialised;
4870 if (g_once_init_enter (&initialised))
4872 /* mask all signals in the worker thread */
4878 pthread_sigmask (SIG_SETMASK, &all, &prev_mask);
4880 glib_worker_context = g_main_context_new ();
4881 g_thread_new ("gmain", glib_worker_main, NULL);
4883 pthread_sigmask (SIG_SETMASK, &prev_mask, NULL);
4885 g_once_init_leave (&initialised, TRUE);
4888 return glib_worker_context;