summaryrefslogtreecommitdiffstats
path: root/app/widgets/gimptoolbox.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/widgets/gimptoolbox.c')
-rw-r--r--app/widgets/gimptoolbox.c811
1 files changed, 811 insertions, 0 deletions
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 <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#undef GSEAL_ENABLE
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#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);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 10:10:12 +0000