Pileus Git - ~andy/gtk/blob - gtk/gtkobject.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   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 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 Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <config.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include "gtkalias.h"
  32 #include "gtkobject.h"
  33 #include "gtkmarshalers.h"
  34 #include "gtksignal.h"
  35
  36
  37 enum {
  38   DESTROY,
  39   LAST_SIGNAL
  40 };
  41 enum {
  42   PROP_0,
  43   PROP_USER_DATA
  44 };
  45
  46
  47 extern void       gtk_object_init_type           (void);        /* for gtktypeutils.h */
  48 static void       gtk_object_base_class_init     (GtkObjectClass *class);
  49 static void       gtk_object_base_class_finalize (GtkObjectClass *class);
  50 static void       gtk_object_class_init          (GtkObjectClass *klass);
  51 static void       gtk_object_init                (GtkObject      *object,
  52                                                   GtkObjectClass *klass);
  53 static void       gtk_object_set_property        (GObject        *object,
  54                                                   guint           property_id,
  55                                                   const GValue   *value,
  56                                                   GParamSpec     *pspec);
  57 static void       gtk_object_get_property        (GObject        *object,
  58                                                   guint           property_id,
  59                                                   GValue         *value,
  60                                                   GParamSpec     *pspec);
  61 static void       gtk_object_dispose            (GObject        *object);
  62 static void       gtk_object_real_destroy        (GtkObject      *object);
  63 static void       gtk_object_finalize            (GObject        *object);
  64 static void       gtk_object_notify_weaks        (GtkObject      *object);
  65
  66 static gpointer    parent_class = NULL;
  67 static guint       object_signals[LAST_SIGNAL] = { 0 };
  68 static GQuark      quark_weakrefs = 0;
  69
  70
  71 /****************************************************
  72  * GtkObject type, class and instance initialization
  73  *
  74  ****************************************************/
  75
  76 GType
  77 gtk_object_get_type (void)
  78 {
  79   static GType object_type = 0;
  80
  81   if (!object_type)
  82     {
  83       static const GTypeInfo object_info =
  84       {
  85         sizeof (GtkObjectClass),
  86         (GBaseInitFunc) gtk_object_base_class_init,
  87         (GBaseFinalizeFunc) gtk_object_base_class_finalize,
  88         (GClassInitFunc) gtk_object_class_init,
  89         NULL,           /* class_finalize */
  90         NULL,           /* class_data */
  91         sizeof (GtkObject),
  92         16,             /* n_preallocs */
  93         (GInstanceInitFunc) gtk_object_init,
  94         NULL,           /* value_table */
  95       };
  96
  97       object_type = g_type_register_static (G_TYPE_OBJECT, "GtkObject",
  98                                             &object_info, G_TYPE_FLAG_ABSTRACT);
  99     }
 100
 101   return object_type;
 102 }
 103
 104 static void
 105 gtk_object_base_class_init (GtkObjectClass *class)
 106 {
 107   /* reset instance specifc methods that don't get inherited */
 108   class->get_arg = NULL;
 109   class->set_arg = NULL;
 110 }
 111
 112 static void
 113 gtk_object_base_class_finalize (GtkObjectClass *class)
 114 {
 115 }
 116
 117 static inline gboolean
 118 gtk_arg_set_from_value (GtkArg       *arg,
 119                         const GValue *value,
 120                         gboolean      copy_string)
 121 {
 122   switch (G_TYPE_FUNDAMENTAL (arg->type))
 123     {
 124     case G_TYPE_CHAR:           GTK_VALUE_CHAR (*arg) = g_value_get_char (value);       break;
 125     case G_TYPE_UCHAR:          GTK_VALUE_UCHAR (*arg) = g_value_get_uchar (value);     break;
 126     case G_TYPE_BOOLEAN:        GTK_VALUE_BOOL (*arg) = g_value_get_boolean (value);    break;
 127     case G_TYPE_INT:            GTK_VALUE_INT (*arg) = g_value_get_int (value);         break;
 128     case G_TYPE_UINT:           GTK_VALUE_UINT (*arg) = g_value_get_uint (value);       break;
 129     case G_TYPE_LONG:           GTK_VALUE_LONG (*arg) = g_value_get_long (value);       break;
 130     case G_TYPE_ULONG:          GTK_VALUE_ULONG (*arg) = g_value_get_ulong (value);     break;
 131     case G_TYPE_ENUM:           GTK_VALUE_ENUM (*arg) = g_value_get_enum (value);       break;
 132     case G_TYPE_FLAGS:          GTK_VALUE_FLAGS (*arg) = g_value_get_flags (value);     break;
 133     case G_TYPE_FLOAT:          GTK_VALUE_FLOAT (*arg) = g_value_get_float (value);     break;
 134     case G_TYPE_DOUBLE:         GTK_VALUE_DOUBLE (*arg) = g_value_get_double (value);   break;
 135     case G_TYPE_BOXED:          GTK_VALUE_BOXED (*arg) = g_value_get_boxed (value);     break;
 136     case G_TYPE_POINTER:        GTK_VALUE_POINTER (*arg) = g_value_get_pointer (value); break;
 137     case G_TYPE_OBJECT:         GTK_VALUE_POINTER (*arg) = g_value_get_object (value);  break;
 138     case G_TYPE_STRING:         if (copy_string)
 139       GTK_VALUE_STRING (*arg) = g_value_dup_string (value);
 140     else
 141       GTK_VALUE_STRING (*arg) = (char *) g_value_get_string (value);
 142     break;
 143     default:
 144       return FALSE;
 145     }
 146   return TRUE;
 147 }
 148
 149 static inline gboolean
 150 gtk_arg_to_value (GtkArg *arg,
 151                   GValue *value)
 152 {
 153   switch (G_TYPE_FUNDAMENTAL (arg->type))
 154     {
 155     case G_TYPE_CHAR:           g_value_set_char (value, GTK_VALUE_CHAR (*arg));        break;
 156     case G_TYPE_UCHAR:          g_value_set_uchar (value, GTK_VALUE_UCHAR (*arg));      break;
 157     case G_TYPE_BOOLEAN:        g_value_set_boolean (value, GTK_VALUE_BOOL (*arg));     break;
 158     case G_TYPE_INT:            g_value_set_int (value, GTK_VALUE_INT (*arg));          break;
 159     case G_TYPE_UINT:           g_value_set_uint (value, GTK_VALUE_UINT (*arg));        break;
 160     case G_TYPE_LONG:           g_value_set_long (value, GTK_VALUE_LONG (*arg));        break;
 161     case G_TYPE_ULONG:          g_value_set_ulong (value, GTK_VALUE_ULONG (*arg));      break;
 162     case G_TYPE_ENUM:           g_value_set_enum (value, GTK_VALUE_ENUM (*arg));        break;
 163     case G_TYPE_FLAGS:          g_value_set_flags (value, GTK_VALUE_FLAGS (*arg));      break;
 164     case G_TYPE_FLOAT:          g_value_set_float (value, GTK_VALUE_FLOAT (*arg));      break;
 165     case G_TYPE_DOUBLE:         g_value_set_double (value, GTK_VALUE_DOUBLE (*arg));    break;
 166     case G_TYPE_STRING:         g_value_set_string (value, GTK_VALUE_STRING (*arg));    break;
 167     case G_TYPE_BOXED:          g_value_set_boxed (value, GTK_VALUE_BOXED (*arg));      break;
 168     case G_TYPE_POINTER:        g_value_set_pointer (value, GTK_VALUE_POINTER (*arg));  break;
 169     case G_TYPE_OBJECT:         g_value_set_object (value, GTK_VALUE_POINTER (*arg));   break;
 170     default:
 171       return FALSE;
 172     }
 173   return TRUE;
 174 }
 175
 176 static void
 177 gtk_arg_proxy_set_property (GObject      *object,
 178                             guint         property_id,
 179                             const GValue *value,
 180                             GParamSpec   *pspec)
 181 {
 182   GtkObjectClass *class = g_type_class_peek (pspec->owner_type);
 183   GtkArg arg;
 184
 185   g_return_if_fail (class->set_arg != NULL);
 186
 187   memset (&arg, 0, sizeof (arg));
 188   arg.type = G_VALUE_TYPE (value);
 189   gtk_arg_set_from_value (&arg, value, FALSE);
 190   arg.name = pspec->name;
 191   class->set_arg (GTK_OBJECT (object), &arg, property_id);
 192 }
 193
 194 static void
 195 gtk_arg_proxy_get_property (GObject     *object,
 196                             guint        property_id,
 197                             GValue      *value,
 198                             GParamSpec  *pspec)
 199 {
 200   GtkObjectClass *class = g_type_class_peek (pspec->owner_type);
 201   GtkArg arg;
 202
 203   g_return_if_fail (class->get_arg != NULL);
 204
 205   memset (&arg, 0, sizeof (arg));
 206   arg.type = G_VALUE_TYPE (value);
 207   arg.name = pspec->name;
 208   class->get_arg (GTK_OBJECT (object), &arg, property_id);
 209   gtk_arg_to_value (&arg, value);
 210 }
 211
 212 void
 213 gtk_object_add_arg_type (const gchar *arg_name,
 214                          GtkType      arg_type,
 215                          guint        arg_flags,
 216                          guint        arg_id)
 217 {
 218   GObjectClass *oclass;
 219   GParamSpec *pspec;
 220   gchar *type_name, *pname;
 221   GType type;
 222
 223   g_return_if_fail (arg_name != NULL);
 224   g_return_if_fail (arg_type > G_TYPE_NONE);
 225   g_return_if_fail (arg_id > 0);
 226   g_return_if_fail (arg_flags & G_PARAM_READWRITE);
 227   if (arg_flags & G_PARAM_CONSTRUCT)
 228     g_return_if_fail ((arg_flags & G_PARAM_CONSTRUCT_ONLY) == 0);
 229   if (arg_flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY))
 230     g_return_if_fail (arg_flags & G_PARAM_WRITABLE);
 231   g_return_if_fail ((arg_flags & ~(G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) == 0);
 232
 233   pname = strchr (arg_name, ':');
 234   g_return_if_fail (pname && pname[1] == ':');
 235
 236   type_name = g_strndup (arg_name, pname - arg_name);
 237   pname += 2;
 238   type = g_type_from_name (type_name);
 239   g_free (type_name);
 240   g_return_if_fail (G_TYPE_IS_OBJECT (type));
 241
 242   oclass = gtk_type_class (type);
 243   if (arg_flags & G_PARAM_READABLE)
 244     {
 245       if (oclass->get_property && oclass->get_property != gtk_arg_proxy_get_property)
 246         {
 247           g_warning (G_STRLOC ": GtkArg compatibility code can't be mixed with customized %s.get_property() implementation",
 248                      g_type_name (type));
 249           return;
 250         }
 251       oclass->get_property = gtk_arg_proxy_get_property;
 252     }
 253   if (arg_flags & G_PARAM_WRITABLE)
 254     {
 255       if (oclass->set_property && oclass->set_property != gtk_arg_proxy_set_property)
 256         {
 257           g_warning (G_STRLOC ": GtkArg compatibility code can't be mixed with customized %s.set_property() implementation",
 258                      g_type_name (type));
 259           return;
 260         }
 261       oclass->set_property = gtk_arg_proxy_set_property;
 262     }
 263   switch (G_TYPE_FUNDAMENTAL (arg_type))
 264     {
 265     case G_TYPE_ENUM:
 266       pspec = g_param_spec_enum (pname, NULL, NULL, arg_type, 0, arg_flags);
 267       break;
 268     case G_TYPE_FLAGS:
 269       pspec = g_param_spec_flags (pname, NULL, NULL, arg_type, 0, arg_flags);
 270       break;
 271     case G_TYPE_CHAR:
 272       pspec = g_param_spec_char (pname, NULL, NULL, -128, 127, 0, arg_flags);
 273       break;
 274     case G_TYPE_UCHAR:
 275       pspec = g_param_spec_uchar (pname, NULL, NULL, 0, 255, 0, arg_flags);
 276       break;
 277     case G_TYPE_BOOLEAN:
 278       pspec = g_param_spec_boolean (pname, NULL, NULL, FALSE, arg_flags);
 279       break;
 280     case G_TYPE_INT:
 281       pspec = g_param_spec_int (pname, NULL, NULL, -2147483647, 2147483647, 0, arg_flags);
 282       break;
 283     case G_TYPE_UINT:
 284       pspec = g_param_spec_uint (pname, NULL, NULL, 0, 4294967295U, 0, arg_flags);
 285       break;
 286     case G_TYPE_FLOAT:
 287       pspec = g_param_spec_float (pname, NULL, NULL, -1E+37, 1E+37, 0, arg_flags);
 288       break;
 289     case G_TYPE_DOUBLE:
 290       pspec = g_param_spec_double (pname, NULL, NULL, -1E+307, 1E+307, 0, arg_flags);
 291       break;
 292     case G_TYPE_STRING:
 293       pspec = g_param_spec_string (pname, NULL, NULL, NULL, arg_flags);
 294       break;
 295     case G_TYPE_POINTER:
 296       pspec = g_param_spec_pointer (pname, NULL, NULL, arg_flags);
 297       break;
 298     case G_TYPE_OBJECT:
 299       pspec = g_param_spec_object (pname, NULL, NULL, arg_type, arg_flags);
 300       break;
 301     case G_TYPE_BOXED:
 302       if (!G_TYPE_IS_FUNDAMENTAL (arg_type))
 303         {
 304           pspec = g_param_spec_boxed (pname, NULL, NULL, arg_type, arg_flags);
 305           break;
 306         }
 307     default:
 308       g_warning (G_STRLOC ": Property type `%s' is not supported by the GtkArg compatibility code",
 309                  g_type_name (arg_type));
 310       return;
 311     }
 312   g_object_class_install_property (oclass, arg_id, pspec);
 313 }
 314
 315 static void
 316 gtk_object_class_init (GtkObjectClass *class)
 317 {
 318   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 319
 320   parent_class = g_type_class_ref (G_TYPE_OBJECT);
 321
 322   gobject_class->set_property = gtk_object_set_property;
 323   gobject_class->get_property = gtk_object_get_property;
 324   gobject_class->dispose = gtk_object_dispose;
 325   gobject_class->finalize = gtk_object_finalize;
 326
 327   class->destroy = gtk_object_real_destroy;
 328
 329   g_object_class_install_property (gobject_class,
 330                                    PROP_USER_DATA,
 331                                    g_param_spec_pointer ("user_data", "User Data",
 332                                                          "Anonymous User Data Pointer",
 333                                                          G_PARAM_READABLE | G_PARAM_WRITABLE));
 334   object_signals[DESTROY] =
 335     g_signal_new ("destroy",
 336                   G_TYPE_FROM_CLASS (gobject_class),
 337                   G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
 338                   G_STRUCT_OFFSET (GtkObjectClass, destroy),
 339                   NULL, NULL,
 340                   _gtk_marshal_VOID__VOID,
 341                   G_TYPE_NONE, 0);
 342 }
 343
 344 static void
 345 gtk_object_init (GtkObject      *object,
 346                  GtkObjectClass *klass)
 347 {
 348   GTK_OBJECT_FLAGS (object) = GTK_FLOATING;
 349 }
 350
 351 /********************************************
 352  * Functions to end a GtkObject's life time
 353  *
 354  ********************************************/
 355 void
 356 gtk_object_destroy (GtkObject *object)
 357 {
 358   g_return_if_fail (object != NULL);
 359   g_return_if_fail (GTK_IS_OBJECT (object));
 360
 361   if (!(GTK_OBJECT_FLAGS (object) & GTK_IN_DESTRUCTION))
 362     g_object_run_dispose (G_OBJECT (object));
 363 }
 364
 365 static void
 366 gtk_object_dispose (GObject *gobject)
 367 {
 368   GtkObject *object = GTK_OBJECT (gobject);
 369
 370   /* guard against reinvocations during
 371    * destruction with the GTK_IN_DESTRUCTION flag.
 372    */
 373   if (!(GTK_OBJECT_FLAGS (object) & GTK_IN_DESTRUCTION))
 374     {
 375       GTK_OBJECT_SET_FLAGS (object, GTK_IN_DESTRUCTION);
 376
 377       g_signal_emit (object, object_signals[DESTROY], 0);
 378
 379       GTK_OBJECT_UNSET_FLAGS (object, GTK_IN_DESTRUCTION);
 380     }
 381
 382   G_OBJECT_CLASS (parent_class)->dispose (gobject);
 383 }
 384
 385 static void
 386 gtk_object_real_destroy (GtkObject *object)
 387 {
 388   g_signal_handlers_destroy (object);
 389 }
 390
 391 static void
 392 gtk_object_finalize (GObject *gobject)
 393 {
 394   GtkObject *object = GTK_OBJECT (gobject);
 395
 396   if (GTK_OBJECT_FLOATING (object))
 397     {
 398       g_warning ("A floating object was finalized. This means that someone\n"
 399                  "called g_object_unref() on an object that had only a floating\n"
 400                  "reference; the initial floating reference is not owned by anyone\n"
 401                  "and must be removed with gtk_object_sink() after a normal\n"
 402                  "reference is obtained with g_object_ref().");
 403     }
 404
 405   gtk_object_notify_weaks (object);
 406
 407   G_OBJECT_CLASS (parent_class)->finalize (gobject);
 408 }
 409
 410 /*****************************************
 411  * GtkObject argument handlers
 412  *
 413  *****************************************/
 414
 415 static void
 416 gtk_object_set_property (GObject      *object,
 417                          guint         property_id,
 418                          const GValue *value,
 419                          GParamSpec   *pspec)
 420 {
 421   switch (property_id)
 422     {
 423     case PROP_USER_DATA:
 424       g_object_set_data (G_OBJECT (object), "user_data", g_value_get_pointer (value));
 425       break;
 426     default:
 427       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 428       break;
 429     }
 430 }
 431
 432 static void
 433 gtk_object_get_property (GObject     *object,
 434                          guint        property_id,
 435                          GValue      *value,
 436                          GParamSpec  *pspec)
 437 {
 438   switch (property_id)
 439     {
 440     case PROP_USER_DATA:
 441       g_value_set_pointer (value, g_object_get_data (G_OBJECT (object), "user_data"));
 442       break;
 443     default:
 444       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 445       break;
 446     }
 447 }
 448
 449 /*****************************************
 450  * gtk_object_sink:
 451  *
 452  *   arguments:
 453  *
 454  *   results:
 455  *****************************************/
 456
 457 void
 458 gtk_object_sink (GtkObject *object)
 459 {
 460   g_return_if_fail (GTK_IS_OBJECT (object));
 461
 462   if (GTK_OBJECT_FLOATING (object))
 463     {
 464       GTK_OBJECT_UNSET_FLAGS (object, GTK_FLOATING);
 465       g_object_unref (object);
 466     }
 467 }
 468
 469 /*****************************************
 470  * Weak references.
 471  *
 472  * Weak refs are very similar to the old "destroy" signal.  They allow
 473  * one to register a callback that is called when the weakly
 474  * referenced object is finalized.
 475  *
 476  * They are not implemented as a signal because they really are
 477  * special and need to be used with great care.  Unlike signals, which
 478  * should be able to execute any code whatsoever.
 479  *
 480  * A weakref callback is not allowed to retain a reference to the
 481  * object.  Object data keys may be retrieved in a weak reference
 482  * callback.
 483  *
 484  * A weakref callback is called at most once.
 485  *
 486  *****************************************/
 487
 488 typedef struct _GtkWeakRef      GtkWeakRef;
 489
 490 struct _GtkWeakRef
 491 {
 492   GtkWeakRef       *next;
 493   GtkDestroyNotify  notify;
 494   gpointer          data;
 495 };
 496
 497 void
 498 gtk_object_weakref (GtkObject        *object,
 499                     GtkDestroyNotify  notify,
 500                     gpointer          data)
 501 {
 502   GtkWeakRef *weak;
 503
 504   g_return_if_fail (notify != NULL);
 505   g_return_if_fail (GTK_IS_OBJECT (object));
 506
 507   if (!quark_weakrefs)
 508     quark_weakrefs = g_quark_from_static_string ("gtk-weakrefs");
 509
 510   weak = g_new (GtkWeakRef, 1);
 511   weak->next = g_object_get_qdata (G_OBJECT (object), quark_weakrefs);
 512   weak->notify = notify;
 513   weak->data = data;
 514   g_object_set_qdata (G_OBJECT (object), quark_weakrefs, weak);
 515 }
 516
 517 void
 518 gtk_object_weakunref (GtkObject        *object,
 519                       GtkDestroyNotify  notify,
 520                       gpointer          data)
 521 {
 522   GtkWeakRef *weaks, *w, **wp;
 523
 524   g_return_if_fail (GTK_IS_OBJECT (object));
 525
 526   if (!quark_weakrefs)
 527     return;
 528
 529   weaks = g_object_get_qdata (G_OBJECT (object), quark_weakrefs);
 530   for (wp = &weaks; *wp; wp = &(*wp)->next)
 531     {
 532       w = *wp;
 533       if (w->notify == notify && w->data == data)
 534         {
 535           if (w == weaks)
 536             g_object_set_qdata (G_OBJECT (object), quark_weakrefs, w->next);
 537           else
 538             *wp = w->next;
 539           g_free (w);
 540           return;
 541         }
 542     }
 543 }
 544
 545 static void
 546 gtk_object_notify_weaks (GtkObject *object)
 547 {
 548   if (quark_weakrefs)
 549     {
 550       GtkWeakRef *w1, *w2;
 551
 552       w1 = g_object_get_qdata (G_OBJECT (object), quark_weakrefs);
 553
 554       while (w1)
 555         {
 556           w1->notify (w1->data);
 557           w2 = w1->next;
 558           g_free (w1);
 559           w1 = w2;
 560         }
 561     }
 562 }
 563
 564 GtkObject*
 565 gtk_object_new (GtkType      object_type,
 566                 const gchar *first_property_name,
 567                 ...)
 568 {
 569   GtkObject *object;
 570   va_list var_args;
 571
 572   g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);
 573
 574   va_start (var_args, first_property_name);
 575   object = (GtkObject *)g_object_new_valist (object_type, first_property_name, var_args);
 576   va_end (var_args);
 577
 578   return object;
 579 }
 580
 581 void
 582 gtk_object_get (GtkObject   *object,
 583                 const gchar *first_property_name,
 584                 ...)
 585 {
 586   va_list var_args;
 587
 588   g_return_if_fail (GTK_IS_OBJECT (object));
 589
 590   va_start (var_args, first_property_name);
 591   g_object_get_valist (G_OBJECT (object), first_property_name, var_args);
 592   va_end (var_args);
 593 }
 594
 595 void
 596 gtk_object_set (GtkObject   *object,
 597                 const gchar *first_property_name,
 598                 ...)
 599 {
 600   va_list var_args;
 601
 602   g_return_if_fail (GTK_IS_OBJECT (object));
 603
 604   va_start (var_args, first_property_name);
 605   g_object_set_valist (G_OBJECT (object), first_property_name, var_args);
 606   va_end (var_args);
 607 }
 608
 609 /*****************************************
 610  * GtkObject object_data mechanism
 611  *
 612  *****************************************/
 613
 614 void
 615 gtk_object_set_data_by_id (GtkObject        *object,
 616                            GQuark            data_id,
 617                            gpointer          data)
 618 {
 619   g_return_if_fail (GTK_IS_OBJECT (object));
 620
 621   g_datalist_id_set_data (&G_OBJECT (object)->qdata, data_id, data);
 622 }
 623
 624 void
 625 gtk_object_set_data (GtkObject        *object,
 626                      const gchar      *key,
 627                      gpointer          data)
 628 {
 629   g_return_if_fail (GTK_IS_OBJECT (object));
 630   g_return_if_fail (key != NULL);
 631
 632   g_datalist_set_data (&G_OBJECT (object)->qdata, key, data);
 633 }
 634
 635 void
 636 gtk_object_set_data_by_id_full (GtkObject        *object,
 637                                 GQuark            data_id,
 638                                 gpointer          data,
 639                                 GtkDestroyNotify  destroy)
 640 {
 641   g_return_if_fail (GTK_IS_OBJECT (object));
 642
 643   g_datalist_id_set_data_full (&G_OBJECT (object)->qdata, data_id, data, destroy);
 644 }
 645
 646 void
 647 gtk_object_set_data_full (GtkObject        *object,
 648                           const gchar      *key,
 649                           gpointer          data,
 650                           GtkDestroyNotify  destroy)
 651 {
 652   g_return_if_fail (GTK_IS_OBJECT (object));
 653   g_return_if_fail (key != NULL);
 654
 655   g_datalist_set_data_full (&G_OBJECT (object)->qdata, key, data, destroy);
 656 }
 657
 658 gpointer
 659 gtk_object_get_data_by_id (GtkObject   *object,
 660                            GQuark       data_id)
 661 {
 662   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 663
 664   return g_datalist_id_get_data (&G_OBJECT (object)->qdata, data_id);
 665 }
 666
 667 gpointer
 668 gtk_object_get_data (GtkObject   *object,
 669                      const gchar *key)
 670 {
 671   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 672   g_return_val_if_fail (key != NULL, NULL);
 673
 674   return g_datalist_get_data (&G_OBJECT (object)->qdata, key);
 675 }
 676
 677 void
 678 gtk_object_remove_data_by_id (GtkObject   *object,
 679                               GQuark       data_id)
 680 {
 681   g_return_if_fail (GTK_IS_OBJECT (object));
 682
 683   g_datalist_id_remove_data (&G_OBJECT (object)->qdata, data_id);
 684 }
 685
 686 void
 687 gtk_object_remove_data (GtkObject   *object,
 688                         const gchar *key)
 689 {
 690   g_return_if_fail (GTK_IS_OBJECT (object));
 691   g_return_if_fail (key != NULL);
 692
 693   g_datalist_remove_data (&G_OBJECT (object)->qdata, key);
 694 }
 695
 696 void
 697 gtk_object_remove_no_notify_by_id (GtkObject      *object,
 698                                    GQuark          key_id)
 699 {
 700   g_return_if_fail (GTK_IS_OBJECT (object));
 701
 702   g_datalist_id_remove_no_notify (&G_OBJECT (object)->qdata, key_id);
 703 }
 704
 705 void
 706 gtk_object_remove_no_notify (GtkObject       *object,
 707                              const gchar     *key)
 708 {
 709   g_return_if_fail (GTK_IS_OBJECT (object));
 710   g_return_if_fail (key != NULL);
 711
 712   g_datalist_remove_no_notify (&G_OBJECT (object)->qdata, key);
 713 }
 714
 715 void
 716 gtk_object_set_user_data (GtkObject *object,
 717                           gpointer   data)
 718 {
 719   g_return_if_fail (GTK_IS_OBJECT (object));
 720
 721   g_object_set_data (G_OBJECT (object), "user_data", data);
 722 }
 723
 724 gpointer
 725 gtk_object_get_user_data (GtkObject *object)
 726 {
 727   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 728
 729   return g_object_get_data (G_OBJECT (object), "user_data");
 730 }
 731
 732 GtkObject*
 733 gtk_object_ref (GtkObject *object)
 734 {
 735   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 736
 737   return (GtkObject*) g_object_ref ((GObject*) object);
 738 }
 739
 740 void
 741 gtk_object_unref (GtkObject *object)
 742 {
 743   g_return_if_fail (GTK_IS_OBJECT (object));
 744
 745   g_object_unref ((GObject*) object);
 746 }