/** * irc_context_lookup_setting_boolean: * @self: Context to lookup in * @setting_name: Setting to lookup * * If the setting has never been set for a context it will lookup * the setting in the parent. If all else fails it uses global settings. * * Returns: Value of setting */ gboolean irc_context_lookup_setting_boolean (IrcContext *self, const char *setting_name) { GSettings *settings = g_object_get_data (G_OBJECT(self), "settings"); if (G_UNLIKELY(settings == NULL)) { const char *id = irc_context_get_id (self); g_autofree char *path = g_strconcat ("/se/tingping/IrcClient/", id, "/", NULL); settings = g_settings_new_with_path ("se.tingping.context", path); g_object_set_data_full (G_OBJECT(self), "settings", settings, g_object_unref); } g_autoptr (GVariant) value = g_settings_get_user_value (settings, setting_name); if (value != NULL) return g_variant_get_boolean (value); IrcContext *parent = irc_context_get_parent (self); if (parent) return irc_context_lookup_setting_boolean (parent, setting_name); static GSettings *global_settings; if (G_UNLIKELY(global_settings == NULL)) global_settings = g_settings_new_with_path ("se.tingping.context", "/se/tingping/IrcClient/"); return g_settings_get_boolean (global_settings, setting_name); }
static void rb_audioscrobbler_plugin_init (RBAudioscrobblerPlugin *plugin) { rb_debug ("RBAudioscrobblerPlugin initialising"); plugin->lastfm_settings = g_settings_new_with_path (AUDIOSCROBBLER_SETTINGS_SCHEMA, AUDIOSCROBBLER_SETTINGS_PATH "/Last.fm/"); plugin->librefm_settings = g_settings_new_with_path (AUDIOSCROBBLER_SETTINGS_SCHEMA, AUDIOSCROBBLER_SETTINGS_PATH "/Libre.fm/"); }
static void panel_drawer_prepare (const char *drawer_id, GIcon *custom_icon, gboolean use_custom_icon, const char *tooltip, char **attached_toplevel_id) { GSettings *settings; char *path; path = g_strdup_printf ("%s%s/", PANEL_OBJECT_PATH, drawer_id); settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); g_free (path); if (tooltip) { g_settings_set_string (settings, PANEL_OBJECT_TOOLTIP_KEY, tooltip); } g_settings_set_boolean (settings, PANEL_OBJECT_USE_CUSTOM_ICON_KEY, use_custom_icon); if (custom_icon) { gchar *icon_name; icon_name = g_icon_to_string(custom_icon); g_settings_set_string (settings, PANEL_OBJECT_CUSTOM_ICON_KEY, icon_name); g_free(icon_name); } if (attached_toplevel_id) { char *toplevel_id; char *toplevel_path; GSettings *toplevel_settings; toplevel_id = panel_profile_find_new_id (PANEL_GSETTINGS_TOPLEVELS); toplevel_path = g_strdup_printf (PANEL_TOPLEVEL_PATH "%s/", toplevel_id); toplevel_settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA, toplevel_path); g_settings_set_string (settings, PANEL_OBJECT_ATTACHED_TOPLEVEL_ID_KEY, toplevel_id); g_settings_set_boolean (toplevel_settings, PANEL_TOPLEVEL_ENABLE_BUTTONS_KEY, TRUE); g_settings_set_boolean (toplevel_settings, PANEL_TOPLEVEL_ENABLE_ARROWS_KEY, TRUE); *attached_toplevel_id = toplevel_id; g_object_unref (toplevel_settings); g_free (toplevel_path); } g_object_unref (settings); }
static void mud_character_constructed (GObject *object) { gchar *character_path; MudCharacter *self = (MudCharacter *)object; G_OBJECT_CLASS (mud_character_parent_class)->constructed (object); /* TODO: Change ID property to default to G_MAXUINT64 and figure out a new ID to use here, instead of caller having to do it */ character_path = g_strdup_printf("/org/gnome/MUD/Characters/%s/", self->id); self->settings = g_settings_new_with_path("org.gnome.MUD.Character", character_path); /* TODO: Reaction to MUD/Profile changes; but maybe this binding to other objects 'id' is enough? */ /* FIXME: For now just setting mud/profile names for the benefit of new freshly created characters; think this through more and maybe do elsewhere, as during load we'd get that value already too and figure it out in manager */ g_settings_bind_with_mapping (self->settings, "profile", self->profile, "id", G_SETTINGS_BIND_SET | G_SETTINGS_BIND_NO_SENSITIVITY, NULL, _set_profile_id_mapping, /* TODO: Get rid of the mapping once we have converted profile over to use full name instead of integer ID too */ NULL, NULL); g_settings_bind (self->settings, "mud", self->mud, "id", G_SETTINGS_BIND_SET | G_SETTINGS_BIND_NO_SENSITIVITY); g_settings_bind (self->settings, "name", self, "name", G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_NO_SENSITIVITY); g_settings_bind (self->settings, "connect-string", self, "connect-string", G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_NO_SENSITIVITY); g_free (character_path); }
static void terminal_profile_save (TerminalProfile *profile) { TerminalProfilePrivate *priv = profile->priv; GSettings *changeset; GSList *l; priv->save_idle_id = 0; changeset = g_settings_new_with_path (CONF_PROFILE_SCHEMA, g_strconcat (CONF_PROFILE_PREFIX, priv->profile_dir,"/", NULL)); g_settings_delay (changeset); for (l = priv->dirty_pspecs; l != NULL; l = l->next) { GParamSpec *pspec = (GParamSpec *) l->data; if (pspec->owner_type != TERMINAL_TYPE_PROFILE) continue; if ((pspec->flags & G_PARAM_WRITABLE) == 0) continue; terminal_profile_gsettings_changeset_add (profile, changeset, pspec); } g_slist_free (priv->dirty_pspecs); priv->dirty_pspecs = NULL; g_settings_apply (changeset); g_object_unref (changeset); }
/** * rb_static_playlist_source_new: * @shell: the #RBShell * @name: the playlist name * @settings_name: the settings name for the playlist (GSettings path friendly) * @local: if %TRUE, the playlist is local to the library * @entry_type: type of database entries that can be added to the playlist. * * Creates a new static playlist source. * * Return value: new playlist. */ RBSource * rb_static_playlist_source_new (RBShell *shell, const char *name, const char *settings_name, gboolean local, RhythmDBEntryType *entry_type) { GSettings *settings; if (name == NULL) name = ""; if (settings_name != NULL) { char *path; path = g_strdup_printf ("/org/gnome/rhythmbox/playlist/%s/", settings_name); settings = g_settings_new_with_path ("org.gnome.rhythmbox.source", path); g_free (path); } else { settings = NULL; } return RB_SOURCE (g_object_new (RB_TYPE_STATIC_PLAYLIST_SOURCE, "name", name, "settings", settings, "shell", shell, "is-local", local, "entry-type", entry_type, "search-type", RB_SOURCE_SEARCH_INCREMENTAL, NULL)); }
static void process_app_info (CcNotificationsPanel *panel, GTask *task, GAppInfo *app_info) { Application *app; char *app_id; char *canonical_app_id; char *path; GSettings *settings; GSource *source; app_id = app_info_get_id (app_info); canonical_app_id = g_strcanon (app_id, "0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "-", '-'); path = g_strconcat (APP_PREFIX, canonical_app_id, "/", NULL); settings = g_settings_new_with_path (APP_SCHEMA, path); app = g_slice_new (Application); app->canonical_app_id = canonical_app_id; app->settings = settings; app->app_info = g_object_ref (app_info); app->panel = g_object_ref (panel); source = g_idle_source_new (); g_source_set_callback (source, queued_app_info, app, NULL); g_source_attach (source, g_task_get_context (task)); g_free (path); }
static void maybe_add_app_id (CcNotificationsPanel *panel, const char *canonical_app_id) { Application *app; gchar *path; gchar *full_app_id; GSettings *settings; GAppInfo *app_info; if (g_hash_table_contains (panel->known_applications, canonical_app_id)) return; path = g_strconcat (APP_PREFIX, canonical_app_id, "/", NULL); settings = g_settings_new_with_path (APP_SCHEMA, path); full_app_id = g_settings_get_string (settings, "application-id"); app_info = G_APP_INFO (g_desktop_app_info_new (full_app_id)); if (app_info == NULL) { /* The application cannot be found, probably it was uninstalled */ g_object_unref (settings); } else { app = g_slice_new (Application); app->canonical_app_id = g_strdup (canonical_app_id); app->settings = settings; app->app_info = app_info; add_application (panel, app); } g_free (path); g_free (full_app_id); }
static void gb_editor_tab_apply_settings (GbEditorTab *tab) { GbEditorTabPrivate *priv; GtkSourceLanguage *lang; const gchar *name; gchar *path; g_return_if_fail (GB_IS_EDITOR_TAB (tab)); priv = tab->priv; g_clear_object (&priv->settings); lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (priv->document)); if (lang) { name = gtk_source_language_get_id (lang); } else { name = "plaintext"; } path = g_strdup_printf ("/org/gnome/builder/preferences/editor/language/%s/", name); priv->settings = g_settings_new_with_path ("org.gnome.builder.preferences.editor.language", path); g_free (path); g_settings_bind (priv->settings, "highlight-matching-brackets", priv->document, "highlight-matching-brackets", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "highlight-current-line", priv->text_view, "highlight-current-line", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "insert-spaces-instead-of-tabs", priv->text_view, "insert-spaces-instead-of-tabs", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "right-margin-position", priv->text_view, "right-margin-position", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "show-line-marks", priv->text_view, "show-line-marks", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "show-line-numbers", priv->text_view, "show-line-numbers", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "show-right-margin", priv->text_view, "show-right-margin", G_SETTINGS_BIND_GET); g_settings_bind (priv->settings, "tab-width", priv->text_view, "tab-width", G_SETTINGS_BIND_GET); }
void panel_layout_toplevel_create (GdkScreen *screen) { char *unique_id; char *path; GSettings *settings; PanelOrientation orientation; int monitor; unique_id = panel_layout_find_free_id (PANEL_LAYOUT_TOPLEVEL_ID_LIST_KEY, PANEL_TOPLEVEL_SCHEMA, PANEL_LAYOUT_TOPLEVEL_PATH, NULL); path = g_strdup_printf ("%s%s/", PANEL_LAYOUT_TOPLEVEL_PATH, unique_id); settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA, path); g_free (path); if (panel_toplevel_find_empty_spot (screen, &orientation, &monitor)) { g_settings_set_enum (settings, PANEL_TOPLEVEL_ORIENTATION_KEY, orientation); g_settings_set_int (settings, PANEL_TOPLEVEL_MONITOR_KEY, monitor); } g_object_unref (settings); panel_gsettings_append_strv (layout_settings, PANEL_LAYOUT_TOPLEVEL_ID_LIST_KEY, unique_id); g_free (unique_id); }
static PanelPropertiesDialog * panel_properties_dialog_new (PanelToplevel *toplevel, GtkBuilder *gui) { PanelPropertiesDialog *dialog; char *toplevel_settings_path; dialog = g_new0 (PanelPropertiesDialog, 1); g_object_set_qdata_full (G_OBJECT (toplevel), panel_properties_dialog_quark, dialog, (GDestroyNotify) panel_properties_dialog_free); dialog->toplevel = toplevel; g_object_get (toplevel, "settings-path", &toplevel_settings_path, NULL); dialog->settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA, toplevel_settings_path); dialog->settings_background = g_settings_get_child (dialog->settings, PANEL_BACKGROUND_SCHEMA_CHILD); g_free (toplevel_settings_path); dialog->properties_dialog = PANEL_GTK_BUILDER_GET (gui, "panel_properties_dialog"); g_signal_connect_swapped (dialog->properties_dialog, "response", G_CALLBACK (panel_properties_dialog_response), dialog); g_signal_connect_swapped (dialog->properties_dialog, "destroy", G_CALLBACK (panel_properties_dialog_destroy), dialog); gtk_window_set_screen (GTK_WINDOW (dialog->properties_dialog), gtk_window_get_screen (GTK_WINDOW (toplevel))); dialog->writability_warn_general = PANEL_GTK_BUILDER_GET (gui, "writability_warn_general"); dialog->writability_warn_background = PANEL_GTK_BUILDER_GET (gui, "writability_warn_background"); panel_properties_dialog_setup_orientation_combo (dialog, gui); panel_properties_dialog_size_spin_setup (dialog, gui); panel_properties_dialog_expand_toggle_setup (dialog, gui); panel_properties_dialog_autohide_toggle_setup (dialog, gui); panel_properties_dialog_hidebuttons_toggle_setup (dialog, gui); panel_properties_dialog_arrows_toggle_setup (dialog, gui); panel_properties_dialog_image_chooser_setup (dialog, gui); panel_properties_dialog_color_button_setup (dialog, gui); panel_properties_dialog_opacity_scale_setup (dialog, gui); panel_properties_dialog_background_radios_setup (dialog, gui); g_signal_connect (dialog->settings_background, "changed", G_CALLBACK (panel_properties_dialog_background_changed), dialog); panel_toplevel_push_autohide_disabler (dialog->toplevel); panel_widget_register_open_dialog (panel_toplevel_get_panel_widget (dialog->toplevel), dialog->properties_dialog); gtk_widget_show (dialog->properties_dialog); return dialog; }
void ephy_web_application_initialize_settings (const char *profile_directory) { GSettings *settings; GSettings *web_app_settings; char *name; char *path; name = g_path_get_basename (profile_directory); settings = g_settings_new_with_path (EPHY_PREFS_WEB_SCHEMA, "/org/gnome/epiphany/web/"); path = g_build_path ("/", "/org/gnome/epiphany/web-apps/", name, "web/", NULL); web_app_settings = g_settings_new_with_path (EPHY_PREFS_WEB_SCHEMA, path); g_free (path); for (guint i = 0; i < G_N_ELEMENTS (ephy_prefs_web_schema); i++) { GVariant *value; value = g_settings_get_value (settings, ephy_prefs_web_schema[i]); g_settings_set_value (web_app_settings, ephy_prefs_web_schema[i], value); g_variant_unref (value); } g_object_unref (settings); g_object_unref (web_app_settings); settings = g_settings_new_with_path (EPHY_PREFS_STATE_SCHEMA, "/org/gnome/epiphany/state/"); path = g_build_path ("/", "/org/gnome/epiphany/web-apps/", name, "state/", NULL); web_app_settings = g_settings_new_with_path (EPHY_PREFS_STATE_SCHEMA, path); g_free (path); for (guint i = 0; i < G_N_ELEMENTS (ephy_prefs_state_schema); i++) { GVariant *value; value = g_settings_get_value (settings, ephy_prefs_state_schema[i]); g_settings_set_value (web_app_settings, ephy_prefs_state_schema[i], value); g_variant_unref (value); } g_object_unref (settings); g_object_unref (web_app_settings); g_free (name); }
void panel_layout_delete_toplevel (const char *toplevel_id) { char *path; char *id_copy; char **objects; int i; if (PANEL_GLIB_STR_EMPTY (toplevel_id)) return; /* The original will be freed if removal succeeds */ id_copy = g_strdup (toplevel_id); if (!panel_gsettings_remove_all_from_strv (layout_settings, PANEL_LAYOUT_TOPLEVEL_ID_LIST_KEY, id_copy)) { g_free (id_copy); return; } path = g_strdup_printf ("%s%s/", PANEL_LAYOUT_TOPLEVEL_PATH, id_copy); panel_dconf_recursive_reset (path, NULL); /* remove all applets that were on this toplevel */ objects = g_settings_get_strv (layout_settings, PANEL_LAYOUT_OBJECT_ID_LIST_KEY); for (i = 0; objects[i] != NULL; i++) { GSettings *settings; char *object_toplevel_id; path = g_strdup_printf ("%s%s/", PANEL_LAYOUT_OBJECT_PATH, objects[i]); settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); object_toplevel_id = g_settings_get_string (settings, PANEL_OBJECT_TOPLEVEL_ID_KEY); g_object_unref (settings); g_free (path); if (g_strcmp0 (id_copy, object_toplevel_id) == 0) panel_layout_delete_object (objects[i]); g_free (object_toplevel_id); } g_strfreev (objects); g_free (id_copy); }
static GSettings * _get_ca_ignore_settings (const char *uuid) { GSettings *settings; char *path = NULL; path = g_strdup_printf ("/org/gnome/nm-applet/eap/%s", uuid); settings = g_settings_new_with_path ("org.gnome.nm-applet.eap", path); g_free (path); return settings; }
static void panel_menu_button_connect_to_gsettings (PanelMenuButton *button) { gchar *path; path = g_strdup_printf (PANEL_OBJECT_PATH "%s/", button->priv->applet_id); button->priv->settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); g_signal_connect (button->priv->settings, "changed", G_CALLBACK (panel_menu_button_gsettings_notify), button); g_free (path); }
void gsd_settings_migrate_check (const gchar *origin_schema, const gchar *origin_path, const gchar *dest_schema, const gchar *dest_path, GsdSettingsMigrateEntry entries[], guint n_entries) { GSettings *origin_settings, *dest_settings; GVariant *variant; guint i; origin_settings = g_settings_new_with_path (origin_schema, origin_path); dest_settings = g_settings_new_with_path (dest_schema, dest_path); for (i = 0; i < n_entries; i++) { variant = g_settings_get_user_value (origin_settings, entries[i].origin_key); if (!variant) continue; if (entries[i].dest_key) { if (entries[i].func) { GVariant *modified; modified = entries[i].func (variant); g_variant_unref (variant); variant = g_variant_ref_sink (modified); } g_settings_set_value (dest_settings, entries[i].dest_key, variant); } g_settings_reset (origin_settings, entries[i].origin_key); g_variant_unref (variant); } g_object_unref (origin_settings); g_object_unref (dest_settings); }
/** * panel_applet_settings_new: * @applet: a #PanelApplet. * @schema: the name of the schema. * * Creates a new #GSettings object for the per-instance settings of @applet, * with a given schema. * * Returns: a new #GSettings object for the per-instance settings of @applet. **/ GSettings * panel_applet_settings_new (PanelApplet *applet, const char *schema) { g_return_val_if_fail (PANEL_IS_APPLET (applet), NULL); g_return_val_if_fail (schema != NULL, NULL); if (!applet->priv->settings_path) { return NULL; } return g_settings_new_with_path (schema, applet->priv->settings_path); }
char * panel_layout_object_create_start (PanelObjectType type, const char *type_detail, const char *toplevel_id, PanelObjectPackType pack_type, int pack_index, GSettings **settings) { char *unique_id; char *path; GSettings *settings_object; char *iid; if (settings) *settings = NULL; iid = panel_object_type_to_iid (type, type_detail); if (!iid) return NULL; unique_id = panel_layout_find_free_id (PANEL_LAYOUT_OBJECT_ID_LIST_KEY, PANEL_OBJECT_SCHEMA, PANEL_LAYOUT_OBJECT_PATH, NULL, -1); 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); g_free (iid); if (settings) *settings = settings_object; else g_object_unref (settings_object); return unique_id; }
gboolean panel_menu_button_create (PanelToplevel *toplevel, int position, const char *filename, const char *menu_path, gboolean use_menu_path, const char *tooltip) { GSettings *settings; gchar *path; const char *scheme; char *id; id = panel_profile_prepare_object (PANEL_OBJECT_MENU, toplevel, position, FALSE); path = g_strdup_printf (PANEL_OBJECT_PATH "%s/", id); settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); g_settings_set_boolean (settings, PANEL_OBJECT_USE_MENU_PATH_KEY, use_menu_path); scheme = panel_menu_filename_to_scheme (filename); if (filename && !scheme) { g_warning ("Failed to find menu scheme for %s\n", filename); g_free (id); g_free (path); g_object_unref (settings); return FALSE; } if (use_menu_path && menu_path && menu_path [0] && scheme) { char *menu_uri; menu_uri = g_strconcat (scheme, ":", menu_path, NULL); g_settings_set_string (settings, PANEL_OBJECT_MENU_PATH_KEY, menu_uri); g_free (menu_uri); } if (tooltip && tooltip [0]) { g_settings_set_string (settings, PANEL_OBJECT_TOOLTIP_KEY, tooltip); } panel_profile_add_to_list (PANEL_GSETTINGS_OBJECTS, id); g_free (id); g_free (path); g_object_unref (settings); return TRUE; }
static gboolean set_commands(const char *key, const char *value, gboolean scale) { g_debug("Set commands key: %s, value: %s\n", key, value); gchar *ret = get_command_key(key, edge_command_map); if (ret == NULL) { return FALSE; } g_debug("Commands Real Key: %s\n", ret); GSettings *cmdSettings = g_settings_new_with_path(COMMANDS_SCHEMA_ID, COMMANDS_SCHEMA_PATH); gboolean ok = g_settings_set_string(cmdSettings, ret, value); g_free(ret); ret = NULL; ret = get_command_key(key, edge_command_run_map); if (ret == NULL) { return FALSE; } if (scale == TRUE) { // Disable cmdSettings edge value, otherwise scaleSettings value invalid g_settings_set_string(cmdSettings, ret, ""); } else { gchar *v = get_command_key(key, edge_map); if (v == NULL) { g_free(ret); return FALSE; } g_settings_set_string(cmdSettings, ret, v); g_free(v); } g_free(ret); g_settings_sync(); return ok; }
static GSettings * get_settings_background_for_toplevel (PanelToplevel *toplevel) { char *toplevel_settings_path; GSettings *settings; GSettings *settings_background; g_object_get (toplevel, "settings-path", &toplevel_settings_path, NULL); settings = g_settings_new_with_path (PANEL_TOPLEVEL_SCHEMA, toplevel_settings_path); settings_background = g_settings_get_child (settings, PANEL_BACKGROUND_SCHEMA_CHILD); g_object_unref (settings); g_free (toplevel_settings_path); return settings_background; }
/** * budgie_applet_get_applet_settings: * @uuid: UUID for this instance * * If your #BudgiePlugin implementation passes the UUID to your BudgieApplet * implementation on construction, you can take advantage of per-instance * settings. * * For most applets, global GSettings keys are more than suffice. However, * in some situations, it may be beneficial to enable multiple unique instances * of your applet, each with their own configuration. * * To facilitate this, use this function to create a new relocatable settings * instance using your UUID. Make sure you set the #BudgieApplet:settings-schema * and #BudgieApplet:settings-prefix properties first. * * Returns: (transfer full): A newly created #GSettings for this applet instance */ GSettings *budgie_applet_get_applet_settings(BudgieApplet *self, gchar *uuid) { GSettings *settings = NULL; gchar *path = NULL; if (!self->priv->schema || !self->priv->prefix) { return NULL; } path = g_strdup_printf("%s/{%s}/", self->priv->prefix, uuid); if (!path) { return NULL; } settings = g_settings_new_with_path(self->priv->schema, path); g_free(path); return settings; }
void drawer_load_from_gsettings (PanelWidget *panel_widget, gboolean locked, gint position, const char *id) { gboolean use_custom_icon; char *toplevel_id; char *custom_icon; char *tooltip; gchar *path; GSettings *settings; g_return_if_fail (panel_widget != NULL); g_return_if_fail (id != NULL); path = g_strdup_printf ("%s%s/", PANEL_OBJECT_PATH, id); settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); g_free (path); toplevel_id = g_settings_get_string (settings, PANEL_OBJECT_ATTACHED_TOPLEVEL_ID_KEY); panel_profile_load_toplevel (toplevel_id); use_custom_icon = g_settings_get_boolean (settings, PANEL_OBJECT_USE_CUSTOM_ICON_KEY); custom_icon = g_settings_get_string (settings, PANEL_OBJECT_CUSTOM_ICON_KEY); tooltip = g_settings_get_string (settings, PANEL_OBJECT_TOOLTIP_KEY); load_drawer_applet (toplevel_id, settings, custom_icon, use_custom_icon, tooltip, panel_widget->toplevel, locked, position, TRUE, id); g_free (toplevel_id); g_free (custom_icon); g_free (tooltip); }
void panel_menu_button_load_from_gsettings (PanelWidget *panel, gboolean locked, int position, gboolean exactpos, const char *id) { GSettings *settings; gchar *path; char *menu_path; char *custom_icon; char *tooltip; gboolean use_menu_path; gboolean use_custom_icon; gboolean has_arrow; path = g_strdup_printf (PANEL_OBJECT_PATH "%s/", id); settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); menu_path = g_settings_get_string (settings, PANEL_OBJECT_MENU_PATH_KEY); custom_icon = g_settings_get_string (settings, PANEL_OBJECT_CUSTOM_ICON_KEY); tooltip = g_settings_get_string (settings, PANEL_OBJECT_TOOLTIP_KEY); use_menu_path = g_settings_get_boolean (settings, PANEL_OBJECT_USE_MENU_PATH_KEY); use_custom_icon = g_settings_get_boolean (settings, PANEL_OBJECT_USE_CUSTOM_ICON_KEY); has_arrow = g_settings_get_boolean (settings, PANEL_OBJECT_HAS_ARROW_KEY); panel_menu_button_load (menu_path, use_menu_path, custom_icon, use_custom_icon, tooltip, panel, locked, position, exactpos, has_arrow, id); g_free (menu_path); g_free (custom_icon); g_free (tooltip); g_free (path); g_object_unref (settings); }
/** * games_settings_bind_window_state: * @path: a valid #GSettings path * @window: a #GtkWindow * * Restore the window configuration, and persist changes to the window configuration: * window width and height, and maximised and fullscreen state. * @window must not be realised yet. * * To make sure the state is saved at exit, g_settings_sync() must be called. */ void games_settings_bind_window_state (const char *path, GtkWindow *window) { WindowState *state; int width, height; gboolean maximised, fullscreen; g_return_if_fail (GTK_IS_WINDOW (window)); g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window))); state = g_slice_new0 (WindowState); state->window = window; state->settings = g_settings_new_with_path (SCHEMA_NAME, path); /* We delay storing the state until exit */ g_settings_delay (state->settings); g_object_set_data_full (G_OBJECT (window), "GamesSettings::WindowState", state, (GDestroyNotify) free_window_state); g_signal_connect (window, "configure-event", G_CALLBACK (window_configure_event_cb), state); g_signal_connect (window, "window-state-event", G_CALLBACK (window_state_event_cb), state); maximised = g_settings_get_boolean (state->settings, STATE_KEY_MAXIMIZED); fullscreen = g_settings_get_boolean (state->settings, STATE_KEY_FULLSCREEN); width = g_settings_get_int (state->settings, STATE_KEY_WIDTH); height = g_settings_get_int (state->settings, STATE_KEY_HEIGHT); if (width > 0 && height > 0) { gtk_window_set_default_size (GTK_WINDOW (window), width, height); } if (maximised) { gtk_window_maximize (GTK_WINDOW (window)); } if (fullscreen) { gtk_window_fullscreen (GTK_WINDOW (window)); } }
QGSettingsPrivate(const QString &schemaId, const QString &path, QGSettings *q) : schemaId(schemaId) , path(path) , valid(false) , settings(Q_NULLPTR) , schema(Q_NULLPTR) { if (path.isEmpty()) settings = g_settings_new(schemaId.toUtf8().constData()); else settings = g_settings_new_with_path(schemaId.toUtf8().constData(), path.toUtf8().constData()); if (settings) { g_object_get(settings, "settings-schema", &schema, Q_NULLPTR); g_signal_connect(settings, "changed", G_CALLBACK(QGSettingsPrivate::settingChanged), q); } valid = settings && schema; }
GSettings * panel_layout_get_instance_settings (GSettings *settings_object, const char *schema) { char *path; char *path_instance; GSettings *settings_instance; g_return_val_if_fail (G_IS_SETTINGS (settings_object), NULL); g_object_get (settings_object, "path", &path, NULL); path_instance = g_strdup_printf ("%s%s", path, PANEL_LAYOUT_OBJECT_CONFIG_SUFFIX); g_free (path); settings_instance = g_settings_new_with_path (schema, path_instance); g_free (path_instance); return settings_instance; }
GSettings * gsd_device_get_settings (GsdDevice *device) { const gchar *schema = NULL, *vendor, *product; GSettings *settings; GsdDeviceType type; gchar *path = NULL; g_return_val_if_fail (GSD_IS_DEVICE (device), NULL); type = gsd_device_get_device_type (device); if (type & (GSD_DEVICE_TYPE_TOUCHSCREEN | GSD_DEVICE_TYPE_TABLET)) { gsd_device_get_device_ids (device, &vendor, &product); if (type & GSD_DEVICE_TYPE_TOUCHSCREEN) { schema = "org.gnome.desktop.peripherals.touchscreen"; path = g_strdup_printf ("/org/gnome/desktop/peripherals/touchscreens/%s:%s/", vendor, product); } else if (type & GSD_DEVICE_TYPE_TABLET) { schema = "org.gnome.desktop.peripherals.tablet"; path = g_strdup_printf ("/org/gnome/desktop/peripherals/tablets/%s:%s/", vendor, product); } } else if (type & (GSD_DEVICE_TYPE_MOUSE | GSD_DEVICE_TYPE_TOUCHPAD)) { schema = "org.gnome.desktop.peripherals.mouse"; } else if (type & GSD_DEVICE_TYPE_KEYBOARD) { schema = "org.gnome.desktop.peripherals.keyboard"; } else { return NULL; } if (path) { settings = g_settings_new_with_path (schema, path); g_free (path); } else { settings = g_settings_new (schema); } return settings; }
static void panel_action_button_connect_to_gsettings (PanelActionButton *button) { gchar *settings_path; gchar *signal_name; settings_path = g_strdup_printf (PANEL_OBJECT_PATH "%s/", button->priv->info->id); button->priv->settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, settings_path); signal_name = g_strdup_printf ("changed::%s", PANEL_OBJECT_ACTION_TYPE_KEY); g_signal_connect (button->priv->settings, signal_name, G_CALLBACK (panel_action_button_type_changed), button); g_free (signal_name); g_free (settings_path); panel_lockdown_notify_add (G_CALLBACK (panel_action_button_update_sensitivity), button); }
void panel_action_button_load_from_gsettings (PanelWidget *panel, gboolean locked, int position, gboolean exactpos, const char *id) { GSettings *settings; PanelActionButtonType type; char *path; path = g_strdup_printf (PANEL_OBJECT_PATH "%s/", id); settings = g_settings_new_with_path (PANEL_OBJECT_SCHEMA, path); type = g_settings_get_enum (settings, PANEL_OBJECT_ACTION_TYPE_KEY); g_free (path); g_object_unref (settings); panel_action_button_load (type, panel, locked, position, exactpos, id); }