static void
gimp_layer_prop_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpLayerPropUndo *layer_prop_undo = GIMP_LAYER_PROP_UNDO (undo);
GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_LAYER_REPOSITION:
{
gint position;
position = gimp_image_get_layer_index (undo->image, layer);
gimp_image_position_layer (undo->image, layer,
layer_prop_undo->position,
FALSE, NULL);
layer_prop_undo->position = position;
}
break;
case GIMP_UNDO_LAYER_MODE:
{
GimpLayerModeEffects mode;
mode = gimp_layer_get_mode (layer);
gimp_layer_set_mode (layer, layer_prop_undo->mode, FALSE);
layer_prop_undo->mode = mode;
}
break;
case GIMP_UNDO_LAYER_OPACITY:
{
gdouble opacity;
opacity = gimp_layer_get_opacity (layer);
gimp_layer_set_opacity (layer, layer_prop_undo->opacity, FALSE);
layer_prop_undo->opacity = opacity;
}
break;
case GIMP_UNDO_LAYER_LOCK_ALPHA:
{
gboolean lock_alpha;
lock_alpha = gimp_layer_get_lock_alpha (layer);
gimp_layer_set_lock_alpha (layer, layer_prop_undo->lock_alpha, FALSE);
layer_prop_undo->lock_alpha = lock_alpha;
}
break;
default:
g_assert_not_reached ();
}
}
/**
* gimp_text_layer_from_layer:
* @layer: a #GimpLayer object
* @text: a #GimpText object
*
* Converts a standard #GimpLayer and a #GimpText object into a
* #GimpTextLayer. The new text layer takes ownership of the @text and
* @layer objects. The @layer object is rendered unusable by this
* function. Don't even try to use if afterwards!
*
* This is a gross hack that is needed in order to load text layers
* from XCF files in a backwards-compatible way. Please don't use it
* for anything else!
*
* Return value: a newly allocated #GimpTextLayer object
**/
static GimpLayer *
gimp_text_layer_from_layer (GimpLayer *layer,
GimpText *text)
{
GimpTextLayer *text_layer;
GimpDrawable *drawable;
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
g_return_val_if_fail (GIMP_IS_TEXT (text), NULL);
text_layer = g_object_new (GIMP_TYPE_TEXT_LAYER,
"image", gimp_item_get_image (GIMP_ITEM (layer)),
NULL);
gimp_item_replace_item (GIMP_ITEM (text_layer), GIMP_ITEM (layer));
drawable = GIMP_DRAWABLE (text_layer);
gimp_drawable_steal_buffer (drawable, GIMP_DRAWABLE (layer));
gimp_layer_set_opacity (GIMP_LAYER (text_layer),
gimp_layer_get_opacity (layer), FALSE);
gimp_layer_set_mode (GIMP_LAYER (text_layer),
gimp_layer_get_mode (layer), FALSE);
gimp_layer_set_blend_space (GIMP_LAYER (text_layer),
gimp_layer_get_blend_space (layer), FALSE);
gimp_layer_set_composite_space (GIMP_LAYER (text_layer),
gimp_layer_get_composite_space (layer), FALSE);
gimp_layer_set_composite_mode (GIMP_LAYER (text_layer),
gimp_layer_get_composite_mode (layer), FALSE);
gimp_layer_set_lock_alpha (GIMP_LAYER (text_layer),
gimp_layer_get_lock_alpha (layer), FALSE);
gimp_text_layer_set_text (text_layer, text);
g_object_unref (text);
g_object_unref (layer);
return GIMP_LAYER (text_layer);
}
static gboolean apply_watermark(watermark_settings settings, image_output out)
{
gboolean success = TRUE;
gint32 layerId;
gdouble posX, posY;
gint wmwidth, wmheight, wmasc, wmdesc;
if (settings->mode) {
if (strlen(settings->text) == 0) {
return TRUE;
}
GimpRGB old_foreground, new_foreground;
gimp_context_get_foreground(&old_foreground);
gimp_rgb_parse_hex (&new_foreground, gdk_color_to_string(&(settings->color)), strlen(gdk_color_to_string(&(settings->color))));
gimp_context_set_foreground(&new_foreground);
gimp_text_get_extents_fontname(
settings->text,
pango_font_description_get_size(settings->font) / PANGO_SCALE,
GIMP_PIXELS,
pango_font_description_get_family(settings->font),
&wmwidth,
&wmheight,
&wmasc,
&wmdesc
);
if (settings->position == WM_POS_TL) {
posX = 10;
posY = 5;
}
else if (settings->position == WM_POS_TC) {
posX = (gimp_image_width(out->image_id) / 2) - (wmwidth / 2);
posY = 5;
}
else if (settings->position == WM_POS_TR) {
posX = gimp_image_width(out->image_id) - wmwidth - 10;
posY = 5;
}
else if (settings->position == WM_POS_BL) {
posX = 10;
posY = gimp_image_height(out->image_id) - wmheight - 5;
}
else if (settings->position == WM_POS_BC) {
posX = (gimp_image_width(out->image_id) / 2) - (wmwidth / 2);
posY = gimp_image_height(out->image_id) - wmheight - 5;
}
else if (settings->position == WM_POS_BR) {
posX = gimp_image_width(out->image_id) - wmwidth - 10;
posY = gimp_image_height(out->image_id) - wmheight - 5;
}
else if (settings->position == WM_POS_CL) {
posX = 10;
posY = (gimp_image_height(out->image_id) / 2) - (wmheight / 2);
}
else if (settings->position == WM_POS_CR) {
posX = gimp_image_width(out->image_id) - wmwidth - 10;
posY = (gimp_image_height(out->image_id) / 2) - (wmheight / 2);
}
else {
posX = (gimp_image_width(out->image_id) / 2) - (wmwidth / 2);
posY = (gimp_image_height(out->image_id) / 2) - (wmheight / 2);
}
layerId = gimp_text_fontname(
out->image_id,
-1,
posX,
posY,
settings->text,
-1,
TRUE,
pango_font_description_get_size(settings->font) / PANGO_SCALE,
GIMP_PIXELS,
pango_font_description_get_family(settings->font)
);
gimp_context_set_foreground(&old_foreground);
gimp_layer_set_opacity(layerId, settings->opacity);
}
else {
if (!g_file_test(settings->image_file, G_FILE_TEST_IS_REGULAR)) {//((access(settings->image_file, R_OK) == -1)) {
// error, can't access image file
return TRUE;
}
layerId = gimp_file_load_layer(
GIMP_RUN_NONINTERACTIVE,
out->image_id,
settings->image_file
);
gimp_layer_set_opacity(layerId, settings->opacity);
wmwidth = gimp_drawable_width(layerId);
wmheight = gimp_drawable_height(layerId);
#if USE_API26
gimp_image_add_layer(
out->image_id,
layerId,
0
);
#else
// starting from 2.8, gimp_image_add_layer is deprecated.
// use gimp_image_insert_layer instead
gimp_image_insert_layer(
out->image_id,
layerId,
0,
0
);
#endif
if (settings->position == WM_POS_TL) {
posX = 10;
posY = 10;
}
else if (settings->position == WM_POS_TC) {
posX = (gimp_image_width(out->image_id) / 2) - (wmwidth / 2);
posY = 10;
}
else if (settings->position == WM_POS_TR) {
posX = gimp_image_width(out->image_id) - wmwidth - 10;
posY = 10;
}
else if (settings->position == WM_POS_BL) {
posX = 10;
posY = gimp_image_height(out->image_id) - wmheight - 10;
}
else if (settings->position == WM_POS_BC) {
posX = (gimp_image_width(out->image_id) / 2) - (wmwidth / 2);
posY = gimp_image_height(out->image_id) - wmheight - 10;
}
else if (settings->position == WM_POS_BR) {
posX = gimp_image_width(out->image_id) - wmwidth - 10;
posY = gimp_image_height(out->image_id) - wmheight - 10;
}
else if (settings->position == WM_POS_CL) {
posX = 10;
posY = (gimp_image_height(out->image_id) / 2) - (wmheight / 2);
}
else if (settings->position == WM_POS_CR) {
posX = gimp_image_width(out->image_id) - wmwidth - 10;
posY = (gimp_image_height(out->image_id) / 2) - (wmheight / 2);
}
else {
posX = (gimp_image_width(out->image_id) / 2) - (wmwidth / 2);
posY = (gimp_image_height(out->image_id) / 2) - (wmheight / 2);
}
gimp_layer_set_offsets(
layerId,
posX,
posY
);
}
// refresh all drawables
g_free(out->drawable_ids);
out->drawable_ids = gimp_image_get_layers(out->image_id, &out->drawable_count);
return success;
}
static void
gimp_warp_tool_animate (GimpWarpTool *wt)
{
GimpTool *tool = GIMP_TOOL (wt);
GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt);
GimpImage *orig_image;
GimpImage *image;
GimpLayer *layer;
GimpLayer *first_layer;
GeglNode *scale_node;
GimpProgress *progress;
GtkWidget *widget;
gint i;
if (! gimp_warp_tool_get_undo_desc (tool, tool->display))
{
gimp_tool_message_literal (tool, tool->display,
_("Please add some warp strokes first."));
return;
}
/* get rid of the image map so we can use wt->graph */
if (wt->image_map)
{
gimp_image_map_abort (wt->image_map);
g_object_unref (wt->image_map);
wt->image_map = NULL;
}
gimp_progress_start (GIMP_PROGRESS (tool), FALSE,
_("Rendering Frame %d"), 1);
orig_image = gimp_item_get_image (GIMP_ITEM (tool->drawable));
image = gimp_create_image (orig_image->gimp,
gimp_item_get_width (GIMP_ITEM (tool->drawable)),
gimp_item_get_height (GIMP_ITEM (tool->drawable)),
gimp_drawable_get_base_type (tool->drawable),
gimp_drawable_get_precision (tool->drawable),
TRUE);
/* the first frame is always the unwarped image */
layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (tool->drawable), image,
GIMP_TYPE_LAYER));
gimp_object_take_name (GIMP_OBJECT (layer),
g_strdup_printf (_("Frame %d"), 1));
gimp_item_set_offset (GIMP_ITEM (layer), 0, 0);
gimp_item_set_visible (GIMP_ITEM (layer), TRUE, FALSE);
gimp_layer_set_mode (layer, GIMP_NORMAL_MODE, FALSE);
gimp_layer_set_opacity (layer, GIMP_OPACITY_OPAQUE, FALSE);
gimp_image_add_layer (image, layer, NULL, 0, FALSE);
first_layer = layer;
scale_node = gegl_node_new_child (NULL,
"operation", "gimp:scalar-multiply",
"n-components", 2,
NULL);
gimp_warp_tool_add_op (wt, scale_node);
progress = gimp_sub_progress_new (GIMP_PROGRESS (tool));
for (i = 1; i < options->n_animation_frames; i++)
{
gimp_progress_set_text (GIMP_PROGRESS (tool),
_("Rendering Frame %d"), i + 1);
gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (progress),
i, options->n_animation_frames);
layer = GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (first_layer),
GIMP_TYPE_LAYER));
gimp_object_take_name (GIMP_OBJECT (layer),
g_strdup_printf (_("Frame %d"), i + 1));
gegl_node_set (scale_node,
"factor", (gdouble) i /
(gdouble) (options->n_animation_frames - 1),
NULL);
gimp_gegl_apply_operation (gimp_drawable_get_buffer (GIMP_DRAWABLE (first_layer)),
progress,
_("Frame"),
wt->graph,
gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)),
NULL);
gimp_image_add_layer (image, layer, NULL, 0, FALSE);
}
g_object_unref (progress);
gimp_warp_tool_remove_op (wt, scale_node);
gimp_progress_end (GIMP_PROGRESS (tool));
/* recreate the image map */
gimp_warp_tool_create_image_map (wt, tool->drawable);
gimp_image_map_apply (wt->image_map, NULL);
widget = GTK_WIDGET (gimp_display_get_shell (tool->display));
gimp_create_display (orig_image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
G_OBJECT (gtk_widget_get_screen (widget)),
gimp_widget_get_monitor (widget));
g_object_unref (image);
}
