Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 845 insertions, 0 deletions

diff --git a/app/tools/gimpseamlessclonetool.c b/app/tools/gimpseamlessclonetool.c
new file mode 100644
index 0000000..79a9780
--- /dev/null
+++ b/app/tools/gimpseamlessclonetool.c
@@ -0,0 +1,845 @@
+/* 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);
+}