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