diff options
Diffstat (limited to '')
| -rw-r--r-- | app/tools/gimpgradienttool.c | 1106 |
1 files changed, 1106 insertions, 0 deletions
diff --git a/app/tools/gimpgradienttool.c b/app/tools/gimpgradienttool.c new file mode 100644 index 0000000..598f804 --- /dev/null +++ b/app/tools/gimpgradienttool.c @@ -0,0 +1,1106 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * Major improvements for interactivity + * Copyright (C) 2014 Michael Henning <drawoc@darkrefraction.com> + * + * 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 <gegl.h> +#include <gtk/gtk.h> +#include <gdk/gdkkeysyms.h> + +#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); + } + } +} |