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
ide_editor_perspective_save_panel_state (IdeEditorPerspective *self)
{
g_autoptr(GSettings) settings = NULL;
GtkWidget *pane;
gboolean reveal;
guint position;
g_assert (IDE_IS_EDITOR_PERSPECTIVE (self));
/* TODO: possibly belongs in editor settings */
settings = g_settings_new ("org.gnome.builder.workbench");
pane = dzl_dock_bin_get_left_edge (DZL_DOCK_BIN (self));
position = dzl_dock_revealer_get_position (DZL_DOCK_REVEALER (pane));
reveal = dzl_dock_revealer_get_reveal_child (DZL_DOCK_REVEALER (pane));
g_settings_set_boolean (settings, "left-visible", reveal);
g_settings_set_int (settings, "left-position", position);
pane = dzl_dock_bin_get_right_edge (DZL_DOCK_BIN (self));
position = dzl_dock_revealer_get_position (DZL_DOCK_REVEALER (pane));
reveal = dzl_dock_revealer_get_reveal_child (DZL_DOCK_REVEALER (pane));
g_settings_set_boolean (settings, "right-visible", reveal);
g_settings_set_int (settings, "right-position", position);
pane = dzl_dock_bin_get_bottom_edge (DZL_DOCK_BIN (self));
position = dzl_dock_revealer_get_position (DZL_DOCK_REVEALER (pane));
reveal = dzl_dock_revealer_get_reveal_child (DZL_DOCK_REVEALER (pane));
g_settings_set_boolean (settings, "bottom-visible", reveal);
g_settings_set_int (settings, "bottom-position", position);
}
static void
dpms_combo_changed_cb (GtkWidget *widget, CcScreenPanel *self)
{
GtkTreeIter iter;
GtkTreeModel *model;
gint value;
gboolean ret;
/* no selection */
ret = gtk_combo_box_get_active_iter (GTK_COMBO_BOX(widget), &iter);
if (!ret)
return;
/* get entry */
model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
gtk_tree_model_get (model, &iter,
1, &value,
-1);
/* set both battery and ac keys */
g_settings_set_int (self->priv->gsd_settings, "sleep-display-ac", value);
g_settings_set_int (self->priv->gsd_settings, "sleep-display-battery", value);
set_idle_delay_from_dpms (self, value);
}
static gboolean
geometry_store_cb (gpointer user_data)
{
GdkWindowState window_state;
GdkWindow *gdk_window;
GSettings *ui_settings;
gboolean maximized;
gint x, y, w, h;
if (!gtk_widget_get_visible (GTK_WIDGET (user_data))){
return FALSE;
}
/* Get window metrics and status */
gtk_window_get_position (GTK_WINDOW (user_data), &x, &y);
gtk_window_get_size (GTK_WINDOW (user_data), &w, &h);
gdk_window = gtk_widget_get_window (GTK_WIDGET (user_data));
window_state = gdk_window_get_state (gdk_window);
maximized = (window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
/* Save values */
ui_settings = g_object_get_data (G_OBJECT (user_data), GEOMETRY_DATA_NAME);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_X_POS, x);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_Y_POS, y);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_WIDTH, w);
g_settings_set_int (ui_settings, TWITUX_UI_WINDOW_HEIGHT, h);
g_settings_set_boolean (ui_settings, TWITUX_UI_WINDOW_MAXIMISED, maximized);
save_queue_id = 0;
return FALSE;
}
/* Preferences Callback : Save. */
void
preferences_save_cb (gpointer data)
{
gint width = gtk_adjustment_get_value (stickynotes->w_prefs_width);
gint height = gtk_adjustment_get_value (stickynotes->w_prefs_height);
gboolean sys_color = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_sys_color));
gboolean sys_font = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_sys_font));
gboolean sticky = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_sticky));
gboolean force_default = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_force));
gboolean desktop_hide = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (stickynotes->w_prefs_desktop));
if (g_settings_is_writable (stickynotes->settings,"default-width"))
g_settings_set_int (stickynotes->settings,"default-width", width);
if (g_settings_is_writable (stickynotes->settings,"default-height"))
g_settings_set_int (stickynotes->settings,"default-height", height);
if (g_settings_is_writable (stickynotes->settings,"use-system-color"))
g_settings_set_boolean (stickynotes->settings,"use-system-color", sys_color);
if (g_settings_is_writable (stickynotes->settings,"use-system-font"))
g_settings_set_boolean (stickynotes->settings,"use-system-font", sys_font);
if (g_settings_is_writable (stickynotes->settings,"sticky"))
g_settings_set_boolean (stickynotes->settings,"sticky", sticky);
if (g_settings_is_writable (stickynotes->settings,"force-default"))
g_settings_set_boolean (stickynotes->settings,"force-default", force_default);
if (g_settings_is_writable (stickynotes->settings,"desktop-hide"))
g_settings_set_boolean (stickynotes->settings,"desktop-hide", desktop_hide);
}
static void
gth_image_saver_webp_save_options (GthImageSaver *base)
{
GthImageSaverWebp *self = GTH_IMAGE_SAVER_WEBP (base);
g_settings_set_int (self->priv->settings, PREF_WEBP_QUALITY, (int) gtk_adjustment_get_value (GTK_ADJUSTMENT (GET_WIDGET ("quality_adjustment"))));
g_settings_set_int (self->priv->settings, PREF_WEBP_METHOD, (int) gtk_adjustment_get_value (GTK_ADJUSTMENT (GET_WIDGET ("method_adjustment"))));
g_settings_set_boolean (self->priv->settings, PREF_WEBP_LOSSLESS, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("lossless_checkbutton"))));
}
void
quit_game (void)
{
g_settings_set_int (settings, "window-width", window_width);
g_settings_set_int (settings, "window-height", window_height);
g_settings_set_boolean (settings, "window-is-maximized", window_is_maximized);
g_settings_set_boolean (settings, "window-is-fullscreen", window_is_fullscreen);
gtk_main_quit ();
}
void
logview_prefs_store_window_size (LogviewPrefs *prefs,
int width, int height)
{
g_assert (LOGVIEW_IS_PREFS (prefs));
g_settings_set_int (prefs->priv->logview_prefs,
PREF_WIDTH, width);
g_settings_set_int (prefs->priv->logview_prefs,
PREF_HEIGHT, height);
}
static void
ok_clicked_cb (GtkWidget *widget,
DialogData *data)
{
ResizeData *resize_data;
GtkTreeIter iter;
char *mime_type;
GthTask *resize_task;
GthTask *list_task;
resize_data = g_new0 (ResizeData, 1);
resize_data->width = gtk_spin_button_get_value (GTK_SPIN_BUTTON (GET_WIDGET ("width_spinbutton")));
resize_data->height = gtk_spin_button_get_value (GTK_SPIN_BUTTON (GET_WIDGET ("height_spinbutton")));
resize_data->unit = units[gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("unit_combobox")))];
resize_data->keep_aspect_ratio = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("keep_ratio_checkbutton")));
resize_data->allow_swap = FALSE;
gtk_combo_box_get_active_iter (GTK_COMBO_BOX (GET_WIDGET ("mime_type_combobox")), &iter);
gtk_tree_model_get (GTK_TREE_MODEL (GET_WIDGET ("mime_type_liststore")), &iter,
MIME_TYPE_COLUMN_TYPE, &mime_type,
-1);
g_settings_set_int (data->settings, PREF_RESIZE_IMAGES_SERIES_WIDTH, resize_data->width);
g_settings_set_int (data->settings, PREF_RESIZE_IMAGES_SERIES_HEIGHT, resize_data->height);
g_settings_set_enum (data->settings, PREF_RESIZE_IMAGES_UNIT, resize_data->unit);
g_settings_set_boolean (data->settings, PREF_RESIZE_IMAGES_KEEP_RATIO, resize_data->keep_aspect_ratio);
g_settings_set_string (data->settings, PREF_RESIZE_IMAGES_MIME_TYPE, mime_type ? mime_type : "");
resize_task = gth_image_task_new (_("Resizing images"),
NULL,
exec_resize,
NULL,
resize_data,
g_free);
list_task = gth_image_list_task_new (data->browser,
data->file_list,
GTH_IMAGE_TASK (resize_task));
gth_image_list_task_set_overwrite_mode (GTH_IMAGE_LIST_TASK (list_task), GTH_OVERWRITE_ASK);
gth_image_list_task_set_output_mime_type (GTH_IMAGE_LIST_TASK (list_task), mime_type);
if (data->use_destination) {
GFile *destination;
destination = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (GET_WIDGET ("destination_filechooserbutton")));
gth_image_list_task_set_destination (GTH_IMAGE_LIST_TASK (list_task), destination);
g_object_unref (destination);
}
gth_browser_exec_task (data->browser, list_task, FALSE);
g_object_unref (list_task);
g_object_unref (resize_task);
g_free (mime_type);
gtk_widget_destroy (data->dialog);
}
static void
cb_check_resize (GtkContainer *container,
gpointer user_data)
{
GSettings *settings;
gint width, height;
settings = g_settings_new (MATE_VOLUME_CONTROL_SCHEMA);
gtk_window_get_size (GTK_WINDOW (container), &width, &height);
g_settings_set_int (settings, MATE_VOLUME_CONTROL_KEY_WINDOW_WIDTH, width);
g_settings_set_int (settings, MATE_VOLUME_CONTROL_KEY_WINDOW_HEIGHT, height);
g_object_unref (settings);
}
static void
gth_file_tool_resize_destroy_options (GthFileTool *base)
{
GthFileToolResize *self;
GtkWidget *window;
GtkWidget *viewer_page;
GtkWidget *viewer;
GSettings *viewer_settings;
self = (GthFileToolResize *) base;
if (self->priv->update_size_id != 0) {
g_source_remove (self->priv->update_size_id);
self->priv->update_size_id = 0;
}
if (self->priv->builder != NULL) {
int unit;
/* save the dialog options */
unit = gtk_combo_box_get_active (GTK_COMBO_BOX (GET_WIDGET ("unit_combobox")));
g_settings_set_enum (self->priv->settings, PREF_RESIZE_UNIT, unit);
g_settings_set_double (self->priv->settings, PREF_RESIZE_WIDTH, (float) gtk_spin_button_get_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton"))));
g_settings_set_double (self->priv->settings, PREF_RESIZE_HEIGHT, (float) gtk_spin_button_get_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton"))));
g_settings_set_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_WIDTH, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_w_spinbutton"))));
g_settings_set_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_HEIGHT, gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_h_spinbutton"))));
g_settings_set_enum (self->priv->settings, PREF_RESIZE_ASPECT_RATIO, gtk_combo_box_get_active (GTK_COMBO_BOX (self->priv->ratio_combobox)));
g_settings_set_boolean (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_INVERT, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("invert_ratio_checkbutton"))));
g_settings_set_boolean (self->priv->settings, PREF_RESIZE_HIGH_QUALITY, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("high_quality_checkbutton"))));
/* destroy the options data */
_cairo_clear_surface (&self->priv->new_image);
_cairo_clear_surface (&self->priv->preview);
_g_clear_object (&self->priv->builder);
}
window = gth_file_tool_get_window (GTH_FILE_TOOL (self));
viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window));
gth_image_viewer_page_reset_viewer_tool (GTH_IMAGE_VIEWER_PAGE (viewer_page));
/* restore the zoom quality */
viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page));
viewer_settings = g_settings_new (GTHUMB_IMAGE_VIEWER_SCHEMA);
gth_image_viewer_set_zoom_quality (GTH_IMAGE_VIEWER (viewer),
g_settings_get_enum (viewer_settings, PREF_IMAGE_VIEWER_ZOOM_QUALITY));
g_object_unref (viewer_settings);
}
static void
free_window_state (WindowState *state)
{
/* Now store the settings */
g_settings_set_int (state->settings, STATE_KEY_WIDTH, state->width);
g_settings_set_int (state->settings, STATE_KEY_HEIGHT, state->height);
g_settings_set_boolean (state->settings, STATE_KEY_MAXIMIZED, state->is_maximised);
g_settings_set_boolean (state->settings, STATE_KEY_FULLSCREEN, state->is_fullscreen);
g_settings_apply (state->settings);
g_object_unref (state->settings);
g_slice_free (WindowState, state);
}
void
meta_prefs_set_num_workspaces (int n_workspaces)
{
g_settings_set_int (SETTINGS (SCHEMA_GENERAL),
KEY_NUM_WORKSPACES,
n_workspaces);
}
static void
accel_cleared_cb (GtkCellRendererAccel *cell,
char *path_string,
GamesControlsList *list)
{
GtkTreePath *path;
GtkTreeIter iter;
char *conf_key = NULL;
guint default_keyval;
path = gtk_tree_path_new_from_string (path_string);
if (!path)
return;
if (!gtk_tree_model_get_iter (list->priv->model, &iter, path)) {
gtk_tree_path_free (path);
return;
}
gtk_tree_path_free (path);
gtk_tree_model_get (list->priv->model, &iter,
CONFKEY_COLUMN, &conf_key,
DEFAULT_KEYCODE_COLUMN, &default_keyval,
-1);
if (!conf_key)
return;
/* Note: the model is updated in the conf notification callback */
/* FIXME: what to do with the modifiers? */
g_settings_set_int (list->priv->settings, conf_key, default_keyval);
g_free (conf_key);
}
static void
show_text_toggled (GtkToggleButton *button, gpointer data)
{
ProgressData *battstat = data;
MatePanelApplet *applet = MATE_PANEL_APPLET (battstat->applet);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (battstat->radio_text_2))
&& gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (battstat->check_text)))
battstat->showtext = APPLET_SHOW_PERCENT;
else if (gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (battstat->radio_text_1)) &&
gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (battstat->check_text)))
battstat->showtext = APPLET_SHOW_TIME;
else
battstat->showtext = APPLET_SHOW_NONE;
battstat->refresh_label = TRUE;
reconfigure_layout( battstat );
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1),
battstat->showtext);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2),
battstat->showtext);
g_settings_set_int (battstat->settings, "show-text", battstat->showtext);
}
static void
scrollmethod_clicked_event (GtkWidget *widget,
GtkBuilder *dialog)
{
GtkToggleButton *disabled = GTK_TOGGLE_BUTTON (WID ("scroll_disabled_radio"));
gtk_widget_set_sensitive (WID ("horiz_scroll_toggle"),
!gtk_toggle_button_get_active (disabled));
gtk_widget_set_sensitive (WID ("natural_scroll_toggle"),
!gtk_toggle_button_get_active (disabled));
GSList *radio_group;
int new_scroll_method;
int old_scroll_method = g_settings_get_int (touchpad_settings, "scroll-method");
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)))
return;
radio_group = g_slist_copy (gtk_radio_button_get_group
(GTK_RADIO_BUTTON (WID ("scroll_disabled_radio"))));
radio_group = g_slist_reverse (radio_group);
new_scroll_method = g_slist_index (radio_group, widget);
g_slist_free (radio_group);
if (new_scroll_method != old_scroll_method)
g_settings_set_int (touchpad_settings, "scroll-method", new_scroll_method);
}
static void
comboxbox_changed_callback (GtkWidget *combobox, void *data)
{
gint value = gtk_combo_box_get_active (GTK_COMBO_BOX (combobox));
gchar *key = (char *) data;
g_settings_set_int (touchpad_settings, key, value);
}
void
gth_pref_save_window_geometry (GtkWindow *window,
const char *schema)
{
GSettings *settings;
int width;
int height;
settings = g_settings_new (schema);
gtk_window_get_size (window, &width, &height);
g_settings_set_int (settings, "width", width);
g_settings_set_int (settings, "height", height);
g_object_unref (settings);
}
static void
garu_effects_equalizer_combo_box_changed (GtkComboBox *widget,
GaruEffects *self)
{
GSList *l;
gchar *band;
int active, i;
active = gtk_combo_box_get_active (widget);
g_settings_set_int (self->settings,"equalizer-preset", active);
equalizer_custom_selected = (active == G_N_ELEMENTS (eq_presets) - 1);
equalizer_changed_by_combo_box = TRUE;
for (l = self->eq_scales; l != NULL; l = l->next)
{
i = g_slist_position (self->eq_scales, l);
/* If custom preset is activated */
if (equalizer_custom_selected)
{
band = g_strdup_printf ("eq-custom-band%d", i);
gtk_range_set_value (GTK_RANGE (l->data),
g_settings_get_double (self->settings, band));
g_free (band);
}
else
{
gtk_range_set_value (GTK_RANGE (l->data),
eq_presets_values[active][i]);
}
}
equalizer_changed_by_combo_box = FALSE;
}
static void
temperature_scale_toggled(GtkToggleButton *toggle_button,
IsPreferencesDialog *self)
{
IsPreferencesDialogPrivate *priv;
priv = self->priv;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->celsius_radio_button))) {
g_settings_set_int(priv->application_settings, "temperature-scale",
IS_TEMPERATURE_SENSOR_SCALE_CELSIUS);
} else {
g_settings_set_int(priv->application_settings, "temperature-scale",
IS_TEMPERATURE_SENSOR_SCALE_FAHRENHEIT);
}
}
static void
garu_effects_equalizer_scale_changed (GtkRange *range,
gchar *band)
{
GaruApplication *app;
GaruPlayer *player;
GSettings *settings;
gint active, i;
gchar *settings_band;
app = GARU_APPLICATION (g_application_get_default ());
settings = garu_application_get_settings (app);
player = garu_application_get_player (app);
active = g_settings_get_int (settings, "equalizer-preset");
if (!equalizer_changed_by_combo_box)
{
if (!equalizer_custom_selected)
{
for (i = 0; i < G_N_ELEMENTS (eq_bands); i++)
{
settings_band = g_strdup_printf ("eq-custom-band%d", i);
g_settings_set_double (settings, settings_band,
eq_presets_values[active][i]);
g_free (settings_band);
}
g_settings_set_int (settings, "equalizer-preset",
G_N_ELEMENTS (eq_presets) - 1);
equalizer_custom_selected = TRUE;
}
g_settings_set_double (settings, band, gtk_range_get_value (range));
}
garu_player_update_equalizer (player);
}
static void prefs_dialog_display_mode_changed(GtkComboBox *display_mode_combo_box,
PrefsDialog *prefs_dialog) {
int display_mode;
display_mode = gtk_combo_box_get_active(display_mode_combo_box);
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_label),
(display_mode != DISPLAY_ICON) &&
(display_mode != DISPLAY_VALUE) &&
(display_mode != DISPLAY_GRAPH));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->layout_mode_combo_box),
(display_mode != DISPLAY_ICON) &&
(display_mode != DISPLAY_VALUE) &&
(display_mode != DISPLAY_GRAPH));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_label),
(display_mode == DISPLAY_GRAPH));
gtk_widget_set_sensitive(GTK_WIDGET(prefs_dialog->graph_size_spinbutton),
(display_mode == DISPLAY_GRAPH));
g_settings_set_int (prefs_dialog->sensors_applet->settings,
DISPLAY_MODE,
gtk_combo_box_get_active(display_mode_combo_box));
sensors_applet_display_layout_changed(prefs_dialog->sensors_applet);
}
static void prefs_dialog_temperature_scale_changed(GtkComboBox *temperature_scale_combo_box,
PrefsDialog *prefs_dialog) {
/* get old temp scale value */
TemperatureScale scales[2];
GtkTreeModel *model;
scales[OLD_TEMP_SCALE] = (TemperatureScale) g_settings_get_int (prefs_dialog->sensors_applet->settings,
TEMPERATURE_SCALE);
scales[NEW_TEMP_SCALE] = (TemperatureScale)gtk_combo_box_get_active(temperature_scale_combo_box);
g_settings_set_int (prefs_dialog->sensors_applet->settings,
TEMPERATURE_SCALE,
scales[NEW_TEMP_SCALE]);
/* now go thru and convert all low and high sensor values in
* the tree to either celcius or Fahrenheit */
model = gtk_tree_view_get_model(prefs_dialog->view);
gtk_tree_model_foreach(model,
(GtkTreeModelForeachFunc)prefs_dialog_convert_low_and_high_values,
scales);
/* finally update display of active sensors */
sensors_applet_update_active_sensors(prefs_dialog->sensors_applet);
}
void config_save(MinbarConfig* config) {
g_settings_set_string(city, "name", config->city);
g_settings_set_double(city, "latitude", config->latitude);
g_settings_set_double(city, "longitude", config->longitude);
g_settings_set_double(city, "correction", config->correction);
g_settings_set_int(prefs, "method", config->method);
g_settings_set_boolean(prefs, "start-hidden", config->start_hidden);
g_settings_set_boolean(prefs, "closes", config->close_closes);
g_settings_set_boolean(prefs, "notification", config->notification);
g_settings_set_int(prefs, "notification-time", config->notification_time);
g_settings_set_boolean(athan, "play", config->athan_enabled);
g_settings_set_string(athan, "normal", config->athan_normal);
g_settings_set_string(athan, "subh", config->athan_subh);
}
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 void
gth_image_saver_png_save_options (GthImageSaver *base)
{
GthImageSaverPng *self = GTH_IMAGE_SAVER_PNG (base);
g_settings_set_int (self->priv->settings, PREF_PNG_COMPRESSION_LEVEL, (int) gtk_adjustment_get_value (GTK_ADJUSTMENT (_gtk_builder_get_widget (self->priv->builder, "png_compression_adjustment"))));
}
void
conf_set_int_value (const gchar *key, gint value)
{
g_assert (key != NULL);
debug2 (DEBUG_CONF, "Setting %s to %d", key, value);
g_settings_set_int (settings, key, value);
}
void
xkb_save_default_group (gint default_group)
{
g_settings_set_int (xkb_desktop_settings,
GKBD_DESKTOP_CONFIG_KEY_DEFAULT_GROUP,
default_group);
}
void oregano_config_save (void)
{
g_settings_set_int (oregano.settings, "engine", oregano.engine);
g_settings_set_boolean (oregano.settings, "compress-files", oregano.compress_files);
g_settings_set_boolean (oregano.settings, "show-log", oregano.show_log);
g_settings_set_boolean (oregano.settings, "show-splash", oregano.show_splash);
}
static void
set_archive_options (DialogData *data)
{
int idx;
idx = gtk_combo_box_get_active (GTK_COMBO_BOX (data->a_archive_type_combo_box));
if (mime_type_desc[data->supported_types[idx]].capabilities & FR_COMMAND_CAN_ENCRYPT) {
const char *pwd;
pwd = gtk_entry_get_text (GTK_ENTRY (data->a_password_entry));
if (pwd != NULL) {
if (strcmp (pwd, "") != 0) {
fr_window_set_password (data->window, pwd);
if (mime_type_desc[data->supported_types[idx]].capabilities & FR_COMMAND_CAN_ENCRYPT_HEADER)
fr_window_set_encrypt_header (data->window, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->a_encrypt_header_checkbutton)));
}
}
}
if ((mime_type_desc[data->supported_types[idx]].capabilities & FR_COMMAND_CAN_CREATE_VOLUMES)
&& gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->a_volume_checkbutton)))
{
double value;
int size;
value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (data->a_volume_spinbutton));
size = floor (value * MEGABYTE);
g_settings_set_int (data->settings, PREF_BATCH_ADD_VOLUME_SIZE, size);
fr_window_set_volume_size (data->window, (guint) size);
}
}
