/* 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); }