graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-22 04:22:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

app/core/Makefile.am new files with functions to translate, flip, rotate,

Browse source 
2006-05-21  Michael Natterer  <mitch@gimp.org>

	* app/core/Makefile.am
	* app/core/gimpimage-item-list.[ch]: new files with functions to
	translate, flip, rotate, transform and align a list of items
	inside an undo group.

	(gimp_image_item_list_get_list): returns a list of items matching
	any combination of GimpItemTypeMask and GimpItemSet.

	* app/core/gimpitem.[ch]: added new function gimp_item_is_in_set().

	* app/core/gimpitem-linked.[ch]: use the new functions. Removed
	gimp_item_linked_get_list().

	* app/tools/gimpeditselectiontool.c: use
	gimp_image_item_list_get_list() instead of
	gimp_item_linked_get_list().

	* app/core/gimpimage-resize.c
	* app/tools/gimpaligntool.c: use the new functions instead of
	creating and iterating the lists manually.
This commit is contained in:
Michael Natterer 2006-05-21 11:32:41 +00:00 committed by Michael Natterer
parent b9416956f8
commit 3e5b6e0e05
11 changed files with 466 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
ChangeLog
View file

@ -1,3 +1,26 @@
2006-05-21 Michael Natterer <mitch@gimp.org>
* app/core/Makefile.am
* app/core/gimpimage-item-list.[ch]: new files with functions to
translate, flip, rotate, transform and align a list of items
inside an undo group.
(gimp_image_item_list_get_list): returns a list of items matching
any combination of GimpItemTypeMask and GimpItemSet.
* app/core/gimpitem.[ch]: added new function gimp_item_is_in_set().
* app/core/gimpitem-linked.[ch]: use the new functions. Removed
gimp_item_linked_get_list().
* app/tools/gimpeditselectiontool.c: use
gimp_image_item_list_get_list() instead of
gimp_item_linked_get_list().
* app/core/gimpimage-resize.c
* app/tools/gimpaligntool.c: use the new functions instead of
creating and iterating the lists manually.
2006-05-20 Manish Singh <yosh@gimp.org>
Fixes to address -ansi -pedantic compilation (bug #342390).

2
app/core/Makefile.am
View file

@ -142,6 +142,8 @@ libappcore_a_sources = \
gimpimage-grid.c \
gimpimage-guides.c \
gimpimage-guides.h \
gimpimage-item-list.c \
gimpimage-item-list.h \
gimpimage-merge.c \
gimpimage-merge.h \
gimpimage-new.c \

241
app/core/gimpimage-item-list.c Normal file
View file

@ -0,0 +1,241 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <glib-object.h>
#include "core-types.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimpimage-item-list.h"
#include "gimpimage-undo.h"
#include "gimpitem.h"
#include "gimpitem-align.h"
#include "gimplist.h"
#include "gimpprogress.h"
#include "gimp-intl.h"
/* public functions */
void
gimp_image_item_list_translate (GimpImage *image,
GList *list,
gint offset_x,
gint offset_y,
gboolean push_undo)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
if (list)
{
GList *l;
if (push_undo)
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_DISPLACE,
_("Translate Items"));
for (l = list; l; l = g_list_next (l))
gimp_item_translate (GIMP_ITEM (l->data),
offset_x, offset_y, push_undo);
if (push_undo)
gimp_image_undo_group_end (image);
}
}
void
gimp_image_item_list_flip (GimpImage *image,
GList *list,
GimpContext *context,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (GIMP_IS_CONTEXT (context));
if (list)
{
GList *l;
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,
_("Flip Items"));
for (l = list; l; l = g_list_next (l))
gimp_item_flip (GIMP_ITEM (l->data), context,
flip_type, axis, clip_result);
gimp_image_undo_group_end (image);
}
}
void
gimp_image_item_list_rotate (GimpImage *image,
GList *list,
GimpContext *context,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (GIMP_IS_CONTEXT (context));
if (list)
{
GList *l;
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,
_("Rotate Items"));
for (l = list; l; l = g_list_next (l))
gimp_item_rotate (GIMP_ITEM (l->data), context,
rotate_type, center_x, center_y, clip_result);
gimp_image_undo_group_end (image);
}
}
void
gimp_image_item_list_transform (GimpImage *image,
GList *list,
GimpContext *context,
const GimpMatrix3 *matrix,
GimpTransformDirection direction,
GimpInterpolationType interpolation_type,
gboolean supersample,
gint recursion_level,
gboolean clip_result,
GimpProgress *progress)
{
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));
if (list)
{
GList *l;
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_TRANSFORM,
_("Transform Items"));
for (l = list; l; l = g_list_next (l))
gimp_item_transform (GIMP_ITEM (l->data), context,
matrix, direction,
interpolation_type,
supersample, recursion_level,
clip_result, progress);
gimp_image_undo_group_end (image);
}
}
void
gimp_image_item_list_align (GimpImage *image,
GList *list,
GimpAlignmentType alignment,
GimpItem *reference,
GimpAlignmentType reference_alignment,
gint offset)
{
g_return_if_fail (GIMP_IS_IMAGE (image));
g_return_if_fail (GIMP_IS_ITEM (reference));
if (list)
{
GList *l;
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_DISPLACE,
_("Align Items"));
for (l = list; l; l = g_list_next (l))
gimp_item_align (GIMP_ITEM (l->data), alignment,
reference, reference_alignment, offset);
gimp_image_undo_group_end (image);
}
}
/**
* gimp_image_item_list_get_list:
* @item: A linked @item.
* @which: Which items to return.
*
* This function returns a #GList og #GimpItem's for which the
* "linked" property is #TRUE. Note that the passed in @item
* must be linked too.
*
* Return value: The list of linked items, excluding the passed @item.
**/
GList *
gimp_image_item_list_get_list (GimpImage *image,
GimpItem *exclude,
GimpItemTypeMask type,
GimpItemSet set)
{
GList *list;
GList *return_list = NULL;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (exclude == NULL || GIMP_IS_ITEM (exclude), NULL);
if (type & GIMP_ITEM_TYPE_LAYERS)
{
for (list = GIMP_LIST (image->layers)->list;
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
if (item != exclude && gimp_item_is_in_set (item, set))
return_list = g_list_prepend (return_list, item);
}
}
if (type & GIMP_ITEM_TYPE_CHANNELS)
{
for (list = GIMP_LIST (image->channels)->list;
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
if (item != exclude && gimp_item_is_in_set (item, set))
return_list = g_list_prepend (return_list, item);
}
}
if (type & GIMP_ITEM_TYPE_VECTORS)
{
for (list = GIMP_LIST (image->vectors)->list;
list;
list = g_list_next (list))
{
GimpItem *item = list->data;
if (item != exclude && gimp_item_is_in_set (item, set))
return_list = g_list_prepend (return_list, item);
}
}
return g_list_reverse (return_list);
}

64
app/core/gimpimage-item-list.h Normal file
View file

@ -0,0 +1,64 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_IMAGE_ITEM_LIST_H__
#define __GIMP_IMAGE_ITEM_LIST_H__
void gimp_image_item_list_translate (GimpImage *image,
GList *list,
gint offset_x,
gint offset_y,
gboolean push_undo);
void gimp_image_item_list_flip (GimpImage *image,
GList *list,
GimpContext *context,
GimpOrientationType flip_type,
gdouble axis,
gboolean clip_result);
void gimp_image_item_list_rotate (GimpImage *image,
GList *list,
GimpContext *context,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gboolean clip_result);
void gimp_image_item_list_transform (GimpImage *image,
GList *list,
GimpContext *context,
const GimpMatrix3 *matrix,
GimpTransformDirection direction,
GimpInterpolationType interpolation_type,
gboolean supersample,
gint recursion_level,
gboolean clip_result,
GimpProgress *progress);
void gimp_image_item_list_align (GimpImage *image,
GList *list,
GimpAlignmentType alignment,
GimpItem *reference,
GimpAlignmentType reference_alignment,
gint offset);
GList * gimp_image_item_list_get_list (GimpImage *image,
GimpItem *exclude,
GimpItemTypeMask type,
GimpItemSet set);
#endif /* __GIMP_IMAGE_ITEM_LIST_H__ */

36
app/core/gimpimage-resize.c
View file

@ -26,6 +26,7 @@
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimpimage-guides.h"
#include "gimpimage-item-list.h"
#include "gimpimage-resize.h"
#include "gimpimage-sample-points.h"
#include "gimpimage-undo.h"
@ -63,6 +64,7 @@ gimp_image_resize_with_layers (GimpImage *image,
GimpProgress *progress)
{
GList *list;
GList *resize_layers;
gdouble progress_max;
gdouble progress_current = 1.0;
gint old_width, old_height;
@ -84,6 +86,10 @@ gimp_image_resize_with_layers (GimpImage *image,
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_RESIZE,
_("Resize Image"));
resize_layers = gimp_image_item_list_get_list (image, NULL,
GIMP_ITEM_TYPE_LAYERS,
layer_set);
old_width = image->width;
old_height = image->height;
@ -145,33 +151,7 @@ gimp_image_resize_with_layers (GimpImage *image,
gimp_item_translate (item, offset_x, offset_y, TRUE);
switch (layer_set)
{
case GIMP_ITEM_SET_ALL:
resize = TRUE;
break;
case GIMP_ITEM_SET_IMAGE_SIZED:
resize = (old_offset_x == 0 &&
old_offset_y == 0 &&
gimp_item_width (item) == old_width &&
gimp_item_height (item) == old_height);
break;
case GIMP_ITEM_SET_VISIBLE:
resize = gimp_item_get_visible (item);
break;
case GIMP_ITEM_SET_LINKED:
resize = gimp_item_get_linked (item);
break;
default:
resize = FALSE;
break;
}
if (resize)
if (g_list_find (resize_layers, item))
gimp_item_resize (item, context,
new_width, new_height,
offset_x + old_offset_x, offset_y + old_offset_y);
@ -180,6 +160,8 @@ gimp_image_resize_with_layers (GimpImage *image,
gimp_progress_set_value (progress, progress_current++ / progress_max);
}
g_list_free (resize_layers);
/* Reposition or remove all guides */
list = image->guides;
while (list)

137
app/core/gimpitem-linked.c
View file

@ -24,6 +24,7 @@
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimpimage-item-list.h"
#include "gimpitem.h"
#include "gimpitem-linked.h"
#include "gimplist.h"
@ -38,20 +39,20 @@ gimp_item_linked_translate (GimpItem *item,
gint offset_y,
gboolean push_undo)
{
GList *linked_list;
GList *list;
g_return_if_fail (GIMP_IS_ITEM (item));
g_return_if_fail (gimp_item_get_linked (item) == TRUE);
g_return_if_fail (gimp_item_is_attached (item));
linked_list = gimp_item_linked_get_list (item, GIMP_ITEM_TYPE_ALL);
list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
GIMP_ITEM_TYPE_ALL,
GIMP_ITEM_SET_LINKED);
for (list = linked_list; list; list = g_list_next (list))
gimp_item_translate (GIMP_ITEM (list->data),
offset_x, offset_y, push_undo);
gimp_image_item_list_translate (gimp_item_get_image (item), list,
offset_x, offset_y, push_undo);
g_list_free (linked_list);
g_list_free (list);
}
void
@ -61,7 +62,6 @@ gimp_item_linked_flip (GimpItem *item,
gdouble axis,
gboolean clip_result)
{
GList *linked_list;
GList *list;
g_return_if_fail (GIMP_IS_ITEM (item));
@ -69,13 +69,14 @@ gimp_item_linked_flip (GimpItem *item,
g_return_if_fail (gimp_item_get_linked (item) == TRUE);
g_return_if_fail (gimp_item_is_attached (item));
linked_list = gimp_item_linked_get_list (item, GIMP_ITEM_TYPE_ALL);
list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
GIMP_ITEM_TYPE_ALL,
GIMP_ITEM_SET_LINKED);
for (list = linked_list; list; list = g_list_next (list))
gimp_item_flip (GIMP_ITEM (list->data), context,
flip_type, axis, clip_result);
gimp_image_item_list_flip (gimp_item_get_image (item), list, context,
flip_type, axis, clip_result);
g_list_free (linked_list);
g_list_free (list);
}
void
@ -86,7 +87,6 @@ gimp_item_linked_rotate (GimpItem *item,
gdouble center_y,
gboolean clip_result)
{
GList *linked_list;
GList *list;
g_return_if_fail (GIMP_IS_ITEM (item));
@ -94,23 +94,24 @@ gimp_item_linked_rotate (GimpItem *item,
g_return_if_fail (gimp_item_get_linked (item) == TRUE);
g_return_if_fail (gimp_item_is_attached (item));
linked_list = gimp_item_linked_get_list (item,
GIMP_ITEM_TYPE_LAYERS |
GIMP_ITEM_TYPE_VECTORS);
list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
GIMP_ITEM_TYPE_LAYERS |
GIMP_ITEM_TYPE_VECTORS,
GIMP_ITEM_SET_LINKED);
for (list = linked_list; list; list = g_list_next (list))
gimp_item_rotate (GIMP_ITEM (list->data), context,
rotate_type, center_x, center_y, clip_result);
gimp_image_item_list_rotate (gimp_item_get_image (item), list, context,
rotate_type, center_x, center_y, clip_result);
g_list_free (linked_list);
g_list_free (list);
linked_list = gimp_item_linked_get_list (item, GIMP_ITEM_TYPE_CHANNELS);
list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
GIMP_ITEM_TYPE_CHANNELS,
GIMP_ITEM_SET_LINKED);
for (list = linked_list; list; list = g_list_next (list))
gimp_item_rotate (GIMP_ITEM (list->data), context,
rotate_type, center_x, center_y, TRUE);
gimp_image_item_list_rotate (gimp_item_get_image (item), list, context,
rotate_type, center_x, center_y, TRUE);
g_list_free (linked_list);
g_list_free (list);
}
void
@ -124,7 +125,6 @@ gimp_item_linked_transform (GimpItem *item,
gboolean clip_result,
GimpProgress *progress)
{
GList *linked_list;
GList *list;
g_return_if_fail (GIMP_IS_ITEM (item));
@ -133,82 +133,15 @@ gimp_item_linked_transform (GimpItem *item,
g_return_if_fail (gimp_item_is_attached (item));
g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
linked_list = gimp_item_linked_get_list (item, GIMP_ITEM_TYPE_ALL);
list = gimp_image_item_list_get_list (gimp_item_get_image (item), item,
GIMP_ITEM_TYPE_ALL,
GIMP_ITEM_SET_LINKED);
for (list = linked_list; list; list = g_list_next (list))
gimp_item_transform (GIMP_ITEM (list->data), context,
matrix, direction,
interpolation_type,
supersample, recursion_level,
clip_result, progress);
gimp_image_item_list_transform (gimp_item_get_image (item), list, context,
matrix, direction,
interpolation_type,
supersample, recursion_level,
clip_result, progress);
g_list_free (linked_list);
}
/**
* gimp_item_linked_get_list:
* @item: A linked @item.
* @which: Which items to return.
*
* This function returns a #GList og #GimpItem's for which the
* "linked" property is #TRUE. Note that the passed in @item
* must be linked too.
*
* Return value: The list of linked items, excluding the passed @item.
**/
GList *
gimp_item_linked_get_list (GimpItem *item,
GimpItemTypeMask which)
{
GimpImage *image;
GimpItem *linked_item;
GList *list;
GList *linked_list = NULL;
g_return_val_if_fail (GIMP_IS_ITEM (item), NULL);
g_return_val_if_fail (gimp_item_get_linked (item), NULL);
g_return_val_if_fail (gimp_item_is_attached (item), NULL);
image = gimp_item_get_image (item);
if (which & GIMP_ITEM_TYPE_LAYERS)
{
for (list = GIMP_LIST (image->layers)->list;
list;
list = g_list_next (list))
{
linked_item = list->data;
if (linked_item != item && gimp_item_get_linked (linked_item))
linked_list = g_list_prepend (linked_list, linked_item);
}
}
if (which & GIMP_ITEM_TYPE_CHANNELS)
{
for (list = GIMP_LIST (image->channels)->list;
list;
list = g_list_next (list))
{
linked_item = list->data;
if (linked_item != item && gimp_item_get_linked (linked_item))
linked_list = g_list_prepend (linked_list, linked_item);
}
}
if (which & GIMP_ITEM_TYPE_VECTORS)
{
for (list = GIMP_LIST (image->vectors)->list;
list;
list = g_list_next (list))
{
linked_item = list->data;
if (linked_item != item && gimp_item_get_linked (linked_item))
linked_list = g_list_prepend (linked_list, linked_item);
}
}
return g_list_reverse (linked_list);
g_list_free (list);
}

3
app/core/gimpitem-linked.h
View file

@ -45,8 +45,5 @@ void gimp_item_linked_transform (GimpItem *item,
gboolean clip_result,
GimpProgress *progress);
GList * gimp_item_linked_get_list (GimpItem *item,
GimpItemTypeMask which);
#endif /* __GIMP_ITEM_LINKED_H__ */

28
app/core/gimpitem.c
View file

@ -1329,3 +1329,31 @@ gimp_item_get_linked (const GimpItem *item)
return item->linked;
}
gboolean
gimp_item_is_in_set (GimpItem *item,
GimpItemSet set)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
switch (set)
{
case GIMP_ITEM_SET_NONE:
return FALSE;
case GIMP_ITEM_SET_ALL:
return TRUE;
case GIMP_ITEM_SET_IMAGE_SIZED:
return (item->width == item->image->width &&
item->height == item->image->height);
case GIMP_ITEM_SET_VISIBLE:
return gimp_item_get_visible (item);
case GIMP_ITEM_SET_LINKED:
return gimp_item_get_linked (item);
}
return FALSE;
}

