GVariant * ostree_zlib_file_header_new (GFileInfo *file_info, GVariant *xattrs) { guint64 size; guint32 uid; guint32 gid; guint32 mode; guint32 rdev; const char *symlink_target; GVariant *ret; ot_lvariant GVariant *tmp_xattrs = NULL; size = g_file_info_get_size (file_info); uid = g_file_info_get_attribute_uint32 (file_info, "unix::uid"); gid = g_file_info_get_attribute_uint32 (file_info, "unix::gid"); mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode"); rdev = g_file_info_get_attribute_uint32 (file_info, "unix::rdev"); if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_SYMBOLIC_LINK) symlink_target = g_file_info_get_symlink_target (file_info); else symlink_target = ""; if (xattrs == NULL) tmp_xattrs = g_variant_ref_sink (g_variant_new_array (G_VARIANT_TYPE ("(ayay)"), NULL, 0)); ret = g_variant_new ("(tuuuus@a(ayay))", GUINT64_TO_BE (size), GUINT32_TO_BE (uid), GUINT32_TO_BE (gid), GUINT32_TO_BE (mode), GUINT32_TO_BE (rdev), symlink_target, xattrs ? xattrs : tmp_xattrs); g_variant_ref_sink (ret); return ret; }
static void _answer_clicked(void *_data, Evas_Object * obj, void *event_info) { (void) obj; (void) event_info; GHashTable *options; struct MessageShowViewData *view = (struct MessageShowViewData *) _data; g_debug("message_show_view_answer_clicked()"); options = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, common_utils_variant_unref); if (!view->number) { g_warning("Trying to answer a message without number?!"); return; } g_hash_table_insert(options, "Phone", g_variant_ref_sink(g_variant_new_string(view->number))); if (view->name) { g_hash_table_insert(options, "Name", g_variant_ref_sink(g_variant_new_string(view->name))); } if (view->photopath) { g_hash_table_insert(options, "Photo", g_variant_ref_sink(g_variant_new_string(view->photopath))); } phoneui_messages_message_new(options); //g_hash_table_destroy(options); }
static gboolean ol_config_proxy_set_default (OlConfigProxy *config, const gchar *key, GVariant *value) { ol_assert_ret (key != NULL && key[0] != '\0', FALSE); OlConfigProxyPrivate *priv = OL_CONFIG_PROXY_GET_PRIVATE (config); if (key[0] == '.' && !g_hash_table_lookup (priv->temp_values, key)) { g_variant_ref_sink (value); g_hash_table_insert (priv->temp_values, g_strdup (key), g_variant_new ("(*)", g_variant_ref_sink (value))); g_signal_emit (config, _signals[SIGNAL_CHANGED], g_quark_from_string (key), key); g_variant_unref (value); } else { if (priv->default_builder == NULL) { priv->default_builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); priv->default_sync_handler = g_timeout_add (DEFAULT_SYNC_TIMEOUT, (GSourceFunc) _sync_default_cb, config); } g_variant_builder_add (priv->default_builder, "{sv}", key, value); } return TRUE; }
static GVariant *prv_get_prop(dleyna_settings_t *settings, const gchar *prop) { GVariant *retval = NULL; #if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_DEBUG gchar *prop_str; #endif if (!strcmp(prop, DLR_INTERFACE_PROP_NEVER_QUIT)) retval = g_variant_ref_sink(g_variant_new_boolean( dleyna_settings_is_never_quit( settings))); else if (!strcmp(prop, DLR_INTERFACE_PROP_WHITE_LIST_ENABLED)) retval = g_variant_ref_sink(g_variant_new_boolean( dleyna_settings_is_white_list_enabled( settings))); else if (!strcmp(prop, DLR_INTERFACE_PROP_WHITE_LIST_ENTRIES)) retval = g_variant_ref_sink(prv_build_wl_entries(settings)); #if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_DEBUG if (retval) { prop_str = g_variant_print(retval, FALSE); DLEYNA_LOG_DEBUG("Prop %s = %s", prop, prop_str); g_free(prop_str); } #endif return retval; }
static void _number_button_add_clicked(void *data, Evas_Object *obj, void *event_info) { (void) obj; (void) event_info; struct MessageNewViewData *view = (struct MessageNewViewData *)data; if (phone_utils_sms_is_valid_number(view->number)) { GHashTable *properties = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, common_utils_variant_unref); g_hash_table_insert(properties, "Name", g_variant_ref_sink(g_variant_new_string("Number"))); g_hash_table_insert(properties, "Phone", g_variant_ref_sink(g_variant_new_string(view->number))); g_hash_table_insert(properties, "Photo", g_variant_ref_sink(g_variant_new_string(CONTACT_NUMBER_PHOTO))); g_ptr_array_add(view->recipients, properties); _process_recipient(properties, view); view->number[0] = '\0'; view->number_length = 0; _number_update_number(view); elm_naviframe_item_simple_promote(view->pager, view->layout_recipients); } else { if (!view->notify) { view->notify = ui_utils_notify(ui_utils_view_window_get(VIEW_PTR(*view)), D_("You have entered<br>an invalid number."), 5); } evas_object_show(view->notify); } }
static struct sr_option *get_options(void) { if (!options[0].def) { options[0].def = g_variant_ref_sink(g_variant_new_int32(DEFAULT_NUM_CHANNELS)); options[1].def = g_variant_ref_sink(g_variant_new_uint64(DEFAULT_SAMPLERATE)); } return options; }
static void _add_entry(GHashTable *entry) { Elm_Object_Item *glit; GVariant *val; int received = 0, answered = 0; val = g_hash_table_lookup(entry, "Direction"); if (val) { const char *dir = g_variant_get_string(val, NULL); if (!strcmp(dir, "in")) { received = 1; } } else { g_warning("ignoring call without Direction field!!"); return; } val = g_hash_table_lookup(entry, "Answered"); if (val) { if (g_variant_get_boolean(val)) { answered = 1; } } glit = elm_genlist_item_append(view.list_all, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_all", g_variant_ref_sink(val)); if (received) { if (answered) { glit = elm_genlist_item_append(view.list_in, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_in", g_variant_ref_sink(val)); } else { glit = elm_genlist_item_append(view.list_missed, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_missed", g_variant_ref_sink(val)); } } else { glit = elm_genlist_item_append(view.list_out, &itc, g_hash_table_ref(entry), NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL); val = g_variant_new_int32(GPOINTER_TO_INT(glit)); g_hash_table_insert(entry, "_item_out", g_variant_ref_sink(val)); } }
static void init_gsettings (void) { #ifdef HAVE_GSETTINGS GVariant *val; const gchar *const *schemas; int schema_found = 0; #if ! GLIB_CHECK_VERSION (2, 36, 0) g_type_init (); #endif schemas = g_settings_list_schemas (); if (schemas == NULL) return; while (! schema_found && *schemas != NULL) schema_found = strcmp (*schemas++, GSETTINGS_SCHEMA) == 0; if (!schema_found) return; gsettings_client = g_settings_new (GSETTINGS_SCHEMA); if (!gsettings_client) return; g_object_ref_sink (G_OBJECT (gsettings_client)); g_signal_connect (G_OBJECT (gsettings_client), "changed", G_CALLBACK (something_changed_gsettingsCB), NULL); val = g_settings_get_value (gsettings_client, GSETTINGS_TOOL_BAR_STYLE); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) current_tool_bar_style = map_tool_bar_style (g_variant_get_string (val, NULL)); g_variant_unref (val); } #ifdef HAVE_XFT val = g_settings_get_value (gsettings_client, GSETTINGS_MONO_FONT); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) current_mono_font = xstrdup (g_variant_get_string (val, NULL)); g_variant_unref (val); } val = g_settings_get_value (gsettings_client, GSETTINGS_FONT_NAME); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) current_font = xstrdup (g_variant_get_string (val, NULL)); g_variant_unref (val); } #endif /* HAVE_XFT */ #endif /* HAVE_GSETTINGS */ }
/***************************************************************************** * neardal_set_adapter_property: Set a property on a specific NEARDAL adapter ****************************************************************************/ errorCode_t neardal_set_adapter_property(const char *adpName, int adpPropId, void *value) { errorCode_t err = NEARDAL_SUCCESS; AdpProp *adpProp = NULL; const gchar *propKey = NULL; GVariant *propValue = NULL; GVariant *variantTmp = NULL; if (neardalMgr.proxy == NULL) neardal_prv_construct(&err); if (err != NEARDAL_SUCCESS || adpName == NULL) goto exit; err = neardal_mgr_prv_get_adapter((gchar *) adpName, &adpProp); if (err != NEARDAL_SUCCESS) goto exit; switch (adpPropId) { case NEARD_ADP_PROP_POWERED: propKey = "Powered"; variantTmp = g_variant_new_boolean(GPOINTER_TO_UINT(value)); g_variant_ref_sink(variantTmp); break; default: break; } propValue = g_variant_new_variant(variantTmp); g_variant_ref_sink(propValue); NEARDAL_TRACE_LOG("Sending:\n%s=%s\n", propKey, g_variant_print(propValue, TRUE)); properties_call_set_sync(adpProp->props, "org.neard.Adapter", propKey, propValue, 0, &neardalMgr.gerror); if (neardalMgr.gerror == NULL) err = NEARDAL_SUCCESS; else { NEARDAL_TRACE_ERR( "DBUS Error (%d): %s\n", neardalMgr.gerror->code, neardalMgr.gerror->message); err = NEARDAL_ERROR_DBUS_INVOKE_METHOD_ERROR; } exit: neardal_tools_prv_free_gerror(&neardalMgr.gerror); neardalMgr.gerror = NULL; g_variant_unref(propValue); g_variant_unref(variantTmp); return err; }
static const struct sr_option *get_options(void) { if (!options[0].def) { options[0].def = g_variant_ref_sink(g_variant_new_string("all")); options[0].values = g_slist_append(options[0].values, g_variant_ref_sink(g_variant_new_string("all"))); options[0].values = g_slist_append(options[0].values, g_variant_ref_sink(g_variant_new_string("spec"))); } return options; }
/** * tp_variant_convert: * @variant: (transfer full): a #GVariant to convert * @type: a #GVariantType @variant must be converted to * * Convert the type of @variant to @type if possible. This takes ownership of * @variant. If no conversion is needed, simply return @variant. If conversion * is not possible, %NULL is returned. * * Returns: (transfer full): a new #GVariant owned by the caller. * Since: 0.19.10 **/ GVariant * tp_variant_convert (GVariant *variant, const GVariantType *type) { GVariant *ret = NULL; gboolean valid; if (variant == NULL) return NULL; g_variant_ref_sink (variant); if (g_variant_is_of_type (variant, type)) return variant; switch (tp_variant_type_classify (type)) { #define CASE(type) \ { \ g##type tmp = _tp_variant_convert_##type (variant, &valid); \ if (valid) \ ret = g_variant_new_##type (tmp); \ } case G_VARIANT_CLASS_DOUBLE: CASE (double); break; case G_VARIANT_CLASS_INT32: CASE (int32); break; case G_VARIANT_CLASS_INT64: CASE (int64); break; case G_VARIANT_CLASS_UINT32: CASE (uint32); break; case G_VARIANT_CLASS_UINT64: CASE (uint64); break; default: break; #undef CASE } g_variant_unref (variant); return (ret != NULL) ? g_variant_ref_sink (ret) : NULL; }
static void something_changed_gsettingsCB (GSettings *settings, gchar *key, gpointer user_data) { GVariant *val; if (strcmp (key, GSETTINGS_TOOL_BAR_STYLE) == 0) { val = g_settings_get_value (settings, GSETTINGS_TOOL_BAR_STYLE); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) { const gchar *newstyle = g_variant_get_string (val, NULL); store_tool_bar_style_changed (newstyle, first_dpyinfo); } g_variant_unref (val); } } #ifdef HAVE_XFT else if (strcmp (key, GSETTINGS_MONO_FONT) == 0) { val = g_settings_get_value (settings, GSETTINGS_MONO_FONT); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) { const gchar *newfont = g_variant_get_string (val, NULL); store_monospaced_changed (newfont); } g_variant_unref (val); } } else if (strcmp (key, GSETTINGS_FONT_NAME) == 0) { val = g_settings_get_value (settings, GSETTINGS_FONT_NAME); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) { const gchar *newfont = g_variant_get_string (val, NULL); store_font_name_changed (newfont); } g_variant_unref (val); } } #endif /* HAVE_XFT */ }
static const struct sr_option *get_options(void) { if (!options[0].def) { options[0].def = g_variant_ref_sink(g_variant_new_int32(DEFAULT_NUM_CHANNELS)); options[1].def = g_variant_ref_sink(g_variant_new_uint64(DEFAULT_SAMPLERATE)); options[2].def = g_variant_ref_sink(g_variant_new_string(sample_formats[0].fmt_name)); for (unsigned int i = 0; i < ARRAY_SIZE(sample_formats); i++) { options[2].values = g_slist_append(options[2].values, g_variant_ref_sink(g_variant_new_string(sample_formats[i].fmt_name))); } } return options; }
GVariant * mm_location_cdma_bs_get_dictionary (MMLocationCdmaBs *self) { GVariantBuilder builder; /* We do allow NULL */ if (!self) return NULL; g_return_val_if_fail (MM_IS_LOCATION_CDMA_BS (self), NULL); /* If mandatory parameters are not found, return NULL */ if (self->priv->longitude == MM_LOCATION_LONGITUDE_UNKNOWN || self->priv->latitude == MM_LOCATION_LATITUDE_UNKNOWN) return NULL; g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&builder, "{sv}", PROPERTY_LONGITUDE, g_variant_new_double (self->priv->longitude)); g_variant_builder_add (&builder, "{sv}", PROPERTY_LATITUDE, g_variant_new_double (self->priv->latitude)); return g_variant_ref_sink (g_variant_builder_end (&builder)); }
static void prv_process_sync_task(dld_task_t *task) { GError *error; switch (task->type) { case DLD_TASK_GET_VERSION: task->result = g_variant_ref_sink(g_variant_new_string( VERSION)); dld_task_complete(task); break; case DLD_TASK_GET_DEVICES: task->result = dld_upnp_get_device_ids(g_context.upnp); dld_task_complete(task); break; case DLD_TASK_RESCAN: dld_upnp_rescan(g_context.upnp); dld_task_complete(task); break; default: goto finished; break; } dleyna_task_queue_task_completed(task->atom.queue_id); finished: return; }
/** * List all possible values for a configuration key. * * @param[in] driver The sr_dev_driver struct to query. Must not be NULL. * @param[in] sdi (optional) If the key is specific to a device, this must * contain a pointer to the struct sr_dev_inst to be checked. * Otherwise it must be NULL. If sdi is != NULL, sdi->priv must * also be != NULL. * @param[in] cg The channel group on the device for which to list the * values, or NULL. * @param[in] key The configuration key (SR_CONF_*). * @param[in,out] data A pointer to a GVariant where the list will be stored. * The caller is given ownership of the GVariant and must thus * unref the GVariant after use. However if this function * returns an error code, the field should be considered * unused, and should not be unreferenced. * * @retval SR_OK Success. * @retval SR_ERR Error. * @retval SR_ERR_ARG The driver doesn't know that key, but this is not to be * interpreted as an error by the caller; merely as an indication * that it's not applicable. * * @since 0.3.0 */ SR_API int sr_config_list(const struct sr_dev_driver *driver, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg, uint32_t key, GVariant **data) { int ret; if (!driver || !data) return SR_ERR; else if (!driver->config_list) return SR_ERR_ARG; else if (key != SR_CONF_SCAN_OPTIONS && key != SR_CONF_DEVICE_OPTIONS) { if (check_key(driver, sdi, cg, key, SR_CONF_LIST, NULL) != SR_OK) return SR_ERR_ARG; } if (sdi && !sdi->priv) { sr_err("Can't list config (sdi != NULL, sdi->priv == NULL)."); return SR_ERR; } if ((ret = driver->config_list(key, data, sdi, cg)) == SR_OK) { log_key(sdi, cg, key, SR_CONF_LIST, *data); g_variant_ref_sink(*data); } return ret; }
static void ide_preferences_spin_button_value_changed (IdePreferencesSpinButton *self, GParamSpec *pspec, GtkSpinButton *spin_button) { GVariant *variant = NULL; gdouble value; g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self)); g_assert (pspec != NULL); g_assert (GTK_IS_SPIN_BUTTON (spin_button)); value = gtk_spin_button_get_value (spin_button); if (g_variant_type_equal (self->type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT16)) variant = g_variant_new_int16 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT16)) variant = g_variant_new_uint16 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT32)) variant = g_variant_new_int32 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT32)) variant = g_variant_new_uint32 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT64)) variant = g_variant_new_int64 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT64)) variant = g_variant_new_uint64 (value); else g_return_if_reached (); g_variant_ref_sink (variant); g_settings_set_value (self->settings, self->key, variant); g_clear_pointer (&variant, g_variant_unref); }
static void g_simple_action_set_state (GAction *action, GVariant *value) { GSimpleAction *simple = G_SIMPLE_ACTION (action); g_return_if_fail (value != NULL); { const GVariantType *state_type; state_type = simple->priv->state ? g_variant_get_type (simple->priv->state) : NULL; g_return_if_fail (state_type != NULL); g_return_if_fail (g_variant_is_of_type (value, state_type)); } g_variant_ref_sink (value); if (!g_variant_equal (simple->priv->state, value)) { if (simple->priv->state) g_variant_unref (simple->priv->state); simple->priv->state = g_variant_ref (value); g_object_notify (G_OBJECT (simple), "state"); } g_variant_unref (value); }
static void impl_get_item_attributes (GMenuModel *menu_model, int item_index, GHashTable **attrs) { RBDisplayPageMenu *menu = RB_DISPLAY_PAGE_MENU (menu_model); RBDisplayPage *page; GtkTreeIter iter; *attrs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref); page = get_page_at_index (menu, item_index, &iter); if (page != NULL) { char *name; char *ptr; GVariant *v; g_object_get (page, "name", &name, NULL); rb_debug ("page at %d is %s", item_index, name); g_hash_table_insert (*attrs, g_strdup ("label"), g_variant_new_string (name)); g_free (name); g_hash_table_insert (*attrs, g_strdup ("action"), g_variant_new_string (menu->priv->action)); ptr = g_strdup_printf ("%p", page); v = g_variant_new_string (ptr); g_hash_table_insert (*attrs, g_strdup ("target"), g_variant_ref_sink (v)); g_free (ptr); g_object_unref (page); } else { rb_debug ("no page at %d", item_index); } }
/** * Read all input from @src, allocating a new #GVariant from it into * output variable @out_variant. @src will be closed as a result. * * Note the returned @out_variant is not floating. */ gboolean ot_util_variant_from_stream (GInputStream *src, const GVariantType *type, gboolean trusted, GVariant **out_variant, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gs_unref_object GMemoryOutputStream *data_stream = NULL; gs_unref_variant GVariant *ret_variant = NULL; data_stream = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free); if (g_output_stream_splice ((GOutputStream*)data_stream, src, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, cancellable, error) < 0) goto out; ret_variant = g_variant_new_from_data (type, g_memory_output_stream_get_data (data_stream), g_memory_output_stream_get_data_size (data_stream), trusted, (GDestroyNotify) g_object_unref, data_stream); data_stream = NULL; /* Transfer ownership */ g_variant_ref_sink (ret_variant); ret = TRUE; ot_transfer_out_value (out_variant, &ret_variant); out: return ret; }
/** * ot_util_variant_map: * @src: a #GFile * @type: Use this for variant * @trusted: See documentation of g_variant_new_from_data() * @out_variant: (out): Return location for new variant * @error: * * Memory-map @src, and store a new #GVariant referring to this memory * in @out_variant. Note the returned @out_variant is not floating. */ gboolean ot_util_variant_map (GFile *src, const GVariantType *type, gboolean trusted, GVariant **out_variant, GError **error) { gboolean ret = FALSE; gs_unref_variant GVariant *ret_variant = NULL; GMappedFile *mfile = NULL; mfile = gs_file_map_noatime (src, NULL, error); if (!mfile) goto out; ret_variant = g_variant_new_from_data (type, g_mapped_file_get_contents (mfile), g_mapped_file_get_length (mfile), trusted, (GDestroyNotify) g_mapped_file_unref, mfile); mfile = NULL; g_variant_ref_sink (ret_variant); ret = TRUE; ot_transfer_out_value(out_variant, &ret_variant); out: if (mfile) g_mapped_file_unref (mfile); return ret; }
/* swiss-army knife: takes an strv of pkgspecs destined for * install, and splits it into repo pkgs, and for local * pkgs, an fd list & idx variant. */ gboolean rpmostree_sort_pkgs_strv (const char *const* pkgs, GUnixFDList *fd_list, GPtrArray **out_repo_pkgs, GVariant **out_fd_idxs, GError **error) { g_autoptr(GPtrArray) repo_pkgs = g_ptr_array_new_with_free_func (g_free); g_auto(GVariantBuilder) builder; g_variant_builder_init (&builder, G_VARIANT_TYPE ("ah")); for (const char *const* pkg = pkgs; pkg && *pkg; pkg++) { if (!g_str_has_suffix (*pkg, ".rpm")) g_ptr_array_add (repo_pkgs, g_strdup (*pkg)); else { glnx_fd_close int fd = -1; if (!glnx_openat_rdonly (AT_FDCWD, *pkg, TRUE, &fd, error)) return FALSE; int idx = g_unix_fd_list_append (fd_list, fd, error); if (idx < 0) return FALSE; g_variant_builder_add (&builder, "h", idx); } } *out_fd_idxs = g_variant_ref_sink (g_variant_new ("ah", &builder)); *out_repo_pkgs = g_steal_pointer (&repo_pkgs); return TRUE; }
/** * @brief Perform sending remote signals to connected clients. * @memberof GstSwitchController */ static void gst_switch_controller_emit_signal (GstSwitchController * controller, const gchar * signame, GVariant * parameters) { GError *error; gboolean res; GList *client; gint num; GST_SWITCH_CONTROLLER_LOCK_CLIENTS (controller); g_assert (parameters); g_variant_ref_sink (parameters); for (client = controller->clients, num = 0; client; client = g_list_next (client)) { error = NULL; res = g_dbus_connection_emit_signal (G_DBUS_CONNECTION (client->data), /*destination_bus_name */ NULL, SWITCH_CONTROLLER_OBJECT_PATH, SWITCH_CONTROLLER_OBJECT_NAME, signame, parameters, &error); if (!res) { g_assert (error != NULL); ERROR ("emit: (%d) %s", num, error->message); } else { ++num; } } /* INFO ("emit: %s (%d/%d)", signame, num, g_list_length (controller->uis)); */ g_variant_unref (parameters); GST_SWITCH_CONTROLLER_UNLOCK_CLIENTS (controller); }
/** * g_notification_add_button_with_target_value: (rename-to g_notification_add_button_with_target) * @notification: a #GNotification * @label: label of the button * @action: an action name * @target: (allow-none): a #GVariant to use as @action's parameter, or %NULL * * Adds a button to @notification that activates @action when clicked. * @action must be an application-wide action (it must start with "app."). * * If @target is non-%NULL, @action will be activated with @target as * its parameter. * * Since: 2.40 */ void g_notification_add_button_with_target_value (GNotification *notification, const gchar *label, const gchar *action, GVariant *target) { Button *button; g_return_if_fail (G_IS_NOTIFICATION (notification)); g_return_if_fail (label != NULL); g_return_if_fail (action != NULL && g_action_name_is_valid (action)); if (!g_str_has_prefix (action, "app.")) { g_warning ("%s: action '%s' does not start with 'app.'." "This is unlikely to work properly.", G_STRFUNC, action); } button = g_slice_new0 (Button); button->label = g_strdup (label); button->action_name = g_strdup (action); if (target) button->target = g_variant_ref_sink (target); g_ptr_array_add (notification->buttons, button); }
static void on_notify (GObject *object, GParamSpec *pspec, gpointer user_data) { GDBusConnection *connection; const gchar *path; GVariant *value; const gchar *property_name; guint prop_id; path = g_object_get_data (object, "gdbus-codegen-path"); connection = g_object_get_data (object, "gdbus-codegen-connection"); if (connection == NULL || path == NULL) goto out; property_name = lookup_property_name_from_property_gname (pspec->name); if (property_name == NULL) goto out; prop_id = lookup_property_id_from_property_name (property_name); value = NULL; switch (prop_id) { } if (value != NULL && property_name != NULL) { queue_notification (object, property_name, g_variant_ref_sink (value)); } out: ; }
static const struct sr_option *get_options(void) { if (!options[0].def) options[0].def = g_variant_ref_sink(g_variant_new_string("")); return options; }
GVariant *dls_upnp_get_server_ids(dls_upnp_t *upnp) { GVariantBuilder vb; GHashTableIter iter; gpointer value; dls_device_t *device; GVariant *retval; DLEYNA_LOG_DEBUG("Enter"); g_variant_builder_init(&vb, G_VARIANT_TYPE("ao")); g_hash_table_iter_init(&iter, upnp->server_udn_map); while (g_hash_table_iter_next(&iter, NULL, &value)) { device = value; DLEYNA_LOG_DEBUG("Have device %s", device->path); g_variant_builder_add(&vb, "o", device->path); } retval = g_variant_ref_sink(g_variant_builder_end(&vb)); DLEYNA_LOG_DEBUG("Exit"); return retval; }
static void variant_table_sink (GHashTable *props, const gchar *name, GVariant *value) { g_hash_table_insert (props, (gchar *)name, g_variant_ref_sink (value)); }
GVariant * mm_network_timezone_get_dictionary (MMNetworkTimezone *self) { GVariantBuilder builder; /* Allow NULL */ if (!self) return NULL; g_return_val_if_fail (MM_IS_NETWORK_TIMEZONE (self), NULL); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); if (self->priv->offset != MM_NETWORK_TIMEZONE_OFFSET_UNKNOWN) g_variant_builder_add (&builder, "{sv}", "offset", g_variant_new_int32 (self->priv->offset)); if (self->priv->dst_offset != MM_NETWORK_TIMEZONE_OFFSET_UNKNOWN) g_variant_builder_add (&builder, "{sv}", "dst-offset", g_variant_new_int32 (self->priv->dst_offset)); if (self->priv->leap_seconds != MM_NETWORK_TIMEZONE_LEAP_SECONDS_UNKNOWN) g_variant_builder_add (&builder, "{sv}", "leap-seconds", g_variant_new_int32 (self->priv->leap_seconds)); return g_variant_ref_sink (g_variant_builder_end (&builder)); }
static gboolean gconf_settings_backend_write (GSettingsBackend *backend, const gchar *key, GVariant *value, gpointer origin_tag) { GConfSettingsBackend *gconf = GCONF_SETTINGS_BACKEND (backend); GConfValue *gconf_value; GError *error; g_variant_ref_sink (value); gconf_value = gconf_settings_backend_gvariant_to_gconf_value (value); g_variant_unref (value); if (gconf_value == NULL) return FALSE; error = NULL; gconf_client_set (gconf->priv->client, key, gconf_value, &error); gconf_value_free (gconf_value); if (error != NULL) { g_error_free (error); return FALSE; } g_settings_backend_changed (backend, key, origin_tag); g_hash_table_replace (gconf->priv->ignore_notifications, g_strdup (key), GINT_TO_POINTER (1)); return TRUE; }