1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
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.
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.
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.
23 #include "gtkobject.h"
24 #include "gtksignal.h"
27 #define OBJECT_DATA_ID_CHUNK 1024
42 typedef struct _GtkObjectData GtkObjectData;
43 typedef struct _GtkArgInfo GtkArgInfo;
49 GtkDestroyNotify destroy;
64 static void gtk_object_class_init (GtkObjectClass *klass);
65 static void gtk_object_init (GtkObject *object);
66 static void gtk_object_set_arg (GtkObject *object,
69 static void gtk_object_get_arg (GtkObject *object,
72 static void gtk_object_shutdown (GtkObject *object);
73 static void gtk_object_real_destroy (GtkObject *object);
74 static void gtk_object_finalize (GtkObject *object);
75 static void gtk_object_notify_weaks (GtkObject *object);
77 static void gtk_object_data_destroy (GtkObjectData *odata);
78 static guint* gtk_object_data_id_alloc (void);
80 GtkArg* gtk_object_collect_args (guint *nargs,
84 static guint object_signals[LAST_SIGNAL] = { 0 };
86 static GHashTable *object_data_ht = NULL;
87 static GMemChunk *object_data_mem_chunk = NULL;
88 static GSList *object_data_id_list = NULL;
89 static guint object_data_id_index = 0;
91 static GHashTable *arg_info_ht = NULL;
93 static const gchar *user_data_key = "user_data";
94 static guint user_data_key_id = 0;
95 static const gchar *weakrefs_key = "gtk-weakrefs";
96 static guint weakrefs_key_id = 0;
99 static guint obj_count = 0;
100 static GHashTable *living_objs_ht = NULL;
102 gtk_object_debug_foreach (gpointer key, gpointer value, gpointer user_data)
106 object = (GtkObject*) value;
107 g_print ("GTK-DEBUG: %p: %s ref_count=%d%s%s\n",
109 gtk_type_name (GTK_OBJECT_TYPE (object)),
111 GTK_OBJECT_FLOATING (object) ? " (floating)" : "",
112 GTK_OBJECT_DESTROYED (object) ? " (destroyed)" : "");
115 gtk_object_debug (void)
117 g_hash_table_foreach (living_objs_ht, gtk_object_debug_foreach, NULL);
119 g_print ("GTK-DEBUG: living objects count = %d\n", obj_count);
122 gtk_object_pointer_hash (const gpointer v)
130 #endif /* G_ENABLE_DEBUG */
132 /****************************************************
133 * GtkObject type, class and instance initialization
135 ****************************************************/
138 gtk_object_init_type ()
140 GtkType object_type = 0;
141 GtkTypeInfo object_info =
145 sizeof (GtkObjectClass),
146 (GtkClassInitFunc) gtk_object_class_init,
147 (GtkObjectInitFunc) gtk_object_init,
152 object_type = gtk_type_unique (0, &object_info);
153 g_assert (object_type == GTK_TYPE_OBJECT);
155 #ifdef G_ENABLE_DEBUG
156 if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
157 ATEXIT (gtk_object_debug);
158 #endif /* G_ENABLE_DEBUG */
162 gtk_object_get_type ()
164 return GTK_TYPE_OBJECT;
168 gtk_object_class_init (GtkObjectClass *class)
170 class->signals = NULL;
174 gtk_object_add_arg_type ("GtkObject::user_data",
178 gtk_object_add_arg_type ("GtkObject::signal",
182 gtk_object_add_arg_type ("GtkObject::object_signal",
187 object_signals[DESTROY] =
188 gtk_signal_new ("destroy",
191 GTK_SIGNAL_OFFSET (GtkObjectClass, destroy),
192 gtk_signal_default_marshaller,
195 gtk_object_class_add_signals (class, object_signals, LAST_SIGNAL);
197 class->shutdown = gtk_object_shutdown;
198 class->destroy = gtk_object_real_destroy;
199 class->finalize = gtk_object_finalize;
203 gtk_object_init (GtkObject *object)
205 GTK_OBJECT_FLAGS (object) = GTK_FLOATING;
207 object->ref_count = 1;
208 object->object_data = NULL;
210 #ifdef G_ENABLE_DEBUG
211 if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
216 living_objs_ht = g_hash_table_new (gtk_object_pointer_hash, NULL);
218 g_hash_table_insert (living_objs_ht, object, object);
220 #endif /* G_ENABLE_DEBUG */
223 /********************************************
224 * Functions to end a GtkObject's life time
226 ********************************************/
229 gtk_object_destroy (GtkObject *object)
231 g_return_if_fail (object != NULL);
232 g_return_if_fail (GTK_IS_OBJECT (object));
234 if (!GTK_OBJECT_DESTROYED (object))
236 /* we will hold a reference on the object in this place, so
237 * to ease all classes shutdown and destroy implementations.
238 * i.e. they don't have to bother about referencing at all.
240 gtk_object_ref (object);
241 object->klass->shutdown (object);
242 gtk_object_unref (object);
247 gtk_object_shutdown (GtkObject *object)
249 GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
250 gtk_signal_emit (object, object_signals[DESTROY]);
254 gtk_object_real_destroy (GtkObject *object)
256 gtk_signal_handlers_destroy (object);
260 gtk_object_finalize (GtkObject *object)
262 GtkObjectData *odata, *next;
264 gtk_object_notify_weaks (object);
266 odata = object->object_data;
270 gtk_object_data_destroy (odata);
277 /*****************************************
278 * GtkObject argument handlers
280 *****************************************/
283 gtk_object_set_arg (GtkObject *object,
290 gtk_object_set_user_data (object, GTK_VALUE_POINTER (*arg));
293 if ((arg->name[9 + 2 + 6] != ':') || (arg->name[9 + 2 + 7] != ':'))
295 g_warning ("invalid signal argument: \"%s\"\n", arg->name);
296 arg->type = GTK_TYPE_INVALID;
299 gtk_signal_connect (object, arg->name + 9 + 2 + 6 + 2,
300 (GtkSignalFunc) GTK_VALUE_SIGNAL (*arg).f,
301 GTK_VALUE_SIGNAL (*arg).d);
303 case ARG_OBJECT_SIGNAL:
304 if ((arg->name[9 + 2 + 13] != ':') || (arg->name[9 + 2 + 14] != ':'))
306 g_warning ("invalid signal argument: \"%s\"\n", arg->name);
307 arg->type = GTK_TYPE_INVALID;
310 gtk_signal_connect_object (object, arg->name + 9 + 2 + 13 + 2,
311 (GtkSignalFunc) GTK_VALUE_SIGNAL (*arg).f,
312 (GtkObject*) GTK_VALUE_SIGNAL (*arg).d);
315 arg->type = GTK_TYPE_INVALID;
321 gtk_object_get_arg (GtkObject *object,
328 GTK_VALUE_POINTER (*arg) = gtk_object_get_user_data (object);
331 case ARG_OBJECT_SIGNAL:
333 arg->type = GTK_TYPE_INVALID;
338 /*****************************************
339 * gtk_object_class_add_signals:
344 *****************************************/
347 gtk_object_class_add_signals (GtkObjectClass *class,
354 g_return_if_fail (class != NULL);
356 new_signals = g_new (guint, class->nsignals + nsignals);
357 for (i = 0; i < class->nsignals; i++)
358 new_signals[i] = class->signals[i];
359 for (i = 0; i < nsignals; i++)
360 new_signals[class->nsignals + i] = signals[i];
362 g_free (class->signals);
363 class->signals = new_signals;
364 class->nsignals += nsignals;
367 /*****************************************
368 * gtk_object_class_add_user_signal:
373 *****************************************/
376 gtk_object_class_add_user_signal (GtkObjectClass *class,
378 GtkSignalMarshaller marshaller,
388 g_return_val_if_fail (class != NULL, 0);
392 params = g_new (GtkType, nparams);
394 va_start (args, nparams);
396 for (i = 0; i < nparams; i++)
397 params[i] = va_arg (args, GtkType);
404 signal_id = gtk_signal_newv (name,
416 gtk_object_class_add_signals (class, &signal_id, 1);
421 /*****************************************
427 *****************************************/
430 gtk_object_sink (GtkObject *object)
432 g_return_if_fail (object != NULL);
433 g_return_if_fail (GTK_IS_OBJECT (object));
435 if (GTK_OBJECT_FLOATING (object))
437 GTK_OBJECT_UNSET_FLAGS (object, GTK_FLOATING);
438 gtk_object_unref (object);
442 /*****************************************
445 * Weak refs are very similar to the old "destroy" signal. They allow
446 * one to register a callback that is called when the weakly
447 * referenced object is finalized.
449 * They are not implemented as a signal because they really are
450 * special and need to be used with great care. Unlike signals, which
451 * should be able to execute any code whatsoever.
453 * A weakref callback is not allowed to retain a reference to the
454 * object. Object data keys may be retrieved in a weak reference
457 * A weakref callback is called at most once.
459 *****************************************/
461 typedef struct _GtkWeakRef GtkWeakRef;
466 GtkDestroyNotify notify;
471 gtk_object_weakref (GtkObject *object,
472 GtkDestroyNotify notify,
477 g_return_if_fail (object != NULL);
478 g_return_if_fail (notify != NULL);
479 g_return_if_fail (GTK_IS_OBJECT (object));
481 if (!weakrefs_key_id)
482 weakrefs_key_id = gtk_object_data_force_id (weakrefs_key);
484 weak = g_new (GtkWeakRef, 1);
485 weak->next = gtk_object_get_data_by_id (object, weakrefs_key_id);
486 weak->notify = notify;
488 gtk_object_set_data_by_id (object, weakrefs_key_id, weak);
492 gtk_object_weakunref (GtkObject *object,
493 GtkDestroyNotify notify,
496 GtkWeakRef *weaks, *w, **wp;
498 g_return_if_fail (object != NULL);
499 g_return_if_fail (GTK_IS_OBJECT (object));
501 if (!weakrefs_key_id)
504 weaks = gtk_object_get_data_by_id (object, weakrefs_key_id);
505 for (wp = &weaks; *wp; wp = &(*wp)->next)
508 if (w->notify == notify && w->data == data)
511 gtk_object_set_data_by_id (object, weakrefs_key_id, w->next);
521 gtk_object_notify_weaks (GtkObject *object)
527 w1 = gtk_object_get_data_by_id (object, weakrefs_key_id);
531 w1->notify (w1->data);
539 /*****************************************
545 *****************************************/
548 gtk_object_new (GtkType type,
557 obj = gtk_type_new (type);
559 va_start (args1, type);
560 va_start (args2, type);
562 args = gtk_object_collect_args (&nargs, args1, args2);
563 gtk_object_setv (obj, nargs, args);
572 /*****************************************
578 *****************************************/
581 gtk_object_newv (GtkType type,
587 obj = gtk_type_new (type);
588 gtk_object_setv (obj, nargs, args);
593 /*****************************************
599 *****************************************/
602 gtk_object_getv (GtkObject *object,
608 g_return_if_fail (object != NULL);
609 g_return_if_fail (GTK_IS_OBJECT (object));
614 for (i = 0; i < nargs; i++)
621 /* hm, the name cutting shouldn't be needed on gets, but what the heck...
623 lookup_name = g_strdup (args[i].name);
624 d = strchr (lookup_name, ':');
625 if (d && d[1] == ':')
627 d = strchr (d + 2, ':');
631 info = g_hash_table_lookup (arg_info_ht, lookup_name);
638 g_warning ("invalid arg name: \"%s\"\n", lookup_name);
639 args[i].type = GTK_TYPE_INVALID;
640 g_free (lookup_name);
643 else if (!gtk_type_is_a (object->klass->type, info->class_type))
645 g_warning ("invalid arg for %s: \"%s\"\n", gtk_type_name (object->klass->type), lookup_name);
646 args[i].type = GTK_TYPE_INVALID;
647 g_free (lookup_name);
650 else if (! (info->arg_flags & GTK_ARG_READABLE))
652 g_warning ("arg is not supplied for read-access: \"%s\"\n", lookup_name);
653 args[i].type = GTK_TYPE_INVALID;
654 g_free (lookup_name);
658 g_free (lookup_name);
660 args[i].type = info->type;
661 gtk_type_get_arg (object, info->class_type, &args[i], info->arg_id);
665 /*****************************************
666 * gtk_object_query_args:
671 *****************************************/
673 struct _GtkQueryArgData
678 typedef struct _GtkQueryArgData GtkQueryArgData;
681 gtk_query_arg_foreach (gpointer key,
685 register GtkArgInfo *info;
686 register GtkQueryArgData *data;
691 if (info->class_type == data->class_type)
692 data->arg_list = g_list_prepend (data->arg_list, info);
696 gtk_object_query_args (GtkType class_type,
701 GtkQueryArgData query_data;
705 g_return_val_if_fail (nargs != NULL, NULL);
707 g_return_val_if_fail (gtk_type_is_a (class_type, gtk_object_get_type ()), NULL);
712 /* make sure the types class has been initialized, because
713 * the argument setup happens in the gtk_*_class_init() functions.
715 gtk_type_class (class_type);
717 query_data.arg_list = NULL;
718 query_data.class_type = class_type;
719 g_hash_table_foreach (arg_info_ht, gtk_query_arg_foreach, &query_data);
721 if (query_data.arg_list)
723 register GList *list;
726 list = query_data.arg_list;
733 g_assert (len == ((GtkObjectClass*) gtk_type_class (class_type))->n_args); /* paranoid */
735 args = g_new0 (GtkArg, len);
738 *arg_flags = g_new (guint32, len);
747 g_assert (info->seq_id > 0 && info->seq_id <= len); /* paranoid */
749 args[info->seq_id - 1].type = info->type;
750 args[info->seq_id - 1].name = info->name;
752 (*arg_flags)[info->seq_id - 1] = info->arg_flags;
756 g_list_free (query_data.arg_list);
764 /*****************************************
770 *****************************************/
773 gtk_object_set (GtkObject *object,
781 g_return_if_fail (object != NULL);
783 va_start (args1, object);
784 va_start (args2, object);
786 args = gtk_object_collect_args (&nargs, args1, args2);
787 gtk_object_setv (object, nargs, args);
794 /*****************************************
800 *****************************************/
803 gtk_object_setv (GtkObject *object,
809 g_return_if_fail (object != NULL);
810 g_return_if_fail (GTK_OBJECT (object));
815 for (i = 0; i < nargs; i++)
822 lookup_name = g_strdup (args[i].name);
823 d = strchr (lookup_name, ':');
824 if (d && d[1] == ':')
826 d = strchr (d + 2, ':');
830 info = g_hash_table_lookup (arg_info_ht, lookup_name);
839 g_warning ("invalid arg name: \"%s\"\n", lookup_name);
842 else if (info->type != args[i].type)
844 g_warning ("invalid arg type for: \"%s\"\n", lookup_name);
847 else if (!gtk_type_is_a (object->klass->type, info->class_type))
849 g_warning ("invalid arg for %s: \"%s\"\n", gtk_type_name (object->klass->type), lookup_name);
852 else if (! (info->arg_flags & GTK_ARG_WRITABLE))
854 g_warning ("arg is not supplied for write-access: \"%s\"\n", lookup_name);
858 g_free (lookup_name);
863 gtk_type_set_arg (object, info->class_type, &args[i], info->arg_id);
867 /*****************************************
868 * gtk_object_add_arg_type:
873 *****************************************/
876 gtk_object_add_arg_type (const char *arg_name,
882 gchar class_part[1024];
886 g_return_if_fail (arg_name != NULL);
887 g_return_if_fail (arg_type > GTK_TYPE_NONE);
888 g_return_if_fail (arg_id > 0);
889 g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
891 arg_part = strchr (arg_name, ':');
892 if (!arg_part || (arg_part[0] != ':') || (arg_part[1] != ':'))
894 g_warning ("invalid arg name: \"%s\"\n", arg_name);
898 strncpy (class_part, arg_name, (glong) (arg_part - arg_name));
899 class_part[(glong) (arg_part - arg_name)] = '\0';
901 class_type = gtk_type_from_name (class_part);
904 g_warning ("invalid class name in arg: \"%s\"\n", arg_name);
908 info = g_new (GtkArgInfo, 1);
909 info->name = g_strdup (arg_name);
910 info->type = arg_type;
911 info->class_type = class_type;
912 info->arg_flags = arg_flags & (GTK_ARG_READABLE | GTK_ARG_WRITABLE);
913 info->arg_id = arg_id;
914 info->seq_id = ++((GtkObjectClass*) gtk_type_class (class_type))->n_args;
917 arg_info_ht = g_hash_table_new (g_str_hash, g_str_equal);
919 g_hash_table_insert (arg_info_ht, info->name, info);
922 /*****************************************
923 * gtk_object_get_arg_type:
928 *****************************************/
931 gtk_object_get_arg_type (const gchar *arg_name)
938 return GTK_TYPE_INVALID;
940 t = strchr (arg_name, ':');
941 if (!t || (t[0] != ':') || (t[1] != ':'))
943 g_warning ("invalid arg name: \"%s\"\n", arg_name);
944 return GTK_TYPE_INVALID;
947 t = strchr (t + 2, ':');
950 strncpy (buffer, arg_name, (long) (t - arg_name));
951 buffer[(long) (t - arg_name)] = '\0';
955 info = g_hash_table_lookup (arg_info_ht, (gpointer) arg_name);
959 return GTK_TYPE_INVALID;
962 /*****************************************
963 * GtkObject object_data mechanism
965 *****************************************/
968 gtk_object_set_data_by_id (GtkObject *object,
972 g_return_if_fail (data_id > 0);
974 gtk_object_set_data_by_id_full (object, data_id, data, NULL);
978 gtk_object_set_data (GtkObject *object,
982 g_return_if_fail (key != NULL);
984 gtk_object_set_data_by_id_full (object, gtk_object_data_force_id (key), data, NULL);
988 gtk_object_set_data_by_id_full (GtkObject *object,
991 GtkDestroyNotify destroy)
993 GtkObjectData *odata;
996 g_return_if_fail (object != NULL);
997 g_return_if_fail (GTK_IS_OBJECT (object));
998 g_return_if_fail (data_id > 0);
1003 odata = object->object_data;
1007 if (odata->id == data_id)
1010 prev->next = odata->next;
1011 if (odata == object->object_data)
1012 object->object_data = odata->next;
1014 gtk_object_data_destroy (odata);
1019 odata = odata->next;
1024 odata = object->object_data;
1027 if (odata->id == data_id)
1030 odata->destroy (odata->data);
1033 odata->destroy = destroy;
1037 odata = odata->next;
1040 if (!object_data_mem_chunk)
1041 object_data_mem_chunk = g_mem_chunk_new ("object data mem chunk",
1042 sizeof (GtkObjectData),
1043 1024, G_ALLOC_AND_FREE);
1045 odata = g_chunk_new (GtkObjectData, object_data_mem_chunk);
1046 odata->id = data_id;
1048 odata->destroy = destroy;
1049 odata->next = object->object_data;
1051 object->object_data = odata;
1056 gtk_object_set_data_full (GtkObject *object,
1059 GtkDestroyNotify destroy)
1061 g_return_if_fail (key != NULL);
1063 gtk_object_set_data_by_id_full (object, gtk_object_data_force_id (key), data, destroy);
1067 gtk_object_data_force_id (const gchar *key)
1071 g_return_val_if_fail (key != NULL, 0);
1073 if (!object_data_ht)
1074 object_data_ht = g_hash_table_new (g_str_hash, g_str_equal);
1076 id = g_hash_table_lookup (object_data_ht, (gpointer) key);
1079 id = gtk_object_data_id_alloc ();
1080 g_hash_table_insert (object_data_ht, g_strdup (key), id);
1087 gtk_object_get_data_by_id (GtkObject *object,
1090 GtkObjectData *odata;
1092 g_return_val_if_fail (object != NULL, NULL);
1093 g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
1097 odata = object->object_data;
1100 if (odata->id == data_id)
1102 odata = odata->next;
1110 gtk_object_get_data (GtkObject *object,
1115 g_return_val_if_fail (key != NULL, NULL);
1117 id = gtk_object_data_try_key (key);
1119 return gtk_object_get_data_by_id (object, id);
1125 gtk_object_data_try_key (const gchar *key)
1127 g_return_val_if_fail (key != NULL, 0);
1133 id = g_hash_table_lookup (object_data_ht, (gpointer) key);
1142 gtk_object_remove_data_by_id (GtkObject *object,
1146 gtk_object_set_data_by_id_full (object, data_id, NULL, NULL);
1150 gtk_object_remove_data (GtkObject *object,
1155 g_return_if_fail (key != NULL);
1157 id = gtk_object_data_try_key (key);
1159 gtk_object_set_data_by_id_full (object, id, NULL, NULL);
1163 gtk_object_data_destroy (GtkObjectData *odata)
1165 g_return_if_fail (odata != NULL);
1168 odata->destroy (odata->data);
1170 g_mem_chunk_free (object_data_mem_chunk, odata);
1174 gtk_object_data_id_alloc ()
1176 static guint next_id = 1;
1179 if (!object_data_id_list ||
1180 (object_data_id_index == OBJECT_DATA_ID_CHUNK))
1182 ids = g_new (guint, OBJECT_DATA_ID_CHUNK);
1183 object_data_id_index = 0;
1184 object_data_id_list = g_slist_prepend (object_data_id_list, ids);
1188 ids = object_data_id_list->data;
1191 ids[object_data_id_index] = next_id++;
1192 return &ids[object_data_id_index++];
1195 /*****************************************
1196 * gtk_object_set_user_data:
1201 *****************************************/
1204 gtk_object_set_user_data (GtkObject *object,
1207 if (!user_data_key_id)
1208 user_data_key_id = gtk_object_data_force_id (user_data_key);
1210 gtk_object_set_data_by_id_full (object, user_data_key_id, data, NULL);
1213 /*****************************************
1214 * gtk_object_get_user_data:
1219 *****************************************/
1222 gtk_object_get_user_data (GtkObject *object)
1224 if (user_data_key_id)
1225 return gtk_object_get_data_by_id (object, user_data_key_id);
1230 /*****************************************
1231 * gtk_object_check_cast:
1236 *****************************************/
1239 gtk_object_descriptive_type_name (GtkType type)
1243 name = gtk_type_name (type);
1251 gtk_object_check_cast (GtkObject *obj,
1256 g_warning ("invalid cast from (NULL) pointer to `%s'",
1257 gtk_object_descriptive_type_name (cast_type));
1262 g_warning ("invalid unclassed pointer in cast to `%s'",
1263 gtk_object_descriptive_type_name (cast_type));
1266 if (obj->klass->type < GTK_TYPE_OBJECT)
1268 g_warning ("invalid class type `%s' in cast to `%s'",
1269 gtk_object_descriptive_type_name (obj->klass->type),
1270 gtk_object_descriptive_type_name (cast_type));
1273 if (!gtk_type_is_a (obj->klass->type, cast_type))
1275 g_warning ("invalid cast from `%s' to `%s'",
1276 gtk_object_descriptive_type_name (obj->klass->type),
1277 gtk_object_descriptive_type_name (cast_type));
1284 /*****************************************
1285 * gtk_object_check_class_cast:
1290 *****************************************/
1293 gtk_object_check_class_cast (GtkObjectClass *klass,
1298 g_warning ("invalid class cast from (NULL) pointer to `%s'",
1299 gtk_object_descriptive_type_name (cast_type));
1302 if (klass->type < GTK_TYPE_OBJECT)
1304 g_warning ("invalid class type `%s' in class cast to `%s'",
1305 gtk_object_descriptive_type_name (klass->type),
1306 gtk_object_descriptive_type_name (cast_type));
1309 if (!gtk_type_is_a (klass->type, cast_type))
1311 g_warning ("invalid class cast from `%s' to `%s'",
1312 gtk_object_descriptive_type_name (klass->type),
1313 gtk_object_descriptive_type_name (cast_type));
1320 /*****************************************
1321 * gtk_object_collect_args:
1326 *****************************************/
1329 gtk_object_collect_args (guint *nargs,
1344 name = va_arg (args1, char *);
1351 type = gtk_object_get_arg_type (name);
1353 switch (GTK_FUNDAMENTAL_TYPE (type))
1355 case GTK_TYPE_INVALID:
1356 g_warning ("invalid arg name: \"%s\" %x\n", name, type);
1357 (void) va_arg (args1, long);
1366 case GTK_TYPE_FLAGS:
1367 (void) va_arg (args1, gint);
1370 case GTK_TYPE_ULONG:
1371 (void) va_arg (args1, glong);
1373 case GTK_TYPE_FLOAT:
1374 (void) va_arg (args1, gfloat);
1376 case GTK_TYPE_DOUBLE:
1377 (void) va_arg (args1, gdouble);
1379 case GTK_TYPE_STRING:
1380 (void) va_arg (args1, gchar*);
1382 case GTK_TYPE_POINTER:
1383 case GTK_TYPE_BOXED:
1384 (void) va_arg (args1, gpointer);
1386 case GTK_TYPE_SIGNAL:
1387 (void) va_arg (args1, GtkFunction);
1388 (void) va_arg (args1, gpointer);
1390 case GTK_TYPE_FOREIGN:
1391 (void) va_arg (args1, gpointer);
1392 (void) va_arg (args1, GtkDestroyNotify);
1394 case GTK_TYPE_CALLBACK:
1395 (void) va_arg (args1, GtkCallbackMarshal);
1396 (void) va_arg (args1, gpointer);
1397 (void) va_arg (args1, GtkDestroyNotify);
1399 case GTK_TYPE_C_CALLBACK:
1400 (void) va_arg (args1, GtkFunction);
1401 (void) va_arg (args1, gpointer);
1404 (void) va_arg (args1, gint);
1405 (void) va_arg (args1, GtkArg*);
1407 case GTK_TYPE_OBJECT:
1408 (void) va_arg (args1, GtkObject*);
1411 g_error ("unsupported type %s in args", gtk_type_name (type));
1423 args = g_new0 (GtkArg, n);
1425 for (i = 0; i < n; i++)
1427 args[i].name = va_arg (args2, char *);
1428 args[i].type = gtk_object_get_arg_type (args[i].name);
1430 switch (GTK_FUNDAMENTAL_TYPE (args[i].type))
1432 case GTK_TYPE_INVALID:
1433 (void) va_arg (args2, long);
1439 GTK_VALUE_CHAR(args[i]) = va_arg (args2, gint);
1442 GTK_VALUE_BOOL(args[i]) = va_arg (args2, gint);
1445 GTK_VALUE_INT(args[i]) = va_arg (args2, gint);
1448 GTK_VALUE_UINT(args[i]) = va_arg (args2, guint);
1451 GTK_VALUE_ENUM(args[i]) = va_arg (args2, gint);
1453 case GTK_TYPE_FLAGS:
1454 GTK_VALUE_FLAGS(args[i]) = va_arg (args2, gint);
1457 GTK_VALUE_LONG(args[i]) = va_arg (args2, glong);
1459 case GTK_TYPE_ULONG:
1460 GTK_VALUE_ULONG(args[i]) = va_arg (args2, gulong);
1462 case GTK_TYPE_FLOAT:
1463 GTK_VALUE_FLOAT(args[i]) = va_arg (args2, gfloat);
1465 case GTK_TYPE_DOUBLE:
1466 GTK_VALUE_DOUBLE(args[i]) = va_arg (args2, gdouble);
1468 case GTK_TYPE_STRING:
1469 GTK_VALUE_STRING(args[i]) = va_arg (args2, gchar*);
1471 case GTK_TYPE_POINTER:
1472 GTK_VALUE_POINTER(args[i]) = va_arg (args2, gpointer);
1474 case GTK_TYPE_BOXED:
1475 GTK_VALUE_BOXED(args[i]) = va_arg (args2, gpointer);
1477 case GTK_TYPE_SIGNAL:
1478 GTK_VALUE_SIGNAL(args[i]).f = va_arg (args2, GtkFunction);
1479 GTK_VALUE_SIGNAL(args[i]).d = va_arg (args2, gpointer);
1481 case GTK_TYPE_FOREIGN:
1482 GTK_VALUE_FOREIGN(args[i]).data = va_arg (args2, gpointer);
1483 GTK_VALUE_FOREIGN(args[i]).notify =
1484 va_arg (args2, GtkDestroyNotify);
1486 case GTK_TYPE_CALLBACK:
1487 GTK_VALUE_CALLBACK(args[i]).marshal =
1488 va_arg (args2, GtkCallbackMarshal);
1489 GTK_VALUE_CALLBACK(args[i]).data = va_arg (args2, gpointer);
1490 GTK_VALUE_CALLBACK(args[i]).notify =
1491 va_arg (args2, GtkDestroyNotify);
1493 case GTK_TYPE_C_CALLBACK:
1494 GTK_VALUE_C_CALLBACK(args[i]).func = va_arg (args2, GtkFunction);
1495 GTK_VALUE_C_CALLBACK(args[i]).func_data =
1496 va_arg (args2, gpointer);
1499 GTK_VALUE_ARGS(args[i]).n_args = va_arg (args2, gint);
1500 GTK_VALUE_ARGS(args[i]).args = va_arg (args2, GtkArg*);
1502 case GTK_TYPE_OBJECT:
1503 GTK_VALUE_OBJECT(args[i]) = va_arg (args2, GtkObject*);
1504 g_assert (GTK_VALUE_OBJECT(args[i]) == NULL ||
1505 GTK_CHECK_TYPE (GTK_VALUE_OBJECT(args[i]),
1509 g_error ("unsupported type %s in args",
1510 gtk_type_name (args[i].type));
1521 #undef gtk_object_ref
1522 #undef gtk_object_unref
1525 gtk_object_ref (GtkObject *object)
1527 g_return_if_fail (object != NULL);
1528 g_return_if_fail (GTK_IS_OBJECT (object));
1530 object->ref_count += 1;
1534 gtk_object_unref (GtkObject *object)
1536 g_return_if_fail (object != NULL);
1537 g_return_if_fail (GTK_IS_OBJECT (object));
1539 if (object->ref_count == 1)
1540 gtk_object_destroy (object);
1542 if (object->ref_count > 0)
1543 object->ref_count -= 1;
1545 if (object->ref_count == 0)
1547 #ifdef G_ENABLE_DEBUG
1548 if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
1550 g_assert (g_hash_table_lookup (living_objs_ht, object) == object);
1551 g_hash_table_remove (living_objs_ht, object);
1554 #endif /* G_ENABLE_DEBUG */
1555 object->klass->finalize (object);
1560 #ifdef G_ENABLE_DEBUG
1561 static GtkObject *gtk_trace_object = NULL;
1563 gtk_trace_referencing (gpointer *o,
1570 GtkObject *object = (GtkObject*) o;
1572 if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
1574 g_return_if_fail (object != NULL);
1575 g_return_if_fail (GTK_IS_OBJECT (object));
1577 exists = g_hash_table_lookup (living_objs_ht, object) != NULL;
1580 (object == gtk_trace_object ||
1581 gtk_trace_object == (void*)42))
1582 printf ("trace: object_%s: (%s:%p)->ref_count=%d%s (%s_f%02d:%d)\n",
1583 do_ref ? "ref" : "unref",
1584 gtk_type_name (GTK_OBJECT_TYPE (object)),
1587 do_ref ? " + 1" : " - 1 ",
1593 printf ("trace: object_%s(%p): no such object! (%s_f%02d:%d)\n",
1594 do_ref ? "ref" : "unref",
1602 gtk_object_ref (object);
1604 gtk_object_unref (object);
1606 #endif /* G_ENABLE_DEBUG */