/* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * Major improvements for interactivity * Copyright (C) 2014 Michael Henning * * 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 #include #include #include "libgimpwidgets/gimpwidgets.h" #include "tools-types.h" #include "config/gimpguiconfig.h" #include "gegl/gimp-gegl-utils.h" #include "operations/gimp-operation-config.h" #include "operations/layer-modes/gimp-layer-modes.h" #include "core/gimp.h" #include "core/gimpdrawable.h" #include "core/gimpdrawable-gradient.h" #include "core/gimpdrawablefilter.h" #include "core/gimperror.h" #include "core/gimpgradient.h" #include "core/gimpimage.h" #include "core/gimpprogress.h" #include "core/gimpprojection.h" #include "widgets/gimphelp-ids.h" #include "widgets/gimpwidgets-utils.h" #include "display/gimpdisplay.h" #include "display/gimptoolline.h" #include "gimpgradientoptions.h" #include "gimpgradienttool.h" #include "gimpgradienttool-editor.h" #include "gimptoolcontrol.h" #include "gimptools-utils.h" #include "gimp-intl.h" /* local function prototypes */ static void gimp_gradient_tool_dispose (GObject *object); static gboolean gimp_gradient_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error); static void gimp_gradient_tool_control (GimpTool *tool, GimpToolAction action, GimpDisplay *display); static void gimp_gradient_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display); static void gimp_gradient_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display); static void gimp_gradient_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display); static gboolean gimp_gradient_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display); static void gimp_gradient_tool_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display); static void gimp_gradient_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display); static const gchar * gimp_gradient_tool_can_undo (GimpTool *tool, GimpDisplay *display); static const gchar * gimp_gradient_tool_can_redo (GimpTool *tool, GimpDisplay *display); static gboolean gimp_gradient_tool_undo (GimpTool *tool, GimpDisplay *display); static gboolean gimp_gradient_tool_redo (GimpTool *tool, GimpDisplay *display); static void gimp_gradient_tool_options_notify (GimpTool *tool, GimpToolOptions *options, const GParamSpec *pspec); static void gimp_gradient_tool_start (GimpGradientTool *gradient_tool, const GimpCoords *coords, GimpDisplay *display); static void gimp_gradient_tool_halt (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_commit (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_line_changed (GimpToolWidget *widget, GimpGradientTool *gradient_tool); static void gimp_gradient_tool_line_response (GimpToolWidget *widget, gint response_id, GimpGradientTool *gradient_tool); static void gimp_gradient_tool_precalc_shapeburst (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_create_graph (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_update_graph (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_fg_bg_changed (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_gradient_dirty (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_set_gradient (GimpGradientTool *gradient_tool, GimpGradient *gradient); static gboolean gimp_gradient_tool_is_shapeburst (GimpGradientTool *gradient_tool); static void gimp_gradient_tool_create_filter (GimpGradientTool *gradient_tool, GimpDrawable *drawable); static void gimp_gradient_tool_filter_flush (GimpDrawableFilter *filter, GimpTool *tool); G_DEFINE_TYPE (GimpGradientTool, gimp_gradient_tool, GIMP_TYPE_DRAW_TOOL) #define parent_class gimp_gradient_tool_parent_class void gimp_gradient_tool_register (GimpToolRegisterCallback callback, gpointer data) { (* callback) (GIMP_TYPE_GRADIENT_TOOL, GIMP_TYPE_GRADIENT_OPTIONS, gimp_gradient_options_gui, GIMP_CONTEXT_PROP_MASK_FOREGROUND | GIMP_CONTEXT_PROP_MASK_BACKGROUND | GIMP_CONTEXT_PROP_MASK_OPACITY | GIMP_CONTEXT_PROP_MASK_PAINT_MODE | GIMP_CONTEXT_PROP_MASK_GRADIENT, "gimp-gradient-tool", _("Gradient"), _("Gradient Tool: Fill selected area with a color gradient"), N_("Gra_dient"), "G", NULL, GIMP_HELP_TOOL_GRADIENT, GIMP_ICON_TOOL_GRADIENT, data); } static void gimp_gradient_tool_class_init (GimpGradientToolClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass); object_class->dispose = gimp_gradient_tool_dispose; tool_class->initialize = gimp_gradient_tool_initialize; tool_class->control = gimp_gradient_tool_control; tool_class->button_press = gimp_gradient_tool_button_press; tool_class->button_release = gimp_gradient_tool_button_release; tool_class->motion = gimp_gradient_tool_motion; tool_class->key_press = gimp_gradient_tool_key_press; tool_class->modifier_key = gimp_gradient_tool_modifier_key; tool_class->cursor_update = gimp_gradient_tool_cursor_update; tool_class->can_undo = gimp_gradient_tool_can_undo; tool_class->can_redo = gimp_gradient_tool_can_redo; tool_class->undo = gimp_gradient_tool_undo; tool_class->redo = gimp_gradient_tool_redo; tool_class->options_notify = gimp_gradient_tool_options_notify; } static void gimp_gradient_tool_init (GimpGradientTool *gradient_tool) { GimpTool *tool = GIMP_TOOL (gradient_tool); gimp_tool_control_set_scroll_lock (tool->control, TRUE); gimp_tool_control_set_preserve (tool->control, FALSE); gimp_tool_control_set_dirty_mask (tool->control, GIMP_DIRTY_IMAGE | GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_DRAWABLE | GIMP_DIRTY_ACTIVE_DRAWABLE); gimp_tool_control_set_dirty_action (tool->control, GIMP_TOOL_ACTION_COMMIT); gimp_tool_control_set_wants_click (tool->control, TRUE); gimp_tool_control_set_wants_double_click (tool->control, TRUE); gimp_tool_control_set_active_modifiers (tool->control, GIMP_TOOL_ACTIVE_MODIFIERS_SEPARATE); gimp_tool_control_set_precision (tool->control, GIMP_CURSOR_PRECISION_SUBPIXEL); gimp_tool_control_set_tool_cursor (tool->control, GIMP_TOOL_CURSOR_GRADIENT); gimp_tool_control_set_action_opacity (tool->control, "context/context-opacity-set"); gimp_tool_control_set_action_object_1 (tool->control, "context/context-gradient-select-set"); gimp_draw_tool_set_default_status (GIMP_DRAW_TOOL (tool), _("Click-Drag to draw a gradient")); } static void gimp_gradient_tool_dispose (GObject *object) { GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (object); gimp_gradient_tool_set_gradient (gradient_tool, NULL); G_OBJECT_CLASS (parent_class)->dispose (object); } static gboolean gimp_gradient_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (tool); GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config); if (! GIMP_TOOL_CLASS (parent_class)->initialize (tool, display, error)) { return FALSE; } if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); if (error) gimp_tools_blink_lock_box (display->gimp, GIMP_ITEM (drawable)); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable)) && ! config->edit_non_visible) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer is not visible.")); return FALSE; } if (! gimp_context_get_gradient (GIMP_CONTEXT (options))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("No gradient available for use with this tool.")); return FALSE; } return TRUE; } static void gimp_gradient_tool_control (GimpTool *tool, GimpToolAction action, GimpDisplay *display) { GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (tool); switch (action) { case GIMP_TOOL_ACTION_PAUSE: case GIMP_TOOL_ACTION_RESUME: break; case GIMP_TOOL_ACTION_HALT: gimp_gradient_tool_halt (gradient_tool); break; case GIMP_TOOL_ACTION_COMMIT: gimp_gradient_tool_commit (gradient_tool); break; } GIMP_TOOL_CLASS (parent_class)->control (tool, action, display); } static void gimp_gradient_tool_button_press (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonPressType press_type, GimpDisplay *display) { GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (tool); if (tool->display && display != tool->display) gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display); if (! gradient_tool->widget) { gimp_gradient_tool_start (gradient_tool, coords, display); gimp_tool_widget_hover (gradient_tool->widget, coords, state, TRUE); } /* call start_edit() before widget_button_press(), because we need to record * the undo state before widget_button_press() potentially changes it. note * that if widget_button_press() return FALSE, nothing changes and no undo * step is created. */ if (press_type == GIMP_BUTTON_PRESS_NORMAL) gimp_gradient_tool_editor_start_edit (gradient_tool); if (gimp_tool_widget_button_press (gradient_tool->widget, coords, time, state, press_type)) { gradient_tool->grab_widget = gradient_tool->widget; } if (press_type == GIMP_BUTTON_PRESS_NORMAL) gimp_tool_control_activate (tool->control); } static void gimp_gradient_tool_button_release (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpButtonReleaseType release_type, GimpDisplay *display) { GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (tool); GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (tool); gimp_tool_pop_status (tool, display); gimp_tool_control_halt (tool->control); if (gradient_tool->grab_widget) { gimp_tool_widget_button_release (gradient_tool->grab_widget, coords, time, state, release_type); gradient_tool->grab_widget = NULL; if (options->instant) { if (release_type == GIMP_BUTTON_RELEASE_CANCEL) gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); else gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, display); } } if (! options->instant) { gimp_gradient_tool_editor_end_edit (gradient_tool, release_type == GIMP_BUTTON_RELEASE_CANCEL); } } static void gimp_gradient_tool_motion (GimpTool *tool, const GimpCoords *coords, guint32 time, GdkModifierType state, GimpDisplay *display) { GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (tool); if (gradient_tool->grab_widget) { gimp_tool_widget_motion (gradient_tool->grab_widget, coords, time, state); } } static gboolean gimp_gradient_tool_key_press (GimpTool *tool, GdkEventKey *kevent, GimpDisplay *display) { GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (tool); GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool); gboolean result; /* call start_edit() before widget_key_press(), because we need to record the * undo state before widget_key_press() potentially changes it. note that if * widget_key_press() return FALSE, nothing changes and no undo step is * created. */ if (display == draw_tool->display) gimp_gradient_tool_editor_start_edit (gradient_tool); result = GIMP_TOOL_CLASS (parent_class)->key_press (tool, kevent, display); if (display == draw_tool->display) gimp_gradient_tool_editor_end_edit (gradient_tool, FALSE); return result; } static void gimp_gradient_tool_modifier_key (GimpTool *tool, GdkModifierType key, gboolean press, GdkModifierType state, GimpDisplay *display) { GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (tool); if (key == gimp_get_extend_selection_mask ()) { if (options->instant_toggle && gtk_widget_get_sensitive (options->instant_toggle)) { g_object_set (options, "instant", ! options->instant, NULL); } } } static void gimp_gradient_tool_cursor_update (GimpTool *tool, const GimpCoords *coords, GdkModifierType state, GimpDisplay *display) { GimpGuiConfig *config = GIMP_GUI_CONFIG (display->gimp->config); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) || gimp_item_is_content_locked (GIMP_ITEM (drawable)) || ! (gimp_item_is_visible (GIMP_ITEM (drawable)) || config->edit_non_visible)) { gimp_tool_set_cursor (tool, display, gimp_tool_control_get_cursor (tool->control), gimp_tool_control_get_tool_cursor (tool->control), GIMP_CURSOR_MODIFIER_BAD); return; } GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display); } static const gchar * gimp_gradient_tool_can_undo (GimpTool *tool, GimpDisplay *display) { return gimp_gradient_tool_editor_can_undo (GIMP_GRADIENT_TOOL (tool)); } static const gchar * gimp_gradient_tool_can_redo (GimpTool *tool, GimpDisplay *display) { return gimp_gradient_tool_editor_can_redo (GIMP_GRADIENT_TOOL (tool)); } static gboolean gimp_gradient_tool_undo (GimpTool *tool, GimpDisplay *display) { return gimp_gradient_tool_editor_undo (GIMP_GRADIENT_TOOL (tool)); } static gboolean gimp_gradient_tool_redo (GimpTool *tool, GimpDisplay *display) { return gimp_gradient_tool_editor_redo (GIMP_GRADIENT_TOOL (tool)); } static void gimp_gradient_tool_options_notify (GimpTool *tool, GimpToolOptions *options, const GParamSpec *pspec) { GimpContext *context = GIMP_CONTEXT (options); GimpGradientTool *gradient_tool = GIMP_GRADIENT_TOOL (tool); if (! strcmp (pspec->name, "gradient")) { gimp_gradient_tool_set_gradient (gradient_tool, context->gradient); if (gradient_tool->filter) gimp_drawable_filter_apply (gradient_tool->filter, NULL); } else if (gradient_tool->render_node && gegl_node_find_property (gradient_tool->render_node, pspec->name)) { /* Sync any property changes on the config object that match the op */ GValue value = G_VALUE_INIT; g_value_init (&value, pspec->value_type); g_object_get_property (G_OBJECT (options), pspec->name, &value); gegl_node_set_property (gradient_tool->render_node, pspec->name, &value); g_value_unset (&value); if (! strcmp (pspec->name, "gradient-type")) { GimpRepeatMode gradient_repeat; GimpRepeatMode node_repeat; GimpGradientType gradient_type; gradient_repeat = GIMP_PAINT_OPTIONS (options)->gradient_options->gradient_repeat; gradient_type = GIMP_GRADIENT_OPTIONS (options)->gradient_type; gegl_node_get (gradient_tool->render_node, "gradient-repeat", &node_repeat, NULL); if (gradient_type >= GIMP_GRADIENT_SHAPEBURST_ANGULAR) { /* These gradient types are only meant to work with repeat * value of "none" so these are the only ones where we * don't keep the render node and the gradient options in * sync. * We could instead reset the "gradient-repeat" value on * GimpGradientOptions, but I assume one would want to revert * back to the last set value if changing back the * gradient type. So instead we just make the option * insensitive (both in GUI and in render). */ if (node_repeat != GIMP_REPEAT_NONE) gegl_node_set (gradient_tool->render_node, "gradient-repeat", GIMP_REPEAT_NONE, NULL); } else if (node_repeat != gradient_repeat) { gegl_node_set (gradient_tool->render_node, "gradient-repeat", gradient_repeat, NULL); } if (gimp_gradient_tool_is_shapeburst (gradient_tool)) gimp_gradient_tool_precalc_shapeburst (gradient_tool); gimp_gradient_tool_update_graph (gradient_tool); } gimp_drawable_filter_apply (gradient_tool->filter, NULL); } else if (gradient_tool->render_node && gimp_gradient_tool_is_shapeburst (gradient_tool) && g_strcmp0 (pspec->name, "distance-metric") == 0) { g_clear_object (&gradient_tool->dist_buffer); gimp_gradient_tool_precalc_shapeburst (gradient_tool); gimp_gradient_tool_update_graph (gradient_tool); gimp_drawable_filter_apply (gradient_tool->filter, NULL); } else if (gradient_tool->filter && ! strcmp (pspec->name, "opacity")) { gimp_drawable_filter_set_opacity (gradient_tool->filter, gimp_context_get_opacity (context)); } else if (gradient_tool->filter && ! strcmp (pspec->name, "paint-mode")) { gimp_drawable_filter_set_mode (gradient_tool->filter, gimp_context_get_paint_mode (context), GIMP_LAYER_COLOR_SPACE_AUTO, GIMP_LAYER_COLOR_SPACE_AUTO, gimp_layer_mode_get_paint_composite_mode ( gimp_context_get_paint_mode (context))); } gimp_gradient_tool_editor_options_notify (gradient_tool, options, pspec); } static void gimp_gradient_tool_start (GimpGradientTool *gradient_tool, const GimpCoords *coords, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (gradient_tool); GimpDisplayShell *shell = gimp_display_get_shell (display); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); GimpContext *context = GIMP_CONTEXT (options); if (options->instant_toggle) gtk_widget_set_sensitive (options->instant_toggle, FALSE); tool->display = display; tool->drawable = drawable; gradient_tool->start_x = coords->x; gradient_tool->start_y = coords->y; gradient_tool->end_x = coords->x; gradient_tool->end_y = coords->y; gradient_tool->widget = gimp_tool_line_new (shell, gradient_tool->start_x, gradient_tool->start_y, gradient_tool->end_x, gradient_tool->end_y); g_object_set (gradient_tool->widget, "status-title", _("Gradient: "), NULL); gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (tool), gradient_tool->widget); g_signal_connect (gradient_tool->widget, "changed", G_CALLBACK (gimp_gradient_tool_line_changed), gradient_tool); g_signal_connect (gradient_tool->widget, "response", G_CALLBACK (gimp_gradient_tool_line_response), gradient_tool); g_signal_connect_swapped (context, "background-changed", G_CALLBACK (gimp_gradient_tool_fg_bg_changed), gradient_tool); g_signal_connect_swapped (context, "foreground-changed", G_CALLBACK (gimp_gradient_tool_fg_bg_changed), gradient_tool); gimp_gradient_tool_create_filter (gradient_tool, drawable); /* Initially sync all of the properties */ gimp_operation_config_sync_node (G_OBJECT (options), gradient_tool->render_node); /* We don't allow repeat values for some shapes. */ if (options->gradient_type >= GIMP_GRADIENT_SHAPEBURST_ANGULAR) gegl_node_set (gradient_tool->render_node, "gradient-repeat", GIMP_REPEAT_NONE, NULL); /* Connect signal handlers for the gradient */ gimp_gradient_tool_set_gradient (gradient_tool, context->gradient); if (gimp_gradient_tool_is_shapeburst (gradient_tool)) gimp_gradient_tool_precalc_shapeburst (gradient_tool); gimp_draw_tool_start (GIMP_DRAW_TOOL (gradient_tool), display); gimp_gradient_tool_editor_start (gradient_tool); } static void gimp_gradient_tool_halt (GimpGradientTool *gradient_tool) { GimpTool *tool = GIMP_TOOL (gradient_tool); GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); GimpContext *context = GIMP_CONTEXT (options); gimp_gradient_tool_editor_halt (gradient_tool); if (gradient_tool->graph) { g_clear_object (&gradient_tool->graph); gradient_tool->render_node = NULL; #if 0 gradient_tool->subtract_node = NULL; gradient_tool->divide_node = NULL; #endif gradient_tool->dist_node = NULL; } g_clear_object (&gradient_tool->dist_buffer); if (gradient_tool->filter) { gimp_tool_control_push_preserve (tool->control, TRUE); gimp_drawable_filter_abort (gradient_tool->filter); g_object_unref (gradient_tool->filter); gradient_tool->filter = NULL; gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (tool->display)); } gimp_gradient_tool_set_tentative_gradient (gradient_tool, NULL); g_signal_handlers_disconnect_by_func (context, G_CALLBACK (gimp_gradient_tool_fg_bg_changed), gradient_tool); if (tool->display) gimp_tool_pop_status (tool, tool->display); if (gimp_draw_tool_is_active (GIMP_DRAW_TOOL (gradient_tool))) gimp_draw_tool_stop (GIMP_DRAW_TOOL (gradient_tool)); gimp_draw_tool_set_widget (GIMP_DRAW_TOOL (tool), NULL); g_clear_object (&gradient_tool->widget); tool->display = NULL; tool->drawable = NULL; if (options->instant_toggle) gtk_widget_set_sensitive (options->instant_toggle, TRUE); } static void gimp_gradient_tool_commit (GimpGradientTool *gradient_tool) { GimpTool *tool = GIMP_TOOL (gradient_tool); if (gradient_tool->filter) { /* halt the editor before committing the filter so that the image-flush * idle source is removed, to avoid flushing the image, and hence * restarting the projection rendering, while applying the filter. */ gimp_gradient_tool_editor_halt (gradient_tool); gimp_tool_control_push_preserve (tool->control, TRUE); gimp_drawable_filter_commit (gradient_tool->filter, GIMP_PROGRESS (tool), FALSE); g_clear_object (&gradient_tool->filter); gimp_tool_control_pop_preserve (tool->control); gimp_image_flush (gimp_display_get_image (tool->display)); } } static void gimp_gradient_tool_line_changed (GimpToolWidget *widget, GimpGradientTool *gradient_tool) { gdouble start_x; gdouble start_y; gdouble end_x; gdouble end_y; gboolean update = FALSE; g_object_get (widget, "x1", &start_x, "y1", &start_y, "x2", &end_x, "y2", &end_y, NULL); if (start_x != gradient_tool->start_x || start_y != gradient_tool->start_y || end_x != gradient_tool->end_x || end_y != gradient_tool->end_y) { gradient_tool->start_x = start_x; gradient_tool->start_y = start_y; gradient_tool->end_x = end_x; gradient_tool->end_y = end_y; update = TRUE; } if (gimp_gradient_tool_editor_line_changed (gradient_tool)) update = TRUE; if (update) { gimp_gradient_tool_update_graph (gradient_tool); gimp_drawable_filter_apply (gradient_tool->filter, NULL); } } static void gimp_gradient_tool_line_response (GimpToolWidget *widget, gint response_id, GimpGradientTool *gradient_tool) { GimpTool *tool = GIMP_TOOL (gradient_tool); switch (response_id) { case GIMP_TOOL_WIDGET_RESPONSE_CONFIRM: gimp_tool_control (tool, GIMP_TOOL_ACTION_COMMIT, tool->display); break; case GIMP_TOOL_WIDGET_RESPONSE_CANCEL: gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, tool->display); break; } } static void gimp_gradient_tool_precalc_shapeburst (GimpGradientTool *gradient_tool) { GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); GimpTool *tool = GIMP_TOOL (gradient_tool); gint x, y, width, height; if (gradient_tool->dist_buffer || ! tool->drawable) return; if (! gimp_item_mask_intersect (GIMP_ITEM (tool->drawable), &x, &y, &width, &height)) return; gradient_tool->dist_buffer = gimp_drawable_gradient_shapeburst_distmap (tool->drawable, options->distance_metric, GEGL_RECTANGLE (x, y, width, height), GIMP_PROGRESS (gradient_tool)); if (gradient_tool->dist_node) gegl_node_set (gradient_tool->dist_node, "buffer", gradient_tool->dist_buffer, NULL); gimp_progress_end (GIMP_PROGRESS (gradient_tool)); } /* gegl graph stuff */ static void gimp_gradient_tool_create_graph (GimpGradientTool *gradient_tool) { GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); GimpContext *context = GIMP_CONTEXT (options); GeglNode *output; /* render_node is not supposed to be recreated */ g_return_if_fail (gradient_tool->graph == NULL); gradient_tool->graph = gegl_node_new (); gradient_tool->dist_node = gegl_node_new_child (gradient_tool->graph, "operation", "gegl:buffer-source", "buffer", gradient_tool->dist_buffer, NULL); #if 0 gradient_tool->subtract_node = gegl_node_new_child (gradient_tool->graph, "operation", "gegl:subtract", NULL); gradient_tool->divide_node = gegl_node_new_child (gradient_tool->graph, "operation", "gegl:divide", NULL); #endif gradient_tool->render_node = gegl_node_new_child (gradient_tool->graph, "operation", "gimp:gradient", "context", context, NULL); output = gegl_node_get_output_proxy (gradient_tool->graph, "output"); gegl_node_link_many (gradient_tool->dist_node, #if 0 gradient_tool->subtract_node, gradient_tool->divide_node, #endif gradient_tool->render_node, output, NULL); gimp_gegl_node_set_underlying_operation (gradient_tool->graph, gradient_tool->render_node); gimp_gradient_tool_update_graph (gradient_tool); } static void gimp_gradient_tool_update_graph (GimpGradientTool *gradient_tool) { GimpTool *tool = GIMP_TOOL (gradient_tool); GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); gint off_x, off_y; gimp_item_get_offset (GIMP_ITEM (tool->drawable), &off_x, &off_y); #if 0 if (gimp_gradient_tool_is_shapeburst (gradient_tool)) { gfloat start, end; gegl_buffer_get (gradient_tool->dist_buffer, GEGL_RECTANGLE (gradient_tool->start_x - off_x, gradient_tool->start_y - off_y, 1, 1), 1.0, babl_format("Y float"), &start, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); gegl_buffer_get (gradient_tool->dist_buffer, GEGL_RECTANGLE (gradient_tool->end_x - off_x, gradient_tool->end_y - off_y, 1, 1), 1.0, babl_format("Y float"), &end, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); if (start != end) { gegl_node_set (gradient_tool->subtract_node, "value", (gdouble) start, NULL); gegl_node_set (gradient_tool->divide_node, "value", (gdouble) (end - start), NULL); } } else #endif { GeglRectangle roi; gdouble start_x, start_y; gdouble end_x, end_y; gimp_item_mask_intersect (GIMP_ITEM (tool->drawable), &roi.x, &roi.y, &roi.width, &roi.height); start_x = gradient_tool->start_x - off_x; start_y = gradient_tool->start_y - off_y; end_x = gradient_tool->end_x - off_x; end_y = gradient_tool->end_y - off_y; gimp_drawable_gradient_adjust_coords (tool->drawable, options->gradient_type, &roi, &start_x, &start_y, &end_x, &end_y); gegl_node_set (gradient_tool->render_node, "start-x", start_x, "start-y", start_y, "end-x", end_x, "end-y", end_y, NULL); } } static void gimp_gradient_tool_fg_bg_changed (GimpGradientTool *gradient_tool) { if (! gradient_tool->filter || ! gradient_tool->gradient) return; if (gimp_gradient_has_fg_bg_segments (gradient_tool->gradient)) { /* Set a property on the node. Otherwise it will cache and refuse to update */ gegl_node_set (gradient_tool->render_node, "gradient", gradient_tool->gradient, NULL); /* Update the filter */ gimp_drawable_filter_apply (gradient_tool->filter, NULL); gimp_gradient_tool_editor_fg_bg_changed (gradient_tool); } } static void gimp_gradient_tool_gradient_dirty (GimpGradientTool *gradient_tool) { if (! gradient_tool->filter) return; if (! gradient_tool->tentative_gradient) { /* Set a property on the node. Otherwise it will cache and refuse to update */ gegl_node_set (gradient_tool->render_node, "gradient", gradient_tool->gradient, NULL); /* Update the filter */ gimp_drawable_filter_apply (gradient_tool->filter, NULL); } gimp_gradient_tool_editor_gradient_dirty (gradient_tool); } static void gimp_gradient_tool_set_gradient (GimpGradientTool *gradient_tool, GimpGradient *gradient) { if (gradient_tool->gradient) g_signal_handlers_disconnect_by_func (gradient_tool->gradient, G_CALLBACK (gimp_gradient_tool_gradient_dirty), gradient_tool); g_set_object (&gradient_tool->gradient, gradient); if (gradient_tool->gradient) { g_signal_connect_swapped (gradient_tool->gradient, "dirty", G_CALLBACK (gimp_gradient_tool_gradient_dirty), gradient_tool); if (gradient_tool->render_node) gegl_node_set (gradient_tool->render_node, "gradient", gradient_tool->gradient, NULL); } gimp_gradient_tool_editor_gradient_changed (gradient_tool); } static gboolean gimp_gradient_tool_is_shapeburst (GimpGradientTool *gradient_tool) { GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); return options->gradient_type >= GIMP_GRADIENT_SHAPEBURST_ANGULAR && options->gradient_type <= GIMP_GRADIENT_SHAPEBURST_DIMPLED; } /* image map stuff */ static void gimp_gradient_tool_create_filter (GimpGradientTool *gradient_tool, GimpDrawable *drawable) { GimpGradientOptions *options = GIMP_GRADIENT_TOOL_GET_OPTIONS (gradient_tool); GimpContext *context = GIMP_CONTEXT (options); if (! gradient_tool->graph) gimp_gradient_tool_create_graph (gradient_tool); gradient_tool->filter = gimp_drawable_filter_new (drawable, C_("undo-type", "Gradient"), gradient_tool->graph, GIMP_ICON_TOOL_GRADIENT); gimp_drawable_filter_set_region (gradient_tool->filter, GIMP_FILTER_REGION_DRAWABLE); gimp_drawable_filter_set_opacity (gradient_tool->filter, gimp_context_get_opacity (context)); gimp_drawable_filter_set_mode (gradient_tool->filter, gimp_context_get_paint_mode (context), GIMP_LAYER_COLOR_SPACE_AUTO, GIMP_LAYER_COLOR_SPACE_AUTO, gimp_layer_mode_get_paint_composite_mode ( gimp_context_get_paint_mode (context))); g_signal_connect (gradient_tool->filter, "flush", G_CALLBACK (gimp_gradient_tool_filter_flush), gradient_tool); } static void gimp_gradient_tool_filter_flush (GimpDrawableFilter *filter, GimpTool *tool) { GimpImage *image = gimp_display_get_image (tool->display); gimp_projection_flush (gimp_image_get_projection (image)); } /* protected functions */ void gimp_gradient_tool_set_tentative_gradient (GimpGradientTool *gradient_tool, GimpGradient *gradient) { g_return_if_fail (GIMP_IS_GRADIENT_TOOL (gradient_tool)); g_return_if_fail (gradient == NULL || GIMP_IS_GRADIENT (gradient)); if (g_set_object (&gradient_tool->tentative_gradient, gradient)) { if (gradient_tool->render_node) { gegl_node_set (gradient_tool->render_node, "gradient", gradient ? gradient : gradient_tool->gradient, NULL); gimp_drawable_filter_apply (gradient_tool->filter, NULL); } } }