gobject/gobject.h

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