SignalGroup
GSignalGroup
manages a collection of signals on a GObject
.
GSignalGroup
simplifies the process of connecting many signals to a GObject
as a group. As such there is no API to disconnect a signal from the group.
In particular, this allows you to:
Change the target instance, which automatically causes disconnection of the signals from the old instance and connecting to the new instance.
Block and unblock signals as a group
Ensuring that blocked state transfers across target instances.
One place you might want to use such a structure is with GtkTextView
and GtkTextBuffer
. Often times, you'll need to connect to many signals on GtkTextBuffer
from a GtkTextView
subclass. This allows you to create a signal group during instance construction, simply bind the GtkTextView:buffer
property to GSignalGroup:target
and connect all the signals you need. When the GtkTextView:buffer
property changes all of the signals will be transitioned correctly.
Skipped during bindings generation
parameter
c_handler
: Callbackmethod
target
: Property has no gettermethod
target-type
: Property has no getter nor setter
Since
2.72
Constructors
Functions
Increases the reference count of the object by one and sets a callback to be called when all other references to the object are dropped, or when this is already the last reference to the object and another reference is established.
Creates a binding between @source_property on @source and @target_property on @target.
Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding.
Connects @c_handler to the signal @detailed_signal on the target instance of @self.
This signal is emitted when #GSignalGroup:target is set to a new value other than null. It is similar to #GObject::notify on target
except it will not emit when #GSignalGroup:target is null and also allows for receiving the #GObject without a data-race.
Connects @closure to the signal @detailed_signal on #GSignalGroup:target.
Connects @c_handler to the signal @detailed_signal on the target instance of @self.
The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.
Connects @c_handler to the signal @detailed_signal on the target instance of @self.
This signal is emitted when the target instance of @self is set to a new #GObject.
This is a variant of g_object_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object.
This is a variant of g_object_get_qdata() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object.
This function is intended for #GObject implementations to re-enforce a floating-ref object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().
Increases the freeze count on @object. If the freeze count is non-zero, the emission of "notify" signals on @object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one #GObject::notify signal is emitted for each property modified while the object is frozen.
Gets a property of an object.
Checks whether @object has a floating-ref reference.
Emits a "notify" signal for the property specified by @pspec on @object.
Removes a reference added with g_object_add_toggle_ref(). The reference count of the object is decreased by one.
Releases all references to other objects. This can be used to break reference cycles.
Sets a property on an object.
This sets an opaque, named pointer on an object. The name is specified through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @object with g_object_get_qdata() until the @object is finalized. Setting a previously set user data pointer, overrides (frees) the old pointer set, using #NULL as pointer essentially removes the data stored.
This function gets back user data pointers stored via g_object_set_qdata() and removes the @data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier, for example: |[ void object_add_to_user_list (GObject *object, const gchar *new_string) { // the quark, naming the object data GQuark quark_string_list = g_quark_from_static_string ("my-string-list"); // retrieve the old string list GList *list = g_object_steal_qdata (object, quark_string_list);
Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on @object and when it reaches zero, queued "notify" signals are emitted.
This function essentially limits the life time of the @closure to the life time of the object. That is, when the object is finalized, the @closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the @closure, to ensure that an extra reference count is held on @object during invocation of the
Adds a weak reference callback to an object. Weak references are used for notification when an object is disposed. They are called "weak references" because they allow you to safely hold a pointer to an object without calling g_object_ref() (g_object_ref() adds a strong reference, that is, forces the object to stay alive).
Removes a weak reference callback to an object.