/**
* 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);
}
