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 Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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 #include <stdarg.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22 #include "gtkobject.h"
  23 #include "gtksignal.h"
  24
  25
  26 enum {
  27   DESTROY,
  28   LAST_SIGNAL
  29 };
  30 enum {
  31   ARG_0,
  32   ARG_USER_DATA,
  33   ARG_SIGNAL,
  34   ARG_SIGNAL_AFTER,
  35   ARG_OBJECT_SIGNAL,
  36   ARG_OBJECT_SIGNAL_AFTER
  37 };
  38
  39
  40 void                  gtk_object_init_type       (void);
  41 static void           gtk_object_base_class_init (GtkObjectClass *klass);
  42 static void           gtk_object_class_init      (GtkObjectClass *klass);
  43 static void           gtk_object_init            (GtkObject      *object);
  44 static void           gtk_object_set_arg         (GtkObject      *object,
  45                                                   GtkArg         *arg,
  46                                                   guint           arg_id);
  47 static void           gtk_object_get_arg         (GtkObject      *object,
  48                                                   GtkArg         *arg,
  49                                                   guint           arg_id);
  50 static void           gtk_object_shutdown        (GtkObject      *object);
  51 static void           gtk_object_real_destroy    (GtkObject      *object);
  52 static void           gtk_object_finalize        (GtkObject      *object);
  53 static void           gtk_object_notify_weaks    (GtkObject      *object);
  54
  55 static guint object_signals[LAST_SIGNAL] = { 0 };
  56
  57 static GHashTable *object_arg_info_ht = NULL;
  58
  59 static const gchar *user_data_key = "user_data";
  60 static guint user_data_key_id = 0;
  61 static const gchar *weakrefs_key = "gtk-weakrefs";
  62 static guint weakrefs_key_id = 0;
  63
  64
  65 #ifdef G_ENABLE_DEBUG
  66 static guint obj_count = 0;
  67 static GHashTable *living_objs_ht = NULL;
  68 static void
  69 gtk_object_debug_foreach (gpointer key, gpointer value, gpointer user_data)
  70 {
  71   GtkObject *object;
  72
  73   object = (GtkObject*) value;
  74   g_message ("[%p] %s\tref_count=%d%s%s",
  75              object,
  76              gtk_type_name (GTK_OBJECT_TYPE (object)),
  77              object->ref_count,
  78              GTK_OBJECT_FLOATING (object) ? " (floating)" : "",
  79              GTK_OBJECT_DESTROYED (object) ? " (destroyed)" : "");
  80 }
  81 static void
  82 gtk_object_debug (void)
  83 {
  84   if (living_objs_ht)
  85     g_hash_table_foreach (living_objs_ht, gtk_object_debug_foreach, NULL);
  86
  87   g_message ("living objects count = %d", obj_count);
  88 }
  89 #endif  /* G_ENABLE_DEBUG */
  90
  91 /****************************************************
  92  * GtkObject type, class and instance initialization
  93  *
  94  ****************************************************/
  95
  96 void
  97 gtk_object_init_type (void)
  98 {
  99   GtkType object_type = 0;
 100   GtkTypeInfo object_info =
 101   {
 102     "GtkObject",
 103     sizeof (GtkObject),
 104     sizeof (GtkObjectClass),
 105     (GtkClassInitFunc) gtk_object_class_init,
 106     (GtkObjectInitFunc) gtk_object_init,
 107     /* reserved_1 */ NULL,
 108     /* reserved_2 */ NULL,
 109     (GtkClassInitFunc) gtk_object_base_class_init,
 110   };
 111
 112   object_type = gtk_type_unique (0, &object_info);
 113   g_assert (object_type == GTK_TYPE_OBJECT);
 114
 115 #ifdef G_ENABLE_DEBUG
 116   if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
 117     g_atexit (gtk_object_debug);
 118 #endif  /* G_ENABLE_DEBUG */
 119 }
 120
 121 GtkType
 122 gtk_object_get_type (void)
 123 {
 124   return GTK_TYPE_OBJECT;
 125 }
 126
 127 static void
 128 gtk_object_base_class_init (GtkObjectClass *class)
 129 {
 130   /* reset instance specific fields that don't get inherited */
 131   class->signals = NULL;
 132   class->nsignals = 0;
 133   class->n_args = 0;
 134
 135   /* reset instance specifc methods that don't get inherited */
 136   class->get_arg = NULL;
 137   class->set_arg = NULL;
 138 }
 139
 140 static void
 141 gtk_object_class_init (GtkObjectClass *class)
 142 {
 143   gtk_object_add_arg_type ("GtkObject::user_data",
 144                            GTK_TYPE_POINTER,
 145                            GTK_ARG_READWRITE,
 146                            ARG_USER_DATA);
 147   gtk_object_add_arg_type ("GtkObject::signal",
 148                            GTK_TYPE_SIGNAL,
 149                            GTK_ARG_WRITABLE,
 150                            ARG_SIGNAL);
 151   gtk_object_add_arg_type ("GtkObject::signal_after",
 152                            GTK_TYPE_SIGNAL,
 153                            GTK_ARG_WRITABLE,
 154                            ARG_SIGNAL_AFTER);
 155   gtk_object_add_arg_type ("GtkObject::object_signal",
 156                            GTK_TYPE_SIGNAL,
 157                            GTK_ARG_WRITABLE,
 158                            ARG_OBJECT_SIGNAL);
 159   gtk_object_add_arg_type ("GtkObject::object_signal_after",
 160                            GTK_TYPE_SIGNAL,
 161                            GTK_ARG_WRITABLE,
 162                            ARG_OBJECT_SIGNAL_AFTER);
 163
 164   object_signals[DESTROY] =
 165     gtk_signal_new ("destroy",
 166                     GTK_RUN_LAST,
 167                     class->type,
 168                     GTK_SIGNAL_OFFSET (GtkObjectClass, destroy),
 169                     gtk_marshal_NONE__NONE,
 170                     GTK_TYPE_NONE, 0);
 171
 172   gtk_object_class_add_signals (class, object_signals, LAST_SIGNAL);
 173
 174   class->get_arg = gtk_object_get_arg;
 175   class->set_arg = gtk_object_set_arg;
 176   class->shutdown = gtk_object_shutdown;
 177   class->destroy = gtk_object_real_destroy;
 178   class->finalize = gtk_object_finalize;
 179 }
 180
 181 static void
 182 gtk_object_init (GtkObject *object)
 183 {
 184   GTK_OBJECT_FLAGS (object) = GTK_FLOATING;
 185
 186   object->ref_count = 1;
 187   g_datalist_init (&object->object_data);
 188
 189 #ifdef G_ENABLE_DEBUG
 190   if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
 191     {
 192       obj_count++;
 193
 194       if (!living_objs_ht)
 195         living_objs_ht = g_hash_table_new (g_direct_hash, NULL);
 196
 197       g_hash_table_insert (living_objs_ht, object, object);
 198     }
 199 #endif /* G_ENABLE_DEBUG */
 200 }
 201
 202 /********************************************
 203  * Functions to end a GtkObject's life time
 204  *
 205  ********************************************/
 206 void
 207 gtk_object_destroy (GtkObject *object)
 208 {
 209   g_return_if_fail (object != NULL);
 210   g_return_if_fail (GTK_IS_OBJECT (object));
 211
 212   if (!GTK_OBJECT_DESTROYED (object))
 213     {
 214       /* we will hold a reference on the object in this place, so
 215        * to ease all classes shutdown and destroy implementations.
 216        * i.e. they don't have to bother about referencing at all.
 217        */
 218       gtk_object_ref (object);
 219       object->klass->shutdown (object);
 220       gtk_object_unref (object);
 221     }
 222 }
 223
 224 static void
 225 gtk_object_shutdown (GtkObject *object)
 226 {
 227   GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
 228   gtk_signal_emit (object, object_signals[DESTROY]);
 229 }
 230
 231 static void
 232 gtk_object_real_destroy (GtkObject *object)
 233 {
 234   if (GTK_OBJECT_CONNECTED (object))
 235     gtk_signal_handlers_destroy (object);
 236 }
 237
 238 static void
 239 gtk_object_finalize (GtkObject *object)
 240 {
 241   gtk_object_notify_weaks (object);
 242
 243   g_datalist_clear (&object->object_data);
 244
 245   gtk_type_free (GTK_OBJECT_TYPE (object), object);
 246 }
 247
 248 /*****************************************
 249  * GtkObject argument handlers
 250  *
 251  *****************************************/
 252
 253 static void
 254 gtk_object_set_arg (GtkObject *object,
 255                     GtkArg    *arg,
 256                     guint      arg_id)
 257 {
 258   guint n = 0;
 259
 260   switch (arg_id)
 261     {
 262       gchar *arg_name;
 263
 264     case ARG_USER_DATA:
 265       gtk_object_set_user_data (object, GTK_VALUE_POINTER (*arg));
 266       break;
 267     case ARG_OBJECT_SIGNAL_AFTER:
 268       n += 6;
 269     case ARG_OBJECT_SIGNAL:
 270       n += 1;
 271     case ARG_SIGNAL_AFTER:
 272       n += 6;
 273     case ARG_SIGNAL:
 274       n += 6;
 275       arg_name = gtk_arg_name_strip_type (arg->name);
 276       if (arg_name &&
 277           arg_name[n] == ':' &&
 278           arg_name[n + 1] == ':' &&
 279           arg_name[n + 2] != 0)
 280         {
 281           gtk_signal_connect_full (object,
 282                                    arg_name + n + 2,
 283                                    GTK_VALUE_SIGNAL (*arg).f, NULL,
 284                                    GTK_VALUE_SIGNAL (*arg).d,
 285                                    NULL,
 286                                    (arg_id == ARG_OBJECT_SIGNAL ||
 287                                     arg_id == ARG_OBJECT_SIGNAL_AFTER),
 288                                    (arg_id == ARG_OBJECT_SIGNAL_AFTER ||
 289                                     arg_id == ARG_SIGNAL_AFTER));
 290         }
 291       else
 292         g_warning ("gtk_object_set_arg(): invalid signal argument: \"%s\"\n", arg->name);
 293       break;
 294     default:
 295       break;
 296     }
 297 }
 298
 299 static void
 300 gtk_object_get_arg (GtkObject *object,
 301                     GtkArg    *arg,
 302                     guint      arg_id)
 303 {
 304   switch (arg_id)
 305     {
 306     case ARG_USER_DATA:
 307       GTK_VALUE_POINTER (*arg) = gtk_object_get_user_data (object);
 308       break;
 309     case ARG_SIGNAL:
 310     case ARG_OBJECT_SIGNAL:
 311     default:
 312       arg->type = GTK_TYPE_INVALID;
 313       break;
 314     }
 315 }
 316
 317 /*****************************************
 318  * gtk_object_class_add_signals:
 319  *
 320  *   arguments:
 321  *
 322  *   results:
 323  *****************************************/
 324
 325 void
 326 gtk_object_class_add_signals (GtkObjectClass *class,
 327                               guint          *signals,
 328                               guint           nsignals)
 329 {
 330   g_return_if_fail (GTK_IS_OBJECT_CLASS (class));
 331   if (!nsignals)
 332     return;
 333   g_return_if_fail (signals != NULL);
 334
 335   class->signals = g_renew (guint, class->signals, class->nsignals + nsignals);
 336   memcpy (class->signals + class->nsignals, signals, nsignals * sizeof (guint));
 337   class->nsignals += nsignals;
 338 }
 339
 340 guint
 341 gtk_object_class_add_user_signal (GtkObjectClass     *class,
 342                                   const gchar        *name,
 343                                   GtkSignalMarshaller marshaller,
 344                                   GtkType             return_val,
 345                                   guint               nparams,
 346                                   ...)
 347 {
 348   GtkType *params;
 349   guint i;
 350   va_list args;
 351   guint signal_id;
 352
 353   g_return_val_if_fail (class != NULL, 0);
 354
 355   if (nparams > 0)
 356     {
 357       params = g_new (GtkType, nparams);
 358
 359       va_start (args, nparams);
 360
 361       for (i = 0; i < nparams; i++)
 362         params[i] = va_arg (args, GtkType);
 363
 364       va_end (args);
 365     }
 366   else
 367     params = NULL;
 368
 369   signal_id = gtk_signal_newv (name,
 370                                0,
 371                                class->type,
 372                                0,
 373                                marshaller,
 374                                return_val,
 375                                nparams,
 376                                params);
 377
 378   g_free (params);
 379
 380   if (signal_id)
 381     gtk_object_class_add_signals (class, &signal_id, 1);
 382
 383   return signal_id;
 384 }
 385
 386 guint
 387 gtk_object_class_user_signal_new (GtkObjectClass     *class,
 388                                   const gchar        *name,
 389                                   GtkSignalRunType    signal_flags,
 390                                   GtkSignalMarshaller marshaller,
 391                                   GtkType             return_val,
 392                                   guint               nparams,
 393                                   ...)
 394 {
 395   GtkType *params;
 396   guint i;
 397   va_list args;
 398   guint signal_id;
 399
 400   g_return_val_if_fail (class != NULL, 0);
 401
 402   if (nparams > 0)
 403     {
 404       params = g_new (GtkType, nparams);
 405
 406       va_start (args, nparams);
 407
 408       for (i = 0; i < nparams; i++)
 409         params[i] = va_arg (args, GtkType);
 410
 411       va_end (args);
 412     }
 413   else
 414     params = NULL;
 415
 416   signal_id = gtk_signal_newv (name,
 417                                signal_flags,
 418                                class->type,
 419                                0,
 420                                marshaller,
 421                                return_val,
 422                                nparams,
 423                                params);
 424
 425   g_free (params);
 426
 427   if (signal_id)
 428     gtk_object_class_add_signals (class, &signal_id, 1);
 429
 430   return signal_id;
 431 }
 432
 433 guint
 434 gtk_object_class_user_signal_newv (GtkObjectClass     *class,
 435                                    const gchar        *name,
 436                                    GtkSignalRunType    signal_flags,
 437                                    GtkSignalMarshaller marshaller,
 438                                    GtkType             return_val,
 439                                    guint               nparams,
 440                                    GtkType            *params)
 441 {
 442   guint signal_id;
 443
 444   g_return_val_if_fail (class != NULL, 0);
 445
 446   if (nparams > 0)
 447     g_return_val_if_fail (params != NULL, 0);
 448
 449   signal_id = gtk_signal_newv (name,
 450                                signal_flags,
 451                                class->type,
 452                                0,
 453                                marshaller,
 454                                return_val,
 455                                nparams,
 456                                params);
 457
 458   if (signal_id)
 459     gtk_object_class_add_signals (class, &signal_id, 1);
 460
 461   return signal_id;
 462 }
 463
 464 /*****************************************
 465  * gtk_object_sink:
 466  *
 467  *   arguments:
 468  *
 469  *   results:
 470  *****************************************/
 471
 472 void
 473 gtk_object_sink (GtkObject *object)
 474 {
 475   g_return_if_fail (object != NULL);
 476   g_return_if_fail (GTK_IS_OBJECT (object));
 477
 478   if (GTK_OBJECT_FLOATING (object))
 479     {
 480       GTK_OBJECT_UNSET_FLAGS (object, GTK_FLOATING);
 481       gtk_object_unref (object);
 482     }
 483 }
 484
 485 /*****************************************
 486  * Weak references.
 487  *
 488  * Weak refs are very similar to the old "destroy" signal.  They allow
 489  * one to register a callback that is called when the weakly
 490  * referenced object is finalized.
 491  *
 492  * They are not implemented as a signal because they really are
 493  * special and need to be used with great care.  Unlike signals, which
 494  * should be able to execute any code whatsoever.
 495  *
 496  * A weakref callback is not allowed to retain a reference to the
 497  * object.  Object data keys may be retrieved in a weak reference
 498  * callback.
 499  *
 500  * A weakref callback is called at most once.
 501  *
 502  *****************************************/
 503
 504 typedef struct _GtkWeakRef      GtkWeakRef;
 505
 506 struct _GtkWeakRef
 507 {
 508   GtkWeakRef       *next;
 509   GtkDestroyNotify  notify;
 510   gpointer          data;
 511 };
 512
 513 void
 514 gtk_object_weakref (GtkObject        *object,
 515                     GtkDestroyNotify  notify,
 516                     gpointer          data)
 517 {
 518   GtkWeakRef *weak;
 519
 520   g_return_if_fail (object != NULL);
 521   g_return_if_fail (notify != NULL);
 522   g_return_if_fail (GTK_IS_OBJECT (object));
 523
 524   if (!weakrefs_key_id)
 525     weakrefs_key_id = g_quark_from_static_string (weakrefs_key);
 526
 527   weak = g_new (GtkWeakRef, 1);
 528   weak->next = gtk_object_get_data_by_id (object, weakrefs_key_id);
 529   weak->notify = notify;
 530   weak->data = data;
 531   gtk_object_set_data_by_id (object, weakrefs_key_id, weak);
 532 }
 533
 534 void
 535 gtk_object_weakunref (GtkObject        *object,
 536                       GtkDestroyNotify  notify,
 537                       gpointer          data)
 538 {
 539   GtkWeakRef *weaks, *w, **wp;
 540
 541   g_return_if_fail (object != NULL);
 542   g_return_if_fail (GTK_IS_OBJECT (object));
 543
 544   if (!weakrefs_key_id)
 545     return;
 546
 547   weaks = gtk_object_get_data_by_id (object, weakrefs_key_id);
 548   for (wp = &weaks; *wp; wp = &(*wp)->next)
 549     {
 550       w = *wp;
 551       if (w->notify == notify && w->data == data)
 552         {
 553           if (w == weaks)
 554             gtk_object_set_data_by_id (object, weakrefs_key_id, w->next);
 555           else
 556             *wp = w->next;
 557           g_free (w);
 558           return;
 559         }
 560     }
 561 }
 562
 563 static void
 564 gtk_object_notify_weaks (GtkObject *object)
 565 {
 566   if (weakrefs_key_id)
 567     {
 568       GtkWeakRef *w1, *w2;
 569
 570       w1 = gtk_object_get_data_by_id (object, weakrefs_key_id);
 571
 572       while (w1)
 573         {
 574           w1->notify (w1->data);
 575           w2 = w1->next;
 576           g_free (w1);
 577           w1 = w2;
 578         }
 579     }
 580 }
 581
 582 /****************************************************
 583  * GtkObject argument mechanism and object creation
 584  *
 585  ****************************************************/
 586
 587 GtkObject*
 588 gtk_object_new (GtkType      object_type,
 589                 const gchar *first_arg_name,
 590                 ...)
 591 {
 592   GtkObject *object;
 593   va_list var_args;
 594   GSList *arg_list = NULL;
 595   GSList *info_list = NULL;
 596   gchar *error;
 597
 598   g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (object_type) == GTK_TYPE_OBJECT, NULL);
 599
 600   object = gtk_type_new (object_type);
 601
 602   va_start (var_args, first_arg_name);
 603   error = gtk_object_args_collect (GTK_OBJECT_TYPE (object),
 604                                    &arg_list,
 605                                    &info_list,
 606                                    first_arg_name,
 607                                    var_args);
 608   va_end (var_args);
 609
 610   if (error)
 611     {
 612       g_warning ("gtk_object_new(): %s", error);
 613       g_free (error);
 614     }
 615   else
 616     {
 617       GSList *slist_arg;
 618       GSList *slist_info;
 619
 620       slist_arg = arg_list;
 621       slist_info = info_list;
 622       while (slist_arg)
 623         {
 624           gtk_object_arg_set (object, slist_arg->data, slist_info->data);
 625           slist_arg = slist_arg->next;
 626           slist_info = slist_info->next;
 627         }
 628       gtk_args_collect_cleanup (arg_list, info_list);
 629     }
 630
 631   return object;
 632 }
 633
 634 GtkObject*
 635 gtk_object_newv (GtkType  object_type,
 636                  guint    n_args,
 637                  GtkArg  *args)
 638 {
 639   GtkObject *object;
 640   GtkArg *max_args;
 641
 642   g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (object_type) == GTK_TYPE_OBJECT, NULL);
 643   if (n_args)
 644     g_return_val_if_fail (args != NULL, NULL);
 645
 646   object = gtk_type_new (object_type);
 647
 648   for (max_args = args + n_args; args < max_args; args++)
 649     gtk_object_arg_set (object, args, NULL);
 650
 651   return object;
 652 }
 653
 654 void
 655 gtk_object_setv (GtkObject *object,
 656                  guint      n_args,
 657                  GtkArg    *args)
 658 {
 659   GtkArg *max_args;
 660
 661   g_return_if_fail (object != NULL);
 662   g_return_if_fail (GTK_IS_OBJECT (object));
 663   if (n_args)
 664     g_return_if_fail (args != NULL);
 665
 666   for (max_args = args + n_args; args < max_args; args++)
 667     gtk_object_arg_set (object, args, NULL);
 668 }
 669
 670 void
 671 gtk_object_getv (GtkObject           *object,
 672                  guint                n_args,
 673                  GtkArg              *args)
 674 {
 675   GtkArg *max_args;
 676
 677   g_return_if_fail (object != NULL);
 678   g_return_if_fail (GTK_IS_OBJECT (object));
 679   if (n_args)
 680     g_return_if_fail (args != NULL);
 681
 682   for (max_args = args + n_args; args < max_args; args++)
 683     gtk_object_arg_get (object, args, NULL);
 684 }
 685
 686 void
 687 gtk_object_set (GtkObject *object,
 688                 const gchar    *first_arg_name,
 689                 ...)
 690 {
 691   va_list var_args;
 692   GSList *arg_list = NULL;
 693   GSList *info_list = NULL;
 694   gchar *error;
 695
 696   g_return_if_fail (object != NULL);
 697   g_return_if_fail (GTK_IS_OBJECT (object));
 698
 699   va_start (var_args, first_arg_name);
 700   error = gtk_object_args_collect (GTK_OBJECT_TYPE (object),
 701                                    &arg_list,
 702                                    &info_list,
 703                                    first_arg_name,
 704                                    var_args);
 705   va_end (var_args);
 706
 707   if (error)
 708     {
 709       g_warning ("gtk_object_set(): %s", error);
 710       g_free (error);
 711     }
 712   else
 713     {
 714       GSList *slist_arg;
 715       GSList *slist_info;
 716
 717       slist_arg = arg_list;
 718       slist_info = info_list;
 719       while (slist_arg)
 720         {
 721           gtk_object_arg_set (object, slist_arg->data, slist_info->data);
 722           slist_arg = slist_arg->next;
 723           slist_info = slist_info->next;
 724         }
 725       gtk_args_collect_cleanup (arg_list, info_list);
 726     }
 727 }
 728
 729 void
 730 gtk_object_arg_set (GtkObject *object,
 731                     GtkArg      *arg,
 732                     GtkArgInfo  *info)
 733 {
 734   GtkObjectClass *oclass;
 735
 736   g_return_if_fail (object != NULL);
 737   g_return_if_fail (GTK_IS_OBJECT (object));
 738   g_return_if_fail (arg != NULL);
 739
 740   if (!info)
 741     {
 742       gchar *error;
 743
 744       error = gtk_arg_get_info (GTK_OBJECT_TYPE (object),
 745                                 object_arg_info_ht,
 746                                 arg->name,
 747                                 &info);
 748       if (error)
 749         {
 750           g_warning ("gtk_object_arg_set(): %s", error);
 751           g_free (error);
 752           return;
 753         }
 754     }
 755
 756   if (! (info->arg_flags & GTK_ARG_WRITABLE))
 757     {
 758       g_warning ("gtk_object_arg_set(): argument \"%s\" is not writable",
 759                  info->full_name);
 760       return;
 761     }
 762   if (info->type != arg->type)
 763     {
 764       g_warning ("gtk_object_arg_set(): argument \"%s\" has invalid type `%s'",
 765                  info->full_name,
 766                  gtk_type_name (arg->type));
 767       return;
 768     }
 769
 770   oclass = gtk_type_class (info->class_type);
 771   g_assert (oclass->set_arg != NULL);
 772   oclass->set_arg (object, arg, info->arg_id);
 773 }
 774
 775 void
 776 gtk_object_arg_get (GtkObject           *object,
 777                     GtkArg              *arg,
 778                     GtkArgInfo          *info)
 779 {
 780   GtkObjectClass *oclass;
 781
 782   g_return_if_fail (object != NULL);
 783   g_return_if_fail (GTK_IS_OBJECT (object));
 784   g_return_if_fail (arg != NULL);
 785
 786   if (!info)
 787     {
 788       gchar *error;
 789
 790       error = gtk_arg_get_info (GTK_OBJECT_TYPE (object),
 791                                 object_arg_info_ht,
 792                                 arg->name,
 793                                 &info);
 794       if (error)
 795         {
 796           g_warning ("gtk_object_arg_get(): %s", error);
 797           g_free (error);
 798           arg->type = GTK_TYPE_INVALID;
 799           return;
 800         }
 801     }
 802
 803   if (! (info->arg_flags & GTK_ARG_READABLE))
 804     {
 805       g_warning ("gtk_object_arg_get(): argument \"%s\" is not readable",
 806                  info->full_name);
 807       arg->type = GTK_TYPE_INVALID;
 808       return;
 809     }
 810
 811   oclass = gtk_type_class (info->class_type);
 812   g_assert (oclass->get_arg != NULL);
 813   arg->type = info->type;
 814   oclass->get_arg (object, arg, info->arg_id);
 815 }
 816
 817 void
 818 gtk_object_add_arg_type (const char *arg_name,
 819                          GtkType     arg_type,
 820                          guint       arg_flags,
 821                          guint       arg_id)
 822 {
 823   g_return_if_fail (arg_name != NULL);
 824   g_return_if_fail (arg_type > GTK_TYPE_NONE);
 825   g_return_if_fail (arg_id > 0);
 826   g_return_if_fail ((arg_flags & GTK_ARG_CHILD_ARG) == 0);
 827   if (arg_flags & GTK_ARG_CONSTRUCT)
 828     g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) == GTK_ARG_READWRITE);
 829   else
 830     g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
 831
 832   if (!object_arg_info_ht)
 833     object_arg_info_ht = g_hash_table_new (gtk_arg_info_hash,
 834                                            gtk_arg_info_equal);
 835
 836   gtk_arg_type_new_static (GTK_TYPE_OBJECT,
 837                            arg_name,
 838                            GTK_STRUCT_OFFSET (GtkObjectClass, n_args),
 839                            object_arg_info_ht,
 840                            arg_type,
 841                            arg_flags,
 842                            arg_id);
 843 }
 844
 845 gchar*
 846 gtk_object_args_collect (GtkType      object_type,
 847                          GSList      **arg_list_p,
 848                          GSList      **info_list_p,
 849                          const gchar  *first_arg_name,
 850                          va_list       var_args)
 851 {
 852   return gtk_args_collect (object_type,
 853                            object_arg_info_ht,
 854                            arg_list_p,
 855                            info_list_p,
 856                            first_arg_name,
 857                            var_args);
 858 }
 859
 860 gchar*
 861 gtk_object_arg_get_info (GtkType      object_type,
 862                          const gchar *arg_name,
 863                          GtkArgInfo **info_p)
 864 {
 865   return gtk_arg_get_info (object_type,
 866                            object_arg_info_ht,
 867                            arg_name,
 868                            info_p);
 869 }
 870
 871 GtkArg*
 872 gtk_object_query_args (GtkType        class_type,
 873                        guint32      **arg_flags,
 874                        guint         *n_args)
 875 {
 876   g_return_val_if_fail (n_args != NULL, NULL);
 877   *n_args = 0;
 878   g_return_val_if_fail (GTK_FUNDAMENTAL_TYPE (class_type) == GTK_TYPE_OBJECT, NULL);
 879
 880   return gtk_args_query (class_type, object_arg_info_ht, arg_flags, n_args);
 881 }
 882
 883 /*****************************************
 884  * GtkObject object_data mechanism
 885  *
 886  *****************************************/
 887
 888 void
 889 gtk_object_set_data_by_id (GtkObject        *object,
 890                            GQuark            data_id,
 891                            gpointer          data)
 892 {
 893   g_return_if_fail (object != NULL);
 894   g_return_if_fail (GTK_IS_OBJECT (object));
 895
 896   g_datalist_id_set_data (&object->object_data, data_id, data);
 897 }
 898
 899 void
 900 gtk_object_set_data (GtkObject        *object,
 901                      const gchar      *key,
 902                      gpointer          data)
 903 {
 904   g_return_if_fail (object != NULL);
 905   g_return_if_fail (GTK_IS_OBJECT (object));
 906   g_return_if_fail (key != NULL);
 907
 908   g_datalist_set_data (&object->object_data, key, data);
 909 }
 910
 911 void
 912 gtk_object_set_data_by_id_full (GtkObject        *object,
 913                                 GQuark            data_id,
 914                                 gpointer          data,
 915                                 GtkDestroyNotify  destroy)
 916 {
 917   g_return_if_fail (object != NULL);
 918   g_return_if_fail (GTK_IS_OBJECT (object));
 919
 920   g_datalist_id_set_data_full (&object->object_data, data_id, data, destroy);
 921 }
 922
 923 void
 924 gtk_object_set_data_full (GtkObject        *object,
 925                           const gchar      *key,
 926                           gpointer          data,
 927                           GtkDestroyNotify  destroy)
 928 {
 929   g_return_if_fail (object != NULL);
 930   g_return_if_fail (GTK_IS_OBJECT (object));
 931   g_return_if_fail (key != NULL);
 932
 933   g_datalist_set_data_full (&object->object_data, key, data, destroy);
 934 }
 935
 936 gpointer
 937 gtk_object_get_data_by_id (GtkObject   *object,
 938                            GQuark       data_id)
 939 {
 940   g_return_val_if_fail (object != NULL, NULL);
 941   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 942
 943   return g_datalist_id_get_data (&object->object_data, data_id);
 944 }
 945
 946 gpointer
 947 gtk_object_get_data (GtkObject   *object,
 948                      const gchar *key)
 949 {
 950   g_return_val_if_fail (object != NULL, NULL);
 951   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
 952   g_return_val_if_fail (key != NULL, NULL);
 953
 954   return g_datalist_get_data (&object->object_data, key);
 955 }
 956
 957 void
 958 gtk_object_remove_data_by_id (GtkObject   *object,
 959                               GQuark       data_id)
 960 {
 961   g_return_if_fail (object != NULL);
 962   g_return_if_fail (GTK_IS_OBJECT (object));
 963
 964   g_datalist_id_remove_data (&object->object_data, data_id);
 965 }
 966
 967 void
 968 gtk_object_remove_data (GtkObject   *object,
 969                         const gchar *key)
 970 {
 971   g_return_if_fail (object != NULL);
 972   g_return_if_fail (GTK_IS_OBJECT (object));
 973   g_return_if_fail (key != NULL);
 974
 975   g_datalist_remove_data (&object->object_data, key);
 976 }
 977
 978 void
 979 gtk_object_remove_no_notify_by_id (GtkObject      *object,
 980                                    GQuark          key_id)
 981 {
 982   g_return_if_fail (object != NULL);
 983   g_return_if_fail (GTK_IS_OBJECT (object));
 984
 985   g_datalist_id_remove_no_notify (&object->object_data, key_id);
 986 }
 987
 988 void
 989 gtk_object_set_data_destroy (GtkObject       *object,
 990                              const gchar     *key)
 991 {
 992   g_return_if_fail (object != NULL);
 993   g_return_if_fail (GTK_IS_OBJECT (object));
 994   g_return_if_fail (key != NULL);
 995
 996   g_datalist_remove_no_notify (&object->object_data, key);
 997 }
 998
 999 void
