summaryrefslogtreecommitdiffstats
path: root/app/dialogs/preferences-dialog.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--app/dialogs/preferences-dialog.c3405
1 files changed, 3405 insertions, 0 deletions
diff --git a/app/dialogs/preferences-dialog.c b/app/dialogs/preferences-dialog.c
new file mode 100644
index 0000000..3797317
--- /dev/null
+++ b/app/dialogs/preferences-dialog.c
@@ -0,0 +1,3405 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpmath/gimpmath.h"
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "dialogs-types.h"
+
+#include "config/gimprc.h"
+
+#include "core/gimp.h"
+#include "core/gimptemplate.h"
+
+#include "plug-in/gimppluginmanager.h"
+
+#include "widgets/gimpaction-history.h"
+#include "widgets/gimpcolorpanel.h"
+#include "widgets/gimpcontainercombobox.h"
+#include "widgets/gimpcontainerview.h"
+#include "widgets/gimpcontrollerlist.h"
+#include "widgets/gimpdevices.h"
+#include "widgets/gimpdialogfactory.h"
+#include "widgets/gimpgrideditor.h"
+#include "widgets/gimphelp.h"
+#include "widgets/gimphelp-ids.h"
+#include "widgets/gimpiconsizescale.h"
+#include "widgets/gimplanguagecombobox.h"
+#include "widgets/gimpmessagebox.h"
+#include "widgets/gimpmessagedialog.h"
+#include "widgets/gimppluginview.h"
+#include "widgets/gimpprefsbox.h"
+#include "widgets/gimppropwidgets.h"
+#include "widgets/gimpstrokeeditor.h"
+#include "widgets/gimptemplateeditor.h"
+#include "widgets/gimptooleditor.h"
+#include "widgets/gimpwidgets-utils.h"
+
+#include "menus/menus.h"
+
+#include "tools/gimp-tools.h"
+
+#include "gui/session.h"
+#include "gui/icon-themes.h"
+#include "gui/themes.h"
+
+#include "preferences-dialog.h"
+#include "preferences-dialog-utils.h"
+#include "resolution-calibrate-dialog.h"
+
+#include "gimp-intl.h"
+
+
+#define RESPONSE_RESET 1
+
+
+/* preferences local functions */
+
+static GtkWidget * prefs_dialog_new (Gimp *gimp,
+ GimpConfig *config);
+static void prefs_config_notify (GObject *config,
+ GParamSpec *param_spec,
+ GObject *config_copy);
+static void prefs_config_copy_notify (GObject *config_copy,
+ GParamSpec *param_spec,
+ GObject *config);
+static void prefs_response (GtkWidget *widget,
+ gint response_id,
+ GtkWidget *dialog);
+
+static void prefs_message (GtkMessageType type,
+ gboolean destroy,
+ const gchar *message);
+
+static void prefs_color_management_reset (GtkWidget *widget,
+ GObject *config);
+static void prefs_dialog_defaults_reset (GtkWidget *widget,
+ GObject *config);
+static void prefs_folders_reset (GtkWidget *widget,
+ GObject *config);
+static void prefs_path_reset (GtkWidget *widget,
+ GObject *config);
+
+static void prefs_import_raw_procedure_callback (GtkWidget *widget,
+ GObject *config);
+static void prefs_resolution_source_callback (GtkWidget *widget,
+ GObject *config);
+static void prefs_resolution_calibrate_callback (GtkWidget *widget,
+ GtkWidget *entry);
+static void prefs_input_devices_dialog (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_keyboard_shortcuts_dialog (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_menus_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_menus_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_menus_remove_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_session_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_session_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_devices_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_devices_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_search_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_tool_options_save_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_tool_options_clear_callback (GtkWidget *widget,
+ Gimp *gimp);
+static void prefs_help_language_change_callback (GtkComboBox *combo,
+ Gimp *gimp);
+static void prefs_help_language_change_callback2 (GtkComboBox *combo,
+ GtkContainer *box);
+
+
+/* private variables */
+
+static GtkWidget *prefs_dialog = NULL;
+static GtkWidget *tool_editor = NULL;
+
+
+/* public function */
+
+GtkWidget *
+preferences_dialog_create (Gimp *gimp)
+{
+ GimpConfig *config;
+ GimpConfig *config_copy;
+ GimpConfig *config_orig;
+
+ g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+
+ if (prefs_dialog)
+ return prefs_dialog;
+
+ /* turn off autosaving while the prefs dialog is open */
+ gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), FALSE);
+
+ config = GIMP_CONFIG (gimp->edit_config);
+ config_copy = gimp_config_duplicate (config);
+ config_orig = gimp_config_duplicate (config);
+
+ g_signal_connect_object (config, "notify",
+ G_CALLBACK (prefs_config_notify),
+ config_copy, 0);
+ g_signal_connect_object (config_copy, "notify",
+ G_CALLBACK (prefs_config_copy_notify),
+ config, 0);
+
+ prefs_dialog = prefs_dialog_new (gimp, config_copy);
+
+ g_object_add_weak_pointer (G_OBJECT (prefs_dialog),
+ (gpointer) &prefs_dialog);
+
+ g_object_set_data (G_OBJECT (prefs_dialog), "gimp", gimp);
+
+ g_object_set_data_full (G_OBJECT (prefs_dialog), "config-copy", config_copy,
+ (GDestroyNotify) g_object_unref);
+ g_object_set_data_full (G_OBJECT (prefs_dialog), "config-orig", config_orig,
+ (GDestroyNotify) g_object_unref);
+
+ return prefs_dialog;
+}
+
+
+/* private functions */
+
+static void
+prefs_config_notify (GObject *config,
+ GParamSpec *param_spec,
+ GObject *config_copy)
+{
+ GValue global_value = G_VALUE_INIT;
+ GValue copy_value = G_VALUE_INIT;
+
+ g_value_init (&global_value, param_spec->value_type);
+ g_value_init (&copy_value, param_spec->value_type);
+
+ g_object_get_property (config, param_spec->name, &global_value);
+ g_object_get_property (config_copy, param_spec->name, &copy_value);
+
+ if (g_param_values_cmp (param_spec, &global_value, &copy_value))
+ {
+ g_signal_handlers_block_by_func (config_copy,
+ prefs_config_copy_notify,
+ config);
+
+ g_object_set_property (config_copy, param_spec->name, &global_value);
+
+ g_signal_handlers_unblock_by_func (config_copy,
+ prefs_config_copy_notify,
+ config);
+ }
+
+ g_value_unset (&global_value);
+ g_value_unset (&copy_value);
+}
+
+static void
+prefs_config_copy_notify (GObject *config_copy,
+ GParamSpec *param_spec,
+ GObject *config)
+{
+ GValue copy_value = G_VALUE_INIT;
+ GValue global_value = G_VALUE_INIT;
+
+ g_value_init (&copy_value, param_spec->value_type);
+ g_value_init (&global_value, param_spec->value_type);
+
+ g_object_get_property (config_copy, param_spec->name, &copy_value);
+ g_object_get_property (config, param_spec->name, &global_value);
+
+ if (g_param_values_cmp (param_spec, &copy_value, &global_value))
+ {
+ if (param_spec->flags & GIMP_CONFIG_PARAM_CONFIRM)
+ {
+#ifdef GIMP_CONFIG_DEBUG
+ g_print ("NOT Applying prefs change of '%s' to edit_config "
+ "because it needs confirmation\n",
+ param_spec->name);
+#endif
+ }
+ else
+ {
+#ifdef GIMP_CONFIG_DEBUG
+ g_print ("Applying prefs change of '%s' to edit_config\n",
+ param_spec->name);
+#endif
+ g_signal_handlers_block_by_func (config,
+ prefs_config_notify,
+ config_copy);
+
+ g_object_set_property (config, param_spec->name, &copy_value);
+
+ g_signal_handlers_unblock_by_func (config,
+ prefs_config_notify,
+ config_copy);
+ }
+ }
+
+ g_value_unset (&copy_value);
+ g_value_unset (&global_value);
+}
+
+static void
+prefs_response (GtkWidget *widget,
+ gint response_id,
+ GtkWidget *dialog)
+{
+ Gimp *gimp = g_object_get_data (G_OBJECT (dialog), "gimp");
+
+ switch (response_id)
+ {
+ case RESPONSE_RESET:
+ {
+ GtkWidget *confirm;
+
+ confirm = gimp_message_dialog_new (_("Reset All Preferences"),
+ GIMP_ICON_DIALOG_QUESTION,
+ dialog,
+ GTK_DIALOG_MODAL |
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ gimp_standard_help_func, NULL,
+
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_Reset"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (confirm),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (confirm)->box,
+ _("Do you really want to reset all "
+ "preferences to default values?"));
+
+ if (gimp_dialog_run (GIMP_DIALOG (confirm)) == GTK_RESPONSE_OK)
+ {
+ GimpConfig *config_copy;
+
+ config_copy = g_object_get_data (G_OBJECT (dialog), "config-copy");
+
+ gimp_config_reset (config_copy);
+ gimp_rc_load_system (GIMP_RC (config_copy));
+
+ /* don't use the default value if there is no help browser */
+ if (! gimp_help_browser_is_installed (gimp))
+ {
+ g_object_set (config_copy,
+ "help-browser", GIMP_HELP_BROWSER_WEB_BROWSER,
+ NULL);
+ }
+ }
+
+ gtk_widget_destroy (confirm);
+
+ return;
+ }
+ break;
+
+ case GTK_RESPONSE_OK:
+ {
+ GObject *config_copy;
+ GList *restart_diff;
+ GList *confirm_diff;
+ GList *list;
+
+ config_copy = g_object_get_data (G_OBJECT (dialog), "config-copy");
+
+ /* destroy config_orig */
+ g_object_set_data (G_OBJECT (dialog), "config-orig", NULL);
+
+ gtk_widget_set_sensitive (GTK_WIDGET (dialog), FALSE);
+
+ confirm_diff = gimp_config_diff (G_OBJECT (gimp->edit_config),
+ config_copy,
+ GIMP_CONFIG_PARAM_CONFIRM);
+
+ g_object_freeze_notify (G_OBJECT (gimp->edit_config));
+
+ for (list = confirm_diff; list; list = g_list_next (list))
+ {
+ GParamSpec *param_spec = list->data;
+ GValue value = G_VALUE_INIT;
+
+ g_value_init (&value, param_spec->value_type);
+
+ g_object_get_property (config_copy,
+ param_spec->name, &value);
+ g_object_set_property (G_OBJECT (gimp->edit_config),
+ param_spec->name, &value);
+
+ g_value_unset (&value);
+ }
+
+ g_object_thaw_notify (G_OBJECT (gimp->edit_config));
+
+ g_list_free (confirm_diff);
+
+ gimp_rc_save (GIMP_RC (gimp->edit_config));
+
+ /* spit out a solely informational warning about changed values
+ * which need restart
+ */
+ restart_diff = gimp_config_diff (G_OBJECT (gimp->edit_config),
+ G_OBJECT (gimp->config),
+ GIMP_CONFIG_PARAM_RESTART);
+
+ if (restart_diff)
+ {
+ GString *string;
+
+ string = g_string_new (_("You will have to restart GIMP for "
+ "the following changes to take effect:"));
+ g_string_append (string, "\n\n");
+
+ for (list = restart_diff; list; list = g_list_next (list))
+ {
+ GParamSpec *param_spec = list->data;
+
+ g_string_append_printf (string, "%s\n", param_spec->name);
+ }
+
+ prefs_message (GTK_MESSAGE_INFO, FALSE, string->str);
+
+ g_string_free (string, TRUE);
+ }
+
+ g_list_free (restart_diff);
+ }
+ break;
+
+ default:
+ {
+ GObject *config_orig;
+ GList *diff;
+ GList *list;
+
+ config_orig = g_object_get_data (G_OBJECT (dialog), "config-orig");
+
+ /* destroy config_copy */
+ g_object_set_data (G_OBJECT (dialog), "config-copy", NULL);
+
+ gtk_widget_set_sensitive (GTK_WIDGET (dialog), FALSE);
+
+ diff = gimp_config_diff (G_OBJECT (gimp->edit_config),
+ config_orig,
+ GIMP_CONFIG_PARAM_SERIALIZE);
+
+ g_object_freeze_notify (G_OBJECT (gimp->edit_config));
+
+ for (list = diff; list; list = g_list_next (list))
+ {
+ GParamSpec *param_spec = list->data;
+ GValue value = G_VALUE_INIT;
+
+ g_value_init (&value, param_spec->value_type);
+
+ g_object_get_property (config_orig,
+ param_spec->name, &value);
+ g_object_set_property (G_OBJECT (gimp->edit_config),
+ param_spec->name, &value);
+
+ g_value_unset (&value);
+ }
+
+ gimp_tool_editor_revert_changes (GIMP_TOOL_EDITOR (tool_editor));
+
+ g_object_thaw_notify (G_OBJECT (gimp->edit_config));
+
+ g_list_free (diff);
+ }
+
+ tool_editor = NULL;
+ }
+
+ /* enable autosaving again */
+ gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), TRUE);
+
+ gtk_widget_destroy (dialog);
+}
+
+static void
+prefs_color_management_reset (GtkWidget *widget,
+ GObject *config)
+{
+ GimpCoreConfig *core_config = GIMP_CORE_CONFIG (config);
+
+ gimp_config_reset (GIMP_CONFIG (core_config->color_management));
+ gimp_config_reset_property (config, "color-profile-policy");
+ gimp_config_reset_property (config, "filter-tool-show-color-options");
+}
+
+static void
+prefs_dialog_defaults_reset (GtkWidget *widget,
+ GObject *config)
+{
+ GParamSpec **pspecs;
+ guint n_pspecs;
+ guint i;
+
+ pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (config),
+ &n_pspecs);
+
+ g_object_freeze_notify (config);
+
+ for (i = 0; i < n_pspecs; i++)
+ {
+ GParamSpec *pspec = pspecs[i];
+
+ if (pspec->owner_type == GIMP_TYPE_DIALOG_CONFIG)
+ gimp_config_reset_property (config, pspec->name);
+ }
+
+ gimp_config_reset_property (config, "filter-tool-max-recent");
+ gimp_config_reset_property (config, "filter-tool-use-last-settings");
+ gimp_config_reset_property (config, "filter-tool-show-color-options");
+
+ g_object_thaw_notify (config);
+
+ g_free (pspecs);
+}
+
+static void
+prefs_folders_reset (GtkWidget *widget,
+ GObject *config)
+{
+ gimp_config_reset_property (config, "temp-path");
+ gimp_config_reset_property (config, "swap-path");
+}
+
+static void
+prefs_path_reset (GtkWidget *widget,
+ GObject *config)
+{
+ const gchar *path_property;
+ const gchar *writable_property;
+
+ path_property = g_object_get_data (G_OBJECT (widget), "path");
+ writable_property = g_object_get_data (G_OBJECT (widget), "path-writable");
+
+ gimp_config_reset_property (config, path_property);
+
+ if (writable_property)
+ gimp_config_reset_property (config, writable_property);
+}
+
+static void
+prefs_template_select_callback (GimpContainerView *view,
+ GimpTemplate *template,
+ gpointer insert_data,
+ GimpTemplate *edit_template)
+{
+ if (template)
+ {
+ /* make sure the resolution values are copied first (see bug #546924) */
+ gimp_config_sync (G_OBJECT (template), G_OBJECT (edit_template),
+ GIMP_TEMPLATE_PARAM_COPY_FIRST);
+ gimp_config_sync (G_OBJECT (template), G_OBJECT (edit_template),
+ 0);
+ }
+}
+
+static void
+prefs_import_raw_procedure_callback (GtkWidget *widget,
+ GObject *config)
+{
+ gchar *raw_plug_in;
+
+ raw_plug_in = gimp_plug_in_view_get_plug_in (GIMP_PLUG_IN_VIEW (widget));
+
+ g_object_set (config,
+ "import-raw-plug-in", raw_plug_in,
+ NULL);
+
+ g_free (raw_plug_in);
+}
+
+static void
+prefs_resolution_source_callback (GtkWidget *widget,
+ GObject *config)
+{
+ gdouble xres;
+ gdouble yres;
+ gboolean from_gdk;
+
+ from_gdk = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
+
+ if (from_gdk)
+ {
+ gimp_get_monitor_resolution (gtk_widget_get_screen (widget),
+ gimp_widget_get_monitor (widget),
+ &xres, &yres);
+ }
+ else
+ {
+ GimpSizeEntry *entry = g_object_get_data (G_OBJECT (widget),
+ "monitor_resolution_sizeentry");
+
+ g_return_if_fail (GIMP_IS_SIZE_ENTRY (entry));
+
+ xres = gimp_size_entry_get_refval (entry, 0);
+ yres = gimp_size_entry_get_refval (entry, 1);
+ }
+
+ g_object_set (config,
+ "monitor-xresolution", xres,
+ "monitor-yresolution", yres,
+ "monitor-resolution-from-windowing-system", from_gdk,
+ NULL);
+}
+
+static void
+prefs_resolution_calibrate_callback (GtkWidget *widget,
+ GtkWidget *entry)
+{
+ GtkWidget *dialog;
+ GtkWidget *prefs_box;
+ const gchar *icon_name;
+
+ dialog = gtk_widget_get_toplevel (entry);
+
+ prefs_box = g_object_get_data (G_OBJECT (dialog), "prefs-box");
+ icon_name = gimp_prefs_box_get_current_icon_name (GIMP_PREFS_BOX (prefs_box));
+
+ resolution_calibrate_dialog (entry, icon_name);
+}
+
+static void
+prefs_input_devices_dialog (GtkWidget *widget,
+ Gimp *gimp)
+{
+ gimp_dialog_factory_dialog_raise (gimp_dialog_factory_get_singleton (),
+ gtk_widget_get_screen (widget),
+ gimp_widget_get_monitor (widget),
+ "gimp-input-devices-dialog", 0);
+}
+
+static void
+prefs_keyboard_shortcuts_dialog (GtkWidget *widget,
+ Gimp *gimp)
+{
+ gimp_dialog_factory_dialog_raise (gimp_dialog_factory_get_singleton (),
+ gtk_widget_get_screen (widget),
+ gimp_widget_get_monitor (widget),
+ "gimp-keyboard-shortcuts-dialog", 0);
+}
+
+static void
+prefs_menus_save_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GtkWidget *clear_button;
+
+ menus_save (gimp, TRUE);
+
+ clear_button = g_object_get_data (G_OBJECT (widget), "clear-button");
+
+ if (clear_button)
+ gtk_widget_set_sensitive (clear_button, TRUE);
+}
+
+static void
+prefs_menus_clear_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GError *error = NULL;
+
+ if (! menus_clear (gimp, &error))
+ {
+ prefs_message (GTK_MESSAGE_ERROR, TRUE, error->message);
+ g_clear_error (&error);
+ }
+ else
+ {
+ gtk_widget_set_sensitive (widget, FALSE);
+
+ prefs_message (GTK_MESSAGE_INFO, TRUE,
+ _("Your keyboard shortcuts will be reset to "
+ "default values the next time you start GIMP."));
+ }
+}
+
+static void
+prefs_menus_remove_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GtkWidget *dialog;
+
+ dialog = gimp_message_dialog_new (_("Remove all Keyboard Shortcuts"),
+ GIMP_ICON_DIALOG_QUESTION,
+ gtk_widget_get_toplevel (widget),
+ GTK_DIALOG_MODAL |
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ gimp_standard_help_func, NULL,
+
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("Cl_ear"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ g_signal_connect_object (gtk_widget_get_toplevel (widget), "unmap",
+ G_CALLBACK (gtk_widget_destroy),
+ dialog, G_CONNECT_SWAPPED);
+
+ gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
+ _("Do you really want to remove all "
+ "keyboard shortcuts from all menus?"));
+
+ if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK)
+ {
+ menus_remove (gimp);
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+static void
+prefs_session_save_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GtkWidget *clear_button;
+
+ session_save (gimp, TRUE);
+
+ clear_button = g_object_get_data (G_OBJECT (widget), "clear-button");
+
+ if (clear_button)
+ gtk_widget_set_sensitive (clear_button, TRUE);
+}
+
+static void
+prefs_session_clear_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GError *error = NULL;
+
+ if (! session_clear (gimp, &error))
+ {
+ prefs_message (GTK_MESSAGE_ERROR, TRUE, error->message);
+ g_clear_error (&error);
+ }
+ else
+ {
+ gtk_widget_set_sensitive (widget, FALSE);
+
+ prefs_message (GTK_MESSAGE_INFO, TRUE,
+ _("Your window setup will be reset to "
+ "default values the next time you start GIMP."));
+ }
+}
+
+static void
+prefs_devices_save_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GtkWidget *clear_button;
+
+ gimp_devices_save (gimp, TRUE);
+
+ clear_button = g_object_get_data (G_OBJECT (widget), "clear-button");
+
+ if (clear_button)
+ gtk_widget_set_sensitive (clear_button, TRUE);
+}
+
+static void
+prefs_devices_clear_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GError *error = NULL;
+
+ if (! gimp_devices_clear (gimp, &error))
+ {
+ prefs_message (GTK_MESSAGE_ERROR, TRUE, error->message);
+ g_clear_error (&error);
+ }
+ else
+ {
+ gtk_widget_set_sensitive (widget, FALSE);
+
+ prefs_message (GTK_MESSAGE_INFO, TRUE,
+ _("Your input device settings will be reset to "
+ "default values the next time you start GIMP."));
+ }
+}
+
+static void
+prefs_search_clear_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ gimp_action_history_clear (gimp);
+}
+
+static void
+prefs_tool_options_save_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GtkWidget *clear_button;
+
+ gimp_tools_save (gimp, TRUE, TRUE);
+
+ clear_button = g_object_get_data (G_OBJECT (widget), "clear-button");
+
+ if (clear_button)
+ gtk_widget_set_sensitive (clear_button, TRUE);
+}
+
+static void
+prefs_tool_options_clear_callback (GtkWidget *widget,
+ Gimp *gimp)
+{
+ GError *error = NULL;
+
+ if (! gimp_tools_clear (gimp, &error))
+ {
+ prefs_message (GTK_MESSAGE_ERROR, TRUE, error->message);
+ g_clear_error (&error);
+ }
+ else
+ {
+ gtk_widget_set_sensitive (widget, FALSE);
+
+ prefs_message (GTK_MESSAGE_INFO, TRUE,
+ _("Your tool options will be reset to "
+ "default values the next time you start GIMP."));
+ }
+}
+
+static void
+prefs_help_language_change_callback (GtkComboBox *combo,
+ Gimp *gimp)
+{
+ gchar *help_locales = NULL;
+ gchar *code;
+
+ code = gimp_language_combo_box_get_code (GIMP_LANGUAGE_COMBO_BOX (combo));
+ if (code && g_strcmp0 ("", code) != 0)
+ {
+ help_locales = g_strdup_printf ("%s:", code);
+ }
+ g_object_set (gimp->config,
+ "help-locales", help_locales? help_locales : "",
+ NULL);
+ g_free (code);
+ if (help_locales)
+ g_free (help_locales);
+}
+
+static void
+prefs_help_language_change_callback2 (GtkComboBox *combo,
+ GtkContainer *box)
+{
+ Gimp *gimp;
+ GtkLabel *label = NULL;
+ GtkImage *icon = NULL;
+ GList *children;
+ GList *iter;
+ const gchar *text;
+ const gchar *icon_name;
+
+ gimp = g_object_get_data (G_OBJECT (box), "gimp");
+ children = gtk_container_get_children (box);
+ for (iter = children; iter; iter = iter->next)
+ {
+ if (GTK_IS_LABEL (iter->data))
+ {
+ label = iter->data;
+ }
+ else if (GTK_IS_IMAGE (iter->data))
+ {
+ icon = iter->data;
+ }
+ }
+ if (gimp_help_user_manual_is_installed (gimp))
+ {
+ text = _("There's a local installation of the user manual.");
+ icon_name = GIMP_ICON_DIALOG_INFORMATION;
+ }
+ else
+ {
+ text = _("The user manual is not installed locally.");
+ icon_name = GIMP_ICON_DIALOG_WARNING;
+ }
+ if (label)
+ {
+ gtk_label_set_text (label, text);
+ }
+ if (icon)
+ {
+ gtk_image_set_from_icon_name (icon, icon_name,
+ GTK_ICON_SIZE_BUTTON);
+ }
+
+ g_list_free (children);
+}
+
+static void
+prefs_format_string_select_callback (GtkTreeSelection *sel,
+ GtkEntry *entry)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ if (gtk_tree_selection_get_selected (sel, &model, &iter))
+ {
+ GValue val = G_VALUE_INIT;
+
+ gtk_tree_model_get_value (model, &iter, 1, &val);
+ gtk_entry_set_text (entry, g_value_get_string (&val));
+ g_value_unset (&val);
+ }
+}
+
+static void
+prefs_theme_select_callback (GtkTreeSelection *sel,
+ Gimp *gimp)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ if (gtk_tree_selection_get_selected (sel, &model, &iter))
+ {
+ GValue val = G_VALUE_INIT;
+
+ gtk_tree_model_get_value (model, &iter, 0, &val);
+ g_object_set_property (G_OBJECT (gimp->config), "theme", &val);
+ g_value_unset (&val);
+ }
+}
+
+static void
+prefs_theme_reload_callback (GtkWidget *button,
+ Gimp *gimp)
+{
+ g_object_notify (G_OBJECT (gimp->config), "theme");
+}
+
+static void
+prefs_icon_theme_select_callback (GtkTreeSelection *sel,
+ Gimp *gimp)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ if (gtk_tree_selection_get_selected (sel, &model, &iter))
+ {
+ GValue val = G_VALUE_INIT;
+
+ gtk_tree_model_get_value (model, &iter, 1, &val);
+ g_object_set_property (G_OBJECT (gimp->config), "icon-theme", &val);
+ g_value_unset (&val);
+ }
+}
+
+static void
+prefs_canvas_padding_color_changed (GtkWidget *button,
+ GtkWidget *combo)
+{
+ gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo),
+ GIMP_CANVAS_PADDING_MODE_CUSTOM);
+}
+
+static void
+prefs_display_options_frame_add (Gimp *gimp,
+ GObject *object,
+ const gchar *label,
+ GtkContainer *parent)
+{
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *checks_vbox;
+ GtkWidget *table;
+ GtkWidget *combo;
+ GtkWidget *button;
+
+ vbox = prefs_frame_new (label, parent, FALSE);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ checks_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+ gtk_box_pack_start (GTK_BOX (hbox), checks_vbox, TRUE, TRUE, 0);
+ gtk_widget_show (checks_vbox);
+
+ prefs_check_button_add (object, "show-selection",
+ _("Show s_election"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-layer-boundary",
+ _("Show _layer boundary"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-canvas-boundary",
+ _("Show can_vas boundary"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-guides",
+ _("Show _guides"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-grid",
+ _("Show gri_d"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-sample-points",
+ _("Show _sample points"),
+ GTK_BOX (checks_vbox));
+
+ checks_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+ gtk_box_pack_start (GTK_BOX (hbox), checks_vbox, TRUE, TRUE, 0);
+ gtk_widget_show (checks_vbox);
+
+#ifndef GDK_WINDOWING_QUARTZ
+ prefs_check_button_add (object, "show-menubar",
+ _("Show _menubar"),
+ GTK_BOX (checks_vbox));
+#endif /* !GDK_WINDOWING_QUARTZ */
+ prefs_check_button_add (object, "show-rulers",
+ _("Show _rulers"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-scrollbars",
+ _("Show scroll_bars"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "show-statusbar",
+ _("Show s_tatusbar"),
+ GTK_BOX (checks_vbox));
+
+ table = prefs_table_new (2, GTK_CONTAINER (vbox));
+
+ combo = prefs_enum_combo_box_add (object, "padding-mode", 0, 0,
+ _("Canvas _padding mode:"),
+ GTK_TABLE (table), 0,
+ NULL);
+
+ button = prefs_color_button_add (object, "padding-color",
+ _("Custom p_adding color:"),
+ _("Select Custom Canvas Padding Color"),
+ GTK_TABLE (table), 1, NULL,
+ gimp_get_user_context (gimp));
+
+ g_signal_connect (button, "color-changed",
+ G_CALLBACK (prefs_canvas_padding_color_changed),
+ combo);
+
+ prefs_check_button_add (object, "padding-in-show-all",
+ _("_Keep canvas padding in \"Show All\" mode"),
+ GTK_BOX (vbox));
+}
+
+static void
+prefs_behavior_options_frame_add (Gimp *gimp,
+ GObject *object,
+ const gchar *label,
+ GtkContainer *parent)
+{
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *checks_vbox;
+
+ vbox = prefs_frame_new (label, parent, FALSE);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ checks_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+ gtk_box_pack_start (GTK_BOX (hbox), checks_vbox, TRUE, TRUE, 0);
+ gtk_widget_show (checks_vbox);
+
+ prefs_check_button_add (object, "snap-to-guides",
+ _("Snap to _Guides"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "snap-to-grid",
+ _("S_nap to Grid"),
+ GTK_BOX (checks_vbox));
+
+ checks_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+ gtk_box_pack_start (GTK_BOX (hbox), checks_vbox, TRUE, TRUE, 0);
+ gtk_widget_show (checks_vbox);
+
+ prefs_check_button_add (object, "snap-to-canvas",
+ _("Snap to Canvas _Edges"),
+ GTK_BOX (checks_vbox));
+ prefs_check_button_add (object, "snap-to-path",
+ _("Snap to _Active Path"),
+ GTK_BOX (checks_vbox));
+}
+
+static void
+prefs_help_func (const gchar *help_id,
+ gpointer help_data)
+{
+ GtkWidget *prefs_box;
+
+ prefs_box = g_object_get_data (G_OBJECT (help_data), "prefs-box");
+
+ help_id = gimp_prefs_box_get_current_help_id (GIMP_PREFS_BOX (prefs_box));
+
+ gimp_standard_help_func (help_id, NULL);
+}
+
+static void
+prefs_message (GtkMessageType type,
+ gboolean destroy_with_parent,
+ const gchar *message)
+{
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new (GTK_WINDOW (prefs_dialog),
+ destroy_with_parent ?
+ GTK_DIALOG_DESTROY_WITH_PARENT : 0,
+ type, GTK_BUTTONS_OK,
+ "%s", message);
+
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (gtk_widget_destroy),
+ NULL);
+ gtk_widget_show (dialog);
+}
+
+static GtkWidget *
+prefs_dialog_new (Gimp *gimp,
+ GimpConfig *config)
+{
+ GtkWidget *dialog;
+ GtkTreeIter top_iter;
+ GtkTreeIter child_iter;
+
+ GtkWidget *prefs_box;
+ GtkSizeGroup *size_group = NULL;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *vbox2;
+ GtkWidget *vbox3;
+ GtkWidget *button;
+ GtkWidget *button2;
+ GtkWidget *table;
+ GtkWidget *label;
+ GtkWidget *entry;
+ GtkWidget *calibrate_button;
+ GSList *group;
+ GtkWidget *separator;
+ GtkWidget *editor;
+ gint i;
+
+ GObject *object;
+ GimpCoreConfig *core_config;
+ GimpDisplayConfig *display_config;
+ GList *manuals;
+
+ g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
+ g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL);
+
+ object = G_OBJECT (config);
+ core_config = GIMP_CORE_CONFIG (config);
+ display_config = GIMP_DISPLAY_CONFIG (config);
+
+ dialog = gimp_dialog_new (_("Preferences"), "gimp-preferences",
+ NULL, 0,
+ prefs_help_func,
+ GIMP_HELP_PREFS_DIALOG,
+
+ _("_Reset"), RESPONSE_RESET,
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_OK"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ RESPONSE_RESET,
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (prefs_response),
+ dialog);
+
+ /* The prefs box */
+ prefs_box = gimp_prefs_box_new ();
+ gtk_container_set_border_width (GTK_CONTAINER (prefs_box), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ prefs_box, TRUE, TRUE, 0);
+ gtk_widget_show (prefs_box);
+
+ g_object_set_data (G_OBJECT (dialog), "prefs-box", prefs_box);
+
+
+ /**********************/
+ /* System Resources */
+ /**********************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-system-resources",
+ _("System Resources"),
+ _("System Resources"),
+ GIMP_HELP_PREFS_SYSTEM_RESOURCES,
+ NULL,
+ &top_iter);
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ vbox2 = prefs_frame_new (_("Resource Consumption"),
+ GTK_CONTAINER (vbox), FALSE);
+
+#ifdef ENABLE_MP
+ table = prefs_table_new (6, GTK_CONTAINER (vbox2));
+#else
+ table = prefs_table_new (5, GTK_CONTAINER (vbox2));
+#endif /* ENABLE_MP */
+
+ prefs_spin_button_add (object, "undo-levels", 1.0, 5.0, 0,
+ _("Minimal number of _undo levels:"),
+ GTK_TABLE (table), 0, size_group);
+ prefs_memsize_entry_add (object, "undo-size",
+ _("Maximum undo _memory:"),
+ GTK_TABLE (table), 1, size_group);
+ prefs_memsize_entry_add (object, "tile-cache-size",
+ _("Tile cache _size:"),
+ GTK_TABLE (table), 2, size_group);
+ prefs_memsize_entry_add (object, "max-new-image-size",
+ _("Maximum _new image size:"),
+ GTK_TABLE (table), 3, size_group);
+
+ prefs_compression_combo_box_add (object, "swap-compression",
+ _("S_wap compression:"),
+ GTK_TABLE (table), 4, size_group);
+
+#ifdef ENABLE_MP
+ prefs_spin_button_add (object, "num-processors", 1.0, 4.0, 0,
+ _("Number of _threads to use:"),
+ GTK_TABLE (table), 5, size_group);
+#endif /* ENABLE_MP */
+
+ /* Internet access */
+#ifdef CHECK_UPDATE
+ vbox2 = prefs_frame_new (_("Network access"), GTK_CONTAINER (vbox),
+ FALSE);
+
+ prefs_check_button_add (object, "check-updates",
+ _("Check for updates (requires internet)"),
+ GTK_BOX (vbox2));
+#endif
+
+ /* Image Thumbnails */
+ vbox2 = prefs_frame_new (_("Image Thumbnails"), GTK_CONTAINER (vbox), FALSE);
+
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "thumbnail-size", 0, 0,
+ _("Size of _thumbnails:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_memsize_entry_add (object, "thumbnail-filesize-limit",
+ _("Maximum _filesize for thumbnailing:"),
+ GTK_TABLE (table), 1, size_group);
+
+ /* Document History */
+ vbox2 = prefs_frame_new (_("Document History"), GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "save-document-history",
+ _("_Keep record of used files in the Recent Documents list"),
+ GTK_BOX (vbox2));
+
+ g_clear_object (&size_group);
+
+
+ /***************/
+ /* Debugging */
+ /***************/
+ /* No debugging preferences are needed on win32. Either GIMP has been
+ * built with DrMinGW support (HAVE_EXCHNDL) or not. If it has, then
+ * the backtracing is enabled and can't be disabled. It assume it will
+ * work only upon a crash.
+ */
+#ifndef G_OS_WIN32
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-wilber-eek", /* TODO: icon needed. */
+ _("Debugging"),
+ _("Debugging"),
+ GIMP_HELP_PREFS_DEBUGGING,
+ NULL,
+ &top_iter);
+
+ hbox = g_object_new (GIMP_TYPE_HINT_BOX,
+ "icon-name", GIMP_ICON_DIALOG_WARNING,
+ "hint", _("We hope you will never need these "
+ "settings, but as all software, GIMP "
+ "has bugs, and crashes can occur. If it "
+ "happens, you can help us by reporting "
+ "bugs."),
+ NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ vbox2 = prefs_frame_new (_("Bug Reporting"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ button = prefs_enum_combo_box_add (object, "debug-policy", 0, 0,
+ _("Debug _policy:"),
+ GTK_TABLE (table), 0, NULL);
+
+ /* Check existence of gdb or lldb to activate the preference, as a
+ * good hint of its prerequisite, unless backtrace() API exists, in
+ * which case the feature is always available.
+ */
+ hbox = NULL;
+ if (! gimp_stack_trace_available (TRUE))
+ {
+#ifndef HAVE_EXECINFO_H
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_WARNING,
+ _("This feature requires \"gdb\" or \"lldb\" installed on your system."));
+ gtk_widget_set_sensitive (button, FALSE);
+#else
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_WARNING,
+ _("This feature is more efficient with \"gdb\" or \"lldb\" installed on your system."));
+#endif /* ! HAVE_EXECINFO_H */
+ }
+ if (hbox)
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+
+#endif /* ! G_OS_WIN32 */
+
+ /**********************/
+ /* Color Management */
+ /**********************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-color-management",
+ _("Color Management"),
+ _("Color Management"),
+ GIMP_HELP_PREFS_COLOR_MANAGEMENT,
+ NULL,
+ &top_iter);
+
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ button = gimp_prefs_box_set_page_resettable (GIMP_PREFS_BOX (prefs_box),
+ vbox,
+ _("R_eset Color Management"));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_color_management_reset),
+ config);
+
+ {
+ GObject *color_config = G_OBJECT (core_config->color_management);
+ GtkListStore *store;
+ gchar *filename;
+ gint row = 0;
+
+ filename = gimp_personal_rc_file ("profilerc");
+ store = gimp_color_profile_store_new (filename);
+ g_free (filename);
+
+ gimp_color_profile_store_add_file (GIMP_COLOR_PROFILE_STORE (store),
+ NULL, NULL);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox));
+
+ prefs_enum_combo_box_add (color_config, "mode", 0, 0,
+ _("Image display _mode:"),
+ GTK_TABLE (table), row++, NULL);
+
+ /* Color Managed Display */
+ vbox2 = prefs_frame_new (_("Color Managed Display"), GTK_CONTAINER (vbox),
+ FALSE);
+
+ table = prefs_table_new (4, GTK_CONTAINER (vbox2));
+ row = 0;
+
+ prefs_profile_combo_box_add (color_config,
+ "display-profile",
+ store,
+ _("Select Monitor Color Profile"),
+ _("_Monitor profile:"),
+ GTK_TABLE (table), row++, size_group,
+ object, "color-profile-path");
+
+ button = gimp_prop_check_button_new (color_config,
+ "display-profile-from-gdk",
+ _("_Try to use the system monitor "
+ "profile"));
+ gtk_table_attach_defaults (GTK_TABLE (table),
+ button, 1, 2, row, row + 1);
+ gtk_widget_show (button);
+ row++;
+
+ prefs_enum_combo_box_add (color_config,
+ "display-rendering-intent", 0, 0,
+ _("_Rendering intent:"),
+ GTK_TABLE (table), row++, size_group);
+
+ button = gimp_prop_check_button_new (color_config,
+ "display-use-black-point-compensation",
+ _("Use _black point compensation"));
+ gtk_table_attach_defaults (GTK_TABLE (table),
+ button, 1, 2, row, row + 1);
+ gtk_widget_show (button);
+ row++;
+
+ prefs_boolean_combo_box_add (color_config,
+ "display-optimize",
+ _("Speed"),
+ _("Precision / Color Fidelity"),
+ _("_Optimize image display for:"),
+ GTK_TABLE (table), row++, size_group);
+
+ /* Print Simulation (Soft-proofing) */
+ vbox2 = prefs_frame_new (_("Soft-Proofing"),
+ GTK_CONTAINER (vbox),
+ FALSE);
+
+ table = prefs_table_new (4, GTK_CONTAINER (vbox2));
+ row = 0;
+
+ prefs_profile_combo_box_add (color_config,
+ "printer-profile",
+ store,
+ _("Select Soft-Proofing Color Profile"),
+ _("_Soft-proofing profile:"),
+ GTK_TABLE (table), row++, size_group,
+ object, "color-profile-path");
+
+ prefs_enum_combo_box_add (color_config,
+ "simulation-rendering-intent", 0, 0,
+ _("Re_ndering intent:"),
+ GTK_TABLE (table), row++, size_group);
+
+ button = gimp_prop_check_button_new (color_config,
+ "simulation-use-black-point-compensation",
+ _("Use black _point compensation"));
+ gtk_table_attach_defaults (GTK_TABLE (table),
+ button, 1, 2, row, row + 1);
+ gtk_widget_show (button);
+ row++;
+
+ prefs_boolean_combo_box_add (color_config,
+ "simulation-optimize",
+ _("Speed"),
+ _("Precision / Color Fidelity"),
+ _("O_ptimize soft-proofing for:"),
+ GTK_TABLE (table), row++, size_group);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, row, row + 1);
+ gtk_widget_show (hbox);
+ row++;
+
+ button = gimp_prop_check_button_new (color_config, "simulation-gamut-check",
+ _("Mar_k out of gamut colors"));
+ gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+ gtk_widget_show (button);
+
+ button = gimp_prop_color_button_new (color_config, "out-of-gamut-color",
+ _("Select Warning Color"),
+ PREFS_COLOR_BUTTON_WIDTH,
+ PREFS_COLOR_BUTTON_HEIGHT,
+ GIMP_COLOR_AREA_FLAT);
+ gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ gimp_color_panel_set_context (GIMP_COLOR_PANEL (button),
+ gimp_get_user_context (gimp));
+
+ /* Preferred profiles */
+ vbox2 = prefs_frame_new (_("Preferred Profiles"), GTK_CONTAINER (vbox),
+ FALSE);
+
+ table = prefs_table_new (3, GTK_CONTAINER (vbox2));
+ row = 0;
+
+ prefs_profile_combo_box_add (color_config,
+ "rgb-profile",
+ store,
+ _("Select Preferred RGB Color Profile"),
+ _("_RGB profile:"),
+ GTK_TABLE (table), row++, size_group,
+ object, "color-profile-path");
+
+ prefs_profile_combo_box_add (color_config,
+ "gray-profile",
+ store,
+ _("Select Preferred Grayscale Color Profile"),
+ _("_Grayscale profile:"),
+ GTK_TABLE (table), row++, size_group,
+ object, "color-profile-path");
+
+ prefs_profile_combo_box_add (color_config,
+ "cmyk-profile",
+ store,
+ _("Select CMYK Color Profile"),
+ _("_CMYK profile:"),
+ GTK_TABLE (table), row++, size_group,
+ object, "color-profile-path");
+
+ /* Policies */
+ vbox2 = prefs_frame_new (_("Policies"), GTK_CONTAINER (vbox),
+ FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ button = prefs_enum_combo_box_add (object, "color-profile-policy", 0, 0,
+ _("_File Open behaviour:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Filter Dialogs */
+ vbox2 = prefs_frame_new (_("Filter Dialogs"), GTK_CONTAINER (vbox),
+ FALSE);
+
+ button = prefs_check_button_add (object, "filter-tool-show-color-options",
+ _("Show _advanced color options"),
+ GTK_BOX (vbox2));
+
+ g_clear_object (&size_group);
+
+ g_object_unref (store);
+ }
+
+
+ /***************************/
+ /* Image Import / Export */
+ /***************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-import-export",
+ _("Image Import & Export"),
+ _("Image Import & Export"),
+ GIMP_HELP_PREFS_IMPORT_EXPORT,
+ NULL,
+ &top_iter);
+
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* Import Policies */
+ vbox2 = prefs_frame_new (_("Import Policies"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ button = prefs_check_button_add (object, "import-promote-float",
+ _("Promote imported images to "
+ "_floating point precision"),
+ GTK_BOX (vbox2));
+
+ vbox3 = prefs_frame_new (NULL, GTK_CONTAINER (vbox2), FALSE);
+ g_object_bind_property (button, "active",
+ vbox3, "sensitive",
+ G_BINDING_SYNC_CREATE);
+ button = prefs_check_button_add (object, "import-promote-dither",
+ _("_Dither images when promoting to "
+ "floating point"),
+ GTK_BOX (vbox3));
+
+ button = prefs_check_button_add (object, "import-add-alpha",
+ _("_Add an alpha channel to imported images"),
+ GTK_BOX (vbox2));
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+ button = prefs_enum_combo_box_add (object, "color-profile-policy", 0, 0,
+ _("Color _profile policy:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Export Policies */
+ vbox2 = prefs_frame_new (_("Export Policies"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ button = prefs_check_button_add (object, "export-color-profile",
+ _("Export the i_mage's color profile by default"),
+ GTK_BOX (vbox2));
+ button = prefs_check_button_add (object, "export-metadata-exif",
+ /* Translators: label for
+ * configuration option (checkbox).
+ * It determines how file export
+ * plug-ins handle Exif by default.
+ */
+ _("Export _Exif metadata by default when available"),
+ GTK_BOX (vbox2));
+ button = prefs_check_button_add (object, "export-metadata-xmp",
+ /* Translators: label for
+ * configuration option (checkbox).
+ * It determines how file export
+ * plug-ins handle XMP by default.
+ */
+ _("Export _XMP metadata by default when available"),
+ GTK_BOX (vbox2));
+ button = prefs_check_button_add (object, "export-metadata-iptc",
+ /* Translators: label for
+ * configuration option (checkbox).
+ * It determines how file export
+ * plug-ins handle IPTC by default.
+ */
+ _("Export _IPTC metadata by default when available"),
+ GTK_BOX (vbox2));
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_WARNING,
+ _("Metadata can contain sensitive information."));
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+
+ /* Export File Type */
+ vbox2 = prefs_frame_new (_("Export File Type"), GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "export-file-type", 0, 0,
+ _("Default export file t_ype:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Raw Image Importer */
+ vbox2 = prefs_frame_new (_("Raw Image Importer"),
+ GTK_CONTAINER (vbox), TRUE);
+
+ {
+ GtkWidget *scrolled_window;
+ GtkWidget *view;
+
+ scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
+ GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (vbox2), scrolled_window, TRUE, TRUE, 0);
+ gtk_widget_show (scrolled_window);
+
+ view = gimp_plug_in_view_new (gimp->plug_in_manager->display_raw_load_procs);
+ gimp_plug_in_view_set_plug_in (GIMP_PLUG_IN_VIEW (view),
+ core_config->import_raw_plug_in);
+ gtk_container_add (GTK_CONTAINER (scrolled_window), view);
+ gtk_widget_show (view);
+
+ g_signal_connect (view, "changed",
+ G_CALLBACK (prefs_import_raw_procedure_callback),
+ config);
+ }
+
+ g_clear_object (&size_group);
+
+
+ /****************/
+ /* Playground */
+ /****************/
+ if (gimp->show_playground)
+ {
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-playground",
+ _("Experimental Playground"),
+ _("Playground"),
+ GIMP_HELP_PREFS_PLAYGROUND,
+ NULL,
+ &top_iter);
+
+ hbox = g_object_new (GIMP_TYPE_HINT_BOX,
+ "icon-name", GIMP_ICON_DIALOG_WARNING,
+ "hint", _("These features are unfinished, buggy "
+ "and may crash GIMP. It is unadvised to "
+ "use them unless you really know what "
+ "you are doing or you intend to contribute "
+ "patches."),
+ NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ /* Hardware Acceleration */
+ vbox2 = prefs_frame_new (_("Hardware Acceleration"), GTK_CONTAINER (vbox),
+ FALSE);
+
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_WARNING,
+ _("OpenCL drivers and support are experimental, "
+ "expect slowdowns and possible crashes "
+ "(please report)."));
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+
+ prefs_check_button_add (object, "use-opencl",
+ _("Use O_penCL"),
+ GTK_BOX (vbox2));
+
+ /* Very unstable tools */
+ vbox2 = prefs_frame_new (_("Insane Options"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ button = prefs_check_button_add (object, "playground-npd-tool",
+ _("_N-Point Deformation tool"),
+ GTK_BOX (vbox2));
+ button = prefs_check_button_add (object, "playground-seamless-clone-tool",
+ _("_Seamless Clone tool"),
+ GTK_BOX (vbox2));
+ }
+
+
+ /******************/
+ /* Tool Options */
+ /******************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-tool-options",
+ C_("preferences", "Tool Options"),
+ C_("preferences", "Tool Options"),
+ GIMP_HELP_PREFS_TOOL_OPTIONS,
+ NULL,
+ &top_iter);
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* General */
+ vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "edit-non-visible",
+ _("Allow _editing on non-visible layers"),
+ GTK_BOX (vbox2));
+
+ prefs_check_button_add (object, "save-tool-options",
+ _("_Save tool options on exit"),
+ GTK_BOX (vbox2));
+
+ button = prefs_button_add (GIMP_ICON_DOCUMENT_SAVE,
+ _("Save Tool Options _Now"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_tool_options_save_callback),
+ gimp);
+
+ button2 = prefs_button_add (GIMP_ICON_RESET,
+ _("_Reset Saved Tool Options to "
+ "Default Values"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button2, "clicked",
+ G_CALLBACK (prefs_tool_options_clear_callback),
+ gimp);
+
+ g_object_set_data (G_OBJECT (button), "clear-button", button2);
+
+ /* Scaling */
+ vbox2 = prefs_frame_new (_("Scaling"), GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "interpolation-type", 0, 0,
+ _("Default _interpolation:"),
+ GTK_TABLE (table), 0, size_group);
+
+ g_object_unref (size_group);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* Global Brush, Pattern, ... */
+ vbox2 = prefs_frame_new (_("Paint Options Shared Between Tools"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add_with_icon (object, "global-brush",
+ _("_Brush"), GIMP_ICON_BRUSH,
+ GTK_BOX (vbox2), size_group);
+ prefs_check_button_add_with_icon (object, "global-dynamics",
+ _("_Dynamics"), GIMP_ICON_DYNAMICS,
+ GTK_BOX (vbox2), size_group);
+ prefs_check_button_add_with_icon (object, "global-pattern",
+ _("_Pattern"), GIMP_ICON_PATTERN,
+ GTK_BOX (vbox2), size_group);
+ prefs_check_button_add_with_icon (object, "global-gradient",
+ _("_Gradient"), GIMP_ICON_GRADIENT,
+ GTK_BOX (vbox2), size_group);
+
+ /* Move Tool */
+ vbox2 = prefs_frame_new (_("Move Tool"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add_with_icon (object, "move-tool-changes-active",
+ _("Set _layer or path as active"),
+ GIMP_ICON_TOOL_MOVE,
+ GTK_BOX (vbox2), size_group);
+
+ g_clear_object (&size_group);
+
+
+ /*******************/
+ /* Default Image */
+ /*******************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-new-image",
+ _("Default New Image"),
+ _("Default Image"),
+ GIMP_HELP_PREFS_NEW_IMAGE,
+ NULL,
+ &top_iter);
+
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox));
+
+ {
+ GtkWidget *combo;
+
+ combo = gimp_container_combo_box_new (gimp->templates,
+ gimp_get_user_context (gimp),
+ 16, 0);
+ gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
+ _("_Template:"), 0.0, 0.5,
+ combo, 1, FALSE);
+
+ gimp_container_view_select_item (GIMP_CONTAINER_VIEW (combo), NULL);
+
+ g_signal_connect (combo, "select-item",
+ G_CALLBACK (prefs_template_select_callback),
+ core_config->default_image);
+ }
+
+ editor = gimp_template_editor_new (core_config->default_image, gimp, FALSE);
+ gimp_template_editor_show_advanced (GIMP_TEMPLATE_EDITOR (editor), TRUE);
+ gtk_box_pack_start (GTK_BOX (vbox), editor, FALSE, FALSE, 0);
+ gtk_widget_show (editor);
+
+ /* Quick Mask Color */
+ vbox2 = prefs_frame_new (_("Quick Mask"), GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_color_button_add (object, "quick-mask-color",
+ _("Quick Mask color:"),
+ _("Set the default Quick Mask color"),
+ GTK_TABLE (table), 0, NULL,
+ gimp_get_user_context (gimp));
+
+
+ /**********************************/
+ /* Default Image / Default Grid */
+ /**********************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-default-grid",
+ _("Default Image Grid"),
+ _("Default Grid"),
+ GIMP_HELP_PREFS_DEFAULT_GRID,
+ &top_iter,
+ &child_iter);
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ /* Grid */
+ editor = gimp_grid_editor_new (core_config->default_grid,
+ gimp_get_user_context (gimp),
+ gimp_template_get_resolution_x (core_config->default_image),
+ gimp_template_get_resolution_y (core_config->default_image));
+ gtk_box_pack_start (GTK_BOX (vbox), editor, TRUE, TRUE, 0);
+ gtk_widget_show (editor);
+
+
+ /***************/
+ /* Interface */
+ /***************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-interface",
+ _("User Interface"),
+ _("Interface"),
+ GIMP_HELP_PREFS_INTERFACE,
+ NULL,
+ &top_iter);
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ /* Language */
+
+ /* Only add the language entry if the iso-codes package is available. */
+#ifdef HAVE_ISO_CODES
+ vbox2 = prefs_frame_new (_("Language"), GTK_CONTAINER (vbox), FALSE);
+
+ prefs_language_combo_box_add (object, "language", GTK_BOX (vbox2));
+#endif
+
+ /* Style */
+ vbox2 = prefs_frame_new (_("Style"), GTK_CONTAINER (vbox), FALSE);
+
+ button = prefs_check_button_add (object, "compact-sliders",
+ _("Use co_mpact sliders"),
+ GTK_BOX (vbox2));
+
+ /* Previews */
+ vbox2 = prefs_frame_new (_("Previews"), GTK_CONTAINER (vbox), FALSE);
+
+ button = prefs_check_button_add (object, "layer-previews",
+ _("_Enable layer & channel previews"),
+ GTK_BOX (vbox2));
+
+ vbox3 = prefs_frame_new (NULL, GTK_CONTAINER (vbox2), FALSE);
+ g_object_bind_property (button, "active",
+ vbox3, "sensitive",
+ G_BINDING_SYNC_CREATE);
+ button = prefs_check_button_add (object, "group-layer-previews",
+ _("Enable layer _group previews"),
+ GTK_BOX (vbox3));
+
+ table = prefs_table_new (3, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "layer-preview-size", 0, 0,
+ _("_Default layer & channel preview size:"),
+ GTK_TABLE (table), 0, NULL);
+ prefs_enum_combo_box_add (object, "undo-preview-size", 0, 0,
+ _("_Undo preview size:"),
+ GTK_TABLE (table), 1, NULL);
+ prefs_enum_combo_box_add (object, "navigation-preview-size", 0, 0,
+ _("Na_vigation preview size:"),
+ GTK_TABLE (table), 2, NULL);
+
+ /* Keyboard Shortcuts */
+ vbox2 = prefs_frame_new (_("Keyboard Shortcuts"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "can-change-accels",
+ _("_Use dynamic keyboard shortcuts"),
+ GTK_BOX (vbox2));
+
+ button = prefs_button_add (GIMP_ICON_PREFERENCES_SYSTEM,
+ _("Configure _Keyboard Shortcuts..."),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_keyboard_shortcuts_dialog),
+ gimp);
+
+ prefs_check_button_add (object, "save-accels",
+ _("_Save keyboard shortcuts on exit"),
+ GTK_BOX (vbox2));
+
+ button = prefs_button_add (GIMP_ICON_DOCUMENT_SAVE,
+ _("Save Keyboard Shortcuts _Now"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_menus_save_callback),
+ gimp);
+
+ button2 = prefs_button_add (GIMP_ICON_RESET,
+ _("_Reset Keyboard Shortcuts to Default Values"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button2, "clicked",
+ G_CALLBACK (prefs_menus_clear_callback),
+ gimp);
+
+ g_object_set_data (G_OBJECT (button), "clear-button", button2);
+
+ button = prefs_button_add (GIMP_ICON_EDIT_CLEAR,
+ _("Remove _All Keyboard Shortcuts"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_menus_remove_callback),
+ gimp);
+
+
+ /***********************/
+ /* Interface / Theme */
+ /***********************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-theme",
+ _("Theme"),
+ _("Theme"),
+ GIMP_HELP_PREFS_THEME,
+ &top_iter,
+ &child_iter);
+
+ vbox2 = prefs_frame_new (_("Select Theme"), GTK_CONTAINER (vbox), TRUE);
+
+ {
+ GtkWidget *scrolled_win;
+ GtkListStore *list_store;
+ GtkWidget *view;
+ GtkTreeSelection *sel;
+ gchar **themes;
+ gint n_themes;
+ gint i;
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_size_request (scrolled_win, -1, 80);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_SHADOW_IN);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_box_pack_start (GTK_BOX (vbox2), scrolled_win, TRUE, TRUE, 0);
+ gtk_widget_show (scrolled_win);
+
+ list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
+
+ view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
+ gtk_container_add (GTK_CONTAINER (scrolled_win), view);
+ gtk_widget_show (view);
+
+ g_object_unref (list_store);
+
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 0,
+ _("Theme"),
+ gtk_cell_renderer_text_new (),
+ "text", 0,
+ NULL);
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
+ _("Folder"),
+ gtk_cell_renderer_text_new (),
+ "text", 1,
+ NULL);
+
+ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
+
+ themes = themes_list_themes (gimp, &n_themes);
+
+ for (i = 0; i < n_themes; i++)
+ {
+ GtkTreeIter iter;
+ GFile *theme_dir = themes_get_theme_dir (gimp, themes[i]);
+
+ gtk_list_store_append (list_store, &iter);
+ gtk_list_store_set (list_store, &iter,
+ 0, themes[i],
+ 1, gimp_file_get_utf8_name (theme_dir),
+ -1);
+
+ if (GIMP_GUI_CONFIG (object)->theme &&
+ ! strcmp (GIMP_GUI_CONFIG (object)->theme, themes[i]))
+ {
+ GtkTreePath *path;
+
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (list_store), &iter);
+
+ gtk_tree_view_set_cursor (GTK_TREE_VIEW (view), path, NULL, FALSE);
+ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (view), path,
+ NULL, FALSE, 0.0, 0.0);
+
+ gtk_tree_path_free (path);
+ }
+ }
+
+ g_strfreev (themes);
+
+ g_signal_connect (sel, "changed",
+ G_CALLBACK (prefs_theme_select_callback),
+ gimp);
+ }
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ button = prefs_button_add (GIMP_ICON_VIEW_REFRESH,
+ _("Reload C_urrent Theme"),
+ GTK_BOX (hbox));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_theme_reload_callback),
+ gimp);
+
+
+ /****************************/
+ /* Interface / Icon Theme */
+ /****************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-icon-theme",
+ _("Icon Theme"),
+ _("Icon Theme"),
+ GIMP_HELP_PREFS_ICON_THEME,
+ &top_iter,
+ &child_iter);
+
+ vbox2 = prefs_frame_new (_("Select an Icon Theme"), GTK_CONTAINER (vbox), TRUE);
+
+ {
+ GtkWidget *scrolled_win;
+ GtkWidget *icon_size_scale;
+ GtkListStore *list_store;
+ GtkWidget *view;
+ GtkTreeSelection *sel;
+ gchar **icon_themes;
+ gint n_icon_themes;
+ gint i;
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_size_request (scrolled_win, -1, 80);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_SHADOW_IN);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_box_pack_start (GTK_BOX (vbox2), scrolled_win, TRUE, TRUE, 0);
+ gtk_widget_show (scrolled_win);
+
+ list_store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
+
+ view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
+ gtk_container_add (GTK_CONTAINER (scrolled_win), view);
+ gtk_widget_show (view);
+
+ g_object_unref (list_store);
+
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 0,
+ NULL,
+ gtk_cell_renderer_pixbuf_new (),
+ "pixbuf", 0,
+ NULL);
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
+ _("Icon Theme"),
+ gtk_cell_renderer_text_new (),
+ "text", 1,
+ NULL);
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 2,
+ _("Folder"),
+ gtk_cell_renderer_text_new (),
+ "text", 2,
+ NULL);
+
+ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
+
+ icon_themes = icon_themes_list_themes (gimp, &n_icon_themes);
+
+ for (i = 0; i < n_icon_themes; i++)
+ {
+ GtkTreeIter iter;
+ GFile *icon_theme_dir = icon_themes_get_theme_dir (gimp, icon_themes[i]);
+ GFile *icon_theme_search_path = g_file_get_parent (icon_theme_dir);
+ GtkIconTheme *theme;
+ gchar *example;
+ GdkPixbuf *pixbuf;
+
+ theme = gtk_icon_theme_new ();
+ gtk_icon_theme_prepend_search_path (theme, gimp_file_get_utf8_name(icon_theme_search_path));
+ g_object_unref (icon_theme_search_path);
+ gtk_icon_theme_set_custom_theme (theme, icon_themes[i]);
+
+ example = gtk_icon_theme_get_example_icon_name (theme);
+ if (! example)
+ {
+ /* If the icon theme didn't explicitly specify an example
+ * icon, try "gimp-wilber".
+ */
+ example = g_strdup ("gimp-wilber");
+ }
+ pixbuf = gtk_icon_theme_load_icon (theme, example, 16, 0, NULL);
+
+ gtk_list_store_append (list_store, &iter);
+ gtk_list_store_set (list_store, &iter,
+ 0, pixbuf,
+ 1, icon_themes[i],
+ 2, gimp_file_get_utf8_name (icon_theme_dir),
+ -1);
+ g_object_unref (theme);
+ g_object_unref (pixbuf);
+ g_free (example);
+
+ if (GIMP_GUI_CONFIG (object)->icon_theme &&
+ ! strcmp (GIMP_GUI_CONFIG (object)->icon_theme, icon_themes[i]))
+ {
+ GtkTreePath *path;
+
+ path = gtk_tree_model_get_path (GTK_TREE_MODEL (list_store), &iter);
+
+ gtk_tree_view_set_cursor (GTK_TREE_VIEW (view), path, NULL, FALSE);
+ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (view), path,
+ NULL, FALSE, 0.0, 0.0);
+
+ gtk_tree_path_free (path);
+ }
+ }
+
+ g_strfreev (icon_themes);
+
+ g_signal_connect (sel, "changed",
+ G_CALLBACK (prefs_icon_theme_select_callback),
+ gimp);
+
+ icon_size_scale = gimp_icon_size_scale_new (gimp);
+ gtk_box_pack_start (GTK_BOX (vbox), icon_size_scale, FALSE, FALSE, 0);
+ gtk_widget_show (icon_size_scale);
+ }
+
+
+ /*************************/
+ /* Interface / Toolbox */
+ /*************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-toolbox",
+ _("Toolbox"),
+ _("Toolbox"),
+ GIMP_HELP_PREFS_TOOLBOX,
+ &top_iter,
+ &child_iter);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* Appearance */
+ vbox2 = prefs_frame_new (_("Appearance"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add_with_icon (object, "toolbox-wilber",
+ _("Show GIMP _logo (drag-and-drop target)"),
+ GIMP_ICON_WILBER,
+ GTK_BOX (vbox2), size_group);
+ prefs_check_button_add_with_icon (object, "toolbox-color-area",
+ _("Show _foreground & background color"),
+ GIMP_ICON_COLORS_DEFAULT,
+ GTK_BOX (vbox2), size_group);
+ prefs_check_button_add_with_icon (object, "toolbox-foo-area",
+ _("Show active _brush, pattern & gradient"),
+ GIMP_ICON_BRUSH,
+ GTK_BOX (vbox2), size_group);
+ prefs_check_button_add_with_icon (object, "toolbox-image-area",
+ _("Show active _image"),
+ GIMP_ICON_IMAGE,
+ GTK_BOX (vbox2), size_group);
+
+ separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
+ gtk_box_pack_start (GTK_BOX (vbox2), separator, FALSE, FALSE, 0);
+ gtk_widget_show (separator);
+
+ button = prefs_check_button_add_with_icon (object, "toolbox-groups",
+ _("Use tool _groups"),
+ NULL,
+ GTK_BOX (vbox2), size_group);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ label = gtk_label_new (NULL);
+ gtk_misc_set_padding (GTK_MISC (label), 2, 2);
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+ gtk_widget_show (label);
+
+ gtk_size_group_add_widget (size_group, label);
+
+ vbox3 = prefs_frame_new (NULL, GTK_CONTAINER (hbox), TRUE);
+ g_object_bind_property (button, "active",
+ vbox3, "sensitive",
+ G_BINDING_SYNC_CREATE);
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox3));
+
+ prefs_enum_combo_box_add (object, "toolbox-group-menu-mode", 0, 0,
+ _("_Menu mode:"),
+ GTK_TABLE (table), 0,
+ NULL);
+
+ g_clear_object (&size_group);
+
+ /* Tool Editor */
+ vbox2 = prefs_frame_new (_("Tools Configuration"),
+ GTK_CONTAINER (vbox), TRUE);
+ tool_editor = gimp_tool_editor_new (gimp->tool_item_list, gimp->user_context,
+ GIMP_VIEW_SIZE_SMALL, 1);
+
+ gtk_box_pack_start (GTK_BOX (vbox2), tool_editor, TRUE, TRUE, 0);
+ gtk_widget_show (tool_editor);
+
+
+ /*********************************/
+ /* Interface / Dialog Defaults */
+ /*********************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ /* FIXME need an icon */
+ "gimp-prefs-controllers",
+ _("Dialog Defaults"),
+ _("Dialog Defaults"),
+ GIMP_HELP_PREFS_DIALOG_DEFAULTS,
+ &top_iter,
+ &child_iter);
+
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ button = gimp_prefs_box_set_page_resettable (GIMP_PREFS_BOX (prefs_box),
+ vbox,
+ _("Reset Dialog _Defaults"));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_dialog_defaults_reset),
+ config);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* Color profile import dialog */
+ vbox2 = prefs_frame_new (_("Color Profile Import Dialog"), GTK_CONTAINER (vbox),
+ FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ button = prefs_enum_combo_box_add (object, "color-profile-policy", 0, 0,
+ _("Color profile policy:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* All color profile chooser dialogs */
+ vbox2 = prefs_frame_new (_("Color Profile File Dialogs"), GTK_CONTAINER (vbox),
+ FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_file_chooser_button_add (object, "color-profile-path",
+ _("Profile folder:"),
+ _("Select Default Folder for Color Profiles"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Convert to Color Profile Dialog */
+ vbox2 = prefs_frame_new (_("Convert to Color Profile Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "image-convert-profile-intent", 0, 0,
+ _("Rendering intent:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "image-convert-profile-black-point-compensation",
+ _("Black point compensation"),
+ GTK_BOX (vbox2));
+
+ /* Convert Precision Dialog */
+ vbox2 = prefs_frame_new (_("Precision Conversion Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (3, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object,
+ "image-convert-precision-layer-dither-method",
+ 0, 0,
+ _("Dither layers:"),
+ GTK_TABLE (table), 0, size_group);
+ prefs_enum_combo_box_add (object,
+ "image-convert-precision-text-layer-dither-method",
+ 0, 0,
+ _("Dither text layers:"),
+ GTK_TABLE (table), 1, size_group);
+ prefs_enum_combo_box_add (object,
+ "image-convert-precision-channel-dither-method",
+ 0, 0,
+ _("Dither channels/masks:"),
+ GTK_TABLE (table), 2, size_group);
+
+ /* Convert Indexed Dialog */
+ vbox2 = prefs_frame_new (_("Indexed Conversion Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "image-convert-indexed-palette-type", 0, 0,
+ _("Colormap:"),
+ GTK_TABLE (table), 0, size_group);
+ prefs_spin_button_add (object, "image-convert-indexed-max-colors", 1.0, 8.0, 0,
+ _("Maximum number of colors:"),
+ GTK_TABLE (table), 1, size_group);
+
+ prefs_check_button_add (object, "image-convert-indexed-remove-duplicates",
+ _("Remove unused and duplicate colors "
+ "from colormap"),
+ GTK_BOX (vbox2));
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+ prefs_enum_combo_box_add (object, "image-convert-indexed-dither-type", 0, 0,
+ _("Color dithering:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "image-convert-indexed-dither-alpha",
+ _("Enable dithering of transparency"),
+ GTK_BOX (vbox2));
+ prefs_check_button_add (object, "image-convert-indexed-dither-text-layers",
+ _("Enable dithering of text layers"),
+ GTK_BOX (vbox2));
+
+ /* Filter Dialogs */
+ vbox2 = prefs_frame_new (_("Filter Dialogs"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "filter-tool-max-recent", 1.0, 8.0, 0,
+ _("Keep recent settings:"),
+ GTK_TABLE (table), 1, size_group);
+
+ button = prefs_check_button_add (object, "filter-tool-use-last-settings",
+ _("Default to the last used settings"),
+ GTK_BOX (vbox2));
+ button = prefs_check_button_add (object, "filter-tool-show-color-options",
+ _("Show advanced color options"),
+ GTK_BOX (vbox2));
+
+ /* Canvas Size Dialog */
+ vbox2 = prefs_frame_new (_("Canvas Size Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "image-resize-fill-type", 0, 0,
+ _("Fill with:"),
+ GTK_TABLE (table), 0, size_group);
+ prefs_enum_combo_box_add (object, "image-resize-layer-set", 0, 0,
+ _("Resize layers:"),
+ GTK_TABLE (table), 1, size_group);
+
+ prefs_check_button_add (object, "image-resize-resize-text-layers",
+ _("Resize text layers"),
+ GTK_BOX (vbox2));
+
+ /* New Layer Dialog */
+ vbox2 = prefs_frame_new (_("New Layer Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_entry_add (object, "layer-new-name",
+ _("Layer name:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_enum_combo_box_add (object, "layer-new-fill-type", 0, 0,
+ _("Fill type:"),
+ GTK_TABLE (table), 1, size_group);
+
+ /* Layer Boundary Size Dialog */
+ vbox2 = prefs_frame_new (_("Layer Boundary Size Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "layer-resize-fill-type", 0, 0,
+ _("Fill with:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Add Layer Mask Dialog */
+ vbox2 = prefs_frame_new (_("Add Layer Mask Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "layer-add-mask-type", 0, 0,
+ _("Layer mask type:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "layer-add-mask-invert",
+ _("Invert mask"),
+ GTK_BOX (vbox2));
+
+ /* Merge Layers Dialog */
+ vbox2 = prefs_frame_new (_("Merge Layers Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "layer-merge-type",
+ GIMP_EXPAND_AS_NECESSARY,
+ GIMP_CLIP_TO_BOTTOM_LAYER,
+ _("Merged layer size:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "layer-merge-active-group-only",
+ _("Merge within active group only"),
+ GTK_BOX (vbox2));
+ prefs_check_button_add (object, "layer-merge-discard-invisible",
+ _("Discard invisible layers"),
+ GTK_BOX (vbox2));
+
+ /* New Channel Dialog */
+ vbox2 = prefs_frame_new (_("New Channel Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_entry_add (object, "channel-new-name",
+ _("Channel name:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_color_button_add (object, "channel-new-color",
+ _("Color and opacity:"),
+ _("Default New Channel Color and Opacity"),
+ GTK_TABLE (table), 1, size_group,
+ gimp_get_user_context (gimp));
+
+ /* New Path Dialog */
+ vbox2 = prefs_frame_new (_("New Path Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_entry_add (object, "path-new-name",
+ _("Path name:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Export Path Dialog */
+ vbox2 = prefs_frame_new (_("Export Paths Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_file_chooser_button_add (object, "path-export-path",
+ _("Export folder:"),
+ _("Select Default Folder for Exporting Paths"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "path-export-active-only",
+ _("Export the active path only"),
+ GTK_BOX (vbox2));
+
+ /* Import Path Dialog */
+ vbox2 = prefs_frame_new (_("Import Paths Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_file_chooser_button_add (object, "path-import-path",
+ _("Import folder:"),
+ _("Select Default Folder for Importing Paths"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "path-import-merge",
+ _("Merge imported paths"),
+ GTK_BOX (vbox2));
+ prefs_check_button_add (object, "path-import-scale",
+ _("Scale imported paths"),
+ GTK_BOX (vbox2));
+
+ /* Feather Selection Dialog */
+ vbox2 = prefs_frame_new (_("Feather Selection Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "selection-feather-radius", 1.0, 10.0, 2,
+ _("Feather radius:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "selection-feather-edge-lock",
+ _("Selected areas continue outside the image"),
+ GTK_BOX (vbox2));
+
+ /* Grow Selection Dialog */
+ vbox2 = prefs_frame_new (_("Grow Selection Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "selection-grow-radius", 1.0, 10.0, 0,
+ _("Grow radius:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Shrink Selection Dialog */
+ vbox2 = prefs_frame_new (_("Shrink Selection Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "selection-shrink-radius", 1.0, 10.0, 0,
+ _("Shrink radius:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_check_button_add (object, "selection-shrink-edge-lock",
+ _("Selected areas continue outside the image"),
+ GTK_BOX (vbox2));
+
+ /* Border Selection Dialog */
+ vbox2 = prefs_frame_new (_("Border Selection Dialog"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "selection-border-radius", 1.0, 10.0, 0,
+ _("Border radius:"),
+ GTK_TABLE (table), 0, size_group);
+
+ prefs_enum_combo_box_add (object, "selection-border-style", 0, 0,
+ _("Border style:"),
+ GTK_TABLE (table), 1, size_group);
+
+ prefs_check_button_add (object, "selection-border-edge-lock",
+ _("Selected areas continue outside the image"),
+ GTK_BOX (vbox2));
+
+ /* Fill Options Dialog */
+ vbox2 = prefs_frame_new (_("Fill Selection Outline & Fill Path Dialogs"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ table = gimp_fill_editor_new (GIMP_DIALOG_CONFIG (object)->fill_options,
+ FALSE);
+ gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 0);
+ gtk_widget_show (table);
+
+ /* Stroke Options Dialog */
+ vbox2 = prefs_frame_new (_("Stroke Selection & Stroke Path Dialogs"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ /* The stroke line width physical values could be based on either the
+ * x or y resolution, some average, or whatever which makes a bit of
+ * sense. There is no perfect answer. The actual stroke dialog though
+ * uses the y resolution on the opened image. So using the y resolution
+ * of the default image seems like the best compromise in the preferences.
+ */
+ table = gimp_stroke_editor_new (GIMP_DIALOG_CONFIG (object)->stroke_options,
+ gimp_template_get_resolution_y (core_config->default_image),
+ FALSE);
+ gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 0);
+ gtk_widget_show (table);
+
+ g_clear_object (&size_group);
+
+
+ /*****************************/
+ /* Interface / Help System */
+ /*****************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-help-system",
+ _("Help System"),
+ _("Help System"),
+ GIMP_HELP_PREFS_HELP,
+ &top_iter,
+ &child_iter);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* General */
+ vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "show-tooltips",
+ _("Show _tooltips"),
+ GTK_BOX (vbox2));
+ prefs_check_button_add (object, "show-help-button",
+ _("Show help _buttons"),
+ GTK_BOX (vbox2));
+
+ table = prefs_table_new (3, GTK_CONTAINER (vbox2));
+ button = prefs_boolean_combo_box_add (object, "user-manual-online",
+ _("Use the online version"),
+ _("Use a locally installed copy"),
+ _("U_ser manual:"),
+ GTK_TABLE (table), 0, size_group);
+ gimp_help_set_help_data (button, NULL, NULL);
+
+ manuals = gimp_help_get_installed_languages ();
+ entry = NULL;
+ if (manuals != NULL)
+ {
+ gchar *help_locales = NULL;
+
+ entry = gimp_language_combo_box_new (TRUE,
+ _("User interface language"));
+
+ g_object_get (config, "help-locales", &help_locales, NULL);
+ if (help_locales && strlen (help_locales))
+ {
+ gchar *sep;
+
+ sep = strchr (help_locales, ':');
+ if (sep)
+ *sep = '\0';
+ }
+ if (help_locales)
+ {
+ gimp_language_combo_box_set_code (GIMP_LANGUAGE_COMBO_BOX (entry),
+ help_locales);
+ g_free (help_locales);
+ }
+ else
+ {
+ gimp_language_combo_box_set_code (GIMP_LANGUAGE_COMBO_BOX (entry),
+ "");
+ }
+ g_signal_connect (entry, "changed",
+ G_CALLBACK (prefs_help_language_change_callback),
+ gimp);
+ gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 1, 2);
+ gtk_widget_show (entry);
+ }
+
+ if (gimp_help_user_manual_is_installed (gimp))
+ {
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_INFORMATION,
+ _("There's a local installation "
+ "of the user manual."));
+ }
+ else
+ {
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_WARNING,
+ _("The user manual is not installed "
+ "locally."));
+ }
+ if (manuals)
+ {
+ g_object_set_data (G_OBJECT (hbox), "gimp", gimp);
+ g_signal_connect (entry, "changed",
+ G_CALLBACK (prefs_help_language_change_callback2),
+ hbox);
+ g_list_free_full (manuals, g_free);
+ }
+
+ gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 2, 3);
+ gtk_widget_show (hbox);
+
+ /* Help Browser */
+#ifdef HAVE_WEBKIT
+ /* If there is no webkit available, assume we are on a platform
+ * that doesn't use the help browser, so don't bother showing
+ * the combo.
+ */
+ vbox2 = prefs_frame_new (_("Help Browser"), GTK_CONTAINER (vbox), FALSE);
+
+ if (gimp_help_browser_is_installed (gimp))
+ {
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ button = prefs_enum_combo_box_add (object, "help-browser", 0, 0,
+ _("H_elp browser to use:"),
+ GTK_TABLE (table), 0, size_group);
+ }
+ else
+ {
+ hbox = prefs_hint_box_new (GIMP_ICON_DIALOG_WARNING,
+ _("The GIMP help browser doesn't seem to "
+ "be installed. Using the web browser "
+ "instead."));
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ g_object_set (config,
+ "help-browser", GIMP_HELP_BROWSER_WEB_BROWSER,
+ NULL);
+ }
+#else
+ g_object_set (config,
+ "help-browser", GIMP_HELP_BROWSER_WEB_BROWSER,
+ NULL);
+#endif /* HAVE_WEBKIT */
+
+ /* Action Search */
+ vbox2 = prefs_frame_new (_("Action Search"), GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_check_button_add (object, "search-show-unavailable-actions",
+ _("Show _unavailable actions"),
+ GTK_BOX (vbox2));
+ prefs_spin_button_add (object, "action-history-size", 1.0, 10.0, 0,
+ _("_Maximum History Size:"),
+ GTK_TABLE (table), 0, size_group);
+
+ button = prefs_button_add (GIMP_ICON_SHRED,
+ _("C_lear Action History"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_search_clear_callback),
+ gimp);
+
+ g_clear_object (&size_group);
+
+
+ /*************************/
+ /* Interface / Display */
+ /*************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-display",
+ _("Display"),
+ _("Display"),
+ GIMP_HELP_PREFS_DISPLAY,
+ &top_iter,
+ &child_iter);
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* Transparency */
+ vbox2 = prefs_frame_new (_("Transparency"), GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "transparency-type", 0, 0,
+ _("_Check style:"),
+ GTK_TABLE (table), 0, size_group);
+ prefs_enum_combo_box_add (object, "transparency-size", 0, 0,
+ _("Check _size:"),
+ GTK_TABLE (table), 1, size_group);
+
+ vbox2 = prefs_frame_new (_("Monitor Resolution"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ {
+ gchar *pixels_per_unit = g_strconcat (_("Pixels"), "/%s", NULL);
+
+ entry = gimp_prop_coordinates_new (object,
+ "monitor-xresolution",
+ "monitor-yresolution",
+ NULL,
+ pixels_per_unit,
+ GIMP_SIZE_ENTRY_UPDATE_RESOLUTION,
+ 0.0, 0.0,
+ TRUE);
+
+ g_free (pixels_per_unit);
+ }
+
+ gtk_table_set_col_spacings (GTK_TABLE (entry), 2);
+ gtk_table_set_row_spacings (GTK_TABLE (entry), 2);
+
+ gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry),
+ _("Horizontal"), 0, 1, 0.0);
+ gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry),
+ _("Vertical"), 0, 2, 0.0);
+ gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry),
+ _("ppi"), 1, 4, 0.0);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+
+ gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 24);
+ gtk_widget_show (entry);
+ gtk_widget_set_sensitive (entry, ! display_config->monitor_res_from_gdk);
+
+ group = NULL;
+
+ {
+ gdouble xres;
+ gdouble yres;
+ gchar *str;
+
+ gimp_get_monitor_resolution (gdk_screen_get_default (), /* FIXME monitor */
+ 0, /* FIXME monitor */
+ &xres, &yres);
+
+ str = g_strdup_printf (_("_Detect automatically (currently %d × %d ppi)"),
+ ROUND (xres), ROUND (yres));
+
+ button = gtk_radio_button_new_with_mnemonic (group, str);
+
+ g_free (str);
+ }
+
+ group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
+ gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ g_object_set_data (G_OBJECT (button), "monitor_resolution_sizeentry", entry);
+
+ g_signal_connect (button, "toggled",
+ G_CALLBACK (prefs_resolution_source_callback),
+ config);
+
+ button = gtk_radio_button_new_with_mnemonic (group, _("_Enter manually"));
+ group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
+ gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ if (! display_config->monitor_res_from_gdk)
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ calibrate_button = gtk_button_new_with_mnemonic (_("C_alibrate..."));
+ label = gtk_bin_get_child (GTK_BIN (calibrate_button));
+ gtk_misc_set_padding (GTK_MISC (label), 4, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), calibrate_button, FALSE, FALSE, 0);
+ gtk_widget_show (calibrate_button);
+ gtk_widget_set_sensitive (calibrate_button,
+ ! display_config->monitor_res_from_gdk);
+
+ g_object_bind_property (button, "active",
+ entry, "sensitive",
+ G_BINDING_SYNC_CREATE);
+ g_object_bind_property (button, "active",
+ calibrate_button, "sensitive",
+ G_BINDING_SYNC_CREATE);
+
+ g_signal_connect (calibrate_button, "clicked",
+ G_CALLBACK (prefs_resolution_calibrate_callback),
+ entry);
+
+ g_clear_object (&size_group);
+
+
+ /***********************************/
+ /* Interface / Window Management */
+ /***********************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-window-management",
+ _("Window Management"),
+ _("Window Management"),
+ GIMP_HELP_PREFS_WINDOW_MANAGEMENT,
+ &top_iter,
+ &child_iter);
+
+ vbox2 = prefs_frame_new (_("Window Manager Hints"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "dock-window-hint", 0, 0,
+ _("Hint for _docks and toolbox:"),
+ GTK_TABLE (table), 1, NULL);
+
+ vbox2 = prefs_frame_new (_("Focus"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "activate-on-focus",
+ _("Activate the _focused image"),
+ GTK_BOX (vbox2));
+
+ /* Window Positions */
+ vbox2 = prefs_frame_new (_("Window Positions"), GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "save-session-info",
+ _("_Save window positions on exit"),
+ GTK_BOX (vbox2));
+ prefs_check_button_add (object, "restore-monitor",
+ _("Open windows on the same _monitor they were open before"),
+ GTK_BOX (vbox2));
+
+ button = prefs_button_add (GIMP_ICON_DOCUMENT_SAVE,
+ _("Save Window Positions _Now"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_session_save_callback),
+ gimp);
+
+ button2 = prefs_button_add (GIMP_ICON_RESET,
+ _("_Reset Saved Window Positions to "
+ "Default Values"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button2, "clicked",
+ G_CALLBACK (prefs_session_clear_callback),
+ gimp);
+
+ g_object_set_data (G_OBJECT (button), "clear-button", button2);
+
+
+ /*******************/
+ /* Image Windows */
+ /*******************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-image-windows",
+ _("Image Windows"),
+ _("Image Windows"),
+ GIMP_HELP_PREFS_IMAGE_WINDOW,
+ NULL,
+ &top_iter);
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ /* General */
+ vbox2 = prefs_frame_new (_("General"), GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "default-show-all",
+ _("Use \"Show _all\" by default"),
+ GTK_BOX (vbox2));
+
+ prefs_check_button_add (object, "default-dot-for-dot",
+ _("Use \"_Dot for dot\" by default"),
+ GTK_BOX (vbox2));
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "marching-ants-speed", 1.0, 10.0, 0,
+ _("Marching ants s_peed:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Zoom & Resize Behavior */
+ vbox2 = prefs_frame_new (_("Zoom & Resize Behavior"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "resize-windows-on-zoom",
+ _("Resize window on _zoom"),
+ GTK_BOX (vbox2));
+ prefs_check_button_add (object, "resize-windows-on-resize",
+ _("Resize window on image _size change"),
+ GTK_BOX (vbox2));
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_boolean_combo_box_add (object, "initial-zoom-to-fit",
+ _("Show entire image"),
+ "1:1",
+ _("Initial zoom _ratio:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Space Bar */
+ vbox2 = prefs_frame_new (_("Space Bar"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "space-bar-action", 0, 0,
+ _("_While space bar is pressed:"),
+ GTK_TABLE (table), 0, size_group);
+
+ /* Mouse Pointers */
+ vbox2 = prefs_frame_new (_("Mouse Pointers"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ button = prefs_check_button_add (object, "show-brush-outline",
+ _("Show _brush outline"),
+ GTK_BOX (vbox2));
+
+ vbox3 = prefs_frame_new (NULL, GTK_CONTAINER (vbox2), FALSE);
+ g_object_bind_property (button, "active",
+ vbox3, "sensitive",
+ G_BINDING_SYNC_CREATE);
+ prefs_check_button_add (object, "snap-brush-outline",
+ _("S_nap brush outline to stroke"),
+ GTK_BOX (vbox3));
+
+ prefs_check_button_add (object, "show-paint-tool-cursor",
+ _("Show pointer for paint _tools"),
+ GTK_BOX (vbox2));
+
+ table = prefs_table_new (2, GTK_CONTAINER (vbox2));
+
+ prefs_enum_combo_box_add (object, "cursor-mode", 0, 0,
+ _("Pointer _mode:"),
+ GTK_TABLE (table), 0, size_group);
+ prefs_enum_combo_box_add (object, "cursor-handedness", 0, 0,
+ _("Pointer _handedness:"),
+ GTK_TABLE (table), 1, NULL);
+
+ g_clear_object (&size_group);
+
+
+ /********************************/
+ /* Image Windows / Appearance */
+ /********************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-image-windows-appearance",
+ _("Image Window Appearance"),
+ _("Appearance"),
+ GIMP_HELP_PREFS_IMAGE_WINDOW_APPEARANCE,
+ &top_iter,
+ &child_iter);
+
+ gimp_prefs_box_set_page_scrollable (GIMP_PREFS_BOX (prefs_box), vbox, TRUE);
+
+ prefs_display_options_frame_add (gimp,
+ G_OBJECT (display_config->default_view),
+ _("Default Appearance in Normal Mode"),
+ GTK_CONTAINER (vbox));
+
+ prefs_display_options_frame_add (gimp,
+ G_OBJECT (display_config->default_fullscreen_view),
+ _("Default Appearance in Fullscreen Mode"),
+ GTK_CONTAINER (vbox));
+
+
+ /****************************************************/
+ /* Image Windows / Image Title & Statusbar Format */
+ /****************************************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-image-title",
+ _("Image Title & Statusbar Format"),
+ _("Title & Status"),
+ GIMP_HELP_PREFS_IMAGE_WINDOW_TITLE,
+ &top_iter,
+ &child_iter);
+
+ {
+ const gchar *format_strings[] =
+ {
+ NULL,
+ NULL,
+ "%f-%p.%i (%t) %z%%",
+ "%f-%p.%i (%t) %d:%s",
+ "%f-%p.%i (%t) %wx%h",
+ "%f-%p-%i (%t) %wx%h (%xx%y)"
+ };
+
+ const gchar *format_names[] =
+ {
+ N_("Current format"),
+ N_("Default format"),
+ N_("Show zoom percentage"),
+ N_("Show zoom ratio"),
+ N_("Show image size"),
+ N_("Show drawable size")
+ };
+
+ struct
+ {
+ gchar *current_setting;
+ const gchar *default_setting;
+ const gchar *title;
+ const gchar *property_name;
+ }
+ formats[] =
+ {
+ { NULL, GIMP_CONFIG_DEFAULT_IMAGE_TITLE_FORMAT,
+ N_("Image Title Format"), "image-title-format" },
+ { NULL, GIMP_CONFIG_DEFAULT_IMAGE_STATUS_FORMAT,
+ N_("Image Statusbar Format"), "image-status-format" }
+ };
+
+ gint format;
+
+ gimp_assert (G_N_ELEMENTS (format_strings) == G_N_ELEMENTS (format_names));
+
+ formats[0].current_setting = display_config->image_title_format;
+ formats[1].current_setting = display_config->image_status_format;
+
+ for (format = 0; format < G_N_ELEMENTS (formats); format++)
+ {
+ GtkWidget *scrolled_win;
+ GtkListStore *list_store;
+ GtkWidget *view;
+ GtkTreeSelection *sel;
+ gint i;
+
+ format_strings[0] = formats[format].current_setting;
+ format_strings[1] = formats[format].default_setting;
+
+ vbox2 = prefs_frame_new (gettext (formats[format].title),
+ GTK_CONTAINER (vbox), TRUE);
+
+ entry = gimp_prop_entry_new (object, formats[format].property_name, 0);
+ gtk_box_pack_start (GTK_BOX (vbox2), entry, FALSE, FALSE, 0);
+ gtk_widget_show (entry);
+
+ scrolled_win = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_SHADOW_IN);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_box_pack_start (GTK_BOX (vbox2), scrolled_win, TRUE, TRUE, 0);
+ gtk_widget_show (scrolled_win);
+
+ list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
+
+ view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
+ gtk_container_add (GTK_CONTAINER (scrolled_win), view);
+ gtk_widget_show (view);
+
+ g_object_unref (list_store);
+
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 0,
+ NULL,
+ gtk_cell_renderer_text_new (),
+ "text", 0,
+ NULL);
+ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), 1,
+ NULL,
+ gtk_cell_renderer_text_new (),
+ "text", 1,
+ NULL);
+
+ sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
+
+ for (i = 0; i < G_N_ELEMENTS (format_strings); i++)
+ {
+ GtkTreeIter iter;
+
+ gtk_list_store_append (list_store, &iter);
+ gtk_list_store_set (list_store, &iter,
+ 0, gettext (format_names[i]),
+ 1, format_strings[i],
+ -1);
+
+ if (i == 0)
+ gtk_tree_selection_select_iter (sel, &iter);
+ }
+
+ g_signal_connect (sel, "changed",
+ G_CALLBACK (prefs_format_string_select_callback),
+ entry);
+ }
+ }
+
+
+ /******************************/
+ /* Image Windows / Snapping */
+ /******************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-image-windows-snapping",
+ _("Image Window Snapping Behavior"),
+ _("Snapping"),
+ GIMP_HELP_PREFS_IMAGE_WINDOW_SNAPPING,
+ &top_iter,
+ &child_iter);
+
+ prefs_behavior_options_frame_add (gimp,
+ G_OBJECT (display_config->default_view),
+ _("Default Behavior in Normal Mode"),
+ GTK_CONTAINER (vbox));
+ prefs_behavior_options_frame_add (gimp,
+ G_OBJECT (display_config->default_fullscreen_view),
+ _("Default Behavior in Fullscreen Mode"),
+ GTK_CONTAINER (vbox));
+
+ /* Snapping Distance */
+ vbox2 = prefs_frame_new (_("General"),
+ GTK_CONTAINER (vbox), FALSE);
+ table = prefs_table_new (1, GTK_CONTAINER (vbox2));
+
+ prefs_spin_button_add (object, "snap-distance", 1.0, 5.0, 0,
+ _("_Snapping distance:"),
+ GTK_TABLE (table), 0, NULL);
+
+
+ /*******************/
+ /* Input Devices */
+ /*******************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-input-devices",
+ _("Input Devices"),
+ _("Input Devices"),
+ GIMP_HELP_PREFS_INPUT_DEVICES,
+ NULL,
+ &top_iter);
+
+ /* Extended Input Devices */
+ vbox2 = prefs_frame_new (_("Extended Input Devices"),
+ GTK_CONTAINER (vbox), FALSE);
+
+ prefs_check_button_add (object, "devices-share-tool",
+ _("S_hare tool and tool options between input devices"),
+ GTK_BOX (vbox2));
+
+ button = prefs_button_add (GIMP_ICON_PREFERENCES_SYSTEM,
+ _("Configure E_xtended Input Devices..."),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_input_devices_dialog),
+ gimp);
+
+ prefs_check_button_add (object, "save-device-status",
+ _("_Save input device settings on exit"),
+ GTK_BOX (vbox2));
+
+ button = prefs_button_add (GIMP_ICON_DOCUMENT_SAVE,
+ _("Save Input Device Settings _Now"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_devices_save_callback),
+ gimp);
+
+ button2 = prefs_button_add (GIMP_ICON_RESET,
+ _("_Reset Saved Input Device Settings to "
+ "Default Values"),
+ GTK_BOX (vbox2));
+ g_signal_connect (button2, "clicked",
+ G_CALLBACK (prefs_devices_clear_callback),
+ gimp);
+
+ g_object_set_data (G_OBJECT (button), "clear-button", button2);
+
+
+ /****************************/
+ /* Additional Controllers */
+ /****************************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-controllers",
+ _("Additional Input Controllers"),
+ _("Input Controllers"),
+ GIMP_HELP_PREFS_INPUT_CONTROLLERS,
+ &top_iter,
+ &child_iter);
+
+ vbox2 = gimp_controller_list_new (gimp);
+ gtk_box_pack_start (GTK_BOX (vbox), vbox2, TRUE, TRUE, 0);
+ gtk_widget_show (vbox2);
+
+
+ /*************/
+ /* Folders */
+ /*************/
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ "gimp-prefs-folders",
+ _("Folders"),
+ _("Folders"),
+ GIMP_HELP_PREFS_FOLDERS,
+ NULL,
+ &top_iter);
+
+ button = gimp_prefs_box_set_page_resettable (GIMP_PREFS_BOX (prefs_box),
+ vbox,
+ _("Reset _Folders"));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_folders_reset),
+ config);
+
+ {
+ static const struct
+ {
+ const gchar *property_name;
+ const gchar *label;
+ const gchar *dialog_title;
+ }
+ dirs[] =
+ {
+ {
+ "temp-path",
+ N_("_Temporary folder:"),
+ N_("Select Folder for Temporary Files")
+ },
+ {
+ "swap-path",
+ N_("_Swap folder:"),
+ N_("Select Swap Folder")
+ }
+ };
+
+ table = prefs_table_new (G_N_ELEMENTS (dirs) + 1, GTK_CONTAINER (vbox));
+
+ for (i = 0; i < G_N_ELEMENTS (dirs); i++)
+ {
+ prefs_file_chooser_button_add (object, dirs[i].property_name,
+ gettext (dirs[i].label),
+ gettext (dirs[i].dialog_title),
+ GTK_TABLE (table), i, NULL);
+ }
+ }
+
+
+ /*********************/
+ /* Folders / <paths> */
+ /*********************/
+ {
+ static const struct
+ {
+ const gchar *tree_label;
+ const gchar *label;
+ const gchar *icon;
+ const gchar *help_data;
+ const gchar *reset_label;
+ const gchar *fs_label;
+ const gchar *path_property_name;
+ const gchar *writable_property_name;
+ }
+ paths[] =
+ {
+ { N_("Brushes"), N_("Brush Folders"),
+ "folders-brushes",
+ GIMP_HELP_PREFS_FOLDERS_BRUSHES,
+ N_("Reset Brush _Folders"),
+ N_("Select Brush Folders"),
+ "brush-path", "brush-path-writable" },
+ { N_("Dynamics"), N_("Dynamics Folders"),
+ "folders-dynamics",
+ GIMP_HELP_PREFS_FOLDERS_DYNAMICS,
+ N_("Reset Dynamics _Folders"),
+ N_("Select Dynamics Folders"),
+ "dynamics-path", "dynamics-path-writable" },
+ { N_("Patterns"), N_("Pattern Folders"),
+ "folders-patterns",
+ GIMP_HELP_PREFS_FOLDERS_PATTERNS,
+ N_("Reset Pattern _Folders"),
+ N_("Select Pattern Folders"),
+ "pattern-path", "pattern-path-writable" },
+ { N_("Palettes"), N_("Palette Folders"),
+ "folders-palettes",
+ GIMP_HELP_PREFS_FOLDERS_PALETTES,
+ N_("Reset Palette _Folders"),
+ N_("Select Palette Folders"),
+ "palette-path", "palette-path-writable" },
+ { N_("Gradients"), N_("Gradient Folders"),
+ "folders-gradients",
+ GIMP_HELP_PREFS_FOLDERS_GRADIENTS,
+ N_("Reset Gradient _Folders"),
+ N_("Select Gradient Folders"),
+ "gradient-path", "gradient-path-writable" },
+ { N_("Fonts"), N_("Font Folders"),
+ "folders-fonts",
+ GIMP_HELP_PREFS_FOLDERS_FONTS,
+ N_("Reset Font _Folders"),
+ N_("Select Font Folders"),
+ "font-path", NULL },
+ { N_("Tool Presets"), N_("Tool Preset Folders"),
+ "folders-tool-presets",
+ GIMP_HELP_PREFS_FOLDERS_TOOL_PRESETS,
+ N_("Reset Tool Preset _Folders"),
+ N_("Select Tool Preset Folders"),
+ "tool-preset-path", "tool-preset-path-writable" },
+ { N_("MyPaint Brushes"), N_("MyPaint Brush Folders"),
+ "folders-mypaint-brushes",
+ GIMP_HELP_PREFS_FOLDERS_MYPAINT_BRUSHES,
+ N_("Reset MyPaint Brush _Folders"),
+ N_("Select MyPaint Brush Folders"),
+ "mypaint-brush-path", "mypaint-brush-path-writable" },
+ { N_("Plug-ins"), N_("Plug-in Folders"),
+ "folders-plug-ins",
+ GIMP_HELP_PREFS_FOLDERS_PLUG_INS,
+ N_("Reset plug-in _Folders"),
+ N_("Select plug-in Folders"),
+ "plug-in-path", NULL },
+ { N_("Scripts"), N_("Script-Fu Folders"),
+ "folders-scripts",
+ GIMP_HELP_PREFS_FOLDERS_SCRIPTS,
+ N_("Reset Script-Fu _Folders"),
+ N_("Select Script-Fu Folders"),
+ "script-fu-path", NULL },
+ { N_("Modules"), N_("Module Folders"),
+ "folders-modules",
+ GIMP_HELP_PREFS_FOLDERS_MODULES,
+ N_("Reset Module _Folders"),
+ N_("Select Module Folders"),
+ "module-path", NULL },
+ { N_("Interpreters"), N_("Interpreter Folders"),
+ "folders-interp",
+ GIMP_HELP_PREFS_FOLDERS_INTERPRETERS,
+ N_("Reset Interpreter _Folders"),
+ N_("Select Interpreter Folders"),
+ "interpreter-path", NULL },
+ { N_("Environment"), N_("Environment Folders"),
+ "folders-environ",
+ GIMP_HELP_PREFS_FOLDERS_ENVIRONMENT,
+ N_("Reset Environment _Folders"),
+ N_("Select Environment Folders"),
+ "environ-path", NULL },
+ { N_("Themes"), N_("Theme Folders"),
+ "folders-themes",
+ GIMP_HELP_PREFS_FOLDERS_THEMES,
+ N_("Reset Theme _Folders"),
+ N_("Select Theme Folders"),
+ "theme-path", NULL },
+ { N_("Icon Themes"), N_("Icon Theme Folders"),
+ "folders-icon-themes",
+ GIMP_HELP_PREFS_FOLDERS_ICON_THEMES,
+ N_("Reset Icon Theme _Folders"),
+ N_("Select Icon Theme Folders"),
+ "icon-theme-path", NULL }
+ };
+
+ for (i = 0; i < G_N_ELEMENTS (paths); i++)
+ {
+ GtkWidget *editor;
+ gchar *icon_name;
+
+ icon_name = g_strconcat ("gimp-prefs-", paths[i].icon, NULL);
+ vbox = gimp_prefs_box_add_page (GIMP_PREFS_BOX (prefs_box),
+ icon_name,
+ gettext (paths[i].label),
+ gettext (paths[i].tree_label),
+ paths[i].help_data,
+ &top_iter,
+ &child_iter);
+ g_free (icon_name);
+
+ button = gimp_prefs_box_set_page_resettable (GIMP_PREFS_BOX (prefs_box),
+ vbox,
+ gettext (paths[i].reset_label));
+ g_object_set_data (G_OBJECT (button), "path",
+ (gpointer) paths[i].path_property_name);
+ g_object_set_data (G_OBJECT (button), "path-writable",
+ (gpointer) paths[i].writable_property_name);
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (prefs_path_reset),
+ config);
+
+ editor = gimp_prop_path_editor_new (object,
+ paths[i].path_property_name,
+ paths[i].writable_property_name,
+ gettext (paths[i].fs_label));
+ gtk_box_pack_start (GTK_BOX (vbox), editor, TRUE, TRUE, 0);
+ gtk_widget_show (editor);
+ }
+ }
+
+ {
+ GtkWidget *tv;
+ GtkTreeModel *model;
+ GtkTreePath *path;
+
+ tv = gimp_prefs_box_get_tree_view (GIMP_PREFS_BOX (prefs_box));
+ gtk_tree_view_expand_all (GTK_TREE_VIEW (tv));
+
+ /* collapse the Folders subtree */
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tv));
+ path = gtk_tree_model_get_path (model, &top_iter);
+ gtk_tree_view_collapse_row (GTK_TREE_VIEW (tv), path);
+ gtk_tree_path_free (path);
+ }
+
+ return dialog;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 15:29:32 +0000