GtkObject

Description

GtkObject is the root of the gtk+ type hierarchy. It serves a similar roles as java's Object class. It is used by the type-casting system to represent the base composite type.

Objects have arguments that are name/typed-value pairs. They may be readable or writable (or both or neither). The special handlers in every object are responsible for setting and getting these parameters. If the handler for a given argument must be called before the object may be used, be sure the GTK_ARG_CONSTRUCT or GTK_ARG_CONSTRUCT_ONLY flags are set; otherwise they are set only when the user does so.

Object also store a simpler association table, sometimes called the object_data. This is just an efficient mapping from a fixed set of strings to a gpointer. This can be used as arbitrary extra members. Notice that each new field name allocates a new quark, so it is probably best only to use this for fields with fixed names.

The primary difference between object_data and arguments is that the object defines two functions which set and get each type of argument. The object just has a table to store its object data in: it does not receive notice when data changes.

Objects are reference counted; this means that we maintain a count of how many references (usually in the form of a pointer) are being held to this object. To indicate that you reference an object, call gtk_object_ref(). The object will not be freed until everyone calls gtk_object_unref().

In order to reduce the chances of a memory leak, gtk+ defines "floating objects". All objects created with gtk_object_new() start out floating with a reference count of 1. In order to reduce that initial reference count you should gtk_object_sink() them, but usually the parent widget you add the child to will sink the object.

So, because gtk_widget_set_parent() sinks the object from gtk_container_add(), there are no memory leaks in this code:

	button = gtk_button_new_with_label("Hi Mom!");
	gtk_container_add(GTK_CONTAINER(window), button);
	/* Button may not be used anymore since we don't retain a reference
	 * to it. */

	adjustment = (GtkAdjustment*) gtk_adjustment_new(0,10,0,0,0,0);
	gtk_range_set_adjustment(range1, adjustment);
	gtk_range_set_adjustment(range2, adjustment);

	adjustment = (GtkAdjustment*) gtk_adjustment_new(0,10,0,0,0,0);
	gtk_object_ref(GTK_OBJECT(adjustment));
	gtk_range_set_adjustment(range1, adjustment);
	gtk_range_set_adjustment(range1, another_adjustment);
	/* With the initial reference, `adjustment' would have
	 * been deleted as `range1' lost its reference to it. */
	gtk_range_set_adjustment(range2, adjustment);
	gtk_object_unref(GTK_OBJECT(adjustment));

Be careful with reference counting: if two objects reference eachother then they will always have at least reference count 1, even if there are no other pointers to them. This means that they will never be freed. More precisely, you must be certain that your references never can form cycles.

If you find yourself forming cyclic references, perhaps you can convert some of them to weak-references. A weak-reference is one that holds a pointer to an object, but doesn't increase the reference count. To insure the object is valid when the referer tries to use it, the referer registers a callback that will be invoked after the object has been destroyed (but before its memory is actually deallocated). This callback must prevent the weak-reference from being used again.

Brief Glossary

struct GtkObject

struct GtkObject;

The object itself. You should never use these members directly- instead you the accessing macros.

GTK_OBJECT_TYPE()

#define GTK_OBJECT_TYPE(obj)		  (GTK_OBJECT (obj)->klass->type)

Get the type of an object.

GTK_OBJECT_SIGNALS()

#define GTK_OBJECT_SIGNALS(obj)		  (GTK_OBJECT (obj)->klass->signals)

Get the array of signals defined for this object.

GTK_OBJECT_NSIGNALS()

#define GTK_OBJECT_NSIGNALS(obj)	  (GTK_OBJECT (obj)->klass->nsignals)

Get the number of signals defined by this object.

enum GtkObjectFlags

typedef enum
{
  GTK_DESTROYED		= 1 << 0,
  GTK_FLOATING		= 1 << 1,
  GTK_CONNECTED		= 1 << 2,
  GTK_CONSTRUCTED	= 1 << 3
} GtkObjectFlags;

Tells about the state of the object.

GTK_OBJECT_FLAGS()

#define GTK_OBJECT_FLAGS(obj)		  (GTK_OBJECT (obj)->flags)

Get the GtkObjectFlags for an object without directly accessing its members.

GTK_OBJECT_DESTROYED()

#define GTK_OBJECT_DESTROYED(obj)	  ((GTK_OBJECT_FLAGS (obj) & GTK_DESTROYED) != 0)

