diff options
Diffstat (limited to 'app/widgets/gimpwidgets-utils.c')
| -rw-r--r-- | app/widgets/gimpwidgets-utils.c | 1964 |
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); +} |