static gboolean
g_child_watch_closure_callback (GPid pid,
gint status,
gpointer data)
{
GClosure *closure = data;
GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
GValue result_value = G_VALUE_INIT;
gboolean result;
g_value_init (&result_value, G_TYPE_BOOLEAN);
#ifdef G_OS_UNIX
g_value_init (¶ms[0], G_TYPE_ULONG);
g_value_set_ulong (¶ms[0], pid);
#endif
#ifdef G_OS_WIN32
g_value_init (¶ms[0], G_TYPE_POINTER);
g_value_set_pointer (¶ms[0], pid);
#endif
g_value_init (¶ms[1], G_TYPE_INT);
g_value_set_int (¶ms[1], status);
g_closure_invoke (closure, &result_value, 2, params, NULL);
result = g_value_get_boolean (&result_value);
g_value_unset (&result_value);
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
return result;
}
void
moo_plugin_call_methodv (const GValue *plugin_and_args,
const char *name,
GValue *return_val)
{
gpointer plugin;
MooPluginMeth *meth;
g_return_if_fail (plugin_and_args != NULL);
g_return_if_fail (name != NULL);
plugin = g_value_get_object (plugin_and_args);
g_return_if_fail (plugin != NULL);
meth = moo_plugin_lookup_method (plugin, name);
if (!meth)
{
g_warning ("plugin '%s' does not have method '%s'",
moo_plugin_id (plugin), name);
return;
}
g_return_if_fail (meth->return_type == G_TYPE_NONE ||
(return_val != NULL && meth->return_type == G_VALUE_TYPE (return_val)));
g_closure_invoke (meth->closure, return_val, meth->n_params + 1, plugin_and_args, NULL);
}
static gint pacman_manager_fetch_cb (const gchar *url, const gchar *path, int force) {
PacmanManagerPrivate *priv;
GValue result = { 0 }, params[4] = { 0 };
g_return_val_if_fail (url != NULL, -1);
g_return_val_if_fail (path != NULL, -1);
g_return_val_if_fail (pacman_manager != NULL, -1);
priv = PACMAN_MANAGER_GET_PRIVATE (pacman_manager);
g_value_init (¶ms[0], PACMAN_TYPE_MANAGER);
g_value_set_instance (¶ms[0], pacman_manager);
g_value_init (¶ms[1], G_TYPE_STRING);
g_value_set_string (¶ms[1], url);
g_value_init (¶ms[2], G_TYPE_STRING);
g_value_set_string (¶ms[2], path);
g_value_init (¶ms[3], G_TYPE_BOOLEAN);
g_value_set_boolean (¶ms[3], force != 0);
g_value_init (&result, G_TYPE_INT);
g_closure_invoke (priv->transfer, &result, 4, params, NULL);
return g_value_get_int (&result);
}
/* returns 0 on success, prints a status msg if msg is true */
int owl_variable_set_fromstring(owl_variable *v, const char *value, int msg) {
char *tostring;
GValue values[] = {G_VALUE_INIT, G_VALUE_INIT};
GValue return_box = G_VALUE_INIT;
int set_successfully;
g_value_init(&values[0], G_TYPE_POINTER);
g_value_set_pointer(&values[0], NULL);
g_value_init(&values[1], G_TYPE_STRING);
g_value_set_static_string(&values[1], value);
g_value_init(&return_box, G_TYPE_INT);
g_closure_invoke(v->set_fromstring_fn, &return_box, 2, values, NULL);
set_successfully = g_value_get_int(&return_box);
if (0 != set_successfully) {
if (msg) owl_function_error("Unable to set %s (must be %s)", owl_variable_get_name(v),
owl_variable_get_validsettings(v));
} else if (msg) {
tostring = owl_variable_get_tostring(v);
if (tostring) {
owl_function_makemsg("%s = '%s'", owl_variable_get_name(v), tostring);
} else {
owl_function_makemsg("%s = <null>", owl_variable_get_name(v));
}
g_free(tostring);
}
g_value_unset(&return_box);
g_value_unset(&values[1]);
g_value_unset(&values[0]);
return set_successfully;
}
static gboolean
io_watch_closure_callback (GIOChannel *channel,
GIOCondition condition,
gpointer data)
{
GClosure *closure = data;
GValue params[2] = { { 0, }, { 0, } };
GValue result_value = { 0, };
gboolean result;
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_value_init (¶ms[0], G_TYPE_IO_CHANNEL);
g_value_set_boxed (¶ms[0], channel);
g_value_init (¶ms[1], G_TYPE_IO_CONDITION);
g_value_set_flags (¶ms[1], condition);
g_closure_invoke (closure, &result_value, 2, params, NULL);
result = g_value_get_boolean (&result_value);
g_value_unset (&result_value);
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
return result;
}
static gboolean
clutter_binding_entry_invoke (ClutterBindingEntry *entry,
GObject *gobject)
{
GValue params[4] = { { 0, }, { 0, }, { 0, }, { 0, } };
GValue result = { 0, };
gboolean retval = TRUE;
g_value_init (¶ms[0], G_TYPE_OBJECT);
g_value_set_object (¶ms[0], gobject);
g_value_init (¶ms[1], G_TYPE_STRING);
g_value_set_static_string (¶ms[1], entry->name);
g_value_init (¶ms[2], G_TYPE_UINT);
g_value_set_uint (¶ms[2], entry->key_val);
g_value_init (¶ms[3], CLUTTER_TYPE_MODIFIER_TYPE);
g_value_set_flags (¶ms[3], entry->modifiers);
g_value_init (&result, G_TYPE_BOOLEAN);
g_closure_invoke (entry->closure, &result, 4, params, NULL);
retval = g_value_get_boolean (&result);
g_value_unset (&result);
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
g_value_unset (¶ms[2]);
g_value_unset (¶ms[3]);
return retval;
}
static gboolean
g_unix_fd_source_closure_callback (int fd,
GIOCondition condition,
gpointer data)
{
GClosure *closure = data;
GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
GValue result_value = G_VALUE_INIT;
gboolean result;
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_value_init (¶ms[0], G_TYPE_INT);
g_value_set_int (¶ms[0], fd);
g_value_init (¶ms[1], G_TYPE_IO_CONDITION);
g_value_set_flags (¶ms[1], condition);
g_closure_invoke (closure, &result_value, 2, params, NULL);
result = g_value_get_boolean (&result_value);
g_value_unset (&result_value);
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
return result;
}
static guint get_buffered_amount(OwrDataChannel *data_channel)
{
OwrDataChannelPrivate *priv = data_channel->priv;
guint64 bytes_sent = 0;
if (priv->on_request_bytes_sent) {
GValue ret_value = G_VALUE_INIT;
GValue params[1] = { G_VALUE_INIT };
g_value_init(&ret_value, G_TYPE_UINT64);
g_value_init(¶ms[0], OWR_TYPE_DATA_CHANNEL);
g_value_set_instance(¶ms[0], data_channel);
g_closure_invoke(priv->on_request_bytes_sent, &ret_value, 1, (const GValue *)¶ms, NULL);
bytes_sent = g_value_get_uint64(&ret_value);
g_value_unset(¶ms[0]);
g_value_unset(&ret_value);
} else
g_warning("on_request_bytes_sent closure not set. Cannot get buffered amount.");
if (priv->bytes_sent < bytes_sent)
bytes_sent = 0;
else
bytes_sent = priv->bytes_sent - bytes_sent;
if (bytes_sent > G_MAXUINT)
bytes_sent = G_MAXUINT;
return (guint) bytes_sent;
}
static inline void
panel_lockdown_invoke_closures (PanelLockdown *lockdown)
{
GSList *l;
for (l = lockdown->closures; l; l = l->next)
g_closure_invoke (l->data, NULL, 0, NULL, NULL);
}
/**
* pka_subscription_deliver_sample:
* @subscription: A #PkaSubscription.
*
* Delivers @sample from @source to the @subscription. @manifest should
* be the current manifest for the source that has already been sent
* to pka_subscription_deliver_manifest().
*
* Returns: None.
* Side effects: None.
*/
void
pka_subscription_deliver_sample (PkaSubscription *subscription, /* IN */
PkaSource *source, /* IN */
PkaManifest *manifest, /* IN */
PkaSample *sample) /* IN */
{
GValue params[3] = { { 0 } };
guint8 *buffer = NULL;
gsize buffer_len = 0;
PkaSample *samples[1] = { sample };
g_return_if_fail(subscription != NULL);
g_return_if_fail(sample != NULL);
g_return_if_fail(PKA_IS_SOURCE(source));
/*
* TODO: In the recent rewrite of this, we didn't implement buffering.
* We need to add back support for buffering based on timeouts or
* size of raw-data.
*/
ENTRY;
g_static_rw_lock_reader_lock(&subscription->rw_lock);
if (G_LIKELY(subscription->sample_closure)) {
if (!pka_encoder_encode_samples(NULL, manifest, samples, 1,
&buffer, &buffer_len)) {
WARNING(Subscription, "Subscription %d failed to encode sample.",
subscription->id);
GOTO(failed);
}
DUMP_BYTES(Sample, buffer, buffer_len);
/*
* XXX: It should be obvious that this marshalling isn't very fast.
* But I've certainly done worse.
*/
g_value_init(¶ms[0], PKA_TYPE_SUBSCRIPTION);
g_value_init(¶ms[1], G_TYPE_POINTER);
g_value_init(¶ms[2], G_TYPE_ULONG);
g_value_set_boxed(¶ms[0], subscription);
g_value_set_pointer(¶ms[1], buffer);
g_value_set_ulong(¶ms[2], buffer_len);
g_closure_invoke(subscription->sample_closure, NULL,
3, ¶ms[0], NULL);
g_value_unset(¶ms[0]);
g_value_unset(¶ms[1]);
g_value_unset(¶ms[2]);
g_free(buffer);
}
failed:
g_static_rw_lock_reader_unlock(&subscription->rw_lock);
EXIT;
}
void GObjectEventListener::handleEvent(ScriptExecutionContext*, Event* event)
{
GValue parameters[2] = { G_VALUE_INIT, G_VALUE_INIT };
g_value_init(¶meters[0], WEBKIT_DOM_TYPE_EVENT_TARGET);
g_value_set_object(¶meters[0], m_target);
GRefPtr<WebKitDOMEvent> domEvent = adoptGRef(WebKit::kit(event));
g_value_init(¶meters[1], WEBKIT_DOM_TYPE_EVENT);
g_value_set_object(¶meters[1], domEvent.get());
g_closure_invoke(m_handler.get(), 0, 2, parameters, NULL);
g_value_unset(parameters + 0);
g_value_unset(parameters + 1);
}
/*
* Call the closure with the list as single argument.
* @callback: (scope sync) (transfer full): the callback to be called with the list
* @list: (transfer full): any list
*/
void _owr_utils_call_closure_with_list(GClosure *callback, GList *list)
{
GValue values[1] = { G_VALUE_INIT };
g_return_if_fail(callback);
g_value_init(&values[0], G_TYPE_POINTER);
g_value_set_pointer(&values[0], list);
g_closure_invoke(callback, NULL, 1, values, NULL);
g_closure_unref(callback);
g_value_unset(&values[0]);
}
static gboolean add_remote_candidate(GHashTable *args)
{
OwrSession *session;
OwrSessionPrivate *priv;
OwrCandidate *candidate;
gboolean forced;
GSList **candidates;
GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
g_return_val_if_fail(args, FALSE);
session = g_hash_table_lookup(args, "session");
candidate = g_hash_table_lookup(args, "candidate");
forced = GPOINTER_TO_INT(g_hash_table_lookup(args, "forced"));
g_return_val_if_fail(session && candidate, FALSE);
priv = session->priv;
candidates = forced ? &priv->forced_remote_candidates : &priv->remote_candidates;
if (g_slist_find(*candidates, candidate)) {
g_warning("Fail: remote candidate already added.");
goto end;
}
if (g_slist_find(priv->local_candidates, candidate)) {
g_warning("Fail: candidate is local.");
goto end;
}
*candidates = g_slist_append(*candidates, candidate);
g_object_ref(candidate);
if (priv->on_remote_candidate) {
g_value_init(¶ms[0], OWR_TYPE_SESSION);
g_value_set_object(¶ms[0], session);
g_value_init(¶ms[1], G_TYPE_BOOLEAN);
g_value_set_boolean(¶ms[1], forced);
g_closure_invoke(priv->on_remote_candidate, NULL, 2, (const GValue *)¶ms, NULL);
g_value_unset(¶ms[0]);
g_value_unset(¶ms[1]);
}
end:
g_object_unref(candidate);
g_object_unref(session);
g_hash_table_unref(args);
return FALSE;
}
static gboolean
source_closure_callback (gpointer data)
{
GClosure *closure = data;
GValue result_value = { 0, };
gboolean result;
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_closure_invoke (closure, &result_value, 0, NULL, NULL);
result = g_value_get_boolean (&result_value);
g_value_unset (&result_value);
return result;
}
static void
rb_plugin_install_done (RBPluginInstallContext *ctx, gboolean retry)
{
GValue param[2] = { {0,}, {0,} };
rb_debug ("invoking plugin install context %p callback: retry %d", ctx, retry);
g_value_init (¶m[0], G_TYPE_POINTER);
g_value_set_pointer (¶m[0], NULL);
g_value_init (¶m[1], G_TYPE_BOOLEAN);
g_value_set_boolean (¶m[1], retry);
g_closure_invoke (ctx->closure, NULL, 2, param, NULL);
g_value_unset (¶m[0]);
g_value_unset (¶m[1]);
}
CALLER_OWN char *owl_variable_get_tostring(const owl_variable *v)
{
GValue instance = G_VALUE_INIT;
GValue tostring_box = G_VALUE_INIT;
char *ret = NULL;
g_value_init(&instance, G_TYPE_POINTER);
g_value_set_pointer(&instance, NULL);
g_value_init(&tostring_box, G_TYPE_STRING);
g_closure_invoke(v->get_tostring_fn, &tostring_box, 1, &instance, NULL);
ret = g_value_dup_string(&tostring_box);
g_value_unset(&tostring_box);
g_value_unset(&instance);
return ret;
}
void
fo_doc_cairo_do_run_callbacks (cairo_t *cr,
PangoLayoutRun *run,
gint x,
gint y)
{
GSList *extra_attrs_list = run->item->analysis.extra_attrs;
g_return_if_fail (cr != NULL);
g_return_if_fail (run != NULL);
while (extra_attrs_list)
{
PangoAttribute *attr = extra_attrs_list->data;
PangoAttrType attr_type = attr->klass->type;
if (attr_type == libfo_pango_attr_callback_get_type ())
{
GValue values[1] = { { 0, { {0}, {0} } } };
g_value_init (&values[0], G_TYPE_POINTER);
g_value_set_pointer (&values[0], cr);
#if 0
g_message ("Got a callback: callback: %p",
((PangoAttrPointer *) attr)->pointer);
#endif
cairo_save (cr);
cairo_translate (cr,
x / PANGO_SCALE,
-y / PANGO_SCALE);
g_closure_invoke (((GClosure *) libfo_pango_attr_callback_get_callback(attr)),
NULL,
1,
values,
NULL);
cairo_restore (cr);
}
extra_attrs_list = extra_attrs_list->next;
}
}
static gboolean data_channel_send(GHashTable *args)
{
OwrDataChannelPrivate *priv;
OwrDataChannel *data_channel;
guint8 *data;
guint length;
gboolean is_binary;
OWR_UNUSED(priv);
OWR_UNUSED(data_channel);
OWR_UNUSED(data);
OWR_UNUSED(is_binary);
data_channel = g_hash_table_lookup(args, "data_channel");
data = g_hash_table_lookup(args, "data");
length = GPOINTER_TO_UINT(g_hash_table_lookup(args, "length"));
is_binary = GPOINTER_TO_UINT(g_hash_table_lookup(args, "is_binary"));
priv = data_channel->priv;
if (priv->on_datachannel_send) {
GValue params[4] = { G_VALUE_INIT, G_VALUE_INIT, G_VALUE_INIT, G_VALUE_INIT };
g_value_init(¶ms[0], OWR_TYPE_DATA_CHANNEL);
g_value_set_object(¶ms[0], data_channel);
g_value_init(¶ms[1], G_TYPE_POINTER);
g_value_set_pointer(¶ms[1], data);
g_value_init(¶ms[2], G_TYPE_UINT);
g_value_set_uint(¶ms[2], length);
g_value_init(¶ms[3], G_TYPE_BOOLEAN);
g_value_set_boolean(¶ms[3], is_binary);
g_closure_invoke(priv->on_datachannel_send, NULL, 4, (const GValue *)¶ms, NULL);
g_value_unset(¶ms[0]);
g_value_unset(¶ms[1]);
g_value_unset(¶ms[2]);
g_value_unset(¶ms[3]);
} else
g_free(data);
g_hash_table_unref(args);
g_object_unref(data_channel);
return FALSE;
}
static void clearClipboardContentsCallback(GtkClipboard* clipboard, gpointer data)
{
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
ASSERT(dataObject);
// Only clear the DataObject for this clipboard if we are not currently setting it.
if (dataObject != settingClipboardDataObject)
dataObject->clearAll();
if (!data)
return;
GRefPtr<GClosure> callback = adoptGRef(static_cast<GClosure*>(data));
GValue firstArgument = {0, {{0}}};
g_value_init(&firstArgument, G_TYPE_POINTER);
g_value_set_pointer(&firstArgument, clipboard);
g_closure_invoke(callback.get(), nullptr, 1, &firstArgument, 0);
}
/**
* pka_subscription_deliver_manifest:
* @subscription: A #PkaSubscription.
* @source: A #PkaSource.
* @manifest: A #PkaManifest.
*
* Delivers @manifest from @souce to the subscriptions handlers.
*
* Returns: None.
* Side effects: None.
*/
void
pka_subscription_deliver_manifest (PkaSubscription *subscription, /* IN */
PkaSource *source, /* IN */
PkaManifest *manifest) /* IN */
{
GValue params[3] = { { 0 } };
guint8 *buffer = NULL;
gsize buffer_len = 0;
g_return_if_fail(subscription != NULL);
g_return_if_fail(manifest != NULL);
g_return_if_fail(PKA_IS_SOURCE(source));
ENTRY;
g_static_rw_lock_reader_lock(&subscription->rw_lock);
if (G_LIKELY(subscription->manifest_closure)) {
if (!pka_encoder_encode_manifest(NULL, manifest, &buffer, &buffer_len)) {
WARNING(Subscription, "Subscription %d failed to encode manifest.",
subscription->id);
GOTO(failed);
}
DUMP_BYTES(Manifest, buffer, buffer_len);
/*
* XXX: It should be obvious that this marshalling isn't very fast.
* But I've certainly done worse. At least it handles things cleanly
* with regard to using libffi.
*/
g_value_init(¶ms[0], PKA_TYPE_SUBSCRIPTION);
g_value_init(¶ms[1], G_TYPE_POINTER);
g_value_init(¶ms[2], G_TYPE_ULONG);
g_value_set_boxed(¶ms[0], subscription);
g_value_set_pointer(¶ms[1], buffer);
g_value_set_ulong(¶ms[2], buffer_len);
g_closure_invoke(subscription->manifest_closure, NULL,
3, ¶ms[0], NULL);
g_value_unset(¶ms[0]);
g_value_unset(¶ms[1]);
g_value_unset(¶ms[2]);
g_free(buffer);
}
failed:
g_static_rw_lock_reader_unlock(&subscription->rw_lock);
EXIT;
}
static void
own_with_closures_on_name_lost (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
OwnNameData *data = user_data;
GValue params[2] = { { 0, }, { 0, } };
g_value_init (¶ms[0], G_TYPE_DBUS_CONNECTION);
g_value_set_object (¶ms[0], connection);
g_value_init (¶ms[1], G_TYPE_STRING);
g_value_set_string (¶ms[1], name);
g_closure_invoke (data->name_lost_closure, NULL, 2, params, NULL);
g_value_unset (params + 0);
g_value_unset (params + 1);
}
static void
watch_with_closures_on_name_vanished (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
WatchNameData *data = user_data;
GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
g_value_init (¶ms[0], G_TYPE_DBUS_CONNECTION);
g_value_set_object (¶ms[0], connection);
g_value_init (¶ms[1], G_TYPE_STRING);
g_value_set_string (¶ms[1], name);
g_closure_invoke (data->name_vanished_closure, NULL, 2, params, NULL);
g_value_unset (params + 0);
g_value_unset (params + 1);
}
static void
panel_applet_setup (PanelApplet *applet)
{
GValue value = {0, };
GArray *params;
gint i;
gboolean ret;
g_assert (applet->priv->id != NULL &&
applet->priv->closure != NULL);
params = g_array_sized_new (FALSE, TRUE, sizeof (GValue), 2);
value.g_type = 0;
g_value_init (&value, G_TYPE_OBJECT);
g_value_set_object (&value, G_OBJECT (applet));
g_array_append_val (params, value);
value.g_type = 0;
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, applet->priv->id);
g_array_append_val (params, value);
value.g_type = 0;
g_value_init (&value, G_TYPE_BOOLEAN);
g_closure_invoke (applet->priv->closure,
&value, params->len,
(GValue *) params->data,
NULL);
for (i = 0; i < params->len; i++)
g_value_unset (&g_array_index (params, GValue, i));
g_array_free (params, TRUE);
ret = g_value_get_boolean (&value);
g_value_unset (&value);
if (!ret) { /* FIXME */
g_warning ("need to free the control here");
return;
}
}
static gboolean
bind_with_closures_transform_from (GBinding *binding,
const GValue *source,
GValue *target,
gpointer data)
{
TransformData *t_data = data;
GValue params[3] = { G_VALUE_INIT, G_VALUE_INIT, G_VALUE_INIT };
GValue retval = G_VALUE_INIT;
gboolean res;
g_value_init (¶ms[0], G_TYPE_BINDING);
g_value_set_object (¶ms[0], binding);
g_value_init (¶ms[1], G_TYPE_VALUE);
g_value_set_boxed (¶ms[1], source);
g_value_init (¶ms[2], G_TYPE_VALUE);
g_value_set_boxed (¶ms[2], target);
g_value_init (&retval, G_TYPE_BOOLEAN);
g_value_set_boolean (&retval, FALSE);
g_closure_invoke (t_data->transform_from_closure, &retval, 3, params, NULL);
res = g_value_get_boolean (&retval);
if (res)
{
const GValue *out_value = g_value_get_boxed (¶ms[2]);
g_assert (out_value != NULL);
g_value_copy (out_value, target);
}
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
g_value_unset (¶ms[2]);
g_value_unset (&retval);
return res;
}
static gboolean
component_source_closure_callback (GObject *pollable_stream, gpointer user_data)
{
GClosure *closure = user_data;
GValue param_value = G_VALUE_INIT;
GValue result_value = G_VALUE_INIT;
gboolean retval;
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_value_init (¶m_value, G_TYPE_OBJECT);
g_value_set_object (¶m_value, pollable_stream);
g_closure_invoke (closure, &result_value, 1, ¶m_value, NULL);
retval = g_value_get_boolean (&result_value);
g_value_unset (¶m_value);
g_value_unset (&result_value);
return retval;
}
static void update_local_credentials(OwrCandidate *candidate, GParamSpec *pspec, OwrSession *session)
{
OwrSessionPrivate *priv;
GSList *item;
GObject *local_candidate;
gchar *ufrag = NULL, *password = NULL;
GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
g_return_if_fail(OWR_IS_CANDIDATE(candidate));
g_return_if_fail(G_IS_PARAM_SPEC(pspec));
g_return_if_fail(OWR_IS_SESSION(session));
priv = session->priv;
g_object_get(G_OBJECT(candidate), "ufrag", &ufrag, "password", &password, NULL);
for (item = priv->local_candidates; item; item = item->next) {
local_candidate = G_OBJECT(item->data);
if (local_candidate == G_OBJECT(candidate))
continue;
g_signal_handlers_block_matched(local_candidate, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
0, 0, NULL, G_CALLBACK(update_local_credentials), session);
g_object_set(local_candidate, "ufrag", ufrag, "password", password, NULL);
g_signal_handlers_unblock_matched(local_candidate, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
0, 0, NULL, G_CALLBACK(update_local_credentials), session);
}
g_free(ufrag);
g_free(password);
if (priv->on_local_candidate_change) {
g_value_init(¶ms[0], OWR_TYPE_SESSION);
g_value_set_object(¶ms[0], session);
g_value_init(¶ms[1], OWR_TYPE_CANDIDATE);
g_value_set_object(¶ms[1], candidate);
g_closure_invoke(priv->on_local_candidate_change, NULL, 2, (const GValue *)¶ms, NULL);
g_value_unset(¶ms[0]);
g_value_unset(¶ms[1]);
}
}
static void async_callback_job_destructor(void *data_ptr)
{
async_call_data* data = data_ptr;
GList* cur_elt = data->extra;
while(cur_elt) {
GList * type_type_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
//GList * type_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
GList * data_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
switch(GPOINTER_TO_INT(type_type_elt->data)) {
case LUA_ASYNC_TYPEID_WITH_FREE:
case LUA_ASYNC_TYPENAME_WITH_FREE:
{
GList *destructor_elt = cur_elt;
cur_elt = g_list_next(cur_elt);
GValue to_free = G_VALUE_INIT;
g_value_init(&to_free,G_TYPE_POINTER);
g_value_set_pointer(&to_free,data_elt->data);
g_closure_invoke(destructor_elt->data,NULL,1,&to_free,NULL);
g_closure_unref (destructor_elt->data);
}
break;
case LUA_ASYNC_TYPEID:
case LUA_ASYNC_TYPENAME:
break;
case LUA_ASYNC_DONE:
default:
// should never happen
printf("%d\n",GPOINTER_TO_INT(type_type_elt->data));
g_assert(false);
break;
}
}
g_list_free(data->extra);
free(data);
}
static gboolean
message_source_closure_callback (SoupMessage *msg,
gpointer data)
{
GClosure *closure = data;
GValue param = G_VALUE_INIT;
GValue result_value = G_VALUE_INIT;
gboolean result;
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_value_init (¶m, SOUP_TYPE_MESSAGE);
g_value_set_object (¶m, msg);
g_closure_invoke (closure, &result_value, 1, ¶m, NULL);
result = g_value_get_boolean (&result_value);
g_value_unset (&result_value);
g_value_unset (¶m);
return result;
}
static gboolean
message_queue_source_closure_callback (gpointer message,
gpointer user_data)
{
GClosure *closure = user_data;
GValue param_value = G_VALUE_INIT;
GValue result_value = G_VALUE_INIT;
gboolean retval;
/* The invoked function is responsible for freeing @message. */
g_value_init (&result_value, G_TYPE_BOOLEAN);
g_value_init (¶m_value, G_TYPE_POINTER);
g_value_set_pointer (¶m_value, message);
g_closure_invoke (closure, &result_value, 1, ¶m_value, NULL);
retval = g_value_get_boolean (&result_value);
g_value_unset (¶m_value);
g_value_unset (&result_value);
return retval;
}
/**
* clutter_alpha_get_alpha:
* @alpha: A #ClutterAlpha
*
* Query the current alpha value.
*
* Return Value: The current alpha value for the alpha
*
* Since: 0.2
*
* Deprecated: 1.12
*/
gdouble
clutter_alpha_get_alpha (ClutterAlpha *alpha)
{
ClutterAlphaPrivate *priv;
gdouble retval = 0;
g_return_val_if_fail (CLUTTER_IS_ALPHA (alpha), 0);
priv = alpha->priv;
if (G_LIKELY (priv->func))
{
return priv->func (alpha, priv->user_data);
}
else if (priv->closure)
{
GValue params = G_VALUE_INIT;
GValue result_value = G_VALUE_INIT;
g_object_ref (alpha);
g_value_init (&result_value, G_TYPE_DOUBLE);
g_value_init (¶ms, CLUTTER_TYPE_ALPHA);
g_value_set_object (¶ms, alpha);
g_closure_invoke (priv->closure, &result_value, 1, ¶ms, NULL);
retval = g_value_get_double (&result_value);
g_value_unset (&result_value);
g_value_unset (¶ms);
g_object_unref (alpha);
}
return retval;
}