1000 gtk_object_set_user_data (GtkObject *object,
1001                           gpointer   data)
1002 {
1003   g_return_if_fail (object != NULL);
1004   g_return_if_fail (GTK_IS_OBJECT (object));
1005
1006   if (!user_data_key_id)
1007     user_data_key_id = g_quark_from_static_string (user_data_key);
1008
1009   g_datalist_id_set_data (&object->object_data, user_data_key_id, data);
1010 }
1011
1012 gpointer
1013 gtk_object_get_user_data (GtkObject *object)
1014 {
1015   g_return_val_if_fail (object != NULL, NULL);
1016   g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
1017
1018   return g_datalist_id_get_data (&object->object_data, user_data_key_id);
1019 }
1020
1021 /*******************************************
1022  * GtkObject referencing and unreferencing
1023  *
1024  *******************************************/
1025
1026 #undef  gtk_object_ref
1027 #undef  gtk_object_unref
1028
1029 void
1030 gtk_object_ref (GtkObject *object)
1031 {
1032   g_return_if_fail (object != NULL);
1033   g_return_if_fail (GTK_IS_OBJECT (object));
1034   g_return_if_fail (object->ref_count > 0);
1035
1036   object->ref_count += 1;
1037 }
1038
1039 void
1040 gtk_object_unref (GtkObject *object)
1041 {
1042   g_return_if_fail (object != NULL);
1043   g_return_if_fail (GTK_IS_OBJECT (object));
1044   g_return_if_fail (object->ref_count > 0);
1045
1046   if (object->ref_count == 1)
1047     {
1048       gtk_object_destroy (object);
1049
1050       g_return_if_fail (object->ref_count > 0);
1051     }
1052
1053   object->ref_count -= 1;
1054
1055   if (object->ref_count == 0)
1056     {
1057 #ifdef G_ENABLE_DEBUG
1058       if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
1059         {
1060           g_assert (g_hash_table_lookup (living_objs_ht, object) == object);
1061           g_hash_table_remove (living_objs_ht, object);
1062           obj_count--;
1063         }
1064 #endif /* G_ENABLE_DEBUG */
1065       object->klass->finalize (object);
1066     }
1067 }
1068
1069 static GtkObject *gtk_trace_object = NULL;
1070 void
1071 gtk_trace_referencing (GtkObject   *object,
1072                        const gchar *func,
1073                        guint       dummy,
1074                        guint       line,
1075                        gboolean    do_ref)
1076 {
1077   if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
1078     {
1079       gboolean exists = TRUE;
1080
1081       g_return_if_fail (object != NULL);
1082       g_return_if_fail (GTK_IS_OBJECT (object));
1083
1084 #ifdef  G_ENABLE_DEBUG
1085       exists = g_hash_table_lookup (living_objs_ht, object) != NULL;
1086 #endif  /* G_ENABLE_DEBUG */
1087
1088       if (exists &&
1089           (object == gtk_trace_object ||
1090            gtk_trace_object == (void*)42))
1091         fprintf (stdout, "trace: object_%s: (%s:%p)->ref_count=%d %s (%s:%d)\n",
1092                  do_ref ? "ref" : "unref",
1093                  gtk_type_name (GTK_OBJECT_TYPE (object)),
1094                  object,
1095                  object->ref_count,
1096                  do_ref ? "+ 1" : "- 1",
1097                  func,
1098                  line);
1099       else if (!exists)
1100         fprintf (stdout, "trace: object_%s(%p): no such object! (%s:%d)\n",
1101                  do_ref ? "ref" : "unref",
1102                  object,
1103                  func,
1104                  line);
1105     }
1106
1107   if (do_ref)
1108     gtk_object_ref (object);
1109   else
1110     gtk_object_unref (object);
1111 }