static OwnNameData * own_name_data_new (GClosure *bus_acquired_closure, GClosure *name_acquired_closure, GClosure *name_lost_closure) { OwnNameData *data; data = g_new0 (OwnNameData, 1); if (bus_acquired_closure != NULL) { data->bus_acquired_closure = g_closure_ref (bus_acquired_closure); g_closure_sink (bus_acquired_closure); if (G_CLOSURE_NEEDS_MARSHAL (bus_acquired_closure)) g_closure_set_marshal (bus_acquired_closure, g_cclosure_marshal_generic); } if (name_acquired_closure != NULL) { data->name_acquired_closure = g_closure_ref (name_acquired_closure); g_closure_sink (name_acquired_closure); if (G_CLOSURE_NEEDS_MARSHAL (name_acquired_closure)) g_closure_set_marshal (name_acquired_closure, g_cclosure_marshal_generic); } if (name_lost_closure != NULL) { data->name_lost_closure = g_closure_ref (name_lost_closure); g_closure_sink (name_lost_closure); if (G_CLOSURE_NEEDS_MARSHAL (name_lost_closure)) g_closure_set_marshal (name_lost_closure, g_cclosure_marshal_generic); } return data; }
static WatchNameData * watch_name_data_new (GClosure *name_appeared_closure, GClosure *name_vanished_closure) { WatchNameData *data; data = g_new0 (WatchNameData, 1); if (name_appeared_closure != NULL) { data->name_appeared_closure = g_closure_ref (name_appeared_closure); g_closure_sink (name_appeared_closure); if (G_CLOSURE_NEEDS_MARSHAL (name_appeared_closure)) g_closure_set_marshal (name_appeared_closure, g_cclosure_marshal_generic); } if (name_vanished_closure != NULL) { data->name_vanished_closure = g_closure_ref (name_vanished_closure); g_closure_sink (name_vanished_closure); if (G_CLOSURE_NEEDS_MARSHAL (name_vanished_closure)) g_closure_set_marshal (name_vanished_closure, g_cclosure_marshal_generic); } return data; }
/** * g_source_set_closure: * @source: the source * @closure: a #GClosure * * Set the callback for a source as a #GClosure. * * If the source is not one of the standard GLib types, the @closure_callback * and @closure_marshal fields of the #GSourceFuncs structure must have been * filled in with pointers to appropriate functions. */ void g_source_set_closure (GSource *source, GClosure *closure) { g_return_if_fail (source != NULL); g_return_if_fail (closure != NULL); if (!source->source_funcs->closure_callback && source->source_funcs != &g_io_watch_funcs && source->source_funcs != &g_timeout_funcs && source->source_funcs != &g_idle_funcs) { g_critical (G_STRLOC ": closure can not be set on closure without GSourceFuncs::closure_callback\n"); return; } g_closure_ref (closure); g_closure_sink (closure); g_source_set_callback_indirect (source, closure, &closure_callback_funcs); if (G_CLOSURE_NEEDS_MARSHAL (closure)) { GClosureMarshal marshal = (GClosureMarshal)source->source_funcs->closure_marshal; if (!marshal) { if (source->source_funcs == &g_idle_funcs || source->source_funcs == &g_timeout_funcs) marshal = source_closure_marshal_BOOLEAN__VOID; else if (source->source_funcs == &g_io_watch_funcs) marshal = g_cclosure_marshal_BOOLEAN__FLAGS; } if (marshal) g_closure_set_marshal (closure, marshal); } }
/* * clutter_alpha_set_closure_internal: * @alpha: a #ClutterAlpha * @closure: a #GClosure * * Sets the @closure for @alpha. This function does not * set the #ClutterAlpha:mode property and does not emit * the #GObject::notify signal for it. */ static inline void clutter_alpha_set_closure_internal (ClutterAlpha *alpha, GClosure *closure) { ClutterAlphaPrivate *priv = alpha->priv; if (priv->notify != NULL) priv->notify (priv->user_data); else if (priv->closure != NULL) g_closure_unref (priv->closure); priv->func = NULL; priv->user_data = NULL; priv->notify = NULL; if (closure == NULL) return; /* need to take ownership of the closure before sinking it */ priv->closure = g_closure_ref (closure); g_closure_sink (closure); /* set the marshaller */ if (G_CLOSURE_NEEDS_MARSHAL (closure)) { GClosureMarshal marshal = _clutter_marshal_DOUBLE__VOID; g_closure_set_marshal (priv->closure, marshal); } }
GObjectEventListener::GObjectEventListener(GObject* target, EventTarget* coreTarget, const char* domEventName, GClosure* handler, bool capture) : EventListener(GObjectEventListenerType) , m_target(target) , m_coreTarget(coreTarget) , m_domEventName(domEventName) , m_handler(handler) , m_capture(capture) { ASSERT(m_coreTarget); if (G_CLOSURE_NEEDS_MARSHAL(m_handler.get())) g_closure_set_marshal(m_handler.get(), g_cclosure_marshal_generic); g_object_weak_ref(m_target, reinterpret_cast<GWeakNotify>(GObjectEventListener::gobjectDestroyedCallback), this); }
/** * g_object_bind_property_with_closures: * @source: (type GObject.Object): the source #GObject * @source_property: the property on @source to bind * @target: (type GObject.Object): the target #GObject * @target_property: the property on @target to bind * @flags: flags to pass to #GBinding * @transform_to: a #GClosure wrapping the transformation function * from the @source to the @target, or %NULL to use the default * @transform_from: a #GClosure wrapping the transformation function * from the @target to the @source, or %NULL to use the default * * 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. * * This function is the language bindings friendly version of * g_object_bind_property_full(), using #GClosure<!-- -->s instead of * function pointers. * * Rename to: g_object_bind_property_full * * Return value: (transfer none): the #GBinding instance representing the * binding between the two #GObject instances. The binding is released * whenever the #GBinding reference count reaches zero. * * Since: 2.26 */ GBinding * g_object_bind_property_with_closures (gpointer source, const gchar *source_property, gpointer target, const gchar *target_property, GBindingFlags flags, GClosure *transform_to, GClosure *transform_from) { TransformData *data; data = g_slice_new0 (TransformData); if (transform_to != NULL) { if (G_CLOSURE_NEEDS_MARSHAL (transform_to)) g_closure_set_marshal (transform_to, g_cclosure_marshal_BOOLEAN__BOXED_BOXED); data->transform_to_closure = g_closure_ref (transform_to); g_closure_sink (data->transform_to_closure); } if (transform_from != NULL) { if (G_CLOSURE_NEEDS_MARSHAL (transform_from)) g_closure_set_marshal (transform_from, g_cclosure_marshal_BOOLEAN__BOXED_BOXED); data->transform_from_closure = g_closure_ref (transform_from); g_closure_sink (data->transform_from_closure); } return g_object_bind_property_full (source, source_property, target, target_property, flags, transform_to != NULL ? bind_with_closures_transform_to : NULL, transform_from != NULL ? bind_with_closures_transform_from : NULL, data, bind_with_closures_free_func); }
void er_dtls_connection_set_send_callback(ErDtlsConnection *self, GClosure *closure) { g_return_if_fail(ER_IS_DTLS_CONNECTION(self)); LOG_TRACE(self, "locking @ set_send_callback"); g_mutex_lock(&self->priv->mutex); LOG_TRACE(self, "locked @ set_send_callback"); self->priv->send_closure = closure; if (closure && G_CLOSURE_NEEDS_MARSHAL(closure)) { g_closure_set_marshal(closure, g_cclosure_marshal_generic); } LOG_TRACE(self, "unlocking @ set_send_callback"); g_mutex_unlock(&self->priv->mutex); }
/** * clutter_binding_pool_install_action: * @pool: a #ClutterBindingPool * @action_name: the name of the action * @key_val: key symbol * @modifiers: bitmask of modifiers * @callback: (type Clutter.BindingActionFunc): function to be called * when the action is activated * @data: data to be passed to @callback * @notify: function to be called when the action is removed * from the pool * * Installs a new action inside a #ClutterBindingPool. The action * is bound to @key_val and @modifiers. * * The same action name can be used for multiple @key_val, @modifiers * pairs. * * When an action has been activated using clutter_binding_pool_activate() * the passed @callback will be invoked (with @data). * * Actions can be blocked with clutter_binding_pool_block_action() * and then unblocked using clutter_binding_pool_unblock_action(). * * Since: 1.0 */ void clutter_binding_pool_install_action (ClutterBindingPool *pool, const gchar *action_name, guint key_val, ClutterModifierType modifiers, GCallback callback, gpointer data, GDestroyNotify notify) { ClutterBindingEntry *entry; GClosure *closure; g_return_if_fail (pool != NULL); g_return_if_fail (action_name != NULL); g_return_if_fail (key_val != 0); g_return_if_fail (callback != NULL); entry = binding_pool_lookup_entry (pool, key_val, modifiers); if (G_UNLIKELY (entry)) { g_warning ("There already is an action '%s' for the given " "key symbol of %d (modifiers: %d) installed inside " "the binding pool.", entry->name, entry->key_val, entry->modifiers); return; } else entry = binding_entry_new (action_name, key_val, modifiers); closure = g_cclosure_new (callback, data, (GClosureNotify) notify); entry->closure = g_closure_ref (closure); g_closure_sink (closure); if (G_CLOSURE_NEEDS_MARSHAL (closure)) { GClosureMarshal marshal; marshal = _clutter_marshal_BOOLEAN__STRING_UINT_FLAGS; g_closure_set_marshal (closure, marshal); } pool->entries = g_slist_prepend (pool->entries, entry); g_hash_table_insert (pool->entries_hash, entry, entry); }
/** * clutter_binding_pool_override_action: * @pool: a #ClutterBindingPool * @key_val: key symbol * @modifiers: bitmask of modifiers * @callback: (type Clutter.BindingActionFunc): function to be called when the action is activated * @data: data to be passed to @callback * @notify: function to be called when the action is removed * from the pool * * Allows overriding the action for @key_val and @modifiers inside a * #ClutterBindingPool. See clutter_binding_pool_install_action(). * * When an action has been activated using clutter_binding_pool_activate() * the passed @callback will be invoked (with @data). * * Actions can be blocked with clutter_binding_pool_block_action() * and then unblocked using clutter_binding_pool_unblock_action(). * * Since: 1.0 */ void clutter_binding_pool_override_action (ClutterBindingPool *pool, guint key_val, ClutterModifierType modifiers, GCallback callback, gpointer data, GDestroyNotify notify) { ClutterBindingEntry *entry; GClosure *closure; g_return_if_fail (pool != NULL); g_return_if_fail (key_val != 0); g_return_if_fail (callback != NULL); entry = binding_pool_lookup_entry (pool, key_val, modifiers); if (G_UNLIKELY (entry == NULL)) { g_warning ("There is no action for the given key symbol " "of %d (modifiers: %d) installed inside the " "binding pool.", key_val, modifiers); return; } if (entry->closure) { g_closure_unref (entry->closure); entry->closure = NULL; } closure = g_cclosure_new (callback, data, (GClosureNotify) notify); entry->closure = g_closure_ref (closure); g_closure_sink (closure); if (G_CLOSURE_NEEDS_MARSHAL (closure)) { GClosureMarshal marshal; marshal = _clutter_marshal_BOOLEAN__STRING_UINT_FLAGS; g_closure_set_marshal (closure, marshal); } }
/** * g_source_set_closure: * @source: the source * @closure: a #GClosure * * Set the callback for a source as a #GClosure. * * If the source is not one of the standard GLib types, the @closure_callback * and @closure_marshal fields of the #GSourceFuncs structure must have been * filled in with pointers to appropriate functions. */ void g_source_set_closure (GSource *source, GClosure *closure) { g_return_if_fail (source != NULL); g_return_if_fail (closure != NULL); if (!source->source_funcs->closure_callback && #ifdef G_OS_UNIX source->source_funcs != &g_unix_fd_source_funcs && source->source_funcs != &g_unix_signal_funcs && #endif source->source_funcs != &g_child_watch_funcs && source->source_funcs != &g_io_watch_funcs && source->source_funcs != &g_timeout_funcs && source->source_funcs != &g_idle_funcs) { g_critical (G_STRLOC ": closure cannot be set on GSource without GSourceFuncs::closure_callback\n"); return; } g_closure_ref (closure); g_closure_sink (closure); g_source_set_callback_indirect (source, closure, &closure_callback_funcs); g_closure_add_invalidate_notifier (closure, source, closure_invalidated); if (G_CLOSURE_NEEDS_MARSHAL (closure)) { GClosureMarshal marshal = (GClosureMarshal)source->source_funcs->closure_marshal; if (marshal) g_closure_set_marshal (closure, marshal); else if (source->source_funcs == &g_idle_funcs || #ifdef G_OS_UNIX source->source_funcs == &g_unix_signal_funcs || #endif source->source_funcs == &g_timeout_funcs) g_closure_set_marshal (closure, source_closure_marshal_BOOLEAN__VOID); else g_closure_set_marshal (closure, g_cclosure_marshal_generic); } }
void gst_dtls_connection_set_send_callback (GstDtlsConnection * self, GClosure * closure) { g_return_if_fail (GST_IS_DTLS_CONNECTION (self)); GST_TRACE_OBJECT (self, "locking @ set_send_callback"); g_mutex_lock (&self->priv->mutex); GST_TRACE_OBJECT (self, "locked @ set_send_callback"); if (self->priv->send_closure) { g_closure_unref (self->priv->send_closure); self->priv->send_closure = NULL; } self->priv->send_closure = closure; if (closure && G_CLOSURE_NEEDS_MARSHAL (closure)) { g_closure_set_marshal (closure, g_cclosure_marshal_generic); } GST_TRACE_OBJECT (self, "unlocking @ set_send_callback"); g_mutex_unlock (&self->priv->mutex); }
void _owr_get_capture_devices(OwrMediaType types, GClosure *callback) { GClosure *merger; g_return_if_fail(callback); if (G_CLOSURE_NEEDS_MARSHAL(callback)) { g_closure_set_marshal(callback, g_cclosure_marshal_generic); } merger = _owr_utils_list_closure_merger_new(callback, (GDestroyNotify) g_object_unref); if (types & OWR_MEDIA_TYPE_VIDEO) { g_closure_ref(merger); _owr_schedule_with_user_data((GSourceFunc) enumerate_video_source_devices, merger); } if (types & OWR_MEDIA_TYPE_AUDIO) { g_closure_ref(merger); _owr_schedule_with_user_data((GSourceFunc) enumerate_audio_source_devices, merger); } g_closure_unref(merger); }