LCOV - code coverage report
Current view: top level - glib/gobject - gobject.h (source / functions) Hit Total Coverage
Test: unnamed Lines: 33 33 100.0 %
Date: 2024-05-21 07:38:11 Functions: 4 4 100.0 %
Branches: 14 14 100.0 %

           Branch data     Line data    Source code
       1                 :            : /* GObject - GLib Type, Object, Parameter and Signal Library
       2                 :            :  * Copyright (C) 1998-1999, 2000-2001 Tim Janik and 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
      17                 :            :  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
      18                 :            :  */
      19                 :            : #ifndef __G_OBJECT_H__
      20                 :            : #define __G_OBJECT_H__
      21                 :            : 
      22                 :            : #if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
      23                 :            : #error "Only <glib-object.h> can be included directly."
      24                 :            : #endif
      25                 :            : 
      26                 :            : #include        <gobject/gtype.h>
      27                 :            : #include        <gobject/gvalue.h>
      28                 :            : #include        <gobject/gparam.h>
      29                 :            : #include        <gobject/gclosure.h>
      30                 :            : #include        <gobject/gsignal.h>
      31                 :            : #include        <gobject/gboxed.h>
      32                 :            : 
      33                 :            : G_BEGIN_DECLS
      34                 :            : 
      35                 :            : /* --- type macros --- */
      36                 :            : /**
      37                 :            :  * G_TYPE_IS_OBJECT:
      38                 :            :  * @type: Type id to check
      39                 :            :  * 
      40                 :            :  * Check if the passed in type id is a %G_TYPE_OBJECT or derived from it.
      41                 :            :  * 
      42                 :            :  * Returns: %FALSE or %TRUE, indicating whether @type is a %G_TYPE_OBJECT.
      43                 :            :  */
      44                 :            : #define G_TYPE_IS_OBJECT(type)      (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT)
      45                 :            : /**
      46                 :            :  * G_OBJECT:
      47                 :            :  * @object: Object which is subject to casting.
      48                 :            :  * 
      49                 :            :  * Casts a #GObject or derived pointer into a (GObject*) pointer.
      50                 :            :  *
      51                 :            :  * Depending on the current debugging level, this function may invoke
      52                 :            :  * certain runtime checks to identify invalid casts.
      53                 :            :  */
      54                 :            : #define G_OBJECT(object)            (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject))
      55                 :            : /**
      56                 :            :  * G_OBJECT_CLASS:
      57                 :            :  * @class: a valid #GObjectClass
      58                 :            :  * 
      59                 :            :  * Casts a derived #GObjectClass structure into a #GObjectClass structure.
      60                 :            :  */
      61                 :            : #define G_OBJECT_CLASS(class)       (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass))
      62                 :            : /**
      63                 :            :  * G_IS_OBJECT:
      64                 :            :  * @object: Instance to check for being a %G_TYPE_OBJECT.
      65                 :            :  * 
      66                 :            :  * Checks whether a valid #GTypeInstance pointer is of type %G_TYPE_OBJECT.
      67                 :            :  */
      68                 :            : #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_42
      69                 :            : #define G_IS_OBJECT(object)         (G_TYPE_CHECK_INSTANCE_FUNDAMENTAL_TYPE ((object), G_TYPE_OBJECT))
      70                 :            : #else
      71                 :            : #define G_IS_OBJECT(object)         (G_TYPE_CHECK_INSTANCE_TYPE ((object), G_TYPE_OBJECT))
      72                 :            : #endif
      73                 :            : /**
      74                 :            :  * G_IS_OBJECT_CLASS:
      75                 :            :  * @class: a #GObjectClass
      76                 :            :  * 
      77                 :            :  * Checks whether @class "is a" valid #GObjectClass structure of type
      78                 :            :  * %G_TYPE_OBJECT or derived.
      79                 :            :  */
      80                 :            : #define G_IS_OBJECT_CLASS(class)    (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_OBJECT))
      81                 :            : /**
      82                 :            :  * G_OBJECT_GET_CLASS:
      83                 :            :  * @object: a #GObject instance.
      84                 :            :  * 
      85                 :            :  * Get the class structure associated to a #GObject instance.
      86                 :            :  *
      87                 :            :  * Returns: pointer to object class structure.
      88                 :            :  */
      89                 :            : #define G_OBJECT_GET_CLASS(object)  (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass))
      90                 :            : /**
      91                 :            :  * G_OBJECT_TYPE:
      92                 :            :  * @object: Object to return the type id for.
      93                 :            :  * 
      94                 :            :  * Get the type id of an object.
      95                 :            :  * 
      96                 :            :  * Returns: Type id of @object.
      97                 :            :  */
      98                 :            : #define G_OBJECT_TYPE(object)       (G_TYPE_FROM_INSTANCE (object))
      99                 :            : /**
     100                 :            :  * G_OBJECT_TYPE_NAME:
     101                 :            :  * @object: Object to return the type name for.
     102                 :            :  * 
     103                 :            :  * Get the name of an object's type.
     104                 :            :  * 
     105                 :            :  * Returns: Type name of @object. The string is owned by the type system and 
     106                 :            :  *  should not be freed.
     107                 :            :  */
     108                 :            : #define G_OBJECT_TYPE_NAME(object)  (g_type_name (G_OBJECT_TYPE (object)))
     109                 :            : /**
     110                 :            :  * G_OBJECT_CLASS_TYPE:
     111                 :            :  * @class: a valid #GObjectClass
     112                 :            :  * 
     113                 :            :  * Get the type id of a class structure.
     114                 :            :  * 
     115                 :            :  * Returns: Type id of @class.
     116                 :            :  */
     117                 :            : #define G_OBJECT_CLASS_TYPE(class)  (G_TYPE_FROM_CLASS (class))
     118                 :            : /**
     119                 :            :  * G_OBJECT_CLASS_NAME:
     120                 :            :  * @class: a valid #GObjectClass
     121                 :            :  * 
     122                 :            :  * Return the name of a class structure's type.
     123                 :            :  * 
     124                 :            :  * Returns: Type name of @class. The string is owned by the type system and 
     125                 :            :  *  should not be freed.
     126                 :            :  */
     127                 :            : #define G_OBJECT_CLASS_NAME(class)  (g_type_name (G_OBJECT_CLASS_TYPE (class)))
     128                 :            : /**
     129                 :            :  * G_VALUE_HOLDS_OBJECT:
     130                 :            :  * @value: a valid #GValue structure
     131                 :            :  * 
     132                 :            :  * Checks whether the given #GValue can hold values derived from type %G_TYPE_OBJECT.
     133                 :            :  * 
     134                 :            :  * Returns: %TRUE on success.
     135                 :            :  */
     136                 :            : #define G_VALUE_HOLDS_OBJECT(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_OBJECT))
     137                 :            : 
     138                 :            : /* --- type macros --- */
     139                 :            : /**
     140                 :            :  * G_TYPE_INITIALLY_UNOWNED:
     141                 :            :  * 
     142                 :            :  * The type for #GInitiallyUnowned.
     143                 :            :  */
     144                 :            : #define G_TYPE_INITIALLY_UNOWNED              (g_initially_unowned_get_type())
     145                 :            : /**
     146                 :            :  * G_INITIALLY_UNOWNED:
     147                 :            :  * @object: Object which is subject to casting.
     148                 :            :  * 
     149                 :            :  * Casts a #GInitiallyUnowned or derived pointer into a (GInitiallyUnowned*) 
     150                 :            :  * pointer.
     151                 :            :  *
     152                 :            :  * Depending on the current debugging level, this function may invoke
     153                 :            :  * certain runtime checks to identify invalid casts.
     154                 :            :  */
     155                 :            : #define G_INITIALLY_UNOWNED(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_INITIALLY_UNOWNED, GInitiallyUnowned))
     156                 :            : /**
     157                 :            :  * G_INITIALLY_UNOWNED_CLASS:
     158                 :            :  * @class: a valid #GInitiallyUnownedClass
     159                 :            :  * 
     160                 :            :  * Casts a derived #GInitiallyUnownedClass structure into a
     161                 :            :  * #GInitiallyUnownedClass structure.
     162                 :            :  */
     163                 :            : #define G_INITIALLY_UNOWNED_CLASS(class)      (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_INITIALLY_UNOWNED, GInitiallyUnownedClass))
     164                 :            : /**
     165                 :            :  * G_IS_INITIALLY_UNOWNED:
     166                 :            :  * @object: Instance to check for being a %G_TYPE_INITIALLY_UNOWNED.
     167                 :            :  * 
     168                 :            :  * Checks whether a valid #GTypeInstance pointer is of type %G_TYPE_INITIALLY_UNOWNED.
     169                 :            :  */
     170                 :            : #define G_IS_INITIALLY_UNOWNED(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), G_TYPE_INITIALLY_UNOWNED))
     171                 :            : /**
     172                 :            :  * G_IS_INITIALLY_UNOWNED_CLASS:
     173                 :            :  * @class: a #GInitiallyUnownedClass
     174                 :            :  * 
     175                 :            :  * Checks whether @class "is a" valid #GInitiallyUnownedClass structure of type
     176                 :            :  * %G_TYPE_INITIALLY_UNOWNED or derived.
     177                 :            :  */
     178                 :            : #define G_IS_INITIALLY_UNOWNED_CLASS(class)   (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_INITIALLY_UNOWNED))
     179                 :            : /**
     180                 :            :  * G_INITIALLY_UNOWNED_GET_CLASS:
     181                 :            :  * @object: a #GInitiallyUnowned instance.
     182                 :            :  * 
     183                 :            :  * Get the class structure associated to a #GInitiallyUnowned instance.
     184                 :            :  *
     185                 :            :  * Returns: pointer to object class structure.
     186                 :            :  */
     187                 :            : #define G_INITIALLY_UNOWNED_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_INITIALLY_UNOWNED, GInitiallyUnownedClass))
     188                 :            : /* GInitiallyUnowned ia a GObject with initially floating reference count */
     189                 :            : 
     190                 :            : 
     191                 :            : /* --- typedefs & structures --- */
     192                 :            : typedef struct _GObject                  GObject;
     193                 :            : typedef struct _GObjectClass             GObjectClass;
     194                 :            : typedef struct _GObject                  GInitiallyUnowned;
     195                 :            : typedef struct _GObjectClass             GInitiallyUnownedClass;
     196                 :            : typedef struct _GObjectConstructParam    GObjectConstructParam;
     197                 :            : /**
     198                 :            :  * GObjectGetPropertyFunc:
     199                 :            :  * @object: a #GObject
     200                 :            :  * @property_id: the numeric id under which the property was registered with
     201                 :            :  *  g_object_class_install_property().
     202                 :            :  * @value: a #GValue to return the property value in
     203                 :            :  * @pspec: the #GParamSpec describing the property
     204                 :            :  * 
     205                 :            :  * The type of the @get_property function of #GObjectClass. 
     206                 :            :  */
     207                 :            : typedef void (*GObjectGetPropertyFunc)  (GObject      *object,
     208                 :            :                                          guint         property_id,
     209                 :            :                                          GValue       *value,
     210                 :            :                                          GParamSpec   *pspec);
     211                 :            : /**
     212                 :            :  * GObjectSetPropertyFunc:
     213                 :            :  * @object: a #GObject
     214                 :            :  * @property_id: the numeric id under which the property was registered with
     215                 :            :  *  g_object_class_install_property().
     216                 :            :  * @value: the new value for the property
     217                 :            :  * @pspec: the #GParamSpec describing the property
     218                 :            :  * 
     219                 :            :  * The type of the @set_property function of #GObjectClass. 
     220                 :            :  */
     221                 :            : typedef void (*GObjectSetPropertyFunc)  (GObject      *object,
     222                 :            :                                          guint         property_id,
     223                 :            :                                          const GValue *value,
     224                 :            :                                          GParamSpec   *pspec);
     225                 :            : /**
     226                 :            :  * GObjectFinalizeFunc:
     227                 :            :  * @object: the #GObject being finalized
     228                 :            :  * 
     229                 :            :  * The type of the @finalize function of #GObjectClass.
     230                 :            :  */
     231                 :            : typedef void (*GObjectFinalizeFunc)     (GObject      *object);
     232                 :            : /**
     233                 :            :  * GWeakNotify:
     234                 :            :  * @data: data that was provided when the weak reference was established
     235                 :            :  * @where_the_object_was: the object being disposed
     236                 :            :  * 
     237                 :            :  * A #GWeakNotify function can be added to an object as a callback that gets
     238                 :            :  * triggered when the object is finalized.
     239                 :            :  *
     240                 :            :  * Since the object is already being disposed when the #GWeakNotify is called,
     241                 :            :  * there's not much you could do with the object, apart from e.g. using its
     242                 :            :  * address as hash-index or the like.
     243                 :            :  *
     244                 :            :  * In particular, this means it’s invalid to call g_object_ref(),
     245                 :            :  * g_weak_ref_init(), g_weak_ref_set(), g_object_add_toggle_ref(),
     246                 :            :  * g_object_weak_ref(), g_object_add_weak_pointer() or any function which calls
     247                 :            :  * them on the object from this callback.
     248                 :            :  */
     249                 :            : typedef void (*GWeakNotify)             (gpointer      data,
     250                 :            :                                          GObject      *where_the_object_was);
     251                 :            : 
     252                 :            : struct  _GObject
     253                 :            : {
     254                 :            :   GTypeInstance  g_type_instance;
     255                 :            :   
     256                 :            :   /*< private >*/
     257                 :            :   guint          ref_count;  /* (atomic) */
     258                 :            :   GData         *qdata;
     259                 :            : };
     260                 :            : /**
     261                 :            :  * GObjectClass:
     262                 :            :  * @g_type_class: the parent class
     263                 :            :  * @constructor: the @constructor function is called by g_object_new () to 
     264                 :            :  *  complete the object initialization after all the construction properties are
     265                 :            :  *  set. The first thing a @constructor implementation must do is chain up to the
     266                 :            :  *  @constructor of the parent class. Overriding @constructor should be rarely 
     267                 :            :  *  needed, e.g. to handle construct properties, or to implement singletons.
     268                 :            :  * @set_property: the generic setter for all properties of this type. Should be
     269                 :            :  *  overridden for every type with properties. If implementations of
     270                 :            :  *  @set_property don't emit property change notification explicitly, this will
     271                 :            :  *  be done implicitly by the type system. However, if the notify signal is
     272                 :            :  *  emitted explicitly, the type system will not emit it a second time.
     273                 :            :  * @get_property: the generic getter for all properties of this type. Should be
     274                 :            :  *  overridden for every type with properties.
     275                 :            :  * @dispose: the @dispose function is supposed to drop all references to other 
     276                 :            :  *  objects, but keep the instance otherwise intact, so that client method 
     277                 :            :  *  invocations still work. It may be run multiple times (due to reference 
     278                 :            :  *  loops). Before returning, @dispose should chain up to the @dispose method 
     279                 :            :  *  of the parent class.
     280                 :            :  * @finalize: instance finalization function, should finish the finalization of 
     281                 :            :  *  the instance begun in @dispose and chain up to the @finalize method of the 
     282                 :            :  *  parent class.
     283                 :            :  * @dispatch_properties_changed: emits property change notification for a bunch
     284                 :            :  *  of properties. Overriding @dispatch_properties_changed should be rarely 
     285                 :            :  *  needed.
     286                 :            :  * @notify: the class closure for the notify signal
     287                 :            :  * @constructed: the @constructed function is called by g_object_new() as the
     288                 :            :  *  final step of the object creation process.  At the point of the call, all
     289                 :            :  *  construction properties have been set on the object.  The purpose of this
     290                 :            :  *  call is to allow for object initialisation steps that can only be performed
     291                 :            :  *  after construction properties have been set.  @constructed implementors
     292                 :            :  *  should chain up to the @constructed call of their parent class to allow it
     293                 :            :  *  to complete its initialisation.
     294                 :            :  * 
     295                 :            :  * The class structure for the GObject type.
     296                 :            :  * 
     297                 :            :  * |[<!-- language="C" -->
     298                 :            :  * // Example of implementing a singleton using a constructor.
     299                 :            :  * static MySingleton *the_singleton = NULL;
     300                 :            :  * 
     301                 :            :  * static GObject*
     302                 :            :  * my_singleton_constructor (GType                  type,
     303                 :            :  *                           guint                  n_construct_params,
     304                 :            :  *                           GObjectConstructParam *construct_params)
     305                 :            :  * {
     306                 :            :  *   GObject *object;
     307                 :            :  *   
     308                 :            :  *   if (!the_singleton)
     309                 :            :  *     {
     310                 :            :  *       object = G_OBJECT_CLASS (parent_class)->constructor (type,
     311                 :            :  *                                                            n_construct_params,
     312                 :            :  *                                                            construct_params);
     313                 :            :  *       the_singleton = MY_SINGLETON (object);
     314                 :            :  *     }
     315                 :            :  *   else
     316                 :            :  *     object = g_object_ref (G_OBJECT (the_singleton));
     317                 :            :  * 
     318                 :            :  *   return object;
     319                 :            :  * }
     320                 :            :  * ]|
     321                 :            :  */
     322                 :            : struct  _GObjectClass
     323                 :            : {
     324                 :            :   GTypeClass   g_type_class;
     325                 :            : 
     326                 :            :   /*< private >*/
     327                 :            :   GSList      *construct_properties;
     328                 :            : 
     329                 :            :   /*< public >*/
     330                 :            :   /* seldom overridden */
     331                 :            :   GObject*   (*constructor)     (GType                  type,
     332                 :            :                                  guint                  n_construct_properties,
     333                 :            :                                  GObjectConstructParam *construct_properties);
     334                 :            :   /* overridable methods */
     335                 :            :   void       (*set_property)            (GObject        *object,
     336                 :            :                                          guint           property_id,
     337                 :            :                                          const GValue   *value,
     338                 :            :                                          GParamSpec     *pspec);
     339                 :            :   void       (*get_property)            (GObject        *object,
     340                 :            :                                          guint           property_id,
     341                 :            :                                          GValue         *value,
     342                 :            :                                          GParamSpec     *pspec);
     343                 :            :   void       (*dispose)                 (GObject        *object);
     344                 :            :   void       (*finalize)                (GObject        *object);
     345                 :            :   /* seldom overridden */
     346                 :            :   void       (*dispatch_properties_changed) (GObject      *object,
     347                 :            :                                              guint         n_pspecs,
     348                 :            :                                              GParamSpec  **pspecs);
     349                 :            :   /* signals */
     350                 :            :   void       (*notify)                  (GObject        *object,
     351                 :            :                                          GParamSpec     *pspec);
     352                 :            : 
     353                 :            :   /* called when done constructing */
     354                 :            :   void       (*constructed)             (GObject        *object);
     355                 :            : 
     356                 :            :   /*< private >*/
     357                 :            :   gsize         flags;
     358                 :            : 
     359                 :            :   gsize         n_construct_properties;
     360                 :            : 
     361                 :            :   gpointer pspecs;
     362                 :            :   gsize n_pspecs;
     363                 :            : 
     364                 :            :   /* padding */
     365                 :            :   gpointer      pdummy[3];
     366                 :            : };
     367                 :            : 
     368                 :            : /**
     369                 :            :  * GObjectConstructParam:
     370                 :            :  * @pspec: the #GParamSpec of the construct parameter
     371                 :            :  * @value: the value to set the parameter to
     372                 :            :  * 
     373                 :            :  * The GObjectConstructParam struct is an auxiliary structure used to hand
     374                 :            :  * #GParamSpec/#GValue pairs to the @constructor of a #GObjectClass.
     375                 :            :  */
     376                 :            : struct _GObjectConstructParam
     377                 :            : {
     378                 :            :   GParamSpec *pspec;
     379                 :            :   GValue     *value;
     380                 :            : };
     381                 :            : 
     382                 :            : /**
     383                 :            :  * GInitiallyUnowned:
     384                 :            :  *
     385                 :            :  * A type for objects that have an initially floating reference.
     386                 :            :  * 
     387                 :            :  * All the fields in the `GInitiallyUnowned` structure are private to the
     388                 :            :  * implementation and should never be accessed directly.
     389                 :            :  */
     390                 :            : /**
     391                 :            :  * GInitiallyUnownedClass:
     392                 :            :  * 
     393                 :            :  * The class structure for the GInitiallyUnowned type.
     394                 :            :  */
     395                 :            : 
     396                 :            : 
     397                 :            : /* --- prototypes --- */
     398                 :            : GOBJECT_AVAILABLE_IN_ALL
     399                 :            : GType       g_initially_unowned_get_type      (void);
     400                 :            : GOBJECT_AVAILABLE_IN_ALL
     401                 :            : void        g_object_class_install_property   (GObjectClass   *oclass,
     402                 :            :                                                guint           property_id,
     403                 :            :                                                GParamSpec     *pspec);
     404                 :            : GOBJECT_AVAILABLE_IN_ALL
     405                 :            : GParamSpec* g_object_class_find_property      (GObjectClass   *oclass,
     406                 :            :                                                const gchar    *property_name);
     407                 :            : GOBJECT_AVAILABLE_IN_ALL
     408                 :            : GParamSpec**g_object_class_list_properties    (GObjectClass   *oclass,
     409                 :            :                                                guint          *n_properties);
     410                 :            : GOBJECT_AVAILABLE_IN_ALL
     411                 :            : void        g_object_class_override_property  (GObjectClass   *oclass,
     412                 :            :                                                guint           property_id,
     413                 :            :                                                const gchar    *name);
     414                 :            : GOBJECT_AVAILABLE_IN_ALL
     415                 :            : void        g_object_class_install_properties (GObjectClass   *oclass,
     416                 :            :                                                guint           n_pspecs,
     417                 :            :                                                GParamSpec    **pspecs);
     418                 :            : 
     419                 :            : GOBJECT_AVAILABLE_IN_ALL
     420                 :            : void        g_object_interface_install_property (gpointer     g_iface,
     421                 :            :                                                  GParamSpec  *pspec);
     422                 :            : GOBJECT_AVAILABLE_IN_ALL
     423                 :            : GParamSpec* g_object_interface_find_property    (gpointer     g_iface,
     424                 :            :                                                  const gchar *property_name);
     425                 :            : GOBJECT_AVAILABLE_IN_ALL
     426                 :            : GParamSpec**g_object_interface_list_properties  (gpointer     g_iface,
     427                 :            :                                                  guint       *n_properties_p);
     428                 :            : 
     429                 :            : GOBJECT_AVAILABLE_IN_ALL
     430                 :            : GType       g_object_get_type                 (void) G_GNUC_CONST;
     431                 :            : GOBJECT_AVAILABLE_IN_ALL
     432                 :            : gpointer    g_object_new                      (GType           object_type,
     433                 :            :                                                const gchar    *first_property_name,
     434                 :            :                                                ...);
     435                 :            : GOBJECT_AVAILABLE_IN_2_54
     436                 :            : GObject*    g_object_new_with_properties      (GType           object_type,
     437                 :            :                                                guint           n_properties,
     438                 :            :                                                const char     *names[],
     439                 :            :                                                const GValue    values[]);
     440                 :            : 
     441                 :            : G_GNUC_BEGIN_IGNORE_DEPRECATIONS
     442                 :            : 
     443                 :            : GOBJECT_DEPRECATED_IN_2_54_FOR(g_object_new_with_properties)
     444                 :            : gpointer    g_object_newv                     (GType           object_type,
     445                 :            :                                                guint           n_parameters,
     446                 :            :                                                GParameter     *parameters);
     447                 :            : 
     448                 :            : G_GNUC_END_IGNORE_DEPRECATIONS
     449                 :            : 
     450                 :            : GOBJECT_AVAILABLE_IN_ALL
     451                 :            : GObject*    g_object_new_valist               (GType           object_type,
     452                 :            :                                                const gchar    *first_property_name,
     453                 :            :                                                va_list         var_args);
     454                 :            : GOBJECT_AVAILABLE_IN_ALL
     455                 :            : void        g_object_set                      (gpointer        object,
     456                 :            :                                                const gchar    *first_property_name,
     457                 :            :                                                ...) G_GNUC_NULL_TERMINATED;
     458                 :            : GOBJECT_AVAILABLE_IN_ALL
     459                 :            : void        g_object_get                      (gpointer        object,
     460                 :            :                                                const gchar    *first_property_name,
     461                 :            :                                                ...) G_GNUC_NULL_TERMINATED;
     462                 :            : GOBJECT_AVAILABLE_IN_ALL
     463                 :            : gpointer    g_object_connect                  (gpointer        object,
     464                 :            :                                                const gchar    *signal_spec,
     465                 :            :                                                ...) G_GNUC_NULL_TERMINATED;
     466                 :            : GOBJECT_AVAILABLE_IN_ALL
     467                 :            : void        g_object_disconnect               (gpointer        object,
     468                 :            :                                                const gchar    *signal_spec,
     469                 :            :                                                ...) G_GNUC_NULL_TERMINATED;
     470                 :            : GOBJECT_AVAILABLE_IN_2_54
     471                 :            : void        g_object_setv                     (GObject        *object,
     472                 :            :                                                guint           n_properties,
     473                 :            :                                                const gchar    *names[],
     474                 :            :                                                const GValue    values[]);
     475                 :            : GOBJECT_AVAILABLE_IN_ALL
     476                 :            : void        g_object_set_valist               (GObject        *object,
     477                 :            :                                                const gchar    *first_property_name,
     478                 :            :                                                va_list         var_args);
     479                 :            : GOBJECT_AVAILABLE_IN_2_54
     480                 :            : void        g_object_getv                     (GObject        *object,
     481                 :            :                                                guint           n_properties,
     482                 :            :                                                const gchar    *names[],
     483                 :            :                                                GValue          values[]);
     484                 :            : GOBJECT_AVAILABLE_IN_ALL
     485                 :            : void        g_object_get_valist               (GObject        *object,
     486                 :            :                                                const gchar    *first_property_name,
     487                 :            :                                                va_list         var_args);
     488                 :            : GOBJECT_AVAILABLE_IN_ALL
     489                 :            : void        g_object_set_property             (GObject        *object,
     490                 :            :                                                const gchar    *property_name,
     491                 :            :                                                const GValue   *value);
     492                 :            : GOBJECT_AVAILABLE_IN_ALL
     493                 :            : void        g_object_get_property             (GObject        *object,
     494                 :            :                                                const gchar    *property_name,
     495                 :            :                                                GValue         *value);
     496                 :            : GOBJECT_AVAILABLE_IN_ALL
     497                 :            : void        g_object_freeze_notify            (GObject        *object);
     498                 :            : GOBJECT_AVAILABLE_IN_ALL
     499                 :            : void        g_object_notify                   (GObject        *object,
     500                 :            :                                                const gchar    *property_name);
     501                 :            : GOBJECT_AVAILABLE_IN_ALL
     502                 :            : void        g_object_notify_by_pspec          (GObject        *object,
     503                 :            :                                                GParamSpec     *pspec);
     504                 :            : GOBJECT_AVAILABLE_IN_ALL
     505                 :            : void        g_object_thaw_notify              (GObject        *object);
     506                 :            : GOBJECT_AVAILABLE_IN_ALL
     507                 :            : gboolean    g_object_is_floating              (gpointer        object);
     508                 :            : GOBJECT_AVAILABLE_IN_ALL
     509                 :            : gpointer    g_object_ref_sink                 (gpointer        object);
     510                 :            : GOBJECT_AVAILABLE_IN_2_70
     511                 :            : gpointer    g_object_take_ref                 (gpointer        object);
     512                 :            : GOBJECT_AVAILABLE_IN_ALL
     513                 :            : gpointer    g_object_ref                      (gpointer        object);
     514                 :            : GOBJECT_AVAILABLE_IN_ALL
     515                 :            : void        g_object_unref                    (gpointer        object);
     516                 :            : GOBJECT_AVAILABLE_IN_ALL
     517                 :            : void        g_object_weak_ref                 (GObject        *object,
     518                 :            :                                                GWeakNotify     notify,
     519                 :            :                                                gpointer        data);
     520                 :            : GOBJECT_AVAILABLE_IN_ALL
     521                 :            : void        g_object_weak_unref               (GObject        *object,
     522                 :            :                                                GWeakNotify     notify,
     523                 :            :                                                gpointer        data);
     524                 :            : GOBJECT_AVAILABLE_IN_ALL
     525                 :            : void        g_object_add_weak_pointer         (GObject        *object, 
     526                 :            :                                                gpointer       *weak_pointer_location);
     527                 :            : GOBJECT_AVAILABLE_IN_ALL
     528                 :            : void        g_object_remove_weak_pointer      (GObject        *object, 
     529                 :            :                                                gpointer       *weak_pointer_location);
     530                 :            : 
     531                 :            : #if defined(glib_typeof) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_56
     532                 :            : /* Make reference APIs type safe with macros */
     533                 :            : #define g_object_ref(Obj) ((glib_typeof (Obj)) (g_object_ref) (Obj))
     534                 :            : #define g_object_ref_sink(Obj) ((glib_typeof (Obj)) (g_object_ref_sink) (Obj))
     535                 :            : #endif
     536                 :            : 
     537                 :            : /**
     538                 :            :  * GToggleNotify:
     539                 :            :  * @data: Callback data passed to g_object_add_toggle_ref()
     540                 :            :  * @object: The object on which g_object_add_toggle_ref() was called.
     541                 :            :  * @is_last_ref: %TRUE if the toggle reference is now the
     542                 :            :  *  last reference to the object. %FALSE if the toggle
     543                 :            :  *  reference was the last reference and there are now other
     544                 :            :  *  references.
     545                 :            :  * 
     546                 :            :  * A callback function used for notification when the state
     547                 :            :  * of a toggle reference changes.
     548                 :            :  *
     549                 :            :  * See also: g_object_add_toggle_ref()
     550                 :            :  */
     551                 :            : typedef void (*GToggleNotify) (gpointer      data,
     552                 :            :                                GObject      *object,
     553                 :            :                                gboolean      is_last_ref);
     554                 :            : 
     555                 :            : GOBJECT_AVAILABLE_IN_ALL
     556                 :            : void g_object_add_toggle_ref    (GObject       *object,
     557                 :            :                                  GToggleNotify  notify,
     558                 :            :                                  gpointer       data);
     559                 :            : GOBJECT_AVAILABLE_IN_ALL
     560                 :            : void g_object_remove_toggle_ref (GObject       *object,
     561                 :            :                                  GToggleNotify  notify,
     562                 :            :                                  gpointer       data);
     563                 :            : 
     564                 :            : GOBJECT_AVAILABLE_IN_ALL
     565                 :            : gpointer    g_object_get_qdata                (GObject        *object,
     566                 :            :                                                GQuark          quark);
     567                 :            : GOBJECT_AVAILABLE_IN_ALL
     568                 :            : void        g_object_set_qdata                (GObject        *object,
     569                 :            :                                                GQuark          quark,
     570                 :            :                                                gpointer        data);
     571                 :            : GOBJECT_AVAILABLE_IN_ALL
     572                 :            : void        g_object_set_qdata_full           (GObject        *object,
     573                 :            :                                                GQuark          quark,
     574                 :            :                                                gpointer        data,
     575                 :            :                                                GDestroyNotify  destroy);
     576                 :            : GOBJECT_AVAILABLE_IN_ALL
     577                 :            : gpointer    g_object_steal_qdata              (GObject        *object,
     578                 :            :                                                GQuark          quark);
     579                 :            : 
     580                 :            : GOBJECT_AVAILABLE_IN_2_34
     581                 :            : gpointer    g_object_dup_qdata                (GObject        *object,
     582                 :            :                                                GQuark          quark,
     583                 :            :                                                GDuplicateFunc  dup_func,
     584                 :            :                                                gpointer         user_data);
     585                 :            : GOBJECT_AVAILABLE_IN_2_34
     586                 :            : gboolean    g_object_replace_qdata            (GObject        *object,
     587                 :            :                                                GQuark          quark,
     588                 :            :                                                gpointer        oldval,
     589                 :            :                                                gpointer        newval,
     590                 :            :                                                GDestroyNotify  destroy,
     591                 :            :                                                GDestroyNotify *old_destroy);
     592                 :            : 
     593                 :            : GOBJECT_AVAILABLE_IN_ALL
     594                 :            : gpointer    g_object_get_data                 (GObject        *object,
     595                 :            :                                                const gchar    *key);
     596                 :            : GOBJECT_AVAILABLE_IN_ALL
     597                 :            : void        g_object_set_data                 (GObject        *object,
     598                 :            :                                                const gchar    *key,
     599                 :            :                                                gpointer        data);
     600                 :            : GOBJECT_AVAILABLE_IN_ALL
     601                 :            : void        g_object_set_data_full            (GObject        *object,
     602                 :            :                                                const gchar    *key,
     603                 :            :                                                gpointer        data,
     604                 :            :                                                GDestroyNotify  destroy);
     605                 :            : GOBJECT_AVAILABLE_IN_ALL
     606                 :            : gpointer    g_object_steal_data               (GObject        *object,
     607                 :            :                                                const gchar    *key);
     608                 :            : 
     609                 :            : GOBJECT_AVAILABLE_IN_2_34
     610                 :            : gpointer    g_object_dup_data                 (GObject        *object,
     611                 :            :                                                const gchar    *key,
     612                 :            :                                                GDuplicateFunc  dup_func,
     613                 :            :                                                gpointer         user_data);
     614                 :            : GOBJECT_AVAILABLE_IN_2_34
     615                 :            : gboolean    g_object_replace_data             (GObject        *object,
     616                 :            :                                                const gchar    *key,
     617                 :            :                                                gpointer        oldval,
     618                 :            :                                                gpointer        newval,
     619                 :            :                                                GDestroyNotify  destroy,
     620                 :            :                                                GDestroyNotify *old_destroy);
     621                 :            : 
     622                 :            : 
     623                 :            : GOBJECT_AVAILABLE_IN_ALL
     624                 :            : void        g_object_watch_closure            (GObject        *object,
     625                 :            :                                                GClosure       *closure);
     626                 :            : GOBJECT_AVAILABLE_IN_ALL
     627                 :            : GClosure*   g_cclosure_new_object             (GCallback       callback_func,
     628                 :            :                                                GObject        *object);
     629                 :            : GOBJECT_AVAILABLE_IN_ALL
     630                 :            : GClosure*   g_cclosure_new_object_swap        (GCallback       callback_func,
     631                 :            :                                                GObject        *object);
     632                 :            : GOBJECT_AVAILABLE_IN_ALL
     633                 :            : GClosure*   g_closure_new_object              (guint           sizeof_closure,
     634                 :            :                                                GObject        *object);
     635                 :            : GOBJECT_AVAILABLE_IN_ALL
     636                 :            : void        g_value_set_object                (GValue         *value,
     637                 :            :                                                gpointer        v_object);
     638                 :            : GOBJECT_AVAILABLE_IN_ALL
     639                 :            : gpointer    g_value_get_object                (const GValue   *value);
     640                 :            : GOBJECT_AVAILABLE_IN_ALL
     641                 :            : gpointer    g_value_dup_object                (const GValue   *value);
     642                 :            : GOBJECT_AVAILABLE_IN_ALL
     643                 :            : gulong      g_signal_connect_object           (gpointer        instance,
     644                 :            :                                                const gchar    *detailed_signal,
     645                 :            :                                                GCallback       c_handler,
     646                 :            :                                                gpointer        gobject,
     647                 :            :                                                GConnectFlags   connect_flags);
     648                 :            : 
     649                 :            : /*< protected >*/
     650                 :            : GOBJECT_AVAILABLE_IN_ALL
     651                 :            : void        g_object_force_floating           (GObject        *object);
     652                 :            : GOBJECT_AVAILABLE_IN_ALL
     653                 :            : void        g_object_run_dispose              (GObject        *object);
     654                 :            : 
     655                 :            : 
     656                 :            : GOBJECT_AVAILABLE_IN_ALL
     657                 :            : void        g_value_take_object               (GValue         *value,
     658                 :            :                                                gpointer        v_object);
     659                 :            : GOBJECT_DEPRECATED_FOR(g_value_take_object)
     660                 :            : void        g_value_set_object_take_ownership (GValue         *value,
     661                 :            :                                                gpointer        v_object);
     662                 :            : 
     663                 :            : GOBJECT_DEPRECATED
     664                 :            : gsize       g_object_compat_control           (gsize           what,
     665                 :            :                                                gpointer        data);
     666                 :            : 
     667                 :            : /* --- implementation macros --- */
     668                 :            : #define G_OBJECT_WARN_INVALID_PSPEC(object, pname, property_id, pspec) \
     669                 :            : G_STMT_START { \
     670                 :            :   GObject *_glib__object = (GObject*) (object); \
     671                 :            :   GParamSpec *_glib__pspec = (GParamSpec*) (pspec); \
     672                 :            :   guint _glib__property_id = (property_id); \
     673                 :            :   g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'", \
     674                 :            :              __FILE__, __LINE__, \
     675                 :            :              (pname), \
     676                 :            :              _glib__property_id, \
     677                 :            :              _glib__pspec->name, \
     678                 :            :              g_type_name (G_PARAM_SPEC_TYPE (_glib__pspec)), \
     679                 :            :              G_OBJECT_TYPE_NAME (_glib__object)); \
     680                 :            : } G_STMT_END
     681                 :            : /**
     682                 :            :  * G_OBJECT_WARN_INVALID_PROPERTY_ID:
     683                 :            :  * @object: the #GObject on which set_property() or get_property() was called
     684                 :            :  * @property_id: the numeric id of the property
     685                 :            :  * @pspec: the #GParamSpec of the property
     686                 :            :  * 
     687                 :            :  * This macro should be used to emit a standard warning about unexpected 
     688                 :            :  * properties in set_property() and get_property() implementations.
     689                 :            :  */
     690                 :            : #define G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec) \
     691                 :            :     G_OBJECT_WARN_INVALID_PSPEC ((object), "property", (property_id), (pspec))
     692                 :            : 
     693                 :            : GOBJECT_AVAILABLE_IN_ALL
     694                 :            : void    g_clear_object (GObject **object_ptr);
     695                 :            : #define g_clear_object(object_ptr) g_clear_pointer ((object_ptr), g_object_unref)
     696                 :            : 
     697                 :            : /**
     698                 :            :  * g_set_object: (skip)
     699                 :            :  * @object_ptr: (inout) (not optional) (nullable): a pointer to a #GObject reference
     700                 :            :  * @new_object: (nullable) (transfer none): a pointer to the new #GObject to
     701                 :            :  *   assign to @object_ptr, or %NULL to clear the pointer
     702                 :            :  *
     703                 :            :  * Updates a #GObject pointer to refer to @new_object.
     704                 :            :  *
     705                 :            :  * It increments the reference count of @new_object (if non-%NULL), decrements
     706                 :            :  * the reference count of the current value of @object_ptr (if non-%NULL), and
     707                 :            :  * assigns @new_object to @object_ptr. The assignment is not atomic.
     708                 :            :  *
     709                 :            :  * @object_ptr must not be %NULL, but can point to a %NULL value.
     710                 :            :  *
     711                 :            :  * A macro is also included that allows this function to be used without
     712                 :            :  * pointer casts. The function itself is static inline, so its address may vary
     713                 :            :  * between compilation units.
     714                 :            :  *
     715                 :            :  * One convenient usage of this function is in implementing property setters:
     716                 :            :  * |[
     717                 :            :  *   void
     718                 :            :  *   foo_set_bar (Foo *foo,
     719                 :            :  *                Bar *new_bar)
     720                 :            :  *   {
     721                 :            :  *     g_return_if_fail (IS_FOO (foo));
     722                 :            :  *     g_return_if_fail (new_bar == NULL || IS_BAR (new_bar));
     723                 :            :  *
     724                 :            :  *     if (g_set_object (&foo->bar, new_bar))
     725                 :            :  *       g_object_notify (foo, "bar");
     726                 :            :  *   }
     727                 :            :  * ]|
     728                 :            :  *
     729                 :            :  * Returns: %TRUE if the value of @object_ptr changed, %FALSE otherwise
     730                 :            :  *
     731                 :            :  * Since: 2.44
     732                 :            :  */
     733                 :            : static inline gboolean
     734                 :       8606 : (g_set_object) (GObject **object_ptr,
     735                 :            :                 GObject  *new_object)
     736                 :            : {
     737                 :       8606 :   GObject *old_object = *object_ptr;
     738                 :            : 
     739                 :            :   /* rely on g_object_[un]ref() to check the pointers are actually GObjects;
     740                 :            :    * elide a (object_ptr != NULL) check because most of the time we will be
     741                 :            :    * operating on struct members with a constant offset, so a NULL check would
     742                 :            :    * not catch bugs
     743                 :            :    */
     744                 :            : 
     745         [ +  + ]:       8606 :   if (old_object == new_object)
     746                 :       8569 :     return FALSE;
     747                 :            : 
     748         [ +  + ]:         37 :   if (new_object != NULL)
     749                 :         34 :     g_object_ref (new_object);
     750                 :            : 
     751                 :         37 :   *object_ptr = new_object;
     752                 :            : 
     753         [ +  + ]:         37 :   if (old_object != NULL)
     754                 :          4 :     g_object_unref (old_object);
     755                 :            : 
     756                 :         37 :   return TRUE;
     757                 :            : }
     758                 :            : 
     759                 :            : /* We need GCC for __extension__, which we need to sort out strict aliasing of @object_ptr */
     760                 :            : #if defined(__GNUC__)
     761                 :            : 
     762                 :            : #define g_set_object(object_ptr, new_object) \
     763                 :            :   (G_GNUC_EXTENSION ({ \
     764                 :            :     G_STATIC_ASSERT (sizeof *(object_ptr) == sizeof (new_object)); \
     765                 :            :     /* Only one access, please; work around type aliasing */ \
     766                 :            :     union { char *in; GObject **out; } _object_ptr; \
     767                 :            :     _object_ptr.in = (char *) (object_ptr); \
     768                 :            :     /* Check types match */ \
     769                 :            :     (void) (0 ? *(object_ptr) = (new_object), FALSE : FALSE); \
     770                 :            :     (g_set_object) (_object_ptr.out, (GObject *) new_object); \
     771                 :            :   })) \
     772                 :            :   GOBJECT_AVAILABLE_MACRO_IN_2_44
     773                 :            : 
     774                 :            : #else  /* if !defined(__GNUC__) */
     775                 :            : 
     776                 :            : #define g_set_object(object_ptr, new_object) \
     777                 :            :  (/* Check types match. */ \
     778                 :            :   0 ? *(object_ptr) = (new_object), FALSE : \
     779                 :            :   (g_set_object) ((GObject **) (object_ptr), (GObject *) (new_object)) \
     780                 :            :  )
     781                 :            : 
     782                 :            : #endif  /* !defined(__GNUC__) */
     783                 :            : 
     784                 :            : /**
     785                 :            :  * g_assert_finalize_object: (skip)
     786                 :            :  * @object: (transfer full) (type GObject.Object): an object
     787                 :            :  *
     788                 :            :  * Assert that @object is non-%NULL, then release one reference to it with
     789                 :            :  * g_object_unref() and assert that it has been finalized (i.e. that there
     790                 :            :  * are no more references).
     791                 :            :  *
     792                 :            :  * If assertions are disabled via `G_DISABLE_ASSERT`,
     793                 :            :  * this macro just calls g_object_unref() without any further checks.
     794                 :            :  *
     795                 :            :  * This macro should only be used in regression tests.
     796                 :            :  *
     797                 :            :  * Since: 2.62
     798                 :            :  */
     799                 :            : static inline void
     800                 :         85 : (g_assert_finalize_object) (GObject *object)
     801                 :            : {
     802                 :         85 :   gpointer weak_pointer = object;
     803                 :            : 
     804                 :         85 :   g_assert_true (G_IS_OBJECT (weak_pointer));
     805                 :         85 :   g_object_add_weak_pointer (object, &weak_pointer);
     806                 :         85 :   g_object_unref (weak_pointer);
     807                 :         85 :   g_assert_null (weak_pointer);
     808                 :         85 : }
     809                 :            : 
     810                 :            : #ifdef G_DISABLE_ASSERT
     811                 :            : #define g_assert_finalize_object(object) g_object_unref (object)
     812                 :            : #else
     813                 :            : #define g_assert_finalize_object(object) (g_assert_finalize_object ((GObject *) object))
     814                 :            : #endif
     815                 :            : 
     816                 :            : /**
     817                 :            :  * g_clear_weak_pointer: (skip)
     818                 :            :  * @weak_pointer_location: The memory address of a pointer
     819                 :            :  *
     820                 :            :  * Clears a weak reference to a #GObject.
     821                 :            :  *
     822                 :            :  * @weak_pointer_location must not be %NULL.
     823                 :            :  *
     824                 :            :  * If the weak reference is %NULL then this function does nothing.
     825                 :            :  * Otherwise, the weak reference to the object is removed for that location
     826                 :            :  * and the pointer is set to %NULL.
     827                 :            :  *
     828                 :            :  * A macro is also included that allows this function to be used without
     829                 :            :  * pointer casts. The function itself is static inline, so its address may vary
     830                 :            :  * between compilation units.
     831                 :            :  *
     832                 :            :  * Since: 2.56
     833                 :            :  */
     834                 :            : static inline void
     835                 :          4 : (g_clear_weak_pointer) (gpointer *weak_pointer_location)
     836                 :            : {
     837                 :          4 :   GObject *object = (GObject *) *weak_pointer_location;
     838                 :            : 
     839         [ +  + ]:          4 :   if (object != NULL)
     840                 :            :     {
     841                 :          2 :       g_object_remove_weak_pointer (object, weak_pointer_location);
     842                 :          2 :       *weak_pointer_location = NULL;
     843                 :            :     }
     844                 :          4 : }
     845                 :            : 
     846                 :            : #define g_clear_weak_pointer(weak_pointer_location) \
     847                 :            :  (/* Check types match. */ \
     848                 :            :   (g_clear_weak_pointer) ((gpointer *) (weak_pointer_location)) \
     849                 :            :  )
     850                 :            : 
     851                 :            : /**
     852                 :            :  * g_set_weak_pointer: (skip)
     853                 :            :  * @weak_pointer_location: the memory address of a pointer
     854                 :            :  * @new_object: (nullable) (transfer none): a pointer to the new #GObject to
     855                 :            :  *   assign to it, or %NULL to clear the pointer
     856                 :            :  *
     857                 :            :  * Updates a pointer to weakly refer to @new_object.
     858                 :            :  *
     859                 :            :  * It assigns @new_object to @weak_pointer_location and ensures
     860                 :            :  * that @weak_pointer_location will automatically be set to %NULL
     861                 :            :  * if @new_object gets destroyed. The assignment is not atomic.
     862                 :            :  * The weak reference is not thread-safe, see g_object_add_weak_pointer()
     863                 :            :  * for details.
     864                 :            :  *
     865                 :            :  * The @weak_pointer_location argument must not be %NULL.
     866                 :            :  *
     867                 :            :  * A macro is also included that allows this function to be used without
     868                 :            :  * pointer casts. The function itself is static inline, so its address may vary
     869                 :            :  * between compilation units.
     870                 :            :  *
     871                 :            :  * One convenient usage of this function is in implementing property setters:
     872                 :            :  * |[
     873                 :            :  *   void
     874                 :            :  *   foo_set_bar (Foo *foo,
     875                 :            :  *                Bar *new_bar)
     876                 :            :  *   {
     877                 :            :  *     g_return_if_fail (IS_FOO (foo));
     878                 :            :  *     g_return_if_fail (new_bar == NULL || IS_BAR (new_bar));
     879                 :            :  *
     880                 :            :  *     if (g_set_weak_pointer (&foo->bar, new_bar))
     881                 :            :  *       g_object_notify (foo, "bar");
     882                 :            :  *   }
     883                 :            :  * ]|
     884                 :            :  *
     885                 :            :  * Returns: %TRUE if the value of @weak_pointer_location changed, %FALSE otherwise
     886                 :            :  *
     887                 :            :  * Since: 2.56
     888                 :            :  */
     889                 :            : static inline gboolean
     890                 :          8 : (g_set_weak_pointer) (gpointer *weak_pointer_location,
     891                 :            :                       GObject  *new_object)
     892                 :            : {
     893                 :          8 :   GObject *old_object = (GObject *) *weak_pointer_location;
     894                 :            : 
     895                 :            :   /* elide a (weak_pointer_location != NULL) check because most of the time we
     896                 :            :    * will be operating on struct members with a constant offset, so a NULL
     897                 :            :    * check would not catch bugs
     898                 :            :    */
     899                 :            : 
     900         [ +  + ]:          8 :   if (old_object == new_object)
     901                 :          2 :     return FALSE;
     902                 :            : 
     903         [ +  + ]:          6 :   if (old_object != NULL)
     904                 :          2 :     g_object_remove_weak_pointer (old_object, weak_pointer_location);
     905                 :            : 
     906                 :          6 :   *weak_pointer_location = new_object;
     907                 :            : 
     908         [ +  + ]:          6 :   if (new_object != NULL)
     909                 :          4 :     g_object_add_weak_pointer (new_object, weak_pointer_location);
     910                 :            : 
     911                 :          6 :   return TRUE;
     912                 :            : }
     913                 :            : 
     914                 :            : #define g_set_weak_pointer(weak_pointer_location, new_object) \
     915                 :            :  (/* Check types match. */ \
     916                 :            :   0 ? *(weak_pointer_location) = (new_object), FALSE : \
     917                 :            :   (g_set_weak_pointer) ((gpointer *) (weak_pointer_location), (GObject *) (new_object)) \
     918                 :            :  )
     919                 :            : 
     920                 :            : typedef struct {
     921                 :            :     /*<private>*/
     922                 :            :     union { gpointer p; } priv;
     923                 :            : } GWeakRef;
     924                 :            : 
     925                 :            : GOBJECT_AVAILABLE_IN_ALL
     926                 :            : void     g_weak_ref_init       (GWeakRef *weak_ref,
     927                 :            :                                 gpointer  object);
     928                 :            : GOBJECT_AVAILABLE_IN_ALL
     929                 :            : void     g_weak_ref_clear      (GWeakRef *weak_ref);
     930                 :            : GOBJECT_AVAILABLE_IN_ALL
     931                 :            : gpointer g_weak_ref_get        (GWeakRef *weak_ref);
     932                 :            : GOBJECT_AVAILABLE_IN_ALL
     933                 :            : void     g_weak_ref_set        (GWeakRef *weak_ref,
     934                 :            :                                 gpointer  object);
     935                 :            : 
     936                 :            : G_END_DECLS
     937                 :            : 
     938                 :            : #endif /* __G_OBJECT_H__ */

Generated by: LCOV version 1.14