From e42129241681dde7adae7d20697e7b421682fbb4 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:23:22 +0200 Subject: Adding upstream version 2.10.22. Signed-off-by: Daniel Baumann --- app/widgets/gimptoolbox.c | 811 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 811 insertions(+) create mode 100644 app/widgets/gimptoolbox.c (limited to 'app/widgets/gimptoolbox.c') diff --git a/app/widgets/gimptoolbox.c b/app/widgets/gimptoolbox.c new file mode 100644 index 0000000..0db8485 --- /dev/null +++ b/app/widgets/gimptoolbox.c @@ -0,0 +1,811 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "config.h" + +#include + +#undef GSEAL_ENABLE + +#include +#include + +#include "libgimpbase/gimpbase.h" +#include "libgimpwidgets/gimpwidgets.h" + +#include "widgets-types.h" + +#include "config/gimpguiconfig.h" + +#include "core/gimp.h" +#include "core/gimpcontext.h" + +#include "file/file-open.h" + +#include "gimpcairo-wilber.h" +#include "gimpdevices.h" +#include "gimpdialogfactory.h" +#include "gimpdockwindow.h" +#include "gimphelp-ids.h" +#include "gimppanedbox.h" +#include "gimptoolbox.h" +#include "gimptoolbox-color-area.h" +#include "gimptoolbox-dnd.h" +#include "gimptoolbox-image-area.h" +#include "gimptoolbox-indicator-area.h" +#include "gimptoolpalette.h" +#include "gimpuimanager.h" +#include "gimpwidgets-utils.h" +#include "gtkhwrapbox.h" + +#include "about.h" + +#include "gimp-intl.h" + + +enum +{ + PROP_0, + PROP_CONTEXT +}; + + +struct _GimpToolboxPrivate +{ + GimpContext *context; + + GtkWidget *vbox; + + GtkWidget *header; + GtkWidget *tool_palette; + GtkWidget *area_wbox; + GtkWidget *color_area; + GtkWidget *foo_area; + GtkWidget *image_area; + + gint area_rows; + gint area_columns; + + GimpPanedBox *drag_handler; + + gboolean in_destruction; +}; + + +static void gimp_toolbox_constructed (GObject *object); +static void gimp_toolbox_dispose (GObject *object); +static void gimp_toolbox_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec); +static void gimp_toolbox_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec); +static void gimp_toolbox_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static gboolean gimp_toolbox_button_press_event (GtkWidget *widget, + GdkEventButton *event); +static void gimp_toolbox_drag_leave (GtkWidget *widget, + GdkDragContext *context, + guint time, + GimpToolbox *toolbox); +static gboolean gimp_toolbox_drag_motion (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time, + GimpToolbox *toolbox); +static gboolean gimp_toolbox_drag_drop (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time, + GimpToolbox *toolbox); +static gchar * gimp_toolbox_get_description (GimpDock *dock, + gboolean complete); +static void gimp_toolbox_set_host_geometry_hints (GimpDock *dock, + GtkWindow *window); +static void gimp_toolbox_book_added (GimpDock *dock, + GimpDockbook *dockbook); +static void gimp_toolbox_book_removed (GimpDock *dock, + GimpDockbook *dockbook); +static void gimp_toolbox_size_request_wilber (GtkWidget *widget, + GtkRequisition *requisition, + GimpToolbox *toolbox); +static gboolean gimp_toolbox_expose_wilber (GtkWidget *widget, + GdkEventExpose *event); +static GtkWidget * toolbox_create_color_area (GimpToolbox *toolbox, + GimpContext *context); +static GtkWidget * toolbox_create_foo_area (GimpToolbox *toolbox, + GimpContext *context); +static GtkWidget * toolbox_create_image_area (GimpToolbox *toolbox, + GimpContext *context); +static void toolbox_area_notify (GimpGuiConfig *config, + GParamSpec *pspec, + GtkWidget *area); +static void toolbox_paste_received (GtkClipboard *clipboard, + const gchar *text, + gpointer data); + + +G_DEFINE_TYPE_WITH_PRIVATE (GimpToolbox, gimp_toolbox, GIMP_TYPE_DOCK) + +#define parent_class gimp_toolbox_parent_class + + +static void +gimp_toolbox_class_init (GimpToolboxClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GimpDockClass *dock_class = GIMP_DOCK_CLASS (klass); + + object_class->constructed = gimp_toolbox_constructed; + object_class->dispose = gimp_toolbox_dispose; + object_class->set_property = gimp_toolbox_set_property; + object_class->get_property = gimp_toolbox_get_property; + + widget_class->size_allocate = gimp_toolbox_size_allocate; + widget_class->button_press_event = gimp_toolbox_button_press_event; + + dock_class->get_description = gimp_toolbox_get_description; + dock_class->set_host_geometry_hints = gimp_toolbox_set_host_geometry_hints; + dock_class->book_added = gimp_toolbox_book_added; + dock_class->book_removed = gimp_toolbox_book_removed; + + g_object_class_install_property (object_class, PROP_CONTEXT, + g_param_spec_object ("context", + NULL, NULL, + GIMP_TYPE_CONTEXT, + GIMP_PARAM_READWRITE | + G_PARAM_CONSTRUCT)); +} + +static void +gimp_toolbox_init (GimpToolbox *toolbox) +{ + toolbox->p = gimp_toolbox_get_instance_private (toolbox); + + gimp_help_connect (GTK_WIDGET (toolbox), gimp_standard_help_func, + GIMP_HELP_TOOLBOX, NULL); +} + +static void +gimp_toolbox_constructed (GObject *object) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (object); + GimpGuiConfig *config; + GtkWidget *main_vbox; + GdkDisplay *display; + GList *list; + + gimp_assert (GIMP_IS_CONTEXT (toolbox->p->context)); + + config = GIMP_GUI_CONFIG (toolbox->p->context->gimp->config); + + main_vbox = gimp_dock_get_main_vbox (GIMP_DOCK (toolbox)); + + toolbox->p->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + gtk_box_pack_start (GTK_BOX (main_vbox), toolbox->p->vbox, FALSE, FALSE, 0); + gtk_box_reorder_child (GTK_BOX (main_vbox), toolbox->p->vbox, 0); + gtk_widget_show (toolbox->p->vbox); + + /* Use g_signal_connect() also for the toolbox itself so we can pass + * data and reuse the same function for the vbox + */ + g_signal_connect (toolbox, "drag-leave", + G_CALLBACK (gimp_toolbox_drag_leave), + toolbox); + g_signal_connect (toolbox, "drag-motion", + G_CALLBACK (gimp_toolbox_drag_motion), + toolbox); + g_signal_connect (toolbox, "drag-drop", + G_CALLBACK (gimp_toolbox_drag_drop), + toolbox); + g_signal_connect (toolbox->p->vbox, "drag-leave", + G_CALLBACK (gimp_toolbox_drag_leave), + toolbox); + g_signal_connect (toolbox->p->vbox, "drag-motion", + G_CALLBACK (gimp_toolbox_drag_motion), + toolbox); + g_signal_connect (toolbox->p->vbox, "drag-drop", + G_CALLBACK (gimp_toolbox_drag_drop), + toolbox); + + toolbox->p->header = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (toolbox->p->header), GTK_SHADOW_NONE); + gtk_box_pack_start (GTK_BOX (toolbox->p->vbox), toolbox->p->header, + FALSE, FALSE, 0); + + g_object_bind_property (config, "toolbox-wilber", + toolbox->p->header, "visible", + G_BINDING_SYNC_CREATE); + + g_signal_connect (toolbox->p->header, "size-request", + G_CALLBACK (gimp_toolbox_size_request_wilber), + toolbox); + g_signal_connect (toolbox->p->header, "expose-event", + G_CALLBACK (gimp_toolbox_expose_wilber), + toolbox); + + gimp_help_set_help_data (toolbox->p->header, + _("Drop image files here to open them"), NULL); + + toolbox->p->tool_palette = gimp_tool_palette_new (); + gimp_tool_palette_set_toolbox (GIMP_TOOL_PALETTE (toolbox->p->tool_palette), + toolbox); + gtk_box_pack_start (GTK_BOX (toolbox->p->vbox), toolbox->p->tool_palette, + FALSE, FALSE, 0); + gtk_widget_show (toolbox->p->tool_palette); + + toolbox->p->area_wbox = gtk_hwrap_box_new (FALSE); + gtk_wrap_box_set_justify (GTK_WRAP_BOX (toolbox->p->area_wbox), GTK_JUSTIFY_TOP); + gtk_wrap_box_set_line_justify (GTK_WRAP_BOX (toolbox->p->area_wbox), + GTK_JUSTIFY_LEFT); + gtk_wrap_box_set_aspect_ratio (GTK_WRAP_BOX (toolbox->p->area_wbox), + 2.0 / 15.0); + + gtk_box_pack_start (GTK_BOX (toolbox->p->vbox), toolbox->p->area_wbox, + FALSE, FALSE, 0); + gtk_widget_show (toolbox->p->area_wbox); + + /* We need to know when the current device changes, so we can update + * the correct tool - to do this we connect to motion events. + * We can't just use EXTENSION_EVENTS_CURSOR though, since that + * would get us extension events for the mouse pointer, and our + * device would change to that and not change back. So we check + * manually that all devices have a cursor, before establishing the check. + */ + display = gtk_widget_get_display (GTK_WIDGET (toolbox)); + for (list = gdk_display_list_devices (display); list; list = list->next) + if (! ((GdkDevice *) (list->data))->has_cursor) + break; + + if (! list) /* all devices have cursor */ + { + gtk_widget_add_events (GTK_WIDGET (toolbox), GDK_POINTER_MOTION_MASK); + gimp_devices_add_widget (toolbox->p->context->gimp, GTK_WIDGET (toolbox)); + } + + toolbox->p->color_area = toolbox_create_color_area (toolbox, + toolbox->p->context); + gtk_wrap_box_pack_wrapped (GTK_WRAP_BOX (toolbox->p->area_wbox), + toolbox->p->color_area, + TRUE, TRUE, FALSE, TRUE, TRUE); + if (config->toolbox_color_area) + gtk_widget_show (toolbox->p->color_area); + + g_signal_connect_object (config, "notify::toolbox-color-area", + G_CALLBACK (toolbox_area_notify), + toolbox->p->color_area, 0); + + toolbox->p->foo_area = toolbox_create_foo_area (toolbox, toolbox->p->context); + gtk_wrap_box_pack (GTK_WRAP_BOX (toolbox->p->area_wbox), toolbox->p->foo_area, + TRUE, TRUE, FALSE, TRUE); + if (config->toolbox_foo_area) + gtk_widget_show (toolbox->p->foo_area); + + g_signal_connect_object (config, "notify::toolbox-foo-area", + G_CALLBACK (toolbox_area_notify), + toolbox->p->foo_area, 0); + + toolbox->p->image_area = toolbox_create_image_area (toolbox, + toolbox->p->context); + gtk_wrap_box_pack (GTK_WRAP_BOX (toolbox->p->area_wbox), toolbox->p->image_area, + TRUE, TRUE, FALSE, TRUE); + if (config->toolbox_image_area) + gtk_widget_show (toolbox->p->image_area); + + g_signal_connect_object (config, "notify::toolbox-image-area", + G_CALLBACK (toolbox_area_notify), + toolbox->p->image_area, 0); + + gimp_toolbox_dnd_init (GIMP_TOOLBOX (toolbox), toolbox->p->vbox); +} + +static void +gimp_toolbox_dispose (GObject *object) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (object); + + toolbox->p->in_destruction = TRUE; + + g_clear_object (&toolbox->p->context); + + G_OBJECT_CLASS (parent_class)->dispose (object); + + toolbox->p->in_destruction = FALSE; +} + +static void +gimp_toolbox_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (object); + + switch (property_id) + { + case PROP_CONTEXT: + toolbox->p->context = g_value_dup_object (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_toolbox_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (object); + + switch (property_id) + { + case PROP_CONTEXT: + g_value_set_object (value, toolbox->p->context); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +gimp_toolbox_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (widget); + GimpGuiConfig *config; + GtkRequisition color_requisition; + GtkRequisition foo_requisition; + GtkRequisition image_requisition; + gint width; + gint height; + gint n_areas; + gint area_rows; + gint area_columns; + + GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation); + + config = GIMP_GUI_CONFIG (toolbox->p->context->gimp->config); + + gtk_widget_size_request (toolbox->p->color_area, &color_requisition); + gtk_widget_size_request (toolbox->p->foo_area, &foo_requisition); + gtk_widget_size_request (toolbox->p->image_area, &image_requisition); + + width = MAX (color_requisition.width, + MAX (foo_requisition.width, + image_requisition.width)); + height = MAX (color_requisition.height, + MAX (foo_requisition.height, + image_requisition.height)); + + n_areas = (config->toolbox_color_area + + config->toolbox_foo_area + + config->toolbox_image_area); + + area_columns = MAX (1, (allocation->width / width)); + area_rows = n_areas / area_columns; + + if (n_areas % area_columns) + area_rows++; + + if (toolbox->p->area_rows != area_rows || + toolbox->p->area_columns != area_columns) + { + toolbox->p->area_rows = area_rows; + toolbox->p->area_columns = area_columns; + + gtk_widget_set_size_request (toolbox->p->area_wbox, -1, + area_rows * height); + } +} + +static gboolean +gimp_toolbox_button_press_event (GtkWidget *widget, + GdkEventButton *event) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (widget); + + if (event->type == GDK_BUTTON_PRESS && event->button == 2) + { + GtkClipboard *clipboard; + + clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY); + gtk_clipboard_request_text (clipboard, + toolbox_paste_received, + g_object_ref (toolbox)); + + return TRUE; + } + + return FALSE; +} + +static void +gimp_toolbox_drag_leave (GtkWidget *widget, + GdkDragContext *context, + guint time, + GimpToolbox *toolbox) +{ + gimp_highlight_widget (widget, FALSE); +} + +static gboolean +gimp_toolbox_drag_motion (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time, + GimpToolbox *toolbox) +{ + gboolean handle; + + if (gimp_paned_box_will_handle_drag (toolbox->p->drag_handler, + widget, + context, + x, y, + time)) + { + gdk_drag_status (context, 0, time); + gimp_highlight_widget (widget, FALSE); + + return FALSE; + } + + handle = (gtk_drag_dest_find_target (widget, context, NULL) != GDK_NONE); + + gdk_drag_status (context, handle ? GDK_ACTION_MOVE : 0, time); + gimp_highlight_widget (widget, handle); + + /* Return TRUE so drag_leave() is called */ + return TRUE; +} + +static gboolean +gimp_toolbox_drag_drop (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time, + GimpToolbox *toolbox) +{ + GdkAtom target; + gboolean dropped = FALSE; + + if (gimp_paned_box_will_handle_drag (toolbox->p->drag_handler, + widget, + context, + x, y, + time)) + { + return FALSE; + } + + target = gtk_drag_dest_find_target (widget, context, NULL); + + if (target != GDK_NONE) + { + /* The URI handlers etc will handle this */ + gtk_drag_get_data (widget, context, target, time); + dropped = TRUE; + } + + gtk_drag_finish (context, dropped, (context->action == GDK_ACTION_MOVE), time); + + return TRUE; +} + +static gchar * +gimp_toolbox_get_description (GimpDock *dock, + gboolean complete) +{ + GString *desc = g_string_new (_("Toolbox")); + gchar *dock_desc = GIMP_DOCK_CLASS (parent_class)->get_description (dock, + complete); + + if (dock_desc && strlen (dock_desc) > 0) + { + g_string_append (desc, GIMP_DOCK_BOOK_SEPARATOR); + g_string_append (desc, dock_desc); + } + + g_free (dock_desc); + + return g_string_free (desc, FALSE /*free_segment*/); +} + +static void +gimp_toolbox_book_added (GimpDock *dock, + GimpDockbook *dockbook) +{ + if (GIMP_DOCK_CLASS (parent_class)->book_added) + GIMP_DOCK_CLASS (parent_class)->book_added (dock, dockbook); + + if (g_list_length (gimp_dock_get_dockbooks (dock)) == 1) + { + gimp_dock_invalidate_geometry (dock); + } +} + +static void +gimp_toolbox_book_removed (GimpDock *dock, + GimpDockbook *dockbook) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (dock); + + if (GIMP_DOCK_CLASS (parent_class)->book_removed) + GIMP_DOCK_CLASS (parent_class)->book_removed (dock, dockbook); + + if (! gimp_dock_get_dockbooks (dock) && + ! toolbox->p->in_destruction) + { + gimp_dock_invalidate_geometry (dock); + } +} + +static void +gimp_toolbox_set_host_geometry_hints (GimpDock *dock, + GtkWindow *window) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (dock); + gint button_width; + gint button_height; + + if (gimp_tool_palette_get_button_size (GIMP_TOOL_PALETTE (toolbox->p->tool_palette), + &button_width, &button_height)) + { + GdkGeometry geometry; + + geometry.min_width = 2 * button_width; + geometry.min_height = -1; + geometry.base_width = button_width; + geometry.base_height = 0; + geometry.width_inc = button_width; + geometry.height_inc = 1; + + gtk_window_set_geometry_hints (window, + NULL, + &geometry, + GDK_HINT_MIN_SIZE | + GDK_HINT_BASE_SIZE | + GDK_HINT_RESIZE_INC | + GDK_HINT_USER_POS); + + gimp_dialog_factory_set_has_min_size (window, TRUE); + } +} + +GtkWidget * +gimp_toolbox_new (GimpDialogFactory *factory, + GimpContext *context, + GimpUIManager *ui_manager) +{ + g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (factory), NULL); + g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); + g_return_val_if_fail (GIMP_IS_UI_MANAGER (ui_manager), NULL); + + return g_object_new (GIMP_TYPE_TOOLBOX, + "context", context, + NULL); +} + +GimpContext * +gimp_toolbox_get_context (GimpToolbox *toolbox) +{ + g_return_val_if_fail (GIMP_IS_TOOLBOX (toolbox), NULL); + + return toolbox->p->context; +} + +void +gimp_toolbox_set_drag_handler (GimpToolbox *toolbox, + GimpPanedBox *drag_handler) +{ + g_return_if_fail (GIMP_IS_TOOLBOX (toolbox)); + + toolbox->p->drag_handler = drag_handler; +} + + +/* private functions */ + +static void +gimp_toolbox_size_request_wilber (GtkWidget *widget, + GtkRequisition *requisition, + GimpToolbox *toolbox) +{ + gint button_width; + gint button_height; + + if (gimp_tool_palette_get_button_size (GIMP_TOOL_PALETTE (toolbox->p->tool_palette), + &button_width, &button_height)) + { + requisition->width = button_width * PANGO_SCALE_SMALL; + requisition->height = button_height * PANGO_SCALE_SMALL; + } + else + { + requisition->width = 16; + requisition->height = 16; + } +} + +static gboolean +gimp_toolbox_expose_wilber (GtkWidget *widget, + GdkEventExpose *event) +{ + cairo_t *cr; + + cr = gdk_cairo_create (gtk_widget_get_window (widget)); + gdk_cairo_region (cr, event->region); + cairo_clip (cr); + + gimp_cairo_draw_toolbox_wilber (widget, cr); + + cairo_destroy (cr); + + return FALSE; +} + +static GtkWidget * +toolbox_create_color_area (GimpToolbox *toolbox, + GimpContext *context) +{ + GtkWidget *alignment; + GtkWidget *col_area; + + alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); + gtk_container_set_border_width (GTK_CONTAINER (alignment), 2); + + gimp_help_set_help_data (alignment, NULL, GIMP_HELP_TOOLBOX_COLOR_AREA); + + col_area = gimp_toolbox_color_area_create (toolbox, 40, 38); + gtk_container_add (GTK_CONTAINER (alignment), col_area); + gtk_widget_show (col_area); + + return alignment; +} + +static GtkWidget * +toolbox_create_foo_area (GimpToolbox *toolbox, + GimpContext *context) +{ + GtkWidget *alignment; + GtkWidget *foo_area; + + alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); + gtk_container_set_border_width (GTK_CONTAINER (alignment), 2); + + gimp_help_set_help_data (alignment, NULL, GIMP_HELP_TOOLBOX_INDICATOR_AREA); + + foo_area = gimp_toolbox_indicator_area_create (toolbox); + gtk_container_add (GTK_CONTAINER (alignment), foo_area); + gtk_widget_show (foo_area); + + return alignment; +} + +static GtkWidget * +toolbox_create_image_area (GimpToolbox *toolbox, + GimpContext *context) +{ + GtkWidget *alignment; + GtkWidget *image_area; + + alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); + gtk_container_set_border_width (GTK_CONTAINER (alignment), 2); + + gimp_help_set_help_data (alignment, NULL, GIMP_HELP_TOOLBOX_IMAGE_AREA); + + image_area = gimp_toolbox_image_area_create (toolbox, 52, 42); + gtk_container_add (GTK_CONTAINER (alignment), image_area); + gtk_widget_show (image_area); + + return alignment; +} + +static void +toolbox_area_notify (GimpGuiConfig *config, + GParamSpec *pspec, + GtkWidget *area) +{ + GtkWidget *parent = gtk_widget_get_parent (area); + gboolean visible; + + if (config->toolbox_color_area || + config->toolbox_foo_area || + config->toolbox_image_area) + { + GtkRequisition req; + + gtk_widget_show (parent); + + gtk_widget_size_request (area, &req); + gtk_widget_set_size_request (parent, req.width, req.height); + } + else + { + gtk_widget_hide (parent); + gtk_widget_set_size_request (parent, -1, -1); + } + + g_object_get (config, pspec->name, &visible, NULL); + g_object_set (area, "visible", visible, NULL); +} + +static void +toolbox_paste_received (GtkClipboard *clipboard, + const gchar *text, + gpointer data) +{ + GimpToolbox *toolbox = GIMP_TOOLBOX (data); + GimpContext *context = toolbox->p->context; + + if (text) + { + const gchar *newline = strchr (text, '\n'); + gchar *copy; + GFile *file = NULL; + + if (newline) + copy = g_strndup (text, newline - text); + else + copy = g_strdup (text); + + g_strstrip (copy); + + if (strlen (copy)) + file = g_file_new_for_commandline_arg (copy); + + g_free (copy); + + if (file) + { + GtkWidget *widget = GTK_WIDGET (toolbox); + GimpImage *image; + GimpPDBStatusType status; + GError *error = NULL; + + image = file_open_with_display (context->gimp, context, NULL, + file, FALSE, + G_OBJECT (gtk_widget_get_screen (widget)), + gimp_widget_get_monitor (widget), + &status, &error); + + if (! image && status != GIMP_PDB_CANCEL) + { + gimp_message (context->gimp, NULL, GIMP_MESSAGE_ERROR, + _("Opening '%s' failed:\n\n%s"), + gimp_file_get_utf8_name (file), error->message); + g_clear_error (&error); + } + + g_object_unref (file); + } + } + + g_object_unref (context); +} -- cgit v1.2.3