static void
ide_application_plugins_enabled_changed (IdeApplication *self,
const gchar *key,
GSettings *settings)
{
PeasPluginInfo *plugin_info;
PeasEngine *engine;
gboolean enabled;
g_assert (IDE_IS_APPLICATION (self));
g_assert (dzl_str_equal0 (key, "enabled"));
g_assert (G_IS_SETTINGS (settings));
enabled = g_settings_get_boolean (settings, key);
engine = peas_engine_get_default ();
plugin_info = g_object_get_data (G_OBJECT (settings), "PEAS_PLUGIN_INFO");
g_assert (plugin_info != NULL);
if (enabled &&
ide_application_can_load_plugin (self, plugin_info) &&
!peas_plugin_info_is_loaded (plugin_info))
peas_engine_load_plugin (engine, plugin_info);
else if (!enabled && peas_plugin_info_is_loaded (plugin_info))
peas_engine_unload_plugin (engine, plugin_info);
}
static void
ide_preferences_spin_button_setting_changed (IdePreferencesSpinButton *self,
const gchar *key,
GSettings *settings)
{
GtkAdjustment *adj;
GVariant *value;
g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self));
g_assert (key != NULL);
g_assert (G_IS_SETTINGS (settings));
if (self->updating)
return;
self->updating = TRUE;
adj = gtk_spin_button_get_adjustment (self->spin_button);
value = g_settings_get_value (settings, key);
apply_value (adj, value, "value");
g_variant_unref (value);
self->updating = FALSE;
}
static void
gy_window_settings__window_realize (GtkWindow *window)
{
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_settings_get (settings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (settings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (settings, "window-maximized", "b", &maximized);
gtk_window_set_default_size (window, geom.width, geom.height);
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
DzlDockBin* dockbin = gy_window_get_dockbin (GY_WINDOW (window));
GtkWidget * edge = dzl_dock_bin_get_left_edge (dockbin);
g_settings_bind (settings, "left-panel-visible", edge, "reveal-child", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "left-panel-position", edge, "position", G_SETTINGS_BIND_DEFAULT);
edge = dzl_dock_bin_get_right_edge (dockbin);
g_settings_bind (settings, "right-panel-visible", edge, "reveal-child", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "right-panel-position", edge, "position", G_SETTINGS_BIND_DEFAULT);
}
static void
sp_window_settings__window_destroy (GtkWindow *window)
{
guint handler;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
handler = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "SETTINGS_HANDLER_ID"));
if (handler != 0)
{
g_source_remove (handler);
g_object_set_data (G_OBJECT (window), "SETTINGS_HANDLER_ID", NULL);
}
g_signal_handlers_disconnect_by_func (window,
G_CALLBACK (sp_window_settings__window_configure_event),
NULL);
g_signal_handlers_disconnect_by_func (window,
G_CALLBACK (sp_window_settings__window_destroy),
NULL);
g_signal_handlers_disconnect_by_func (window,
G_CALLBACK (sp_window_settings__window_realize),
NULL);
g_object_unref (settings);
}
void
gnc_gsettings_remove_cb_by_func (const gchar *schema,
const gchar *key,
gpointer func,
gpointer user_data)
{
gint matched = 0;
GQuark quark = 0;
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_if_fail (G_IS_SETTINGS (settings_ptr));
g_return_if_fail (func);
ENTER ();
if ((key) && (gnc_gsettings_is_valid_key(settings_ptr, key)))
quark = g_quark_from_string (key);
matched = g_signal_handlers_disconnect_matched (
settings_ptr,
G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
g_signal_lookup ("changed", G_TYPE_SETTINGS), /* signal_id */
quark, /* signal_detail */
NULL, /* closure */
G_CALLBACK (func), /* callback function */
user_data);
LEAVE ("Schema: %s, key: %s - removed %d handlers for 'changed' signal", schema, key, matched);
}
static GSettings * gnc_gsettings_get_settings_ptr (const gchar *schema_str)
{
GSettings *gset = NULL;
gchar *full_name = gnc_gsettings_normalize_schema_name (schema_str);
ENTER("");
if (!schema_hash)
schema_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
gset = g_hash_table_lookup (schema_hash, full_name);
DEBUG ("Looking for schema %s returned gsettings %p", full_name, gset);
if (!gset)
{
gset = g_settings_new (full_name);
DEBUG ("Created gsettings object %p for schema %s", gset, full_name);
if (G_IS_SETTINGS(gset))
g_hash_table_insert (schema_hash, full_name, gset);
else
PWARN ("Ignoring attempt to access unknown gsettings schema %s", full_name);
}
else
{
g_free(full_name);
}
LEAVE("");
return gset;
}
gulong
gnc_gsettings_register_cb (const gchar *schema,
const gchar *key,
gpointer func,
gpointer user_data)
{
gulong retval = 0;
gchar *signal = NULL;
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
ENTER("");
g_return_val_if_fail (G_IS_SETTINGS (settings_ptr), retval);
g_return_val_if_fail (func, retval);
if ((!key) || (*key == '\0'))
signal = g_strdup ("changed");
else
{
if (gnc_gsettings_is_valid_key(settings_ptr, key))
signal = g_strconcat ("changed::", key, NULL);
}
retval = g_signal_connect (settings_ptr, signal, G_CALLBACK (func), user_data);
g_free (signal);
LEAVE("");
return retval;
}
static void
gb_color_picker_prefs_palette_row_changed (GbColorPickerPrefsPaletteRow *self,
const gchar *key,
GSettings *settings)
{
g_autoptr (GVariant) value = NULL;
gboolean active;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (key != NULL);
g_assert (G_IS_SETTINGS (settings));
if (self->target == NULL)
{
gtk_widget_set_visible (GTK_WIDGET (self->image), FALSE);
return;
}
if (self->updating == TRUE)
return;
value = g_settings_get_value (settings, key);
if (g_variant_is_of_type (value, g_variant_get_type (self->target)))
{
active = (g_variant_equal (value, self->target));
gtk_widget_set_visible (GTK_WIDGET (self->image), active);
}
else
g_warning ("Value and target must be of the same type");
}
static void
on_line_spacing_changed_cb (GbpLineSpacingBufferAddin *self,
const gchar *key,
GSettings *settings)
{
gint spacing;
g_assert (GBP_IS_LINE_SPACING_BUFFER_ADDIN (self));
g_assert (IDE_IS_BUFFER (self->buffer));
g_assert (G_IS_SETTINGS (settings));
if (self->tag != NULL)
{
GtkTextTagTable *table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (self->buffer));
gtk_text_tag_table_remove (table, self->tag);
self->tag = NULL;
}
spacing = g_settings_get_int (settings, "line-spacing");
if (spacing > 0)
{
self->tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (self->buffer), NULL,
"pixels-above-lines", spacing,
"pixels-below-lines", spacing,
NULL);
gbp_line_spacing_buffer_addin_apply (self);
}
}
void
gnc_gsettings_remove_cb_by_id (const gchar *schema,
guint handlerid)
{
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_if_fail (G_IS_SETTINGS (settings_ptr));
g_signal_handler_disconnect (settings_ptr, handlerid);
}
static void
gb_preferences_switch_set_settings (GbPreferencesSwitch *self,
GSettings *settings)
{
g_return_if_fail (GB_IS_PREFERENCES_SWITCH (self));
g_return_if_fail (G_IS_SETTINGS (settings));
if (g_set_object (&self->settings, settings))
gb_preferences_switch_update_settings (self);
}
void
gnc_gsettings_reset (const gchar *schema,
const gchar *key)
{
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_if_fail (G_IS_SETTINGS (settings_ptr));
if (gnc_gsettings_is_valid_key (settings_ptr, key))
g_settings_reset (settings_ptr, key);
else
PERR ("Invalid key %s for schema %s", key, schema);
}
static void
gb_color_picker_prefs_palette_row_disconnect (IdePreferencesBin *bin,
GSettings *settings)
{
GbColorPickerPrefsPaletteRow *self = (GbColorPickerPrefsPaletteRow *)bin;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (G_IS_SETTINGS (settings));
g_signal_handler_disconnect (settings, self->handler);
self->handler = 0;
g_clear_object (&self->settings);
}
gint
gnc_gsettings_get_enum (const gchar *schema,
const gchar *key)
{
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_val_if_fail (G_IS_SETTINGS (settings_ptr), 0);
if (gnc_gsettings_is_valid_key (settings_ptr, key))
return g_settings_get_enum (settings_ptr, key);
else
{
PERR ("Invalid key %s for schema %s", key, schema);
return 0;
}
}
gboolean
gnc_gsettings_get_bool (const gchar *schema,
const gchar *key)
{
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_val_if_fail (G_IS_SETTINGS (settings_ptr), FALSE);
if (gnc_gsettings_is_valid_key (settings_ptr, key))
return g_settings_get_boolean (settings_ptr, key);
else
{
PERR ("Invalid key %s for schema %s", key, schema);
return FALSE;
}
}
void gnc_gsettings_bind (const gchar *schema,
/*@ null @*/ const gchar *key,
gpointer object,
const gchar *property)
{
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_if_fail (G_IS_SETTINGS (settings_ptr));
if (gnc_gsettings_is_valid_key (settings_ptr, key))
g_settings_bind (settings_ptr, key, object, property, 0);
else
{
PERR ("Invalid key %s for schema %s", key, schema);
}
}
GVariant *
gnc_gsettings_get_value (const gchar *schema,
const gchar *key)
{
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_val_if_fail (G_IS_SETTINGS (settings_ptr), NULL);
if (gnc_gsettings_is_valid_key (settings_ptr, key))
return g_settings_get_value (settings_ptr, key);
else
{
PERR ("Invalid key %s for schema %s", key, schema);
return NULL;
}
}
/**
* games_settings_get_keyval:
* @settings: a #GSettings
* @key: the key name
* @keyval: (out):
* @modifiers: (out):
*
* Returns the keyboard key associated with @key in @group, or 0 if
* the value could not be parsed as a keyval.
*
* Returns: a keyboard key value
*/
void
games_settings_get_keyval (GSettings *settings,
const char *key,
guint *keyval,
GdkModifierType *modifiers)
{
KeyEntry entry;
g_return_if_fail (G_IS_SETTINGS (settings));
g_return_if_fail (key != NULL && key[0] != '\0');
g_settings_get_mapped (settings, key, (GSettingsGetMapping) variant_to_keyval, &entry);
if (keyval)
*keyval = entry.keyval;
if (modifiers)
*modifiers = entry.modifiers;
}
static char *
get_loc (GSettings *settings)
{
char *path, *schema, *ret;
g_return_val_if_fail (G_IS_SETTINGS (settings), NULL);
g_object_get (G_OBJECT (settings),
"path", &path,
"schema", &schema,
NULL);
ret = g_strdup_printf ("schema: %s (path: %s)", schema, path);
g_free (schema);
g_free (path);
return ret;
}
/**
* games_settings_set_keyval:
* @settings: a #GSettings
* @key: the key name
* @keyval: the value to store
* @modifiers: key modifiers with @keyval
*
* Associates @keyval with the key @key in group @group.
*
* It is a programmer error to pass a key that isn't valid for settings.
*
* Returns: TRUE if setting the key succeeded, FALSE if the key was not writable
*/
gboolean
games_settings_set_keyval (GSettings *settings,
const char *key,
guint keyval,
GdkModifierType modifiers)
{
char *value;
gboolean rv;
g_return_val_if_fail (G_IS_SETTINGS (settings), FALSE);
g_return_val_if_fail (key != NULL && key[0] != '\0', FALSE);
value = gtk_accelerator_name (keyval, modifiers);
rv = g_settings_set_string (settings, key, value);
g_free (value);
return rv;
}
static void
ide_terminal_font_changed (IdeTerminal *self,
const gchar *key,
GSettings *settings)
{
PangoFontDescription *font_desc = NULL;
g_autofree gchar *font_name = NULL;
g_assert (IDE_IS_TERMINAL (self));
g_assert (G_IS_SETTINGS (settings));
font_name = g_settings_get_string (settings, "font-name");
if (font_name != NULL)
font_desc = pango_font_description_from_string (font_name);
vte_terminal_set_font (VTE_TERMINAL (self), font_desc);
g_clear_pointer (&font_desc, pango_font_description_free);
}
static void
ide_highlight_engine_settings_changed (IdeHighlightEngine *self,
const gchar *key,
GSettings *settings)
{
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
g_assert (G_IS_SETTINGS (settings));
if (g_settings_get_boolean (settings, "semantic-highlighting"))
{
self->enabled = TRUE;
ide_highlight_engine_rebuild (self);
}
else
{
self->enabled = FALSE;
ide_highlight_engine_clear (self);
}
}
static void
sp_window_settings__window_realize (GtkWindow *window)
{
GtkApplication *app;
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
GList *list;
guint count = 0;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_settings_get (settings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (settings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (settings, "window-maximized", "b", &maximized);
geom.width = MAX (geom.width, WINDOW_MIN_WIDTH);
geom.height = MAX (geom.height, WINDOW_MIN_HEIGHT);
gtk_window_set_default_size (window, geom.width, geom.height);
/*
* If there are other windows currently visible other than this one,
* then ignore positioning and let the window manager decide.
*/
count = 0;
app = GTK_APPLICATION (g_application_get_default ());
list = gtk_application_get_windows (app);
for (; list != NULL; list = list->next)
{
GtkWindow *ele = list->data;
if (SP_IS_WINDOW (ele) && (ele != window) &&
gtk_widget_get_visible (GTK_WIDGET (window)))
count++;
}
if (count == 0)
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
}
static gboolean gnc_gsettings_is_valid_key(GSettings *settings, const gchar *key)
{
gchar **keys = NULL;
gint i = 0;
gboolean found = FALSE;
#ifdef HAVE_GLIB_2_46
GSettingsSchema *schema;
#endif
// Check if the key is valid key within settings
if (!G_IS_SETTINGS(settings))
return FALSE;
#ifdef HAVE_GLIB_2_46
g_object_get (settings, "settings-schema", &schema, NULL);
if (!schema)
return FALSE;
#endif
// Get list of keys
#ifdef HAVE_GLIB_2_46
keys = g_settings_schema_list_keys(schema);
#else
keys = g_settings_list_keys(settings);
#endif
while (keys && keys[i])
{
if (!g_strcmp0(key, keys[i]))
{
found = TRUE;
break;
}
i++;
}
// Free keys
g_strfreev(keys);
return found;
}
gboolean
gnc_gsettings_set_value (const gchar *schema,
const gchar *key,
GVariant *value)
{
gboolean result = FALSE;
GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema);
g_return_val_if_fail (G_IS_SETTINGS (settings_ptr), FALSE);
if (gnc_gsettings_is_valid_key (settings_ptr, key))
{
result = g_settings_set_value (settings_ptr, key, value);
if (!result)
PERR ("Unable to set value for key %s in schema %s", key, schema);
}
else
PERR ("Invalid key %s for schema %s", key, schema);
return result;
}
static void
gb_project_tree_builder_rebuild (GSettings *settings,
const gchar *key,
GbProjectTreeBuilder *self)
{
IdeTree *tree;
gboolean sort_directories_first;
g_assert (G_IS_SETTINGS (settings));
g_assert (GB_IS_PROJECT_TREE_BUILDER (self));
sort_directories_first = g_settings_get_boolean (settings, "sort-directories-first");
if (sort_directories_first != self->sort_directories_first)
{
self->sort_directories_first = sort_directories_first;
if ((tree = ide_tree_builder_get_tree (IDE_TREE_BUILDER (self))))
ide_tree_rebuild (tree);
}
}
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;
}
static void
gb_color_picker_prefs_palette_row_connect (IdePreferencesBin *bin,
GSettings *settings)
{
GbColorPickerPrefsPaletteRow *self = (GbColorPickerPrefsPaletteRow *)bin;
g_autofree gchar *signal_detail = NULL;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (G_IS_SETTINGS (settings));
signal_detail = g_strdup_printf ("changed::%s", self->key);
self->settings = g_object_ref (settings);
self->handler =
g_signal_connect_object (settings,
signal_detail,
G_CALLBACK (gb_color_picker_prefs_palette_row_changed),
self,
G_CONNECT_SWAPPED);
gb_color_picker_prefs_palette_row_changed (self, self->key, settings);
}
static gboolean
sp_window_settings__window_configure_event (GtkWindow *window,
GdkEventConfigure *event)
{
guint handler;
g_assert (GTK_IS_WINDOW (window));
g_assert (event != NULL);
g_assert (G_IS_SETTINGS (settings));
handler = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "SETTINGS_HANDLER_ID"));
if (handler == 0)
{
handler = g_timeout_add_seconds (SAVE_TIMEOUT_SECS,
sp_window_settings__window_save_settings_cb,
window);
g_object_set_data (G_OBJECT (window), "SETTINGS_HANDLER_ID", GINT_TO_POINTER (handler));
}
return GDK_EVENT_PROPAGATE;
}
static gboolean
sp_window_settings__window_save_settings_cb (gpointer data)
{
GtkWindow *window = data;
GdkRectangle geom;
gboolean maximized;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_object_set_data (G_OBJECT (window), "SETTINGS_HANDLER_ID", NULL);
gtk_window_get_size (window, &geom.width, &geom.height);
gtk_window_get_position (window, &geom.x, &geom.y);
maximized = gtk_window_is_maximized (window);
g_settings_set (settings, "window-size", "(ii)", geom.width, geom.height);
g_settings_set (settings, "window-position", "(ii)", geom.x, geom.y);
g_settings_set_boolean (settings, "window-maximized", maximized);
return G_SOURCE_REMOVE;
}
