static void
change_clock_settings (GObject *gobject,
GParamSpec *pspec,
CcDateTimePanel *panel)
{
CcDateTimePanelPrivate *priv = panel->priv;
GDesktopClockFormat value;
const char *active_id;
g_signal_handlers_block_by_func (priv->clock_settings, clock_settings_changed_cb,
panel);
active_id = gtk_combo_box_get_active_id (GTK_COMBO_BOX (W ("format_combobox")));
if (!g_strcmp0 (active_id, "24h"))
value = G_DESKTOP_CLOCK_FORMAT_24H;
else
value = G_DESKTOP_CLOCK_FORMAT_12H;
g_settings_set_enum (priv->clock_settings, CLOCK_FORMAT_KEY, value);
g_settings_set_enum (priv->filechooser_settings, CLOCK_FORMAT_KEY, value);
priv->clock_format = value;
update_time (panel);
g_signal_handlers_unblock_by_func (priv->clock_settings, clock_settings_changed_cb,
panel);
}
static void
save_options (GthImportPreferencesDialog *self)
{
GFile *destination;
gboolean single_subfolder;
GthSubfolderType subfolder_type;
GthSubfolderFormat subfolder_format;
const char *custom_format;
destination = gth_import_preferences_dialog_get_destination (self);
if (destination != NULL) {
char *uri;
uri = g_file_get_uri (destination);
g_settings_set_string (self->priv->settings, PREF_IMPORTER_DESTINATION, uri);
g_free (uri);
}
single_subfolder = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("single_subfolder_checkbutton")));
g_settings_set_boolean (self->priv->settings, PREF_IMPORTER_SUBFOLDER_SINGLE, single_subfolder);
subfolder_type = get_subfolder_type (self);
g_settings_set_enum (self->priv->settings, PREF_IMPORTER_SUBFOLDER_TYPE, subfolder_type);
subfolder_format = gtk_combo_box_get_active (GTK_COMBO_BOX (self->priv->subfolder_format_list));
g_settings_set_enum (self->priv->settings, PREF_IMPORTER_SUBFOLDER_FORMAT, subfolder_format);
custom_format = gtk_entry_get_text (GTK_ENTRY (GET_WIDGET ("custom_format_entry")));
g_settings_set_string (self->priv->settings, PREF_IMPORTER_SUBFOLDER_CUSTOM_FORMAT, custom_format);
_g_object_unref (destination);
}
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
accel_cleared_callback (GtkCellRendererText *cell,
const char *path_string,
CcWacomPage *page)
{
GtkTreeView *view;
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
GtkTreeIter iter;
GtkTreeModel *model;
CsdWacomTabletButton *button;
CcWacomPagePrivate *priv;
GtkDirectionType dir;
priv = page->priv;
view = GTK_TREE_VIEW (MWID("shortcut_treeview"));
model = gtk_tree_view_get_model (view);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
MAPPING_BUTTON_COLUMN, &button,
MAPPING_BUTTON_DIRECTION, &dir,
-1);
/* sanity check */
if (button == NULL)
return;
/* Unset the key */
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING) {
char *strs[3];
char **strv;
strs[2] = NULL;
strs[0] = strs[1] = "";
strv = g_settings_get_strv (button->settings, KEY_CUSTOM_ELEVATOR_ACTION);
if (strv != NULL) {
if (g_strv_length (strv) >= 1)
strs[0] = strv[0];
if (g_strv_length (strv) >= 2)
strs[1] = strv[1];
}
if (dir == GTK_DIR_UP)
strs[0] = "";
else
strs[1] = "";
if (*strs[0] == '\0' && *strs[1] == '\0')
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, CSD_WACOM_ACTION_TYPE_NONE);
g_settings_set_strv (button->settings, KEY_CUSTOM_ELEVATOR_ACTION, (const gchar * const*) strs);
if (strv != NULL)
g_strfreev (strv);
} else {
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, CSD_WACOM_ACTION_TYPE_NONE);
g_settings_set_string (button->settings, CUSTOM_ACTION_KEY, "");
}
}
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
mouse_focus_toggled_callback (GtkWidget *button,
void *data)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (focus_mode_checkbutton))) {
g_settings_set_enum (marco_settings,
MARCO_FOCUS_KEY,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (focus_mode_mouse_checkbutton)) ?
FOCUS_MODE_MOUSE : FOCUS_MODE_SLOPPY);
}
else {
g_settings_set_enum (marco_settings, MARCO_FOCUS_KEY, FOCUS_MODE_CLICK);
}
}
static void
font_radio_toggled (GtkToggleButton *toggle_button,
FontPair *pair)
{
if (!in_change) {
GSettings *settings = g_settings_new (FONT_RENDER_SCHEMA);
g_settings_set_enum (settings, FONT_ANTIALIASING_KEY, pair->antialiasing);
g_settings_set_enum (settings, FONT_HINTING_KEY, pair->hinting);
/* Restore back to the previous state until we get notification */
font_render_load (settings);
g_object_unref (settings);
}
}
static void
change_button_action_type (CcWacomButtonRow *row,
GsdWacomActionType type)
{
GsdWacomTabletButton *button;
GsdWacomActionType current_type;
button = row->priv->button;
if (button == NULL)
return;
current_type = g_settings_get_enum (button->settings, ACTION_TYPE_KEY);
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING)
{
if (type == GSD_WACOM_ACTION_TYPE_NONE)
assign_custom_key_to_dir_button (row, "");
else if (type == GSD_WACOM_ACTION_TYPE_CUSTOM)
{
guint keyval;
GdkModifierType mask;
char *custom_key;
g_object_get (row->priv->key_shortcut_button,
"key-value", &keyval,
"key-mods", &mask,
NULL);
mask &= ~GDK_LOCK_MASK;
custom_key = gtk_accelerator_name (keyval, mask);
assign_custom_key_to_dir_button (row, custom_key);
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, type);
g_free (custom_key);
}
}
else if (current_type != type)
{
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, type);
}
gtk_widget_set_sensitive (GTK_WIDGET (row->priv->key_shortcut_button),
type == GSD_WACOM_ACTION_TYPE_CUSTOM);
}
static void temp_combo_changed_cb(GtkComboBox* combo, MateWeatherPref* pref)
{
MateWeatherApplet* gw_applet = pref->priv->applet;
TempUnit new_unit, old_unit;
g_return_if_fail(gw_applet != NULL);
new_unit = gtk_combo_box_get_active(combo) + 2;
old_unit = gw_applet->mateweather_pref.temperature_unit;
if (new_unit == old_unit)
{
return;
}
gw_applet->mateweather_pref.temperature_unit = new_unit;
g_settings_set_enum (gw_applet->settings, "temperature-unit", new_unit);
gtk_label_set_text(GTK_LABEL(gw_applet->label), weather_info_get_temp_summary(gw_applet->mateweather_info));
if (gw_applet->details_dialog)
{
mateweather_dialog_update(MATEWEATHER_DIALOG(gw_applet->details_dialog));
}
}
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 dist_combo_changed_cb(GtkComboBox* combo, MateWeatherPref* pref)
{
MateWeatherApplet* gw_applet = pref->priv->applet;
DistanceUnit new_unit, old_unit;
g_return_if_fail(gw_applet != NULL);
new_unit = gtk_combo_box_get_active(combo) + 2;
old_unit = gw_applet->mateweather_pref.distance_unit;
if (new_unit == old_unit)
{
return;
}
gw_applet->mateweather_pref.distance_unit = new_unit;
g_settings_set_enum (gw_applet->settings, "distance-unit", new_unit);
if (gw_applet->details_dialog)
{
mateweather_dialog_update(MATEWEATHER_DIALOG(gw_applet->details_dialog));
}
}
static void
combo_action_cell_changed (GtkCellRendererCombo *cell,
const gchar *path_string,
GtkTreeIter *new_iter,
CcWacomPage *page)
{
GtkTreeView *tree_view;
GtkTreePath *path;
GtkTreeModel *model;
CcWacomPagePrivate *priv;
CsdWacomActionType type;
GtkTreeIter iter;
CsdWacomTabletButton *button;
priv = page->priv;
tree_view = GTK_TREE_VIEW (MWID("shortcut_treeview"));
model = gtk_tree_view_get_model (tree_view);
path = gtk_tree_path_new_from_string (path_string);
gtk_tree_model_get (GTK_TREE_MODEL (priv->action_store), new_iter, ACTION_TYPE_COLUMN, &type, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, MAPPING_TYPE_COLUMN, WACOM_C(action_table[type].action_name), -1);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter, MAPPING_BUTTON_COLUMN, &button, -1);
if (button == NULL)
return;
if (button->settings == NULL)
return;
g_settings_set_enum (button->settings, ACTION_TYPE_KEY, type);
gtk_widget_grab_focus (GTK_WIDGET (tree_view));
}
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
wp_shade_type_changed (GtkWidget *combobox,
AppearanceData *data)
{
MateWPItem *item;
GtkTreeIter iter;
GdkPixbuf *pixbuf;
item = get_selected_item (data, &iter);
if (item == NULL)
return;
item->shade_type = gtk_combo_box_get_active (GTK_COMBO_BOX (data->wp_color_menu));
pixbuf = mate_wp_item_get_thumbnail (item, data->thumb_factory,
data->thumb_width,
data->thumb_height);
gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
if (pixbuf != NULL)
g_object_unref (pixbuf);
if (g_settings_is_writable (data->wp_settings, WP_SHADING_KEY))
g_settings_set_enum (data->wp_settings, WP_SHADING_KEY, item->shade_type);
}
static void
double_click_titlebar_changed_callback (GtkWidget *optionmenu,
void *data)
{
g_settings_set_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY,
gtk_combo_box_get_active (GTK_COMBO_BOX (optionmenu)));
}
static void
style_changed_cb (GtkComboBox *box,
CcBackgroundPanel *panel)
{
CcBackgroundPanelPrivate *priv = panel->priv;
GtkTreeModel *model;
GtkTreeIter iter;
GDesktopBackgroundStyle value;
if (!gtk_combo_box_get_active_iter (box, &iter))
{
return;
}
model = gtk_combo_box_get_model (box);
gtk_tree_model_get (model, &iter, 1, &value, -1);
g_settings_set_enum (priv->settings, WP_OPTIONS_KEY, value);
if (priv->current_background)
g_object_set (G_OBJECT (priv->current_background), "placement", value, NULL);
g_settings_apply (priv->settings);
update_preview (priv, NULL);
}
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
fm_list_view_zoom_normal (FMDirectoryView *view)
{
MarlinZoomLevel zoom;
zoom = g_settings_get_enum (marlin_list_view_settings, "default-zoom-level");
g_settings_set_enum (marlin_list_view_settings, "zoom-level", zoom);
}
static void
update_selected_format (NautilusCompressDialogController *self,
NautilusCompressionFormat format)
{
const char *extension;
const char *description_label_name;
GtkWidget *active_button;
switch (format)
{
case NAUTILUS_COMPRESSION_ZIP:
{
extension = ".zip";
description_label_name = "zip-description-label";
active_button = self->zip_radio_button;
}
break;
case NAUTILUS_COMPRESSION_TAR_XZ:
{
extension = ".tar.xz";
description_label_name = "tar-xz-description-label";
active_button = self->tar_xz_radio_button;
}
break;
case NAUTILUS_COMPRESSION_7ZIP:
{
extension = ".7z";
description_label_name = "seven-zip-description-label";
active_button = self->seven_zip_radio_button;
}
break;
default:
{
g_assert_not_reached ();
}
break;
}
self->extension = extension;
gtk_stack_set_visible_child_name (GTK_STACK (self->description_stack),
description_label_name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_button),
TRUE);
g_settings_set_enum (nautilus_compression_preferences,
NAUTILUS_PREFERENCES_DEFAULT_COMPRESSION_FORMAT,
format);
/* Since the extension changes when the button is toggled, force a
* verification of the new file name by simulating an entry change
*/
g_signal_emit_by_name (self->name_entry, "changed");
}
void
tracker_config_set_verbosity (TrackerConfig *config,
gint value)
{
g_return_if_fail (TRACKER_IS_CONFIG (config));
g_settings_set_enum (G_SETTINGS (config), "verbosity", value);
g_object_notify (G_OBJECT (config), "verbosity");
}
static gboolean
wp_props_wp_set (AppearanceData *data, MateWPItem *item)
{
gchar *pcolor, *scolor;
g_settings_delay (data->wp_settings);
if (!strcmp (item->filename, "(none)"))
{
g_settings_set_string (data->wp_settings, WP_OPTIONS_KEY, "none");
g_settings_set_string (data->wp_settings, WP_FILE_KEY, "");
}
else
{
gchar *uri;
if (g_utf8_validate (item->filename, -1, NULL))
uri = g_strdup (item->filename);
else
uri = g_filename_to_utf8 (item->filename, -1, NULL, NULL, NULL);
if (uri == NULL) {
g_warning ("Failed to convert filename to UTF-8: %s", item->filename);
} else {
g_settings_set_string (data->wp_settings, WP_FILE_KEY, uri);
g_free (uri);
}
g_settings_set_enum (data->wp_settings, WP_OPTIONS_KEY, item->options);
}
g_settings_set_enum (data->wp_settings, WP_SHADING_KEY, item->shade_type);
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);
g_settings_apply (data->wp_settings);
return FALSE;
}
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
config_set_mode (int mode)
{
GSettings *settings;
settings = g_settings_new (GSETTINGS_SCHEMA);
g_settings_set_enum (settings, KEY_MODE, mode);
g_object_unref (settings);
}
static void
migrate_tabs_visibility ()
{
gboolean always_show_tabs;
always_show_tabs = g_settings_get_boolean (EPHY_SETTINGS_UI,
EPHY_PREFS_UI_ALWAYS_SHOW_TABS_BAR);
if (always_show_tabs)
g_settings_set_enum (EPHY_SETTINGS_UI,
EPHY_PREFS_UI_TABS_BAR_VISIBILITY_POLICY,
EPHY_PREFS_UI_TABS_BAR_VISIBILITY_POLICY_ALWAYS);
}
static void
enum_item_toggled (GtkToggleButton *toggle_button,
EnumItem *item)
{
EnumGroup *group = item->group;
if (!in_change) {
g_settings_set_enum (group->settings, group->settings_key, item->value);
}
/* Restore back to the previous state until we get notification */
enum_group_load (group);
}
static void
pd_transp_radio_toggle_cb (GtkWidget *widget, gpointer data)
{
gpointer value = NULL;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
return;
value = g_object_get_data (G_OBJECT (widget), GSETTINGS_OBJECT_VALUE);
g_settings_set_enum (G_SETTINGS (data), EOM_CONF_VIEW_TRANSPARENCY,
GPOINTER_TO_INT (value));
}
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
set_autocheck_type (GSettings *settings,
PlumaSpellPluginAutocheckType autocheck_type)
{
if (!g_settings_is_writable (settings,
AUTOCHECK_TYPE_KEY))
{
return;
}
g_settings_set_enum (settings,
AUTOCHECK_TYPE_KEY,
autocheck_type);
}
static void
scrollmethod_changed_event (GtkToggleButton *button, CcMousePropertiesPrivate *d)
{
GsdTouchpadScrollMethod method;
if (d->changing_scroll)
return;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (WID ("two_finger_scroll_toggle"))))
method = GSD_TOUCHPAD_SCROLL_METHOD_TWO_FINGER_SCROLLING;
else
method = GSD_TOUCHPAD_SCROLL_METHOD_EDGE_SCROLLING;
g_settings_set_enum (d->touchpad_settings, "scroll-method", method);
}
static void
visual_bell_type_toggle_cb (GtkWidget *button,
CcUaPanel *panel)
{
gboolean frame_flash;
GDesktopVisualBellType type;
frame_flash = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
if (frame_flash)
type = G_DESKTOP_VISUAL_BELL_FRAME_FLASH;
else
type = G_DESKTOP_VISUAL_BELL_FULLSCREEN_FLASH;
g_settings_set_enum (panel->priv->wm_settings, "visual-bell-type", type);
}
