* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "config.h"
+
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
-#include <stdlib.h>
+
+#undef GTK_DISABLE_DEPRECATED
+
#include "gtkobject.h"
-#include "gtksignal.h"
+#include "gtkintl.h"
+#include "gtkmarshalers.h"
+#include "gtkprivate.h"
+#define GTK_DISABLE_DEPRECATED
+#include "gtkalias.h"
-#define GTK_OBJECT_DATA_ID_BLOCK_SIZE (1024)
-#define GTK_OBJECT_DATA_BLOCK_SIZE (1024)
enum {
DESTROY,
LAST_SIGNAL
};
enum {
- ARG_0,
- ARG_USER_DATA,
- ARG_SIGNAL,
- ARG_OBJECT_SIGNAL
-};
-
-
-typedef struct _GtkObjectData GtkObjectData;
-typedef struct _GtkArgInfo GtkArgInfo;
-
-struct _GtkObjectData
-{
- guint id;
- gpointer data;
- GtkDestroyNotify destroy;
- GtkObjectData *next;
-};
-
-struct _GtkArgInfo
-{
- char *name;
- GtkType type;
- GtkType class_type;
- guint arg_flags;
- guint arg_id;
- guint seq_id;
+ PROP_0,
+ PROP_USER_DATA
};
-static void gtk_object_class_init (GtkObjectClass *klass);
-static void gtk_object_init (GtkObject *object);
-static void gtk_object_set_arg (GtkObject *object,
- GtkArg *arg,
- guint arg_id);
-static void gtk_object_get_arg (GtkObject *object,
- GtkArg *arg,
- guint arg_id);
-static void gtk_object_shutdown (GtkObject *object);
-static void gtk_object_real_destroy (GtkObject *object);
-static void gtk_object_finalize (GtkObject *object);
-static void gtk_object_notify_weaks (GtkObject *object);
-
-GtkArg* gtk_object_collect_args (guint *nargs,
- va_list args1,
- va_list args2);
-
-static guint object_signals[LAST_SIGNAL] = { 0 };
+static void gtk_object_base_class_init (GtkObjectClass *class);
+static void gtk_object_base_class_finalize (GtkObjectClass *class);
+static void gtk_object_class_init (GtkObjectClass *klass);
+static void gtk_object_init (GtkObject *object,
+ GtkObjectClass *klass);
+static void gtk_object_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gtk_object_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gtk_object_dispose (GObject *object);
+static void gtk_object_real_destroy (GtkObject *object);
+static void gtk_object_finalize (GObject *object);
+static void gtk_object_notify_weaks (GtkObject *object);
+
+static gpointer parent_class = NULL;
+static guint object_signals[LAST_SIGNAL] = { 0 };
+static GQuark quark_weakrefs = 0;
-static GHashTable *arg_info_ht = NULL;
-static const gchar *user_data_key = "user_data";
-static guint user_data_key_id = 0;
-static const gchar *weakrefs_key = "gtk-weakrefs";
-static guint weakrefs_key_id = 0;
+/****************************************************
+ * GtkObject type, class and instance initialization
+ *
+ ****************************************************/
-static GtkObjectData *gtk_object_data_free_list = NULL;
+GType
+gtk_object_get_type (void)
+{
+ static GType object_type = 0;
+
+ if (!object_type)
+ {
+ const GTypeInfo object_info =
+ {
+ sizeof (GtkObjectClass),
+ (GBaseInitFunc) gtk_object_base_class_init,
+ (GBaseFinalizeFunc) gtk_object_base_class_finalize,
+ (GClassInitFunc) gtk_object_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkObject),
+ 16, /* n_preallocs */
+ (GInstanceInitFunc) gtk_object_init,
+ NULL, /* value_table */
+ };
+
+ object_type = g_type_register_static (G_TYPE_INITIALLY_UNOWNED, I_("GtkObject"),
+ &object_info, G_TYPE_FLAG_ABSTRACT);
+ }
-#define GTK_OBJECT_DATA_DESTROY( odata ) { \
- if (odata->destroy) \
- odata->destroy (odata->data); \
- odata->next = gtk_object_data_free_list; \
- gtk_object_data_free_list = odata; \
+ return object_type;
}
-
-#ifdef G_ENABLE_DEBUG
-static guint obj_count = 0;
-static GHashTable *living_objs_ht = NULL;
static void
-gtk_object_debug_foreach (gpointer key, gpointer value, gpointer user_data)
+gtk_object_base_class_init (GtkObjectClass *class)
{
- GtkObject *object;
-
- object = (GtkObject*) value;
- g_print ("GTK-DEBUG: %p: %s ref_count=%d%s%s\n",
- object,
- gtk_type_name (GTK_OBJECT_TYPE (object)),
- object->ref_count,
- GTK_OBJECT_FLOATING (object) ? " (floating)" : "",
- GTK_OBJECT_DESTROYED (object) ? " (destroyed)" : "");
+ /* reset instance specifc methods that don't get inherited */
+ class->get_arg = NULL;
+ class->set_arg = NULL;
+}
+
+static void
+gtk_object_base_class_finalize (GtkObjectClass *class)
+{
+}
+
+static inline gboolean
+gtk_arg_set_from_value (GtkArg *arg,
+ const GValue *value,
+ gboolean copy_string)
+{
+ switch (G_TYPE_FUNDAMENTAL (arg->type))
+ {
+ case G_TYPE_CHAR: GTK_VALUE_CHAR (*arg) = g_value_get_char (value); break;
+ case G_TYPE_UCHAR: GTK_VALUE_UCHAR (*arg) = g_value_get_uchar (value); break;
+ case G_TYPE_BOOLEAN: GTK_VALUE_BOOL (*arg) = g_value_get_boolean (value); break;
+ case G_TYPE_INT: GTK_VALUE_INT (*arg) = g_value_get_int (value); break;
+ case G_TYPE_UINT: GTK_VALUE_UINT (*arg) = g_value_get_uint (value); break;
+ case G_TYPE_LONG: GTK_VALUE_LONG (*arg) = g_value_get_long (value); break;
+ case G_TYPE_ULONG: GTK_VALUE_ULONG (*arg) = g_value_get_ulong (value); break;
+ case G_TYPE_ENUM: GTK_VALUE_ENUM (*arg) = g_value_get_enum (value); break;
+ case G_TYPE_FLAGS: GTK_VALUE_FLAGS (*arg) = g_value_get_flags (value); break;
+ case G_TYPE_FLOAT: GTK_VALUE_FLOAT (*arg) = g_value_get_float (value); break;
+ case G_TYPE_DOUBLE: GTK_VALUE_DOUBLE (*arg) = g_value_get_double (value); break;
+ case G_TYPE_BOXED: GTK_VALUE_BOXED (*arg) = g_value_get_boxed (value); break;
+ case G_TYPE_POINTER: GTK_VALUE_POINTER (*arg) = g_value_get_pointer (value); break;
+ case G_TYPE_OBJECT: GTK_VALUE_POINTER (*arg) = g_value_get_object (value); break;
+ case G_TYPE_STRING: if (copy_string)
+ GTK_VALUE_STRING (*arg) = g_value_dup_string (value);
+ else
+ GTK_VALUE_STRING (*arg) = (char *) g_value_get_string (value);
+ break;
+ default:
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static inline gboolean
+gtk_arg_to_value (GtkArg *arg,
+ GValue *value)
+{
+ switch (G_TYPE_FUNDAMENTAL (arg->type))
+ {
+ case G_TYPE_CHAR: g_value_set_char (value, GTK_VALUE_CHAR (*arg)); break;
+ case G_TYPE_UCHAR: g_value_set_uchar (value, GTK_VALUE_UCHAR (*arg)); break;
+ case G_TYPE_BOOLEAN: g_value_set_boolean (value, GTK_VALUE_BOOL (*arg)); break;
+ case G_TYPE_INT: g_value_set_int (value, GTK_VALUE_INT (*arg)); break;
+ case G_TYPE_UINT: g_value_set_uint (value, GTK_VALUE_UINT (*arg)); break;
+ case G_TYPE_LONG: g_value_set_long (value, GTK_VALUE_LONG (*arg)); break;
+ case G_TYPE_ULONG: g_value_set_ulong (value, GTK_VALUE_ULONG (*arg)); break;
+ case G_TYPE_ENUM: g_value_set_enum (value, GTK_VALUE_ENUM (*arg)); break;
+ case G_TYPE_FLAGS: g_value_set_flags (value, GTK_VALUE_FLAGS (*arg)); break;
+ case G_TYPE_FLOAT: g_value_set_float (value, GTK_VALUE_FLOAT (*arg)); break;
+ case G_TYPE_DOUBLE: g_value_set_double (value, GTK_VALUE_DOUBLE (*arg)); break;
+ case G_TYPE_STRING: g_value_set_string (value, GTK_VALUE_STRING (*arg)); break;
+ case G_TYPE_BOXED: g_value_set_boxed (value, GTK_VALUE_BOXED (*arg)); break;
+ case G_TYPE_POINTER: g_value_set_pointer (value, GTK_VALUE_POINTER (*arg)); break;
+ case G_TYPE_OBJECT: g_value_set_object (value, GTK_VALUE_POINTER (*arg)); break;
+ default:
+ return FALSE;
+ }
+ return TRUE;
}
+
static void
-gtk_object_debug (void)
+gtk_arg_proxy_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- g_hash_table_foreach (living_objs_ht, gtk_object_debug_foreach, NULL);
+ GtkObjectClass *class = g_type_class_peek (pspec->owner_type);
+ GtkArg arg;
+
+ g_return_if_fail (class->set_arg != NULL);
- g_print ("GTK-DEBUG: living objects count = %d\n", obj_count);
+ memset (&arg, 0, sizeof (arg));
+ arg.type = G_VALUE_TYPE (value);
+ gtk_arg_set_from_value (&arg, value, FALSE);
+ arg.name = pspec->name;
+ class->set_arg (GTK_OBJECT (object), &arg, property_id);
}
-static guint
-gtk_object_pointer_hash (const gpointer v)
+
+static void
+gtk_arg_proxy_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- gint i;
+ GtkObjectClass *class = g_type_class_peek (pspec->owner_type);
+ GtkArg arg;
- i = (gint) v;
-
- return i;
-}
-#endif /* G_ENABLE_DEBUG */
+ g_return_if_fail (class->get_arg != NULL);
-/****************************************************
- * GtkObject type, class and instance initialization
- *
- ****************************************************/
+ memset (&arg, 0, sizeof (arg));
+ arg.type = G_VALUE_TYPE (value);
+ arg.name = pspec->name;
+ class->get_arg (GTK_OBJECT (object), &arg, property_id);
+ gtk_arg_to_value (&arg, value);
+}
void
-gtk_object_init_type (void)
-{
- GtkType object_type = 0;
- GtkTypeInfo object_info =
- {
- "GtkObject",
- sizeof (GtkObject),
- sizeof (GtkObjectClass),
- (GtkClassInitFunc) gtk_object_class_init,
- (GtkObjectInitFunc) gtk_object_init,
- gtk_object_set_arg,
- gtk_object_get_arg,
- };
-
- object_type = gtk_type_unique (0, &object_info);
- g_assert (object_type == GTK_TYPE_OBJECT);
-
-#ifdef G_ENABLE_DEBUG
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- ATEXIT (gtk_object_debug);
-#endif /* G_ENABLE_DEBUG */
+gtk_object_add_arg_type (const gchar *arg_name,
+ GtkType arg_type,
+ guint arg_flags,
+ guint arg_id)
+{
+ GObjectClass *oclass;
+ GParamSpec *pspec;
+ gchar *type_name, *pname;
+ GType type;
+
+ g_return_if_fail (arg_name != NULL);
+ g_return_if_fail (arg_type > G_TYPE_NONE);
+ g_return_if_fail (arg_id > 0);
+ g_return_if_fail (arg_flags & G_PARAM_READWRITE);
+ if (arg_flags & G_PARAM_CONSTRUCT)
+ g_return_if_fail ((arg_flags & G_PARAM_CONSTRUCT_ONLY) == 0);
+ if (arg_flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY))
+ g_return_if_fail (arg_flags & G_PARAM_WRITABLE);
+ g_return_if_fail ((arg_flags & ~(G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME)) == 0);
+
+ pname = strchr (arg_name, ':');
+ g_return_if_fail (pname && pname[1] == ':');
+
+ type_name = g_strndup (arg_name, pname - arg_name);
+ pname += 2;
+ type = g_type_from_name (type_name);
+ g_free (type_name);
+ g_return_if_fail (G_TYPE_IS_OBJECT (type));
+
+ oclass = gtk_type_class (type);
+ if (arg_flags & G_PARAM_READABLE)
+ {
+ if (oclass->get_property && oclass->get_property != gtk_arg_proxy_get_property)
+ {
+ g_warning (G_STRLOC ": GtkArg compatibility code can't be mixed with customized %s.get_property() implementation",
+ g_type_name (type));
+ return;
+ }
+ oclass->get_property = gtk_arg_proxy_get_property;
+ }
+ if (arg_flags & G_PARAM_WRITABLE)
+ {
+ if (oclass->set_property && oclass->set_property != gtk_arg_proxy_set_property)
+ {
+ g_warning (G_STRLOC ": GtkArg compatibility code can't be mixed with customized %s.set_property() implementation",
+ g_type_name (type));
+ return;
+ }
+ oclass->set_property = gtk_arg_proxy_set_property;
+ }
+ switch (G_TYPE_FUNDAMENTAL (arg_type))
+ {
+ case G_TYPE_ENUM:
+ pspec = g_param_spec_enum (pname, NULL, NULL, arg_type, 0, arg_flags);
+ break;
+ case G_TYPE_FLAGS:
+ pspec = g_param_spec_flags (pname, NULL, NULL, arg_type, 0, arg_flags);
+ break;
+ case G_TYPE_CHAR:
+ pspec = g_param_spec_char (pname, NULL, NULL, -128, 127, 0, arg_flags);
+ break;
+ case G_TYPE_UCHAR:
+ pspec = g_param_spec_uchar (pname, NULL, NULL, 0, 255, 0, arg_flags);
+ break;
+ case G_TYPE_BOOLEAN:
+ pspec = g_param_spec_boolean (pname, NULL, NULL, FALSE, arg_flags);
+ break;
+ case G_TYPE_INT:
+ pspec = g_param_spec_int (pname, NULL, NULL, G_MININT, G_MAXINT, 0, arg_flags);
+ break;
+ case G_TYPE_UINT:
+ pspec = g_param_spec_uint (pname, NULL, NULL, 0, G_MAXUINT, 0, arg_flags);
+ break;
+ case G_TYPE_FLOAT:
+ pspec = g_param_spec_float (pname, NULL, NULL, -G_MAXFLOAT, G_MAXFLOAT, 0, arg_flags);
+ break;
+ case G_TYPE_DOUBLE:
+ pspec = g_param_spec_double (pname, NULL, NULL, -G_MAXDOUBLE, G_MAXDOUBLE, 0, arg_flags);
+ break;
+ case G_TYPE_STRING:
+ pspec = g_param_spec_string (pname, NULL, NULL, NULL, arg_flags);
+ break;
+ case G_TYPE_POINTER:
+ pspec = g_param_spec_pointer (pname, NULL, NULL, arg_flags);
+ break;
+ case G_TYPE_OBJECT:
+ pspec = g_param_spec_object (pname, NULL, NULL, arg_type, arg_flags);
+ break;
+ case G_TYPE_BOXED:
+ if (!G_TYPE_IS_FUNDAMENTAL (arg_type))
+ {
+ pspec = g_param_spec_boxed (pname, NULL, NULL, arg_type, arg_flags);
+ break;
+ }
+ default:
+ g_warning (G_STRLOC ": Property type `%s' is not supported by the GtkArg compatibility code",
+ g_type_name (arg_type));
+ return;
+ }
+ g_object_class_install_property (oclass, arg_id, pspec);
}
-GtkType
-gtk_object_get_type (void)
+static guint (*gobject_floating_flag_handler) (GtkObject*,gint) = NULL;
+
+static guint
+gtk_object_floating_flag_handler (GtkObject *object,
+ gint job)
{
- return GTK_TYPE_OBJECT;
+ /* FIXME: remove this whole thing once GTK+ breaks ABI */
+ if (!GTK_IS_OBJECT (object))
+ return gobject_floating_flag_handler (object, job);
+ switch (job)
+ {
+ guint32 oldvalue;
+ case +1: /* force floating if possible */
+ do
+ oldvalue = g_atomic_int_get (&object->flags);
+ while (!g_atomic_int_compare_and_exchange (&object->flags, oldvalue, oldvalue | GTK_FLOATING));
+ return oldvalue & GTK_FLOATING;
+ case -1: /* sink if possible */
+ do
+ oldvalue = g_atomic_int_get (&object->flags);
+ while (!g_atomic_int_compare_and_exchange (&object->flags, oldvalue, oldvalue & ~(guint32) GTK_FLOATING));
+ return oldvalue & GTK_FLOATING;
+ default: /* check floating */
+ return 0 != (g_atomic_int_get (&object->flags) & GTK_FLOATING);
+ }
}
static void
gtk_object_class_init (GtkObjectClass *class)
{
- class->signals = NULL;
- class->nsignals = 0;
- class->n_args = 0;
-
- gtk_object_add_arg_type ("GtkObject::user_data",
- GTK_TYPE_POINTER,
- GTK_ARG_READWRITE,
- ARG_USER_DATA);
- gtk_object_add_arg_type ("GtkObject::signal",
- GTK_TYPE_SIGNAL,
- GTK_ARG_WRITABLE,
- ARG_SIGNAL);
- gtk_object_add_arg_type ("GtkObject::object_signal",
- GTK_TYPE_SIGNAL,
- GTK_ARG_WRITABLE,
- ARG_OBJECT_SIGNAL);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+ gboolean is_glib_2_10_1;
- object_signals[DESTROY] =
- gtk_signal_new ("destroy",
- GTK_RUN_LAST,
- class->type,
- GTK_SIGNAL_OFFSET (GtkObjectClass, destroy),
- gtk_signal_default_marshaller,
- GTK_TYPE_NONE, 0);
+ parent_class = g_type_class_ref (G_TYPE_OBJECT);
+
+ is_glib_2_10_1 = g_object_compat_control (3, &gobject_floating_flag_handler);
+ if (!is_glib_2_10_1)
+ g_error ("this version of Gtk+ requires GLib-2.10.1");
+ g_object_compat_control (2, gtk_object_floating_flag_handler);
- gtk_object_class_add_signals (class, object_signals, LAST_SIGNAL);
+ gobject_class->set_property = gtk_object_set_property;
+ gobject_class->get_property = gtk_object_get_property;
+ gobject_class->dispose = gtk_object_dispose;
+ gobject_class->finalize = gtk_object_finalize;
- class->shutdown = gtk_object_shutdown;
class->destroy = gtk_object_real_destroy;
- class->finalize = gtk_object_finalize;
+
+ g_object_class_install_property (gobject_class,
+ PROP_USER_DATA,
+ g_param_spec_pointer ("user-data",
+ P_("User Data"),
+ P_("Anonymous User Data Pointer"),
+ GTK_PARAM_READWRITE));
+ object_signals[DESTROY] =
+ g_signal_new (I_("destroy"),
+ G_TYPE_FROM_CLASS (gobject_class),
+ G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
+ G_STRUCT_OFFSET (GtkObjectClass, destroy),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
}
static void
-gtk_object_init (GtkObject *object)
+gtk_object_init (GtkObject *object,
+ GtkObjectClass *klass)
{
- GTK_OBJECT_FLAGS (object) = GTK_FLOATING;
-
- object->ref_count = 1;
- object->object_data = NULL;
-
-#ifdef G_ENABLE_DEBUG
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- {
- obj_count++;
-
- if (!living_objs_ht)
- living_objs_ht = g_hash_table_new (gtk_object_pointer_hash, NULL);
-
- g_hash_table_insert (living_objs_ht, object, object);
- }
-#endif /* G_ENABLE_DEBUG */
+ gboolean was_floating;
+ /* sink the GInitiallyUnowned floating flag */
+ was_floating = gobject_floating_flag_handler (object, -1);
+ /* set GTK_FLOATING via gtk_object_floating_flag_handler */
+ if (was_floating)
+ g_object_force_floating (G_OBJECT (object));
}
/********************************************
g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!GTK_OBJECT_DESTROYED (object))
- {
- /* we will hold a reference on the object in this place, so
- * to ease all classes shutdown and destroy implementations.
- * i.e. they don't have to bother about referencing at all.
- */
- gtk_object_ref (object);
- object->klass->shutdown (object);
- gtk_object_unref (object);
- }
+ if (!(GTK_OBJECT_FLAGS (object) & GTK_IN_DESTRUCTION))
+ g_object_run_dispose (G_OBJECT (object));
}
static void
-gtk_object_shutdown (GtkObject *object)
+gtk_object_dispose (GObject *gobject)
{
- GTK_OBJECT_SET_FLAGS (object, GTK_DESTROYED);
- gtk_signal_emit (object, object_signals[DESTROY]);
+ GtkObject *object = GTK_OBJECT (gobject);
+
+ /* guard against reinvocations during
+ * destruction with the GTK_IN_DESTRUCTION flag.
+ */
+ if (!(GTK_OBJECT_FLAGS (object) & GTK_IN_DESTRUCTION))
+ {
+ GTK_OBJECT_SET_FLAGS (object, GTK_IN_DESTRUCTION);
+
+ g_signal_emit (object, object_signals[DESTROY], 0);
+
+ GTK_OBJECT_UNSET_FLAGS (object, GTK_IN_DESTRUCTION);
+ }
+
+ G_OBJECT_CLASS (parent_class)->dispose (gobject);
}
static void
gtk_object_real_destroy (GtkObject *object)
{
- if (GTK_OBJECT_CONNECTED (object))
- gtk_signal_handlers_destroy (object);
+ g_signal_handlers_destroy (object);
}
static void
-gtk_object_finalize (GtkObject *object)
+gtk_object_finalize (GObject *gobject)
{
- gtk_object_notify_weaks (object);
+ GtkObject *object = GTK_OBJECT (gobject);
- while (object->object_data)
+ if (g_object_is_floating (object))
{
- GtkObjectData *odata;
-
- odata = object->object_data;
- object->object_data = odata->next;
- GTK_OBJECT_DATA_DESTROY (odata);
+ g_warning ("A floating object was finalized. This means that someone\n"
+ "called g_object_unref() on an object that had only a floating\n"
+ "reference; the initial floating reference is not owned by anyone\n"
+ "and must be removed with g_object_ref_sink().");
}
- gtk_type_free (GTK_OBJECT_TYPE (object), object);
+ gtk_object_notify_weaks (object);
+
+ G_OBJECT_CLASS (parent_class)->finalize (gobject);
}
/*****************************************
*****************************************/
static void
-gtk_object_set_arg (GtkObject *object,
- GtkArg *arg,
- guint arg_id)
+gtk_object_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- switch (arg_id)
+ switch (property_id)
{
- case ARG_USER_DATA:
- gtk_object_set_user_data (object, GTK_VALUE_POINTER (*arg));
- break;
- case ARG_SIGNAL:
- if ((arg->name[9 + 2 + 6] != ':') || (arg->name[9 + 2 + 7] != ':'))
- {
- g_warning ("invalid signal argument: \"%s\"\n", arg->name);
- arg->type = GTK_TYPE_INVALID;
- return;
- }
- gtk_signal_connect (object, arg->name + 9 + 2 + 6 + 2,
- (GtkSignalFunc) GTK_VALUE_SIGNAL (*arg).f,
- GTK_VALUE_SIGNAL (*arg).d);
- break;
- case ARG_OBJECT_SIGNAL:
- if ((arg->name[9 + 2 + 13] != ':') || (arg->name[9 + 2 + 14] != ':'))
- {
- g_warning ("invalid signal argument: \"%s\"\n", arg->name);
- arg->type = GTK_TYPE_INVALID;
- return;
- }
- gtk_signal_connect_object (object, arg->name + 9 + 2 + 13 + 2,
- (GtkSignalFunc) GTK_VALUE_SIGNAL (*arg).f,
- (GtkObject*) GTK_VALUE_SIGNAL (*arg).d);
+ case PROP_USER_DATA:
+ g_object_set_data (G_OBJECT (object), I_("user_data"), g_value_get_pointer (value));
break;
default:
- arg->type = GTK_TYPE_INVALID;
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
-gtk_object_get_arg (GtkObject *object,
- GtkArg *arg,
- guint arg_id)
+gtk_object_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- switch (arg_id)
+ switch (property_id)
{
- case ARG_USER_DATA:
- GTK_VALUE_POINTER (*arg) = gtk_object_get_user_data (object);
+ case PROP_USER_DATA:
+ g_value_set_pointer (value, g_object_get_data (G_OBJECT (object), "user_data"));
break;
- case ARG_SIGNAL:
- case ARG_OBJECT_SIGNAL:
default:
- arg->type = GTK_TYPE_INVALID;
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
-/*****************************************
- * gtk_object_class_add_signals:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_object_class_add_signals (GtkObjectClass *class,
- guint *signals,
- guint nsignals)
-{
- guint *new_signals;
- guint i;
-
- g_return_if_fail (class != NULL);
-
- new_signals = g_new (guint, class->nsignals + nsignals);
- for (i = 0; i < class->nsignals; i++)
- new_signals[i] = class->signals[i];
- for (i = 0; i < nsignals; i++)
- new_signals[class->nsignals + i] = signals[i];
-
- g_free (class->signals);
- class->signals = new_signals;
- class->nsignals += nsignals;
-}
-
-guint
-gtk_object_class_add_user_signal (GtkObjectClass *class,
- const gchar *name,
- GtkSignalMarshaller marshaller,
- GtkType return_val,
- guint nparams,
- ...)
-{
- GtkType *params;
- guint i;
- va_list args;
- guint signal_id;
-
- g_return_val_if_fail (class != NULL, 0);
-
- if (nparams > 0)
- {
- params = g_new (GtkType, nparams);
-
- va_start (args, nparams);
-
- for (i = 0; i < nparams; i++)
- params[i] = va_arg (args, GtkType);
-
- va_end (args);
- }
- else
- params = NULL;
-
- signal_id = gtk_signal_newv (name,
- 0,
- class->type,
- 0,
- marshaller,
- return_val,
- nparams,
- params);
-
- g_free (params);
-
- if (signal_id)
- gtk_object_class_add_signals (class, &signal_id, 1);
-
- return signal_id;
-}
-
-guint
-gtk_object_class_add_user_signal_no_recurse (GtkObjectClass *class,
- const gchar *name,
- GtkSignalMarshaller marshaller,
- GtkType return_val,
- guint nparams,
- ...)
-{
- GtkType *params;
- guint i;
- va_list args;
- guint signal_id;
-
- g_return_val_if_fail (class != NULL, 0);
-
- if (nparams > 0)
- {
- params = g_new (GtkType, nparams);
-
- va_start (args, nparams);
-
- for (i = 0; i < nparams; i++)
- params[i] = va_arg (args, GtkType);
-
- va_end (args);
- }
- else
- params = NULL;
-
- signal_id = gtk_signal_newv (name,
- GTK_RUN_NO_RECURSE,
- class->type,
- 0,
- marshaller,
- return_val,
- nparams,
- params);
-
- g_free (params);
-
- if (signal_id)
- gtk_object_class_add_signals (class, &signal_id, 1);
-
- return signal_id;
-}
-
-/*****************************************
- * gtk_object_sink:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
void
gtk_object_sink (GtkObject *object)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
-
- if (GTK_OBJECT_FLOATING (object))
- {
- GTK_OBJECT_UNSET_FLAGS (object, GTK_FLOATING);
- gtk_object_unref (object);
- }
+ g_object_ref_sink (object);
+ g_object_unref (object);
}
/*****************************************
{
GtkWeakRef *weak;
- g_return_if_fail (object != NULL);
g_return_if_fail (notify != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!weakrefs_key_id)
- weakrefs_key_id = gtk_object_data_force_id (weakrefs_key);
+ if (!quark_weakrefs)
+ quark_weakrefs = g_quark_from_static_string ("gtk-weakrefs");
weak = g_new (GtkWeakRef, 1);
- weak->next = gtk_object_get_data_by_id (object, weakrefs_key_id);
+ weak->next = g_object_get_qdata (G_OBJECT (object), quark_weakrefs);
weak->notify = notify;
weak->data = data;
- gtk_object_set_data_by_id (object, weakrefs_key_id, weak);
+ g_object_set_qdata (G_OBJECT (object), quark_weakrefs, weak);
}
void
{
GtkWeakRef *weaks, *w, **wp;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!weakrefs_key_id)
+ if (!quark_weakrefs)
return;
- weaks = gtk_object_get_data_by_id (object, weakrefs_key_id);
+ weaks = g_object_get_qdata (G_OBJECT (object), quark_weakrefs);
for (wp = &weaks; *wp; wp = &(*wp)->next)
{
w = *wp;
if (w->notify == notify && w->data == data)
{
if (w == weaks)
- gtk_object_set_data_by_id (object, weakrefs_key_id, w->next);
+ g_object_set_qdata (G_OBJECT (object), quark_weakrefs, w->next);
else
*wp = w->next;
g_free (w);
static void
gtk_object_notify_weaks (GtkObject *object)
{
- if (weakrefs_key_id)
+ if (quark_weakrefs)
{
GtkWeakRef *w1, *w2;
- w1 = gtk_object_get_data_by_id (object, weakrefs_key_id);
+ w1 = g_object_get_qdata (G_OBJECT (object), quark_weakrefs);
while (w1)
{
}
}
-/*****************************************
- * gtk_object_new:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
GtkObject*
-gtk_object_new (GtkType type,
+gtk_object_new (GtkType object_type,
+ const gchar *first_property_name,
...)
{
- GtkObject *obj;
- GtkArg *args;
- guint nargs;
- va_list args1;
- va_list args2;
-
- obj = gtk_type_new (type);
-
- va_start (args1, type);
- va_start (args2, type);
-
- args = gtk_object_collect_args (&nargs, args1, args2);
- gtk_object_setv (obj, nargs, args);
- g_free (args);
-
- va_end (args1);
- va_end (args2);
-
- return obj;
-}
-
-/*****************************************
- * gtk_object_newv:
- *
- * arguments:
- *
- * results:
- *****************************************/
+ GtkObject *object;
+ va_list var_args;
-GtkObject*
-gtk_object_newv (GtkType type,
- guint nargs,
- GtkArg *args)
-{
- gpointer obj;
+ g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL);
- obj = gtk_type_new (type);
- gtk_object_setv (obj, nargs, args);
+ va_start (var_args, first_property_name);
+ object = (GtkObject *)g_object_new_valist (object_type, first_property_name, var_args);
+ va_end (var_args);
- return obj;
+ return object;
}
-/*****************************************
- * gtk_object_getv:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
void
-gtk_object_getv (GtkObject *object,
- guint nargs,
- GtkArg *args)
+gtk_object_get (GtkObject *object,
+ const gchar *first_property_name,
+ ...)
{
- guint i;
+ va_list var_args;
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- if (!arg_info_ht)
- return;
-
- for (i = 0; i < nargs; i++)
- {
- GtkArgInfo *info;
- gchar *lookup_name;
- gchar *d;
-
-
- /* hm, the name cutting shouldn't be needed on gets, but what the heck...
- */
- lookup_name = g_strdup (args[i].name);
- d = strchr (lookup_name, ':');
- if (d && d[1] == ':')
- {
- d = strchr (d + 2, ':');
- if (d)
- *d = 0;
-
- info = g_hash_table_lookup (arg_info_ht, lookup_name);
- }
- else
- info = NULL;
-
- if (!info)
- {
- g_warning ("invalid arg name: \"%s\"\n", lookup_name);
- args[i].type = GTK_TYPE_INVALID;
- g_free (lookup_name);
- continue;
- }
- else if (!gtk_type_is_a (object->klass->type, info->class_type))
- {
- g_warning ("invalid arg for %s: \"%s\"\n", gtk_type_name (object->klass->type), lookup_name);
- args[i].type = GTK_TYPE_INVALID;
- g_free (lookup_name);
- continue;
- }
- else if (! (info->arg_flags & GTK_ARG_READABLE))
- {
- g_warning ("arg is not supplied for read-access: \"%s\"\n", lookup_name);
- args[i].type = GTK_TYPE_INVALID;
- g_free (lookup_name);
- continue;
- }
- else
- g_free (lookup_name);
-
- args[i].type = info->type;
- gtk_type_get_arg (object, info->class_type, &args[i], info->arg_id);
- }
+ va_start (var_args, first_property_name);
+ g_object_get_valist (G_OBJECT (object), first_property_name, var_args);
+ va_end (var_args);
}
-/*****************************************
- * gtk_object_query_args:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-struct _GtkQueryArgData
-{
- GList *arg_list;
- GtkType class_type;
-};
-typedef struct _GtkQueryArgData GtkQueryArgData;
-
-static void
-gtk_query_arg_foreach (gpointer key,
- gpointer value,
- gpointer user_data)
-{
- register GtkArgInfo *info;
- register GtkQueryArgData *data;
-
- info = value;
- data = user_data;
-
- if (info->class_type == data->class_type)
- data->arg_list = g_list_prepend (data->arg_list, info);
-}
-
-GtkArg*
-gtk_object_query_args (GtkType class_type,
- guint32 **arg_flags,
- guint *nargs)
-{
- GtkArg *args;
- GtkQueryArgData query_data;
-
- if (arg_flags)
- *arg_flags = NULL;
- g_return_val_if_fail (nargs != NULL, NULL);
- *nargs = 0;
- g_return_val_if_fail (gtk_type_is_a (class_type, gtk_object_get_type ()), NULL);
-
- if (!arg_info_ht)
- return NULL;
-
- /* make sure the types class has been initialized, because
- * the argument setup happens in the gtk_*_class_init() functions.
- */
- gtk_type_class (class_type);
-
- query_data.arg_list = NULL;
- query_data.class_type = class_type;
- g_hash_table_foreach (arg_info_ht, gtk_query_arg_foreach, &query_data);
-
- if (query_data.arg_list)
- {
- register GList *list;
- register guint len;
-
- list = query_data.arg_list;
- len = 1;
- while (list->next)
- {
- len++;
- list = list->next;
- }
- g_assert (len == ((GtkObjectClass*) gtk_type_class (class_type))->n_args); /* paranoid */
-
- args = g_new0 (GtkArg, len);
- *nargs = len;
- if (arg_flags)
- *arg_flags = g_new (guint32, len);
-
- do
- {
- GtkArgInfo *info;
-
- info = list->data;
- list = list->prev;
-
- g_assert (info->seq_id > 0 && info->seq_id <= len); /* paranoid */
-
- args[info->seq_id - 1].type = info->type;
- args[info->seq_id - 1].name = info->name;
- if (arg_flags)
- (*arg_flags)[info->seq_id - 1] = info->arg_flags;
- }
- while (list);
-
- g_list_free (query_data.arg_list);
- }
- else
- args = NULL;
-
- return args;
-}
-
-/*****************************************
- * gtk_object_set:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
void
-gtk_object_set (GtkObject *object,
+gtk_object_set (GtkObject *object,
+ const gchar *first_property_name,
...)
{
- GtkArg *args;
- guint nargs;
- va_list args1;
- va_list args2;
-
- g_return_if_fail (object != NULL);
-
- va_start (args1, object);
- va_start (args2, object);
-
- args = gtk_object_collect_args (&nargs, args1, args2);
- gtk_object_setv (object, nargs, args);
- g_free (args);
-
- va_end (args1);
- va_end (args2);
-}
-
-/*****************************************
- * gtk_object_setv:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_object_setv (GtkObject *object,
- guint nargs,
- GtkArg *args)
-{
- guint i;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_OBJECT (object));
-
- if (!arg_info_ht)
- return;
-
- for (i = 0; i < nargs; i++)
- {
- GtkArgInfo *info;
- gchar *lookup_name;
- gchar *d;
- gboolean arg_ok;
-
- lookup_name = g_strdup (args[i].name);
- d = strchr (lookup_name, ':');
- if (d && d[1] == ':')
- {
- d = strchr (d + 2, ':');
- if (d)
- *d = 0;
-
- info = g_hash_table_lookup (arg_info_ht, lookup_name);
- }
- else
- info = NULL;
-
- arg_ok = TRUE;
-
- if (!info)
- {
- g_warning ("invalid arg name: \"%s\"\n", lookup_name);
- arg_ok = FALSE;
- }
- else if (info->type != args[i].type)
- {
- g_warning ("invalid arg type for: \"%s\"\n", lookup_name);
- arg_ok = FALSE;
- }
- else if (!gtk_type_is_a (object->klass->type, info->class_type))
- {
- g_warning ("invalid arg for %s: \"%s\"\n", gtk_type_name (object->klass->type), lookup_name);
- arg_ok = FALSE;
- }
- else if (! (info->arg_flags & GTK_ARG_WRITABLE))
- {
- g_warning ("arg is not supplied for write-access: \"%s\"\n", lookup_name);
- arg_ok = FALSE;
- }
-
- g_free (lookup_name);
-
- if (!arg_ok)
- continue;
-
- gtk_type_set_arg (object, info->class_type, &args[i], info->arg_id);
- }
-}
-
-/*****************************************
- * gtk_object_add_arg_type:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-void
-gtk_object_add_arg_type (const char *arg_name,
- GtkType arg_type,
- guint arg_flags,
- guint arg_id)
-{
- GtkArgInfo *info;
- gchar class_part[1024];
- gchar *arg_part;
- GtkType class_type;
-
- g_return_if_fail (arg_name != NULL);
- g_return_if_fail (arg_type > GTK_TYPE_NONE);
- g_return_if_fail (arg_id > 0);
- g_return_if_fail ((arg_flags & GTK_ARG_READWRITE) != 0);
+ va_list var_args;
- arg_part = strchr (arg_name, ':');
- if (!arg_part || (arg_part[0] != ':') || (arg_part[1] != ':'))
- {
- g_warning ("invalid arg name: \"%s\"\n", arg_name);
- return;
- }
-
- strncpy (class_part, arg_name, (glong) (arg_part - arg_name));
- class_part[(glong) (arg_part - arg_name)] = '\0';
-
- class_type = gtk_type_from_name (class_part);
- if (!class_type)
- {
- g_warning ("invalid class name in arg: \"%s\"\n", arg_name);
- return;
- }
-
- info = g_new (GtkArgInfo, 1);
- info->name = g_strdup (arg_name);
- info->type = arg_type;
- info->class_type = class_type;
- info->arg_flags = arg_flags & (GTK_ARG_READABLE | GTK_ARG_WRITABLE);
- info->arg_id = arg_id;
- info->seq_id = ++((GtkObjectClass*) gtk_type_class (class_type))->n_args;
-
- if (!arg_info_ht)
- arg_info_ht = g_hash_table_new (g_str_hash, g_str_equal);
-
- g_hash_table_insert (arg_info_ht, info->name, info);
-}
-
-/*****************************************
- * gtk_object_get_arg_type:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-GtkType
-gtk_object_get_arg_type (const gchar *arg_name)
-{
- GtkArgInfo *info;
- gchar buffer[1024];
- gchar *t;
-
- g_return_val_if_fail (arg_name != NULL, 0);
-
- if (!arg_info_ht)
- return GTK_TYPE_INVALID;
-
- if (!arg_name || strlen (arg_name) > 1000)
- {
- /* security audit
- */
- g_warning ("gtk_object_get_arg_type(): argument `arg_name' exceeds maximum size.");
- return 0;
- }
-
- t = strchr (arg_name, ':');
- if (!t || (t[0] != ':') || (t[1] != ':'))
- {
- g_warning ("invalid arg name: \"%s\"\n", arg_name);
- return GTK_TYPE_INVALID;
- }
-
- t = strchr (t + 2, ':');
- if (t)
- {
- strncpy (buffer, arg_name, (long) (t - arg_name));
- buffer[(long) (t - arg_name)] = '\0';
- arg_name = buffer;
- }
-
- info = g_hash_table_lookup (arg_info_ht, (gpointer) arg_name);
- if (info)
- return info->type;
-
- return GTK_TYPE_INVALID;
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ va_start (var_args, first_property_name);
+ g_object_set_valist (G_OBJECT (object), first_property_name, var_args);
+ va_end (var_args);
}
/*****************************************
void
gtk_object_set_data_by_id (GtkObject *object,
- guint data_id,
+ GQuark data_id,
gpointer data)
{
- g_return_if_fail (data_id > 0);
+ g_return_if_fail (GTK_IS_OBJECT (object));
- gtk_object_set_data_by_id_full (object, data_id, data, NULL);
+ g_datalist_id_set_data (&G_OBJECT (object)->qdata, data_id, data);
}
void
const gchar *key,
gpointer data)
{
+ g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- gtk_object_set_data_by_id_full (object, gtk_object_data_force_id (key), data, NULL);
+ g_datalist_set_data (&G_OBJECT (object)->qdata, key, data);
}
void
gtk_object_set_data_by_id_full (GtkObject *object,
- guint data_id,
+ GQuark data_id,
gpointer data,
GtkDestroyNotify destroy)
{
- GtkObjectData *odata;
-
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
- g_return_if_fail (data_id > 0);
- odata = object->object_data;
- if (!data)
- {
- GtkObjectData *prev;
-
- prev = NULL;
-
- while (odata)
- {
- if (odata->id == data_id)
- {
- if (prev)
- prev->next = odata->next;
- else
- object->object_data = odata->next;
-
- GTK_OBJECT_DATA_DESTROY (odata);
- break;
- }
-
- prev = odata;
- odata = odata->next;
- }
- }
- else
- {
- GtkObjectData *prev;
-
- prev = NULL;
-
- while (odata)
- {
- if (odata->id == data_id)
- {
- /* we need to be unlinked while invoking the destroy function
- */
- if (odata->destroy)
- {
- if (prev)
- prev->next = odata->next;
- else
- object->object_data = odata->next;
-
- odata->destroy (odata->data);
-
- odata->next = object->object_data;
- object->object_data = odata;
- }
-
- odata->data = data;
- odata->destroy = destroy;
- return;
- }
-
- prev = odata;
- odata = prev->next;
- }
-
- if (gtk_object_data_free_list)
- {
- odata = gtk_object_data_free_list;
- gtk_object_data_free_list = odata->next;
- }
- else
- {
- GtkObjectData *odata_block;
- guint i;
-
- odata_block = g_new0 (GtkObjectData, GTK_OBJECT_DATA_BLOCK_SIZE);
- for (i = 1; i < GTK_OBJECT_DATA_BLOCK_SIZE; i++)
- {
- (odata_block + i)->next = gtk_object_data_free_list;
- gtk_object_data_free_list = (odata_block + i);
- }
-
- odata = odata_block;
- }
-
- odata->id = data_id;
- odata->data = data;
- odata->destroy = destroy;
- odata->next = object->object_data;
-
- object->object_data = odata;
- }
+ g_datalist_id_set_data_full (&G_OBJECT (object)->qdata, data_id, data, destroy);
}
void
gpointer data,
GtkDestroyNotify destroy)
{
+ g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- gtk_object_set_data_by_id_full (object, gtk_object_data_force_id (key), data, destroy);
+ g_datalist_set_data_full (&G_OBJECT (object)->qdata, key, data, destroy);
}
gpointer
gtk_object_get_data_by_id (GtkObject *object,
- guint data_id)
+ GQuark data_id)
{
- GtkObjectData *odata;
-
- g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- if (data_id)
- {
- odata = object->object_data;
- while (odata)
- {
- if (odata->id == data_id)
- return odata->data;
- odata = odata->next;
- }
- }
-
- return NULL;
+ return g_datalist_id_get_data (&G_OBJECT (object)->qdata, data_id);
}
gpointer
gtk_object_get_data (GtkObject *object,
const gchar *key)
{
- guint id;
-
+ g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
g_return_val_if_fail (key != NULL, NULL);
- id = gtk_object_data_try_key (key);
- if (id)
- return gtk_object_get_data_by_id (object, id);
-
- return NULL;
+ return g_datalist_get_data (&G_OBJECT (object)->qdata, key);
}
void
gtk_object_remove_data_by_id (GtkObject *object,
- guint data_id)
+ GQuark data_id)
{
- if (data_id)
- gtk_object_set_data_by_id_full (object, data_id, NULL, NULL);
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ g_datalist_id_remove_data (&G_OBJECT (object)->qdata, data_id);
}
void
gtk_object_remove_data (GtkObject *object,
const gchar *key)
{
- gint id;
-
+ g_return_if_fail (GTK_IS_OBJECT (object));
g_return_if_fail (key != NULL);
- id = gtk_object_data_try_key (key);
- if (id)
- gtk_object_set_data_by_id_full (object, id, NULL, NULL);
+ g_datalist_remove_data (&G_OBJECT (object)->qdata, key);
}
-/*****************************************
- * gtk_object_set_user_data:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
void
-gtk_object_set_user_data (GtkObject *object,
- gpointer data)
+gtk_object_remove_no_notify_by_id (GtkObject *object,
+ GQuark key_id)
{
- if (!user_data_key_id)
- user_data_key_id = gtk_object_data_force_id (user_data_key);
-
- gtk_object_set_data_by_id_full (object, user_data_key_id, data, NULL);
-}
-
-/*****************************************
- * gtk_object_get_user_data:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-gpointer
-gtk_object_get_user_data (GtkObject *object)
-{
- if (user_data_key_id)
- return gtk_object_get_data_by_id (object, user_data_key_id);
+ g_return_if_fail (GTK_IS_OBJECT (object));
- return NULL;
+ g_datalist_id_remove_no_notify (&G_OBJECT (object)->qdata, key_id);
}
-/*****************************************
- * gtk_object_check_cast:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-static gchar*
-gtk_object_descriptive_type_name (GtkType type)
+void
+gtk_object_remove_no_notify (GtkObject *object,
+ const gchar *key)
{
- gchar *name;
-
- name = gtk_type_name (type);
- if (!name)
- name = "(unknown)";
-
- return name;
-}
+ g_return_if_fail (GTK_IS_OBJECT (object));
+ g_return_if_fail (key != NULL);
-GtkObject*
-gtk_object_check_cast (GtkObject *obj,
- GtkType cast_type)
-{
- if (!obj)
- {
- g_warning ("invalid cast from (NULL) pointer to `%s'",
- gtk_object_descriptive_type_name (cast_type));
- return obj;
- }
- if (!obj->klass)
- {
- g_warning ("invalid unclassed pointer in cast to `%s'",
- gtk_object_descriptive_type_name (cast_type));
- return obj;
- }
- if (obj->klass->type < GTK_TYPE_OBJECT)
- {
- g_warning ("invalid class type `%s' in cast to `%s'",
- gtk_object_descriptive_type_name (obj->klass->type),
- gtk_object_descriptive_type_name (cast_type));
- return obj;
- }
- if (!gtk_type_is_a (obj->klass->type, cast_type))
- {
- g_warning ("invalid cast from `%s' to `%s'",
- gtk_object_descriptive_type_name (obj->klass->type),
- gtk_object_descriptive_type_name (cast_type));
- return obj;
- }
-
- return obj;
+ g_datalist_remove_no_notify (&G_OBJECT (object)->qdata, key);
}
-/*****************************************
- * gtk_object_check_class_cast:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-GtkObjectClass*
-gtk_object_check_class_cast (GtkObjectClass *klass,
- GtkType cast_type)
+void
+gtk_object_set_user_data (GtkObject *object,
+ gpointer data)
{
- if (!klass)
- {
- g_warning ("invalid class cast from (NULL) pointer to `%s'",
- gtk_object_descriptive_type_name (cast_type));
- return klass;
- }
- if (klass->type < GTK_TYPE_OBJECT)
- {
- g_warning ("invalid class type `%s' in class cast to `%s'",
- gtk_object_descriptive_type_name (klass->type),
- gtk_object_descriptive_type_name (cast_type));
- return klass;
- }
- if (!gtk_type_is_a (klass->type, cast_type))
- {
- g_warning ("invalid class cast from `%s' to `%s'",
- gtk_object_descriptive_type_name (klass->type),
- gtk_object_descriptive_type_name (cast_type));
- return klass;
- }
+ g_return_if_fail (GTK_IS_OBJECT (object));
- return klass;
+ g_object_set_data (G_OBJECT (object), "user_data", data);
}
-/*****************************************
- * gtk_object_collect_args:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
-GtkArg*
-gtk_object_collect_args (guint *nargs,
- va_list args1,
- va_list args2)
+gpointer
+gtk_object_get_user_data (GtkObject *object)
{
- GtkArg *args;
- GtkType type;
- gchar *name;
- gint done;
- gint i, n;
-
- n = 0;
- done = FALSE;
-
- while (!done)
- {
- name = va_arg (args1, char *);
- if (!name)
- {
- done = TRUE;
- continue;
- }
-
- type = gtk_object_get_arg_type (name);
-
- switch (GTK_FUNDAMENTAL_TYPE (type))
- {
- case GTK_TYPE_INVALID:
- g_warning ("invalid arg name: \"%s\" %x\n", name, type);
- (void) va_arg (args1, long);
- continue;
- case GTK_TYPE_NONE:
- break;
- case GTK_TYPE_CHAR:
- case GTK_TYPE_BOOL:
- case GTK_TYPE_INT:
- case GTK_TYPE_UINT:
- case GTK_TYPE_ENUM:
- case GTK_TYPE_FLAGS:
- (void) va_arg (args1, gint);
- break;
- case GTK_TYPE_LONG:
- case GTK_TYPE_ULONG:
- (void) va_arg (args1, glong);
- break;
- case GTK_TYPE_FLOAT:
- (void) va_arg (args1, gfloat);
- break;
- case GTK_TYPE_DOUBLE:
- (void) va_arg (args1, gdouble);
- break;
- case GTK_TYPE_STRING:
- (void) va_arg (args1, gchar*);
- break;
- case GTK_TYPE_POINTER:
- case GTK_TYPE_BOXED:
- (void) va_arg (args1, gpointer);
- break;
- case GTK_TYPE_SIGNAL:
- (void) va_arg (args1, GtkFunction);
- (void) va_arg (args1, gpointer);
- break;
- case GTK_TYPE_FOREIGN:
- (void) va_arg (args1, gpointer);
- (void) va_arg (args1, GtkDestroyNotify);
- break;
- case GTK_TYPE_CALLBACK:
- (void) va_arg (args1, GtkCallbackMarshal);
- (void) va_arg (args1, gpointer);
- (void) va_arg (args1, GtkDestroyNotify);
- break;
- case GTK_TYPE_C_CALLBACK:
- (void) va_arg (args1, GtkFunction);
- (void) va_arg (args1, gpointer);
- break;
- case GTK_TYPE_ARGS:
- (void) va_arg (args1, gint);
- (void) va_arg (args1, GtkArg*);
- break;
- case GTK_TYPE_OBJECT:
- (void) va_arg (args1, GtkObject*);
- break;
- default:
- g_error ("unsupported type %s in args", gtk_type_name (type));
- break;
- }
-
- n += 1;
- }
-
- *nargs = n;
- args = NULL;
-
- if (n > 0)
- {
- args = g_new0 (GtkArg, n);
-
- for (i = 0; i < n; i++)
- {
- args[i].name = va_arg (args2, char *);
- args[i].type = gtk_object_get_arg_type (args[i].name);
-
- switch (GTK_FUNDAMENTAL_TYPE (args[i].type))
- {
- case GTK_TYPE_INVALID:
- (void) va_arg (args2, long);
- i -= 1;
- continue;
- case GTK_TYPE_NONE:
- break;
- case GTK_TYPE_CHAR:
- GTK_VALUE_CHAR(args[i]) = va_arg (args2, gint);
- break;
- case GTK_TYPE_BOOL:
- GTK_VALUE_BOOL(args[i]) = va_arg (args2, gint);
- break;
- case GTK_TYPE_INT:
- GTK_VALUE_INT(args[i]) = va_arg (args2, gint);
- break;
- case GTK_TYPE_UINT:
- GTK_VALUE_UINT(args[i]) = va_arg (args2, guint);
- break;
- case GTK_TYPE_ENUM:
- GTK_VALUE_ENUM(args[i]) = va_arg (args2, gint);
- break;
- case GTK_TYPE_FLAGS:
- GTK_VALUE_FLAGS(args[i]) = va_arg (args2, gint);
- break;
- case GTK_TYPE_LONG:
- GTK_VALUE_LONG(args[i]) = va_arg (args2, glong);
- break;
- case GTK_TYPE_ULONG:
- GTK_VALUE_ULONG(args[i]) = va_arg (args2, gulong);
- break;
- case GTK_TYPE_FLOAT:
- GTK_VALUE_FLOAT(args[i]) = va_arg (args2, gfloat);
- break;
- case GTK_TYPE_DOUBLE:
- GTK_VALUE_DOUBLE(args[i]) = va_arg (args2, gdouble);
- break;
- case GTK_TYPE_STRING:
- GTK_VALUE_STRING(args[i]) = va_arg (args2, gchar*);
- break;
- case GTK_TYPE_POINTER:
- GTK_VALUE_POINTER(args[i]) = va_arg (args2, gpointer);
- break;
- case GTK_TYPE_BOXED:
- GTK_VALUE_BOXED(args[i]) = va_arg (args2, gpointer);
- break;
- case GTK_TYPE_SIGNAL:
- GTK_VALUE_SIGNAL(args[i]).f = va_arg (args2, GtkFunction);
- GTK_VALUE_SIGNAL(args[i]).d = va_arg (args2, gpointer);
- break;
- case GTK_TYPE_FOREIGN:
- GTK_VALUE_FOREIGN(args[i]).data = va_arg (args2, gpointer);
- GTK_VALUE_FOREIGN(args[i]).notify =
- va_arg (args2, GtkDestroyNotify);
- break;
- case GTK_TYPE_CALLBACK:
- GTK_VALUE_CALLBACK(args[i]).marshal =
- va_arg (args2, GtkCallbackMarshal);
- GTK_VALUE_CALLBACK(args[i]).data = va_arg (args2, gpointer);
- GTK_VALUE_CALLBACK(args[i]).notify =
- va_arg (args2, GtkDestroyNotify);
- break;
- case GTK_TYPE_C_CALLBACK:
- GTK_VALUE_C_CALLBACK(args[i]).func = va_arg (args2, GtkFunction);
- GTK_VALUE_C_CALLBACK(args[i]).func_data =
- va_arg (args2, gpointer);
- break;
- case GTK_TYPE_ARGS:
- GTK_VALUE_ARGS(args[i]).n_args = va_arg (args2, gint);
- GTK_VALUE_ARGS(args[i]).args = va_arg (args2, GtkArg*);
- break;
- case GTK_TYPE_OBJECT:
- GTK_VALUE_OBJECT(args[i]) = va_arg (args2, GtkObject*);
- g_assert (GTK_VALUE_OBJECT(args[i]) == NULL ||
- GTK_CHECK_TYPE (GTK_VALUE_OBJECT(args[i]),
- args[i].type));
- break;
- default:
- g_error ("unsupported type %s in args",
- gtk_type_name (args[i].type));
- break;
- }
- }
- }
+ g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- return args;
+ return g_object_get_data (G_OBJECT (object), "user_data");
}
-
-
-#undef gtk_object_ref
-#undef gtk_object_unref
-
-void
+GtkObject*
gtk_object_ref (GtkObject *object)
{
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_OBJECT (object));
+ g_return_val_if_fail (GTK_IS_OBJECT (object), NULL);
- object->ref_count += 1;
+ return (GtkObject*) g_object_ref ((GObject*) object);
}
void
gtk_object_unref (GtkObject *object)
{
- g_return_if_fail (object != NULL);
g_return_if_fail (GTK_IS_OBJECT (object));
-
- if (object->ref_count == 1)
- gtk_object_destroy (object);
-
- if (object->ref_count > 0)
- object->ref_count -= 1;
- if (object->ref_count == 0)
- {
-#ifdef G_ENABLE_DEBUG
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- {
- g_assert (g_hash_table_lookup (living_objs_ht, object) == object);
- g_hash_table_remove (living_objs_ht, object);
- obj_count--;
- }
-#endif /* G_ENABLE_DEBUG */
- object->klass->finalize (object);
- }
+ g_object_unref ((GObject*) object);
}
-static GtkObject *gtk_trace_object = NULL;
-void
-gtk_trace_referencing (GtkObject *object,
- const gchar *func,
- guint dummy,
- guint line,
- gboolean do_ref)
-{
- if (gtk_debug_flags & GTK_DEBUG_OBJECTS)
- {
- gboolean exists = TRUE;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_IS_OBJECT (object));
-
-#ifdef G_ENABLE_DEBUG
- exists = g_hash_table_lookup (living_objs_ht, object) != NULL;
-#endif /* G_ENABLE_DEBUG */
-
- if (exists &&
- (object == gtk_trace_object ||
- gtk_trace_object == (void*)42))
- fprintf (stdout, "trace: object_%s: (%s:%p)->ref_count=%d %s (%s:%d)\n",
- do_ref ? "ref" : "unref",
- gtk_type_name (GTK_OBJECT_TYPE (object)),
- object,
- object->ref_count,
- do_ref ? "+ 1" : "- 1",
- func,
- line);
- else if (!exists)
- fprintf (stdout, "trace: object_%s(%p): no such object! (%s:%d)\n",
- do_ref ? "ref" : "unref",
- object,
- func,
- line);
- }
-
- if (do_ref)
- gtk_object_ref (object);
- else
- gtk_object_unref (object);
-}
+#define __GTK_OBJECT_C__
+#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff