void
gimp_image_resize_with_layers (GimpImage *image,
GimpContext *context,
gint new_width,
gint new_height,
gint offset_x,
gint offset_y,
GimpItemSet layer_set,
gboolean resize_text_layers,
GimpProgress *progress)
{
GList *list;
GList *resize_layers;
gdouble progress_max;
gdouble progress_current = 1.0;
gint old_width, old_height;
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (GIMP_IS_CONTEXT (context));
g_return_if_fail (new_width > 0 && new_height > 0);
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
gimp_set_busy (image->gimp);
g_object_freeze_notify (G_OBJECT (image));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_RESIZE,
C_("undo-type", "Resize Image"));
resize_layers = gimp_image_item_list_get_list (image, NULL,
GIMP_ITEM_TYPE_LAYERS,
layer_set);
progress_max = (gimp_container_get_n_children (gimp_image_get_layers (image)) +
gimp_container_get_n_children (gimp_image_get_channels (image)) +
gimp_container_get_n_children (gimp_image_get_vectors (image)) +
g_list_length (resize_layers) +
1 /* selection */);
old_width = gimp_image_get_width (image);
old_height = gimp_image_get_height (image);
/* Push the image size to the stack */
gimp_image_undo_push_image_size (image, NULL,
-offset_x, -offset_y,
new_width, new_height);
/* Set the new width and height */
g_object_set (image,
"width", new_width,
"height", new_height,
NULL);
/* Resize all channels */
for (list = gimp_image_get_channel_iter (image);
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_resize (item, context,
new_width, new_height, offset_x, offset_y);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Resize all vectors */
for (list = gimp_image_get_vectors_iter (image);
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_resize (item, context,
new_width, new_height, offset_x, offset_y);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Don't forget the selection mask! */
gimp_item_resize (GIMP_ITEM (gimp_image_get_mask (image)), context,
new_width, new_height, offset_x, offset_y);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
/* Reposition all layers */
for (list = gimp_image_get_layer_iter (image);
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_translate (item, offset_x, offset_y, TRUE);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Resize all resize_layers to image size */
for (list = resize_layers; list; list = g_list_next (list))
{
GimpItem *item = list->data;
gint old_offset_x;
gint old_offset_y;
/* group layers can't be resized here */
if (gimp_viewable_get_children (GIMP_VIEWABLE (item)))
continue;
if (! resize_text_layers && gimp_item_is_text_layer (item))
continue;
gimp_item_get_offset (item, &old_offset_x, &old_offset_y);
gimp_item_resize (item, context,
new_width, new_height,
old_offset_x, old_offset_y);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
g_list_free (resize_layers);
/* Reposition or remove all guides */
list = gimp_image_get_guides (image);
while (list)
{
GimpGuide *guide = list->data;
gboolean remove_guide = FALSE;
gint new_position = gimp_guide_get_position (guide);
list = g_list_next (list);
switch (gimp_guide_get_orientation (guide))
{
case GIMP_ORIENTATION_HORIZONTAL:
new_position += offset_y;
if (new_position < 0 || new_position > new_height)
remove_guide = TRUE;
break;
case GIMP_ORIENTATION_VERTICAL:
new_position += offset_x;
if (new_position < 0 || new_position > new_width)
remove_guide = TRUE;
break;
default:
break;
}
if (remove_guide)
gimp_image_remove_guide (image, guide, TRUE);
else if (new_position != gimp_guide_get_position (guide))
gimp_image_move_guide (image, guide, new_position, TRUE);
}
/* Reposition or remove sample points */
list = gimp_image_get_sample_points (image);
while (list)
{
GimpSamplePoint *sample_point = list->data;
gboolean remove_sample_point = FALSE;
gint new_x = sample_point->x;
gint new_y = sample_point->y;
list = g_list_next (list);
new_y += offset_y;
if ((sample_point->y < 0) || (sample_point->y > new_height))
remove_sample_point = TRUE;
new_x += offset_x;
if ((sample_point->x < 0) || (sample_point->x > new_width))
remove_sample_point = TRUE;
if (remove_sample_point)
gimp_image_remove_sample_point (image, sample_point, TRUE);
else if (new_x != sample_point->x || new_y != sample_point->y)
gimp_image_move_sample_point (image, sample_point,
new_x, new_y, TRUE);
}
gimp_image_undo_group_end (image);
gimp_image_size_changed_detailed (image,
offset_x, offset_y,
old_width, old_height);
g_object_thaw_notify (G_OBJECT (image));
gimp_unset_busy (image->gimp);
}
static void
gimp_image_duplicate_floating_sel (GimpImage *image,
GimpImage *new_image)
{
GimpLayer *floating_sel;
GimpDrawable *floating_sel_drawable;
GList *floating_sel_path;
GimpItemStack *new_item_stack;
GimpLayer *new_floating_sel;
GimpDrawable *new_floating_sel_drawable;
floating_sel = gimp_image_get_floating_selection (image);
if (! floating_sel)
return;
floating_sel_drawable = gimp_layer_get_floating_sel_drawable (floating_sel);
if (GIMP_IS_LAYER_MASK (floating_sel_drawable))
{
GimpLayer *layer;
layer = gimp_layer_mask_get_layer (GIMP_LAYER_MASK (floating_sel_drawable));
floating_sel_path = gimp_item_get_path (GIMP_ITEM (layer));
new_item_stack = GIMP_ITEM_STACK (gimp_image_get_layers (new_image));
}
else
{
floating_sel_path = gimp_item_get_path (GIMP_ITEM (floating_sel_drawable));
if (GIMP_IS_LAYER (floating_sel_drawable))
new_item_stack = GIMP_ITEM_STACK (gimp_image_get_layers (new_image));
else
new_item_stack = GIMP_ITEM_STACK (gimp_image_get_channels (new_image));
}
/* adjust path[0] for the floating layer missing in new_image */
floating_sel_path->data =
GUINT_TO_POINTER (GPOINTER_TO_UINT (floating_sel_path->data) - 1);
if (GIMP_IS_LAYER (floating_sel_drawable))
{
new_floating_sel =
GIMP_LAYER (gimp_image_duplicate_item (GIMP_ITEM (floating_sel),
new_image));
}
else
{
/* can't use gimp_item_convert() for floating selections of channels
* or layer masks because they maybe don't have a normal layer's type
*/
new_floating_sel =
GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (floating_sel),
G_TYPE_FROM_INSTANCE (floating_sel)));
gimp_item_set_image (GIMP_ITEM (new_floating_sel), new_image);
gimp_object_set_name (GIMP_OBJECT (new_floating_sel),
gimp_object_get_name (floating_sel));
}
/* Make sure the copied layer doesn't say: "<old layer> copy" */
gimp_object_set_name (GIMP_OBJECT (new_floating_sel),
gimp_object_get_name (floating_sel));
new_floating_sel_drawable =
GIMP_DRAWABLE (gimp_item_stack_get_item_by_path (new_item_stack,
floating_sel_path));
if (GIMP_IS_LAYER_MASK (floating_sel_drawable))
new_floating_sel_drawable =
GIMP_DRAWABLE (gimp_layer_get_mask (GIMP_LAYER (new_floating_sel_drawable)));
floating_sel_attach (new_floating_sel, new_floating_sel_drawable);
g_list_free (floating_sel_path);
}
void
gimp_image_rotate (GimpImage *image,
GimpContext *context,
GimpRotationType rotate_type,
GimpProgress *progress)
{
GList *list;
gdouble center_x;
gdouble center_y;
gdouble progress_max;
gdouble progress_current = 1.0;
gint new_image_width;
gint new_image_height;
gint previous_image_width;
gint previous_image_height;
gint offset_x;
gint offset_y;
gboolean size_changed;
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (GIMP_IS_CONTEXT (context));
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
gimp_set_busy (image->gimp);
previous_image_width = gimp_image_get_width (image);
previous_image_height = gimp_image_get_height (image);
center_x = previous_image_width / 2.0;
center_y = previous_image_height / 2.0;
progress_max = (gimp_container_get_n_children (gimp_image_get_channels (image)) +
gimp_container_get_n_children (gimp_image_get_layers (image)) +
gimp_container_get_n_children (gimp_image_get_vectors (image)) +
1 /* selection */);
g_object_freeze_notify (G_OBJECT (image));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_ROTATE, NULL);
/* Resize the image (if needed) */
switch (rotate_type)
{
case GIMP_ROTATE_90:
case GIMP_ROTATE_270:
new_image_width = gimp_image_get_height (image);
new_image_height = gimp_image_get_width (image);
size_changed = TRUE;
offset_x = (gimp_image_get_width (image) - new_image_width) / 2;
offset_y = (gimp_image_get_height (image) - new_image_height) / 2;
break;
case GIMP_ROTATE_180:
new_image_width = gimp_image_get_width (image);
new_image_height = gimp_image_get_height (image);
size_changed = FALSE;
offset_x = 0;
offset_y = 0;
break;
default:
g_assert_not_reached ();
return;
}
/* Rotate all channels */
for (list = gimp_image_get_channel_iter (image);
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_rotate (item, context, rotate_type, center_x, center_y, FALSE);
gimp_item_set_offset (item, 0, 0);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Rotate all vectors */
for (list = gimp_image_get_vectors_iter (image);
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_rotate (item, context, rotate_type, center_x, center_y, FALSE);
gimp_item_set_offset (item, 0, 0);
gimp_item_set_size (item, new_image_width, new_image_height);
gimp_item_translate (item,
(new_image_width - gimp_image_get_width (image)) / 2,
(new_image_height - gimp_image_get_height (image)) / 2,
FALSE);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Don't forget the selection mask! */
{
GimpChannel *mask = gimp_image_get_mask (image);
gimp_item_rotate (GIMP_ITEM (mask), context,
rotate_type, center_x, center_y, FALSE);
gimp_item_set_offset (GIMP_ITEM (mask), 0, 0);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Rotate all layers */
for (list = gimp_image_get_layer_iter (image);
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gint off_x;
gint off_y;
gimp_item_get_offset (item, &off_x, &off_y);
gimp_item_rotate (item, context, rotate_type, center_x, center_y, FALSE);
gimp_image_rotate_item_offset (image, rotate_type, item, off_x, off_y);
if (progress)
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
/* Rotate all Guides */
gimp_image_rotate_guides (image, rotate_type);
/* Rotate all sample points */
gimp_image_rotate_sample_points (image, rotate_type);
/* Resize the image (if needed) */
if (size_changed)
{
gdouble xres;
gdouble yres;
gimp_image_undo_push_image_size (image,
NULL,
offset_x,
offset_y,
new_image_width,
new_image_height);
g_object_set (image,
"width", new_image_width,
"height", new_image_height,
NULL);
gimp_image_get_resolution (image, &xres, &yres);
if (xres != yres)
gimp_image_set_resolution (image, yres, xres);
}
gimp_image_undo_group_end (image);
if (size_changed)
gimp_image_size_changed_detailed (image,
-offset_x,
-offset_y,
previous_image_width,
previous_image_height);
g_object_thaw_notify (G_OBJECT (image));
gimp_unset_busy (image->gimp);
}
