static void
path_changed (GeglPath *path,
const GeglRectangle *roi,
GeglOperation *operation)
{
GeglRectangle rect;
GeglProperties *o = GEGL_PROPERTIES (operation);
WarpPrivate *priv = (WarpPrivate *) o->user_data;
/* mark the processed stroke as invalid, so that we recheck it against the
* new path upon the next call to process().
*/
if (priv)
priv->processed_stroke_valid = FALSE;
/* invalidate the incoming rectangle */
rect.x = floor (roi->x - o->size/2);
rect.y = floor (roi->y - o->size/2);
rect.width = ceil (roi->x + roi->width + o->size/2) - rect.x;
rect.height = ceil (roi->y + roi->height + o->size/2) - rect.y;
/* we don't want to clear the cached data right away; we potentially do this
* in process(), if the cached path is not an initial segment of the new
* path. block our INVALIDATED handler so that the cache isn't cleared.
*/
g_signal_handlers_block_by_func (operation->node,
node_invalidated, operation);
gegl_operation_invalidate (operation, &rect, FALSE);
g_signal_handlers_unblock_by_func (operation->node,
node_invalidated, operation);
}
static void
gimp_n_point_deformation_tool_perform_deformation (GimpNPointDeformationTool *npd_tool)
{
GObject *operation;
g_object_get (npd_tool->npd_node,
"gegl-operation", &operation,
NULL);
gimp_npd_debug (("gegl_operation_invalidate\n"));
gegl_operation_invalidate (GEGL_OPERATION (operation), NULL, FALSE);
g_object_unref (operation);
gimp_npd_debug (("gegl_node_process\n"));
gegl_node_process (npd_tool->sink);
}
static void path_changed (GeglPath *path,
const GeglRectangle *roi,
gpointer userdata)
{
GeglRectangle rect = *roi;
GeglChantO *o = GEGL_CHANT_PROPERTIES (userdata);
/* invalidate the incoming rectangle */
rect.x -= o->width/2;
rect.y -= o->width/2;
rect.width += o->width;
rect.height += o->width;
gegl_operation_invalidate (userdata, &rect, FALSE);
};
static void path_changed (GeglPath *path,
const GeglRectangle *roi,
gpointer userdata)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (userdata);
GeglRectangle rect;
gdouble x0, x1, y0, y1;
gegl_path_get_bounds(o->d, &x0, &x1, &y0, &y1);
rect.x = x0 - 1;
rect.y = y0 - 1;
rect.width = x1 - x0 + 2;
rect.height = y1 - y0 + 2;
gegl_operation_invalidate (userdata, &rect, TRUE);
};
static void buffer_changed (GeglBuffer *buffer,
const GeglRectangle *rect,
gpointer userdata)
{
gegl_operation_invalidate (GEGL_OPERATION (userdata), rect, FALSE);
}
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, &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);
}
static gboolean update (gpointer operation)
{
GeglRectangle bounds = gegl_operation_get_bounding_box (operation);
gegl_operation_invalidate (operation, &bounds, FALSE);
return TRUE;
}