Test whether a GtkObject has had gtk_object_destroyed() invoked on it.

GTK_OBJECT_FLOATING()

#define GTK_OBJECT_FLOATING(obj)	  ((GTK_OBJECT_FLAGS (obj) & GTK_FLOATING) != 0)

When an object is created, it has an initial reference count of 1 and is floating. Sinking the object refers to decrementing that original reference count.

GTK_OBJECT_CONNECTED()

#define GTK_OBJECT_CONNECTED(obj)	  ((GTK_OBJECT_FLAGS (obj) & GTK_CONNECTED) != 0)

Test whether a GtkObject has had a signal connected to it.

GTK_OBJECT_CONSTRUCTED()

#define GTK_OBJECT_CONSTRUCTED(obj)	  ((GTK_OBJECT_FLAGS (obj) & GTK_CONSTRUCTED) != 0)

Test whether a GtkObject's arguments have been prepared.

GTK_OBJECT_SET_FLAGS()

#define GTK_OBJECT_SET_FLAGS(obj,flag)	  G_STMT_START{ (GTK_OBJECT_FLAGS (obj) |= (flag)); }G_STMT_END

Turn on certain object flags. (Private)

GTK_OBJECT_UNSET_FLAGS()

#define GTK_OBJECT_UNSET_FLAGS(obj,flag)  G_STMT_START{ (GTK_OBJECT_FLAGS (obj) &= ~(flag)); }G_STMT_END

Turn off certain object flags. (Private)

enum GtkArgFlags

typedef enum
{
  GTK_ARG_READABLE	 = 1 << 0,
  GTK_ARG_WRITABLE	 = 1 << 1,
  GTK_ARG_CONSTRUCT	 = 1 << 2,
  GTK_ARG_CONSTRUCT_ONLY = 1 << 3,
  GTK_ARG_CHILD_ARG	 = 1 << 4,
  GTK_ARG_MASK		 = 0x1f,
  
  /* aliases
   */
  GTK_ARG_READWRITE	 = GTK_ARG_READABLE | GTK_ARG_WRITABLE
} GtkArgFlags;

Possible flags indicating how an argument should be treated.

gtk_object_class_user_signal_new ()

guint       gtk_object_class_user_signal_new
                                            (GtkObjectClass *klass,
                                             const gchar *name,
                                             GtkSignalRunType signal_flags,
                                             GtkSignalMarshaller marshaller,
                                             GtkType return_val,
                                             guint nparams,
                                             ...);

Define a signal-handler for a new signal on an already defined object.

See the signal documentation for more general information.

gtk_object_class_user_signal_newv ()

guint       gtk_object_class_user_signal_newv
                                            (GtkObjectClass *klass,
                                             const gchar *name,
                                             GtkSignalRunType signal_flags,
                                             GtkSignalMarshaller marshaller,
                                             GtkType return_val,
                                             guint nparams,
                                             GtkType *params);

Define a signal-handler for a new signal on an already defined object.

gtk_object_new ()

GtkObject*  gtk_object_new                  (GtkType type,
                                             const gchar *first_arg_name,
                                             ...);

Construct an object given its arguments, enumerated in the call to the function.

gtk_object_newv ()

GtkObject*  gtk_object_newv                 (GtkType object_type,
                                             guint n_args,
                                             GtkArg *args);

Construct an object with an array of arguments.

gtk_object_constructed ()

void        gtk_object_constructed          (GtkObject *object);

Mark an allocated object as constructed. This is used for situations that require precise control of the construction process.

This is done when gtk_object_default_construct() is inadequate. In GtkCList the need arises because GtkCList does construction work that must happen after its derivers. This work cannot be done in an initializer function, so an alternate constructor is mandatory. It calls gtk_object_constructed() to indicate it has done its job, so that no other constructor will be invoked.

Normally this function is just automatically run from gtk_object_default_construct().

gtk_object_default_construct ()

void        gtk_object_default_construct    (GtkObject *object);

This function is called to construct arguments that haven't been initialized but have the GTK_ARG_CONSTRUCT flag set.

All number arguments are set to 0. All pointers and strings are set to NULL.

Normally invoked by gtk_object_new() automatically; gtk_type_new() can be used to bypass it.

gtk_object_sink ()

void        gtk_object_sink                 (GtkObject *object);

Decrement the initial count given to the object. Additional invocations have no effect.

