static void
swap_colors_clicked (GtkButton *button,
CcBackgroundPanel *panel)
{
CcBackgroundPanelPrivate *priv = panel->priv;
GdkColor pcolor, scolor;
char *new_pcolor, *new_scolor;
gtk_color_button_get_color (GTK_COLOR_BUTTON (WID ("style-pcolor")), &pcolor);
gtk_color_button_get_color (GTK_COLOR_BUTTON (WID ("style-scolor")), &scolor);
gtk_color_button_set_color (GTK_COLOR_BUTTON (WID ("style-scolor")), &pcolor);
gtk_color_button_set_color (GTK_COLOR_BUTTON (WID ("style-pcolor")), &scolor);
new_pcolor = gdk_color_to_string (&scolor);
new_scolor = gdk_color_to_string (&pcolor);
g_object_set (priv->current_background,
"primary-color", new_pcolor,
"secondary-color", new_scolor,
NULL);
g_settings_set_string (priv->settings, WP_PCOLOR_KEY, new_pcolor);
g_settings_set_string (priv->settings, WP_SCOLOR_KEY, new_scolor);
g_free (new_pcolor);
g_free (new_scolor);
g_settings_apply (priv->settings);
update_preview (priv, NULL);
}
/* Called when the column sort is changed */
static void
on_sort_column_changed (GtkTreeSortable *sort,
gpointer user_data)
{
SeahorseKeyManagerStore *self = SEAHORSE_KEY_MANAGER_STORE (user_data);
GtkSortType ord;
gchar* value;
gint column_id;
if (!self->priv->settings)
return;
/* We have a sort so save it */
if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (self), &column_id, &ord)) {
if (column_id >= 0 && column_id < N_COLS) {
if (columns[column_id].user_data != NULL) {
value = g_strconcat (ord == GTK_SORT_DESCENDING ? "-" : "",
columns[column_id].user_data, NULL);
g_settings_set_string (self->priv->settings, "sort-by", value);
g_free (value);
}
}
/* No sort so save blank */
} else if (self->priv->settings) {
g_settings_set_string (self->priv->settings, "sort-by", "");
}
}
static void row_selected_cb(GtkTreeSelection* selection, MateWeatherPref* pref)
{
MateWeatherApplet* gw_applet = pref->priv->applet;
GtkTreeModel* model;
WeatherLocation* loc = NULL;
GtkTreeIter iter;
if (!gtk_tree_selection_get_selected(selection, &model, &iter))
return;
gtk_tree_model_get(model, &iter, MATEWEATHER_XML_COL_POINTER, &loc, -1);
if (!loc)
{
return;
}
g_settings_set_string (gw_applet->settings, "location1", loc->code);
g_settings_set_string (gw_applet->settings, "location2", loc->zone);
g_settings_set_string (gw_applet->settings, "location3", loc->radar);
g_settings_set_string (gw_applet->settings, "location4", loc->name);
g_settings_set_string (gw_applet->settings, "coordinates", loc->coordinates);
if (gw_applet->mateweather_pref.location)
{
weather_location_free(gw_applet->mateweather_pref.location);
}
gw_applet->mateweather_pref.location =
weather_location_new (loc->name, loc->code, loc->zone, loc->radar, loc->coordinates,
NULL, NULL);
mateweather_update(gw_applet);
}
static void
wp_color_changed (AppearanceData *data,
gboolean update)
{
MateWPItem *item;
item = get_selected_item (data, NULL);
if (item == NULL)
return;
gtk_color_button_get_color (GTK_COLOR_BUTTON (data->wp_pcpicker), item->pcolor);
gtk_color_button_get_color (GTK_COLOR_BUTTON (data->wp_scpicker), item->scolor);
if (update)
{
gchar *pcolor, *scolor;
pcolor = gdk_color_to_string (item->pcolor);
scolor = gdk_color_to_string (item->scolor);
g_settings_set_string (data->wp_settings, WP_PCOLOR_KEY, pcolor);
g_settings_set_string (data->wp_settings, WP_SCOLOR_KEY, scolor);
g_free (pcolor);
g_free (scolor);
}
wp_shade_type_changed (NULL, data);
}
static void
wallpaper_style_set_as_current (WallpaperStyle *style)
{
char *uri;
if (style->file == NULL)
return;
uri = g_file_get_uri (style->file);
if (uri != NULL) {
GSettings *settings;
if (g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Cinnamon") == 0 || g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "X-Cinnamon") == 0) {
settings = g_settings_new (CINNAMON_DESKTOP_BACKGROUND_SCHEMA);
}
else if (g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "MATE") == 0) {
settings = g_settings_new (MATE_DESKTOP_BACKGROUND_SCHEMA);
}
else {
settings = g_settings_new (GNOME_DESKTOP_BACKGROUND_SCHEMA);
}
if (g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "MATE") == 0) {
g_settings_set_string (settings, MATE_DESKTOP_BACKGROUND_FILE_KEY, uri);
}
else {
g_settings_set_string (settings, DESKTOP_BACKGROUND_FILE_KEY, uri);
}
g_settings_set_enum (settings, DESKTOP_BACKGROUND_STYLE_KEY, style->background_style);
g_object_unref (settings);
}
g_free (uri);
}
static void
dlg_add_folder_save_last_options (DialogData *data)
{
char *base_dir;
char *filename;
const char *include_files;
const char *exclude_files;
const char *exclude_folders;
gboolean update;
gboolean recursive;
gboolean no_symlinks;
get_options_from_widgets (data,
&base_dir,
&filename,
&include_files,
&exclude_files,
&exclude_folders,
&update,
&recursive,
&no_symlinks);
g_settings_set_string (data->settings, PREF_ADD_CURRENT_FOLDER, base_dir);
g_settings_set_string (data->settings, PREF_ADD_FILENAME, filename);
g_settings_set_string (data->settings, PREF_ADD_INCLUDE_FILES, include_files);
g_settings_set_string (data->settings, PREF_ADD_EXCLUDE_FILES, exclude_files);
g_settings_set_string (data->settings, PREF_ADD_EXCLUDE_FOLDERS, exclude_folders);
g_settings_set_boolean (data->settings, PREF_ADD_UPDATE, update);
g_settings_set_boolean (data->settings, PREF_ADD_RECURSIVE, recursive);
g_settings_set_boolean (data->settings, PREF_ADD_NO_SYMLINKS, no_symlinks);
g_free (base_dir);
g_free (filename);
}
static GVariant *
set_contrast_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
gboolean hc;
CcUaPanel *self = user_data;
CcUaPanelPrivate *priv = self->priv;
GVariant *ret = NULL;
hc = g_value_get_boolean (value);
if (hc)
{
ret = g_variant_new_string (HIGH_CONTRAST_THEME);
g_settings_set_string (priv->interface_settings, KEY_ICON_THEME, HIGH_CONTRAST_THEME);
g_settings_set_string (priv->wm_settings, KEY_WM_THEME, HIGH_CONTRAST_THEME);
}
else
{
g_settings_reset (priv->interface_settings, KEY_GTK_THEME);
g_settings_reset (priv->interface_settings, KEY_ICON_THEME);
g_settings_reset (priv->wm_settings, KEY_WM_THEME);
}
return ret;
}
/* Preferences Callback : Change color. */
void
preferences_color_cb (GtkWidget *button, gpointer data)
{
GdkColor color, font_color;
char *color_str, *font_color_str;
gtk_color_button_get_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_color), &color);
gtk_color_button_get_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_font_color),
&font_color);
color_str = g_strdup_printf ("#%.2x%.2x%.2x",
color.red / 256,
color.green / 256,
color.blue / 256);
font_color_str = g_strdup_printf ("#%.2x%.2x%.2x",
font_color.red / 256,
font_color.green / 256,
font_color.blue / 256);
g_settings_set_string (stickynotes->settings, "default-color", color_str);
g_settings_set_string (stickynotes->settings, "default-font-color", font_color_str);
g_free (color_str);
g_free (font_color_str);
}
static void prefs_drive_changed (BraseroDriveSelection *selection, BraseroDrive *drive, gpointer user_data)
{
if (drive)
g_settings_set_string (sj_settings, SJ_SETTINGS_DEVICE, brasero_drive_get_device (drive));
else
g_settings_set_string (sj_settings, SJ_SETTINGS_DEVICE, NULL);
}
static void
photos_application_set_bg_download (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosApplication *self = PHOTOS_APPLICATION (user_data);
PhotosApplicationPrivate *priv = self->priv;
PhotosBaseItem *item = PHOTOS_BASE_ITEM (source_object);
GError *error;
gchar *filename = NULL;
error = NULL;
filename = photos_base_item_download_finish (item, res, &error);
if (error != NULL)
{
const gchar *uri;
uri = photos_base_item_get_uri (item);
g_warning ("Unable to extract the local filename for %s", uri);
g_error_free (error);
goto out;
}
g_settings_set_string (priv->settings, "picture-uri", filename);
g_settings_set_enum (priv->settings, "picture-options", G_DESKTOP_BACKGROUND_STYLE_ZOOM);
g_settings_set_enum (priv->settings, "color-shading-type", G_DESKTOP_BACKGROUND_SHADING_SOLID);
g_settings_set_string (priv->settings, "primary-color", "#000000000000");
g_settings_set_string (priv->settings, "secondary-color", "#000000000000");
out:
g_free (filename);
g_object_unref (self);
}
static void
preferences_theme_changed_cb (GtkComboBox *combo,
EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreeModel *model;
GtkTreeIter iter;
gboolean is_adium;
gchar *name;
gchar *path;
if (gtk_combo_box_get_active_iter (combo, &iter)) {
model = gtk_combo_box_get_model (combo);
gtk_tree_model_get (model, &iter,
COL_COMBO_IS_ADIUM, &is_adium,
COL_COMBO_NAME, &name,
COL_COMBO_PATH, &path,
-1);
g_settings_set_string (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_THEME,
name);
if (is_adium == TRUE)
g_settings_set_string (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_ADIUM_PATH,
path);
g_free (name);
g_free (path);
}
}
static gboolean
layout_changed (NemoDesktopManager *manager)
{
FETCH_PRIV (manager);
gint n_monitors = 0;
gint x_primary = 0;
gboolean show_desktop_on_primary = FALSE;
gboolean show_desktop_on_remaining = FALSE;
priv->update_layout_idle_id = 0;
close_all_windows (manager);
gchar *pref = g_settings_get_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT);
if (g_strcmp0 (pref, "") == 0) {
g_settings_set_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT, DESKTOPS_DEFAULT);
g_free (pref);
layout_changed (manager);
return G_SOURCE_REMOVE;
}
gchar **pref_split = g_strsplit (pref, "::", 2);
if (g_strv_length (pref_split) != 2) {
g_settings_set_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT, DESKTOPS_DEFAULT);
g_free (pref);
g_strfreev (pref_split);
layout_changed (manager);
return G_SOURCE_REMOVE;
}
n_monitors = get_n_monitors (manager);
x_primary = 0; /* always */
show_desktop_on_primary = g_strcmp0 (pref_split[0], "true") == 0;
show_desktop_on_remaining = g_strcmp0 (pref_split[1], "true") == 0;
priv->desktop_on_primary_only = show_desktop_on_primary && !show_desktop_on_remaining;
gint i = 0;
gboolean primary_set = FALSE;
for (i = 0; i < n_monitors; i++) {
if (i == x_primary) {
create_new_desktop_window (manager, i, show_desktop_on_primary, show_desktop_on_primary);
primary_set = primary_set || show_desktop_on_primary;
} else if (!nemo_desktop_utils_get_monitor_cloned (i, x_primary)) {
gboolean set_layout_primary = !primary_set && !show_desktop_on_primary && show_desktop_on_remaining;
create_new_desktop_window (manager, i, set_layout_primary, show_desktop_on_remaining);
primary_set = primary_set || set_layout_primary;
}
}
g_free (pref);
g_strfreev (pref_split);
return G_SOURCE_REMOVE;
}
static void
layout_changed (NemoDesktopManager *manager)
{
gint n_monitors = 0;
gint x_primary = 0;
gboolean show_desktop_on_primary = FALSE;
gboolean show_desktop_on_remaining = FALSE;
close_all_windows (manager);
NemoApplication *app = NEMO_APPLICATION (g_application_get_default ());
if (!nemo_application_get_show_desktop (app)) {
return;
}
gchar *pref = g_settings_get_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT);
if (g_strcmp0 (pref, "") == 0) {
g_settings_set_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT, DESKTOPS_DEFAULT);
g_free (pref);
layout_changed (manager);
}
gchar **pref_split = g_strsplit (pref, "::", 2);
if (g_strv_length (pref_split) != 2) {
g_settings_set_string (nemo_desktop_preferences, NEMO_PREFERENCES_DESKTOP_LAYOUT, DESKTOPS_DEFAULT);
g_free (pref);
g_strfreev (pref_split);
layout_changed (manager);
}
n_monitors = gdk_screen_get_n_monitors (manager->screen);
x_primary = gdk_screen_get_primary_monitor (manager->screen);
show_desktop_on_primary = g_strcmp0 (pref_split[0], "true") == 0;
show_desktop_on_remaining = g_strcmp0 (pref_split[1], "true") == 0;
gint i = 0;
gboolean primary_set = FALSE;
for (i = 0; i < n_monitors; i++) {
if (i == x_primary) {
create_new_desktop_window (manager, i, show_desktop_on_primary, show_desktop_on_primary);
primary_set = primary_set || show_desktop_on_primary;
} else if (!nemo_desktop_utils_get_monitor_cloned (i, x_primary)) {
gboolean set_layout_primary = !primary_set && !show_desktop_on_primary && show_desktop_on_remaining;
create_new_desktop_window (manager, i, set_layout_primary, show_desktop_on_remaining);
primary_set = primary_set || set_layout_primary;
}
}
g_free (pref);
g_strfreev (pref_split);
}
gboolean
xmr_settings_set_radio(XmrSettings *sett,
const gchar *name,
const gchar *url)
{
g_return_val_if_fail(sett != NULL, FALSE);
if (g_settings_set_string(G_SETTINGS(sett), "radio-name", name) != TRUE)
return FALSE;
return g_settings_set_string(G_SETTINGS(sett), "radio-url", url);
}
gboolean
xmr_settings_set_usr_info(XmrSettings *sett,
const gchar *usr,
const gchar *pwd)
{
g_return_val_if_fail(sett != NULL, FALSE);
if (g_settings_set_string(G_SETTINGS(sett), "usr", usr) != TRUE)
return FALSE;
return g_settings_set_string(G_SETTINGS(sett), "pwd", pwd);
}
static void
tracking_radio_toggled_cb (GtkWidget *widget, ZoomOptionsPrivate *priv)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) == TRUE)
{
g_settings_set_string (priv->settings, "mouse-tracking",
gtk_buildable_get_name (GTK_BUILDABLE (widget)));
g_settings_set_string (priv->settings, "focus-tracking",
gtk_buildable_get_name (GTK_BUILDABLE (widget)));
g_settings_set_string (priv->settings, "caret-tracking",
gtk_buildable_get_name (GTK_BUILDABLE (widget)));
}
}
static void
titlebar_layout_changed_callback (GtkWidget *optionmenu,
void *data)
{
gint value = gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu));
if (value == 0) {
g_settings_set_string (marco_settings, MARCO_BUTTON_LAYOUT_KEY, MARCO_BUTTON_LAYOUT_RIGHT);
}
else if (value == 1) {
g_settings_set_string (marco_settings, MARCO_BUTTON_LAYOUT_KEY, MARCO_BUTTON_LAYOUT_LEFT);
}
}
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;
}
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);
}
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;
}
/* Preferences Callback : Change font. */
void preferences_font_cb (GtkWidget *button, gpointer data)
{
const char *font_str;
font_str = gtk_font_button_get_font_name (GTK_FONT_BUTTON (button));
g_settings_set_string (stickynotes->settings, "default-font", font_str);
}
static gboolean radar_url_changed(GtkWidget* widget, GdkEventFocus* event, MateWeatherPref* pref)
{
MateWeatherApplet* gw_applet = pref->priv->applet;
gchar *text;
text = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1);
if (gw_applet->mateweather_pref.radar)
{
g_free(gw_applet->mateweather_pref.radar);
}
if (text)
{
gw_applet->mateweather_pref.radar = g_strdup(text);
g_free (text);
}
else
{
gw_applet->mateweather_pref.radar = NULL;
}
g_settings_set_string (gw_applet->settings, "radar", gw_applet->mateweather_pref.radar);
return FALSE;
}
/* callback for gtkpod window's close button */
static gboolean on_gtkpod_delete_event(GtkWidget *widget, GdkEvent *event, gpointer user_data) {
if (!ok_to_close_gtkpod())
return TRUE;
AnjutaPluginManager *plugin_manager;
AnjutaApp *app;
gchar *remembered_plugins;
gchar *session_dir;
app = ANJUTA_APP(widget);
plugin_manager = anjuta_shell_get_plugin_manager(ANJUTA_SHELL(app), NULL);
/* Save remembered plugins */
remembered_plugins = anjuta_plugin_manager_get_remembered_plugins(plugin_manager);
g_settings_set_string(app->settings, GTKPOD_REMEMBERED_PLUGINS, remembered_plugins);
g_free(remembered_plugins);
session_dir = get_user_session_dir();
anjuta_shell_session_save(ANJUTA_SHELL(app), session_dir, NULL);
g_free(session_dir);
anjuta_shell_notify_exit(ANJUTA_SHELL(app), NULL);
if (!gtkpod_cleanup_quit()) {
// Dont want to quit so avoid signalling any destroy event
return TRUE;
}
return FALSE;
}
void
calendar_config_set_dir_path (const gchar *path)
{
calendar_config_init ();
g_settings_set_string (config, "audio-dir", path);
}
static gboolean
set_background_image_from_uri (PanelToplevel *toplevel,
const char *uri)
{
GFile *file;
GSettings *settings;
file = g_file_new_for_uri (uri);
if (!g_file_is_native (file)) {
g_object_unref (file);
return FALSE;
}
g_object_unref (file);
settings = get_settings_background_for_toplevel (toplevel);
if (!g_settings_is_writable (settings,
PANEL_BACKGROUND_TYPE_KEY) ||
!g_settings_is_writable (settings,
PANEL_BACKGROUND_IMAGE_URI_KEY)) {
g_object_unref (settings);
return FALSE;
}
g_settings_set_string (settings, PANEL_BACKGROUND_IMAGE_URI_KEY, uri);
g_settings_set_enum (settings, PANEL_BACKGROUND_TYPE_KEY, PANEL_BACK_IMAGE);
g_object_unref (settings);
return FALSE;
}
static void
on_combobox_changed (GtkComboBox *widget,
GvcSoundThemeChooser *chooser)
{
GtkTreeIter iter;
GtkTreeModel *model;
char *theme_name;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (chooser->priv->combo_box), &iter) == FALSE) {
return;
}
model = gtk_combo_box_get_model (GTK_COMBO_BOX (chooser->priv->combo_box));
gtk_tree_model_get (model, &iter, THEME_IDENTIFIER_COL, &theme_name, -1);
g_assert (theme_name != NULL);
/* It is necessary to update the theme name before any other setting as
* the "changed" notification will reload the contents of the widget */
g_settings_set_string (chooser->priv->sound_settings, SOUND_THEME_KEY, theme_name);
/* special case for no sounds */
if (strcmp (theme_name, NO_SOUNDS_THEME_NAME) == 0) {
g_settings_set_boolean (chooser->priv->sound_settings, EVENT_SOUNDS_KEY, FALSE);
return;
} else {
g_settings_set_boolean (chooser->priv->sound_settings, EVENT_SOUNDS_KEY, TRUE);
}
g_free (theme_name);
/* FIXME: reset alert model */
}
static void
do_setup (GtkWidget * widget, gpointer data)
{
const gchar *type_name = NULL;
int i;
char **player_names;
gsize n_player_names;
NumberOfComputers =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (ComputerSpinner));
NumberOfHumans =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (HumanSpinner));
if (tmpDoDelay == -1)
tmpDoDelay = DoDelay;
else
DoDelay = tmpDoDelay;
DisplayComputerThoughts = tmpDisplayComputerThoughts;
for (i = 0; i < MAX_NUMBER_OF_PLAYERS; i++) {
if (players[i].name != _(DefaultPlayerNames[i]))
g_free (players[i].name);
players[i].name =
g_strdup (gtk_entry_get_text (GTK_ENTRY (PlayerNames[i])));
if (i < NumberOfPlayers)
score_list_set_column_title (ScoreList, i + 1, players[i].name);
}
setupdialog_destroy (setupdialog, 1);
n_player_names = MAX_NUMBER_OF_PLAYERS;
player_names = g_newa (char *, n_player_names + 1);
for (i = 0; i < MAX_NUMBER_OF_PLAYERS; ++i) {
player_names[i] = players[i].name;
}
player_names[i] = NULL;
g_settings_set_strv (settings, "player-names", (const gchar *const *) player_names);
g_settings_set_int (settings, "number-of-computer-opponents", NumberOfComputers);
g_settings_set_int (settings, "number-of-human-opponents", NumberOfHumans);
g_settings_set_boolean (settings, "delay-between-rolls", DoDelay);
type_name = game_type_name (NewGameType);
if (type_name) {
g_settings_set_string (settings, "game-type", type_name);
}
g_settings_set_int (settings, "monte-carlo-trials", NUM_TRIALS);
if (((NumberOfComputers != OriginalNumberOfComputers)
|| (NumberOfHumans != OriginalNumberOfHumans)
|| (NewGameType != game_type))
&& !GameIsOver ())
WarnNumPlayersChanged ();
}
static void
preferences_languages_save (EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreeView *view;
GtkTreeModel *model;
gchar *languages = NULL;
view = GTK_TREE_VIEW (priv->treeview_spell_checker);
model = gtk_tree_view_get_model (view);
gtk_tree_model_foreach (model,
(GtkTreeModelForeachFunc) preferences_languages_save_foreach,
&languages);
/* if user selects no languages, we don't want spell check */
g_settings_set_boolean (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_SPELL_CHECKER_ENABLED,
languages != NULL);
g_settings_set_string (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_SPELL_CHECKER_LANGUAGES,
languages != NULL ? languages : "");
g_free (languages);
}
static void
shell_migrate_save_current_version (void)
{
GSettings *settings;
gchar *version;
/* Save the version after the startup wizard has had a chance to
* run. If the user chooses to restore data and settings from a
* backup, Evolution will restart and the restored data may need
* to be migrated.
*
* If we save the version before the restart, then Evolution will
* think it has already migrated data and settings to the current
* version and the restored data may not be handled properly.
*
* This implies an awareness of module behavior from within the
* application core, but practical considerations overrule here. */
settings = g_settings_new ("org.gnome.evolution");
version = g_strdup_printf (
"%d.%d.%d",
EVO_MAJOR_VERSION,
EVO_MINOR_VERSION,
EVO_MICRO_VERSION);
g_settings_set_string (settings, "version", version);
g_free (version);
g_object_unref (settings);
}
static void
color_changed_cb (GtkColorButton *button,
CcBackgroundPanel *panel)
{
CcBackgroundPanelPrivate *priv = panel->priv;
GdkColor color;
gchar *value;
gboolean is_pcolor = FALSE;
gtk_color_button_get_color (button, &color);
if (WID ("style-pcolor") == GTK_WIDGET (button))
is_pcolor = TRUE;
value = gdk_color_to_string (&color);
if (priv->current_background)
{
g_object_set (G_OBJECT (priv->current_background),
is_pcolor ? "primary-color" : "secondary-color", value, NULL);
}
g_settings_set_string (priv->settings,
is_pcolor ? WP_PCOLOR_KEY : WP_SCOLOR_KEY, value);
g_settings_apply (priv->settings);
g_free (value);
update_preview (priv, NULL);
}
