void InspectorClient::storeSetting(const String& key, const String& value)
{
if (shouldIgnoreSetting(key))
return;
GSettings* settings = inspectorGSettings();
if (!settings)
return;
PlatformRefPtr<GVariant> variant(0);
// Set the key with the appropriate type, and also avoid setting
// unknown keys to avoid aborting the execution.
if (key == "resourceTrackingEnabled" || key == "xhrMonitor"
|| key == "debuggerEnabled" || key == "profilerEnabled")
variant = adoptPlatformRef(variantFromTruthString(value));
else if (key == "frontendSettings")
variant = adoptPlatformRef(g_variant_new_string(value.utf8().data()));
if (!variant)
return;
g_settings_set_value(settings, toGSettingName(key).utf8().data(), variant.get());
}
void settings_manager_add_interested (SettingsManager* self, const gchar* app_desktop_name) {
static const char key[] = "interested-media-players";
GVariantType* _tmp0_;
GVariantType* _tmp1_;
GVariantBuilder* _tmp2_;
GVariantBuilder* _tmp3_;
GVariantBuilder* players;
GSettings* _tmp4_;
gchar** _tmp5_;
gchar** _tmp6_ = NULL;
GVariantBuilder* _tmp12_;
const gchar* _tmp13_;
GSettings* _tmp14_;
GVariantBuilder* _tmp15_;
GVariant* _tmp16_ = NULL;
GVariant* _tmp17_;
GSettings* _tmp18_;
g_return_if_fail (self != NULL);
g_return_if_fail (app_desktop_name != NULL);
_tmp0_ = g_variant_type_new ("as");
_tmp1_ = _tmp0_;
_tmp2_ = g_variant_builder_new (_tmp1_);
_tmp3_ = _tmp2_;
_g_variant_type_free0 (_tmp1_);
players = _tmp3_;
_tmp4_ = self->priv->settings;
_tmp6_ = _tmp5_ = g_settings_get_strv (_tmp4_, key);
{
gchar** player_collection = NULL;
gint player_collection_length1 = 0;
gint _player_collection_size_ = 0;
gint player_it = 0;
player_collection = _tmp6_;
player_collection_length1 = _vala_array_length (_tmp5_);
for (player_it = 0; player_it < _vala_array_length (_tmp5_); player_it = player_it + 1) {
gchar* _tmp7_;
gchar* player = NULL;
_tmp7_ = g_strdup (player_collection[player_it]);
player = _tmp7_;
{
const gchar* _tmp8_;
const gchar* _tmp9_;
GVariantBuilder* _tmp10_;
const gchar* _tmp11_;
_tmp8_ = player;
_tmp9_ = app_desktop_name;
if (g_strcmp0 (_tmp8_, _tmp9_) == 0) {
_g_free0 (player);
player_collection = (_vala_array_free (player_collection, player_collection_length1, (GDestroyNotify) g_free), NULL);
_g_variant_builder_unref0 (players);
return;
}
_tmp10_ = players;
_tmp11_ = player;
g_variant_builder_add (_tmp10_, "s", _tmp11_, NULL);
_g_free0 (player);
}
}
player_collection = (_vala_array_free (player_collection, player_collection_length1, (GDestroyNotify) g_free), NULL);
}
_tmp12_ = players;
_tmp13_ = app_desktop_name;
g_variant_builder_add (_tmp12_, "s", _tmp13_, NULL);
_tmp14_ = self->priv->settings;
_tmp15_ = players;
_tmp16_ = g_variant_builder_end (_tmp15_);
_tmp17_ = g_variant_ref_sink (_tmp16_);
g_settings_set_value (_tmp14_, key, _tmp17_);
_g_variant_unref0 (_tmp17_);
_tmp18_ = self->priv->settings;
g_settings_apply (_tmp18_);
_g_variant_builder_unref0 (players);
}
static void ccsGSettingsWrapperSetValueDefault (CCSGSettingsWrapper *wrapper, const char *key, GVariant *variant)
{
GSETTINGS_WRAPPER_PRIVATE (wrapper);
g_settings_set_value (gswPrivate->settings, key, variant);
}
static gboolean
handle_file (const gchar *filename)
{
GKeyFile *keyfile;
MateConfClient *client;
MateConfValue *value;
gint i, j;
gchar *mateconf_key;
gchar **groups;
gchar **keys;
GVariantBuilder *builder;
GVariant *v;
const gchar *s;
gchar *str;
gint ii;
GSList *list, *l;
GSettings *settings;
GError *error;
keyfile = g_key_file_new ();
error = NULL;
if (!g_key_file_load_from_file (keyfile, filename, 0, &error))
{
g_printerr ("%s\n", error->message);
g_error_free (error);
g_key_file_free (keyfile);
return FALSE;
}
client = mateconf_client_get_default ();
groups = g_key_file_get_groups (keyfile, NULL);
for (i = 0; groups[i]; i++)
{
gchar **schema_path;
schema_path = g_strsplit (groups[i], ":", 2);
if (verbose)
{
g_print ("collecting settings for schema '%s'\n", schema_path[0]);
if (schema_path[1])
g_print ("for storage at '%s'\n", schema_path[1]);
}
if (schema_path[1] != NULL)
settings = g_settings_new_with_path (schema_path[0], schema_path[1]);
else
settings = g_settings_new (schema_path[0]);
g_settings_delay (settings);
error = NULL;
if ((keys = g_key_file_get_keys (keyfile, groups[i], NULL, &error)) == NULL)
{
g_printerr ("%s", error->message);
g_error_free (error);
continue;
}
for (j = 0; keys[j]; j++)
{
if (strchr (keys[j], '/') != 0)
{
g_printerr ("Key '%s' contains a '/'\n", keys[j]);
continue;
}
error = NULL;
if ((mateconf_key = g_key_file_get_string (keyfile, groups[i], keys[j], &error)) == NULL)
{
g_printerr ("%s", error->message);
g_error_free (error);
continue;
}
error = NULL;
if ((value = mateconf_client_get_without_default (client, mateconf_key, &error)) == NULL)
{
if (error)
{
g_printerr ("Failed to get MateConf key '%s': %s\n",
mateconf_key, error->message);
g_error_free (error);
}
else
{
if (verbose)
g_print ("Skipping MateConf key '%s', no user value\n",
mateconf_key);
}
g_free (mateconf_key);
continue;
}
switch (value->type)
{
case MATECONF_VALUE_STRING:
if (dry_run)
g_print ("set key '%s' to string '%s'\n", keys[j],
mateconf_value_get_string (value));
else
g_settings_set (settings, keys[j], "s",
mateconf_value_get_string (value));
break;
case MATECONF_VALUE_INT:
if (dry_run)
g_print ("set key '%s' to integer '%d'\n",
keys[j], mateconf_value_get_int (value));
else
g_settings_set (settings, keys[j], "i",
mateconf_value_get_int (value));
break;
case MATECONF_VALUE_BOOL:
if (dry_run)
g_print ("set key '%s' to boolean '%d'\n",
keys[j], mateconf_value_get_bool (value));
else
g_settings_set (settings, keys[j], "b",
mateconf_value_get_bool (value));
break;
case MATECONF_VALUE_FLOAT:
if (dry_run)
g_print ("set key '%s' to double '%g'\n",
keys[j], mateconf_value_get_float (value));
else
g_settings_set (settings, keys[j], "d",
mateconf_value_get_float (value));
break;
case MATECONF_VALUE_LIST:
switch (mateconf_value_get_list_type (value))
{
case MATECONF_VALUE_STRING:
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
list = mateconf_value_get_list (value);
if (list != NULL)
{
for (l = list; l; l = l->next)
{
MateConfValue *lv = l->data;
s = mateconf_value_get_string (lv);
g_variant_builder_add (builder, "s", s);
}
v = g_variant_new ("as", builder);
}
else
v = g_variant_new_array (G_VARIANT_TYPE_STRING, NULL, 0);
g_variant_ref_sink (v);
if (dry_run)
{
str = g_variant_print (v, FALSE);
g_print ("set key '%s' to a list of strings: %s\n",
keys[j], str);
g_free (str);
}
else
g_settings_set_value (settings, keys[j], v);
g_variant_unref (v);
g_variant_builder_unref (builder);
break;
case MATECONF_VALUE_INT:
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
list = mateconf_value_get_list (value);
if (list != NULL)
{
for (l = list; l; l = l->next)
{
MateConfValue *lv = l->data;
ii = mateconf_value_get_int (lv);
g_variant_builder_add (builder, "i", ii);
}
v = g_variant_new ("ai", builder);
}
else
v = g_variant_new_array (G_VARIANT_TYPE_INT32, NULL, 0);
g_variant_ref_sink (v);
if (dry_run)
{
str = g_variant_print (v, FALSE);
g_print ("set key '%s' to a list of integers: %s\n",
keys[j], str);
g_free (str);
}
else
g_settings_set_value (settings, keys[j], v);
g_variant_unref (v);
g_variant_builder_unref (builder);
break;
default:
g_printerr ("Keys of type 'list of %s' not handled yet\n",
mateconf_value_type_to_string (mateconf_value_get_list_type (value)));
break;
}
break;
default:
g_printerr ("Keys of type %s not handled yet\n",
mateconf_value_type_to_string (value->type));
break;
}
mateconf_value_free (value);
g_free (mateconf_key);
}
g_strfreev (keys);
if (!dry_run)
g_settings_apply (settings);
g_object_unref (settings);
g_strfreev (schema_path);
}
g_strfreev (groups);
g_object_unref (client);
return TRUE;
}
/* This only supports migrating from v0.5's config file */
gboolean migrate_config(gmpv_handle *ctx)
{
gchar *config_file = get_config_file_path();
gboolean result = FALSE;
if(g_file_test(config_file, G_FILE_TEST_EXISTS))
{
const gchar *key_list[] = { "csd-enable",
"dark-theme-enable",
"mpv-input-config-enable",
"mpv-config-enable",
"mpv-input-config-file",
"mpv-config-file",
"mpv-options",
NULL };
GSettingsBackend *backend;
GSettings *keyfile_settings;
GSettings *default_settings;
const gchar **iter;
backend = g_keyfile_settings_backend_new
( config_file,
"/org/gnome-mpv/gnome-mpv/",
"main" );
keyfile_settings = g_settings_new_with_backend( CONFIG_ROOT,
backend );
default_settings = g_settings_new(CONFIG_ROOT);
iter = key_list;
while(*iter)
{
GVariant *value;
value = g_settings_get_value(keyfile_settings, *iter);
g_settings_set_value(default_settings, *iter, value);
iter++;
g_variant_unref(value);
}
g_object_unref(backend);
g_object_unref(keyfile_settings);
g_object_unref(default_settings);
/* Rename the old config file */
gchar *backup_config_file = g_strconcat( config_file,
".bak",
NULL );
GFile *src = g_file_new_for_path(config_file);
GFile *dest = g_file_new_for_path(backup_config_file);
result = g_file_move( src,
dest,
G_FILE_COPY_NONE,
NULL,
NULL,
NULL,
NULL );
g_free(backup_config_file);
g_object_unref(src);
g_object_unref(dest);
}
g_free(config_file);
return result;
}
static void pocketvox_setup_save_and_quit(PocketvoxSetup *setup, gpointer data)
{
gboolean addModule;
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
GVariantBuilder *builder;
GVariant *value;
GList* infos = g_hash_table_get_values(priv->apps);
GList* iter = NULL;
GList* tmp = NULL;
builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssb)"));
for(iter = infos; iter; iter = iter->next)
{
ModuleInfos *info = (ModuleInfos *)iter->data;
const gchar *id = gtk_entry_get_text(GTK_ENTRY(info->entry_id));
const gchar *dict = gtk_entry_get_text(GTK_ENTRY(info->entry_path));
gboolean isapp = gtk_switch_get_active(GTK_SWITCH(info->sw));
//by default each module should be added
addModule = TRUE;
//check if we have a valid module
if( id == NULL
|| !g_strcmp0(id, "") == TRUE
|| dict == NULL
|| !g_strcmp0(dict, "") == TRUE)
{
g_warning("PocketvoxSetup: an invalid module couldn't be added to your configuration");
addModule = FALSE;
}
//check if we already find this one
if(addModule == TRUE)
{
addModule = addModule & (NULL == g_list_find_custom(tmp, id, pocketvox_module_check));
if(addModule == FALSE)
{
g_warning("PocketvoxSetup: 2 modules cannot have the same ID");
}
}
//add the new module to the GVariant
if(addModule == TRUE)
{
g_variant_builder_add(builder, "(ssb)", id, dict, isapp);
tmp = g_list_append(tmp, g_strdup(id));
}
}
value = g_variant_new("a(ssb)", builder);
g_variant_builder_unref(builder);
g_settings_set_value(priv->settings, "list-apps", value);
g_settings_sync();
g_list_free(infos);
for(iter=tmp; iter; iter=iter->next)
{
g_free((gchar *)iter->data);
}
g_list_free(tmp);
g_hash_table_destroy(priv->apps);
gtk_main_quit();
}
char *
panel_layout_object_create_start (PanelObjectType type,
const char *type_detail,
const char *toplevel_id,
PanelObjectPackType pack_type,
int pack_index,
GVariant *initial_settings,
GSettings **settings)
{
char *unique_id;
char *path;
GSettings *settings_object;
char *iid;
char *try_id;
if (settings)
*settings = NULL;
iid = panel_object_type_to_iid (type, type_detail);
if (!iid)
return NULL;
try_id = panel_layout_object_generate_id (iid);
unique_id = panel_layout_find_free_id (PANEL_LAYOUT_OBJECT_ID_LIST_KEY,
PANEL_OBJECT_SCHEMA,
PANEL_LAYOUT_OBJECT_PATH,
try_id);
path = g_strdup_printf ("%s%s/", PANEL_LAYOUT_OBJECT_PATH, unique_id);
settings_object = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path);
g_free (path);
g_settings_set_string (settings_object,
PANEL_OBJECT_IID_KEY,
iid);
g_settings_set_string (settings_object,
PANEL_OBJECT_TOPLEVEL_ID_KEY,
toplevel_id);
g_settings_set_enum (settings_object,
PANEL_OBJECT_PACK_TYPE_KEY,
pack_type);
g_settings_set_int (settings_object,
PANEL_OBJECT_PACK_INDEX_KEY,
pack_index);
if (initial_settings != NULL) {
GSettings *tmp;
path = g_strdup_printf ("%s%s/initial-settings/", PANEL_LAYOUT_OBJECT_PATH, unique_id);
tmp = g_settings_new_with_path ("org.gnome.gnome-panel.applet.initial-settings", path);
g_free (path);
g_settings_set_value (tmp, "settings", initial_settings);
g_object_unref (tmp);
}
g_free (try_id);
g_free (iid);
if (settings)
*settings = settings_object;
else
g_object_unref (settings_object);
return unique_id;
}
