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;
}
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;
}
void dt_lua_async_call_alien_internal(const char * call_function, int line,lua_CFunction pusher,int nresults,dt_lua_finish_callback cb, void*cb_data, dt_lua_async_call_arg_type arg_type,...)
{
#ifdef _DEBUG
dt_print(DT_DEBUG_LUA,"LUA DEBUG : %s called from %s %d\n",__FUNCTION__,call_function,line);
#endif
async_call_data*data = malloc(sizeof(async_call_data));
data->pusher = pusher;
data->extra=NULL;
data->cb = cb;
data->cb_data = cb_data;
data->nresults = nresults;
va_list ap;
va_start(ap,arg_type);
dt_lua_async_call_arg_type cur_type = arg_type;
while(cur_type != LUA_ASYNC_DONE){
data->extra=g_list_append(data->extra,GINT_TO_POINTER(cur_type));
switch(cur_type) {
case LUA_ASYNC_TYPEID:
data->extra=g_list_append(data->extra,GINT_TO_POINTER(va_arg(ap,luaA_Type)));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
break;
case LUA_ASYNC_TYPEID_WITH_FREE:
{
data->extra=g_list_append(data->extra,GINT_TO_POINTER(va_arg(ap,luaA_Type)));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
GClosure* closure = va_arg(ap,GClosure*);
g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal(closure, g_cclosure_marshal_generic);
data->extra=g_list_append(data->extra,closure);
}
break;
case LUA_ASYNC_TYPENAME:
data->extra=g_list_append(data->extra,va_arg(ap,char *));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
break;
case LUA_ASYNC_TYPENAME_WITH_FREE:
{
data->extra=g_list_append(data->extra,va_arg(ap,char *));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
GClosure* closure = va_arg(ap,GClosure*);
g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal(closure, g_cclosure_marshal_generic);
data->extra=g_list_append(data->extra,closure);
}
break;
default:
// should never happen
g_assert(false);
break;
}
cur_type = va_arg(ap,dt_lua_async_call_arg_type);
}
va_end(ap);
g_async_queue_push(darktable.lua_state.alien_job_queue,(gpointer)data);
g_main_context_wakeup(darktable.lua_state.context);
}
void
moo_plugin_method_new (const char *name,
GType ptype,
GCallback method,
GClosureMarshal c_marshaller,
GType return_type,
guint n_params,
...)
{
va_list args;
GClosure *closure;
g_return_if_fail (g_type_is_a (ptype, MOO_TYPE_PLUGIN));
g_return_if_fail (name != NULL);
g_return_if_fail (method != NULL);
g_return_if_fail (c_marshaller != NULL);
closure = g_cclosure_new (method, NULL, NULL);
g_closure_sink (g_closure_ref (closure));
va_start (args, n_params);
moo_plugin_method_new_valist (name, ptype, closure, c_marshaller,
return_type, n_params, args);
va_end (args);
g_closure_unref (closure);
}
/**
* thunar_clipboard_manager_paste_files:
* @manager : a #XfdesktopClipboardManager.
* @target_file : the #GFile of the folder to which the contents on the clipboard
* should be pasted.
* @widget : a #GtkWidget, on which to perform the paste or %NULL if no widget is
* known.
* @new_files_closure : a #GClosure to connect to the job's "new-files" signal,
* which will be emitted when the job finishes with the
* list of #GFile<!---->s created by the job, or
* %NULL if you're not interested in the signal.
*
* Pastes the contents from the clipboard associated with @manager to the directory
* referenced by @target_file.
* Code copied and adapted from thunar-clipboard-manager.c
* Copyright (c) 2005-2006 Benedikt Meurer <*****@*****.**>
* Copyright (c) 2009-2011 Jannis Pohlmann <*****@*****.**>
**/
void
xfdesktop_clipboard_manager_paste_files (XfdesktopClipboardManager *manager,
GFile *target_file,
GtkWidget *widget,
GClosure *new_files_closure)
{
XfdesktopClipboardPasteRequest *request;
g_return_if_fail (XFDESKTOP_IS_CLIPBOARD_MANAGER (manager));
g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
/* prepare the paste request */
request = g_slice_new0 (XfdesktopClipboardPasteRequest);
request->manager = g_object_ref (G_OBJECT (manager));
request->target_file = g_object_ref (target_file);
request->widget = widget;
/* take a reference on the closure (if any) */
if (G_LIKELY (new_files_closure != NULL))
{
request->new_files_closure = new_files_closure;
g_closure_ref (new_files_closure);
g_closure_sink (new_files_closure);
}
/* get notified when the widget is destroyed prior to
* completing the clipboard contents retrieval
*/
if (G_LIKELY (request->widget != NULL))
g_object_add_weak_pointer (G_OBJECT (request->widget), (gpointer) &request->widget);
/* schedule the request */
gtk_clipboard_request_contents (manager->clipboard, manager->x_special_gnome_copied_files,
xfdesktop_clipboard_manager_contents_received, request);
}
/*
* 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);
}
}
/**
* 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);
}
}
static VALUE
rg_initialize(VALUE self)
{
GClosure* closure = g_rclosure_new(rb_block_proc(), Qnil, NULL);
G_INITIALIZE(self, closure);
g_closure_sink(closure);
return self;
}
void owl_variable_dict_newvar_other(owl_vardict *vd, const char *name, const char *summary, const char *description, const char *validsettings, bool takes_on_off, GClosure *get_tostring_fn, GClosure *set_fromstring_fn)
{
owl_variable *var = owl_variable_newvar(OWL_VARIABLE_OTHER, name, summary,
description, validsettings);
var->takes_on_off = takes_on_off;
var->get_tostring_fn = g_closure_ref(get_tostring_fn);
g_closure_sink(get_tostring_fn);
var->set_fromstring_fn = g_closure_ref(set_fromstring_fn);
g_closure_sink(set_fromstring_fn);
var->default_str = owl_variable_get_tostring(var);
/* Note: this'll overwrite any existing variable of that name, even a C one,
but it's consistent with previous behavior and commands. */
owl_variable_dict_add_variable(vd, var);
}
/* Hack. We iterate over the accel map instead of the actions,
* in order to pull the parameters out of accel map entries
*/
static void
add_accel_closure (gpointer data,
const gchar *accel_path,
guint accel_key,
GdkModifierType accel_mods,
gboolean changed)
{
GtkApplicationWindow *window = data;
GActionGroup *actions;
const gchar *path;
const gchar *p;
gchar *action_name;
GVariant *parameter;
AccelClosure *closure;
if (accel_key == 0)
return;
if (!g_str_has_prefix (accel_path, "<GAction>/"))
return;
path = accel_path + strlen ("<GAction>/");
p = strchr (path, '/');
if (p)
{
action_name = g_strndup (path, p - path);
parameter = g_variant_parse (NULL, p + 1, NULL, NULL, NULL);
if (!parameter)
g_warning ("Failed to parse parameter from '%s'\n", accel_path);
}
else
{
action_name = g_strdup (path);
parameter = NULL;
}
actions = G_ACTION_GROUP (_gtk_widget_get_action_muxer (GTK_WIDGET (window)));
if (g_action_group_has_action (actions, action_name))
{
closure = (AccelClosure*) g_closure_new_object (sizeof (AccelClosure), g_object_ref (actions));
g_closure_set_marshal (&closure->closure, accel_activate);
closure->action_name = g_strdup (action_name);
closure->parameter = parameter ? g_variant_ref_sink (parameter) : NULL;
window->priv->accel_closures = g_slist_prepend (window->priv->accel_closures, g_closure_ref (&closure->closure));
g_closure_sink (&closure->closure);
gtk_accel_group_connect_by_path (window->priv->accels, accel_path, &closure->closure);
}
else if (parameter)
{
g_variant_unref (parameter);
}
g_free (action_name);
}
static inline GClosure *createCppClosure(ClosureDataBase *closureData)
{
GClosure *closure = g_closure_new_simple(sizeof(GClosure), closureData);
g_closure_set_marshal(closure, &c_marshaller);
g_closure_add_finalize_notifier(closure, NULL, &closureDestroyNotify);
g_closure_ref(closure);
g_closure_sink(closure);
return closure;
}
CALLER_OWN GClosure *owl_variable_make_closure(owl_variable *v,
GCallback fn,
GClosureMarshal marshal) {
GClosure *closure = g_cclosure_new_swap(fn, v, NULL);
g_closure_set_marshal(closure,marshal);
g_closure_ref(closure);
g_closure_sink(closure);
return closure;
}
static void
test_closure (GClosure *closure)
{
/* try to produce high contention in closure->ref_count */
guint i = 0, n = quick_rand32() % 199;
for (i = 0; i < n; i++)
g_closure_ref (closure);
g_closure_sink (closure); /* NOP */
for (i = 0; i < n; i++)
g_closure_unref (closure);
}
/**
* 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);
}
/**
* pyg_signal_class_closure_get:
*
* Returns the GClosure used for the class closure of signals. When
* called, it will invoke the method do_signalname (for the signal
* "signalname").
*
* Returns: the closure.
*/
GClosure *
pyg_signal_class_closure_get(void)
{
static GClosure *closure;
if (closure == NULL) {
closure = g_closure_new_simple(sizeof(GClosure), NULL);
g_closure_set_marshal(closure, pyg_signal_class_closure_marshal);
g_closure_ref(closure);
g_closure_sink(closure);
}
return closure;
}
void
moo_plugin_method_newv (const char *name,
GType ptype,
GClosure *closure,
GClosureMarshal c_marshaller,
GType return_type,
guint n_params,
const GType *param_types)
{
MooPluginMeth *m;
GHashTable *meths;
char *norm_name;
g_return_if_fail (g_type_is_a (ptype, MOO_TYPE_PLUGIN));
g_return_if_fail (name != NULL);
g_return_if_fail (closure != NULL);
g_return_if_fail (c_marshaller != NULL);
g_return_if_fail (!n_params || param_types);
norm_name = g_strdelimit (g_strdup (name), "_", '-');
meths = g_type_get_qdata (ptype, MOO_PLUGIN_METHS_QUARK);
if (meths)
{
if (g_hash_table_lookup (meths, norm_name) != NULL)
{
g_warning ("method '%s' is already registered for type '%s'",
name, g_type_name (ptype));
g_free (norm_name);
return;
}
}
else
{
meths = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
(GDestroyNotify) meth_free);
g_type_set_qdata (ptype, MOO_PLUGIN_METHS_QUARK, meths);
}
m = g_new0 (MooPluginMeth, 1);
m->ptype = ptype;
m->return_type = return_type;
m->n_params = n_params;
m->param_types = n_params ? g_memdup (param_types, n_params * sizeof (GType)) : NULL;
m->closure = g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal (closure, c_marshaller);
g_hash_table_insert (meths, norm_name, m);
}
/**
* playerctl_player_on:
* @self: an #PlayerctlPlayer
* @event: the event to subscribe to
* @callback: the callback to run on the event
*
* A convenience function for bindings to subscribe an event with a callback
*
* Returns: (transfer none): the #PlayerctlPlayer for chaining
*/
PlayerctlPlayer *playerctl_player_on(PlayerctlPlayer *self, const gchar *event, GClosure *callback, GError **err)
{
GError *tmp_error = NULL;
if (self->priv->init_error != NULL) {
g_propagate_error(err, g_error_copy(self->priv->init_error));
return self;
}
g_closure_ref(callback);
g_closure_sink(callback);
g_signal_connect_closure(self, event, callback, TRUE);
return self;
}
static void
infobar_response_cb (GtkInfoBar *infobar, gint response, RBImportErrorsSource *source)
{
char **details = NULL;
GtkTreeIter iter;
GClosure *closure;
int i;
/* gather plugin installer detail strings */
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (source->priv->missing_plugin_model), &iter) == FALSE) {
return;
}
i = 0;
do {
RhythmDBEntry *entry;
char **bits;
int j;
entry = rhythmdb_query_model_iter_to_entry (source->priv->missing_plugin_model, &iter);
bits = g_strsplit (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_COMMENT), "\n", 0);
for (j = 0; bits[j] != NULL; j++) {
if (rb_str_in_strv (bits[j], (const char **)details) == FALSE) {
details = g_realloc (details, sizeof (char *) * i+2);
details[i++] = g_strdup (bits[j]);
details[i] = NULL;
}
}
g_strfreev (bits);
} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (source->priv->missing_plugin_model), &iter));
/* run the installer */
closure = g_cclosure_new ((GCallback) missing_plugins_retry_cb,
g_object_ref (source),
(GClosureNotify) missing_plugins_retry_cleanup);
g_closure_set_marshal (closure, g_cclosure_marshal_VOID__BOOLEAN);
if (rb_missing_plugins_install ((const char **)details, TRUE, closure) == TRUE) {
/* disable the button while the installer is running */
gtk_info_bar_set_response_sensitive (infobar, response, FALSE);
}
g_closure_sink (closure);
g_strfreev (details);
}
/**
* 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);
}
static JSBool
gjs_timeout_add(JSContext *context,
JSObject *obj,
uintN argc,
jsval *argv,
jsval *retval)
{
GClosure *closure;
JSObject *callback;
guint32 interval;
guint id;
/* Best I can tell, there is no way to know if argv[1] is really
* callable other than to just try it. Checking whether it's a
* function will not detect native objects that provide
* JSClass::call, for example.
*/
if (!gjs_parse_args(context, "timeout_add", "uo", argc, argv,
"interval", &interval, "callback", &callback))
return JS_FALSE;
closure = gjs_closure_new(context, callback, "timeout");
if (closure == NULL)
return JS_FALSE;
g_closure_ref(closure);
g_closure_sink(closure);
id = g_timeout_add_full(G_PRIORITY_DEFAULT,
interval,
closure_source_func,
closure,
closure_destroy_notify);
/* this is needed to remove the timeout if the JSContext is
* destroyed.
*/
g_closure_add_invalidate_notifier(closure, GUINT_TO_POINTER(id),
closure_invalidated);
if (!JS_NewNumberValue(context, id, retval))
return JS_FALSE;
return JS_TRUE;
}
/**
* 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);
}
}
void
terminal_accels_init (void)
{
guint i, j;
settings_keybindings = g_settings_new (CONF_KEYS_SCHEMA);
g_signal_connect (settings_keybindings,
"changed",
G_CALLBACK(keys_change_notify),
NULL);
gsettings_key_to_entry = g_hash_table_new (g_str_hash, g_str_equal);
notification_group = gtk_accel_group_new ();
for (i = 0; i < G_N_ELEMENTS (all_entries); ++i)
{
for (j = 0; j < all_entries[i].n_elements; ++j)
{
KeyEntry *key_entry;
key_entry = &(all_entries[i].key_entry[j]);
g_hash_table_insert (gsettings_key_to_entry,
(gpointer) key_entry->gsettings_key,
key_entry);
key_entry->closure = g_closure_new_simple (sizeof (GClosure), key_entry);
g_closure_ref (key_entry->closure);
g_closure_sink (key_entry->closure);
gtk_accel_group_connect_by_path (notification_group,
I_(key_entry->accel_path),
key_entry->closure);
keys_change_notify (settings_keybindings, key_entry->gsettings_key, NULL);
}
}
g_signal_connect (notification_group, "accel-changed",
G_CALLBACK (accel_changed_callback), NULL);
}
/**
* 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);
}
}
static void
gtk_action_init (GtkAction *action)
{
action->private_data = G_TYPE_INSTANCE_GET_PRIVATE (action,
GTK_TYPE_ACTION,
GtkActionPrivate);
action->private_data->name = NULL;
action->private_data->label = NULL;
action->private_data->short_label = NULL;
action->private_data->tooltip = NULL;
action->private_data->stock_id = NULL;
action->private_data->icon_name = NULL;
action->private_data->visible_horizontal = TRUE;
action->private_data->visible_vertical = TRUE;
action->private_data->visible_overflown = TRUE;
action->private_data->is_important = FALSE;
action->private_data->hide_if_empty = TRUE;
action->private_data->always_show_image = FALSE;
action->private_data->activate_blocked = FALSE;
action->private_data->sensitive = TRUE;
action->private_data->visible = TRUE;
action->private_data->label_set = FALSE;
action->private_data->short_label_set = FALSE;
action->private_data->accel_count = 0;
action->private_data->accel_group = NULL;
action->private_data->accel_quark = 0;
action->private_data->accel_closure =
g_closure_new_object (sizeof (GClosure), G_OBJECT (action));
g_closure_set_marshal (action->private_data->accel_closure,
closure_accel_activate);
g_closure_ref (action->private_data->accel_closure);
g_closure_sink (action->private_data->accel_closure);
action->private_data->action_group = NULL;
action->private_data->proxies = NULL;
action->private_data->gicon = NULL;
}
static JSBool
gjs_timeout_add_seconds(JSContext *context,
JSObject *obj,
uintN argc,
jsval *argv,
jsval *retval)
{
GClosure *closure;
JSObject *callback;
guint32 interval;
guint id;
/* See comment for timeout_add above */
if (!gjs_parse_args(context, "timeout_add_seconds", "uo", argc, argv,
"interval", &interval, "callback", &callback))
return JS_FALSE;
closure = gjs_closure_new(context, callback, "timeout_seconds");
if (closure == NULL)
return JS_FALSE;
g_closure_ref(closure);
g_closure_sink(closure);
id = g_timeout_add_seconds_full(G_PRIORITY_DEFAULT,
interval,
closure_source_func,
closure,
closure_destroy_notify);
/* this is needed to remove the timeout if the JSContext is
* destroyed.
*/
g_closure_add_invalidate_notifier(closure, GUINT_TO_POINTER(id),
closure_invalidated);
if (!JS_NewNumberValue(context, id, retval))
return JS_FALSE;
return JS_TRUE;
}
/**
* e_soup_ssl_trust_connect:
* @soup_message: a #SoupMessage about to be sent to the source
* @source: an #ESource that uses WebDAV
*
* Sets up automatic SSL certificate trust handling for @soup_message using the trust
* data stored in @source's WebDAV extension. If @soup_message is about to be sent on
* an SSL connection with an invalid certificate, the code checks if the WebDAV
* extension already has a trust response for that certificate and verifies it
* with e_source_webdav_verify_ssl_trust(). If the verification fails, then
* the @soup_message send also fails.
*
* This works by connecting to the "network-event" signal on @soup_message and
* connecting to the "accept-certificate" signal on each #GTlsConnection for
* which @soup_message reports a #G_SOCKET_CLIENT_TLS_HANDSHAKING event. These
* handlers are torn down automatically when @soup_message is disposed. This process
* is not thread-safe; it is sufficient for safety if all use of @soup_message's
* session and the disposal of @soup_message occur in the same thread.
*
* Since: 3.16
**/
void
e_soup_ssl_trust_connect (SoupMessage *soup_message,
ESource *source)
{
ESoupSslTrustData *handler;
g_return_if_fail (SOUP_IS_MESSAGE (soup_message));
g_return_if_fail (E_IS_SOURCE (source));
handler = g_malloc (sizeof (ESoupSslTrustData));
handler->soup_message = soup_message;
g_object_weak_ref (G_OBJECT (soup_message), e_soup_ssl_trust_message_finalized_cb, handler);
handler->source = g_object_ref (source);
handler->accept_certificate_closure = g_cclosure_new (G_CALLBACK (e_soup_ssl_trust_accept_certificate_cb), handler, NULL);
g_closure_ref (handler->accept_certificate_closure);
g_closure_sink (handler->accept_certificate_closure);
g_signal_connect (
soup_message, "network-event",
G_CALLBACK (e_soup_ssl_trust_network_event_cb), handler);
}
static gboolean
emit_status_changed (RhythmDBImportJob *job)
{
g_mutex_lock (&job->priv->lock);
job->priv->status_changed_id = 0;
rb_debug ("emitting status changed: %d/%d", job->priv->imported, job->priv->total);
g_signal_emit (job, signals[STATUS_CHANGED], 0, job->priv->total, job->priv->imported);
/* temporary ref while emitting this signal as we're expecting the caller
* to release the final reference there.
*/
g_object_ref (job);
if (job->priv->scan_complete && job->priv->imported >= job->priv->total) {
if (job->priv->retry_entries != NULL && job->priv->retried == FALSE) {
gboolean processing = FALSE;
char **details = NULL;
GClosure *retry;
GSList *l;
int i;
/* gather missing plugin details etc. */
i = 0;
for (l = job->priv->retry_entries; l != NULL; l = l->next) {
RhythmDBEntry *entry;
char **bits;
int j;
entry = (RhythmDBEntry *)l->data;
bits = g_strsplit (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_COMMENT), "\n", 0);
for (j = 0; bits[j] != NULL; j++) {
if (rb_str_in_strv (bits[j], (const char **)details) == FALSE) {
details = g_realloc (details, sizeof (char *) * (i+2));
details[i++] = g_strdup (bits[j]);
details[i] = NULL;
}
}
g_strfreev (bits);
}
retry = g_cclosure_new ((GCallback) missing_plugins_retry_cb,
g_object_ref (job),
(GClosureNotify)g_object_unref);
g_closure_set_marshal (retry, g_cclosure_marshal_VOID__BOOLEAN);
processing = rb_missing_plugins_install ((const char **)details, FALSE, retry);
g_strfreev (details);
if (processing) {
rb_debug ("plugin installation is in progress");
} else {
rb_debug ("no plugin installation attempted; job complete");
g_signal_emit (job, signals[COMPLETE], 0, job->priv->total);
}
g_closure_sink (retry);
} else {
rb_debug ("emitting job complete");
g_signal_emit (job, signals[COMPLETE], 0, job->priv->total);
}
}
g_mutex_unlock (&job->priv->lock);
g_object_unref (job);
return FALSE;
}
void dt_lua_do_chunk_async_internal(const char * call_function, int line, lua_CFunction pusher,dt_lua_async_call_arg_type arg_type,...)
{
#ifdef _DEBUG
dt_print(DT_DEBUG_LUA,"LUA DEBUG : %s called from %s %d\n",__FUNCTION__,call_function,line);
#endif
dt_job_t *job = dt_control_job_create(&async_callback_job, "lua: async call");
if(job)
{
async_call_data*data = malloc(sizeof(async_call_data));
data->pusher = pusher;
data->extra=NULL;
va_list ap;
va_start(ap,arg_type);
dt_lua_async_call_arg_type cur_type = arg_type;
while(cur_type != LUA_ASYNC_DONE){
data->extra=g_list_append(data->extra,GINT_TO_POINTER(cur_type));
switch(cur_type) {
case LUA_ASYNC_TYPEID:
data->extra=g_list_append(data->extra,GINT_TO_POINTER(va_arg(ap,luaA_Type)));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
break;
case LUA_ASYNC_TYPEID_WITH_FREE:
{
data->extra=g_list_append(data->extra,GINT_TO_POINTER(va_arg(ap,luaA_Type)));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
GClosure* closure = va_arg(ap,GClosure*);
g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal(closure, g_cclosure_marshal_generic);
data->extra=g_list_append(data->extra,closure);
}
break;
case LUA_ASYNC_TYPENAME:
data->extra=g_list_append(data->extra,va_arg(ap,char *));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
break;
case LUA_ASYNC_TYPENAME_WITH_FREE:
{
data->extra=g_list_append(data->extra,va_arg(ap,char *));
data->extra=g_list_append(data->extra,va_arg(ap,gpointer));
GClosure* closure = va_arg(ap,GClosure*);
g_closure_ref (closure);
g_closure_sink (closure);
g_closure_set_marshal(closure, g_cclosure_marshal_generic);
data->extra=g_list_append(data->extra,closure);
}
break;
default:
// should never happen
g_assert(false);
break;
}
cur_type = va_arg(ap,dt_lua_async_call_arg_type);
}
va_end(ap);
dt_control_job_set_params(job, data, async_callback_job_destructor);
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_FG, job);
}
}
static void
missing_encoder_response_cb (GtkDialog *dialog, gint response, RBTrackTransferQueue *queue)
{
GClosure *retry;
GstEncodingTarget *target;
GPtrArray *details;
GList *profiles;
const GList *l;
RBEncoder *encoder;
switch (response) {
case GTK_RESPONSE_YES:
/* 'continue' -> start the batch */
rb_debug ("starting batch regardless of missing plugins");
actually_start_batch (queue);
break;
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
/* 'cancel' -> cancel the batch and start the next one */
rb_debug ("cancelling batch");
_rb_track_transfer_batch_cancel (queue->priv->current);
g_object_unref (queue->priv->current);
queue->priv->current = NULL;
start_next_batch (queue);
break;
case GTK_RESPONSE_ACCEPT:
/* 'install plugins' -> try to install encoder/muxer */
/* get profiles that need plugins installed */
profiles = NULL;
encoder = rb_encoder_new ();
g_object_get (queue->priv->current, "encoding-target", &target, NULL);
for (l = gst_encoding_target_get_profiles (target); l != NULL; l = l->next) {
GstEncodingProfile *profile = GST_ENCODING_PROFILE (l->data);
char *profile_media_type;
profile_media_type = rb_gst_encoding_profile_get_media_type (profile);
if (profile_media_type != NULL &&
(rb_gst_media_type_is_lossless (profile_media_type) == FALSE) &&
rb_encoder_get_missing_plugins (encoder, profile, NULL, NULL)) {
profiles = g_list_append (profiles, profile);
}
g_free (profile_media_type);
}
g_object_unref (encoder);
g_object_unref (target);
if (profiles == NULL) {
rb_debug ("apparently we don't need any plugins any more");
actually_start_batch (queue);
break;
}
rb_debug ("attempting plugin installation");
details = get_missing_plugin_strings (profiles, FALSE);
retry = g_cclosure_new ((GCallback) missing_plugins_retry_cb,
g_object_ref (queue),
(GClosureNotify) g_object_unref);
g_closure_set_marshal (retry, g_cclosure_marshal_VOID__BOOLEAN);
if (rb_missing_plugins_install ((const char **)details->pdata, FALSE, retry)) {
rb_debug ("attempting to install missing plugins for transcoding");
} else {
rb_debug ("proceeding without the missing plugins for transcoding");
actually_start_batch (queue);
}
g_closure_sink (retry);
g_ptr_array_free (details, TRUE);
g_list_free (profiles);
break;
default:
g_assert_not_reached ();
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void
thunar_uca_provider_activated (ThunarUcaProvider *uca_provider,
GtkAction *action)
{
GtkTreeRowReference *row;
ThunarUcaContext *uca_context;
GtkTreePath *path;
GtkTreeIter iter;
GtkWidget *dialog;
GtkWidget *window;
gboolean succeed;
GError *error = NULL;
GList *files;
gchar **argv;
gchar *working_directory = NULL;
gchar *filename;
gchar *label;
gchar *uri;
gint argc;
gchar *icon_name = NULL;
gboolean startup_notify;
GClosure *child_watch;
g_return_if_fail (THUNAR_UCA_IS_PROVIDER (uca_provider));
g_return_if_fail (GTK_IS_ACTION (action));
/* check if the row reference is still valid */
row = g_object_get_qdata (G_OBJECT (action), thunar_uca_row_quark);
if (G_UNLIKELY (!gtk_tree_row_reference_valid (row)))
return;
/* determine the iterator for the item */
path = gtk_tree_row_reference_get_path (row);
gtk_tree_model_get_iter (GTK_TREE_MODEL (uca_provider->model), &iter, path);
gtk_tree_path_free (path);
/* determine the files and the window for the action */
uca_context = g_object_get_qdata (G_OBJECT (action), thunar_uca_context_quark);
window = thunar_uca_context_get_window (uca_context);
files = thunar_uca_context_get_files (uca_context);
/* determine the argc/argv for the item */
succeed = thunar_uca_model_parse_argv (uca_provider->model, &iter, files, &argc, &argv, &error);
if (G_LIKELY (succeed))
{
/* get the icon name and whether startup notification is active */
gtk_tree_model_get (GTK_TREE_MODEL (uca_provider->model), &iter,
THUNAR_UCA_MODEL_COLUMN_ICON, &icon_name,
THUNAR_UCA_MODEL_COLUMN_STARTUP_NOTIFY, &startup_notify,
-1);
/* determine the working from the first file */
if (G_LIKELY (files != NULL))
{
/* determine the filename of the first selected file */
uri = thunarx_file_info_get_uri (files->data);
filename = g_filename_from_uri (uri, NULL, NULL);
if (G_LIKELY (filename != NULL))
{
/* if this is a folder action, we just use the filename as working directory */
if (g_object_get_qdata (G_OBJECT (action), thunar_uca_folder_quark) != NULL)
{
working_directory = filename;
filename = NULL;
}
else
{
working_directory = g_path_get_dirname (filename);
}
}
g_free (filename);
g_free (uri);
}
/* build closre for child watch */
child_watch = g_cclosure_new_swap (G_CALLBACK (thunar_uca_provider_child_watch),
uca_provider, thunar_uca_provider_child_watch_destroy);
g_closure_ref (child_watch);
g_closure_sink (child_watch);
/* spawn the command on the window's screen */
succeed = xfce_spawn_on_screen_with_child_watch (gtk_widget_get_screen (GTK_WIDGET (window)),
working_directory, argv, NULL,
G_SPAWN_SEARCH_PATH,
startup_notify,
gtk_get_current_event_time (),
icon_name,
child_watch,
&error);
/* check if we succeed */
if (G_LIKELY (succeed))
{
/* release existing child watch */
thunar_uca_provider_child_watch_destroy (uca_provider, NULL);
/* set new closure */
uca_provider->child_watch = child_watch;
/* take over ownership of the working directory as child watch path */
uca_provider->child_watch_path = working_directory;
working_directory = NULL;
}
else
{
/* spawn failed, release watch */
g_closure_unref (child_watch);
}
/* cleanup */
g_free (working_directory);
g_strfreev (argv);
g_free (icon_name);
}
/* present error message to the user */
if (G_UNLIKELY (!succeed))
{
g_object_get (G_OBJECT (action), "label", &label, NULL);
dialog = gtk_message_dialog_new ((GtkWindow *) window,
GTK_DIALOG_DESTROY_WITH_PARENT
| GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Failed to launch action \"%s\"."), label);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s.", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
g_free (label);
}
}