This is designed to free the user from worrying about dereferencing an object that they have just created. So long as the object is sunk at some point, the reference count will be set properly.

furthermore it may be sunk multiple times. Only the first time will actually dereference.

The basic outline is: when you create an object it is floating. Setting its parent causes it to be sunk, however its parent has obtained a reference, so its reference count is one.

gtk_object_ref ()

void        gtk_object_ref                  (GtkObject *object);

Increase the reference count of the object.

gtk_object_unref ()

void        gtk_object_unref                (GtkObject *object);

Decrease the reference count of an object. When its reference count drops to 0, the object is deleted.

If it was not already destroyed, it will be, with gtk_object_destroy(), then weak links are notified, then the object-data is freed and the memory for the object itself is freed using gtk_type_free().

gtk_object_weakref ()

void        gtk_object_weakref              (GtkObject *object,
                                             GtkDestroyNotify notify,
                                             gpointer data);

Adds a weak reference callback to an object.

Weak references are a mechanism to safely keep a pointer to an object without using the reference counting mechansim. They use a callback function to receive notice that the object is about to be freed (aka finalized). This happens after the destroy callback has been run.

gtk_object_weakunref ()

void        gtk_object_weakunref            (GtkObject *object,
                                             GtkDestroyNotify notify,
                                             gpointer data);

Removes a weak reference callback to an object.

gtk_object_destroy ()

void        gtk_object_destroy              (GtkObject *object);

Calls the object's shutdown handler.

The memory for the object itself won't be deleted until its reference count drops to 0, though. See gtk_object_unref().

gtk_object_getv ()

void        gtk_object_getv                 (GtkObject *object,
                                             guint n_args,
                                             GtkArg *args);

Gets an array of argument values from an object.

gtk_object_set ()

void        gtk_object_set                  (GtkObject *object,
                                             const gchar *first_arg_name,
                                             ...);

This function sets multiple arguments of an object.

It takes an object, then a list of name/value pairs in a list, followed by NULL.

void set_box_properties(GtkBox* box)
{
  gtk_object_set(GTK_OBJECT(box), "homogeneous", TRUE,
                                  "spacing", 8,
				  NULL);
}

gtk_object_setv ()

void        gtk_object_setv                 (GtkObject *object,
                                             guint n_args,
                                             GtkArg *args);

Set an array of arguments.

gtk_object_query_args ()

GtkArg*     gtk_object_query_args           (GtkType class_type,
                                             guint32 **arg_flags,
                                             guint *n_args);

Get all the arguments that may be used for a given type.

In Java, this type of mechanism is called introspection. It is used by applications like Glade, that have to determine what can be done to an object at run-time.

gtk_object_set_data ()

void        gtk_object_set_data             (GtkObject *object,
                                             const gchar *key,
                                             gpointer data);

Each object carries around a table of associations from strings to pointers. This function lets you set an association.

If the object already had an association with that name, the old association will be destroyed.

gtk_object_set_data_full ()

