static void
gimp_clone_options_notify (GObject *object,
GParamSpec *pspec)
{
if (G_OBJECT_CLASS (parent_class)->notify)
G_OBJECT_CLASS (parent_class)->notify (object, pspec);
if (! strcmp ("clone-type", g_param_spec_get_name (pspec)))
GIMP_SOURCE_OPTIONS (object)->use_source =
(GIMP_CLONE_OPTIONS (object)->clone_type == GIMP_IMAGE_CLONE);
}
static gboolean
gimp_source_core_start (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GError **error)
{
GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
if (! GIMP_PAINT_CORE_CLASS (parent_class)->start (paint_core, drawable,
paint_options, coords,
error))
{
return FALSE;
}
paint_core->use_saved_proj = FALSE;
if (! source_core->set_source &&
gimp_source_core_use_source (source_core, options))
{
if (! source_core->src_drawable)
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Set a source image first."));
return FALSE;
}
if (options->sample_merged &&
gimp_item_get_image (GIMP_ITEM (source_core->src_drawable)) ==
gimp_item_get_image (GIMP_ITEM (drawable)))
{
paint_core->use_saved_proj = TRUE;
}
}
return TRUE;
}
static GeglBuffer *
gimp_source_core_real_get_source (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpPickable *src_pickable,
gint src_offset_x,
gint src_offset_y,
GeglBuffer *paint_buffer,
gint paint_buffer_x,
gint paint_buffer_y,
gint *paint_area_offset_x,
gint *paint_area_offset_y,
gint *paint_area_width,
gint *paint_area_height,
GeglRectangle *src_rect)
{
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
GeglBuffer *src_buffer = gimp_pickable_get_buffer (src_pickable);
GeglBuffer *dest_buffer;
gint x, y;
gint width, height;
if (! gimp_rectangle_intersect (paint_buffer_x + src_offset_x,
paint_buffer_y + src_offset_y,
gegl_buffer_get_width (paint_buffer),
gegl_buffer_get_height (paint_buffer),
0, 0,
gegl_buffer_get_width (src_buffer),
gegl_buffer_get_height (src_buffer),
&x, &y,
&width, &height))
{
return FALSE;
}
/* If the source image is different from the destination,
* then we should copy straight from the source image
* to the canvas.
* Otherwise, we need a call to get_orig_image to make sure
* we get a copy of the unblemished (offset) image
*/
if (( options->sample_merged && (src_image != image)) ||
(! options->sample_merged && (source_core->src_drawable != drawable)))
{
dest_buffer = src_buffer;
}
else
{
/* get the original image */
if (options->sample_merged)
dest_buffer = gimp_paint_core_get_orig_proj (GIMP_PAINT_CORE (source_core));
else
dest_buffer = gimp_paint_core_get_orig_image (GIMP_PAINT_CORE (source_core));
}
*paint_area_offset_x = x - (paint_buffer_x + src_offset_x);
*paint_area_offset_y = y - (paint_buffer_y + src_offset_y);
*paint_area_width = width;
*paint_area_height = height;
*src_rect = *GEGL_RECTANGLE (x, y, width, height);
return g_object_ref (dest_buffer);
}
void
gimp_source_core_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpSymmetry *sym)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpDynamics *dynamics = GIMP_BRUSH_CORE (paint_core)->dynamics;
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpPickable *src_pickable = NULL;
GeglBuffer *src_buffer = NULL;
GeglRectangle src_rect;
gint base_src_offset_x;
gint base_src_offset_y;
gint src_offset_x;
gint src_offset_y;
GeglBuffer *paint_buffer;
gint paint_buffer_x;
gint paint_buffer_y;
gint paint_area_offset_x;
gint paint_area_offset_y;
gint paint_area_width;
gint paint_area_height;
gdouble fade_point;
gdouble opacity;
GeglNode *op;
GimpCoords *origin;
GimpCoords *coords;
gint n_strokes;
gint i;
fade_point = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
origin = gimp_symmetry_get_origin (sym);
/* Some settings are based on the original stroke. */
opacity = gimp_dynamics_get_linear_value (dynamics,
GIMP_DYNAMICS_OUTPUT_OPACITY,
origin,
paint_options,
fade_point);
if (opacity == 0.0)
return;
base_src_offset_x = source_core->offset_x;
base_src_offset_y = source_core->offset_y;
if (gimp_source_core_use_source (source_core, options))
{
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
if (options->sample_merged)
{
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
gint off_x, off_y;
src_pickable = GIMP_PICKABLE (src_image);
gimp_item_get_offset (GIMP_ITEM (source_core->src_drawable),
&off_x, &off_y);
base_src_offset_x += off_x;
base_src_offset_y += off_y;
}
gimp_pickable_flush (src_pickable);
}
gimp_brush_core_eval_transform_dynamics (GIMP_BRUSH_CORE (paint_core),
drawable,
paint_options,
origin);
n_strokes = gimp_symmetry_get_size (sym);
for (i = 0; i < n_strokes; i++)
{
coords = gimp_symmetry_get_coords (sym, i);
paint_buffer = gimp_paint_core_get_paint_buffer (paint_core, drawable,
paint_options, coords,
&paint_buffer_x,
&paint_buffer_y,
NULL, NULL);
if (! paint_buffer)
continue;
paint_area_offset_x = 0;
paint_area_offset_y = 0;
paint_area_width = gegl_buffer_get_width (paint_buffer);
paint_area_height = gegl_buffer_get_height (paint_buffer);
src_offset_x = base_src_offset_x;
src_offset_y = base_src_offset_y;
if (gimp_source_core_use_source (source_core, options))
{
/* When using a source, use the same for every stroke. */
src_offset_x = src_offset_x - coords->x + origin->x;
src_offset_y = src_offset_y - coords->y + origin->y;
src_buffer =
GIMP_SOURCE_CORE_GET_CLASS (source_core)->get_source (source_core,
drawable,
paint_options,
src_pickable,
src_offset_x,
src_offset_y,
paint_buffer,
paint_buffer_x,
paint_buffer_y,
&paint_area_offset_x,
&paint_area_offset_y,
&paint_area_width,
&paint_area_height,
&src_rect);
if (! src_buffer)
continue;
}
/* Set the paint buffer to transparent */
gegl_buffer_clear (paint_buffer, NULL);
op = gimp_symmetry_get_operation (sym, i,
gegl_buffer_get_width (paint_buffer),
gegl_buffer_get_height (paint_buffer));
GIMP_SOURCE_CORE_GET_CLASS (source_core)->motion (source_core,
drawable,
paint_options,
coords,
op,
opacity,
src_pickable,
src_buffer,
&src_rect,
src_offset_x,
src_offset_y,
paint_buffer,
paint_buffer_x,
paint_buffer_y,
paint_area_offset_x,
paint_area_offset_y,
paint_area_width,
paint_area_height);
if (src_buffer)
g_object_unref (src_buffer);
}
}
static void
gimp_source_core_paint (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpSymmetry *sym,
GimpPaintState paint_state,
guint32 time)
{
GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
const GimpCoords *coords;
/* The source is based on the original stroke */
coords = gimp_symmetry_get_origin (sym);
switch (paint_state)
{
case GIMP_PAINT_STATE_INIT:
if (source_core->set_source)
{
gimp_source_core_set_src_drawable (source_core, drawable);
source_core->src_x = coords->x;
source_core->src_y = coords->y;
source_core->first_stroke = TRUE;
}
else if (options->align_mode == GIMP_SOURCE_ALIGN_NO)
{
source_core->orig_src_x = source_core->src_x;
source_core->orig_src_y = source_core->src_y;
source_core->first_stroke = TRUE;
}
break;
case GIMP_PAINT_STATE_MOTION:
if (source_core->set_source)
{
/* If the control key is down, move the src target and return */
source_core->src_x = coords->x;
source_core->src_y = coords->y;
source_core->first_stroke = TRUE;
}
else
{
/* otherwise, update the target */
gint dest_x;
gint dest_y;
dest_x = coords->x;
dest_y = coords->y;
if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED)
{
source_core->offset_x = 0;
source_core->offset_y = 0;
}
else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
}
else if (source_core->first_stroke)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
source_core->first_stroke = FALSE;
}
source_core->src_x = dest_x + source_core->offset_x;
source_core->src_y = dest_y + source_core->offset_y;
gimp_source_core_motion (source_core, drawable, paint_options,
sym);
}
break;
case GIMP_PAINT_STATE_FINISH:
if (options->align_mode == GIMP_SOURCE_ALIGN_NO &&
! source_core->first_stroke)
{
source_core->src_x = source_core->orig_src_x;
source_core->src_y = source_core->orig_src_y;
}
break;
default:
break;
}
g_object_notify (G_OBJECT (source_core), "src-x");
g_object_notify (G_OBJECT (source_core), "src-y");
}
static void
gimp_clone_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
gdouble opacity,
GimpPickable *src_pickable,
PixelRegion *srcPR,
gint src_offset_x,
gint src_offset_y,
TempBuf *paint_area,
gint paint_area_offset_x,
gint paint_area_offset_y,
gint paint_area_width,
gint paint_area_height)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpCloneOptions *options = GIMP_CLONE_OPTIONS (paint_options);
GimpSourceOptions *source_options = GIMP_SOURCE_OPTIONS (paint_options);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpImage *src_image = NULL;
GimpDynamicsOutput *force_output;
GimpImageType src_type = 0;
GimpImageType dest_type;
gpointer pr = NULL;
gint y;
PixelRegion destPR;
GimpPattern *pattern = NULL;
gdouble fade_point;
gdouble force;
switch (options->clone_type)
{
case GIMP_IMAGE_CLONE:
src_image = gimp_pickable_get_image (src_pickable);
src_type = gimp_pickable_get_image_type (src_pickable);
if (gimp_pickable_get_bytes (src_pickable) < srcPR->bytes)
src_type = GIMP_IMAGE_TYPE_WITH_ALPHA (src_type);
pixel_region_init_temp_buf (&destPR, paint_area,
paint_area_offset_x, paint_area_offset_y,
paint_area_width, paint_area_height);
pr = pixel_regions_register (2, srcPR, &destPR);
break;
case GIMP_PATTERN_CLONE:
pattern = gimp_context_get_pattern (context);
pixel_region_init_temp_buf (&destPR, paint_area,
0, 0,
paint_area->width, paint_area->height);
pr = pixel_regions_register (1, &destPR);
break;
}
dest_type = gimp_drawable_type (drawable);
for (; pr != NULL; pr = pixel_regions_process (pr))
{
guchar *s = srcPR->data;
guchar *d = destPR.data;
for (y = 0; y < destPR.h; y++)
{
switch (options->clone_type)
{
case GIMP_IMAGE_CLONE:
gimp_clone_line_image (image, dest_type,
src_image, src_type,
s, d,
srcPR->bytes, destPR.bytes, destPR.w);
s += srcPR->rowstride;
break;
case GIMP_PATTERN_CLONE:
gimp_clone_line_pattern (image, dest_type,
pattern, d,
paint_area->x + src_offset_x,
paint_area->y + y + src_offset_y,
destPR.bytes, destPR.w);
break;
}
d += destPR.rowstride;
}
}
force_output = gimp_dynamics_get_output (GIMP_BRUSH_CORE (paint_core)->dynamics,
GIMP_DYNAMICS_OUTPUT_FORCE);
fade_point = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
force = gimp_dynamics_output_get_linear_value (force_output,
coords,
paint_options,
fade_point);
gimp_brush_core_paste_canvas (GIMP_BRUSH_CORE (paint_core), drawable,
coords,
MIN (opacity, GIMP_OPACITY_OPAQUE),
gimp_context_get_opacity (context),
gimp_context_get_paint_mode (context),
gimp_paint_options_get_brush_mode (paint_options),
force,
/* In fixed mode, paint incremental so the
* individual brushes are properly applied
* on top of each other.
* Otherwise the stuff we paint is seamless
* and we don't need intermediate masking.
*/
source_options->align_mode ==
GIMP_SOURCE_ALIGN_FIXED ?
GIMP_PAINT_INCREMENTAL : GIMP_PAINT_CONSTANT);
}
static void
gimp_perspective_clone_paint (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GimpPaintState paint_state,
guint32 time)
{
GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_core);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpCloneOptions *clone_options = GIMP_CLONE_OPTIONS (paint_options);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
switch (paint_state)
{
case GIMP_PAINT_STATE_INIT:
if (source_core->set_source)
{
g_object_set (source_core, "src-drawable", drawable, NULL);
source_core->src_x = coords->x;
source_core->src_y = coords->y;
/* get source coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
source_core->src_x,
source_core->src_y,
&clone->src_x_fv,
&clone->src_y_fv);
source_core->first_stroke = TRUE;
}
else
{
GeglBuffer *orig_buffer = NULL;
GeglNode *tile = NULL;
GeglNode *src_node;
if (options->align_mode == GIMP_SOURCE_ALIGN_NO)
{
source_core->orig_src_x = source_core->src_x;
source_core->orig_src_y = source_core->src_y;
source_core->first_stroke = TRUE;
}
clone->node = gegl_node_new ();
g_object_set (clone->node,
"dont-cache", TRUE,
NULL);
switch (clone_options->clone_type)
{
case GIMP_IMAGE_CLONE:
{
GimpPickable *src_pickable;
GimpImage *src_image;
GimpImage *dest_image;
/* If the source image is different from the
* destination, then we should copy straight from the
* source image to the canvas.
* Otherwise, we need a call to get_orig_image to make sure
* we get a copy of the unblemished (offset) image
*/
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
src_image = gimp_pickable_get_image (src_pickable);
if (options->sample_merged)
src_pickable = GIMP_PICKABLE (gimp_image_get_projection (src_image));
dest_image = gimp_item_get_image (GIMP_ITEM (drawable));
if ((options->sample_merged &&
(src_image != dest_image)) ||
(! options->sample_merged &&
(source_core->src_drawable != drawable)))
{
orig_buffer = gimp_pickable_get_buffer (src_pickable);
}
else
{
if (options->sample_merged)
orig_buffer = gimp_paint_core_get_orig_proj (paint_core);
else
orig_buffer = gimp_paint_core_get_orig_image (paint_core);
}
}
break;
case GIMP_PATTERN_CLONE:
{
GimpPattern *pattern = gimp_context_get_pattern (context);
orig_buffer = gimp_pattern_create_buffer (pattern);
tile = gegl_node_new_child (clone->node,
"operation", "gegl:tile",
NULL);
clone->crop = gegl_node_new_child (clone->node,
"operation", "gegl:crop",
NULL);
}
break;
}
src_node = gegl_node_new_child (clone->node,
"operation", "gegl:buffer-source",
"buffer", orig_buffer,
NULL);
clone->transform_node =
gegl_node_new_child (clone->node,
"operation", "gegl:transform",
"sampler", GIMP_INTERPOLATION_LINEAR,
NULL);
clone->dest_node =
gegl_node_new_child (clone->node,
"operation", "gegl:write-buffer",
NULL);
if (tile)
{
gegl_node_link_many (src_node,
tile,
clone->crop,
clone->transform_node,
clone->dest_node,
NULL);
g_object_unref (orig_buffer);
}
else
{
gegl_node_link_many (src_node,
clone->transform_node,
clone->dest_node,
NULL);
}
}
break;
case GIMP_PAINT_STATE_MOTION:
if (source_core->set_source)
{
/* If the control key is down, move the src target and return */
source_core->src_x = coords->x;
source_core->src_y = coords->y;
/* get source coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
source_core->src_x,
source_core->src_y,
&clone->src_x_fv,
&clone->src_y_fv);
source_core->first_stroke = TRUE;
}
else
{
/* otherwise, update the target */
gint dest_x;
gint dest_y;
dest_x = coords->x;
dest_y = coords->y;
if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED)
{
source_core->offset_x = 0;
source_core->offset_y = 0;
}
else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
}
else if (source_core->first_stroke)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
/* get destination coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
dest_x,
dest_y,
&clone->dest_x_fv,
&clone->dest_y_fv);
source_core->first_stroke = FALSE;
}
gimp_source_core_motion (source_core, drawable, paint_options, coords);
}
break;
case GIMP_PAINT_STATE_FINISH:
if (clone->node)
{
g_object_unref (clone->node);
clone->node = NULL;
clone->crop = NULL;
clone->transform_node = NULL;
clone->dest_node = NULL;
}
break;
default:
break;
}
g_object_notify (G_OBJECT (clone), "src-x");
g_object_notify (G_OBJECT (clone), "src-y");
}
void
gimp_source_core_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpDynamics *dynamics = GIMP_BRUSH_CORE (paint_core)->dynamics;
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpPickable *src_pickable = NULL;
GeglBuffer *src_buffer = NULL;
GeglRectangle src_rect;
gint src_offset_x;
gint src_offset_y;
GeglBuffer *paint_buffer;
gint paint_buffer_x;
gint paint_buffer_y;
gint paint_area_offset_x;
gint paint_area_offset_y;
gint paint_area_width;
gint paint_area_height;
gdouble fade_point;
gdouble opacity;
fade_point = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
opacity = gimp_dynamics_get_linear_value (dynamics,
GIMP_DYNAMICS_OUTPUT_OPACITY,
coords,
paint_options,
fade_point);
if (opacity == 0.0)
return;
src_offset_x = source_core->offset_x;
src_offset_y = source_core->offset_y;
if (gimp_source_core_use_source (source_core, options))
{
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
if (options->sample_merged)
{
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
gint off_x, off_y;
src_pickable = GIMP_PICKABLE (src_image);
gimp_item_get_offset (GIMP_ITEM (source_core->src_drawable),
&off_x, &off_y);
src_offset_x += off_x;
src_offset_y += off_y;
}
gimp_pickable_flush (src_pickable);
}
paint_buffer = gimp_paint_core_get_paint_buffer (paint_core, drawable,
paint_options, coords,
&paint_buffer_x,
&paint_buffer_y);
if (! paint_buffer)
return;
paint_area_offset_x = 0;
paint_area_offset_y = 0;
paint_area_width = gegl_buffer_get_width (paint_buffer);
paint_area_height = gegl_buffer_get_height (paint_buffer);
if (gimp_source_core_use_source (source_core, options))
{
src_buffer =
GIMP_SOURCE_CORE_GET_CLASS (source_core)->get_source (source_core,
drawable,
paint_options,
src_pickable,
src_offset_x,
src_offset_y,
paint_buffer,
paint_buffer_x,
paint_buffer_y,
&paint_area_offset_x,
&paint_area_offset_y,
&paint_area_width,
&paint_area_height,
&src_rect);
if (! src_buffer)
return;
}
/* Set the paint buffer to transparent */
gegl_buffer_clear (paint_buffer, NULL);
GIMP_SOURCE_CORE_GET_CLASS (source_core)->motion (source_core,
drawable,
paint_options,
coords,
opacity,
src_pickable,
src_buffer,
&src_rect,
src_offset_x,
src_offset_y,
paint_buffer,
paint_buffer_x,
paint_buffer_y,
paint_area_offset_x,
paint_area_offset_y,
paint_area_width,
paint_area_height);
if (src_buffer)
g_object_unref (src_buffer);
}
void
gimp_source_core_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpPickable *src_pickable = NULL;
PixelRegion srcPR;
gint src_offset_x;
gint src_offset_y;
TempBuf *paint_area;
gint paint_area_offset_x;
gint paint_area_offset_y;
gint paint_area_width;
gint paint_area_height;
gdouble opacity;
opacity = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
if (opacity == 0.0)
return;
src_offset_x = source_core->offset_x;
src_offset_y = source_core->offset_y;
if (options->use_source)
{
src_pickable = GIMP_PICKABLE (source_core->src_drawable);
if (options->sample_merged)
{
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
gint off_x, off_y;
src_pickable = GIMP_PICKABLE (gimp_image_get_projection (src_image));
gimp_item_offsets (GIMP_ITEM (source_core->src_drawable),
&off_x, &off_y);
src_offset_x += off_x;
src_offset_y += off_y;
}
gimp_pickable_flush (src_pickable);
}
paint_area = gimp_paint_core_get_paint_area (paint_core, drawable,
paint_options);
if (! paint_area)
return;
paint_area_offset_x = 0;
paint_area_offset_y = 0;
paint_area_width = paint_area->width;
paint_area_height = paint_area->height;
if (options->use_source &&
! GIMP_SOURCE_CORE_GET_CLASS (source_core)->get_source (source_core,
drawable,
paint_options,
src_pickable,
src_offset_x,
src_offset_y,
paint_area,
&paint_area_offset_x,
&paint_area_offset_y,
&paint_area_width,
&paint_area_height,
&srcPR))
{
return;
}
/* Set the paint area to transparent */
temp_buf_data_clear (paint_area);
GIMP_SOURCE_CORE_GET_CLASS (source_core)->motion (source_core,
drawable,
paint_options,
opacity,
src_pickable,
&srcPR,
src_offset_x,
src_offset_y,
paint_area,
paint_area_offset_x,
paint_area_offset_y,
paint_area_width,
paint_area_height);
}
static gboolean
gimp_source_core_real_get_source (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpPickable *src_pickable,
gint src_offset_x,
gint src_offset_y,
TempBuf *paint_area,
gint *paint_area_offset_x,
gint *paint_area_offset_y,
gint *paint_area_width,
gint *paint_area_height,
PixelRegion *srcPR)
{
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
GimpImage *src_image = gimp_pickable_get_image (src_pickable);
TileManager *src_tiles = gimp_pickable_get_tiles (src_pickable);
gint x1, y1;
gint x2, y2;
x1 = CLAMP (paint_area->x + src_offset_x,
0, tile_manager_width (src_tiles));
y1 = CLAMP (paint_area->y + src_offset_y,
0, tile_manager_height (src_tiles));
x2 = CLAMP (paint_area->x + src_offset_x + paint_area->width,
0, tile_manager_width (src_tiles));
y2 = CLAMP (paint_area->y + src_offset_y + paint_area->height,
0, tile_manager_height (src_tiles));
if (!(x2 - x1) || !(y2 - y1))
return FALSE;
/* If the source image is different from the destination,
* then we should copy straight from the source image
* to the canvas.
* Otherwise, we need a call to get_orig_image to make sure
* we get a copy of the unblemished (offset) image
*/
if (( options->sample_merged && (src_image != image)) ||
(! options->sample_merged && (source_core->src_drawable != drawable)))
{
pixel_region_init (srcPR, src_tiles,
x1, y1, x2 - x1, y2 - y1, FALSE);
}
else
{
TempBuf *orig;
/* get the original image */
if (options->sample_merged)
orig = gimp_paint_core_get_orig_proj (GIMP_PAINT_CORE (source_core),
src_pickable,
x1, y1, x2, y2);
else
orig = gimp_paint_core_get_orig_image (GIMP_PAINT_CORE (source_core),
GIMP_DRAWABLE (src_pickable),
x1, y1, x2, y2);
pixel_region_init_temp_buf (srcPR, orig,
0, 0, x2 - x1, y2 - y1);
}
*paint_area_offset_x = x1 - (paint_area->x + src_offset_x);
*paint_area_offset_y = y1 - (paint_area->y + src_offset_y);
*paint_area_width = x2 - x1;
*paint_area_height = y2 - y1;
return TRUE;
}
static void
gimp_perspective_clone_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
{
GimpDrawTool *draw_tool = GIMP_DRAW_TOOL (tool);
gdouble closest_dist;
gdouble dist;
clone_tool->function = TRANSFORM_HANDLE_NONE;
if (display != tool->display)
return;
dist = gimp_draw_tool_calc_distance_square (draw_tool, display,
coords->x, coords->y,
clone_tool->tx1,
clone_tool->ty1);
closest_dist = dist;
clone_tool->function = TRANSFORM_HANDLE_NW;
dist = gimp_draw_tool_calc_distance_square (draw_tool, display,
coords->x, coords->y,
clone_tool->tx2,
clone_tool->ty2);
if (dist < closest_dist)
{
closest_dist = dist;
clone_tool->function = TRANSFORM_HANDLE_NE;
}
dist = gimp_draw_tool_calc_distance_square (draw_tool, display,
coords->x, coords->y,
clone_tool->tx3,
clone_tool->ty3);
if (dist < closest_dist)
{
closest_dist = dist;
clone_tool->function = TRANSFORM_HANDLE_SW;
}
dist = gimp_draw_tool_calc_distance_square (draw_tool, display,
coords->x, coords->y,
clone_tool->tx4,
clone_tool->ty4);
if (dist < closest_dist)
{
closest_dist = dist;
clone_tool->function = TRANSFORM_HANDLE_SE;
}
}
else
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
if (proximity)
{
GimpPaintCore *core = GIMP_PAINT_TOOL (tool)->core;
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (core);
GimpSourceCore *source_core = GIMP_SOURCE_CORE (core);
if (source_core->src_drawable == NULL)
{
gimp_tool_replace_status (tool, display,
_("Ctrl-Click to set a clone source"));
}
else
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
clone_tool->src_x = source_core->src_x;
clone_tool->src_y = source_core->src_y;
if (! source_core->first_stroke)
{
if (GIMP_SOURCE_OPTIONS (options)->align_mode ==
GIMP_SOURCE_ALIGN_YES)
{
gdouble nnx, nny;
/* Set the coordinates for the reference cross */
gimp_perspective_clone_get_source_point (clone,
coords->x,
coords->y,
&nnx, &nny);
clone_tool->src_x = nnx;
clone_tool->src_y = nny;
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
}
}
}
static void
gimp_perspective_clone_tool_oper_update (GimpTool *tool,
const GimpCoords *coords,
GdkModifierType state,
gboolean proximity,
GimpDisplay *display)
{
GimpPerspectiveCloneTool *clone_tool = GIMP_PERSPECTIVE_CLONE_TOOL (tool);
GimpPerspectiveCloneOptions *options;
options = GIMP_PERSPECTIVE_CLONE_TOOL_GET_OPTIONS (tool);
if (options->clone_mode == GIMP_PERSPECTIVE_CLONE_MODE_ADJUST)
{
if (clone_tool->widget)
{
if (display == tool->display)
{
gimp_tool_widget_hover (clone_tool->widget, coords, state,
proximity);
}
}
}
else
{
GIMP_TOOL_CLASS (parent_class)->oper_update (tool, coords, state,
proximity, display);
if (proximity)
{
GimpPaintCore *core = GIMP_PAINT_TOOL (tool)->core;
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (core);
GimpSourceCore *source_core = GIMP_SOURCE_CORE (core);
if (source_core->src_drawable == NULL)
{
gimp_tool_replace_status (tool, display,
_("Ctrl-Click to set a clone source"));
}
else
{
gimp_draw_tool_pause (GIMP_DRAW_TOOL (tool));
clone_tool->src_x = source_core->src_x;
clone_tool->src_y = source_core->src_y;
if (! source_core->first_stroke)
{
if (GIMP_SOURCE_OPTIONS (options)->align_mode ==
GIMP_SOURCE_ALIGN_YES)
{
gdouble nnx, nny;
/* Set the coordinates for the reference cross */
gimp_perspective_clone_get_source_point (clone,
coords->x,
coords->y,
&nnx, &nny);
clone_tool->src_x = floor (nnx);
clone_tool->src_y = floor (nny);
}
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (tool));
}
}
}
}
static void
gimp_clone_motion (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
gdouble opacity,
GimpPickable *src_pickable,
GeglBuffer *src_buffer,
GeglRectangle *src_rect,
gint src_offset_x,
gint src_offset_y,
GeglBuffer *paint_buffer,
gint paint_buffer_x,
gint paint_buffer_y,
gint paint_area_offset_x,
gint paint_area_offset_y,
gint paint_area_width,
gint paint_area_height)
{
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpCloneOptions *options = GIMP_CLONE_OPTIONS (paint_options);
GimpSourceOptions *source_options = GIMP_SOURCE_OPTIONS (paint_options);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
gdouble fade_point;
gdouble force;
if (gimp_source_core_use_source (source_core, source_options))
{
gegl_buffer_copy (src_buffer,
GEGL_RECTANGLE (src_rect->x,
src_rect->y,
paint_area_width,
paint_area_height),
paint_buffer,
GEGL_RECTANGLE (paint_area_offset_x,
paint_area_offset_y,
0, 0));
}
else if (options->clone_type == GIMP_PATTERN_CLONE)
{
GimpPattern *pattern = gimp_context_get_pattern (context);
GeglBuffer *src_buffer = gimp_pattern_create_buffer (pattern);
gegl_buffer_set_pattern (paint_buffer,
GEGL_RECTANGLE (paint_area_offset_x,
paint_area_offset_y,
paint_area_width,
paint_area_height),
src_buffer,
- paint_buffer_x - src_offset_x,
- paint_buffer_y - src_offset_y);
g_object_unref (src_buffer);
}
else
{
g_return_if_reached ();
}
fade_point = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
force = gimp_dynamics_get_linear_value (GIMP_BRUSH_CORE (paint_core)->dynamics,
GIMP_DYNAMICS_OUTPUT_FORCE,
coords,
paint_options,
fade_point);
gimp_brush_core_paste_canvas (GIMP_BRUSH_CORE (paint_core), drawable,
coords,
MIN (opacity, GIMP_OPACITY_OPAQUE),
gimp_context_get_opacity (context),
gimp_context_get_paint_mode (context),
gimp_paint_options_get_brush_mode (paint_options),
force,
/* In fixed mode, paint incremental so the
* individual brushes are properly applied
* on top of each other.
* Otherwise the stuff we paint is seamless
* and we don't need intermediate masking.
*/
source_options->align_mode ==
GIMP_SOURCE_ALIGN_FIXED ?
GIMP_PAINT_INCREMENTAL : GIMP_PAINT_CONSTANT);
}
static gboolean
gimp_perspective_clone_get_source (GimpSourceCore *source_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpPickable *src_pickable,
gint src_offset_x,
gint src_offset_y,
TempBuf *paint_area,
gint *paint_area_offset_x,
gint *paint_area_offset_y,
gint *paint_area_width,
gint *paint_area_height,
PixelRegion *srcPR)
{
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (source_core);
GimpPaintCore *paint_core = GIMP_PAINT_CORE (source_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
GimpImage *src_image;
GimpImage *image;
GimpImageType src_type;
gint x1d, y1d, x2d, y2d;
gdouble x1s, y1s, x2s, y2s, x3s, y3s, x4s, y4s;
gint xmin, ymin, xmax, ymax;
TileManager *src_tiles;
TileManager *orig_tiles;
PixelRegion origPR;
PixelRegion destPR;
GimpMatrix3 matrix;
gint bytes;
src_image = gimp_pickable_get_image (src_pickable);
image = gimp_item_get_image (GIMP_ITEM (drawable));
src_type = gimp_pickable_get_image_type (src_pickable);
src_tiles = gimp_pickable_get_tiles (src_pickable);
/* Destination coordinates that will be painted */
x1d = paint_area->x;
y1d = paint_area->y;
x2d = paint_area->x + paint_area->width;
y2d = paint_area->y + paint_area->height;
/* Boundary box for source pixels to copy: Convert all the vertex of
* the box to paint in destination area to its correspondent in
* source area bearing in mind perspective
*/
gimp_perspective_clone_get_source_point (clone, x1d, y1d, &x1s, &y1s);
gimp_perspective_clone_get_source_point (clone, x1d, y2d, &x2s, &y2s);
gimp_perspective_clone_get_source_point (clone, x2d, y1d, &x3s, &y3s);
gimp_perspective_clone_get_source_point (clone, x2d, y2d, &x4s, &y4s);
xmin = floor (MIN4 (x1s, x2s, x3s, x4s));
ymin = floor (MIN4 (y1s, y2s, y3s, y4s));
xmax = ceil (MAX4 (x1s, x2s, x3s, x4s));
ymax = ceil (MAX4 (y1s, y2s, y3s, y4s));
xmin = CLAMP (xmin - 1, 0, tile_manager_width (src_tiles));
ymin = CLAMP (ymin - 1, 0, tile_manager_height (src_tiles));
xmax = CLAMP (xmax + 1, 0, tile_manager_width (src_tiles));
ymax = CLAMP (ymax + 1, 0, tile_manager_height (src_tiles));
/* if the source area is completely out of the image */
if (!(xmax - xmin) || !(ymax - ymin))
return FALSE;
/* If the source image is different from the destination,
* then we should copy straight from the source image
* to the canvas.
* Otherwise, we need a call to get_orig_image to make sure
* we get a copy of the unblemished (offset) image
*/
if (( options->sample_merged && (src_image != image)) ||
(! options->sample_merged && (source_core->src_drawable != drawable)))
{
pixel_region_init (&origPR, src_tiles,
xmin, ymin, xmax - xmin, ymax - ymin, FALSE);
}
else
{
TempBuf *orig;
/* get the original image */
if (options->sample_merged)
orig = gimp_paint_core_get_orig_proj (paint_core,
src_pickable,
xmin, ymin, xmax, ymax);
else
orig = gimp_paint_core_get_orig_image (paint_core,
GIMP_DRAWABLE (src_pickable),
xmin, ymin, xmax, ymax);
pixel_region_init_temp_buf (&origPR, orig,
0, 0, xmax - xmin, ymax - ymin);
}
/* copy the original image to a tile manager, adding alpha if needed */
bytes = GIMP_IMAGE_TYPE_BYTES (GIMP_IMAGE_TYPE_WITH_ALPHA (src_type));
orig_tiles = tile_manager_new (xmax - xmin, ymax - ymin, bytes);
tile_manager_set_offsets (orig_tiles, xmin, ymin);
pixel_region_init (&destPR, orig_tiles,
0, 0, xmax - xmin, ymax - ymin,
TRUE);
if (bytes > origPR.bytes)
add_alpha_region (&origPR, &destPR);
else
copy_region (&origPR, &destPR);
clone->src_area = temp_buf_resize (clone->src_area,
tile_manager_bpp (orig_tiles),
0, 0,
x2d - x1d, y2d - y1d);
pixel_region_init_temp_buf (&destPR, clone->src_area,
0, 0,
x2d - x1d, y2d - y1d);
gimp_perspective_clone_get_matrix (clone, &matrix);
gimp_transform_region (src_pickable,
GIMP_CONTEXT (paint_options),
orig_tiles,
&destPR,
x1d, y1d, x2d, y2d,
&matrix,
GIMP_INTERPOLATION_LINEAR, 0, NULL);
tile_manager_unref (orig_tiles);
pixel_region_init_temp_buf (srcPR, clone->src_area,
0, 0, x2d - x1d, y2d - y1d);
return TRUE;
}
static void
gimp_perspective_clone_paint (GimpPaintCore *paint_core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
GimpPaintState paint_state,
guint32 time)
{
GimpSourceCore *source_core = GIMP_SOURCE_CORE (paint_core);
GimpPerspectiveClone *clone = GIMP_PERSPECTIVE_CLONE (paint_core);
GimpSourceOptions *options = GIMP_SOURCE_OPTIONS (paint_options);
switch (paint_state)
{
case GIMP_PAINT_STATE_INIT:
if (source_core->set_source)
{
g_object_set (source_core, "src-drawable", drawable, NULL);
source_core->src_x = paint_core->cur_coords.x;
source_core->src_y = paint_core->cur_coords.y;
/* get source coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
source_core->src_x,
source_core->src_y,
&clone->src_x_fv,
&clone->src_y_fv);
source_core->first_stroke = TRUE;
}
else if (options->align_mode == GIMP_SOURCE_ALIGN_NO)
{
source_core->orig_src_x = source_core->src_x;
source_core->orig_src_y = source_core->src_y;
source_core->first_stroke = TRUE;
}
break;
case GIMP_PAINT_STATE_MOTION:
if (source_core->set_source)
{
/* If the control key is down, move the src target and return */
source_core->src_x = paint_core->cur_coords.x;
source_core->src_y = paint_core->cur_coords.y;
/* get source coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
source_core->src_x,
source_core->src_y,
&clone->src_x_fv,
&clone->src_y_fv);
source_core->first_stroke = TRUE;
}
else
{
/* otherwise, update the target */
gint dest_x;
gint dest_y;
dest_x = paint_core->cur_coords.x;
dest_y = paint_core->cur_coords.y;
if (options->align_mode == GIMP_SOURCE_ALIGN_REGISTERED)
{
source_core->offset_x = 0;
source_core->offset_y = 0;
}
else if (options->align_mode == GIMP_SOURCE_ALIGN_FIXED)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
}
else if (source_core->first_stroke)
{
source_core->offset_x = source_core->src_x - dest_x;
source_core->offset_y = source_core->src_y - dest_y;
/* get destination coordinates in front view perspective */
gimp_matrix3_transform_point (&clone->transform_inv,
dest_x,
dest_y,
&clone->dest_x_fv,
&clone->dest_y_fv);
source_core->first_stroke = FALSE;
}
gimp_source_core_motion (source_core, drawable, paint_options);
}
break;
case GIMP_PAINT_STATE_FINISH:
break;
default:
break;
}
g_object_notify (G_OBJECT (clone), "src-x");
g_object_notify (G_OBJECT (clone), "src-y");
}