static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GVariant *gvar, *grange[2]; GVariantBuilder gvb; int ret; (void)sdi; (void)cg; ret = SR_OK; switch (key) { case SR_CONF_DEVICE_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, devopts, ARRAY_SIZE(devopts), sizeof(uint32_t)); break; case SR_CONF_SAMPLERATE: g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}")); gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), sl2_samplerates, ARRAY_SIZE(sl2_samplerates), sizeof(uint64_t)); g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar); *data = g_variant_builder_end(&gvb); break; case SR_CONF_TRIGGER_MATCH: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, trigger_matches, ARRAY_SIZE(trigger_matches), sizeof(int32_t)); break; case SR_CONF_LIMIT_SAMPLES: grange[0] = g_variant_new_uint64(0); grange[1] = g_variant_new_uint64(MAX_SAMPLES); *data = g_variant_new_tuple(grange, 2); break; default: return SR_ERR_NA; } return ret; }
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GVariant *tuple, *rational[2]; GVariantBuilder gvb; unsigned int i; (void)sdi; (void)cg; switch (key) { case SR_CONF_DEVICE_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t)); break; case SR_CONF_SAMPLE_INTERVAL: g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY); for (i = 0; i < ARRAY_SIZE(kecheng_kc_330b_sample_intervals); i++) { rational[0] = g_variant_new_uint64(kecheng_kc_330b_sample_intervals[i][0]); rational[1] = g_variant_new_uint64(kecheng_kc_330b_sample_intervals[i][1]); tuple = g_variant_new_tuple(rational, 2); g_variant_builder_add_value(&gvb, tuple); } *data = g_variant_builder_end(&gvb); break; case SR_CONF_SPL_WEIGHT_FREQ: *data = g_variant_new_strv(weight_freq, ARRAY_SIZE(weight_freq)); break; case SR_CONF_SPL_WEIGHT_TIME: *data = g_variant_new_strv(weight_time, ARRAY_SIZE(weight_time)); break; case SR_CONF_DATA_SOURCE: *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources)); break; default: return SR_ERR_NA; } return SR_OK; }
static gboolean register_display (State *state, GCancellable *cancellable) { GdmDBusManager *manager = NULL; GError *error = NULL; gboolean registered = FALSE; GVariantBuilder details; manager = gdm_dbus_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS, "org.gnome.DisplayManager", "/org/gnome/DisplayManager/Manager", cancellable, &error); if (!manager) { g_debug ("could not contact display manager: %s", error->message); g_error_free (error); goto out; } g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}")); g_variant_builder_add (&details, "{ss}", "session-type", "x11"); g_variant_builder_add (&details, "{ss}", "x11-display-name", state->display_name); registered = gdm_dbus_manager_call_register_display_sync (manager, g_variant_builder_end (&details), cancellable, &error); if (error != NULL) { g_debug ("Could not register display: %s", error->message); g_error_free (error); } out: g_clear_object (&manager); return registered; }
GVariant * mm_location_gps_raw_get_dictionary (MMLocationGpsRaw *self) { GVariantBuilder builder; /* We do allow NULL */ if (!self) return NULL; g_return_val_if_fail (MM_IS_LOCATION_GPS_RAW (self), NULL); /* If mandatory parameters are not found, return NULL */ if (!self->priv->utc_time || self->priv->longitude == MM_LOCATION_GPS_RAW_LONGITUDE_UNKNOWN || self->priv->latitude == MM_LOCATION_GPS_RAW_LATITUDE_UNKNOWN) return NULL; g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&builder, "{sv}", PROPERTY_UTC_TIME, g_variant_new_string (self->priv->utc_time)); 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)); /* Altitude is optional */ if (self->priv->altitude != MM_LOCATION_GPS_RAW_ALTITUDE_UNKNOWN) g_variant_builder_add (&builder, "{sv}", PROPERTY_ALTITUDE, g_variant_new_double (self->priv->altitude)); return g_variant_ref_sink (g_variant_builder_end (&builder)); }
static int korva_control_push (KorvaController1 *controller, const char *path, const char *uid, const char *title) { GFile *source; GVariantBuilder *builder; char *out_tag; GError *error = NULL; if (g_str_has_prefix (path, "~")) { source = g_file_parse_name (path); } else { source = g_file_new_for_commandline_arg (path); } builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY); g_variant_builder_add (builder, "{sv}", "URI", g_variant_new_string (g_file_get_uri (source))); if (title != NULL) { g_variant_builder_add (builder, "{sv}", "Title", g_variant_new_string (title)); } korva_controller1_call_push_sync (controller, g_variant_builder_end (builder), device, &out_tag, NULL, &error); if (error != NULL) { g_print ("Failed to Push %s to %s: %s\n", file, device, error->message); g_error_free (error); return 1; } else { g_print ("Pushed %s to %s. The ID is %s\n", file, device, out_tag); return 0; } }
static void prv_wl_notify_prop(dlr_manager_t *manager, const gchar *prop_name, GVariant *prop_val) { GVariant *val; GVariantBuilder array; g_variant_builder_init(&array, G_VARIANT_TYPE("a{sv}")); g_variant_builder_add(&array, "{sv}", prop_name, prop_val); val = g_variant_new("(s@a{sv}as)", DLEYNA_SERVER_INTERFACE_MANAGER, g_variant_builder_end(&array), NULL); (void) dlr_renderer_get_connector()->notify( manager->connection, DLEYNA_SERVER_OBJECT, DLR_INTERFACE_PROPERTIES, DLR_INTERFACE_PROPERTIES_CHANGED, val, NULL); }
static void steadyflow_iapp_service_proxy_set_visible (SteadyflowIAppService* self, gboolean visible, GError** error) { GDBusMessage *_message; GVariant *_arguments; GVariantBuilder _arguments_builder; GDBusMessage *_reply_message; G_IO_ERROR; _message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "net.launchpad.steadyflow.App", "SetVisible"); g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE); g_variant_builder_add_value (&_arguments_builder, g_variant_new_boolean (visible)); _arguments = g_variant_builder_end (&_arguments_builder); g_dbus_message_set_body (_message, _arguments); _reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error); g_object_unref (_message); if (!_reply_message) { return; } if (g_dbus_message_to_gerror (_reply_message, error)) { g_object_unref (_reply_message); return; } g_object_unref (_reply_message); }
void RatingsFilter::UpdateState(float raw_rating) { if (!IsValid()) return; bool new_filtering = raw_rating > 0.0f; GVariantBuilder b; g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}")); g_variant_builder_add(&b, "{sv}", "rating", g_variant_new("d", raw_rating)); IgnoreChanges(true); dee_model_set_value(model_,iter_, FilterColumn::RENDERER_STATE, g_variant_builder_end(&b)); dee_model_set_value(model_, iter_, FilterColumn::FILTERING, g_variant_new("b", new_filtering ? TRUE : FALSE)); IgnoreChanges(false); filtering.EmitChanged(filtering); }
/** * fcitx_input_method_set_imlist: * @im: A #FcitxInputMethod * @array: (element-type FcitxIMItem) (transfer none): A #FcitxIMItem List * * Set Fcitx all im list **/ FCITX_EXPORT_API void fcitx_input_method_set_imlist(FcitxInputMethod *im, GPtrArray *array) { GVariantBuilder builder; g_variant_builder_init(&builder, G_VARIANT_TYPE("a(sssb)")); g_ptr_array_foreach(array, _fcitx_im_item_foreach_cb, &builder); GVariant *value = g_variant_builder_end(&builder); GError *error = NULL; GVariant *result = g_dbus_connection_call_sync( g_dbus_proxy_get_connection(G_DBUS_PROXY(im)), g_dbus_proxy_get_name(G_DBUS_PROXY(im)), FCITX_IM_DBUS_PATH, "org.freedesktop.DBus.Properties", "Set", g_variant_new("(ssv)", FCITX_IM_DBUS_INTERFACE, "IMList", value), G_VARIANT_TYPE_UNIT, G_DBUS_CALL_FLAGS_NONE, -1, /* timeout */ NULL, &error); if (error) { g_warning("%s", error->message); g_error_free(error); } g_variant_unref(result); }
GVariant * nm_supplicant_config_to_variant (NMSupplicantConfig *self) { NMSupplicantConfigPrivate *priv; GVariantBuilder builder; GHashTableIter iter; ConfigOption *option; const char *key; g_return_val_if_fail (NM_IS_SUPPLICANT_CONFIG (self), NULL); priv = NM_SUPPLICANT_CONFIG_GET_PRIVATE (self); g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); g_hash_table_iter_init (&iter, priv->config); while (g_hash_table_iter_next (&iter, (gpointer) &key, (gpointer) &option)) { switch (option->type) { case TYPE_INT: g_variant_builder_add (&builder, "{sv}", key, g_variant_new_int32 (atoi (option->value))); break; case TYPE_BYTES: case TYPE_UTF8: g_variant_builder_add (&builder, "{sv}", key, g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, option->value, option->len, 1)); break; case TYPE_KEYWORD: case TYPE_STRING: g_variant_builder_add (&builder, "{sv}", key, g_variant_new_string (option->value)); break; default: break; } } return g_variant_builder_end (&builder); }
gboolean appendStringToVariantIfUnique (GVariant **variant, const char *string) { GVariantBuilder newVariantBuilder; FindItemInVariantData findItemData; memset (&findItemData, 0, sizeof (FindItemInVariantData)); g_variant_builder_init (&newVariantBuilder, G_VARIANT_TYPE ("as")); findItemData.item = string; rebuildVariant (&newVariantBuilder, *variant, findItemForVariantData, &findItemData); if (!findItemData.found) g_variant_builder_add (&newVariantBuilder, "s", string); g_variant_unref (*variant); *variant = g_variant_builder_end (&newVariantBuilder); return !findItemData.found; }
static void g_menu_exporter_menu_items_changed (GMenuModel *model, gint position, gint removed, gint added, gpointer user_data) { GMenuExporterMenu *menu = user_data; GSequenceIter *point; gint i; g_assert (menu->model == model); g_assert (menu->item_links != NULL); g_assert (position + removed <= g_sequence_get_length (menu->item_links)); point = g_sequence_get_iter_at_pos (menu->item_links, position + removed); g_sequence_remove_range (g_sequence_get_iter_at_pos (menu->item_links, position), point); for (i = position; i < position + added; i++) g_sequence_insert_before (point, g_menu_exporter_menu_create_links (menu, i)); if (g_menu_exporter_group_is_subscribed (menu->group)) { GVariantBuilder builder; g_variant_builder_init (&builder, G_VARIANT_TYPE ("(uuuuaa{sv})")); g_variant_builder_add (&builder, "u", g_menu_exporter_group_get_id (menu->group)); g_variant_builder_add (&builder, "u", menu->id); g_variant_builder_add (&builder, "u", position); g_variant_builder_add (&builder, "u", removed); g_variant_builder_open (&builder, G_VARIANT_TYPE ("aa{sv}")); for (i = position; i < position + added; i++) g_variant_builder_add_value (&builder, g_menu_exporter_menu_describe_item (menu, i)); g_variant_builder_close (&builder); g_menu_exporter_report (g_menu_exporter_group_get_exporter (menu->group), g_variant_builder_end (&builder)); } }
static gboolean update_bus_environment (State *state, GCancellable *cancellable) { GVariantBuilder builder; GVariant *reply = NULL; GError *error = NULL; gboolean environment_updated = FALSE; g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{ss}")); g_variant_builder_add (&builder, "{ss}", "DISPLAY", state->display_name); g_variant_builder_add (&builder, "{ss}", "XAUTHORITY", state->auth_file); reply = g_dbus_connection_call_sync (state->bus_connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "UpdateActivationEnvironment", g_variant_new ("(@a{ss})", g_variant_builder_end (&builder)), NULL, G_DBUS_CALL_FLAGS_NONE, -1, cancellable, &error); if (reply == NULL) { g_debug ("could not update activation environment: %s", error->message); goto out; } g_variant_unref (reply); environment_updated = TRUE; out: g_clear_error (&error); return environment_updated; }
static gboolean parse_keyvalue_strings (char **strings, GVariant **out_metadata, GError **error) { gboolean ret = FALSE; char **iter; g_autoptr(GVariantBuilder) builder = NULL; builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); for (iter = strings; *iter; iter++) { const char *s; const char *eq; g_autofree char *key = NULL; s = *iter; eq = strchr (s, '='); if (!eq) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Missing '=' in KEY=VALUE metadata '%s'", s); goto out; } key = g_strndup (s, eq - s); g_variant_builder_add (builder, "{sv}", key, g_variant_new_string (eq + 1)); } ret = TRUE; *out_metadata = g_variant_builder_end (builder); g_variant_ref_sink (*out_metadata); out: return ret; }
static void on_bss_proxy_acquired (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_free_error GError *error = NULL; gs_strfreev char **properties = NULL; gs_unref_variant GVariant *props = NULL; GVariantBuilder builder; char **iter; if (!g_async_initable_init_finish (G_ASYNC_INITABLE (proxy), result, &error)) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { nm_log_dbg (LOGD_SUPPLICANT, "Failed to acquire BSS proxy: (%s)", error->message); g_hash_table_remove (NM_SUPPLICANT_INTERFACE_GET_PRIVATE (user_data)->bss_proxies, g_dbus_proxy_get_object_path (proxy)); } return; } self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); iter = properties = g_dbus_proxy_get_cached_property_names (proxy); while (iter && *iter) { GVariant *copy = g_dbus_proxy_get_cached_property (proxy, *iter); g_variant_builder_add (&builder, "{sv}", *iter++, copy); g_variant_unref (copy); } props = g_variant_builder_end (&builder); g_signal_emit (self, signals[NEW_BSS], 0, g_dbus_proxy_get_object_path (proxy), g_variant_ref_sink (props)); }
static GVariant * build_metadata(XmrMprisPlugin *plugin) { GVariantBuilder *builder; GVariant *v = NULL; builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add(builder, "{sv}", "mpris:trackid", g_variant_new ("o", "/org/mpris/MediaPlayer2/Track/track0")); g_variant_builder_add(builder, "{sv}", "mpris:length", g_variant_new("x", plugin->duration / 1000)); if (plugin->current_song != NULL) { if (plugin->current_song->album_name) g_variant_builder_add(builder, "{sv}", "xesam:album", g_variant_new("s", plugin->current_song->album_name)); if (plugin->current_song->artist_name) g_variant_builder_add(builder, "{sv}", "xesam:artist", variant_for_metadata(plugin->current_song->artist_name, TRUE)); if (plugin->current_song->song_name) g_variant_builder_add(builder, "{sv}", "xesam:title", g_variant_new("s", plugin->current_song->song_name)); if (plugin->current_song->location) g_variant_builder_add(builder, "{sv}", "xesam:url", g_variant_new("s", plugin->current_song->location)); } v = g_variant_builder_end (builder); g_variant_builder_unref (builder); return v; }
/** * CacheEntrySerialize: * @self: #CacheEntry to serialize. * * Returns: Human-readable string representing @self. */ gchar *CacheEntrySerialize(CacheEntry *self) { GVariantBuilder builder; const gchar *algorithm = NULL; GVariant *result_variant = NULL; gchar *result = NULL; g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); g_variant_builder_add(&builder, "{sv}", "version", g_variant_new_int32(self->version)); g_variant_builder_add(&builder, "{sv}", "tries", g_variant_new_int32(self->tries)); algorithm = CacheUtilHashalgToString(self->algorithm); if (algorithm) g_variant_builder_add(&builder, "{sv}", "algorithm", g_variant_new_string(algorithm)); struct {const gchar *name; gchar *value;} attrs[] = { {"salt", CacheUtilBytesToString(self->salt)}, {"hash", CacheUtilBytesToString(self->hash)}, {"last_verified", CacheUtilDatetimeToString(self->last_verified)}, {"last_used", CacheUtilDatetimeToString(self->last_used)}, {"last_tried", CacheUtilDatetimeToString(self->last_tried)}, }; for (guint i = 0; i < G_N_ELEMENTS(attrs); i++) { if (attrs[i].value) { g_variant_builder_add(&builder, "{sv}", attrs[i].name, g_variant_new_string(attrs[i].value)); g_free(attrs[i].value); } } result_variant = g_variant_builder_end(&builder); result = g_variant_print(result_variant, TRUE); g_variant_unref(result_variant); return result; }
/** * @memberof GstSwitchController * * Remoting method stub of "get_preview_ports". */ static GVariant * gst_switch_controller__get_preview_ports (GstSwitchController * controller, GDBusConnection * connection, GVariant * parameters) { GVariant *result = NULL; if (controller->server) { GArray *serves = NULL, *types = NULL; GArray *ports = gst_switch_server_get_preview_sink_ports (controller->server, &serves, &types); int n; GVariantBuilder *builder; GVariant *value; gchar *res; builder = g_variant_builder_new (G_VARIANT_TYPE ("a(iii)")); for (n = 0; n < ports->len; ++n) { g_variant_builder_add (builder, "(iii)", g_array_index (ports, gint, n), g_array_index (serves, gint, n), g_array_index (types, gint, n)); } value = g_variant_builder_end (builder); //result = g_variant_new_tuple (&value, 1); res = g_variant_print (value, FALSE); result = g_variant_new ("(s)", res); /* INFO ("value: %s (%d)", g_variant_get_type_string (value), g_variant_n_children (value)); INFO ("result: %s, %s", g_variant_get_type_string (result), res); */ g_free (res); g_array_free (ports, TRUE); g_array_free (types, TRUE); } return result; }
GVariant * mm_unlock_retries_get_dictionary (MMUnlockRetries *self) { GVariantBuilder builder; GHashTableIter iter; gpointer key, value; /* We do allow NULL */ if (!self) return NULL; g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{uu}")); g_hash_table_iter_init (&iter, self->priv->ht); while (g_hash_table_iter_next (&iter, &key, &value)) { g_variant_builder_add (&builder, "{uu}", GPOINTER_TO_UINT (key), GPOINTER_TO_UINT (value)); } return g_variant_ref_sink (g_variant_builder_end (&builder)); }
void nm_dhcp4_config_set_options (NMDhcp4Config *self, GHashTable *options) { NMDhcp4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (self); GHashTableIter iter; const char *key, *value; GVariantBuilder builder; g_return_if_fail (NM_IS_DHCP4_CONFIG (self)); g_return_if_fail (options != NULL); g_variant_unref (priv->options); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); g_hash_table_iter_init (&iter, options); while (g_hash_table_iter_next (&iter, (gpointer) &key, (gpointer) &value)) g_variant_builder_add (&builder, "{sv}", key, g_variant_new_string (value)); priv->options = g_variant_builder_end (&builder); g_variant_ref_sink (priv->options); g_object_notify (G_OBJECT (self), NM_DHCP4_CONFIG_OPTIONS); }
gboolean nm_supplicant_interface_request_scan (NMSupplicantInterface *self, const GPtrArray *ssids) { NMSupplicantInterfacePrivate *priv; GVariantBuilder builder; guint i; g_return_val_if_fail (NM_IS_SUPPLICANT_INTERFACE (self), FALSE); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); /* Scan parameters */ g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&builder, "{sv}", "Type", g_variant_new_string ("active")); if (ssids) { GVariantBuilder ssids_builder; g_variant_builder_init (&ssids_builder, G_VARIANT_TYPE_BYTESTRING_ARRAY); for (i = 0; i < ssids->len; i++) { GByteArray *ssid = g_ptr_array_index (ssids, i); g_variant_builder_add (&ssids_builder, "@ay", g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, ssid->data, ssid->len, 1)); } g_variant_builder_add (&builder, "{sv}", "SSIDs", g_variant_builder_end (&ssids_builder)); } g_dbus_proxy_call (priv->iface_proxy, "Scan", g_variant_new ("(a{sv})", &builder), G_DBUS_CALL_FLAGS_NONE, -1, priv->other_cancellable, (GAsyncReadyCallback) scan_request_cb, self); return TRUE; }
/** * cd_sensor_get_metadata_as_variant: **/ static GVariant * cd_sensor_get_metadata_as_variant (CdSensor *sensor) { CdSensorPrivate *priv = GET_PRIVATE (sensor); GList *l; GVariantBuilder builder; g_autoptr(GList) list = NULL; /* we always must have at least one bit of metadata */ if (g_hash_table_size (priv->metadata) == 0) return g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0); /* add all the keys in the dictionary to the variant builder */ list = g_hash_table_get_keys (priv->metadata); g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (l = list; l != NULL; l = l->next) { g_variant_builder_add (&builder, "{ss}", l->data, g_hash_table_lookup (priv->metadata, l->data)); } return g_variant_builder_end (&builder); }
/** * cd_sensor_get_options_as_variant: **/ static GVariant * cd_sensor_get_options_as_variant (CdSensor *sensor) { CdSensorPrivate *priv = GET_PRIVATE (sensor); GList *l; GVariantBuilder builder; g_autoptr(GList) list = NULL; /* do not try to build an empty array */ if (g_hash_table_size (priv->options) == 0) return g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0); /* add all the keys in the dictionary to the variant builder */ list = g_hash_table_get_keys (priv->options); g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); for (l = list; l != NULL; l = l->next) { g_variant_builder_add (&builder, "{sv}", l->data, g_hash_table_lookup (priv->options, l->data)); } return g_variant_builder_end (&builder); }
void dlr_manager_get_all_props(dlr_manager_t *manager, dleyna_settings_t *settings, dlr_task_t *task, dlr_manager_task_complete_t cb) { dlr_async_task_t *cb_data = (dlr_async_task_t *)task; dlr_task_get_props_t *task_data = &task->ut.get_props; gchar *i_name = task_data->interface_name; GVariantBuilder vb; DLEYNA_LOG_DEBUG("Enter"); DLEYNA_LOG_DEBUG("Path: %s", task->path); DLEYNA_LOG_DEBUG("Interface %s", i_name); cb_data->cb = cb; g_variant_builder_init(&vb, G_VARIANT_TYPE("a{sv}")); if (!strcmp(i_name, DLEYNA_SERVER_INTERFACE_MANAGER) || !strcmp(i_name, "")) { prv_add_all_props(settings, &vb); cb_data->task.result = g_variant_ref_sink( g_variant_builder_end(&vb)); } else { DLEYNA_LOG_WARNING("Interface is unknown."); cb_data->error = g_error_new(DLEYNA_SERVER_ERROR, DLEYNA_ERROR_UNKNOWN_INTERFACE, "Interface is unknown."); } (void) g_idle_add(dlr_async_task_complete, cb_data); DLEYNA_LOG_DEBUG("Exit"); }
static void load_applet_into_window (const char *title, const char *prefs_path, guint size, guint orientation) { GtkWidget *container; GtkWidget *applet_window; GVariantBuilder builder; container = mate_panel_applet_container_new (); applet_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); //FIXME: we could set the window icon with the applet icon gtk_window_set_title (GTK_WINDOW (applet_window), title); gtk_container_add (GTK_CONTAINER (applet_window), container); gtk_widget_show (container); g_signal_connect (container, "applet-broken", G_CALLBACK (applet_broken_cb), applet_window); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&builder, "{sv}", "prefs-path", g_variant_new_string (prefs_path)); g_variant_builder_add (&builder, "{sv}", "size", g_variant_new_uint32 (size)); g_variant_builder_add (&builder, "{sv}", "orient", g_variant_new_uint32 (orientation)); mate_panel_applet_container_add (MATE_PANEL_APPLET_CONTAINER (container), gtk_widget_get_screen (applet_window), title, NULL, (GAsyncReadyCallback)applet_activated_cb, applet_window, g_variant_builder_end (&builder)); }
static void send_dbus_event (ControlData *data) { GVariantBuilder props_builder; GVariant *props_changed = NULL; g_assert (data->connection); g_variant_builder_init (&props_builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&props_builder, "{sv}", "HasDualGpu", g_variant_new_boolean (data->available)); props_changed = g_variant_new ("(s@a{sv}@as)", CONTROL_PROXY_IFACE_NAME, g_variant_builder_end (&props_builder), g_variant_new_strv (NULL, 0)); g_dbus_connection_emit_signal (data->connection, NULL, CONTROL_PROXY_DBUS_PATH, "org.freedesktop.DBus.Properties", "PropertiesChanged", props_changed, NULL); }
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GVariant *gvar; GVariantBuilder gvb; (void)sdi; (void)cg; switch (key) { case SR_CONF_SCAN_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t)); break; case SR_CONF_DEVICE_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t)); break; case SR_CONF_SAMPLERATE: g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}")); gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates, ARRAY_SIZE(samplerates), sizeof(uint64_t)); g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar); *data = g_variant_builder_end(&gvb); break; case SR_CONF_TRIGGER_MATCH: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, soft_trigger_matches, ARRAY_SIZE(soft_trigger_matches), sizeof(int32_t)); break; default: return SR_ERR_NA; } return SR_OK; }
static gboolean gb_vim_command_search (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { GtkSourceView *source_view; GtkTextBuffer *buffer; const gchar *search_begin = NULL; const gchar *search_end = NULL; const gchar *replace_begin = NULL; const gchar *replace_end = NULL; gchar *search_text = NULL; gchar *replace_text = NULL; gunichar separator; gboolean confirm_replace = FALSE; g_assert (GTK_IS_WIDGET (active_widget)); g_assert (g_str_has_prefix (command, "%s") || g_str_has_prefix (command, "s")); if (IDE_IS_EDITOR_VIEW (active_widget)) source_view = GTK_SOURCE_VIEW (IDE_EDITOR_VIEW (active_widget)->frame1->source_view); else return gb_vim_set_source_view_error (error); if (*command == '%') command++; command++; separator = g_utf8_get_char (command); if (!separator) goto invalid_request; search_begin = command = g_utf8_next_char (command); for (; *command; command = g_utf8_next_char (command)) { if (*command == '\\') { command = g_utf8_next_char (command); if (!*command) goto invalid_request; continue; } if (g_utf8_get_char (command) == separator) { search_end = command; break; } } if (!search_end) goto invalid_request; replace_begin = command = g_utf8_next_char (command); for (; *command; command = g_utf8_next_char (command)) { if (*command == '\\') { command = g_utf8_next_char (command); if (!*command) goto invalid_request; continue; } if (g_utf8_get_char (command) == separator) { replace_end = command; break; } } if (!replace_end) goto invalid_request; command = g_utf8_next_char (command); if (*command) { for (; *command; command++) { switch (*command) { case 'c': confirm_replace = TRUE; break; case 'g': break; /* what other options are supported? */ default: break; } } } search_text = g_strndup (search_begin, search_end - search_begin); replace_text = g_strndup (replace_begin, replace_end - replace_begin); if (confirm_replace) { GVariant *variant; GVariantBuilder builder; g_variant_builder_init (&builder, G_VARIANT_TYPE_STRING_ARRAY); g_variant_builder_add (&builder, "s", search_text); g_variant_builder_add (&builder, "s", replace_text); variant = g_variant_builder_end (&builder); ide_widget_action (GTK_WIDGET (IDE_EDITOR_VIEW (active_widget)->frame1), "frame", "replace-confirm", variant); return TRUE; } buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); if (gtk_text_buffer_get_has_selection (buffer)) { GtkTextIter begin; GtkTextIter end; gtk_text_buffer_get_selection_bounds (buffer, &begin, &end); gtk_text_iter_order (&begin, &end); gb_vim_do_search_and_replace (buffer, &begin, &end, search_text, replace_text, FALSE); } else gb_vim_do_search_and_replace (buffer, NULL, NULL, search_text, replace_text, TRUE); g_free (search_text); g_free (replace_text); return TRUE; invalid_request: g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_UNKNOWN_OPTION, _("Invalid search and replace request")); return FALSE; }
GVariant* js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue, const GVariantType* sig, JSValueRef *exception) { if (g_variant_type_is_array(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); if (g_variant_type_is_dict_entry(child_sig)) { const GVariantType* key_sig = g_variant_type_first(child_sig); const GVariantType* value_sig = g_variant_type_next(key_sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_function_child(ctx, jsvalue, i)) continue; g_variant_builder_open(&builder, child_sig); JSValueRef key = JSValueMakeString(ctx, JSPropertyNameArrayGetNameAtIndex(array, i)); JSValueRef value = JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL); g_variant_builder_add_value(&builder, js_to_dbus(ctx, key, key_sig, exception)); g_variant_builder_add_value(&builder, js_to_dbus(ctx, value, value_sig, exception)); g_variant_builder_close(&builder); } return g_variant_builder_end(&builder); } else { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) continue; g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), child_sig, exception)); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } } else if (g_variant_type_is_tuple(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* current_sig = g_variant_type_first(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) continue; g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), current_sig, exception)); current_sig = g_variant_type_next(current_sig); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } else { switch (g_variant_type_peek_string(sig)[0]) { case 'y': return g_variant_new_byte(JSValueToNumber(ctx, jsvalue, exception)); case 'n': return g_variant_new_int16(JSValueToNumber(ctx, jsvalue, exception)); case 'q': return g_variant_new_uint16(JSValueToNumber(ctx, jsvalue, exception)); case 'i': return g_variant_new_int32(JSValueToNumber(ctx, jsvalue, exception)); case 'u': return g_variant_new_uint32(JSValueToNumber(ctx, jsvalue, exception)); case 'x': return g_variant_new_int64(JSValueToNumber(ctx, jsvalue, exception)); case 't': return g_variant_new_uint64(JSValueToNumber(ctx, jsvalue, exception)); case 'd': return g_variant_new_double(JSValueToNumber(ctx, jsvalue, exception)); case 'h': return g_variant_new_handle(JSValueToNumber(ctx, jsvalue, exception)); case 'b': return g_variant_new_boolean(JSValueToBoolean(ctx, jsvalue)); case 's': { char* v = jsvalue_to_cstr(ctx, jsvalue); GVariant* r = g_variant_new_string(v); g_free(v); return r; } case 'v': { //TODO: /*g_variant_new_variant()*/ g_assert_not_reached(); } } } g_assert_not_reached(); }
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { GVariant *tuple, *rational[2]; GVariantBuilder gvb; unsigned int i; GVariant *gvar; if (key == SR_CONF_SCAN_OPTIONS) { *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t)); return SR_OK; } else if (key == SR_CONF_DEVICE_OPTIONS && !sdi) { *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t)); return SR_OK; } if (!sdi) return SR_ERR_ARG; if (!cg) { switch (key) { case SR_CONF_DEVICE_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, devopts, ARRAY_SIZE(devopts), sizeof(uint32_t)); break; case SR_CONF_SAMPLERATE: g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}")); gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates, ARRAY_SIZE(samplerates), sizeof(uint64_t)); g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar); *data = g_variant_builder_end(&gvb); break; default: return SR_ERR_NA; } } else { switch (key) { case SR_CONF_DEVICE_OPTIONS: *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t)); break; case SR_CONF_COUPLING: *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling)); break; case SR_CONF_VDIV: g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY); for (i = 0; i < ARRAY_SIZE(vdivs); i++) { rational[0] = g_variant_new_uint64(vdivs[i][0]); rational[1] = g_variant_new_uint64(vdivs[i][1]); tuple = g_variant_new_tuple(rational, 2); g_variant_builder_add_value(&gvb, tuple); } *data = g_variant_builder_end(&gvb); break; default: return SR_ERR_NA; } } return SR_OK; }