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; }