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