summaryrefslogtreecommitdiffstats
path: root/app/widgets/gimpwidgets-utils.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/widgets/gimpwidgets-utils.c')
-rw-r--r--app/widgets/gimpwidgets-utils.c1964
1 files changed, 1964 insertions, 0 deletions
diff --git a/app/widgets/gimpwidgets-utils.c b/app/widgets/gimpwidgets-utils.c
new file mode 100644
index 0000000..b6750bf
--- /dev/null
+++ b/app/widgets/gimpwidgets-utils.c
@@ -0,0 +1,1964 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpwidgets-utils.c
+ * Copyright (C) 1999-2003 Michael Natterer <mitch@gimp.org>
+ *
+ * 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>
+
+#ifdef GDK_WINDOWING_WIN32
+#include <gdk/gdkwin32.h>
+#endif
+
+#ifdef GDK_WINDOWING_X11
+#include <gdk/gdkx.h>
+#endif
+
+#ifdef PLATFORM_OSX
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpconfig/gimpconfig.h"
+#include "libgimpmath/gimpmath.h"
+#include "libgimpcolor/gimpcolor.h"
+#include "libgimpwidgets/gimpwidgets.h"
+
+#include "widgets-types.h"
+
+#include "gegl/gimp-babl.h"
+
+#include "gimpaction.h"
+#include "gimpdialogfactory.h"
+#include "gimpdock.h"
+#include "gimpdockcontainer.h"
+#include "gimpdockwindow.h"
+#include "gimperrordialog.h"
+#include "gimpsessioninfo.h"
+#include "gimpwidgets-utils.h"
+
+#include "gimp-intl.h"
+
+
+#define GIMP_TOOL_OPTIONS_GUI_KEY "gimp-tool-options-gui"
+#define GIMP_TOOL_OPTIONS_GUI_FUNC_KEY "gimp-tool-options-gui-func"
+
+
+/**
+ * gimp_menu_position:
+ * @menu: a #GtkMenu widget
+ * @x: pointer to horizontal position
+ * @y: pointer to vertical position
+ *
+ * Positions a #GtkMenu so that it pops up on screen. This function
+ * takes care of the preferred popup direction (taken from the widget
+ * render direction) and it handles multiple monitors representing a
+ * single #GdkScreen (Xinerama).
+ *
+ * You should call this function with @x and @y initialized to the
+ * origin of the menu. This is typically the center of the widget the
+ * menu is popped up from. gimp_menu_position() will then decide if
+ * and how these initial values need to be changed.
+ **/
+void
+gimp_menu_position (GtkMenu *menu,
+ gint *x,
+ gint *y)
+{
+ GtkWidget *widget;
+ GdkScreen *screen;
+ GtkRequisition requisition;
+ GdkRectangle rect;
+ gint monitor;
+
+ g_return_if_fail (GTK_IS_MENU (menu));
+ g_return_if_fail (x != NULL);
+ g_return_if_fail (y != NULL);
+
+ widget = GTK_WIDGET (menu);
+
+ screen = gtk_widget_get_screen (widget);
+
+ monitor = gdk_screen_get_monitor_at_point (screen, *x, *y);
+ gdk_screen_get_monitor_workarea (screen, monitor, &rect);
+
+ gtk_menu_set_screen (menu, screen);
+
+ gtk_widget_size_request (widget, &requisition);
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
+ {
+ *x -= requisition.width;
+ if (*x < rect.x)
+ *x += requisition.width;
+ }
+ else
+ {
+ if (*x + requisition.width > rect.x + rect.width)
+ *x -= requisition.width;
+ }
+
+ if (*x < rect.x)
+ *x = rect.x;
+
+ if (*y + requisition.height > rect.y + rect.height)
+ *y -= requisition.height;
+
+ if (*y < rect.y)
+ *y = rect.y;
+}
+
+/**
+ * gimp_button_menu_position:
+ * @button: a button widget to popup the menu from
+ * @menu: the menu to position
+ * @position: the preferred popup direction for the menu (left or right)
+ * @x: return location for x coordinate
+ * @y: return location for y coordinate
+ *
+ * Utility function to position a menu that pops up from a button.
+ **/
+void
+gimp_button_menu_position (GtkWidget *button,
+ GtkMenu *menu,
+ GtkPositionType position,
+ gint *x,
+ gint *y)
+{
+ GdkScreen *screen;
+ GtkAllocation button_allocation;
+ GtkRequisition menu_requisition;
+ GdkRectangle rect;
+ gint monitor;
+
+ g_return_if_fail (GTK_IS_WIDGET (button));
+ g_return_if_fail (gtk_widget_get_realized (button));
+ g_return_if_fail (GTK_IS_MENU (menu));
+ g_return_if_fail (x != NULL);
+ g_return_if_fail (y != NULL);
+
+ gtk_widget_get_allocation (button, &button_allocation);
+
+ if (gtk_widget_get_direction (button) == GTK_TEXT_DIR_RTL)
+ {
+ switch (position)
+ {
+ case GTK_POS_LEFT: position = GTK_POS_RIGHT; break;
+ case GTK_POS_RIGHT: position = GTK_POS_LEFT; break;
+ default:
+ break;
+ }
+ }
+
+ *x = 0;
+ *y = 0;
+
+ if (! gtk_widget_get_has_window (button))
+ {
+ *x += button_allocation.x;
+ *y += button_allocation.y;
+ }
+
+ gdk_window_get_root_coords (gtk_widget_get_window (button), *x, *y, x, y);
+
+ gtk_widget_size_request (GTK_WIDGET (menu), &menu_requisition);
+
+ screen = gtk_widget_get_screen (button);
+
+ monitor = gdk_screen_get_monitor_at_point (screen, *x, *y);
+ gdk_screen_get_monitor_workarea (screen, monitor, &rect);
+
+ gtk_menu_set_screen (menu, screen);
+
+ switch (position)
+ {
+ case GTK_POS_LEFT:
+ *x -= menu_requisition.width;
+ if (*x < rect.x)
+ *x += menu_requisition.width + button_allocation.width;
+ break;
+
+ case GTK_POS_RIGHT:
+ *x += button_allocation.width;
+ if (*x + menu_requisition.width > rect.x + rect.width)
+ *x -= button_allocation.width + menu_requisition.width;
+ break;
+
+ default:
+ g_warning ("%s: unhandled position (%d)", G_STRFUNC, position);
+ break;
+ }
+
+ if (*y + menu_requisition.height > rect.y + rect.height)
+ *y -= menu_requisition.height - button_allocation.height;
+
+ if (*y < rect.y)
+ *y = rect.y;
+}
+
+void
+gimp_table_attach_icon (GtkTable *table,
+ gint row,
+ const gchar *icon_name,
+ GtkWidget *widget,
+ gint colspan,
+ gboolean left_align)
+{
+ GtkWidget *image;
+
+ g_return_if_fail (GTK_IS_TABLE (table));
+ g_return_if_fail (icon_name != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_BUTTON);
+ gtk_misc_set_alignment (GTK_MISC (image), 1.0, 0.5);
+ gtk_table_attach (table, image, 0, 1, row, row + 1,
+ GTK_FILL, GTK_FILL, 0, 0);
+ gtk_widget_show (image);
+
+ if (left_align)
+ {
+ GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+
+ gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
+ gtk_widget_show (widget);
+
+ widget = hbox;
+ }
+
+ gtk_table_attach (table, widget, 1, 1 + colspan, row, row + 1,
+ GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+ gtk_widget_show (widget);
+}
+
+void
+gimp_enum_radio_box_add (GtkBox *box,
+ GtkWidget *widget,
+ gint enum_value,
+ gboolean below)
+{
+ GList *children;
+ GList *list;
+ gint pos;
+
+ g_return_if_fail (GTK_IS_BOX (box));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ children = gtk_container_get_children (GTK_CONTAINER (box));
+
+ for (list = children, pos = 1;
+ list;
+ list = g_list_next (list), pos++)
+ {
+ if (GTK_IS_RADIO_BUTTON (list->data) &&
+ GPOINTER_TO_INT (g_object_get_data (list->data, "gimp-item-data")) ==
+ enum_value)
+ {
+ GtkWidget *radio = list->data;
+ GtkWidget *hbox;
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0);
+ gtk_box_reorder_child (GTK_BOX (box), hbox, pos);
+
+ if (below)
+ {
+ GtkWidget *spacer;
+ gint indicator_size;
+ gint indicator_spacing;
+ gint focus_width;
+ gint focus_padding;
+ gint border_width;
+
+ gtk_widget_style_get (radio,
+ "indicator-size", &indicator_size,
+ "indicator-spacing", &indicator_spacing,
+ "focus-line-width", &focus_width,
+ "focus-padding", &focus_padding,
+ NULL);
+
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (radio));
+
+ spacer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ gtk_widget_set_size_request (spacer,
+ indicator_size +
+ 3 * indicator_spacing +
+ focus_width +
+ focus_padding +
+ border_width,
+ -1);
+ gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0);
+ gtk_widget_show (spacer);
+ }
+ else
+ {
+ GtkSizeGroup *size_group;
+
+ size_group = g_object_get_data (G_OBJECT (box), "size-group");
+
+ if (! size_group)
+ {
+ size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+ g_object_set_data (G_OBJECT (box), "size-group", size_group);
+
+ gtk_size_group_add_widget (size_group, radio);
+ g_object_unref (size_group);
+ }
+ else
+ {
+ gtk_size_group_add_widget (size_group, radio);
+ }
+
+ gtk_box_set_spacing (GTK_BOX (hbox), 4);
+
+ g_object_ref (radio);
+ gtk_container_remove (GTK_CONTAINER (box), radio);
+ gtk_box_pack_start (GTK_BOX (hbox), radio, FALSE, FALSE, 0);
+ g_object_unref (radio);
+ }
+
+ gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
+ gtk_widget_show (widget);
+
+ g_object_bind_property (radio, "active",
+ widget, "sensitive",
+ G_BINDING_SYNC_CREATE);
+
+ gtk_widget_show (hbox);
+
+ break;
+ }
+ }
+
+ g_list_free (children);
+}
+
+void
+gimp_enum_radio_frame_add (GtkFrame *frame,
+ GtkWidget *widget,
+ gint enum_value,
+ gboolean below)
+{
+ GtkWidget *box;
+
+ g_return_if_fail (GTK_IS_FRAME (frame));
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ box = gtk_bin_get_child (GTK_BIN (frame));
+
+ g_return_if_fail (GTK_IS_BOX (box));
+
+ gimp_enum_radio_box_add (GTK_BOX (box), widget, enum_value, below);
+}
+
+/**
+ * gimp_widget_load_icon:
+ * @widget: parent widget (to determine icon theme and
+ * style)
+ * @icon_name: icon name
+ * @size: requested pixel size
+ *
+ * Loads an icon into a pixbuf with size as close as possible to @size.
+ * If icon does not exist or fail to load, the function will fallback to
+ * "gimp-wilber-eek" instead to prevent NULL pixbuf. As a last resort,
+ * if even the fallback failed to load, a magenta @size square will be
+ * returned, so this function is guaranteed to always return a
+ * #GdkPixbuf.
+ *
+ * Return value: a newly allocated #GdkPixbuf containing @icon_name at
+ * size @size or a fallback icon/size.
+ **/
+GdkPixbuf *
+gimp_widget_load_icon (GtkWidget *widget,
+ const gchar *icon_name,
+ gint size)
+{
+ GdkPixbuf *pixbuf;
+ GtkIconTheme *icon_theme;
+ gint *icon_sizes;
+ gint closest_size = -1;
+ gint min_diff = G_MAXINT;
+ gint i;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+ g_return_val_if_fail (icon_name != NULL, NULL);
+
+ icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (widget));
+
+ if (! gtk_icon_theme_has_icon (icon_theme, icon_name))
+ {
+ g_printerr ("WARNING: icon theme has no icon '%s'.\n",
+ icon_name);
+
+ return gtk_icon_theme_load_icon (icon_theme, GIMP_ICON_WILBER_EEK,
+ size, 0, NULL);
+ }
+
+ icon_sizes = gtk_icon_theme_get_icon_sizes (icon_theme, icon_name);
+
+ for (i = 0; icon_sizes[i]; i++)
+ {
+ if (icon_sizes[i] > 0 &&
+ icon_sizes[i] <= size)
+ {
+ if (size - icon_sizes[i] < min_diff)
+ {
+ min_diff = size - icon_sizes[i];
+ closest_size = icon_sizes[i];
+ }
+ }
+ }
+
+ g_free (icon_sizes);
+
+ if (closest_size != -1)
+ size = closest_size;
+
+ pixbuf = gtk_icon_theme_load_icon (icon_theme, icon_name, size,
+ GTK_ICON_LOOKUP_USE_BUILTIN, NULL);
+
+ if (! pixbuf)
+ {
+ /* The icon was seemingly present in the current icon theme, yet
+ * it failed to load. Maybe the file is broken?
+ * As last resort, try to load "gimp-wilber-eek" as fallback.
+ * Note that we are not making more checks, so if the fallback
+ * icon fails to load as well, the function may still return NULL.
+ */
+ g_printerr ("WARNING: icon '%s' failed to load. Check the files "
+ "in your icon theme.\n", icon_name);
+
+ pixbuf = gtk_icon_theme_load_icon (icon_theme,
+ GIMP_ICON_WILBER_EEK,
+ size, 0, NULL);
+ if (! pixbuf)
+ {
+ /* As last resort, just draw an ugly magenta square. */
+ guchar *data;
+ gint rowstride = 3 * size;
+ gint i, j;
+
+ g_printerr ("WARNING: icon '%s' failed to load. Check the files "
+ "in your icon theme.\n", GIMP_ICON_WILBER_EEK);
+
+ data = g_new (guchar, rowstride * size);
+ for (i = 0; i < size; i++)
+ {
+ for (j = 0; j < size; j++)
+ {
+ data[i * rowstride + j * 3] = 255;
+ data[i * rowstride + j * 3 + 1] = 0;
+ data[i * rowstride + j * 3 + 2] = 255;
+ }
+ }
+ pixbuf = gdk_pixbuf_new_from_data (data, GDK_COLORSPACE_RGB, FALSE,
+ 8, size, size, rowstride,
+ (GdkPixbufDestroyNotify) g_free,
+ NULL);
+ }
+ }
+
+ return pixbuf;
+}
+
+GtkIconSize
+gimp_get_icon_size (GtkWidget *widget,
+ const gchar *icon_name,
+ GtkIconSize max_size,
+ gint width,
+ gint height)
+{
+ GtkIconSet *icon_set;
+ GtkIconSize *sizes;
+ gint n_sizes;
+ gint i;
+ gint width_diff = 1024;
+ gint height_diff = 1024;
+ gint max_width;
+ gint max_height;
+ GtkIconSize icon_size = GTK_ICON_SIZE_MENU;
+ GtkSettings *settings;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), icon_size);
+ g_return_val_if_fail (icon_name != NULL, icon_size);
+ g_return_val_if_fail (width > 0, icon_size);
+ g_return_val_if_fail (height > 0, icon_size);
+
+ icon_set = gtk_style_lookup_icon_set (gtk_widget_get_style (widget),
+ icon_name);
+
+ if (! icon_set)
+ return GTK_ICON_SIZE_INVALID;
+
+ settings = gtk_widget_get_settings (widget);
+
+ if (! gtk_icon_size_lookup_for_settings (settings, max_size,
+ &max_width, &max_height))
+ {
+ max_width = 1024;
+ max_height = 1024;
+ }
+
+ gtk_icon_set_get_sizes (icon_set, &sizes, &n_sizes);
+
+ for (i = 0; i < n_sizes; i++)
+ {
+ gint icon_width;
+ gint icon_height;
+
+ if (gtk_icon_size_lookup_for_settings (settings, sizes[i],
+ &icon_width, &icon_height))
+ {
+ if (icon_width <= width &&
+ icon_height <= height &&
+ icon_width <= max_width &&
+ icon_height <= max_height &&
+ ((width - icon_width) < width_diff ||
+ (height - icon_height) < height_diff))
+ {
+ width_diff = width - icon_width;
+ height_diff = height - icon_height;
+
+ icon_size = sizes[i];
+ }
+ }
+ }
+
+ g_free (sizes);
+
+ return icon_size;
+}
+
+GimpTabStyle
+gimp_preview_tab_style_to_icon (GimpTabStyle tab_style)
+{
+ switch (tab_style)
+ {
+ case GIMP_TAB_STYLE_PREVIEW:
+ tab_style = GIMP_TAB_STYLE_ICON;
+ break;
+
+ case GIMP_TAB_STYLE_PREVIEW_NAME:
+ tab_style = GIMP_TAB_STYLE_ICON_NAME;
+ break;
+
+ case GIMP_TAB_STYLE_PREVIEW_BLURB:
+ tab_style = GIMP_TAB_STYLE_ICON_BLURB;
+ break;
+
+ default:
+ break;
+ }
+
+ return tab_style;
+}
+
+const gchar *
+gimp_get_mod_string (GdkModifierType modifiers)
+{
+ static GHashTable *mod_labels;
+ gchar *label;
+
+ if (! modifiers)
+ return NULL;
+
+ if (G_UNLIKELY (! mod_labels))
+ mod_labels = g_hash_table_new (g_int_hash, g_int_equal);
+
+ modifiers = gimp_replace_virtual_modifiers (modifiers);
+
+ label = g_hash_table_lookup (mod_labels, &modifiers);
+
+ if (! label)
+ {
+ GtkAccelLabelClass *accel_label_class;
+
+ label = gtk_accelerator_get_label (0, modifiers);
+
+ accel_label_class = g_type_class_ref (GTK_TYPE_ACCEL_LABEL);
+
+ if (accel_label_class->mod_separator &&
+ *accel_label_class->mod_separator)
+ {
+ gchar *sep = g_strrstr (label, accel_label_class->mod_separator);
+
+ if (sep - label ==
+ strlen (label) - strlen (accel_label_class->mod_separator))
+ *sep = '\0';
+ }
+
+ g_type_class_unref (accel_label_class);
+
+ g_hash_table_insert (mod_labels,
+ g_memdup (&modifiers, sizeof (GdkModifierType)),
+ label);
+ }
+
+ return label;
+}
+
+#define BUF_SIZE 100
+/**
+ * gimp_suggest_modifiers:
+ * @message: initial text for the message
+ * @modifiers: bit mask of modifiers that should be suggested
+ * @extend_selection_format: optional format string for the
+ * "Extend selection" modifier
+ * @toggle_behavior_format: optional format string for the
+ * "Toggle behavior" modifier
+ * @alt_format: optional format string for the Alt modifier
+ *
+ * Utility function to build a message suggesting to use some
+ * modifiers for performing different actions (only Shift, Ctrl and
+ * Alt are currently supported). If some of these modifiers are
+ * already active, they will not be suggested. The optional format
+ * strings #extend_selection_format, #toggle_behavior_format and
+ * #alt_format may be used to describe what the modifier will do.
+ * They must contain a single '%%s' which will be replaced by the name
+ * of the modifier. They can also be %NULL if the modifier name
+ * should be left alone.
+ *
+ * Return value: a newly allocated string containing the message.
+ **/
+gchar *
+gimp_suggest_modifiers (const gchar *message,
+ GdkModifierType modifiers,
+ const gchar *extend_selection_format,
+ const gchar *toggle_behavior_format,
+ const gchar *alt_format)
+{
+ GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
+ GdkModifierType toggle_mask = gimp_get_toggle_behavior_mask ();
+ gchar msg_buf[3][BUF_SIZE];
+ gint num_msgs = 0;
+ gboolean try = FALSE;
+
+ if (modifiers & extend_mask)
+ {
+ if (extend_selection_format && *extend_selection_format)
+ {
+ g_snprintf (msg_buf[num_msgs], BUF_SIZE, extend_selection_format,
+ gimp_get_mod_string (extend_mask));
+ }
+ else
+ {
+ g_strlcpy (msg_buf[num_msgs],
+ gimp_get_mod_string (extend_mask), BUF_SIZE);
+ try = TRUE;
+ }
+
+ num_msgs++;
+ }
+
+ if (modifiers & toggle_mask)
+ {
+ if (toggle_behavior_format && *toggle_behavior_format)
+ {
+ g_snprintf (msg_buf[num_msgs], BUF_SIZE, toggle_behavior_format,
+ gimp_get_mod_string (toggle_mask));
+ }
+ else
+ {
+ g_strlcpy (msg_buf[num_msgs],
+ gimp_get_mod_string (toggle_mask), BUF_SIZE);
+ try = TRUE;
+ }
+
+ num_msgs++;
+ }
+
+ if (modifiers & GDK_MOD1_MASK)
+ {
+ if (alt_format && *alt_format)
+ {
+ g_snprintf (msg_buf[num_msgs], BUF_SIZE, alt_format,
+ gimp_get_mod_string (GDK_MOD1_MASK));
+ }
+ else
+ {
+ g_strlcpy (msg_buf[num_msgs],
+ gimp_get_mod_string (GDK_MOD1_MASK), BUF_SIZE);
+ try = TRUE;
+ }
+
+ num_msgs++;
+ }
+
+ /* This convoluted way to build the message using multiple format strings
+ * tries to make the messages easier to translate to other languages.
+ */
+
+ switch (num_msgs)
+ {
+ case 1:
+ return g_strdup_printf (try ? _("%s (try %s)") : _("%s (%s)"),
+ message, msg_buf[0]);
+
+ case 2:
+ return g_strdup_printf (_("%s (try %s, %s)"),
+ message, msg_buf[0], msg_buf[1]);
+
+ case 3:
+ return g_strdup_printf (_("%s (try %s, %s, %s)"),
+ message, msg_buf[0], msg_buf[1], msg_buf[2]);
+ }
+
+ return g_strdup (message);
+}
+#undef BUF_SIZE
+
+GimpChannelOps
+gimp_modifiers_to_channel_op (GdkModifierType modifiers)
+{
+ GdkModifierType extend_mask = gimp_get_extend_selection_mask ();
+ GdkModifierType modify_mask = gimp_get_modify_selection_mask ();
+
+ if (modifiers & extend_mask)
+ {
+ if (modifiers & modify_mask)
+ {
+ return GIMP_CHANNEL_OP_INTERSECT;
+ }
+ else
+ {
+ return GIMP_CHANNEL_OP_ADD;
+ }
+ }
+ else if (modifiers & modify_mask)
+ {
+ return GIMP_CHANNEL_OP_SUBTRACT;
+ }
+
+ return GIMP_CHANNEL_OP_REPLACE;
+}
+
+GdkModifierType
+gimp_replace_virtual_modifiers (GdkModifierType modifiers)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+ GdkModifierType result = 0;
+ gint i;
+
+ for (i = 0; i < 8; i++)
+ {
+ GdkModifierType real = 1 << i;
+
+ if (modifiers & real)
+ {
+ GdkModifierType virtual = real;
+
+ gdk_keymap_add_virtual_modifiers (gdk_keymap_get_for_display (display),
+ &virtual);
+
+ if (virtual == real)
+ result |= virtual;
+ else
+ result |= virtual & ~real;
+ }
+ }
+
+ return result;
+}
+
+GdkModifierType
+gimp_get_primary_accelerator_mask (void)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+
+ return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR);
+}
+
+GdkModifierType
+gimp_get_extend_selection_mask (void)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+
+ return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_EXTEND_SELECTION);
+}
+
+GdkModifierType
+gimp_get_modify_selection_mask (void)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+
+ return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+}
+
+GdkModifierType
+gimp_get_toggle_behavior_mask (void)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+
+ /* use the modify selection modifier */
+ return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+}
+
+GdkModifierType
+gimp_get_constrain_behavior_mask (void)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+
+ /* use the modify selection modifier */
+ return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_MODIFY_SELECTION);
+}
+
+GdkModifierType
+gimp_get_all_modifiers_mask (void)
+{
+ GdkDisplay *display = gdk_display_get_default ();
+
+ return (GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_MOD1_MASK |
+ gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR) |
+ gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_EXTEND_SELECTION) |
+ gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
+ GDK_MODIFIER_INTENT_MODIFY_SELECTION));
+}
+
+/**
+ * gimp_get_monitor_resolution:
+ * @screen: a #GdkScreen
+ * @monitor: a monitor number
+ * @xres: returns the horizontal monitor resolution (in dpi)
+ * @yres: returns the vertical monitor resolution (in dpi)
+ *
+ * Retrieves the monitor's resolution from GDK.
+ **/
+void
+gimp_get_monitor_resolution (GdkScreen *screen,
+ gint monitor,
+ gdouble *xres,
+ gdouble *yres)
+{
+ GdkRectangle size_pixels;
+ gint width_mm, height_mm;
+ gdouble x = 0.0;
+ gdouble y = 0.0;
+#ifdef PLATFORM_OSX
+ CGSize size;
+#endif
+
+ g_return_if_fail (GDK_IS_SCREEN (screen));
+ g_return_if_fail (xres != NULL);
+ g_return_if_fail (yres != NULL);
+
+#ifndef PLATFORM_OSX
+ gdk_screen_get_monitor_geometry (screen, monitor, &size_pixels);
+
+ width_mm = gdk_screen_get_monitor_width_mm (screen, monitor);
+ height_mm = gdk_screen_get_monitor_height_mm (screen, monitor);
+#else
+ width_mm = 0;
+ height_mm = 0;
+ size = CGDisplayScreenSize (kCGDirectMainDisplay);
+ if (!CGSizeEqualToSize (size, CGSizeZero))
+ {
+ width_mm = size.width;
+ height_mm = size.height;
+ }
+ size_pixels.width = CGDisplayPixelsWide (kCGDirectMainDisplay);
+ size_pixels.height = CGDisplayPixelsHigh (kCGDirectMainDisplay);
+#endif
+ /*
+ * From xdpyinfo.c:
+ *
+ * there are 2.54 centimeters to an inch; so there are 25.4 millimeters.
+ *
+ * dpi = N pixels / (M millimeters / (25.4 millimeters / 1 inch))
+ * = N pixels / (M inch / 25.4)
+ * = N * 25.4 pixels / M inch
+ */
+
+ if (width_mm > 0 && height_mm > 0)
+ {
+ x = (size_pixels.width * 25.4) / (gdouble) width_mm;
+ y = (size_pixels.height * 25.4) / (gdouble) height_mm;
+ }
+
+ if (x < GIMP_MIN_RESOLUTION || x > GIMP_MAX_RESOLUTION ||
+ y < GIMP_MIN_RESOLUTION || y > GIMP_MAX_RESOLUTION)
+ {
+ g_printerr ("gimp_get_monitor_resolution(): GDK returned bogus "
+ "values for the monitor resolution, using 96 dpi instead.\n");
+
+ x = 96.0;
+ y = 96.0;
+ }
+
+ /* round the value to full integers to give more pleasant results */
+ *xres = ROUND (x);
+ *yres = ROUND (y);
+}
+
+
+/**
+ * gimp_rgb_get_gdk_color:
+ * @rgb: the source color as #GimpRGB
+ * @gdk_color: pointer to a #GdkColor
+ *
+ * Initializes @gdk_color from a #GimpRGB. This function does not
+ * allocate the color for you. Depending on how you want to use it,
+ * you may have to call gdk_colormap_alloc_color().
+ **/
+void
+gimp_rgb_get_gdk_color (const GimpRGB *rgb,
+ GdkColor *gdk_color)
+{
+ guchar r, g, b;
+
+ g_return_if_fail (rgb != NULL);
+ g_return_if_fail (gdk_color != NULL);
+
+ gimp_rgb_get_uchar (rgb, &r, &g, &b);
+
+ gdk_color->red = (r << 8) | r;
+ gdk_color->green = (g << 8) | g;
+ gdk_color->blue = (b << 8) | b;
+}
+
+/**
+ * gimp_rgb_set_gdk_color:
+ * @rgb: a #GimpRGB that is to be set
+ * @gdk_color: pointer to the source #GdkColor
+ *
+ * Initializes @rgb from a #GdkColor. This function does not touch
+ * the alpha value of @rgb.
+ **/
+void
+gimp_rgb_set_gdk_color (GimpRGB *rgb,
+ const GdkColor *gdk_color)
+{
+ guchar r, g, b;
+
+ g_return_if_fail (rgb != NULL);
+ g_return_if_fail (gdk_color != NULL);
+
+ r = gdk_color->red >> 8;
+ g = gdk_color->green >> 8;
+ b = gdk_color->blue >> 8;
+
+ gimp_rgb_set_uchar (rgb, r, g, b);
+}
+
+void
+gimp_window_set_hint (GtkWindow *window,
+ GimpWindowHint hint)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ switch (hint)
+ {
+ case GIMP_WINDOW_HINT_NORMAL:
+ gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_NORMAL);
+ break;
+
+ case GIMP_WINDOW_HINT_UTILITY:
+ gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_UTILITY);
+ break;
+
+ case GIMP_WINDOW_HINT_KEEP_ABOVE:
+ gtk_window_set_keep_above (window, TRUE);
+ break;
+ }
+}
+
+/**
+ * gimp_window_get_native_id:
+ * @window: a #GtkWindow
+ *
+ * This function is used to pass a window handle to plug-ins so that
+ * they can set their dialog windows transient to the parent window.
+ *
+ * Return value: a native window ID of the window's #GdkWindow or 0
+ * if the window isn't realized yet
+ */
+guint32
+gimp_window_get_native_id (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
+
+#ifdef GDK_NATIVE_WINDOW_POINTER
+#ifdef __GNUC__
+#warning gimp_window_get_native() unimplementable for the target windowing system
+#endif
+ return 0;
+#endif
+
+#ifdef GDK_WINDOWING_WIN32
+ if (window && gtk_widget_get_realized (GTK_WIDGET (window)))
+ return GDK_WINDOW_HWND (gtk_widget_get_window (GTK_WIDGET (window)));
+#endif
+
+#ifdef GDK_WINDOWING_X11
+ if (window && gtk_widget_get_realized (GTK_WIDGET (window)))
+ return GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (window)));
+#endif
+
+ return 0;
+}
+
+static void
+gimp_window_transient_realized (GtkWidget *window,
+ GdkWindow *parent)
+{
+ if (gtk_widget_get_realized (window))
+ gdk_window_set_transient_for (gtk_widget_get_window (window), parent);
+}
+
+/* similar to what we have in libgimp/gimpui.c */
+static GdkWindow *
+gimp_get_foreign_window (guint32 window)
+{
+#ifdef GDK_WINDOWING_X11
+ return gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
+ window);
+#endif
+
+#ifdef GDK_WINDOWING_WIN32
+ return gdk_win32_window_foreign_new_for_display (gdk_display_get_default (),
+ window);
+#endif
+
+ return NULL;
+}
+
+void
+gimp_window_set_transient_for (GtkWindow *window,
+ guint32 parent_ID)
+{
+ /* Cross-process transient-for is broken in gdk/win32 <= 2.10.6. It
+ * causes hangs, at least when used as by the gimp and script-fu
+ * processes. In some newer GTK+ version it will be fixed to be a
+ * no-op. If it eventually is fixed to actually work, change this to
+ * a run-time check of GTK+ version. Remember to change also the
+ * function with the same name in libgimp/gimpui.c
+ */
+#ifndef GDK_WINDOWING_WIN32
+ GdkWindow *parent;
+
+ parent = gimp_get_foreign_window (parent_ID);
+ if (! parent)
+ return;
+
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
+ gdk_window_set_transient_for (gtk_widget_get_window (GTK_WIDGET (window)),
+ parent);
+
+ g_signal_connect_object (window, "realize",
+ G_CALLBACK (gimp_window_transient_realized),
+ parent, 0);
+
+ g_object_unref (parent);
+#endif
+}
+
+static gboolean
+gimp_widget_accel_find_func (GtkAccelKey *key,
+ GClosure *closure,
+ gpointer data)
+{
+ return (GClosure *) data == closure;
+}
+
+static void
+gimp_widget_accel_changed (GtkAccelGroup *accel_group,
+ guint unused1,
+ GdkModifierType unused2,
+ GClosure *accel_closure,
+ GtkWidget *widget)
+{
+ GClosure *widget_closure;
+
+ widget_closure = g_object_get_data (G_OBJECT (widget), "gimp-accel-closure");
+
+ if (accel_closure == widget_closure)
+ {
+ GimpAction *action;
+ GtkAccelKey *accel_key;
+ const gchar *tooltip;
+ const gchar *help_id;
+
+ action = g_object_get_data (G_OBJECT (widget), "gimp-accel-action");
+
+ tooltip = gimp_action_get_tooltip (action);
+ help_id = gimp_action_get_help_id (action);
+
+ accel_key = gtk_accel_group_find (accel_group,
+ gimp_widget_accel_find_func,
+ accel_closure);
+
+ if (accel_key &&
+ accel_key->accel_key &&
+ (accel_key->accel_flags & GTK_ACCEL_VISIBLE))
+ {
+ gchar *escaped = g_markup_escape_text (tooltip, -1);
+ gchar *accel = gtk_accelerator_get_label (accel_key->accel_key,
+ accel_key->accel_mods);
+ gchar *tmp = g_strdup_printf ("%s <b>%s</b>", escaped, accel);
+
+ g_free (accel);
+ g_free (escaped);
+
+ gimp_help_set_help_data_with_markup (widget, tmp, help_id);
+ g_free (tmp);
+ }
+ else
+ {
+ gimp_help_set_help_data (widget, tooltip, help_id);
+ }
+ }
+}
+
+static void gimp_accel_help_widget_weak_notify (gpointer accel_group,
+ GObject *where_widget_was);
+
+static void
+gimp_accel_help_accel_group_weak_notify (gpointer widget,
+ GObject *where_accel_group_was)
+{
+ g_object_weak_unref (widget,
+ gimp_accel_help_widget_weak_notify,
+ where_accel_group_was);
+
+ g_object_set_data (widget, "gimp-accel-group", NULL);
+}
+
+static void
+gimp_accel_help_widget_weak_notify (gpointer accel_group,
+ GObject *where_widget_was)
+{
+ g_object_weak_unref (accel_group,
+ gimp_accel_help_accel_group_weak_notify,
+ where_widget_was);
+}
+
+void
+gimp_widget_set_accel_help (GtkWidget *widget,
+ GimpAction *action)
+{
+ GtkAccelGroup *accel_group;
+ GClosure *accel_closure;
+
+ accel_group = g_object_get_data (G_OBJECT (widget), "gimp-accel-group");
+
+ if (accel_group)
+ {
+ g_signal_handlers_disconnect_by_func (accel_group,
+ gimp_widget_accel_changed,
+ widget);
+ g_object_weak_unref (G_OBJECT (accel_group),
+ gimp_accel_help_accel_group_weak_notify,
+ widget);
+ g_object_weak_unref (G_OBJECT (widget),
+ gimp_accel_help_widget_weak_notify,
+ accel_group);
+ g_object_set_data (G_OBJECT (widget), "gimp-accel-group", NULL);
+ }
+
+ accel_closure = gimp_action_get_accel_closure (action);
+
+ if (accel_closure)
+ {
+ accel_group = gtk_accel_group_from_accel_closure (accel_closure);
+
+ g_object_set_data (G_OBJECT (widget), "gimp-accel-group",
+ accel_group);
+ g_object_weak_ref (G_OBJECT (accel_group),
+ gimp_accel_help_accel_group_weak_notify,
+ widget);
+ g_object_weak_ref (G_OBJECT (widget),
+ gimp_accel_help_widget_weak_notify,
+ accel_group);
+
+ g_object_set_data (G_OBJECT (widget), "gimp-accel-closure",
+ accel_closure);
+ g_object_set_data (G_OBJECT (widget), "gimp-accel-action",
+ action);
+
+ g_signal_connect_object (accel_group, "accel-changed",
+ G_CALLBACK (gimp_widget_accel_changed),
+ widget, 0);
+
+ gimp_widget_accel_changed (accel_group,
+ 0, 0,
+ accel_closure,
+ widget);
+ }
+ else
+ {
+ gimp_help_set_help_data (widget,
+ gimp_action_get_tooltip (action),
+ gimp_action_get_help_id (action));
+
+ }
+}
+
+const gchar *
+gimp_get_message_icon_name (GimpMessageSeverity severity)
+{
+ switch (severity)
+ {
+ case GIMP_MESSAGE_INFO:
+ return GIMP_ICON_DIALOG_INFORMATION;
+
+ case GIMP_MESSAGE_WARNING:
+ return GIMP_ICON_DIALOG_WARNING;
+
+ case GIMP_MESSAGE_ERROR:
+ return GIMP_ICON_DIALOG_ERROR;
+
+ case GIMP_MESSAGE_BUG_WARNING:
+ case GIMP_MESSAGE_BUG_CRITICAL:
+ return GIMP_ICON_WILBER_EEK;
+ }
+
+ g_return_val_if_reached (GIMP_ICON_DIALOG_WARNING);
+}
+
+gboolean
+gimp_get_color_tag_color (GimpColorTag color_tag,
+ GimpRGB *color,
+ gboolean inherited)
+{
+ static const struct
+ {
+ guchar r;
+ guchar g;
+ guchar b;
+ }
+ colors[] =
+ {
+ { 0, 0, 0 }, /* none */
+ { 84, 102, 159 }, /* blue */
+ { 111, 143, 48 }, /* green */
+ { 210, 182, 45 }, /* yellow */
+ { 217, 122, 38 }, /* orange */
+ { 87, 53, 25 }, /* brown */
+ { 170, 42, 47 }, /* red */
+ { 99, 66, 174 }, /* violet */
+ { 87, 87, 87 } /* gray */
+ };
+
+ g_return_val_if_fail (color != NULL, FALSE);
+ g_return_val_if_fail (color_tag < G_N_ELEMENTS (colors), FALSE);
+
+ if (color_tag > GIMP_COLOR_TAG_NONE)
+ {
+ gimp_rgba_set_uchar (color,
+ colors[color_tag].r,
+ colors[color_tag].g,
+ colors[color_tag].b,
+ 255);
+
+ if (inherited)
+ {
+ gimp_rgb_composite (color, &(GimpRGB) {1.0, 1.0, 1.0, 0.2},
+ GIMP_RGB_COMPOSITE_NORMAL);
+ }
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void
+gimp_pango_layout_set_scale (PangoLayout *layout,
+ gdouble scale)
+{
+ PangoAttrList *attrs;
+ PangoAttribute *attr;
+
+ g_return_if_fail (PANGO_IS_LAYOUT (layout));
+
+ attrs = pango_attr_list_new ();
+
+ attr = pango_attr_scale_new (scale);
+ attr->start_index = 0;
+ attr->end_index = -1;
+ pango_attr_list_insert (attrs, attr);
+
+ pango_layout_set_attributes (layout, attrs);
+ pango_attr_list_unref (attrs);
+}
+
+void
+gimp_pango_layout_set_weight (PangoLayout *layout,
+ PangoWeight weight)
+{
+ PangoAttrList *attrs;
+ PangoAttribute *attr;
+
+ g_return_if_fail (PANGO_IS_LAYOUT (layout));
+
+ attrs = pango_attr_list_new ();
+
+ attr = pango_attr_weight_new (weight);
+ attr->start_index = 0;
+ attr->end_index = -1;
+ pango_attr_list_insert (attrs, attr);
+
+ pango_layout_set_attributes (layout, attrs);
+ pango_attr_list_unref (attrs);
+}
+
+static gboolean
+gimp_highlight_widget_expose (GtkWidget *widget,
+ GdkEventExpose *event,
+ gpointer data)
+{
+ /* this code is a modified version of gtk+'s gtk_drag_highlight_expose(),
+ * changing the highlight color from black to the widget's text color, which
+ * improves its visibility when using a dark theme.
+ */
+
+ gint x, y, width, height;
+
+ if (gtk_widget_is_drawable (widget))
+ {
+ GdkWindow *window;
+ GtkStyle *style;
+ const GdkColor *color;
+ cairo_t *cr;
+
+ window = gtk_widget_get_window (widget);
+ style = gtk_widget_get_style (widget);
+
+ if (!gtk_widget_get_has_window (widget))
+ {
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (widget, &allocation);
+
+ x = allocation.x;
+ y = allocation.y;
+ width = allocation.width;
+ height = allocation.height;
+ }
+ else
+ {
+ x = 0;
+ y = 0;
+ width = gdk_window_get_width (window);
+ height = gdk_window_get_height (window);
+ }
+
+ gtk_paint_shadow (style, window,
+ GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+ &event->area, widget, "dnd",
+ x, y, width, height);
+
+ color = &style->text[GTK_STATE_NORMAL];
+
+ cr = gdk_cairo_create (gtk_widget_get_window (widget));
+ cairo_set_source_rgb (cr,
+ (gdouble) color->red / 0xffff,
+ (gdouble) color->green / 0xffff,
+ (gdouble) color->blue / 0xffff);
+ cairo_set_line_width (cr, 1.0);
+ cairo_rectangle (cr,
+ x + 0.5, y + 0.5,
+ width - 1, height - 1);
+ cairo_stroke (cr);
+ cairo_destroy (cr);
+ }
+
+ return FALSE;
+}
+
+/**
+ * gimp_highlight_widget:
+ * @widget:
+ * @highlight:
+ *
+ * Turns highlighting for @widget on or off according to
+ * @highlight, in a similar fashion to gtk_drag_highlight()
+ * and gtk_drag_unhighlight().
+ **/
+void
+gimp_highlight_widget (GtkWidget *widget,
+ gboolean highlight)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (highlight)
+ {
+ g_signal_connect_after (widget, "expose-event",
+ G_CALLBACK (gimp_highlight_widget_expose),
+ NULL);
+ }
+ else
+ {
+ g_signal_handlers_disconnect_by_func (widget,
+ gimp_highlight_widget_expose,
+ NULL);
+ }
+
+ gtk_widget_queue_draw (widget);
+}
+
+typedef struct
+{
+ gint timeout_id;
+ gint counter;
+} WidgetBlink;
+
+static WidgetBlink *
+widget_blink_new (void)
+{
+ WidgetBlink *blink;
+
+ blink = g_slice_new (WidgetBlink);
+
+ blink->timeout_id = 0;
+ blink->counter = 0;
+
+ return blink;
+}
+
+static void
+widget_blink_free (WidgetBlink *blink)
+{
+ if (blink->timeout_id)
+ {
+ g_source_remove (blink->timeout_id);
+ blink->timeout_id = 0;
+ }
+
+ g_slice_free (WidgetBlink, blink);
+}
+
+static gboolean
+gimp_widget_blink_timeout (GtkWidget *widget)
+{
+ WidgetBlink *blink;
+
+ blink = g_object_get_data (G_OBJECT (widget), "gimp-widget-blink");
+
+ gimp_highlight_widget (widget, blink->counter % 2 == 1);
+ blink->counter++;
+
+ if (blink->counter == 3)
+ {
+ blink->timeout_id = 0;
+
+ g_object_set_data (G_OBJECT (widget), "gimp-widget-blink", NULL);
+
+ return G_SOURCE_REMOVE;
+ }
+
+ return G_SOURCE_CONTINUE;
+}
+
+void
+gimp_widget_blink (GtkWidget *widget)
+{
+ WidgetBlink *blink;
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ blink = widget_blink_new ();
+
+ g_object_set_data_full (G_OBJECT (widget), "gimp-widget-blink", blink,
+ (GDestroyNotify) widget_blink_free);
+
+ blink->timeout_id = g_timeout_add (150,
+ (GSourceFunc) gimp_widget_blink_timeout,
+ widget);
+
+ gimp_highlight_widget (widget, TRUE);
+
+ while ((widget = gtk_widget_get_parent (widget)))
+ gimp_widget_blink_cancel (widget);
+}
+
+void gimp_widget_blink_cancel (GtkWidget *widget)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (g_object_get_data (G_OBJECT (widget), "gimp-widget-blink"))
+ {
+ gimp_highlight_widget (widget, FALSE);
+
+ g_object_set_data (G_OBJECT (widget), "gimp-widget-blink", NULL);
+ }
+}
+
+/**
+ * gimp_dock_with_window_new:
+ * @factory: a #GimpDialogFacotry
+ * @screen: the #GdkScreen the dock window should appear on
+ * @toolbox: if %TRUE; gives a "gimp-toolbox-window" with a
+ * "gimp-toolbox", "gimp-dock-window"+"gimp-dock"
+ * otherwise
+ *
+ * Returns: the newly created #GimpDock with the #GimpDockWindow
+ **/
+GtkWidget *
+gimp_dock_with_window_new (GimpDialogFactory *factory,
+ GdkScreen *screen,
+ gint monitor,
+ gboolean toolbox)
+{
+ GtkWidget *dock_window;
+ GimpDockContainer *dock_container;
+ GtkWidget *dock;
+ GimpUIManager *ui_manager;
+
+ g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL);
+ g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+ /* Create a dock window to put the dock in. We need to create the
+ * dock window before the dock because the dock has a dependency to
+ * the ui manager in the dock window
+ */
+ dock_window = gimp_dialog_factory_dialog_new (factory, screen, monitor,
+ NULL /*ui_manager*/,
+ (toolbox ?
+ "gimp-toolbox-window" :
+ "gimp-dock-window"),
+ -1 /*view_size*/,
+ FALSE /*present*/);
+
+ dock_container = GIMP_DOCK_CONTAINER (dock_window);
+ ui_manager = gimp_dock_container_get_ui_manager (dock_container);
+ dock = gimp_dialog_factory_dialog_new (factory,
+ screen,
+ monitor,
+ ui_manager,
+ (toolbox ?
+ "gimp-toolbox" :
+ "gimp-dock"),
+ -1 /*view_size*/,
+ FALSE /*present*/);
+
+ if (dock)
+ gimp_dock_window_add_dock (GIMP_DOCK_WINDOW (dock_window),
+ GIMP_DOCK (dock),
+ -1);
+
+ return dock;
+}
+
+GtkWidget *
+gimp_tools_get_tool_options_gui (GimpToolOptions *tool_options)
+{
+ GtkWidget *widget;
+
+ widget = g_object_get_data (G_OBJECT (tool_options),
+ GIMP_TOOL_OPTIONS_GUI_KEY);
+
+ if (! widget)
+ {
+ GimpToolOptionsGUIFunc func;
+
+ func = g_object_get_data (G_OBJECT (tool_options),
+ GIMP_TOOL_OPTIONS_GUI_FUNC_KEY);
+
+ if (func)
+ {
+ widget = func (tool_options);
+
+ gimp_tools_set_tool_options_gui (tool_options, widget);
+ }
+ }
+
+ return widget;
+}
+
+void
+gimp_tools_set_tool_options_gui (GimpToolOptions *tool_options,
+ GtkWidget *widget)
+{
+ GtkWidget *prev_widget;
+
+ prev_widget = g_object_get_data (G_OBJECT (tool_options),
+ GIMP_TOOL_OPTIONS_GUI_KEY);
+
+ if (widget == prev_widget)
+ return;
+
+ if (prev_widget)
+ gtk_widget_destroy (prev_widget);
+
+ g_object_set_data_full (G_OBJECT (tool_options),
+ GIMP_TOOL_OPTIONS_GUI_KEY,
+ widget ? g_object_ref_sink (widget) : NULL,
+ widget ? (GDestroyNotify) g_object_unref : NULL);
+}
+
+void
+gimp_tools_set_tool_options_gui_func (GimpToolOptions *tool_options,
+ GimpToolOptionsGUIFunc func)
+{
+ g_object_set_data (G_OBJECT (tool_options),
+ GIMP_TOOL_OPTIONS_GUI_FUNC_KEY,
+ func);
+}
+
+void
+gimp_widget_flush_expose (GtkWidget *widget)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ if (! gtk_widget_is_drawable (widget))
+ return;
+
+ gdk_window_process_updates (gtk_widget_get_window (widget), FALSE);
+ gdk_flush ();
+}
+
+gboolean
+gimp_widget_get_fully_opaque (GtkWidget *widget)
+{
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+
+ return g_object_get_data (G_OBJECT (widget),
+ "gimp-widget-fully-opaque") != NULL;
+}
+
+void
+gimp_widget_set_fully_opaque (GtkWidget *widget,
+ gboolean fully_opaque)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ return g_object_set_data (G_OBJECT (widget),
+ "gimp-widget-fully-opaque",
+ GINT_TO_POINTER (fully_opaque));
+}
+
+static void
+gimp_gtk_container_clear_callback (GtkWidget *widget,
+ GtkContainer *container)
+{
+ gtk_container_remove (container, widget);
+}
+
+void
+gimp_gtk_container_clear (GtkContainer *container)
+{
+ gtk_container_foreach (container,
+ (GtkCallback) gimp_gtk_container_clear_callback,
+ container);
+}
+
+void
+gimp_gtk_adjustment_chain (GtkAdjustment *adjustment1,
+ GtkAdjustment *adjustment2)
+{
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment1));
+ g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment2));
+
+ g_object_bind_property (adjustment1, "value",
+ adjustment2, "lower",
+ G_BINDING_SYNC_CREATE);
+ g_object_bind_property (adjustment2, "value",
+ adjustment1, "upper",
+ G_BINDING_SYNC_CREATE);
+}
+
+static gboolean
+gimp_print_event_free (gpointer data)
+{
+ g_free (data);
+
+ return FALSE;
+}
+
+const gchar *
+gimp_print_event (const GdkEvent *event)
+{
+ gchar *str;
+
+ switch (event->type)
+ {
+ case GDK_ENTER_NOTIFY:
+ str = g_strdup ("ENTER_NOTIFY");
+ break;
+
+ case GDK_LEAVE_NOTIFY:
+ str = g_strdup ("LEAVE_NOTIFY");
+ break;
+
+ case GDK_PROXIMITY_IN:
+ str = g_strdup ("PROXIMITY_IN");
+ break;
+
+ case GDK_PROXIMITY_OUT:
+ str = g_strdup ("PROXIMITY_OUT");
+ break;
+
+ case GDK_FOCUS_CHANGE:
+ if (event->focus_change.in)
+ str = g_strdup ("FOCUS_IN");
+ else
+ str = g_strdup ("FOCUS_OUT");
+ break;
+
+ case GDK_BUTTON_PRESS:
+ str = g_strdup_printf ("BUTTON_PRESS (%d @ %0.0f:%0.0f)",
+ event->button.button,
+ event->button.x,
+ event->button.y);
+ break;
+
+ case GDK_2BUTTON_PRESS:
+ str = g_strdup_printf ("2BUTTON_PRESS (%d @ %0.0f:%0.0f)",
+ event->button.button,
+ event->button.x,
+ event->button.y);
+ break;
+
+ case GDK_3BUTTON_PRESS:
+ str = g_strdup_printf ("3BUTTON_PRESS (%d @ %0.0f:%0.0f)",
+ event->button.button,
+ event->button.x,
+ event->button.y);
+ break;
+
+ case GDK_BUTTON_RELEASE:
+ str = g_strdup_printf ("BUTTON_RELEASE (%d @ %0.0f:%0.0f)",
+ event->button.button,
+ event->button.x,
+ event->button.y);
+ break;
+
+ case GDK_SCROLL:
+ str = g_strdup_printf ("SCROLL (%d)",
+ event->scroll.direction);
+ break;
+
+ case GDK_MOTION_NOTIFY:
+ str = g_strdup_printf ("MOTION_NOTIFY (%0.0f:%0.0f %d)",
+ event->motion.x,
+ event->motion.y,
+ event->motion.time);
+ break;
+
+ case GDK_KEY_PRESS:
+ str = g_strdup_printf ("KEY_PRESS (%d, %s)",
+ event->key.keyval,
+ gdk_keyval_name (event->key.keyval) ?
+ gdk_keyval_name (event->key.keyval) : "<none>");
+ break;
+
+ case GDK_KEY_RELEASE:
+ str = g_strdup_printf ("KEY_RELEASE (%d, %s)",
+ event->key.keyval,
+ gdk_keyval_name (event->key.keyval) ?
+ gdk_keyval_name (event->key.keyval) : "<none>");
+ break;
+
+ default:
+ str = g_strdup_printf ("UNHANDLED (type %d)",
+ event->type);
+ break;
+ }
+
+ g_idle_add (gimp_print_event_free, str);
+
+ return str;
+}
+
+gboolean
+gimp_color_profile_store_add_defaults (GimpColorProfileStore *store,
+ GimpColorConfig *config,
+ GimpImageBaseType base_type,
+ GimpPrecision precision,
+ GError **error)
+{
+ GimpColorProfile *profile;
+ const Babl *format;
+ gchar *label;
+ GError *my_error = NULL;
+
+ g_return_val_if_fail (GIMP_IS_COLOR_PROFILE_STORE (store), FALSE);
+ g_return_val_if_fail (GIMP_IS_COLOR_CONFIG (config), FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+ format = gimp_babl_format (base_type, precision, TRUE);
+ profile = gimp_babl_format_get_color_profile (format);
+
+ if (base_type == GIMP_GRAY)
+ {
+ label = g_strdup_printf (_("Built-in grayscale (%s)"),
+ gimp_color_profile_get_label (profile));
+
+ profile = gimp_color_config_get_gray_color_profile (config, &my_error);
+ }
+ else
+ {
+ label = g_strdup_printf (_("Built-in RGB (%s)"),
+ gimp_color_profile_get_label (profile));
+
+ profile = gimp_color_config_get_rgb_color_profile (config, &my_error);
+ }
+
+ gimp_color_profile_store_add_file (store, NULL, label);
+ g_free (label);
+
+ if (profile)
+ {
+ GFile *file;
+
+ if (base_type == GIMP_GRAY)
+ {
+ file = gimp_file_new_for_config_path (config->gray_profile, NULL);
+
+ label = g_strdup_printf (_("Preferred grayscale (%s)"),
+ gimp_color_profile_get_label (profile));
+ }
+ else
+ {
+ file = gimp_file_new_for_config_path (config->rgb_profile, NULL);
+
+ label = g_strdup_printf (_("Preferred RGB (%s)"),
+ gimp_color_profile_get_label (profile));
+ }
+
+ g_object_unref (profile);
+
+ gimp_color_profile_store_add_file (store, file, label);
+
+ g_object_unref (file);
+ g_free (label);
+
+ return TRUE;
+ }
+ else if (my_error)
+ {
+ g_propagate_error (error, my_error);
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+connect_path_show (GimpColorProfileChooserDialog *dialog)
+{
+ GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
+ GFile *file = gtk_file_chooser_get_file (chooser);
+
+ if (file)
+ {
+ /* if something is already selected in this dialog,
+ * leave it alone
+ */
+ g_object_unref (file);
+ }
+ else
+ {
+ GObject *config;
+ const gchar *property;
+ gchar *path = NULL;
+
+ config = g_object_get_data (G_OBJECT (dialog), "profile-path-config");
+ property = g_object_get_data (G_OBJECT (dialog), "profile-path-property");
+
+ g_object_get (config, property, &path, NULL);
+
+ if (path)
+ {
+ GFile *folder = gimp_file_new_for_config_path (path, NULL);
+
+ if (folder)
+ {
+ gtk_file_chooser_set_current_folder_file (chooser, folder, NULL);
+ g_object_unref (folder);
+ }
+
+ g_free (path);
+ }
+ }
+}
+
+static void
+connect_path_response (GimpColorProfileChooserDialog *dialog,
+ gint response)
+{
+ if (response == GTK_RESPONSE_ACCEPT)
+ {
+ GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
+ GFile *file = gtk_file_chooser_get_file (chooser);
+
+ if (file)
+ {
+ GFile *folder = gtk_file_chooser_get_current_folder_file (chooser);
+
+ if (folder)
+ {
+ GObject *config;
+ const gchar *property;
+ gchar *path = NULL;
+
+ config = g_object_get_data (G_OBJECT (dialog),
+ "profile-path-config");
+ property = g_object_get_data (G_OBJECT (dialog),
+ "profile-path-property");
+
+ path = gimp_file_get_config_path (folder, NULL);
+
+ g_object_set (config, property, path, NULL);
+
+ if (path)
+ g_free (path);
+
+ g_object_unref (folder);
+ }
+
+ g_object_unref (file);
+ }
+ }
+}
+
+void
+gimp_color_profile_chooser_dialog_connect_path (GtkWidget *dialog,
+ GObject *config,
+ const gchar *property_name)
+{
+ g_return_if_fail (GIMP_IS_COLOR_PROFILE_CHOOSER_DIALOG (dialog));
+ g_return_if_fail (G_IS_OBJECT (config));
+ g_return_if_fail (property_name != NULL);
+
+ g_object_set_data_full (G_OBJECT (dialog), "profile-path-config",
+ g_object_ref (config),
+ (GDestroyNotify) g_object_unref);
+ g_object_set_data_full (G_OBJECT (dialog), "profile-path-property",
+ g_strdup (property_name),
+ (GDestroyNotify) g_free);
+
+ g_signal_connect (dialog, "show",
+ G_CALLBACK (connect_path_show),
+ NULL);
+ g_signal_connect (dialog, "response",
+ G_CALLBACK (connect_path_response),
+ NULL);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-08 20:00:38 +0000