void        gtk_object_set_data_full        (GtkObject *object,
                                             const gchar *key,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

Like gtk_object_set_data() except it adds notification for when the association is destroyed, either by gtk_object_remove_data() or when the object is destroyed.

gtk_object_remove_data ()

void        gtk_object_remove_data          (GtkObject *object,
                                             const gchar *key);

Remove a specified datum from the object's data associations (the object_data). Subsequent calls to gtk_object_get_data() will return NULL.

If you specified a destroy handler with gtk_object_set_data_full(), it will be invoked.

gtk_object_get_data ()

gpointer    gtk_object_get_data             (GtkObject *object,
                                             const gchar *key);

Get a named field from the object's table of associations (the object_data).

gtk_object_remove_no_notify ()

void        gtk_object_remove_no_notify     (GtkObject *object,
                                             const gchar *key);

Remove a specified datum from the object's data associations (the object_data), without invoking the association's destroy handler.

Just like gtk_object_remove_data() except that any destroy handler will be ignored. Therefore this only affects data set using gtk_object_set_data_full().

gtk_object_set_user_data ()

void        gtk_object_set_user_data        (GtkObject *object,
                                             gpointer data);

For convenience, every object offers a generic user data pointer. The function set it.

This function is equivalent to:

	gtk_object_set_data(object, "user_data", data);

gtk_object_get_user_data ()

gpointer    gtk_object_get_user_data        (GtkObject *object);

Get the object's user data pointer.

This is intended to be a pointer for your convenience in writing applications.

gtk_object_class_add_signals ()

void        gtk_object_class_add_signals    (GtkObjectClass *klass,
                                             guint *signals,
                                             guint nsignals);

Add an array of signals to a GtkObjectClass. Usually this is called when registering a new type of object.

gtk_object_add_arg_type ()

void        gtk_object_add_arg_type         (const gchar *arg_name,
                                             GtkType arg_type,
                                             guint arg_flags,
                                             guint arg_id);

Add a new type of argument to an object class. Usually this is called when registering a new type of object.

gtk_object_set_data_by_id ()

void        gtk_object_set_data_by_id       (GtkObject *object,
                                             GQuark data_id,
                                             gpointer data);

Just like gtk_object_set_data() except that it takes a GQuark instead of a string, so it is slightly faster.

Use gtk_object_data_try_key() and gtk_object_data_force_id() to get an id from a string.

gtk_object_set_data_by_id_full ()

void        gtk_object_set_data_by_id_full  (GtkObject *object,
                                             GQuark data_id,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

Just like gtk_object_set_data_full() except that it takes a GQuark instead of a string, so it is slightly faster.

Use gtk_object_data_try_key() and gtk_object_data_force_id() to get an id from a string.

gtk_object_get_data_by_id ()

gpointer    gtk_object_get_data_by_id       (GtkObject *object,
                                             GQuark data_id);

Just like gtk_object_get_data() except that it takes a GQuark instead of a string, so it is slightly faster.

Use gtk_object_data_try_key() and gtk_object_data_force_id() to get an id from a string.

gtk_object_remove_data_by_id ()

void        gtk_object_remove_data_by_id    (GtkObject *object,
                                             GQuark data_id);

Just like gtk_object_remove_data() except that it takes a GQuark instead of a string, so it is slightly faster.

Remove a specified datum from the object's data associations. Subsequent calls to gtk_object_get_data() will return NULL.

Use gtk_object_data_try_key() and gtk_object_data_force_id() to get an id from a string.

gtk_object_remove_no_notify_by_id ()

void        gtk_object_remove_no_notify_by_id
                                            (GtkObject *object,
                                             GQuark key_id);

Just like gtk_object_remove_no_notify() except that it takes a GQuark instead of a string, so it is slightly faster.

Use gtk_object_data_try_key() and gtk_object_data_force_id() to get an id from a string.

gtk_object_data_try_key

#define	gtk_object_data_try_key	    g_quark_try_string

Sees whether a certain quark exists. Returns that quark if so.

Although this is currently the same as g_quark_try_string(), it might someday be different, for example, if GQuarks and object data are converted to separate mechanisms, so it is good to use this macro.

gtk_object_data_force_id

#define	gtk_object_data_force_id    g_quark_from_string

Makes a quark from a string, possibly allocating a new quark.

Although this is currently the same as g_quark_from_string(), it might someday be different, for example, if GQuarks and object data are converted to separate mechanisms, so it is good to use this macro.

gtk_object_arg_set ()

void        gtk_object_arg_set              (GtkObject *object,
                                             GtkArg *arg,
                                             GtkArgInfo *info);

Private function to set an argument and argument info to an object.

gtk_object_arg_get ()

void        gtk_object_arg_get              (GtkObject *object,
                                             GtkArg *arg,
                                             GtkArgInfo *info);

Private function to get an argument and argument info from an object.

gtk_object_args_collect ()

gchar*      gtk_object_args_collect         (GtkType object_type,
                                             GSList **arg_list_p,
                                             GSList **info_list_p,
                                             const gchar *first_arg_name,
                                             va_list var_args);

Private: Gets an array of GtkArgs from a va_list C structure.

gtk_object_arg_get_info ()

gchar*      gtk_object_arg_get_info         (GtkType object_type,
                                             const gchar *arg_name,
                                             GtkArgInfo **info_p);

Query information about an argument type.

gtk_trace_referencing ()

void        gtk_trace_referencing           (GtkObject *object,
                                             const gchar *func,
                                             guint dummy,
                                             guint line,
                                             gboolean do_ref);

Private: print debugging information while doing a gtk_object_ref() or a gtk_object_unref().

The "destroy" signal

void        user_function                  (GtkObject *object,
                                            gpointer user_data);

Indicates that an object is being destroyed.