3
app/core/gimpitem.h
View file

@ -252,5 +252,8 @@ void gimp_item_set_linked (GimpItem *item,
gboolean push_undo);
gboolean gimp_item_get_linked (const GimpItem *item);
gboolean gimp_item_is_in_set (GimpItem *item,
GimpItemSet set);
#endif /* __GIMP_ITEM_H__ */

78
app/tools/gimpaligntool.c
View file

@ -26,17 +26,15 @@
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "core/gimpimage-undo.h"
#include "core/gimpimage-item-list.h"
#include "core/gimplayer.h"
#include "core/gimptoolinfo.h"
#include "core/gimpitem-align.h"
#include "core/gimplist.h"
#include "display/gimpdisplay.h"
#include "widgets/gimphelp-ids.h"
#include "gimpdrawtool.h"
#include "display/gimpdisplay.h"
#include "gimpalignoptions.h"
#include "gimpaligntool.h"
#include "gimptoolcontrol.h"
@ -621,41 +619,29 @@ static void
do_horizontal_alignment (GtkWidget *widget,
gpointer data)
{
GimpAlignTool *align_tool = data;
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (data);
GimpImage *image;
GimpItem *item0;
GList *list;
GimpItem *reference;
/* make sure there is something to align */
if (! g_list_nth (align_tool->selected_items, 1))
return;
image = GIMP_TOOL (align_tool)->display->image;
item0 = g_list_first (align_tool->selected_items)->data;
reference = align_tool->selected_items->data;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_DISPLACE,
_("Align items"));
for (list = g_list_next (align_tool->selected_items); list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_align (item,
align_tool->horz_align_type,
item0,
align_tool->horz_align_type,
align_tool->horz_offset);
}
gimp_image_undo_group_end (image);
if (GIMP_TOOL (align_tool)->display)
gimp_image_flush (image);
gimp_image_item_list_align (image, g_list_next (align_tool->selected_items),
align_tool->horz_align_type,
reference,
align_tool->horz_align_type,
align_tool->horz_offset);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));
gimp_image_flush (image);
}
@ -663,41 +649,29 @@ static void
do_vertical_alignment (GtkWidget *widget,
gpointer data)
{
GimpAlignTool *align_tool = data;
GimpAlignTool *align_tool = GIMP_ALIGN_TOOL (data);
GimpImage *image;
GimpItem *item0;
GList *list;
GimpItem *reference;
/* make sure there is something to align */
if (! g_list_nth (align_tool->selected_items, 1))
if (g_list_nth (align_tool->selected_items, 1))
return;
image = GIMP_TOOL (align_tool)->display->image;
item0 = g_list_first (align_tool->selected_items)->data;
reference = align_tool->selected_items->data;
gimp_draw_tool_pause (GIMP_DRAW_TOOL (align_tool));
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_DISPLACE,
_("Align items"));
for (list = g_list_next (align_tool->selected_items); list;
list = g_list_next (list))
{
GimpItem *item = list->data;
gimp_item_align (item,
align_tool->vert_align_type,
item0,
align_tool->vert_align_type,
align_tool->vert_offset);
}
gimp_image_undo_group_end (image);
if (GIMP_TOOL (align_tool)->display)
gimp_image_flush (GIMP_TOOL (align_tool)->display->image);
gimp_image_item_list_align (image, g_list_next (align_tool->selected_items),
align_tool->vert_align_type,
reference,
align_tool->vert_align_type,
align_tool->vert_offset);
gimp_draw_tool_resume (GIMP_DRAW_TOOL (align_tool));
gimp_image_flush (image);
}

