void
gimp_image_convert_precision (GimpImage *image,
GimpPrecision precision,
gint layer_dither_type,
gint text_layer_dither_type,
gint mask_dither_type,
GimpProgress *progress)
{
GList *all_drawables;
GList *list;
const gchar *undo_desc = NULL;
gint nth_drawable, n_drawables;
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (precision != gimp_image_get_precision (image));
g_return_if_fail (precision == GIMP_PRECISION_U8_GAMMA ||
gimp_image_get_base_type (image) != GIMP_INDEXED);
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
all_drawables = g_list_concat (gimp_image_get_layer_list (image),
gimp_image_get_channel_list (image));
n_drawables = g_list_length (all_drawables) + 1 /* + selection */;
switch (precision)
{
case GIMP_PRECISION_U8_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 8 bit linear integer");
break;
case GIMP_PRECISION_U8_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 8 bit gamma integer");
break;
case GIMP_PRECISION_U16_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 16 bit linear integer");
break;
case GIMP_PRECISION_U16_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 16 bit gamma integer");
break;
case GIMP_PRECISION_U32_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 32 bit linear integer");
break;
case GIMP_PRECISION_U32_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 32 bit gamma integer");
break;
case GIMP_PRECISION_HALF_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 16 bit linear floating point");
break;
case GIMP_PRECISION_HALF_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 16 bit gamma floating point");
break;
case GIMP_PRECISION_FLOAT_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 32 bit linear floating point");
break;
case GIMP_PRECISION_FLOAT_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 32 bit gamma floating point");
break;
case GIMP_PRECISION_DOUBLE_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 64 bit linear floating point");
break;
case GIMP_PRECISION_DOUBLE_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 64 bit gamma floating point");
break;
}
if (progress)
gimp_progress_start (progress, FALSE, "%s", undo_desc);
g_object_freeze_notify (G_OBJECT (image));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_CONVERT,
undo_desc);
/* Push the image precision to the stack */
gimp_image_undo_push_image_precision (image, NULL);
/* Set the new precision */
g_object_set (image, "precision", precision, NULL);
for (list = all_drawables, nth_drawable = 0;
list;
list = g_list_next (list), nth_drawable++)
{
GimpDrawable *drawable = list->data;
gint dither_type;
if (gimp_item_is_text_layer (GIMP_ITEM (drawable)))
dither_type = text_layer_dither_type;
else
dither_type = layer_dither_type;
gimp_drawable_convert_type (drawable, image,
gimp_drawable_get_base_type (drawable),
precision,
dither_type,
mask_dither_type,
FALSE,
TRUE);
if (progress)
gimp_progress_set_value (progress,
(gdouble) nth_drawable / (gdouble) n_drawables);
}
g_list_free (all_drawables);
/* convert the selection mask */
{
GimpChannel *mask = gimp_image_get_mask (image);
GeglBuffer *buffer;
gimp_image_undo_push_mask_precision (image, NULL, mask);
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image)),
gimp_image_get_mask_format (image));
gegl_buffer_copy (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)), NULL,
GEGL_ABYSS_NONE,
buffer, NULL);
gimp_drawable_set_buffer (GIMP_DRAWABLE (mask), FALSE, NULL, buffer);
g_object_unref (buffer);
nth_drawable++;
if (progress)
gimp_progress_set_value (progress,
(gdouble) nth_drawable / (gdouble) n_drawables);
}
gimp_image_undo_group_end (image);
gimp_image_precision_changed (image);
g_object_thaw_notify (G_OBJECT (image));
if (progress)
gimp_progress_end (progress);
}
void
gimp_image_convert_precision (GimpImage *image,
GimpPrecision precision,
gint layer_dither_type,
gint text_layer_dither_type,
gint mask_dither_type,
GimpProgress *progress)
{
GimpColorProfile *old_profile;
GimpColorProfile *new_profile = NULL;
const Babl *old_format;
const Babl *new_format;
GList *all_drawables;
GList *list;
const gchar *undo_desc = NULL;
GimpProgress *sub_progress = NULL;
gint nth_drawable, n_drawables;
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (precision != gimp_image_get_precision (image));
g_return_if_fail (precision == GIMP_PRECISION_U8_GAMMA ||
gimp_image_get_base_type (image) != GIMP_INDEXED);
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
all_drawables = g_list_concat (gimp_image_get_layer_list (image),
gimp_image_get_channel_list (image));
n_drawables = g_list_length (all_drawables) + 1 /* + selection */;
if (progress)
sub_progress = gimp_sub_progress_new (progress);
switch (precision)
{
case GIMP_PRECISION_U8_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 8 bit linear integer");
break;
case GIMP_PRECISION_U8_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 8 bit gamma integer");
break;
case GIMP_PRECISION_U16_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 16 bit linear integer");
break;
case GIMP_PRECISION_U16_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 16 bit gamma integer");
break;
case GIMP_PRECISION_U32_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 32 bit linear integer");
break;
case GIMP_PRECISION_U32_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 32 bit gamma integer");
break;
case GIMP_PRECISION_HALF_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 16 bit linear floating point");
break;
case GIMP_PRECISION_HALF_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 16 bit gamma floating point");
break;
case GIMP_PRECISION_FLOAT_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 32 bit linear floating point");
break;
case GIMP_PRECISION_FLOAT_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 32 bit gamma floating point");
break;
case GIMP_PRECISION_DOUBLE_LINEAR:
undo_desc = C_("undo-type", "Convert Image to 64 bit linear floating point");
break;
case GIMP_PRECISION_DOUBLE_GAMMA:
undo_desc = C_("undo-type", "Convert Image to 64 bit gamma floating point");
break;
}
if (progress)
gimp_progress_start (progress, FALSE, "%s", undo_desc);
g_object_freeze_notify (G_OBJECT (image));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_CONVERT,
undo_desc);
/* Push the image precision to the stack */
gimp_image_undo_push_image_precision (image, NULL);
old_profile = gimp_image_get_color_profile (image);
old_format = gimp_image_get_layer_format (image, FALSE);
/* Set the new precision */
g_object_set (image, "precision", precision, NULL);
new_format = gimp_image_get_layer_format (image, FALSE);
if (old_profile &&
gimp_babl_format_get_linear (old_format) !=
gimp_babl_format_get_linear (new_format))
{
GimpColorProfile *new_profile;
/* when converting between linear and gamma, we create a new
* profile using the original profile's chromacities and
* whitepoint, but a linear/sRGB-gamma TRC.
*/
if (gimp_babl_format_get_linear (new_format))
{
new_profile =
gimp_color_profile_new_linear_from_color_profile (old_profile);
}
else
{
new_profile =
gimp_color_profile_new_srgb_trc_from_color_profile (old_profile);
}
/* if a new profile cannot be be generated, convert to the
* builtin profile, which is better than leaving the user with
* broken colors
*/
if (! new_profile)
{
new_profile = gimp_image_get_builtin_color_profile (image);
g_object_ref (new_profile);
}
}
for (list = all_drawables, nth_drawable = 0;
list;
list = g_list_next (list), nth_drawable++)
{
GimpDrawable *drawable = list->data;
gint dither_type;
if (gimp_item_is_text_layer (GIMP_ITEM (drawable)))
dither_type = text_layer_dither_type;
else
dither_type = layer_dither_type;
if (sub_progress)
gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (sub_progress),
nth_drawable, n_drawables);
gimp_drawable_convert_type (drawable, image,
gimp_drawable_get_base_type (drawable),
precision,
new_profile,
dither_type,
mask_dither_type,
TRUE, sub_progress);
}
g_list_free (all_drawables);
if (old_profile)
{
gimp_image_set_color_profile (image, new_profile, NULL);
g_object_unref (new_profile);
}
/* convert the selection mask */
{
GimpChannel *mask = gimp_image_get_mask (image);
GeglBuffer *buffer;
if (sub_progress)
gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (sub_progress),
nth_drawable, n_drawables);
gimp_image_undo_push_mask_precision (image, NULL, mask);
buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0,
gimp_image_get_width (image),
gimp_image_get_height (image)),
gimp_image_get_mask_format (image));
gegl_buffer_copy (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)), NULL,
GEGL_ABYSS_NONE,
buffer, NULL);
gimp_drawable_set_buffer (GIMP_DRAWABLE (mask), FALSE, NULL, buffer);
g_object_unref (buffer);
nth_drawable++;
}
if (sub_progress)
gimp_progress_set_value (sub_progress, 1.0);
gimp_image_undo_group_end (image);
gimp_image_precision_changed (image);
g_object_thaw_notify (G_OBJECT (image));
if (sub_progress)
g_object_unref (sub_progress);
if (progress)
gimp_progress_end (progress);
}
static void
gimp_mask_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpMaskUndo *mask_undo = GIMP_MASK_UNDO (undo);
GimpChannel *channel = GIMP_CHANNEL (GIMP_ITEM_UNDO (undo)->item);
GimpDrawable *drawable = GIMP_DRAWABLE (channel);
GeglBuffer *new_buffer;
const Babl *format;
gint x1, y1, x2, y2;
gint width = 0;
gint height = 0;
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
if (gimp_channel_bounds (channel, &x1, &y1, &x2, &y2))
{
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
gimp_drawable_get_format (drawable));
gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1),
new_buffer,
GEGL_RECTANGLE (0, 0, 0, 0));
gegl_buffer_clear (gimp_drawable_get_buffer (drawable),
GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1));
}
else
{
new_buffer = NULL;
}
format = gimp_drawable_get_format (drawable);
if (mask_undo->convert_format)
{
GeglBuffer *buffer;
gint width = gimp_item_get_width (GIMP_ITEM (channel));
gint height = gimp_item_get_height (GIMP_ITEM (channel));
buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
mask_undo->format);
gegl_buffer_clear (buffer, NULL);
gimp_drawable_set_buffer (drawable, FALSE, NULL, buffer);
g_object_unref (buffer);
}
if (mask_undo->buffer)
{
width = gegl_buffer_get_width (mask_undo->buffer);
height = gegl_buffer_get_height (mask_undo->buffer);
gegl_buffer_copy (mask_undo->buffer,
NULL,
gimp_drawable_get_buffer (drawable),
GEGL_RECTANGLE (mask_undo->x, mask_undo->y, 0, 0));
g_object_unref (mask_undo->buffer);
}
/* invalidate the current bounds and boundary of the mask */
gimp_drawable_invalidate_boundary (drawable);
if (mask_undo->buffer)
{
channel->empty = FALSE;
channel->x1 = mask_undo->x;
channel->y1 = mask_undo->y;
channel->x2 = mask_undo->x + width;
channel->y2 = mask_undo->y + height;
}
else
{
channel->empty = TRUE;
channel->x1 = 0;
channel->y1 = 0;
channel->x2 = gimp_item_get_width (GIMP_ITEM (channel));
channel->y2 = gimp_item_get_height (GIMP_ITEM (channel));
}
/* we know the bounds */
channel->bounds_known = TRUE;
/* set the new mask undo parameters */
mask_undo->buffer = new_buffer;
mask_undo->x = x1;
mask_undo->y = y1;
mask_undo->format = format;
gimp_drawable_update (GIMP_DRAWABLE (channel),
0, 0,
gimp_item_get_width (GIMP_ITEM (channel)),
gimp_item_get_height (GIMP_ITEM (channel)));
}
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)))
{
GeglBuffer *new_buffer;
new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
gimp_drawable_get_format (drawable));
gimp_drawable_set_buffer (drawable, FALSE, NULL, new_buffer);
g_object_unref (new_buffer);
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);
}
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);
}
