void
gimp_drawable_offset (GimpDrawable *drawable,
GimpContext *context,
gboolean wrap_around,
GimpOffsetType fill_type,
gint offset_x,
gint offset_y)
{
GimpItem *item;
GeglBuffer *src_buffer;
GeglBuffer *new_buffer;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint width, height;
gint src_x, src_y;
gint dest_x, dest_y;
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (GIMP_IS_CONTEXT (context));
item = GIMP_ITEM (drawable);
width = gimp_item_get_width (item);
height = gimp_item_get_height (item);
if (wrap_around)
{
/* avoid modulo operation on negative values */
while (offset_x < 0)
offset_x += width;
while (offset_y < 0)
offset_y += height;
offset_x %= width;
offset_y %= height;
}
else
{
offset_x = CLAMP (offset_x, -width, width);
offset_y = CLAMP (offset_y, -height, height);
}
if (offset_x == 0 && offset_y == 0)
return;
src_buffer = gimp_drawable_get_buffer (drawable);
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
gimp_drawable_get_format (drawable));
if (! wrap_around)
{
if (fill_type == GIMP_OFFSET_BACKGROUND)
{
GimpRGB bg;
GeglColor *color;
gimp_context_get_background (context, &bg);
gimp_pickable_srgb_to_image_color (GIMP_PICKABLE (drawable),
&bg, &bg);
color = gimp_gegl_color_new (&bg);
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
}
}
if (offset_x >= 0)
{
src_x = 0;
dest_x = offset_x;
width = CLAMP ((width - offset_x), 0, width);
}
else
{
src_x = -offset_x;
dest_x = 0;
width = CLAMP ((width + offset_x), 0, width);
}
if (offset_y >= 0)
{
src_y = 0;
dest_y = offset_y;
height = CLAMP ((height - offset_y), 0, height);
}
else
{
src_y = -offset_y;
dest_y = 0;
height = CLAMP ((height + offset_y), 0, height);
}
/* Copy the center region */
if (width && height)
{
gegl_buffer_copy (src_buffer,
GEGL_RECTANGLE (src_x, src_y, width, height),
GEGL_ABYSS_NONE,
new_buffer,
GEGL_RECTANGLE (dest_x,dest_y, width, height));
}
if (wrap_around)
{
/* Copy appropriately for wrap around */
if (offset_x >= 0 && offset_y >= 0)
{
src_x = gimp_item_get_width (item) - offset_x;
src_y = gimp_item_get_height (item) - offset_y;
}
else if (offset_x >= 0 && offset_y < 0)
{
src_x = gimp_item_get_width (item) - offset_x;
src_y = 0;
}
else if (offset_x < 0 && offset_y >= 0)
{
src_x = 0;
src_y = gimp_item_get_height (item) - offset_y;
}
else if (offset_x < 0 && offset_y < 0)
{
src_x = 0;
src_y = 0;
}
dest_x = (src_x + offset_x) % gimp_item_get_width (item);
if (dest_x < 0)
dest_x = gimp_item_get_width (item) + dest_x;
dest_y = (src_y + offset_y) % gimp_item_get_height (item);
if (dest_y < 0)
dest_y = gimp_item_get_height (item) + dest_y;
/* intersecting region */
if (offset_x != 0 && offset_y != 0)
{
gegl_buffer_copy (src_buffer,
GEGL_RECTANGLE (src_x, src_y,
ABS (offset_x), ABS (offset_y)),
GEGL_ABYSS_NONE,
new_buffer,
GEGL_RECTANGLE (dest_x, dest_y, 0, 0));
}
/* X offset */
if (offset_x != 0)
{
if (offset_y >= 0)
{
src_rect.x = src_x;
src_rect.y = 0;
src_rect.width = ABS (offset_x);
src_rect.height = gimp_item_get_height (item) - ABS (offset_y);
dest_rect.x = dest_x;
dest_rect.y = dest_y + offset_y;
}
else if (offset_y < 0)
{
src_rect.x = src_x;
src_rect.y = src_y - offset_y;
src_rect.width = ABS (offset_x);
src_rect.height = gimp_item_get_height (item) - ABS (offset_y);
dest_rect.x = dest_x;
dest_rect.y = 0;
}
gegl_buffer_copy (src_buffer, &src_rect, GEGL_ABYSS_NONE,
new_buffer, &dest_rect);
}
/* X offset */
if (offset_y != 0)
{
if (offset_x >= 0)
{
src_rect.x = 0;
src_rect.y = src_y;
src_rect.width = gimp_item_get_width (item) - ABS (offset_x);
src_rect.height = ABS (offset_y);
dest_rect.x = dest_x + offset_x;
dest_rect.y = dest_y;
}
else if (offset_x < 0)
{
src_rect.x = src_x - offset_x;
src_rect.y = src_y;
src_rect.width = gimp_item_get_width (item) - ABS (offset_x);
src_rect.height = ABS (offset_y);
dest_rect.x = 0;
dest_rect.y = dest_y;
}
gegl_buffer_copy (src_buffer, &src_rect, GEGL_ABYSS_NONE,
new_buffer, &dest_rect);
}
}
gimp_drawable_set_buffer (drawable,
gimp_item_is_attached (item),
C_("undo-type", "Offset Drawable"),
new_buffer);
g_object_unref (new_buffer);
}
void
gimp_drawable_edit_fill (GimpDrawable *drawable,
GimpFillOptions *options,
const gchar *undo_desc)
{
GimpContext *context;
gint x, y, width, height;
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
g_return_if_fail (GIMP_IS_FILL_OPTIONS (options));
if (! gimp_item_mask_intersect (GIMP_ITEM (drawable),
&x, &y, &width, &height))
{
return; /* nothing to do, but the fill succeeded */
}
context = GIMP_CONTEXT (options);
if (gimp_layer_mode_is_alpha_only (gimp_context_get_paint_mode (context)))
{
if (! gimp_drawable_has_alpha (drawable) ||
! (gimp_drawable_get_active_mask (drawable) &
GIMP_COMPONENT_MASK_ALPHA))
{
return; /* nothing to do, but the fill succeeded */
}
}
if (! undo_desc)
undo_desc = gimp_fill_options_get_undo_desc (options);
/* check if we can fill the drawable's buffer directly */
if (gimp_drawable_edit_can_fill_direct (drawable, options))
{
gimp_drawable_edit_fill_direct (drawable, options, undo_desc);
gimp_drawable_update (drawable, x, y, width, height);
}
else
{
GeglNode *operation;
GimpDrawableFilter *filter;
gdouble opacity;
GimpLayerMode mode;
GimpLayerMode composite_mode;
opacity = gimp_context_get_opacity (context);
mode = gimp_context_get_paint_mode (context);
composite_mode = gimp_layer_mode_get_paint_composite_mode (mode);
operation = gegl_node_new_child (NULL,
"operation", "gimp:fill-source",
"options", options,
"drawable", drawable,
"pattern-offset-x", -x,
"pattern-offset-y", -y,
NULL);
filter = gimp_drawable_filter_new (drawable, undo_desc, operation, NULL);
gimp_drawable_filter_set_opacity (filter, opacity);
gimp_drawable_filter_set_mode (filter,
mode,
GIMP_LAYER_COLOR_SPACE_AUTO,
GIMP_LAYER_COLOR_SPACE_AUTO,
composite_mode);
gimp_drawable_filter_apply (filter, NULL);
gimp_drawable_filter_commit (filter, NULL, FALSE);
g_object_unref (filter);
g_object_unref (operation);
}
}
void
gimp_paint_core_finish (GimpPaintCore *core,
GimpDrawable *drawable,
gboolean push_undo)
{
GimpImage *image;
g_return_if_fail (GIMP_IS_PAINT_CORE (core));
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
if (core->applicator)
{
g_object_unref (core->applicator);
core->applicator = NULL;
}
if (core->stroke_buffer)
{
g_array_free (core->stroke_buffer, TRUE);
core->stroke_buffer = NULL;
}
image = gimp_item_get_image (GIMP_ITEM (drawable));
/* Determine if any part of the image has been altered--
* if nothing has, then just return...
*/
if ((core->x2 == core->x1) || (core->y2 == core->y1))
{
gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable));
return;
}
if (push_undo)
{
GeglBuffer *buffer;
gint x, y, width, height;
gimp_rectangle_intersect (core->x1, core->y1,
core->x2 - core->x1, core->y2 - core->y1,
0, 0,
gimp_item_get_width (GIMP_ITEM (drawable)),
gimp_item_get_height (GIMP_ITEM (drawable)),
&x, &y, &width, &height);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_PAINT,
core->undo_desc);
GIMP_PAINT_CORE_GET_CLASS (core)->push_undo (core, image, NULL);
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
gimp_drawable_get_format (drawable));
gegl_buffer_copy (core->undo_buffer,
GEGL_RECTANGLE (x, y, width, height),
buffer,
GEGL_RECTANGLE (0, 0, 0, 0));
gimp_drawable_push_undo (drawable, NULL,
buffer, x, y, width, height);
g_object_unref (buffer);
gimp_image_undo_group_end (image);
}
g_object_unref (core->undo_buffer);
core->undo_buffer = NULL;
if (core->saved_proj_buffer)
{
g_object_unref (core->saved_proj_buffer);
core->saved_proj_buffer = NULL;
}
gimp_viewable_preview_thaw (GIMP_VIEWABLE (drawable));
}
static gboolean
gimp_text_layer_render (GimpTextLayer *layer)
{
GimpDrawable *drawable;
GimpItem *item;
GimpImage *image;
GimpTextLayout *layout;
gdouble xres;
gdouble yres;
gint width;
gint height;
if (! layer->text)
return FALSE;
drawable = GIMP_DRAWABLE (layer);
item = GIMP_ITEM (layer);
image = gimp_item_get_image (item);
if (gimp_container_is_empty (image->gimp->fonts))
{
gimp_message_literal (image->gimp, NULL, GIMP_MESSAGE_ERROR,
_("Due to lack of any fonts, "
"text functionality is not available."));
return FALSE;
}
gimp_image_get_resolution (image, &xres, &yres);
layout = gimp_text_layout_new (layer->text, xres, yres);
g_object_freeze_notify (G_OBJECT (drawable));
if (gimp_text_layout_get_size (layout, &width, &height) &&
(width != gimp_item_get_width (item) ||
height != gimp_item_get_height (item)))
{
TileManager *new_tiles = tile_manager_new (width, height,
gimp_drawable_bytes (drawable));
gimp_drawable_set_tiles (drawable, FALSE, NULL, new_tiles,
gimp_drawable_type (drawable));
tile_manager_unref (new_tiles);
if (gimp_layer_get_mask (GIMP_LAYER (layer)))
{
GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (layer));
static GimpContext *unused_eek = NULL;
if (! unused_eek)
unused_eek = gimp_context_new (image->gimp, "eek", NULL);
gimp_item_resize (GIMP_ITEM (mask), unused_eek, width, height, 0, 0);
}
}
if (layer->auto_rename)
{
GimpItem *item = GIMP_ITEM (layer);
gchar *name = NULL;
if (layer->text->text)
{
name = gimp_utf8_strtrim (layer->text->text, 30);
}
else if (layer->text->markup)
{
gchar *tmp = gimp_markup_extract_text (layer->text->markup);
name = gimp_utf8_strtrim (tmp, 30);
g_free (tmp);
}
if (! name)
name = g_strdup (_("Empty Text Layer"));
if (gimp_item_is_attached (item))
{
gimp_item_tree_rename_item (gimp_item_get_tree (item), item,
name, FALSE, NULL);
g_free (name);
}
else
{
gimp_object_take_name (GIMP_OBJECT (layer), name);
}
}
gimp_text_layer_render_layout (layer, layout);
g_object_unref (layout);
g_object_thaw_notify (G_OBJECT (drawable));
return (width > 0 && height > 0);
}
GimpDrawable *
gimp_drawable_transform_rotate (GimpDrawable *drawable,
GimpContext *context,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result)
{
GimpImage *image;
GeglBuffer *orig_buffer;
gint orig_offset_x;
gint orig_offset_y;
gboolean new_layer;
GimpDrawable *result = NULL;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
image = gimp_item_get_image (GIMP_ITEM (drawable));
/* Start a transform undo group */
gimp_image_undo_group_start (image,
GIMP_UNDO_GROUP_TRANSFORM,
C_("undo-type", "Rotate"));
/* Cut/Copy from the specified drawable */
orig_buffer = gimp_drawable_transform_cut (drawable, context,
&orig_offset_x, &orig_offset_y,
&new_layer);
if (orig_buffer)
{
GeglBuffer *new_buffer;
gint new_offset_x;
gint new_offset_y;
/* always clip unfloated buffers so they keep their size */
if (GIMP_IS_CHANNEL (drawable) &&
! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer)))
clip_result = TRUE;
/* also transform the mask if we are transforming an entire layer */
if (GIMP_IS_LAYER (drawable) &&
gimp_layer_get_mask (GIMP_LAYER (drawable)) &&
gimp_channel_is_empty (gimp_image_get_mask (image)))
{
GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (drawable));
gimp_item_rotate (GIMP_ITEM (mask), context,
rotate_type,
center_x,
center_y,
clip_result);
}
/* transform the buffer */
new_buffer = gimp_drawable_transform_buffer_rotate (drawable, context,
orig_buffer,
orig_offset_x,
orig_offset_y,
rotate_type,
center_x, center_y,
clip_result,
&new_offset_x,
&new_offset_y);
/* Free the cut/copied buffer */
g_object_unref (orig_buffer);
if (new_buffer)
{
result = gimp_drawable_transform_paste (drawable, new_buffer,
new_offset_x, new_offset_y,
new_layer);
g_object_unref (new_buffer);
}
}
/* push the undo group end */
gimp_image_undo_group_end (image);
return result;
}
gboolean
gimp_paint_core_stroke_vectors (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
gboolean emulate_dynamics,
GimpVectors *vectors,
gboolean push_undo,
GError **error)
{
GList *stroke;
gboolean initialized = FALSE;
gboolean due_to_lack_of_points = FALSE;
gint off_x, off_y;
gint vectors_off_x, vectors_off_y;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
gimp_item_get_offset (GIMP_ITEM (vectors), &vectors_off_x, &vectors_off_y);
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
off_x -= vectors_off_x;
off_y -= vectors_off_y;
for (stroke = vectors->strokes; stroke; stroke = stroke->next)
{
GArray *coords;
gboolean closed;
coords = gimp_stroke_interpolate (GIMP_STROKE (stroke->data),
1.0, &closed);
if (coords && coords->len)
{
gint i;
for (i = 0; i < coords->len; i++)
{
g_array_index (coords, GimpCoords, i).x -= off_x;
g_array_index (coords, GimpCoords, i).y -= off_y;
}
if (emulate_dynamics)
gimp_paint_core_stroke_emulate_dynamics ((GimpCoords *) coords->data,
coords->len);
if (initialized ||
gimp_paint_core_start (core, drawable, paint_options,
&g_array_index (coords, GimpCoords, 0),
error))
{
initialized = TRUE;
core->cur_coords = g_array_index (coords, GimpCoords, 0);
core->last_coords = g_array_index (coords, GimpCoords, 0);
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_INIT, 0);
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_MOTION, 0);
for (i = 1; i < coords->len; i++)
{
gimp_paint_core_interpolate (core, drawable, paint_options,
&g_array_index (coords, GimpCoords, i),
0);
}
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_FINISH, 0);
}
else
{
if (coords)
g_array_free (coords, TRUE);
break;
}
}
else
{
due_to_lack_of_points = TRUE;
}
if (coords)
g_array_free (coords, TRUE);
}
if (initialized)
{
gimp_paint_core_finish (core, drawable, push_undo);
gimp_paint_core_cleanup (core);
}
if (! initialized && due_to_lack_of_points && *error == NULL)
{
g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED,
_("Not enough points to stroke"));
}
return initialized;
}
void
gimp_edit_get_paste_offset (GimpImage *image,
GimpDrawable *drawable,
GimpObject *paste,
gint viewport_x,
gint viewport_y,
gint viewport_width,
gint viewport_height,
gint *offset_x,
gint *offset_y)
{
gint image_width;
gint image_height;
gint width;
gint height;
gboolean clamp_to_image = TRUE;
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (drawable == NULL ||
gimp_item_is_attached (GIMP_ITEM (drawable)));
g_return_if_fail (GIMP_IS_VIEWABLE (paste));
g_return_if_fail (offset_x != NULL);
g_return_if_fail (offset_y != NULL);
image_width = gimp_image_get_width (image);
image_height = gimp_image_get_height (image);
gimp_viewable_get_size (GIMP_VIEWABLE (paste), &width, &height);
if (viewport_width == image_width &&
viewport_height == image_height)
{
/* if the whole image is visible, act as if there was no viewport */
viewport_x = 0;
viewport_y = 0;
viewport_width = 0;
viewport_height = 0;
}
if (drawable)
{
/* if pasting to a drawable */
GimpContainer *children;
gint off_x, off_y;
gint target_x, target_y;
gint target_width, target_height;
gint paste_x, paste_y;
gint paste_width, paste_height;
gboolean have_mask;
have_mask = ! gimp_channel_is_empty (gimp_image_get_mask (image));
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
children = gimp_viewable_get_children (GIMP_VIEWABLE (drawable));
if (children && gimp_container_get_n_children (children) == 0)
{
/* treat empty layer groups as image-sized, use the selection
* as target
*/
gimp_item_bounds (GIMP_ITEM (gimp_image_get_mask (image)),
&target_x, &target_y,
&target_width, &target_height);
}
else
{
gimp_item_mask_intersect (GIMP_ITEM (drawable),
&target_x, &target_y,
&target_width, &target_height);
}
if (! have_mask && /* if we have no mask */
viewport_width > 0 && /* and we have a viewport */
viewport_height > 0 &&
(width < target_width || /* and the paste is smaller than the target */
height < target_height) &&
/* and the viewport intersects with the target */
gimp_rectangle_intersect (viewport_x, viewport_y,
viewport_width, viewport_height,
off_x, off_y, /* target_x,y are 0 */
target_width, target_height,
&paste_x, &paste_y,
&paste_width, &paste_height))
{
/* center on the viewport */
*offset_x = paste_x + (paste_width - width) / 2;
*offset_y = paste_y + (paste_height- height) / 2;
}
else
{
/* otherwise center on the target */
*offset_x = off_x + target_x + (target_width - width) / 2;
*offset_y = off_y + target_y + (target_height - height) / 2;
/* and keep it that way */
clamp_to_image = FALSE;
}
}
else if (viewport_width > 0 && /* if we have a viewport */
viewport_height > 0 &&
(width < image_width || /* and the paste is */
height < image_height)) /* smaller than the image */
{
/* center on the viewport */
*offset_x = viewport_x + (viewport_width - width) / 2;
*offset_y = viewport_y + (viewport_height - height) / 2;
}
else
{
/* otherwise center on the image */
*offset_x = (image_width - width) / 2;
*offset_y = (image_height - height) / 2;
/* and keep it that way */
clamp_to_image = FALSE;
}
if (clamp_to_image)
{
/* Ensure that the pasted layer is always within the image, if it
* fits and aligned at top left if it doesn't. (See bug #142944).
*/
*offset_x = MIN (*offset_x, image_width - width);
*offset_y = MIN (*offset_y, image_height - height);
*offset_x = MAX (*offset_x, 0);
*offset_y = MAX (*offset_y, 0);
}
}
GimpDrawable *
gimp_drawable_transform_affine (GimpDrawable *drawable,
GimpContext *context,
const GimpMatrix3 *matrix,
GimpTransformDirection direction,
GimpInterpolationType interpolation_type,
gint recursion_level,
GimpTransformResize clip_result,
GimpProgress *progress)
{
GimpImage *image;
GeglBuffer *orig_buffer;
gint orig_offset_x;
gint orig_offset_y;
gboolean new_layer;
GimpDrawable *result = NULL;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (matrix != NULL, NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
image = gimp_item_get_image (GIMP_ITEM (drawable));
/* Start a transform undo group */
gimp_image_undo_group_start (image,
GIMP_UNDO_GROUP_TRANSFORM,
C_("undo-type", "Transform"));
/* Cut/Copy from the specified drawable */
orig_buffer = gimp_drawable_transform_cut (drawable, context,
&orig_offset_x, &orig_offset_y,
&new_layer);
if (orig_buffer)
{
GeglBuffer *new_buffer;
gint new_offset_x;
gint new_offset_y;
/* always clip unfloated buffers so they keep their size */
if (GIMP_IS_CHANNEL (drawable) &&
! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer)))
clip_result = GIMP_TRANSFORM_RESIZE_CLIP;
/* also transform the mask if we are transforming an entire layer */
if (GIMP_IS_LAYER (drawable) &&
gimp_layer_get_mask (GIMP_LAYER (drawable)) &&
gimp_channel_is_empty (gimp_image_get_mask (image)))
{
GimpLayerMask *mask = gimp_layer_get_mask (GIMP_LAYER (drawable));
gimp_item_transform (GIMP_ITEM (mask), context,
matrix,
direction,
interpolation_type,
recursion_level,
clip_result,
progress);
}
/* transform the buffer */
new_buffer = gimp_drawable_transform_buffer_affine (drawable, context,
orig_buffer,
orig_offset_x,
orig_offset_y,
matrix,
direction,
interpolation_type,
recursion_level,
clip_result,
&new_offset_x,
&new_offset_y,
progress);
/* Free the cut/copied buffer */
g_object_unref (orig_buffer);
if (new_buffer)
{
result = gimp_drawable_transform_paste (drawable, new_buffer,
new_offset_x, new_offset_y,
new_layer);
g_object_unref (new_buffer);
}
}
/* push the undo group end */
gimp_image_undo_group_end (image);
return result;
}
GimpLayer *
gimp_edit_paste (GimpImage *image,
GimpDrawable *drawable,
GimpBuffer *paste,
gboolean paste_into,
gint viewport_x,
gint viewport_y,
gint viewport_width,
gint viewport_height)
{
GimpLayer *layer;
const Babl *format;
gint image_width;
gint image_height;
gint width;
gint height;
gint offset_x;
gint offset_y;
gboolean clamp_to_image = TRUE;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (drawable == NULL ||
gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_BUFFER (paste), NULL);
/* Make a new layer: if drawable == NULL,
* user is pasting into an empty image.
*/
if (drawable)
format = gimp_drawable_get_format_with_alpha (drawable);
else
format = gimp_image_get_layer_format (image, TRUE);
layer = gimp_layer_new_from_buffer (paste, image,
format,
_("Pasted Layer"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
if (! layer)
return NULL;
image_width = gimp_image_get_width (image);
image_height = gimp_image_get_height (image);
width = gimp_item_get_width (GIMP_ITEM (layer));
height = gimp_item_get_height (GIMP_ITEM (layer));
if (viewport_width == image_width &&
viewport_height == image_height)
{
/* if the whole image is visible, act as if there was no viewport */
viewport_x = 0;
viewport_y = 0;
viewport_width = 0;
viewport_height = 0;
}
if (drawable)
{
/* if pasting to a drawable */
gint off_x, off_y;
gint x1, y1, x2, y2;
gint paste_x, paste_y;
gint paste_width, paste_height;
gboolean have_mask;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
have_mask = gimp_item_mask_bounds (GIMP_ITEM (drawable),
&x1, &y1, &x2, &y2);
if (! have_mask && /* if we have no mask */
viewport_width > 0 && /* and we have a viewport */
viewport_height > 0 &&
(width < (x2 - x1) || /* and the paste is smaller than the target */
height < (y2 - y1)) &&
/* and the viewport intersects with the target */
gimp_rectangle_intersect (viewport_x, viewport_y,
viewport_width, viewport_height,
off_x, off_y,
x2 - x1, y2 - y1,
&paste_x, &paste_y,
&paste_width, &paste_height))
{
/* center on the viewport */
offset_x = paste_x + (paste_width - width) / 2;
offset_y = paste_y + (paste_height- height) / 2;
}
else
{
/* otherwise center on the target */
offset_x = off_x + ((x1 + x2) - width) / 2;
offset_y = off_y + ((y1 + y2) - height) / 2;
/* and keep it that way */
clamp_to_image = FALSE;
}
}
else if (viewport_width > 0 && /* if we have a viewport */
viewport_height > 0 &&
(width < image_width || /* and the paste is */
height < image_height)) /* smaller than the image */
{
/* center on the viewport */
offset_x = viewport_x + (viewport_width - width) / 2;
offset_y = viewport_y + (viewport_height - height) / 2;
}
else
{
/* otherwise center on the image */
offset_x = (image_width - width) / 2;
offset_y = (image_height - height) / 2;
/* and keep it that way */
clamp_to_image = FALSE;
}
if (clamp_to_image)
{
/* Ensure that the pasted layer is always within the image, if it
* fits and aligned at top left if it doesn't. (See bug #142944).
*/
offset_x = MIN (offset_x, image_width - width);
offset_y = MIN (offset_y, image_height - height);
offset_x = MAX (offset_x, 0);
offset_y = MAX (offset_y, 0);
}
gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y);
/* Start a group undo */
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
C_("undo-type", "Paste"));
/* If there is a selection mask clear it--
* this might not always be desired, but in general,
* it seems like the correct behavior.
*/
if (! gimp_channel_is_empty (gimp_image_get_mask (image)) && ! paste_into)
gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE);
/* if there's a drawable, add a new floating selection */
if (drawable)
floating_sel_attach (layer, drawable);
else
gimp_image_add_layer (image, layer, NULL, 0, TRUE);
/* end the group undo */
gimp_image_undo_group_end (image);
return layer;
}
gboolean
gimp_edit_fill_full (GimpImage *image,
GimpDrawable *drawable,
const GimpRGB *color,
GimpPattern *pattern,
gdouble opacity,
GimpLayerModeEffects paint_mode,
const gchar *undo_desc)
{
GeglBuffer *dest_buffer;
const Babl *format;
gint x, y, width, height;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (color != NULL || pattern != NULL, FALSE);
if (! gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &width, &height))
return TRUE; /* nothing to do, but the fill succeeded */
if (pattern &&
babl_format_has_alpha (gimp_temp_buf_get_format (pattern->mask)) &&
! gimp_drawable_has_alpha (drawable))
{
format = gimp_drawable_get_format_with_alpha (drawable);
}
else
{
format = gimp_drawable_get_format (drawable);
}
dest_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
format);
if (pattern)
{
GeglBuffer *src_buffer = gimp_pattern_create_buffer (pattern);
gegl_buffer_set_pattern (dest_buffer, NULL, src_buffer, 0, 0);
g_object_unref (src_buffer);
}
else
{
GeglColor *gegl_color = gimp_gegl_color_new (color);
gegl_buffer_set_color (dest_buffer, NULL, gegl_color);
g_object_unref (gegl_color);
}
gimp_drawable_apply_buffer (drawable, dest_buffer,
GEGL_RECTANGLE (0, 0, width, height),
TRUE, undo_desc,
opacity, paint_mode,
NULL, x, y);
g_object_unref (dest_buffer);
gimp_drawable_update (drawable, x, y, width, height);
return TRUE;
}
gboolean
gimp_paint_core_start (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GError **error)
{
GimpItem *item;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
item = GIMP_ITEM (drawable);
if (core->stroke_buffer)
{
g_array_free (core->stroke_buffer, TRUE);
core->stroke_buffer = NULL;
}
core->stroke_buffer = g_array_sized_new (TRUE, TRUE,
sizeof (GimpCoords),
STROKE_BUFFER_INIT_SIZE);
core->cur_coords = *coords;
if (! GIMP_PAINT_CORE_GET_CLASS (core)->start (core, drawable,
paint_options,
coords, error))
{
return FALSE;
}
/* Allocate the undo structure */
if (core->undo_tiles)
tile_manager_unref (core->undo_tiles);
core->undo_tiles = tile_manager_new (gimp_item_get_width (item),
gimp_item_get_height (item),
gimp_drawable_bytes (drawable));
/* Allocate the saved proj structure */
if (core->saved_proj_tiles)
tile_manager_unref (core->saved_proj_tiles);
core->saved_proj_tiles = NULL;
if (core->use_saved_proj)
{
GimpImage *image = gimp_item_get_image (item);
GimpPickable *pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
TileManager *tiles = gimp_pickable_get_tiles (pickable);
core->saved_proj_tiles = tile_manager_new (tile_manager_width (tiles),
tile_manager_height (tiles),
tile_manager_bpp (tiles));
}
/* Allocate the canvas blocks structure */
if (core->canvas_tiles)
tile_manager_unref (core->canvas_tiles);
core->canvas_tiles = tile_manager_new (gimp_item_get_width (item),
gimp_item_get_height (item),
1);
/* Get the initial undo extents */
core->x1 = core->x2 = core->cur_coords.x;
core->y1 = core->y2 = core->cur_coords.y;
core->last_paint.x = -1e6;
core->last_paint.y = -1e6;
/* Freeze the drawable preview so that it isn't constantly updated. */
gimp_viewable_preview_freeze (GIMP_VIEWABLE (drawable));
return TRUE;
}
gboolean
gimp_drawable_bucket_fill (GimpDrawable *drawable,
GimpContext *context,
GimpBucketFillMode fill_mode,
gint paint_mode,
gdouble opacity,
gboolean do_seed_fill,
gboolean fill_transparent,
GimpSelectCriterion fill_criterion,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y,
GError **error)
{
GimpImage *image;
GimpRGB color;
GimpPattern *pattern = NULL;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
image = gimp_item_get_image (GIMP_ITEM (drawable));
if (fill_mode == GIMP_FG_BUCKET_FILL)
{
gimp_context_get_foreground (context, &color);
}
else if (fill_mode == GIMP_BG_BUCKET_FILL)
{
gimp_context_get_background (context, &color);
}
else if (fill_mode == GIMP_PATTERN_BUCKET_FILL)
{
pattern = gimp_context_get_pattern (context);
if (! pattern)
{
g_set_error (error, 0, 0,
_("No patterns available for this operation."));
return FALSE;
}
}
else
{
g_warning ("%s: invalid fill_mode passed", G_STRFUNC);
return FALSE;
}
gimp_drawable_bucket_fill_full (drawable,
fill_mode,
paint_mode, opacity,
do_seed_fill,
fill_transparent, fill_criterion,
threshold, sample_merged,
x, y,
&color, pattern);
return TRUE;
}
void
gimp_drawable_bucket_fill_full (GimpDrawable *drawable,
GimpBucketFillMode fill_mode,
gint paint_mode,
gdouble opacity,
gboolean do_seed_fill,
gboolean fill_transparent,
GimpSelectCriterion fill_criterion,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y,
const GimpRGB *color,
GimpPattern *pattern)
{
GimpImage *image;
TileManager *buf_tiles;
PixelRegion bufPR, maskPR;
GimpChannel *mask = NULL;
gint bytes;
gint x1, y1, x2, y2;
guchar col[MAX_CHANNELS];
TempBuf *pat_buf = NULL;
gboolean new_buf = FALSE;
gboolean selection;
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
g_return_if_fail (fill_mode != GIMP_PATTERN_BUCKET_FILL ||
GIMP_IS_PATTERN (pattern));
g_return_if_fail (fill_mode == GIMP_PATTERN_BUCKET_FILL ||
color != NULL);
image = gimp_item_get_image (GIMP_ITEM (drawable));
bytes = gimp_drawable_bytes (drawable);
selection = gimp_drawable_mask_bounds (drawable, &x1, &y1, &x2, &y2);
if ((x1 == x2) || (y1 == y2))
return;
if (fill_mode == GIMP_FG_BUCKET_FILL ||
fill_mode == GIMP_BG_BUCKET_FILL)
{
guchar tmp_col[MAX_CHANNELS];
gimp_rgb_get_uchar (color,
&tmp_col[RED_PIX],
&tmp_col[GREEN_PIX],
&tmp_col[BLUE_PIX]);
gimp_image_transform_color (image, gimp_drawable_type (drawable), col,
GIMP_RGB, tmp_col);
col[gimp_drawable_bytes_with_alpha (drawable) - 1] = OPAQUE_OPACITY;
}
else if (fill_mode == GIMP_PATTERN_BUCKET_FILL)
{
pat_buf = gimp_image_transform_temp_buf (image,
gimp_drawable_type (drawable),
pattern->mask, &new_buf);
}
else
{
g_warning ("%s: invalid fill_mode passed", G_STRFUNC);
return;
}
gimp_set_busy (image->gimp);
/* Do a seed bucket fill...To do this, calculate a new
* contiguous region. If there is a selection, calculate the
* intersection of this region with the existing selection.
*/
if (do_seed_fill)
{
mask = gimp_image_contiguous_region_by_seed (image, drawable,
sample_merged,
TRUE,
(gint) threshold,
fill_transparent,
fill_criterion,
(gint) x,
(gint) y);
if (selection)
{
gint off_x = 0;
gint off_y = 0;
if (! sample_merged)
gimp_item_offsets (GIMP_ITEM (drawable), &off_x, &off_y);
gimp_channel_combine_mask (mask, gimp_image_get_mask (image),
GIMP_CHANNEL_OP_INTERSECT,
-off_x, -off_y);
}
gimp_channel_bounds (mask, &x1, &y1, &x2, &y2);
/* make sure we handle the mask correctly if it was sample-merged */
if (sample_merged)
{
GimpItem *item;
gint off_x, off_y;
item = GIMP_ITEM (drawable);
/* Limit the channel bounds to the drawable's extents */
gimp_item_offsets (item, &off_x, &off_y);
x1 = CLAMP (x1, off_x, (off_x + gimp_item_width (item)));
y1 = CLAMP (y1, off_y, (off_y + gimp_item_height (item)));
x2 = CLAMP (x2, off_x, (off_x + gimp_item_width (item)));
y2 = CLAMP (y2, off_y, (off_y + gimp_item_height (item)));
pixel_region_init (&maskPR,
gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)),
x1, y1, (x2 - x1), (y2 - y1), TRUE);
/* translate mask bounds to drawable coords */
x1 -= off_x;
y1 -= off_y;
x2 -= off_x;
y2 -= off_y;
}
else
{
pixel_region_init (&maskPR,
gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)),
x1, y1, (x2 - x1), (y2 - y1), TRUE);
}
/* if the image doesn't have an alpha channel, make sure that
* the buf_tiles have. We need the alpha channel to fill with
* the region calculated above
*/
if (! gimp_drawable_has_alpha (drawable))
bytes++;
}
else if (fill_mode == GIMP_PATTERN_BUCKET_FILL &&
(pat_buf->bytes == 2 || pat_buf->bytes == 4))
{
/* If pattern being applied has an alpha channel, add one to the
* buf_tiles.
*/
if (! gimp_drawable_has_alpha (drawable))
bytes++;
}
buf_tiles = tile_manager_new ((x2 - x1), (y2 - y1), bytes);
pixel_region_init (&bufPR, buf_tiles, 0, 0, (x2 - x1), (y2 - y1), TRUE);
switch (fill_mode)
{
case GIMP_FG_BUCKET_FILL:
case GIMP_BG_BUCKET_FILL:
if (mask)
color_region_mask (&bufPR, &maskPR, col);
else
color_region (&bufPR, col);
break;
case GIMP_PATTERN_BUCKET_FILL:
if (mask)
pattern_region (&bufPR, &maskPR, pat_buf, x1, y1);
else
pattern_region (&bufPR, NULL, pat_buf, x1, y1);
break;
}
/* Apply it to the image */
pixel_region_init (&bufPR, buf_tiles, 0, 0, (x2 - x1), (y2 - y1), FALSE);
gimp_drawable_apply_region (drawable, &bufPR,
TRUE, C_("command", "Bucket Fill"),
opacity, paint_mode,
NULL, x1, y1);
tile_manager_unref (buf_tiles);
/* update the image */
gimp_drawable_update (drawable, x1, y1, x2 - x1, y2 - y1);
/* free the mask */
if (mask)
g_object_unref (mask);
if (new_buf)
temp_buf_free (pat_buf);
gimp_unset_busy (image->gimp);
}
GeglBuffer *
gimp_drawable_transform_buffer_flip (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result,
gint *new_offset_x,
gint *new_offset_y)
{
GeglBuffer *new_buffer;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint orig_x, orig_y;
gint orig_width, orig_height;
gint new_x, new_y;
gint new_width, new_height;
gint i;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
orig_x = orig_offset_x;
orig_y = orig_offset_y;
orig_width = gegl_buffer_get_width (orig_buffer);
orig_height = gegl_buffer_get_height (orig_buffer);
new_x = orig_x;
new_y = orig_y;
new_width = orig_width;
new_height = orig_height;
switch (flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
new_x = RINT (-((gdouble) orig_x +
(gdouble) orig_width - axis) + axis);
break;
case GIMP_ORIENTATION_VERTICAL:
new_y = RINT (-((gdouble) orig_y +
(gdouble) orig_height - axis) + axis);
break;
case GIMP_ORIENTATION_UNKNOWN:
g_return_val_if_reached (NULL);
break;
}
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
new_width, new_height),
gegl_buffer_get_format (orig_buffer));
if (clip_result && (new_x != orig_x || new_y != orig_y))
{
GimpRGB bg;
GeglColor *color;
gint clip_x, clip_y;
gint clip_width, clip_height;
*new_offset_x = orig_x;
*new_offset_y = orig_y;
/* "Outside" a channel is transparency, not the bg color */
if (GIMP_IS_CHANNEL (drawable))
gimp_rgba_set (&bg, 0.0, 0.0, 0.0, 0.0);
else
gimp_context_get_background (context, &bg);
color = gimp_gegl_color_new (&bg);
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
if (gimp_rectangle_intersect (orig_x, orig_y, orig_width, orig_height,
new_x, new_y, new_width, new_height,
&clip_x, &clip_y,
&clip_width, &clip_height))
{
orig_x = new_x = clip_x - orig_x;
orig_y = new_y = clip_y - orig_y;
}
orig_width = new_width = clip_width;
orig_height = new_height = clip_height;
}
else
{
*new_offset_x = new_x;
*new_offset_y = new_y;
orig_x = 0;
orig_y = 0;
new_x = 0;
new_y = 0;
}
if (new_width == 0 && new_height == 0)
return new_buffer;
switch (flip_type)
{
case GIMP_ORIENTATION_HORIZONTAL:
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = 1;
src_rect.height = orig_height;
dest_rect.x = new_x + new_width - 1;
dest_rect.y = new_y;
dest_rect.width = 1;
dest_rect.height = new_height;
for (i = 0; i < orig_width; i++)
{
src_rect.x = i + orig_x;
dest_rect.x = new_x + new_width - i - 1;
gegl_buffer_copy (orig_buffer, &src_rect,
new_buffer, &dest_rect);
}
break;
case GIMP_ORIENTATION_VERTICAL:
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = orig_width;
src_rect.height = 1;
dest_rect.x = new_x;
dest_rect.y = new_y + new_height - 1;
dest_rect.width = new_width;
dest_rect.height = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = i + orig_y;
dest_rect.y = new_y + new_height - i - 1;
gegl_buffer_copy (orig_buffer, &src_rect,
new_buffer, &dest_rect);
}
break;
case GIMP_ORIENTATION_UNKNOWN:
break;
}
return new_buffer;
}
GimpLayer *
gimp_edit_paste (GimpImage *image,
GimpDrawable *drawable,
GimpObject *paste,
GimpPasteType paste_type,
gint viewport_x,
gint viewport_y,
gint viewport_width,
gint viewport_height)
{
GimpLayer *layer = NULL;
const Babl *floating_format;
gint offset_x;
gint offset_y;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (drawable == NULL ||
gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_IMAGE (paste) || GIMP_IS_BUFFER (paste), NULL);
/* change paste type to NEW_LAYER for cases where we can't attach a
* floating selection
*/
if (! drawable ||
gimp_viewable_get_children (GIMP_VIEWABLE (drawable)) ||
gimp_item_is_content_locked (GIMP_ITEM (drawable)))
{
paste_type = GIMP_PASTE_TYPE_NEW_LAYER;
}
/* floating pastes always have the pasted-to drawable's format with
* alpha; if drawable == NULL, user is pasting into an empty image
*/
if (drawable)
floating_format = gimp_drawable_get_format_with_alpha (drawable);
else
floating_format = gimp_image_get_layer_format (image, TRUE);
if (GIMP_IS_IMAGE (paste))
{
GType layer_type;
layer = gimp_image_get_layer_iter (GIMP_IMAGE (paste))->data;
switch (paste_type)
{
case GIMP_PASTE_TYPE_FLOATING:
case GIMP_PASTE_TYPE_FLOATING_INTO:
/* when pasting as floating selection, force creation of a
* plain layer, so gimp_item_convert() will collapse a
* group layer
*/
layer_type = GIMP_TYPE_LAYER;
break;
case GIMP_PASTE_TYPE_NEW_LAYER:
layer_type = G_TYPE_FROM_INSTANCE (layer);
break;
default:
g_return_val_if_reached (NULL);
}
layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (layer),
image, layer_type));
switch (paste_type)
{
case GIMP_PASTE_TYPE_FLOATING:
case GIMP_PASTE_TYPE_FLOATING_INTO:
/* when pasting as floating selection, get rid of the layer mask,
* and make sure the layer has the right format
*/
if (gimp_layer_get_mask (layer))
gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE);
if (gimp_drawable_get_format (GIMP_DRAWABLE (layer)) !=
floating_format)
{
gimp_drawable_convert_type (GIMP_DRAWABLE (layer), image,
gimp_drawable_get_base_type (drawable),
gimp_drawable_get_precision (drawable),
TRUE,
NULL,
GEGL_DITHER_NONE, GEGL_DITHER_NONE,
FALSE, NULL);
}
break;
default:
break;
}
}
else if (GIMP_IS_BUFFER (paste))
{
layer = gimp_layer_new_from_buffer (GIMP_BUFFER (paste), image,
floating_format,
_("Pasted Layer"),
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
}
if (! layer)
return NULL;
gimp_edit_get_paste_offset (image, drawable, GIMP_OBJECT (layer),
viewport_x,
viewport_y,
viewport_width,
viewport_height,
&offset_x,
&offset_y);
gimp_item_translate (GIMP_ITEM (layer), offset_x, offset_y, FALSE);
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
C_("undo-type", "Paste"));
switch (paste_type)
{
case GIMP_PASTE_TYPE_FLOATING:
/* if there is a selection mask clear it - this might not
* always be desired, but in general, it seems like the correct
* behavior
*/
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE);
/* fall thru */
case GIMP_PASTE_TYPE_FLOATING_INTO:
floating_sel_attach (layer, drawable);
break;
case GIMP_PASTE_TYPE_NEW_LAYER:
{
GimpLayer *parent = NULL;
gint position = 0;
/* always add on top of the passed layer, where we would
* attach a floating selection
*/
if (GIMP_IS_LAYER (drawable))
{
parent = gimp_layer_get_parent (GIMP_LAYER (drawable));
position = gimp_item_get_index (GIMP_ITEM (drawable));
}
gimp_image_add_layer (image, layer, parent, position, TRUE);
}
break;
}
gimp_image_undo_group_end (image);
return layer;
}
GeglBuffer *
gimp_drawable_transform_buffer_rotate (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result,
gint *new_offset_x,
gint *new_offset_y)
{
GeglBuffer *new_buffer;
GeglRectangle src_rect;
GeglRectangle dest_rect;
gint orig_x, orig_y;
gint orig_width, orig_height;
gint orig_bpp;
gint new_x, new_y;
gint new_width, new_height;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
orig_x = orig_offset_x;
orig_y = orig_offset_y;
orig_width = gegl_buffer_get_width (orig_buffer);
orig_height = gegl_buffer_get_height (orig_buffer);
orig_bpp = babl_format_get_bytes_per_pixel (gegl_buffer_get_format (orig_buffer));
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_drawable_transform_rotate_point (orig_x,
orig_y + orig_height,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_height;
new_height = orig_width;
break;
case GIMP_ROTATE_180:
gimp_drawable_transform_rotate_point (orig_x + orig_width,
orig_y + orig_height,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_width;
new_height = orig_height;
break;
case GIMP_ROTATE_270:
gimp_drawable_transform_rotate_point (orig_x + orig_width,
orig_y,
rotate_type, center_x, center_y,
&new_x, &new_y);
new_width = orig_height;
new_height = orig_width;
break;
default:
g_return_val_if_reached (NULL);
break;
}
if (clip_result && (new_x != orig_x || new_y != orig_y ||
new_width != orig_width || new_height != orig_height))
{
GimpRGB bg;
GeglColor *color;
gint clip_x, clip_y;
gint clip_width, clip_height;
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
orig_width, orig_height),
gegl_buffer_get_format (orig_buffer));
*new_offset_x = orig_x;
*new_offset_y = orig_y;
/* "Outside" a channel is transparency, not the bg color */
if (GIMP_IS_CHANNEL (drawable))
gimp_rgba_set (&bg, 0.0, 0.0, 0.0, 0.0);
else
gimp_context_get_background (context, &bg);
color = gimp_gegl_color_new (&bg);
gegl_buffer_set_color (new_buffer, NULL, color);
g_object_unref (color);
if (gimp_rectangle_intersect (orig_x, orig_y, orig_width, orig_height,
new_x, new_y, new_width, new_height,
&clip_x, &clip_y,
&clip_width, &clip_height))
{
gint saved_orig_x = orig_x;
gint saved_orig_y = orig_y;
new_x = clip_x - orig_x;
new_y = clip_y - orig_y;
switch (rotate_type)
{
case GIMP_ROTATE_90:
gimp_drawable_transform_rotate_point (clip_x + clip_width,
clip_y,
GIMP_ROTATE_270,
center_x,
center_y,
&orig_x,
&orig_y);
orig_x -= saved_orig_x;
orig_y -= saved_orig_y;
orig_width = clip_height;
orig_height = clip_width;
break;
case GIMP_ROTATE_180:
orig_x = clip_x - orig_x;
orig_y = clip_y - orig_y;
orig_width = clip_width;
orig_height = clip_height;
break;
case GIMP_ROTATE_270:
gimp_drawable_transform_rotate_point (clip_x,
clip_y + clip_height,
GIMP_ROTATE_90,
center_x,
center_y,
&orig_x,
&orig_y);
orig_x -= saved_orig_x;
orig_y -= saved_orig_y;
orig_width = clip_height;
orig_height = clip_width;
break;
}
new_width = clip_width;
new_height = clip_height;
}
else
{
new_width = 0;
new_height = 0;
}
}
else
{
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
new_width, new_height),
gegl_buffer_get_format (orig_buffer));
*new_offset_x = new_x;
*new_offset_y = new_y;
orig_x = 0;
orig_y = 0;
new_x = 0;
new_y = 0;
}
if (new_width < 1 || new_height < 1)
return new_buffer;
src_rect.x = orig_x;
src_rect.y = orig_y;
src_rect.width = orig_width;
src_rect.height = orig_height;
dest_rect.x = new_x;
dest_rect.y = new_y;
dest_rect.width = new_width;
dest_rect.height = new_height;
switch (rotate_type)
{
case GIMP_ROTATE_90:
{
guchar *buf = g_new (guchar, new_height * orig_bpp);
gint i;
g_assert (new_height == orig_width);
src_rect.y = orig_y + orig_height - 1;
src_rect.height = 1;
dest_rect.x = new_x;
dest_rect.width = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = orig_y + orig_height - 1 - i;
dest_rect.x = new_x + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
case GIMP_ROTATE_180:
{
guchar *buf = g_new (guchar, new_width * orig_bpp);
gint i, j, k;
g_assert (new_width == orig_width);
src_rect.y = orig_y + orig_height - 1;
src_rect.height = 1;
dest_rect.y = new_y;
dest_rect.height = 1;
for (i = 0; i < orig_height; i++)
{
src_rect.y = orig_y + orig_height - 1 - i;
dest_rect.y = new_y + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
for (j = 0; j < orig_width / 2; j++)
{
guchar *left = buf + j * orig_bpp;
guchar *right = buf + (orig_width - 1 - j) * orig_bpp;
for (k = 0; k < orig_bpp; k++)
{
guchar tmp = left[k];
left[k] = right[k];
right[k] = tmp;
}
}
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
case GIMP_ROTATE_270:
{
guchar *buf = g_new (guchar, new_width * orig_bpp);
gint i;
g_assert (new_width == orig_height);
src_rect.x = orig_x + orig_width - 1;
src_rect.width = 1;
dest_rect.y = new_y;
dest_rect.height = 1;
for (i = 0; i < orig_width; i++)
{
src_rect.x = orig_x + orig_width - 1 - i;
dest_rect.y = new_y + i;
gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, buf,
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
gegl_buffer_set (new_buffer, &dest_rect, 0, NULL, buf,
GEGL_AUTO_ROWSTRIDE);
}
g_free (buf);
}
break;
}
return new_buffer;
}
void
gimp_drawable_blend (GimpDrawable *drawable,
GimpContext *context,
GimpGradient *gradient,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble startx,
gdouble starty,
gdouble endx,
gdouble endy,
GimpProgress *progress)
{
GimpImage *image;
GeglBuffer *buffer;
gint x, y, width, height;
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
g_return_if_fail (GIMP_IS_CONTEXT (context));
g_return_if_fail (GIMP_IS_GRADIENT (gradient));
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
image = gimp_item_get_image (GIMP_ITEM (drawable));
if (! gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &width, &height))
return;
gimp_set_busy (image->gimp);
/* Always create an alpha temp buf (for generality) */
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
gimp_drawable_get_format_with_alpha (drawable));
gradient_fill_region (image, drawable, context,
buffer, GEGL_RECTANGLE (0, 0, width, height),
gradient, gradient_type, offset, repeat, reverse,
supersample, max_depth, threshold, dither,
(startx - x), (starty - y),
(endx - x), (endy - y),
progress);
gimp_drawable_apply_buffer (drawable, buffer,
GEGL_RECTANGLE (0, 0, width, height),
TRUE, C_("undo-type", "Blend"),
opacity, paint_mode,
NULL, x, y);
/* update the image */
gimp_drawable_update (drawable, x, y, width, height);
/* free the temporary buffer */
g_object_unref (buffer);
gimp_unset_busy (image->gimp);
}
GeglBuffer *
gimp_drawable_transform_buffer_affine (GimpDrawable *drawable,
GimpContext *context,
GeglBuffer *orig_buffer,
gint orig_offset_x,
gint orig_offset_y,
const GimpMatrix3 *matrix,
GimpTransformDirection direction,
GimpInterpolationType interpolation_type,
gint recursion_level,
GimpTransformResize clip_result,
gint *new_offset_x,
gint *new_offset_y,
GimpProgress *progress)
{
GeglBuffer *new_buffer;
GimpMatrix3 m;
GimpMatrix3 inv;
gint u1, v1, u2, v2; /* source bounding box */
gint x1, y1, x2, y2; /* target bounding box */
GeglNode *affine;
GimpMatrix3 gegl_matrix;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (GEGL_IS_BUFFER (orig_buffer), NULL);
g_return_val_if_fail (matrix != NULL, NULL);
g_return_val_if_fail (new_offset_x != NULL, NULL);
g_return_val_if_fail (new_offset_y != NULL, NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
m = *matrix;
inv = *matrix;
if (direction == GIMP_TRANSFORM_BACKWARD)
{
/* keep the original matrix here, so we dont need to recalculate
* the inverse later
*/
gimp_matrix3_invert (&inv);
}
else
{
/* Find the inverse of the transformation matrix */
gimp_matrix3_invert (&m);
}
u1 = orig_offset_x;
v1 = orig_offset_y;
u2 = u1 + gegl_buffer_get_width (orig_buffer);
v2 = v1 + gegl_buffer_get_height (orig_buffer);
/* Always clip unfloated buffers since they must keep their size */
if (G_TYPE_FROM_INSTANCE (drawable) == GIMP_TYPE_CHANNEL &&
! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer)))
clip_result = GIMP_TRANSFORM_RESIZE_CLIP;
/* Find the bounding coordinates of target */
gimp_transform_resize_boundary (&inv, clip_result,
u1, v1, u2, v2,
&x1, &y1, &x2, &y2);
/* Get the new temporary buffer for the transformed result */
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
gegl_buffer_get_format (orig_buffer));
gimp_matrix3_identity (&gegl_matrix);
gimp_matrix3_translate (&gegl_matrix, u1, v1);
gimp_matrix3_mult (&inv, &gegl_matrix);
gimp_matrix3_translate (&gegl_matrix, -x1, -y1);
affine = gegl_node_new_child (NULL,
"operation", "gegl:transform",
"filter", gimp_interpolation_to_gegl_filter (interpolation_type),
"hard-edges", TRUE,
NULL);
gimp_gegl_node_set_matrix (affine, &gegl_matrix);
gimp_apply_operation (orig_buffer, progress, NULL,
affine,
new_buffer, NULL);
g_object_unref (affine);
*new_offset_x = x1;
*new_offset_y = y1;
return new_buffer;
}
GimpLayer *
text_render (GimpImage *image,
GimpDrawable *drawable,
GimpContext *context,
gint text_x,
gint text_y,
const gchar *fontname,
const gchar *text,
gint border,
gboolean antialias)
{
PangoFontDescription *desc;
GimpText *gtext;
GimpLayer *layer;
GimpRGB color;
gchar *font;
gdouble size;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (drawable == NULL || GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (drawable == NULL ||
gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (fontname != NULL, NULL);
g_return_val_if_fail (text != NULL, NULL);
if (border < 0)
border = 0;
desc = pango_font_description_from_string (fontname);
size = PANGO_PIXELS (pango_font_description_get_size (desc));
pango_font_description_unset_fields (desc, PANGO_FONT_MASK_SIZE);
font = pango_font_description_to_string (desc);
pango_font_description_free (desc);
gimp_context_get_foreground (context, &color);
gtext = g_object_new (GIMP_TYPE_TEXT,
"text", text,
"font", font,
"font-size", size,
"antialias", antialias,
"border", border,
"color", &color,
NULL);
g_free (font);
layer = gimp_text_layer_new (image, gtext);
g_object_unref (gtext);
if (!layer)
return NULL;
/* Start a group undo */
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TEXT,
_("Add Text Layer"));
/* Set the layer offsets */
gimp_item_set_offset (GIMP_ITEM (layer), text_x, text_y);
/* If there is a selection mask clear it--
* this might not always be desired, but in general,
* it seems like the correct behavior.
*/
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE);
if (drawable == NULL)
{
/* If the drawable is NULL, create a new layer */
gimp_image_add_layer (image, layer, NULL, -1, TRUE);
}
else
{
/* Otherwise, instantiate the text as the new floating selection */
floating_sel_attach (layer, drawable);
}
/* end the group undo */
gimp_image_undo_group_end (image);
return layer;
}
GeglBuffer *
gimp_drawable_transform_cut (GimpDrawable *drawable,
GimpContext *context,
gint *offset_x,
gint *offset_y,
gboolean *new_layer)
{
GimpImage *image;
GeglBuffer *buffer;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (offset_x != NULL, NULL);
g_return_val_if_fail (offset_y != NULL, NULL);
g_return_val_if_fail (new_layer != NULL, NULL);
image = gimp_item_get_image (GIMP_ITEM (drawable));
/* extract the selected mask if there is a selection */
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
{
gint x, y, w, h;
/* set the keep_indexed flag to FALSE here, since we use
* gimp_layer_new_from_buffer() later which assumes that the buffer
* are either RGB or GRAY. Eeek!!! (Sven)
*/
if (gimp_item_mask_intersect (GIMP_ITEM (drawable), &x, &y, &w, &h))
{
buffer = gimp_selection_extract (GIMP_SELECTION (gimp_image_get_mask (image)),
GIMP_PICKABLE (drawable),
context,
TRUE, FALSE, TRUE,
offset_x, offset_y,
NULL);
/* clear the selection */
gimp_channel_clear (gimp_image_get_mask (image), NULL, TRUE);
*new_layer = TRUE;
}
else
{
buffer = NULL;
*new_layer = FALSE;
}
}
else /* otherwise, just copy the layer */
{
buffer = gimp_selection_extract (GIMP_SELECTION (gimp_image_get_mask (image)),
GIMP_PICKABLE (drawable),
context,
FALSE, TRUE, GIMP_IS_LAYER (drawable),
offset_x, offset_y,
NULL);
*new_layer = FALSE;
}
return buffer;
}
void
gimp_drawable_stroke_boundary (GimpDrawable *drawable,
GimpStrokeOptions *options,
const BoundSeg *bound_segs,
gint n_bound_segs,
gint offset_x,
gint offset_y)
{
GimpScanConvert *scan_convert;
BoundSeg *stroke_segs;
gint n_stroke_segs;
GimpVector2 *points;
gint n_points;
gint seg;
gint i;
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
g_return_if_fail (GIMP_IS_STROKE_OPTIONS (options));
if (n_bound_segs == 0)
return;
g_return_if_fail (bound_segs != NULL);
stroke_segs = boundary_sort (bound_segs, n_bound_segs, &n_stroke_segs);
if (n_stroke_segs == 0)
return;
scan_convert = gimp_scan_convert_new ();
points = g_new0 (GimpVector2, n_bound_segs + 4);
seg = 0;
n_points = 0;
points[n_points].x = (gdouble) (stroke_segs[0].x1 + offset_x);
points[n_points].y = (gdouble) (stroke_segs[0].y1 + offset_y);
n_points++;
for (i = 0; i < n_stroke_segs; i++)
{
while (stroke_segs[seg].x1 != -1 ||
stroke_segs[seg].x2 != -1 ||
stroke_segs[seg].y1 != -1 ||
stroke_segs[seg].y2 != -1)
{
points[n_points].x = (gdouble) (stroke_segs[seg].x1 + offset_x);
points[n_points].y = (gdouble) (stroke_segs[seg].y1 + offset_y);
n_points++;
seg++;
}
/* Close the stroke points up */
points[n_points] = points[0];
n_points++;
gimp_scan_convert_add_polyline (scan_convert, n_points, points, TRUE);
n_points = 0;
seg++;
points[n_points].x = (gdouble) (stroke_segs[seg].x1 + offset_x);
points[n_points].y = (gdouble) (stroke_segs[seg].y1 + offset_y);
n_points++;
}
g_free (points);
g_free (stroke_segs);
gimp_drawable_stroke_scan_convert (drawable, options, scan_convert);
gimp_scan_convert_free (scan_convert);
}
gboolean
gimp_paint_core_stroke_boundary (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
gboolean emulate_dynamics,
const GimpBoundSeg *bound_segs,
gint n_bound_segs,
gint offset_x,
gint offset_y,
gboolean push_undo,
GError **error)
{
GimpBoundSeg *stroke_segs;
gint n_stroke_segs;
gint off_x;
gint off_y;
GimpCoords *coords;
gboolean initialized = FALSE;
gint n_coords;
gint seg;
gint s;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (bound_segs != NULL && n_bound_segs > 0, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
stroke_segs = gimp_boundary_sort (bound_segs, n_bound_segs,
&n_stroke_segs);
if (n_stroke_segs == 0)
return TRUE;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
off_x -= offset_x;
off_y -= offset_y;
coords = g_new0 (GimpCoords, n_bound_segs + 4);
seg = 0;
n_coords = 0;
/* we offset all coordinates by 0.5 to align the brush with the path */
coords[n_coords] = default_coords;
coords[n_coords].x = (gdouble) (stroke_segs[0].x1 - off_x + 0.5);
coords[n_coords].y = (gdouble) (stroke_segs[0].y1 - off_y + 0.5);
n_coords++;
for (s = 0; s < n_stroke_segs; s++)
{
while (stroke_segs[seg].x1 != -1 ||
stroke_segs[seg].x2 != -1 ||
stroke_segs[seg].y1 != -1 ||
stroke_segs[seg].y2 != -1)
{
coords[n_coords] = default_coords;
coords[n_coords].x = (gdouble) (stroke_segs[seg].x1 - off_x + 0.5);
coords[n_coords].y = (gdouble) (stroke_segs[seg].y1 - off_y + 0.5);
n_coords++;
seg++;
}
/* Close the stroke points up */
coords[n_coords] = coords[0];
n_coords++;
if (emulate_dynamics)
gimp_paint_core_stroke_emulate_dynamics (coords, n_coords);
if (initialized ||
gimp_paint_core_start (core, drawable, paint_options, &coords[0],
error))
{
gint i;
initialized = TRUE;
core->cur_coords = coords[0];
core->last_coords = coords[0];
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_INIT, 0);
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_MOTION, 0);
for (i = 1; i < n_coords; i++)
{
gimp_paint_core_interpolate (core, drawable, paint_options,
&coords[i], 0);
}
gimp_paint_core_paint (core, drawable, paint_options,
GIMP_PAINT_STATE_FINISH, 0);
}
else
{
break;
}
n_coords = 0;
seg++;
coords[n_coords] = default_coords;
coords[n_coords].x = (gdouble) (stroke_segs[seg].x1 - off_x + 0.5);
coords[n_coords].y = (gdouble) (stroke_segs[seg].y1 - off_y + 0.5);
n_coords++;
}
if (initialized)
{
gimp_paint_core_finish (core, drawable, push_undo);
gimp_paint_core_cleanup (core);
}
g_free (coords);
g_free (stroke_segs);
return initialized;
}
gboolean
gimp_paint_core_start (GimpPaintCore *core,
GimpDrawable *drawable,
GimpPaintOptions *paint_options,
const GimpCoords *coords,
GError **error)
{
GimpImage *image;
GimpItem *item;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), FALSE);
g_return_val_if_fail (GIMP_IS_PAINT_OPTIONS (paint_options), FALSE);
g_return_val_if_fail (coords != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
item = GIMP_ITEM (drawable);
image = gimp_item_get_image (item);
if (core->stroke_buffer)
{
g_array_free (core->stroke_buffer, TRUE);
core->stroke_buffer = NULL;
}
core->stroke_buffer = g_array_sized_new (TRUE, TRUE,
sizeof (GimpCoords),
STROKE_BUFFER_INIT_SIZE);
core->cur_coords = *coords;
if (! GIMP_PAINT_CORE_GET_CLASS (core)->start (core, drawable,
paint_options,
coords, error))
{
return FALSE;
}
/* Allocate the undo structure */
if (core->undo_buffer)
g_object_unref (core->undo_buffer);
core->undo_buffer = gegl_buffer_dup (gimp_drawable_get_buffer (drawable));
/* Allocate the saved proj structure */
if (core->saved_proj_buffer)
{
g_object_unref (core->saved_proj_buffer);
core->saved_proj_buffer = NULL;
}
if (core->use_saved_proj)
{
GimpPickable *pickable = GIMP_PICKABLE (gimp_image_get_projection (image));
GeglBuffer *buffer = gimp_pickable_get_buffer (pickable);
core->saved_proj_buffer = gegl_buffer_dup (buffer);
}
/* Allocate the canvas blocks structure */
if (core->canvas_buffer)
g_object_unref (core->canvas_buffer);
core->canvas_buffer =
gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_item_get_width (item),
gimp_item_get_height (item)),
babl_format ("Y float"));
/* Get the initial undo extents */
core->x1 = core->x2 = core->cur_coords.x;
core->y1 = core->y2 = core->cur_coords.y;
core->last_paint.x = -1e6;
core->last_paint.y = -1e6;
{
GimpChannel *mask = gimp_image_get_mask (image);
GeglBuffer *mask_buffer = NULL;
gint offset_x = 0;
gint offset_y = 0;
/* don't apply the mask to itself and don't apply an empty mask */
if (GIMP_DRAWABLE (mask) == drawable || gimp_channel_is_empty (mask))
mask = NULL;
if (mask)
{
mask_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));
gimp_item_get_offset (item, &offset_x, &offset_y);
}
core->applicator =
gimp_applicator_new (gimp_drawable_get_buffer (drawable),
gimp_drawable_get_active_mask (drawable),
mask_buffer,
-offset_x, -offset_y);
}
/* Freeze the drawable preview so that it isn't constantly updated. */
gimp_viewable_preview_freeze (GIMP_VIEWABLE (drawable));
return TRUE;
}