59
app/tools/gimpeditselectiontool.c
View file

@ -35,6 +35,7 @@
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "core/gimpimage-guides.h"
#include "core/gimpimage-item-list.h"
#include "core/gimpimage-undo.h"
#include "core/gimpitem-linked.h"
#include "core/gimplayer.h"
@ -340,8 +341,10 @@ gimp_edit_selection_tool_start (GimpTool *parent_tool,
GList *linked;
GList *list;
linked = gimp_item_linked_get_list (active_item,
GIMP_ITEM_TYPE_LAYERS);
linked = gimp_image_item_list_get_list (display->image,
active_item,
GIMP_ITEM_TYPE_LAYERS,
GIMP_ITEM_SET_LINKED);
/* Expand the rectangle to include all linked layers as well */
for (list = linked; list; list = g_list_next (list))
@ -383,8 +386,10 @@ gimp_edit_selection_tool_start (GimpTool *parent_tool,
GList *linked;
GList *list;
linked = gimp_item_linked_get_list (active_item,
GIMP_ITEM_TYPE_VECTORS);
linked = gimp_image_item_list_get_list (display->image,
active_item,
GIMP_ITEM_TYPE_VECTORS,
GIMP_ITEM_SET_LINKED);
for (list = linked; list; list = g_list_next (list))
{
@ -508,16 +513,17 @@ gimp_edit_selection_tool_button_release (GimpTool *tool,
/* translate all linked channels as well */
GList *linked;
GList *list;
linked = gimp_item_linked_get_list (active_item,
GIMP_ITEM_TYPE_CHANNELS);
linked = gimp_image_item_list_get_list (display->image,
active_item,
GIMP_ITEM_TYPE_CHANNELS,
GIMP_ITEM_SET_LINKED);
for (list = linked; list; list = g_list_next (list))
gimp_item_translate (GIMP_ITEM (list->data),
edit_select->cumlx,
edit_select->cumly,
TRUE);
gimp_image_item_list_translate (display->image,
linked,
edit_select->cumlx,
edit_select->cumly,
TRUE);
g_list_free (linked);
}
@ -635,16 +641,17 @@ gimp_edit_selection_tool_motion (GimpTool *tool,
/* translate all linked layers & vectors as well */
GList *linked;
GList *list;
linked = gimp_item_linked_get_list (active_item,
GIMP_ITEM_TYPE_LAYERS |
GIMP_ITEM_TYPE_VECTORS);
linked = gimp_image_item_list_get_list (display->image,
active_item,
GIMP_ITEM_TYPE_LAYERS |
GIMP_ITEM_TYPE_VECTORS,
GIMP_ITEM_SET_LINKED);
for (list = linked; list; list = g_list_next (list))
gimp_item_translate (GIMP_ITEM (list->data),
xoffset, yoffset,
edit_select->first_move);
gimp_image_item_list_translate (display->image,
linked,
xoffset, yoffset,
edit_select->first_move);
g_list_free (linked);
}
@ -799,8 +806,10 @@ gimp_edit_selection_tool_draw (GimpDrawTool *draw_tool)
GList *linked;
GList *list;
linked = gimp_item_linked_get_list (active_item,
GIMP_ITEM_TYPE_LAYERS);
linked = gimp_image_item_list_get_list (display->image,
active_item,
GIMP_ITEM_TYPE_LAYERS,
GIMP_ITEM_SET_LINKED);
for (list = linked; list; list = g_list_next (list))
{
@ -850,8 +859,10 @@ gimp_edit_selection_tool_draw (GimpDrawTool *draw_tool)
GList *linked;
GList *list;
linked = gimp_item_linked_get_list (active_item,
GIMP_ITEM_TYPE_VECTORS);
linked = gimp_image_item_list_get_list (display->image,
active_item,
GIMP_ITEM_TYPE_VECTORS,
GIMP_ITEM_SET_LINKED);
for (list = linked; list; list = g_list_next (list))
{