LCOV - code coverage report
Current view: top level - glib/glib - gmain.h (source / functions) Hit Total Coverage
Test: unnamed Lines: 10 10 100.0 %
Date: 2024-03-26 05:16:46 Functions: 3 3 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* gmain.h - the GLib Main loop
       2                 :            :  * Copyright (C) 1998-2000 Red Hat, Inc.
       3                 :            :  *
       4                 :            :  * SPDX-License-Identifier: LGPL-2.1-or-later
       5                 :            :  *
       6                 :            :  * This library is free software; you can redistribute it and/or
       7                 :            :  * modify it under the terms of the GNU Lesser General Public
       8                 :            :  * License as published by the Free Software Foundation; either
       9                 :            :  * version 2.1 of the License, or (at your option) any later version.
      10                 :            :  *
      11                 :            :  * This library is distributed in the hope that it will be useful,
      12                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14                 :            :  * Lesser General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU Lesser General Public License
      17                 :            :  * along with this library; if not, see <http://www.gnu.org/licenses/>.
      18                 :            :  */
      19                 :            : 
      20                 :            : #ifndef __G_MAIN_H__
      21                 :            : #define __G_MAIN_H__
      22                 :            : 
      23                 :            : #if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
      24                 :            : #error "Only <glib.h> can be included directly."
      25                 :            : #endif
      26                 :            : 
      27                 :            : #include <glib/gpoll.h>
      28                 :            : #include <glib/gslist.h>
      29                 :            : #include <glib/gthread.h>
      30                 :            : 
      31                 :            : G_BEGIN_DECLS
      32                 :            : 
      33                 :            : typedef enum /*< flags >*/
      34                 :            : {
      35                 :            :   G_IO_IN       GLIB_SYSDEF_POLLIN,
      36                 :            :   G_IO_OUT      GLIB_SYSDEF_POLLOUT,
      37                 :            :   G_IO_PRI      GLIB_SYSDEF_POLLPRI,
      38                 :            :   G_IO_ERR      GLIB_SYSDEF_POLLERR,
      39                 :            :   G_IO_HUP      GLIB_SYSDEF_POLLHUP,
      40                 :            :   G_IO_NVAL     GLIB_SYSDEF_POLLNVAL
      41                 :            : } GIOCondition;
      42                 :            : 
      43                 :            : /**
      44                 :            :  * GMainContextFlags:
      45                 :            :  * @G_MAIN_CONTEXT_FLAGS_NONE: Default behaviour.
      46                 :            :  * @G_MAIN_CONTEXT_FLAGS_OWNERLESS_POLLING: Assume that polling for events will
      47                 :            :  * free the thread to process other jobs. That's useful if you're using
      48                 :            :  * `g_main_context_{prepare,query,check,dispatch}` to integrate GMainContext in
      49                 :            :  * other event loops.
      50                 :            :  *
      51                 :            :  * Flags to pass to g_main_context_new_with_flags() which affect the behaviour
      52                 :            :  * of a #GMainContext.
      53                 :            :  *
      54                 :            :  * Since: 2.72
      55                 :            :  */
      56                 :            : GLIB_AVAILABLE_TYPE_IN_2_72
      57                 :            : typedef enum /*< flags >*/
      58                 :            : {
      59                 :            :   G_MAIN_CONTEXT_FLAGS_NONE = 0,
      60                 :            :   G_MAIN_CONTEXT_FLAGS_OWNERLESS_POLLING = 1
      61                 :            : } GMainContextFlags;
      62                 :            : 
      63                 :            : 
      64                 :            : /**
      65                 :            :  * GMainContext:
      66                 :            :  *
      67                 :            :  * The `GMainContext` struct is an opaque data
      68                 :            :  * type representing a set of sources to be handled in a main loop.
      69                 :            :  */
      70                 :            : typedef struct _GMainContext            GMainContext;
      71                 :            : 
      72                 :            : /**
      73                 :            :  * GMainLoop:
      74                 :            :  *
      75                 :            :  * The `GMainLoop` struct is an opaque data type
      76                 :            :  * representing the main event loop of a GLib or GTK application.
      77                 :            :  */
      78                 :            : typedef struct _GMainLoop               GMainLoop;
      79                 :            : 
      80                 :            : /**
      81                 :            :  * GSource:
      82                 :            :  *
      83                 :            :  * The `GSource` struct is an opaque data type
      84                 :            :  * representing an event source.
      85                 :            :  */
      86                 :            : typedef struct _GSource                 GSource;
      87                 :            : typedef struct _GSourcePrivate          GSourcePrivate;
      88                 :            : 
      89                 :            : /**
      90                 :            :  * GSourceCallbackFuncs:
      91                 :            :  * @ref: Called when a reference is added to the callback object
      92                 :            :  * @unref: Called when a reference to the callback object is dropped
      93                 :            :  * @get: Called to extract the callback function and data from the
      94                 :            :  *     callback object.
      95                 :            :  *
      96                 :            :  * The `GSourceCallbackFuncs` struct contains
      97                 :            :  * functions for managing callback objects.
      98                 :            :  */
      99                 :            : typedef struct _GSourceCallbackFuncs    GSourceCallbackFuncs;
     100                 :            : 
     101                 :            : /**
     102                 :            :  * GSourceFuncs:
     103                 :            :  * @prepare: Called before all the file descriptors are polled. If the
     104                 :            :  *     source can determine that it is ready here (without waiting for the
     105                 :            :  *     results of the poll() call) it should return %TRUE. It can also return
     106                 :            :  *     a @timeout_ value which should be the maximum timeout (in milliseconds)
     107                 :            :  *     which should be passed to the poll() call. The actual timeout used will
     108                 :            :  *     be -1 if all sources returned -1, or it will be the minimum of all
     109                 :            :  *     the @timeout_ values returned which were >= 0.  Since 2.36 this may
     110                 :            :  *     be %NULL, in which case the effect is as if the function always returns
     111                 :            :  *     %FALSE with a timeout of -1.  If @prepare returns a
     112                 :            :  *     timeout and the source also has a ready time set, then the
     113                 :            :  *     lower of the two will be used.
     114                 :            :  * @check: Called after all the file descriptors are polled. The source
     115                 :            :  *     should return %TRUE if it is ready to be dispatched. Note that some
     116                 :            :  *     time may have passed since the previous prepare function was called,
     117                 :            :  *     so the source should be checked again here.  Since 2.36 this may
     118                 :            :  *     be %NULL, in which case the effect is as if the function always returns
     119                 :            :  *     %FALSE.
     120                 :            :  * @dispatch: Called to dispatch the event source, after it has returned
     121                 :            :  *     %TRUE in either its @prepare or its @check function, or if a ready time
     122                 :            :  *     has been reached. The @dispatch function receives a callback function and
     123                 :            :  *     user data. The callback function may be %NULL if the source was never
     124                 :            :  *     connected to a callback using g_source_set_callback(). The @dispatch
     125                 :            :  *     function should call the callback function with @user_data and whatever
     126                 :            :  *     additional parameters are needed for this type of event source. The
     127                 :            :  *     return value of the @dispatch function should be %G_SOURCE_REMOVE if the
     128                 :            :  *     source should be removed or %G_SOURCE_CONTINUE to keep it.
     129                 :            :  * @finalize: Called when the source is finalized. At this point, the source
     130                 :            :  *     will have been destroyed, had its callback cleared, and have been removed
     131                 :            :  *     from its #GMainContext, but it will still have its final reference count,
     132                 :            :  *     so methods can be called on it from within this function.
     133                 :            :  *
     134                 :            :  * The `GSourceFuncs` struct contains a table of
     135                 :            :  * functions used to handle event sources in a generic manner.
     136                 :            :  *
     137                 :            :  * For idle sources, the prepare and check functions always return %TRUE
     138                 :            :  * to indicate that the source is always ready to be processed. The prepare
     139                 :            :  * function also returns a timeout value of 0 to ensure that the poll() call
     140                 :            :  * doesn't block (since that would be time wasted which could have been spent
     141                 :            :  * running the idle function).
     142                 :            :  *
     143                 :            :  * For timeout sources, the prepare and check functions both return %TRUE
     144                 :            :  * if the timeout interval has expired. The prepare function also returns
     145                 :            :  * a timeout value to ensure that the poll() call doesn't block too long
     146                 :            :  * and miss the next timeout.
     147                 :            :  *
     148                 :            :  * For file descriptor sources, the prepare function typically returns %FALSE,
     149                 :            :  * since it must wait until poll() has been called before it knows whether
     150                 :            :  * any events need to be processed. It sets the returned timeout to -1 to
     151                 :            :  * indicate that it doesn't mind how long the poll() call blocks. In the
     152                 :            :  * check function, it tests the results of the poll() call to see if the
     153                 :            :  * required condition has been met, and returns %TRUE if so.
     154                 :            :  */
     155                 :            : typedef struct _GSourceFuncs            GSourceFuncs;
     156                 :            : 
     157                 :            : /**
     158                 :            :  * GPid:
     159                 :            :  *
     160                 :            :  * A type which is used to hold a process identification.
     161                 :            :  *
     162                 :            :  * On UNIX, processes are identified by a process id (an integer),
     163                 :            :  * while Windows uses process handles (which are pointers).
     164                 :            :  *
     165                 :            :  * GPid is used in GLib only for descendant processes spawned with
     166                 :            :  * the g_spawn functions.
     167                 :            :  */
     168                 :            : /* defined in glibconfig.h */
     169                 :            : 
     170                 :            : /**
     171                 :            :  * G_PID_FORMAT:
     172                 :            :  *
     173                 :            :  * A format specifier that can be used in printf()-style format strings
     174                 :            :  * when printing a #GPid.
     175                 :            :  *
     176                 :            :  * Since: 2.50
     177                 :            :  */
     178                 :            : /* defined in glibconfig.h */
     179                 :            : 
     180                 :            : /**
     181                 :            :  * GSourceFunc:
     182                 :            :  * @user_data: data passed to the function, set when the source was
     183                 :            :  *     created with one of the above functions
     184                 :            :  *
     185                 :            :  * Specifies the type of function passed to g_timeout_add(),
     186                 :            :  * g_timeout_add_full(), g_idle_add(), and g_idle_add_full().
     187                 :            :  *
     188                 :            :  * When calling g_source_set_callback(), you may need to cast a function of a
     189                 :            :  * different type to this type. Use G_SOURCE_FUNC() to avoid warnings about
     190                 :            :  * incompatible function types.
     191                 :            :  *
     192                 :            :  * Returns: %FALSE if the source should be removed. %G_SOURCE_CONTINUE and
     193                 :            :  * %G_SOURCE_REMOVE are more memorable names for the return value.
     194                 :            :  */
     195                 :            : typedef gboolean (*GSourceFunc)       (gpointer user_data);
     196                 :            : 
     197                 :            : /**
     198                 :            :  * GSourceOnceFunc:
     199                 :            :  * @user_data: data passed to the function, set when the source was
     200                 :            :  *   created
     201                 :            :  *
     202                 :            :  * A source function that is only called once before being removed from the main
     203                 :            :  * context automatically.
     204                 :            :  *
     205                 :            :  * See: g_idle_add_once(), g_timeout_add_once()
     206                 :            :  *
     207                 :            :  * Since: 2.74
     208                 :            :  */
     209                 :            : typedef void (* GSourceOnceFunc) (gpointer user_data);
     210                 :            : 
     211                 :            : /**
     212                 :            :  * G_SOURCE_FUNC:
     213                 :            :  * @f: a function pointer.
     214                 :            :  *
     215                 :            :  * Cast a function pointer to a #GSourceFunc, suppressing warnings from GCC 8
     216                 :            :  * onwards with `-Wextra` or `-Wcast-function-type` enabled about the function
     217                 :            :  * types being incompatible.
     218                 :            :  *
     219                 :            :  * For example, the correct type of callback for a source created by
     220                 :            :  * g_child_watch_source_new() is #GChildWatchFunc, which accepts more arguments
     221                 :            :  * than #GSourceFunc. Casting the function with `(GSourceFunc)` to call
     222                 :            :  * g_source_set_callback() will trigger a warning, even though it will be cast
     223                 :            :  * back to the correct type before it is called by the source.
     224                 :            :  *
     225                 :            :  * Since: 2.58
     226                 :            :  */
     227                 :            : #define G_SOURCE_FUNC(f) ((GSourceFunc) (void (*)(void)) (f)) GLIB_AVAILABLE_MACRO_IN_2_58
     228                 :            : 
     229                 :            : /**
     230                 :            :  * GChildWatchFunc:
     231                 :            :  * @pid: the process id of the child process
     232                 :            :  * @wait_status: Status information about the child process, encoded
     233                 :            :  *               in a platform-specific manner
     234                 :            :  * @user_data: user data passed to g_child_watch_add()
     235                 :            :  *
     236                 :            :  * Prototype of a #GChildWatchSource callback, called when a child
     237                 :            :  * process has exited.
     238                 :            :  *
     239                 :            :  * To interpret @wait_status, see the documentation
     240                 :            :  * for g_spawn_check_wait_status(). In particular,
     241                 :            :  * on Unix platforms, note that it is usually not equal
     242                 :            :  * to the integer passed to `exit()` or returned from `main()`.
     243                 :            :  */
     244                 :            : typedef void     (*GChildWatchFunc)   (GPid     pid,
     245                 :            :                                        gint     wait_status,
     246                 :            :                                        gpointer user_data);
     247                 :            : 
     248                 :            : 
     249                 :            : /**
     250                 :            :  * GSourceDisposeFunc:
     251                 :            :  * @source: #GSource that is currently being disposed
     252                 :            :  *
     253                 :            :  * Dispose function for @source. See g_source_set_dispose_function() for
     254                 :            :  * details.
     255                 :            :  *
     256                 :            :  * Since: 2.64
     257                 :            :  */
     258                 :            : GLIB_AVAILABLE_TYPE_IN_2_64
     259                 :            : typedef void (*GSourceDisposeFunc)       (GSource *source);
     260                 :            : 
     261                 :            : struct _GSource
     262                 :            : {
     263                 :            :   /*< private >*/
     264                 :            :   gpointer callback_data;
     265                 :            :   GSourceCallbackFuncs *callback_funcs;
     266                 :            : 
     267                 :            :   const GSourceFuncs *source_funcs;
     268                 :            :   guint ref_count;
     269                 :            : 
     270                 :            :   GMainContext *context;
     271                 :            : 
     272                 :            :   gint priority;
     273                 :            :   guint flags;
     274                 :            :   guint source_id;
     275                 :            : 
     276                 :            :   GSList *poll_fds;
     277                 :            :   
     278                 :            :   GSource *prev;
     279                 :            :   GSource *next;
     280                 :            : 
     281                 :            :   char    *name;
     282                 :            : 
     283                 :            :   GSourcePrivate *priv;
     284                 :            : };
     285                 :            : 
     286                 :            : struct _GSourceCallbackFuncs
     287                 :            : {
     288                 :            :   void (*ref)   (gpointer     cb_data);
     289                 :            :   void (*unref) (gpointer     cb_data);
     290                 :            :   void (*get)   (gpointer     cb_data,
     291                 :            :                  GSource     *source, 
     292                 :            :                  GSourceFunc *func,
     293                 :            :                  gpointer    *data);
     294                 :            : };
     295                 :            : 
     296                 :            : /**
     297                 :            :  * GSourceDummyMarshal:
     298                 :            :  *
     299                 :            :  * This is just a placeholder for #GClosureMarshal,
     300                 :            :  * which cannot be used here for dependency reasons.
     301                 :            :  */
     302                 :            : typedef void (*GSourceDummyMarshal) (void);
     303                 :            : 
     304                 :            : struct _GSourceFuncs
     305                 :            : {
     306                 :            :   gboolean (*prepare)  (GSource    *source,
     307                 :            :                         gint       *timeout_);/* Can be NULL */
     308                 :            :   gboolean (*check)    (GSource    *source);/* Can be NULL */
     309                 :            :   gboolean (*dispatch) (GSource    *source,
     310                 :            :                         GSourceFunc callback,
     311                 :            :                         gpointer    user_data);
     312                 :            :   void     (*finalize) (GSource    *source); /* Can be NULL */
     313                 :            : 
     314                 :            :   /*< private >*/
     315                 :            :   /* For use by g_source_set_closure */
     316                 :            :   GSourceFunc     closure_callback;        
     317                 :            :   GSourceDummyMarshal closure_marshal; /* Really is of type GClosureMarshal */
     318                 :            : };
     319                 :            : 
     320                 :            : /* Standard priorities */
     321                 :            : 
     322                 :            : /**
     323                 :            :  * G_PRIORITY_HIGH:
     324                 :            :  *
     325                 :            :  * Use this for high priority event sources.
     326                 :            :  *
     327                 :            :  * It is not used within GLib or GTK.
     328                 :            :  */
     329                 :            : #define G_PRIORITY_HIGH            -100
     330                 :            : 
     331                 :            : /**
     332                 :            :  * G_PRIORITY_DEFAULT:
     333                 :            :  *
     334                 :            :  * Use this for default priority event sources.
     335                 :            :  *
     336                 :            :  * In GLib this priority is used when adding timeout functions
     337                 :            :  * with g_timeout_add(). In GDK this priority is used for events
     338                 :            :  * from the X server.
     339                 :            :  */
     340                 :            : #define G_PRIORITY_DEFAULT          0
     341                 :            : 
     342                 :            : /**
     343                 :            :  * G_PRIORITY_HIGH_IDLE:
     344                 :            :  *
     345                 :            :  * Use this for high priority idle functions.
     346                 :            :  *
     347                 :            :  * GTK uses %G_PRIORITY_HIGH_IDLE + 10 for resizing operations,
     348                 :            :  * and %G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is
     349                 :            :  * done to ensure that any pending resizes are processed before any
     350                 :            :  * pending redraws, so that widgets are not redrawn twice unnecessarily.)
     351                 :            :  */
     352                 :            : #define G_PRIORITY_HIGH_IDLE        100
     353                 :            : 
     354                 :            : /**
     355                 :            :  * G_PRIORITY_DEFAULT_IDLE:
     356                 :            :  *
     357                 :            :  * Use this for default priority idle functions.
     358                 :            :  *
     359                 :            :  * In GLib this priority is used when adding idle functions with
     360                 :            :  * g_idle_add().
     361                 :            :  */
     362                 :            : #define G_PRIORITY_DEFAULT_IDLE     200
     363                 :            : 
     364                 :            : /**
     365                 :            :  * G_PRIORITY_LOW:
     366                 :            :  *
     367                 :            :  * Use this for very low priority background tasks.
     368                 :            :  *
     369                 :            :  * It is not used within GLib or GTK.
     370                 :            :  */
     371                 :            : #define G_PRIORITY_LOW              300
     372                 :            : 
     373                 :            : /**
     374                 :            :  * G_SOURCE_REMOVE:
     375                 :            :  *
     376                 :            :  * Use this macro as the return value of a #GSourceFunc to remove
     377                 :            :  * the #GSource from the main loop.
     378                 :            :  *
     379                 :            :  * Since: 2.32
     380                 :            :  */
     381                 :            : #define G_SOURCE_REMOVE         FALSE
     382                 :            : 
     383                 :            : /**
     384                 :            :  * G_SOURCE_CONTINUE:
     385                 :            :  *
     386                 :            :  * Use this macro as the return value of a #GSourceFunc to leave
     387                 :            :  * the #GSource in the main loop.
     388                 :            :  *
     389                 :            :  * Since: 2.32
     390                 :            :  */
     391                 :            : #define G_SOURCE_CONTINUE       TRUE
     392                 :            : 
     393                 :            : /* GMainContext: */
     394                 :            : 
     395                 :            : GLIB_AVAILABLE_IN_ALL
     396                 :            : GMainContext *g_main_context_new       (void);
     397                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     398                 :            : GLIB_AVAILABLE_IN_2_72
     399                 :            : GMainContext *g_main_context_new_with_flags (GMainContextFlags flags);
     400                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     401                 :            : GLIB_AVAILABLE_IN_ALL
     402                 :            : GMainContext *g_main_context_ref       (GMainContext *context);
     403                 :            : GLIB_AVAILABLE_IN_ALL
     404                 :            : void          g_main_context_unref     (GMainContext *context);
     405                 :            : GLIB_AVAILABLE_IN_ALL
     406                 :            : GMainContext *g_main_context_default   (void);
     407                 :            : 
     408                 :            : GLIB_AVAILABLE_IN_ALL
     409                 :            : gboolean      g_main_context_iteration (GMainContext *context,
     410                 :            :                                         gboolean      may_block);
     411                 :            : GLIB_AVAILABLE_IN_ALL
     412                 :            : gboolean      g_main_context_pending   (GMainContext *context);
     413                 :            : 
     414                 :            : /* For implementation of legacy interfaces
     415                 :            :  */
     416                 :            : GLIB_AVAILABLE_IN_ALL
     417                 :            : GSource      *g_main_context_find_source_by_id              (GMainContext *context,
     418                 :            :                                                              guint         source_id);
     419                 :            : GLIB_AVAILABLE_IN_ALL
     420                 :            : GSource      *g_main_context_find_source_by_user_data       (GMainContext *context,
     421                 :            :                                                              gpointer      user_data);
     422                 :            : GLIB_AVAILABLE_IN_ALL
     423                 :            : GSource      *g_main_context_find_source_by_funcs_user_data (GMainContext *context,
     424                 :            :                                                              GSourceFuncs *funcs,
     425                 :            :                                                              gpointer      user_data);
     426                 :            : 
     427                 :            : /* Low level functions for implementing custom main loops.
     428                 :            :  */
     429                 :            : GLIB_AVAILABLE_IN_ALL
     430                 :            : void     g_main_context_wakeup  (GMainContext *context);
     431                 :            : GLIB_AVAILABLE_IN_ALL
     432                 :            : gboolean g_main_context_acquire (GMainContext *context);
     433                 :            : GLIB_AVAILABLE_IN_ALL
     434                 :            : void     g_main_context_release (GMainContext *context);
     435                 :            : GLIB_AVAILABLE_IN_ALL
     436                 :            : gboolean g_main_context_is_owner (GMainContext *context);
     437                 :            : GLIB_DEPRECATED_IN_2_58_FOR(g_main_context_is_owner)
     438                 :            : gboolean g_main_context_wait    (GMainContext *context,
     439                 :            :                                  GCond        *cond,
     440                 :            :                                  GMutex       *mutex);
     441                 :            : 
     442                 :            : GLIB_AVAILABLE_IN_ALL
     443                 :            : gboolean g_main_context_prepare  (GMainContext *context,
     444                 :            :                                   gint         *priority);
     445                 :            : GLIB_AVAILABLE_IN_ALL
     446                 :            : gint     g_main_context_query    (GMainContext *context,
     447                 :            :                                   gint          max_priority,
     448                 :            :                                   gint         *timeout_,
     449                 :            :                                   GPollFD      *fds,
     450                 :            :                                   gint          n_fds);
     451                 :            : GLIB_AVAILABLE_IN_ALL
     452                 :            : gboolean     g_main_context_check    (GMainContext *context,
     453                 :            :                                       gint          max_priority,
     454                 :            :                                       GPollFD      *fds,
     455                 :            :                                       gint          n_fds);
     456                 :            : GLIB_AVAILABLE_IN_ALL
     457                 :            : void     g_main_context_dispatch (GMainContext *context);
     458                 :            : 
     459                 :            : GLIB_AVAILABLE_IN_ALL
     460                 :            : void     g_main_context_set_poll_func (GMainContext *context,
     461                 :            :                                        GPollFunc     func);
     462                 :            : GLIB_AVAILABLE_IN_ALL
     463                 :            : GPollFunc g_main_context_get_poll_func (GMainContext *context);
     464                 :            : 
     465                 :            : /* Low level functions for use by source implementations
     466                 :            :  */
     467                 :            : GLIB_AVAILABLE_IN_ALL
     468                 :            : void     g_main_context_add_poll    (GMainContext *context,
     469                 :            :                                      GPollFD      *fd,
     470                 :            :                                      gint          priority);
     471                 :            : GLIB_AVAILABLE_IN_ALL
     472                 :            : void     g_main_context_remove_poll (GMainContext *context,
     473                 :            :                                      GPollFD      *fd);
     474                 :            : 
     475                 :            : GLIB_AVAILABLE_IN_ALL
     476                 :            : gint     g_main_depth               (void);
     477                 :            : GLIB_AVAILABLE_IN_ALL
     478                 :            : GSource *g_main_current_source      (void);
     479                 :            : 
     480                 :            : /* GMainContexts for other threads
     481                 :            :  */
     482                 :            : GLIB_AVAILABLE_IN_ALL
     483                 :            : void          g_main_context_push_thread_default (GMainContext *context);
     484                 :            : GLIB_AVAILABLE_IN_ALL
     485                 :            : void          g_main_context_pop_thread_default  (GMainContext *context);
     486                 :            : GLIB_AVAILABLE_IN_ALL
     487                 :            : GMainContext *g_main_context_get_thread_default  (void);
     488                 :            : GLIB_AVAILABLE_IN_ALL
     489                 :            : GMainContext *g_main_context_ref_thread_default  (void);
     490                 :            : 
     491                 :            : /**
     492                 :            :  * GMainContextPusher:
     493                 :            :  *
     494                 :            :  * Opaque type. See g_main_context_pusher_new() for details.
     495                 :            :  *
     496                 :            :  * Since: 2.64
     497                 :            :  */
     498                 :            : typedef void GMainContextPusher GLIB_AVAILABLE_TYPE_IN_2_64;
     499                 :            : 
     500                 :            : /**
     501                 :            :  * g_main_context_pusher_new:
     502                 :            :  * @main_context: (transfer none): a main context to push
     503                 :            :  *
     504                 :            :  * Push @main_context as the new thread-default main context for the current
     505                 :            :  * thread, using g_main_context_push_thread_default(), and return a new
     506                 :            :  * #GMainContextPusher. Pop with g_main_context_pusher_free(). Using
     507                 :            :  * g_main_context_pop_thread_default() on @main_context while a
     508                 :            :  * #GMainContextPusher exists for it can lead to undefined behaviour.
     509                 :            :  *
     510                 :            :  * Using two #GMainContextPushers in the same scope is not allowed, as it leads
     511                 :            :  * to an undefined pop order.
     512                 :            :  *
     513                 :            :  * This is intended to be used with g_autoptr().  Note that g_autoptr()
     514                 :            :  * is only available when using GCC or clang, so the following example
     515                 :            :  * will only work with those compilers:
     516                 :            :  * |[
     517                 :            :  * typedef struct
     518                 :            :  * {
     519                 :            :  *   ...
     520                 :            :  *   GMainContext *context;
     521                 :            :  *   ...
     522                 :            :  * } MyObject;
     523                 :            :  *
     524                 :            :  * static void
     525                 :            :  * my_object_do_stuff (MyObject *self)
     526                 :            :  * {
     527                 :            :  *   g_autoptr(GMainContextPusher) pusher = g_main_context_pusher_new (self->context);
     528                 :            :  *
     529                 :            :  *   // Code with main context as the thread default here
     530                 :            :  *
     531                 :            :  *   if (cond)
     532                 :            :  *     // No need to pop
     533                 :            :  *     return;
     534                 :            :  *
     535                 :            :  *   // Optionally early pop
     536                 :            :  *   g_clear_pointer (&pusher, g_main_context_pusher_free);
     537                 :            :  *
     538                 :            :  *   // Code with main context no longer the thread default here
     539                 :            :  * }
     540                 :            :  * ]|
     541                 :            :  *
     542                 :            :  * Returns: (transfer full): a #GMainContextPusher
     543                 :            :  * Since: 2.64
     544                 :            :  */
     545                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     546                 :            : GLIB_AVAILABLE_STATIC_INLINE_IN_2_64
     547                 :            : static inline GMainContextPusher *
     548                 :          1 : g_main_context_pusher_new (GMainContext *main_context)
     549                 :            : {
     550                 :          1 :   g_main_context_push_thread_default (main_context);
     551                 :          1 :   return (GMainContextPusher *) main_context;
     552                 :            : }
     553                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     554                 :            : 
     555                 :            : /**
     556                 :            :  * g_main_context_pusher_free:
     557                 :            :  * @pusher: (transfer full): a #GMainContextPusher
     558                 :            :  *
     559                 :            :  * Pop @pusher’s main context as the thread default main context.
     560                 :            :  * See g_main_context_pusher_new() for details.
     561                 :            :  *
     562                 :            :  * This will pop the #GMainContext as the current thread-default main context,
     563                 :            :  * but will not call g_main_context_unref() on it.
     564                 :            :  *
     565                 :            :  * Since: 2.64
     566                 :            :  */
     567                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     568                 :            : GLIB_AVAILABLE_STATIC_INLINE_IN_2_64
     569                 :            : static inline void
     570                 :          1 : g_main_context_pusher_free (GMainContextPusher *pusher)
     571                 :            : {
     572                 :          1 :   g_main_context_pop_thread_default ((GMainContext *) pusher);
     573                 :          1 : }
     574                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     575                 :            : 
     576                 :            : /* GMainLoop: */
     577                 :            : 
     578                 :            : GLIB_AVAILABLE_IN_ALL
     579                 :            : GMainLoop *g_main_loop_new        (GMainContext *context,
     580                 :            :                                    gboolean      is_running);
     581                 :            : GLIB_AVAILABLE_IN_ALL
     582                 :            : void       g_main_loop_run        (GMainLoop    *loop);
     583                 :            : GLIB_AVAILABLE_IN_ALL
     584                 :            : void       g_main_loop_quit       (GMainLoop    *loop);
     585                 :            : GLIB_AVAILABLE_IN_ALL
     586                 :            : GMainLoop *g_main_loop_ref        (GMainLoop    *loop);
     587                 :            : GLIB_AVAILABLE_IN_ALL
     588                 :            : void       g_main_loop_unref      (GMainLoop    *loop);
     589                 :            : GLIB_AVAILABLE_IN_ALL
     590                 :            : gboolean   g_main_loop_is_running (GMainLoop    *loop);
     591                 :            : GLIB_AVAILABLE_IN_ALL
     592                 :            : GMainContext *g_main_loop_get_context (GMainLoop    *loop);
     593                 :            : 
     594                 :            : /* GSource: */
     595                 :            : 
     596                 :            : GLIB_AVAILABLE_IN_ALL
     597                 :            : GSource *g_source_new             (GSourceFuncs   *source_funcs,
     598                 :            :                                    guint           struct_size);
     599                 :            : 
     600                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     601                 :            : GLIB_AVAILABLE_IN_2_64
     602                 :            : void     g_source_set_dispose_function (GSource            *source,
     603                 :            :                                         GSourceDisposeFunc  dispose);
     604                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     605                 :            : 
     606                 :            : GLIB_AVAILABLE_IN_ALL
     607                 :            : GSource *g_source_ref             (GSource        *source);
     608                 :            : GLIB_AVAILABLE_IN_ALL
     609                 :            : void     g_source_unref           (GSource        *source);
     610                 :            : 
     611                 :            : GLIB_AVAILABLE_IN_ALL
     612                 :            : guint    g_source_attach          (GSource        *source,
     613                 :            :                                    GMainContext   *context);
     614                 :            : GLIB_AVAILABLE_IN_ALL
     615                 :            : void     g_source_destroy         (GSource        *source);
     616                 :            : 
     617                 :            : GLIB_AVAILABLE_IN_ALL
     618                 :            : void     g_source_set_priority    (GSource        *source,
     619                 :            :                                    gint            priority);
     620                 :            : GLIB_AVAILABLE_IN_ALL
     621                 :            : gint     g_source_get_priority    (GSource        *source);
     622                 :            : GLIB_AVAILABLE_IN_ALL
     623                 :            : void     g_source_set_can_recurse (GSource        *source,
     624                 :            :                                    gboolean        can_recurse);
     625                 :            : GLIB_AVAILABLE_IN_ALL
     626                 :            : gboolean g_source_get_can_recurse (GSource        *source);
     627                 :            : GLIB_AVAILABLE_IN_ALL
     628                 :            : guint    g_source_get_id          (GSource        *source);
     629                 :            : 
     630                 :            : GLIB_AVAILABLE_IN_ALL
     631                 :            : GMainContext *g_source_get_context (GSource       *source);
     632                 :            : 
     633                 :            : GLIB_AVAILABLE_IN_ALL
     634                 :            : void     g_source_set_callback    (GSource        *source,
     635                 :            :                                    GSourceFunc     func,
     636                 :            :                                    gpointer        data,
     637                 :            :                                    GDestroyNotify  notify);
     638                 :            : 
     639                 :            : GLIB_AVAILABLE_IN_ALL
     640                 :            : void     g_source_set_funcs       (GSource        *source,
     641                 :            :                                    GSourceFuncs   *funcs);
     642                 :            : GLIB_AVAILABLE_IN_ALL
     643                 :            : gboolean g_source_is_destroyed    (GSource        *source);
     644                 :            : 
     645                 :            : GLIB_AVAILABLE_IN_ALL
     646                 :            : void                 g_source_set_name       (GSource        *source,
     647                 :            :                                               const char     *name);
     648                 :            : GLIB_AVAILABLE_IN_2_70
     649                 :            : void                 g_source_set_static_name (GSource        *source,
     650                 :            :                                                const char     *name);
     651                 :            : GLIB_AVAILABLE_IN_ALL
     652                 :            : const char *         g_source_get_name       (GSource        *source);
     653                 :            : GLIB_AVAILABLE_IN_ALL
     654                 :            : void                 g_source_set_name_by_id (guint           tag,
     655                 :            :                                               const char     *name);
     656                 :            : 
     657                 :            : GLIB_AVAILABLE_IN_2_36
     658                 :            : void                 g_source_set_ready_time (GSource        *source,
     659                 :            :                                               gint64          ready_time);
     660                 :            : GLIB_AVAILABLE_IN_2_36
     661                 :            : gint64               g_source_get_ready_time (GSource        *source);
     662                 :            : 
     663                 :            : #ifdef G_OS_UNIX
     664                 :            : GLIB_AVAILABLE_IN_2_36
     665                 :            : gpointer             g_source_add_unix_fd    (GSource        *source,
     666                 :            :                                               gint            fd,
     667                 :            :                                               GIOCondition    events);
     668                 :            : GLIB_AVAILABLE_IN_2_36
     669                 :            : void                 g_source_modify_unix_fd (GSource        *source,
     670                 :            :                                               gpointer        tag,
     671                 :            :                                               GIOCondition    new_events);
     672                 :            : GLIB_AVAILABLE_IN_2_36
     673                 :            : void                 g_source_remove_unix_fd (GSource        *source,
     674                 :            :                                               gpointer        tag);
     675                 :            : GLIB_AVAILABLE_IN_2_36
     676                 :            : GIOCondition         g_source_query_unix_fd  (GSource        *source,
     677                 :            :                                               gpointer        tag);
     678                 :            : #endif
     679                 :            : 
     680                 :            : /* Used to implement g_source_connect_closure and internally*/
     681                 :            : GLIB_AVAILABLE_IN_ALL
     682                 :            : void g_source_set_callback_indirect (GSource              *source,
     683                 :            :                                      gpointer              callback_data,
     684                 :            :                                      GSourceCallbackFuncs *callback_funcs);
     685                 :            : 
     686                 :            : GLIB_AVAILABLE_IN_ALL
     687                 :            : void     g_source_add_poll            (GSource        *source,
     688                 :            :                                        GPollFD        *fd);
     689                 :            : GLIB_AVAILABLE_IN_ALL
     690                 :            : void     g_source_remove_poll         (GSource        *source,
     691                 :            :                                        GPollFD        *fd);
     692                 :            : 
     693                 :            : GLIB_AVAILABLE_IN_ALL
     694                 :            : void     g_source_add_child_source    (GSource        *source,
     695                 :            :                                        GSource        *child_source);
     696                 :            : GLIB_AVAILABLE_IN_ALL
     697                 :            : void     g_source_remove_child_source (GSource        *source,
     698                 :            :                                        GSource        *child_source);
     699                 :            : 
     700                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     701                 :            : GLIB_DEPRECATED_IN_2_28_FOR(g_source_get_time)
     702                 :            : void     g_source_get_current_time (GSource        *source,
     703                 :            :                                     GTimeVal       *timeval);
     704                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     705                 :            : 
     706                 :            : GLIB_AVAILABLE_IN_ALL
     707                 :            : gint64   g_source_get_time         (GSource        *source);
     708                 :            : 
     709                 :            :  /* void g_source_connect_closure (GSource        *source,
     710                 :            :                                   GClosure       *closure);
     711                 :            :  */
     712                 :            : 
     713                 :            : /* Specific source types
     714                 :            :  */
     715                 :            : GLIB_AVAILABLE_IN_ALL
     716                 :            : GSource *g_idle_source_new        (void);
     717                 :            : GLIB_AVAILABLE_IN_ALL
     718                 :            : GSource *g_child_watch_source_new (GPid pid);
     719                 :            : GLIB_AVAILABLE_IN_ALL
     720                 :            : GSource *g_timeout_source_new     (guint interval);
     721                 :            : GLIB_AVAILABLE_IN_ALL
     722                 :            : GSource *g_timeout_source_new_seconds (guint interval);
     723                 :            : 
     724                 :            : /* Miscellaneous functions
     725                 :            :  */
     726                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     727                 :            : GLIB_DEPRECATED_IN_2_62_FOR(g_get_real_time)
     728                 :            : void   g_get_current_time                 (GTimeVal       *result);
     729                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     730                 :            : 
     731                 :            : GLIB_AVAILABLE_IN_ALL
     732                 :            : gint64 g_get_monotonic_time               (void);
     733                 :            : GLIB_AVAILABLE_IN_ALL
     734                 :            : gint64 g_get_real_time                    (void);
     735                 :            : 
     736                 :            : 
     737                 :            : /* Source manipulation by ID */
     738                 :            : GLIB_AVAILABLE_IN_ALL
     739                 :            : gboolean g_source_remove                     (guint          tag);
     740                 :            : GLIB_AVAILABLE_IN_ALL
     741                 :            : gboolean g_source_remove_by_user_data        (gpointer       user_data);
     742                 :            : GLIB_AVAILABLE_IN_ALL
     743                 :            : gboolean g_source_remove_by_funcs_user_data  (GSourceFuncs  *funcs,
     744                 :            :                                               gpointer       user_data);
     745                 :            : 
     746                 :            : /**
     747                 :            :  * GClearHandleFunc:
     748                 :            :  * @handle_id: the handle ID to clear
     749                 :            :  *
     750                 :            :  * Specifies the type of function passed to g_clear_handle_id().
     751                 :            :  * The implementation is expected to free the resource identified
     752                 :            :  * by @handle_id; for instance, if @handle_id is a #GSource ID,
     753                 :            :  * g_source_remove() can be used.
     754                 :            :  *
     755                 :            :  * Since: 2.56
     756                 :            :  */
     757                 :            : typedef void (* GClearHandleFunc) (guint handle_id);
     758                 :            : 
     759                 :            : GLIB_AVAILABLE_IN_2_56
     760                 :            : void    g_clear_handle_id (guint           *tag_ptr,
     761                 :            :                            GClearHandleFunc clear_func);
     762                 :            : 
     763                 :            : #define g_clear_handle_id(tag_ptr, clear_func)             \
     764                 :            :   G_STMT_START {                                           \
     765                 :            :     G_STATIC_ASSERT (sizeof *(tag_ptr) == sizeof (guint)); \
     766                 :            :     guint *_tag_ptr = (guint *) (tag_ptr);                 \
     767                 :            :     guint _handle_id;                                      \
     768                 :            :                                                            \
     769                 :            :     _handle_id = *_tag_ptr;                                \
     770                 :            :     if (_handle_id > 0)                                    \
     771                 :            :       {                                                    \
     772                 :            :         *_tag_ptr = 0;                                     \
     773                 :            :         clear_func (_handle_id);                           \
     774                 :            :       }                                                    \
     775                 :            :   } G_STMT_END                                             \
     776                 :            :   GLIB_AVAILABLE_MACRO_IN_2_56
     777                 :            : 
     778                 :            : /* Idles, child watchers and timeouts */
     779                 :            : GLIB_AVAILABLE_IN_ALL
     780                 :            : guint    g_timeout_add_full         (gint            priority,
     781                 :            :                                      guint           interval,
     782                 :            :                                      GSourceFunc     function,
     783                 :            :                                      gpointer        data,
     784                 :            :                                      GDestroyNotify  notify);
     785                 :            : GLIB_AVAILABLE_IN_ALL
     786                 :            : guint    g_timeout_add              (guint           interval,
     787                 :            :                                      GSourceFunc     function,
     788                 :            :                                      gpointer        data);
     789                 :            : GLIB_AVAILABLE_IN_2_74
     790                 :            : guint    g_timeout_add_once         (guint           interval,
     791                 :            :                                      GSourceOnceFunc function,
     792                 :            :                                      gpointer        data);
     793                 :            : GLIB_AVAILABLE_IN_ALL
     794                 :            : guint    g_timeout_add_seconds_full (gint            priority,
     795                 :            :                                      guint           interval,
     796                 :            :                                      GSourceFunc     function,
     797                 :            :                                      gpointer        data,
     798                 :            :                                      GDestroyNotify  notify);
     799                 :            : GLIB_AVAILABLE_IN_ALL
     800                 :            : guint    g_timeout_add_seconds      (guint           interval,
     801                 :            :                                      GSourceFunc     function,
     802                 :            :                                      gpointer        data);
     803                 :            : GLIB_AVAILABLE_IN_2_78
     804                 :            : guint    g_timeout_add_seconds_once (guint           interval,
     805                 :            :                                      GSourceOnceFunc function,
     806                 :            :                                      gpointer        data);
     807                 :            : GLIB_AVAILABLE_IN_ALL
     808                 :            : guint    g_child_watch_add_full     (gint            priority,
     809                 :            :                                      GPid            pid,
     810                 :            :                                      GChildWatchFunc function,
     811                 :            :                                      gpointer        data,
     812                 :            :                                      GDestroyNotify  notify);
     813                 :            : GLIB_AVAILABLE_IN_ALL
     814                 :            : guint    g_child_watch_add          (GPid            pid,
     815                 :            :                                      GChildWatchFunc function,
     816                 :            :                                      gpointer        data);
     817                 :            : GLIB_AVAILABLE_IN_ALL
     818                 :            : guint    g_idle_add                 (GSourceFunc     function,
     819                 :            :                                      gpointer        data);
     820                 :            : GLIB_AVAILABLE_IN_ALL
     821                 :            : guint    g_idle_add_full            (gint            priority,
     822                 :            :                                      GSourceFunc     function,
     823                 :            :                                      gpointer        data,
     824                 :            :                                      GDestroyNotify  notify);
     825                 :            : GLIB_AVAILABLE_IN_2_74
     826                 :            : guint    g_idle_add_once            (GSourceOnceFunc function,
     827                 :            :                                      gpointer        data);
     828                 :            : GLIB_AVAILABLE_IN_ALL
     829                 :            : gboolean g_idle_remove_by_data      (gpointer        data);
     830                 :            : 
     831                 :            : GLIB_AVAILABLE_IN_ALL
     832                 :            : void     g_main_context_invoke_full (GMainContext   *context,
     833                 :            :                                      gint            priority,
     834                 :            :                                      GSourceFunc     function,
     835                 :            :                                      gpointer        data,
     836                 :            :                                      GDestroyNotify  notify);
     837                 :            : GLIB_AVAILABLE_IN_ALL
     838                 :            : void     g_main_context_invoke      (GMainContext   *context,
     839                 :            :                                      GSourceFunc     function,
     840                 :            :                                      gpointer        data);
     841                 :            : 
     842                 :            : GLIB_AVAILABLE_STATIC_INLINE_IN_2_70
     843                 :            : static inline int
     844                 :       1662 : g_steal_fd (int *fd_ptr)
     845                 :            : {
     846                 :       1662 :   int fd = *fd_ptr;
     847                 :       1662 :   *fd_ptr = -1;
     848                 :       1662 :   return fd;
     849                 :            : }
     850                 :            : 
     851                 :            : /* Hook for GClosure / GSource integration. Don't touch */
     852                 :            : GLIB_VAR GSourceFuncs g_timeout_funcs;
     853                 :            : GLIB_VAR GSourceFuncs g_child_watch_funcs;
     854                 :            : GLIB_VAR GSourceFuncs g_idle_funcs;
     855                 :            : #ifdef G_OS_UNIX
     856                 :            : GLIB_VAR GSourceFuncs g_unix_signal_funcs;
     857                 :            : GLIB_VAR GSourceFuncs g_unix_fd_source_funcs;
     858                 :            : #endif
     859                 :            : 
     860                 :            : G_END_DECLS
     861                 :            : 
     862                 :            : #endif /* __G_MAIN_H__ */

Generated by: LCOV version 1.14