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