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

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