callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
901b0e72110bb9a87f570611c248b57c3f063004
gimp/app/tools/gimpseamlessclonetool.c
Ell 1f76013d1e app: add "clip" parameter to gimp_display_shell_untransform_viewport() 
... which specifies whether to clip the viewport to the canvas
(previously, it would always be clipped).  Use the appropriate
value in all callers, depending on the shell's "show all" mode.  In
particular, this commit avoids clipping the image projection's
priority rect to the canvas in "show all" mode.
2019-09-04 20:56:23 +03:00

846 lines
29 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
*
* gimpseamlessclonetool.c
* Copyright (C) 2011 Barak Itkin <lightningismyname@gmail.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 <gegl-plugin.h> /* gegl_operation_invalidate() */
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "tools-types.h"
#include "config/gimpguiconfig.h" /* playground */
#include "gegl/gimp-gegl-utils.h"
#include "core/gimp.h"
#include "core/gimpbuffer.h"
#include "core/gimpdrawablefilter.h"
#include "core/gimpimage.h"
#include "core/gimpitem.h"
#include "core/gimpprogress.h"
#include "core/gimpprojection.h"
#include "core/gimptoolinfo.h"
#include "widgets/gimphelp-ids.h"
#include "widgets/gimpclipboard.h"
#include "display/gimpdisplay.h"
#include "display/gimpdisplayshell.h"
#include "display/gimpdisplayshell-transform.h"
#include "gimpseamlessclonetool.h"
#include "gimpseamlesscloneoptions.h"
#include "gimptoolcontrol.h"
#include "gimp-intl.h"
#define SC_DEBUG TRUE
#ifdef SC_DEBUG
#define sc_debug_fstart() g_debug ("%s::start", __FUNCTION__);
#define sc_debug_fend() g_debug ("%s::end", __FUNCTION__);
#else
#define sc_debug_fstart()
#define sc_debug_fend()
#endif
#define gimp_seamless_clone_tool_is_in_paste(sc,x0,y0) \
( ((sc)->xoff <= (x0) && (x0) < (sc)->xoff + (sc)->width) \
&& ((sc)->yoff <= (y0) && (y0) < (sc)->yoff + (sc)->height)) \
#define gimp_seamless_clone_tool_is_in_paste_c(sc,coords) \
gimp_seamless_clone_tool_is_in_paste((sc),(coords)->x,(coords)->y)
/* init ----------> preprocess
* | |
* | |
* | |
* | v
* | render(wait, motion)
* | / |
* | _____/ |
* | _____/ |
* v v v
* quit <---------- commit
*
* Begin at INIT state
*
* INIT: Wait for click on canvas
* have a paste ? -> PREPROCESS : -> QUIT
*
* PREPROCESS: Do the preprocessing
* -> RENDER
*
* RENDER: Interact and wait for quit signal
* commit quit ? -> COMMIT : -> QUIT
*
* COMMIT: Commit the changes
* -> QUIT
*
* QUIT: Invoked by sending a ACTION_HALT to the tool_control
* Free resources
*/
enum
{
SC_STATE_INIT,
SC_STATE_PREPROCESS,
SC_STATE_RENDER_WAIT,
SC_STATE_RENDER_MOTION,
SC_STATE_COMMIT,
SC_STATE_QUIT
};
static void gimp_seamless_clone_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display);
static void gimp_seamless_clone_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display);
static void gimp_seamless_clone_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display);
static void gimp_seamless_clone_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display);
static gboolean gimp_seamless_clone_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display);
static void gimp_seamless_clone_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display);
static void gimp_seamless_clone_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display);
static void gimp_seamless_clone_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec);
static void gimp_seamless_clone_tool_draw (GimpDrawTool *draw_tool);
static void gimp_seamless_clone_tool_start (GimpSeamlessCloneTool *sc,
GimpDisplay *display);
static void gimp_seamless_clone_tool_stop (GimpSeamlessCloneTool *sc,
gboolean display_change_only);
static void gimp_seamless_clone_tool_commit (GimpSeamlessCloneTool *sc);
static void gimp_seamless_clone_tool_create_render_node (GimpSeamlessCloneTool *sc);
static gboolean gimp_seamless_clone_tool_render_node_update (GimpSeamlessCloneTool *sc);
static void gimp_seamless_clone_tool_create_filter (GimpSeamlessCloneTool *sc,
GimpDrawable *drawable);
static void gimp_seamless_clone_tool_filter_flush (GimpDrawableFilter *filter,
GimpTool *tool);
static void gimp_seamless_clone_tool_filter_update (GimpSeamlessCloneTool *sc);
G_DEFINE_TYPE (GimpSeamlessCloneTool, gimp_seamless_clone_tool,
GIMP_TYPE_DRAW_TOOL)
#define parent_class gimp_seamless_clone_tool_parent_class
void
gimp_seamless_clone_tool_register (GimpToolRegisterCallback callback,
gpointer data)
{
/* we should not know that "data" is a Gimp*, but what the heck this
* is experimental playground stuff
*/
if (GIMP_GUI_CONFIG (GIMP (data)->config)->playground_seamless_clone_tool)
(* callback) (GIMP_TYPE_SEAMLESS_CLONE_TOOL,
GIMP_TYPE_SEAMLESS_CLONE_OPTIONS,
gimp_seamless_clone_options_gui,
0,
"gimp-seamless-clone-tool",
_("Seamless Clone"),
_("Seamless Clone: Seamlessly paste one image into another"),
N_("_Seamless Clone"), NULL,
NULL, GIMP_HELP_TOOL_SEAMLESS_CLONE,
GIMP_ICON_TOOL_SEAMLESS_CLONE,
data);
}
static void
gimp_seamless_clone_tool_class_init (GimpSeamlessCloneToolClass *klass)
{
GimpToolClass *tool_class = GIMP_TOOL_CLASS (klass);
GimpDrawToolClass *draw_tool_class = GIMP_DRAW_TOOL_CLASS (klass);
tool_class->control = gimp_seamless_clone_tool_control;
tool_class->button_press = gimp_seamless_clone_tool_button_press;
tool_class->button_release = gimp_seamless_clone_tool_button_release;
tool_class->motion = gimp_seamless_clone_tool_motion;
tool_class->key_press = gimp_seamless_clone_tool_key_press;
tool_class->oper_update = gimp_seamless_clone_tool_oper_update;
tool_class->cursor_update = gimp_seamless_clone_tool_cursor_update;
tool_class->options_notify = gimp_seamless_clone_tool_options_notify;
draw_tool_class->draw = gimp_seamless_clone_tool_draw;
}
static void
gimp_seamless_clone_tool_init (GimpSeamlessCloneTool *self)
{
GimpTool *tool = GIMP_TOOL (self);
gimp_tool_control_set_dirty_mask (tool->control,
GIMP_DIRTY_IMAGE |
GIMP_DIRTY_IMAGE_STRUCTURE |
GIMP_DIRTY_DRAWABLE |
GIMP_DIRTY_SELECTION);
gimp_tool_control_set_tool_cursor (tool->control,
GIMP_TOOL_CURSOR_MOVE);
self->tool_state = SC_STATE_INIT;
}
static void
gimp_seamless_clone_tool_control (GimpTool *tool,
GimpToolAction action,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
switch (action)
{
case GIMP_TOOL_ACTION_PAUSE:
case GIMP_TOOL_ACTION_RESUME:
break;
case GIMP_TOOL_ACTION_HALT:
if (tool->display)
gimp_seamless_clone_tool_stop (sc, FALSE);
/* TODO: If we have any tool options that should be reset, here is
* a good place to do so.
*/
break;
case GIMP_TOOL_ACTION_COMMIT:
gimp_seamless_clone_tool_commit (sc);
break;
}
GIMP_TOOL_CLASS (parent_class)->control (tool, action, display);
}
/**
* gimp_seamless_clone_tool_start:
* @sc: The GimpSeamlessCloneTool to initialize for usage on the given
* display
* @display: The display to initialize the tool for
*
* A utility function to initialize a tool for working on a given
* display. At the beginning of each function, we can check if the event's
* display is the same as the tool's one, and if not call this. This is
* not required by the gimptool interface or anything like that, but
* this is a convenient way to do all the initialization work in one
* place, and this is how the base class (GimpDrawTool) does that
*/
static void
gimp_seamless_clone_tool_start (GimpSeamlessCloneTool *sc,
GimpDisplay *display)
{
GimpTool *tool = GIMP_TOOL (sc);
GimpImage *image = gimp_display_get_image (display);
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
/* First handle the paste - we need to make sure we have one in order
* to do anything else.
*/
if (sc->paste == NULL)
{
GimpBuffer *buffer = gimp_clipboard_get_buffer (tool->tool_info->gimp);
if (! buffer)
{
gimp_tool_push_status (tool, display,
"%s",
_("There is no image data in the clipboard to paste."));
return;
}
sc->paste = gimp_gegl_buffer_dup (gimp_buffer_get_buffer (buffer));
g_object_unref (buffer);
sc->width = gegl_buffer_get_width (sc->paste);
sc->height = gegl_buffer_get_height (sc->paste);
}
/* Free resources which are relevant only for the previous display */
gimp_seamless_clone_tool_stop (sc, TRUE);
tool->display = display;
gimp_seamless_clone_tool_create_filter (sc, drawable);
gimp_draw_tool_start (GIMP_DRAW_TOOL (sc), display);
sc->tool_state = SC_STATE_RENDER_WAIT;
}
/**
* gimp_seamless_clone_tool_stop:
* @sc: The seamless clone tool whose resources should be freed
* @display_change_only: Mark that the only reason for this call was a
* switch of the working display.
*
* This function frees any resources associated with the seamless clone
* tool, including caches, gegl graphs, and anything the tool created.
* Afterwards, it initializes all the relevant pointers to some initial
* value (usually NULL) like the init function does.
*
* Note that for seamless cloning, no change needs to be done when
* switching to a different display, except for clearing the image map.
* So for that, we provide a boolean parameter to specify that the only
* change was one of the display
*/
static void
gimp_seamless_clone_tool_stop (GimpSeamlessCloneTool *sc,
gboolean display_change_only)
{
/* See if we actually have any reason to stop */
if (sc->tool_state == SC_STATE_INIT)
return;
if (! display_change_only)
{
sc->tool_state = SC_STATE_INIT;
g_clear_object (&sc->paste);
g_clear_object (&sc->render_node);
sc->sc_node = NULL;
}
/* This should always happen, even when we just switch a display */
if (sc->filter)
{
gimp_drawable_filter_abort (sc->filter);
g_clear_object (&sc->filter);
if (GIMP_TOOL (sc)->display)
gimp_image_flush (gimp_display_get_image (GIMP_TOOL (sc)->display));
}
gimp_draw_tool_stop (GIMP_DRAW_TOOL (sc));
}
static void
gimp_seamless_clone_tool_commit (GimpSeamlessCloneTool *sc)
{
GimpTool *tool = GIMP_TOOL (sc);
if (sc->filter)
{
gimp_tool_control_push_preserve (tool->control, TRUE);
gimp_drawable_filter_commit (sc->filter, GIMP_PROGRESS (tool), FALSE);
g_clear_object (&sc->filter);
gimp_tool_control_pop_preserve (tool->control);
gimp_image_flush (gimp_display_get_image (tool->display));
}
}
static void
gimp_seamless_clone_tool_button_press (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonPressType press_type,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
if (display != tool->display)
{
gimp_seamless_clone_tool_start (sc, display);
/* Center the paste on the mouse */
sc->xoff = (gint) coords->x - sc->width / 2;
sc->yoff = (gint) coords->y - sc->height / 2;
}
if (sc->tool_state == SC_STATE_RENDER_WAIT &&
gimp_seamless_clone_tool_is_in_paste_c (sc, coords))
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (sc));
/* Record previous location, in case the user cancels the
* movement
*/
sc->xoff_p = sc->xoff;
sc->yoff_p = sc->yoff;
/* Record the mouse location, so that the dragging offset can be
* calculated
*/
sc->xclick = coords->x;
sc->yclick = coords->y;
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
if (gimp_seamless_clone_tool_render_node_update (sc))
{
gimp_seamless_clone_tool_filter_update (sc);
}
sc->tool_state = SC_STATE_RENDER_MOTION;
/* In order to receive motion events from the current click, we must
* activate the tool control
*/
gimp_tool_control_activate (tool->control);
}
}
void
gimp_seamless_clone_tool_button_release (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpButtonReleaseType release_type,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
gimp_tool_control_halt (tool->control);
/* There is nothing to do, unless we were actually moving a paste */
if (sc->tool_state == SC_STATE_RENDER_MOTION)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (sc));
if (release_type == GIMP_BUTTON_RELEASE_CANCEL)
{
sc->xoff = sc->xoff_p;
sc->yoff = sc->yoff_p;
}
else
{
sc->xoff = sc->xoff_p + (gint) (coords->x - sc->xclick);
sc->yoff = sc->yoff_p + (gint) (coords->y - sc->yclick);
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
if (gimp_seamless_clone_tool_render_node_update (sc))
{
gimp_seamless_clone_tool_filter_update (sc);
}
sc->tool_state = SC_STATE_RENDER_WAIT;
}
}
static void
gimp_seamless_clone_tool_motion (GimpTool *tool,
const GimpCoords *coords,
guint32 time,
GdkModifierType state,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
if (sc->tool_state == SC_STATE_RENDER_MOTION)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (sc));
sc->xoff = sc->xoff_p + (gint) (coords->x - sc->xclick);
sc->yoff = sc->yoff_p + (gint) (coords->y - sc->yclick);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
if (gimp_seamless_clone_tool_render_node_update (sc))
{
gimp_seamless_clone_tool_filter_update (sc);
}
}
}
static gboolean
gimp_seamless_clone_tool_key_press (GimpTool *tool,
GdkEventKey *kevent,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sct = GIMP_SEAMLESS_CLONE_TOOL (tool);
if (sct->tool_state == SC_STATE_RENDER_MOTION ||
sct->tool_state == SC_STATE_RENDER_WAIT)
{
switch (kevent->keyval)
{
case GDK_KEY_Return:
case GDK_KEY_KP_Enter:
case GDK_KEY_ISO_Enter:
gimp_tool_control_set_preserve (tool->control, TRUE);
/* TODO: there may be issues with committing the image map
* result after some changes were made and the preview
* was scrolled. We can fix these by either invalidating
* the area which is a union of the previous paste
* rectangle each time (in the update function) or by
* invalidating and re-rendering all now (expensive and
* perhaps useless */
gimp_drawable_filter_commit (sct->filter, GIMP_PROGRESS (tool), FALSE);
g_clear_object (&sct->filter);
gimp_tool_control_set_preserve (tool->control, FALSE);
gimp_image_flush (gimp_display_get_image (display));
gimp_seamless_clone_tool_control (tool, GIMP_TOOL_ACTION_HALT,
display);
return TRUE;
case GDK_KEY_Escape:
gimp_seamless_clone_tool_control (tool, GIMP_TOOL_ACTION_HALT,
display);
return TRUE;
default:
break;
}
}
return FALSE;
}
static void
gimp_seamless_clone_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
/* TODO: Modify data here */
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
/* Mouse cursor policy:
* - Always use the move cursor
* - While dragging the paste, use a move modified
* - Else, While hovering above it, display no modifier
* - Else, display a "bad" modifier
*/
static void
gimp_seamless_clone_tool_cursor_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
GimpDisplay *display)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
GimpCursorModifier modifier = GIMP_CURSOR_MODIFIER_BAD;
/* Only update if the tool is actually active on some display */
if (tool->display)
{
if (sc->tool_state == SC_STATE_RENDER_MOTION)
{
modifier = GIMP_CURSOR_MODIFIER_MOVE;
}
else if (sc->tool_state == SC_STATE_RENDER_WAIT &&
gimp_seamless_clone_tool_is_in_paste_c (sc, coords))
{
modifier = GIMP_CURSOR_MODIFIER_NONE;
}
gimp_tool_control_set_cursor_modifier (tool->control, modifier);
}
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state, display);
}
static void
gimp_seamless_clone_tool_options_notify (GimpTool *tool,
GimpToolOptions *options,
const GParamSpec *pspec)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (tool);
GIMP_TOOL_CLASS (parent_class)->options_notify (tool, options, pspec);
if (! tool->display)
return;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
if (! strcmp (pspec->name, "max-refine-scale"))
{
if (gimp_seamless_clone_tool_render_node_update (sc))
{
gimp_seamless_clone_tool_filter_update (sc);
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
static void
gimp_seamless_clone_tool_draw (GimpDrawTool *draw_tool)
{
GimpSeamlessCloneTool *sc = GIMP_SEAMLESS_CLONE_TOOL (draw_tool);
if (sc->tool_state == SC_STATE_RENDER_WAIT ||
sc->tool_state == SC_STATE_RENDER_MOTION)
{
gimp_draw_tool_add_rectangle (draw_tool, FALSE,
sc->xoff, sc->yoff, sc->width, sc->height);
}
}
/**
* gimp_seamless_clone_tool_create_render_node:
* @sc: The GimpSeamlessCloneTool to initialize
*
* This function creates a Gegl node graph of the composition which is
* needed to render the drawable. The graph should have an "input" pad
* which will receive the drawable on which the preview is applied, and
* it should also have an "output" pad to which the final result will be
* rendered
*/
static void
gimp_seamless_clone_tool_create_render_node (GimpSeamlessCloneTool *sc)
{
/* Here is a textual description of the graph we are going to create:
*
* <input> <- drawable
* +--+--------------------------+
* | |output |
* | | |
* | | <buffer-source> <- paste |
* | | |output |
* | | | |
* | |input |aux |
* |<seamless-paste-render> |
* | |output |
* | | |
* | |input |
* +----+------------------------+
* <output>
*/
GimpSeamlessCloneOptions *options = GIMP_SEAMLESS_CLONE_TOOL_GET_OPTIONS (sc);
GeglNode *node;
GeglNode *op, *paste, *overlay;
GeglNode *input, *output;
node = gegl_node_new ();
input = gegl_node_get_input_proxy (node, "input");
output = gegl_node_get_output_proxy (node, "output");
paste = gegl_node_new_child (node,
"operation", "gegl:buffer-source",
"buffer", sc->paste,
NULL);
op = gegl_node_new_child (node,
"operation", "gegl:seamless-clone",
"max-refine-scale", options->max_refine_scale,
NULL);
overlay = gegl_node_new_child (node,
"operation", "svg:dst-over",
NULL);
gegl_node_connect_to (input, "output",
op, "input");
gegl_node_connect_to (paste, "output",
op, "aux");
gegl_node_connect_to (op, "output",
overlay, "input");
gegl_node_connect_to (input, "output",
overlay, "aux");
gegl_node_connect_to (overlay, "output",
output, "input");
sc->render_node = node;
sc->sc_node = op;
}
/* gimp_seamless_clone_tool_render_node_update:
* sc: the Seamless Clone tool whose render has to be updated.
*
* Returns: TRUE if any property changed.
*/
static gboolean
gimp_seamless_clone_tool_render_node_update (GimpSeamlessCloneTool *sc)
{
static gint rendered__max_refine_scale = -1;
static gint rendered_xoff = G_MAXINT;
static gint rendered_yoff = G_MAXINT;
GimpSeamlessCloneOptions *options = GIMP_SEAMLESS_CLONE_TOOL_GET_OPTIONS (sc);
GimpDrawable *bg = GIMP_TOOL (sc)->drawable;
gint off_x, off_y;
/* All properties stay the same. No need to update. */
if (rendered__max_refine_scale == options->max_refine_scale &&
rendered_xoff == sc->xoff &&
rendered_yoff == sc->yoff)
return FALSE;
gimp_item_get_offset (GIMP_ITEM (bg), &off_x, &off_y);
gegl_node_set (sc->sc_node,
"xoff", (gint) sc->xoff - off_x,
"yoff", (gint) sc->yoff - off_y,
"max-refine-scale", (gint) options->max_refine_scale,
NULL);
rendered__max_refine_scale = options->max_refine_scale;
rendered_xoff = sc->xoff;
rendered_yoff = sc->yoff;
return TRUE;
}
static void
gimp_seamless_clone_tool_create_filter (GimpSeamlessCloneTool *sc,
GimpDrawable *drawable)
{
if (! sc->render_node)
gimp_seamless_clone_tool_create_render_node (sc);
sc->filter = gimp_drawable_filter_new (drawable,
_("Seamless Clone"),
sc->render_node,
GIMP_ICON_TOOL_SEAMLESS_CLONE);
gimp_drawable_filter_set_region (sc->filter, GIMP_FILTER_REGION_DRAWABLE);
g_signal_connect (sc->filter, "flush",
G_CALLBACK (gimp_seamless_clone_tool_filter_flush),
sc);
}
static void
gimp_seamless_clone_tool_filter_flush (GimpDrawableFilter *filter,
GimpTool *tool)
{
GimpImage *image = gimp_display_get_image (tool->display);
gimp_projection_flush (gimp_image_get_projection (image));
}
static void
gimp_seamless_clone_tool_filter_update (GimpSeamlessCloneTool *sc)
{
GimpTool *tool = GIMP_TOOL (sc);
GimpDisplayShell *shell = gimp_display_get_shell (tool->display);
GimpItem *item = GIMP_ITEM (tool->drawable);
gint x, y;
gint w, h;
gint off_x, off_y;
GeglRectangle visible;
GeglOperation *op = NULL;
GimpProgress *progress;
GeglNode *output;
GeglProcessor *processor;
gdouble value;
progress = gimp_progress_start (GIMP_PROGRESS (sc), FALSE,
_("Cloning the foreground object"));
/* Find out at which x,y is the top left corner of the currently
* displayed part */
gimp_display_shell_untransform_viewport (shell, ! shell->show_all,
&x, &y, &w, &h);
/* Find out where is our drawable positioned */
gimp_item_get_offset (item, &off_x, &off_y);
/* Create a rectangle from the intersection of the currently displayed
* part with the drawable */
gimp_rectangle_intersect (x, y, w, h,
off_x,
off_y,
gimp_item_get_width (item),
gimp_item_get_height (item),
&visible.x,
&visible.y,
&visible.width,
&visible.height);
/* Since the filter_apply function receives a rectangle describing
* where it should update the preview, and since that rectangle should
* be relative to the drawable's location, we now offset back by the
* drawable's offsetts. */
visible.x -= off_x;
visible.y -= off_y;
g_object_get (sc->sc_node, "gegl-operation", &op, NULL);
/* If any cache of the visible area was present, clear it!
* We need to clear the cache in the sc_node, since that is
* where the previous paste was located
*/
gegl_operation_invalidate (op, &visible, TRUE);
g_object_unref (op);
/* Now update the image map and show this area */
gimp_drawable_filter_apply (sc->filter, NULL);
/* Show update progress. */
output = gegl_node_get_output_proxy (sc->render_node, "output");
processor = gegl_node_new_processor (output, NULL);
while (gegl_processor_work (processor, &value))
{
if (progress)
gimp_progress_set_value (progress, value);
}
if (progress)
gimp_progress_end (progress);
g_object_unref (processor);
}
Reference in New Issue View Git Blame Copy Permalink