dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make reordering items between groups work in the core and the UI 

* app/core/gimpimage.[ch]: rename all gimp_image_reposition_foo() to
  gimp_image_reorder_foo() and added "new_parent" parameters. Factor
  out calculating of the item's new container and index to a utility
  function.

* app/core/core-enums.[ch]: rename the REPOSITION undos to REORDER.

* app/core/gimpimage-undo-push.[ch]
* app/core/gimpchannelpropundo.[ch]
* app/core/gimplayerpropundo.[ch]
* app/vectors/gimpvectorspropundo.[ch]: change accordingly. Remember
  the old parent item in all item reorder undos.

* app/widgets/gimpitemtreeview.h: change GimpReorderItemFunc prototype
  accordingly.

* app/widgets/gimpchanneltreeview.c
* app/widgets/gimplayertreeview.c
* app/widgets/gimpvectorstreeview.c (class_init): follow image API
  name changes.

* app/widgets/gimpitemtreeview.c (gimp_item_tree_view_drop_viewable):
  implement reordering of items between groups.

* app/widgets/gimpcontainertreeview.c
  (gimp_container_tree_view_reorder_item): fix to reorder the item
  within its level of the tree (unrelated to above changes, but needed
  to make them work).
This commit is contained in:
Michael Natterer 2009-08-06 18:43:57 +02:00
parent e8bd830f48
commit d059f239ac
18 changed files with 348 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
app/core/core-enums.c
View File

@ -835,7 +835,7 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_ITEM_LINKED, "GIMP_UNDO_ITEM_LINKED", "item-linked" },
{ GIMP_UNDO_LAYER_ADD, "GIMP_UNDO_LAYER_ADD", "layer-add" },
{ GIMP_UNDO_LAYER_REMOVE, "GIMP_UNDO_LAYER_REMOVE", "layer-remove" },
{ GIMP_UNDO_LAYER_REPOSITION, "GIMP_UNDO_LAYER_REPOSITION", "layer-reposition" },
{ GIMP_UNDO_LAYER_REORDER, "GIMP_UNDO_LAYER_REORDER", "layer-reorder" },
{ GIMP_UNDO_LAYER_MODE, "GIMP_UNDO_LAYER_MODE", "layer-mode" },
{ GIMP_UNDO_LAYER_OPACITY, "GIMP_UNDO_LAYER_OPACITY", "layer-opacity" },
{ GIMP_UNDO_LAYER_LOCK_ALPHA, "GIMP_UNDO_LAYER_LOCK_ALPHA", "layer-lock-alpha" },
@ -847,12 +847,12 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_LAYER_MASK_SHOW, "GIMP_UNDO_LAYER_MASK_SHOW", "layer-mask-show" },
{ GIMP_UNDO_CHANNEL_ADD, "GIMP_UNDO_CHANNEL_ADD", "channel-add" },
{ GIMP_UNDO_CHANNEL_REMOVE, "GIMP_UNDO_CHANNEL_REMOVE", "channel-remove" },
{ GIMP_UNDO_CHANNEL_REPOSITION, "GIMP_UNDO_CHANNEL_REPOSITION", "channel-reposition" },
{ GIMP_UNDO_CHANNEL_REORDER, "GIMP_UNDO_CHANNEL_REORDER", "channel-reorder" },
{ GIMP_UNDO_CHANNEL_COLOR, "GIMP_UNDO_CHANNEL_COLOR", "channel-color" },
{ GIMP_UNDO_VECTORS_ADD, "GIMP_UNDO_VECTORS_ADD", "vectors-add" },
{ GIMP_UNDO_VECTORS_REMOVE, "GIMP_UNDO_VECTORS_REMOVE", "vectors-remove" },
{ GIMP_UNDO_VECTORS_MOD, "GIMP_UNDO_VECTORS_MOD", "vectors-mod" },
{ GIMP_UNDO_VECTORS_REPOSITION, "GIMP_UNDO_VECTORS_REPOSITION", "vectors-reposition" },
{ GIMP_UNDO_VECTORS_REORDER, "GIMP_UNDO_VECTORS_REORDER", "vectors-reorder" },
{ GIMP_UNDO_FS_TO_LAYER, "GIMP_UNDO_FS_TO_LAYER", "fs-to-layer" },
{ GIMP_UNDO_TRANSFORM, "GIMP_UNDO_TRANSFORM", "transform" },
{ GIMP_UNDO_PAINT, "GIMP_UNDO_PAINT", "paint" },
@ -920,7 +920,7 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_ITEM_LINKED, NC_("undo-type", "Link/Unlink item"), NULL },
{ GIMP_UNDO_LAYER_ADD, NC_("undo-type", "New layer"), NULL },
{ GIMP_UNDO_LAYER_REMOVE, NC_("undo-type", "Delete layer"), NULL },
{ GIMP_UNDO_LAYER_REPOSITION, NC_("undo-type", "Reposition layer"), NULL },
{ GIMP_UNDO_LAYER_REORDER, NC_("undo-type", "Reorder layer"), NULL },
{ GIMP_UNDO_LAYER_MODE, NC_("undo-type", "Set layer mode"), NULL },
{ GIMP_UNDO_LAYER_OPACITY, NC_("undo-type", "Set layer opacity"), NULL },
{ GIMP_UNDO_LAYER_LOCK_ALPHA, NC_("undo-type", "Lock/Unlock alpha channel"), NULL },
@ -932,12 +932,12 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_LAYER_MASK_SHOW, NC_("undo-type", "Show layer mask"), NULL },
{ GIMP_UNDO_CHANNEL_ADD, NC_("undo-type", "New channel"), NULL },
{ GIMP_UNDO_CHANNEL_REMOVE, NC_("undo-type", "Delete channel"), NULL },
{ GIMP_UNDO_CHANNEL_REPOSITION, NC_("undo-type", "Reposition channel"), NULL },
{ GIMP_UNDO_CHANNEL_REORDER, NC_("undo-type", "Reorder channel"), NULL },
{ GIMP_UNDO_CHANNEL_COLOR, NC_("undo-type", "Channel color"), NULL },
{ GIMP_UNDO_VECTORS_ADD, NC_("undo-type", "New path"), NULL },
{ GIMP_UNDO_VECTORS_REMOVE, NC_("undo-type", "Delete path"), NULL },
{ GIMP_UNDO_VECTORS_MOD, NC_("undo-type", "Path modification"), NULL },
{ GIMP_UNDO_VECTORS_REPOSITION, NC_("undo-type", "Reposition path"), NULL },
{ GIMP_UNDO_VECTORS_REORDER, NC_("undo-type", "Reorder path"), NULL },
{ GIMP_UNDO_FS_TO_LAYER, NC_("undo-type", "Floating selection to layer"), NULL },
{ GIMP_UNDO_TRANSFORM, NC_("undo-type", "Transform"), NULL },
{ GIMP_UNDO_PAINT, NC_("undo-type", "Paint"), NULL },

6
app/core/core-enums.h
View File

@ -416,7 +416,7 @@ typedef enum /*< pdb-skip >*/
GIMP_UNDO_ITEM_LINKED, /*< desc="Link/Unlink item" >*/
GIMP_UNDO_LAYER_ADD, /*< desc="New layer" >*/
GIMP_UNDO_LAYER_REMOVE, /*< desc="Delete layer" >*/
GIMP_UNDO_LAYER_REPOSITION, /*< desc="Reposition layer" >*/
GIMP_UNDO_LAYER_REORDER, /*< desc="Reorder layer" >*/
GIMP_UNDO_LAYER_MODE, /*< desc="Set layer mode" >*/
GIMP_UNDO_LAYER_OPACITY, /*< desc="Set layer opacity" >*/
GIMP_UNDO_LAYER_LOCK_ALPHA, /*< desc="Lock/Unlock alpha channel" >*/
@ -428,12 +428,12 @@ typedef enum /*< pdb-skip >*/
GIMP_UNDO_LAYER_MASK_SHOW, /*< desc="Show layer mask" >*/
GIMP_UNDO_CHANNEL_ADD, /*< desc="New channel" >*/
GIMP_UNDO_CHANNEL_REMOVE, /*< desc="Delete channel" >*/
GIMP_UNDO_CHANNEL_REPOSITION, /*< desc="Reposition channel" >*/
GIMP_UNDO_CHANNEL_REORDER, /*< desc="Reorder channel" >*/
GIMP_UNDO_CHANNEL_COLOR, /*< desc="Channel color" >*/
GIMP_UNDO_VECTORS_ADD, /*< desc="New path" >*/
GIMP_UNDO_VECTORS_REMOVE, /*< desc="Delete path" >*/
GIMP_UNDO_VECTORS_MOD, /*< desc="Path modification" >*/
GIMP_UNDO_VECTORS_REPOSITION, /*< desc="Reposition path" >*/
GIMP_UNDO_VECTORS_REORDER, /*< desc="Reorder path" >*/
GIMP_UNDO_FS_TO_LAYER, /*< desc="Floating selection to layer" >*/
GIMP_UNDO_TRANSFORM, /*< desc="Transform" >*/
GIMP_UNDO_PAINT, /*< desc="Paint" >*/

19
app/core/gimpchannelpropundo.c
View File

@ -79,7 +79,8 @@ gimp_channel_prop_undo_constructor (GType type,
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_CHANNEL_REPOSITION:
case GIMP_UNDO_CHANNEL_REORDER:
channel_prop_undo->parent = GIMP_CHANNEL (gimp_viewable_get_parent (GIMP_VIEWABLE (channel)));
channel_prop_undo->position = gimp_item_get_index (GIMP_ITEM (channel));
break;
@ -106,14 +107,20 @@ gimp_channel_prop_undo_pop (GimpUndo *undo,
switch (undo->undo_type)
{
case GIMP_UNDO_CHANNEL_REPOSITION:
case GIMP_UNDO_CHANNEL_REORDER:
{
gint position;
GimpChannel *parent;
gint position;
parent = GIMP_CHANNEL (gimp_viewable_get_parent (GIMP_VIEWABLE (channel)));
position = gimp_item_get_index (GIMP_ITEM (channel));
gimp_image_position_channel (undo->image, channel,
channel_prop_undo->position,
FALSE, NULL);
gimp_image_reorder_channel (undo->image, channel,
channel_prop_undo->parent,
channel_prop_undo->position,
FALSE, NULL);
channel_prop_undo->parent = parent;
channel_prop_undo->position = position;
}
break;

1
app/core/gimpchannelpropundo.h
View File

@ -36,6 +36,7 @@ struct _GimpChannelPropUndo
{
GimpItemUndo parent_instance;
GimpChannel *parent;
gint position;
GimpRGB color;
};

24
app/core/gimpimage-undo-push.c
View File

@ -450,16 +450,16 @@ gimp_image_undo_push_layer_remove (GimpImage *image,
}
GimpUndo *
gimp_image_undo_push_layer_reposition (GimpImage *image,
const gchar *undo_desc,
GimpLayer *layer)
gimp_image_undo_push_layer_reorder (GimpImage *image,
const gchar *undo_desc,
GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), NULL);
return gimp_image_undo_push (image, GIMP_TYPE_LAYER_PROP_UNDO,
GIMP_UNDO_LAYER_REPOSITION, undo_desc,
GIMP_UNDO_LAYER_REORDER, undo_desc,
GIMP_DIRTY_IMAGE_STRUCTURE,
"item", layer,
NULL);
@ -683,16 +683,16 @@ gimp_image_undo_push_channel_remove (GimpImage *image,
}
GimpUndo *
gimp_image_undo_push_channel_reposition (GimpImage *image,
const gchar *undo_desc,
GimpChannel *channel)
gimp_image_undo_push_channel_reorder (GimpImage *image,
const gchar *undo_desc,
GimpChannel *channel)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)), NULL);
return gimp_image_undo_push (image, GIMP_TYPE_CHANNEL_PROP_UNDO,
GIMP_UNDO_CHANNEL_REPOSITION, undo_desc,
GIMP_UNDO_CHANNEL_REORDER, undo_desc,
GIMP_DIRTY_IMAGE_STRUCTURE,
"item", channel,
NULL);
@ -782,16 +782,16 @@ gimp_image_undo_push_vectors_mod (GimpImage *image,
}
GimpUndo *
gimp_image_undo_push_vectors_reposition (GimpImage *image,
const gchar *undo_desc,
GimpVectors *vectors)
gimp_image_undo_push_vectors_reorder (GimpImage *image,
const gchar *undo_desc,
GimpVectors *vectors)
{
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), NULL);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (vectors)), NULL);
return gimp_image_undo_push (image, GIMP_TYPE_VECTORS_PROP_UNDO,
GIMP_UNDO_VECTORS_REPOSITION, undo_desc,
GIMP_UNDO_VECTORS_REORDER, undo_desc,
GIMP_DIRTY_IMAGE_STRUCTURE,
"item", vectors,
NULL);

6
app/core/gimpimage-undo-push.h
View File

@ -114,7 +114,7 @@ GimpUndo * gimp_image_undo_push_layer_remove (GimpImage *image,
GimpLayer *prev_parent,
gint prev_position,
GimpLayer *prev_layer);
GimpUndo * gimp_image_undo_push_layer_reposition (GimpImage *image,
GimpUndo * gimp_image_undo_push_layer_reorder (GimpImage *image,
const gchar *undo_desc,
GimpLayer *layer);
GimpUndo * gimp_image_undo_push_layer_mode (GimpImage *image,
@ -169,7 +169,7 @@ GimpUndo * gimp_image_undo_push_channel_remove (GimpImage *image,
GimpChannel *prev_parent,
gint prev_position,
GimpChannel *prev_channel);
GimpUndo * gimp_image_undo_push_channel_reposition (GimpImage *image,
GimpUndo * gimp_image_undo_push_channel_reorder (GimpImage *image,
const gchar *undo_desc,
GimpChannel *channel);
GimpUndo * gimp_image_undo_push_channel_color (GimpImage *image,
@ -192,7 +192,7 @@ GimpUndo * gimp_image_undo_push_vectors_remove (GimpImage *image,
GimpUndo * gimp_image_undo_push_vectors_mod (GimpImage *image,
const gchar *undo_desc,
GimpVectors *vectors);
GimpUndo * gimp_image_undo_push_vectors_reposition (GimpImage *image,
GimpUndo * gimp_image_undo_push_vectors_reorder (GimpImage *image,
const gchar *undo_desc,
GimpVectors *vectors);

305
app/core/gimpimage.c
View File

@ -3005,6 +3005,33 @@ gimp_image_get_insert_pos (GimpItem *parent,
return parent;
}
static GimpContainer *
gimp_image_get_reorder_pos (GimpItem *item,
GimpItem *new_parent,
gint *new_index,
GimpContainer *toplevel_container)
{
GimpContainer *container;
GimpContainer *new_container;
gint num_items;
container = gimp_item_get_container (item);
if (new_parent)
new_container = gimp_viewable_get_children (GIMP_VIEWABLE (new_parent));
else
new_container = toplevel_container;
num_items = gimp_container_get_n_children (new_container);
if (new_container == container)
num_items--;
*new_index = CLAMP (*new_index, 0, num_items);
return new_container;
}
gboolean
gimp_image_add_layer (GimpImage *image,
GimpLayer *layer,
@ -3286,7 +3313,8 @@ gimp_image_raise_layer (GimpImage *image,
GimpLayer *layer,
GError **error)
{
gint index;
GimpLayer *parent;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
@ -3301,8 +3329,11 @@ gimp_image_raise_layer (GimpImage *image,
return FALSE;
}
return gimp_image_position_layer (image, layer, index - 1,
TRUE, _("Raise Layer"));
parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)));
return gimp_image_reorder_layer (image, layer,
parent, index - 1,
TRUE, _("Raise Layer"));
}
gboolean
@ -3311,6 +3342,7 @@ gimp_image_lower_layer (GimpImage *image,
GError **error)
{
GimpContainer *container;
GimpLayer *parent;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@ -3328,19 +3360,27 @@ gimp_image_lower_layer (GimpImage *image,
return FALSE;
}
return gimp_image_position_layer (image, layer, index + 1,
TRUE, _("Lower Layer"));
parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)));
return gimp_image_reorder_layer (image, layer,
parent, index + 1,
TRUE, _("Lower Layer"));
}
gboolean
gimp_image_raise_layer_to_top (GimpImage *image,
GimpLayer *layer)
{
GimpLayer *parent;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
return gimp_image_position_layer (image, layer, 0,
TRUE, _("Raise Layer to Top"));
parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)));
return gimp_image_reorder_layer (image, layer,
parent, 0,
TRUE, _("Raise Layer to Top"));
}
gboolean
@ -3348,6 +3388,7 @@ gimp_image_lower_layer_to_bottom (GimpImage *image,
GimpLayer *layer)
{
GimpContainer *container;
GimpLayer *parent;
gint length;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@ -3357,40 +3398,65 @@ gimp_image_lower_layer_to_bottom (GimpImage *image,
length = gimp_container_get_n_children (container);
return gimp_image_position_layer (image, layer, length - 1,
TRUE, _("Lower Layer to Bottom"));
parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)));
return gimp_image_reorder_layer (image, layer,
parent, length - 1,
TRUE, _("Lower Layer to Bottom"));
}
gboolean
gimp_image_position_layer (GimpImage *image,
GimpLayer *layer,
gint new_index,
gboolean push_undo,
const gchar *undo_desc)
gimp_image_reorder_layer (GimpImage *image,
GimpLayer *layer,
GimpLayer *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc)
{
GimpContainer *container;
gint index;
gint num_layers;
GimpContainer *new_container;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)), FALSE);
g_return_val_if_fail (gimp_item_get_image (GIMP_ITEM (layer)) == image, FALSE);
g_return_val_if_fail (new_parent == NULL || GIMP_IS_LAYER (new_parent), FALSE);
g_return_val_if_fail (new_parent == NULL ||
gimp_item_is_attached (GIMP_ITEM (new_parent)), FALSE);
g_return_val_if_fail (new_parent == NULL ||
gimp_item_get_image (GIMP_ITEM (new_parent)) == image,
FALSE);
container = gimp_item_get_container (GIMP_ITEM (layer));
index = gimp_item_get_index (GIMP_ITEM (layer));
if (index < 0)
return FALSE;
new_container = gimp_image_get_reorder_pos (GIMP_ITEM (layer),
GIMP_ITEM (new_parent),
&new_index,
image->layers);
num_layers = gimp_container_get_n_children (container);
new_index = CLAMP (new_index, 0, num_layers - 1);
if (new_index != index)
if (new_container != container ||
new_index != gimp_item_get_index (GIMP_ITEM (layer)))
{
if (push_undo)
gimp_image_undo_push_layer_reposition (image, undo_desc, layer);
gimp_image_undo_push_layer_reorder (image, undo_desc, layer);
gimp_container_reorder (container, GIMP_OBJECT (layer), new_index);
if (new_container != container)
{
g_object_ref (layer);
gimp_container_remove (container, GIMP_OBJECT (layer));
gimp_viewable_set_parent (GIMP_VIEWABLE (layer),
GIMP_VIEWABLE (new_parent));
gimp_container_insert (new_container, GIMP_OBJECT (layer), new_index);
g_object_unref (layer);
}
else
{
gimp_container_reorder (container, GIMP_OBJECT (layer), new_index);
}
}
return TRUE;
@ -3547,7 +3613,8 @@ gimp_image_raise_channel (GimpImage *image,
GimpChannel *channel,
GError **error)
{
gint index;
GimpChannel *parent;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE);
@ -3562,19 +3629,27 @@ gimp_image_raise_channel (GimpImage *image,
return FALSE;
}
return gimp_image_position_channel (image, channel, index - 1,
TRUE, _("Raise Channel"));
parent = GIMP_CHANNEL (gimp_viewable_get_parent (GIMP_VIEWABLE (channel)));
return gimp_image_reorder_channel (image, channel,
parent, index - 1,
TRUE, _("Raise Channel"));
}
gboolean
gimp_image_raise_channel_to_top (GimpImage *image,
GimpChannel *channel)
{
GimpChannel *parent;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE);
return gimp_image_position_channel (image, channel, 0,
TRUE, _("Raise Channel to Top"));
parent = GIMP_CHANNEL (gimp_viewable_get_parent (GIMP_VIEWABLE (channel)));
return gimp_image_reorder_channel (image, channel,
parent, 0,
TRUE, _("Raise Channel to Top"));
}
@ -3584,6 +3659,7 @@ gimp_image_lower_channel (GimpImage *image,
GError **error)
{
GimpContainer *container;
GimpChannel *parent;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@ -3601,8 +3677,11 @@ gimp_image_lower_channel (GimpImage *image,
return FALSE;
}
return gimp_image_position_channel (image, channel, index + 1,
TRUE, _("Lower Channel"));
parent = GIMP_CHANNEL (gimp_viewable_get_parent (GIMP_VIEWABLE (channel)));
return gimp_image_reorder_channel (image, channel,
parent, index + 1,
TRUE, _("Lower Channel"));
}
gboolean
@ -3610,6 +3689,7 @@ gimp_image_lower_channel_to_bottom (GimpImage *image,
GimpChannel *channel)
{
GimpContainer *container;
GimpChannel *parent;
gint length;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@ -3619,41 +3699,67 @@ gimp_image_lower_channel_to_bottom (GimpImage *image,
length = gimp_container_get_n_children (container);
return gimp_image_position_channel (image, channel, length - 1,
TRUE, _("Lower Channel to Bottom"));
parent = GIMP_CHANNEL (gimp_viewable_get_parent (GIMP_VIEWABLE (channel)));
return gimp_image_reorder_channel (image, channel,
parent, length - 1,
TRUE, _("Lower Channel to Bottom"));
}
gboolean
gimp_image_position_channel (GimpImage *image,
GimpChannel *channel,
gint new_index,
gboolean push_undo,
const gchar *undo_desc)
gimp_image_reorder_channel (GimpImage *image,
GimpChannel *channel,
GimpChannel *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc)
{
GimpContainer *container;
gint index;
gint num_channels;
GimpContainer *new_container;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (channel)), FALSE);
g_return_val_if_fail (gimp_item_get_image (GIMP_ITEM (channel)) == image,
FALSE);
g_return_val_if_fail (new_parent == NULL ||
GIMP_IS_CHANNEL (new_parent), FALSE);
g_return_val_if_fail (new_parent == NULL ||
gimp_item_is_attached (GIMP_ITEM (new_parent)), FALSE);
g_return_val_if_fail (new_parent == NULL ||
gimp_item_get_image (GIMP_ITEM (new_parent)) == image,
FALSE);
container = gimp_item_get_container (GIMP_ITEM (channel));
index = gimp_item_get_index (GIMP_ITEM (channel));
if (index < 0)
return FALSE;
new_container = gimp_image_get_reorder_pos (GIMP_ITEM (channel),
GIMP_ITEM (new_parent),
&new_index,
image->channels);
num_channels = gimp_container_get_n_children (container);
new_index = CLAMP (new_index, 0, num_channels - 1);
if (new_index != index)
if (new_container != container ||
new_index != gimp_item_get_index (GIMP_ITEM (channel)))
{
if (push_undo)
gimp_image_undo_push_channel_reposition (image, undo_desc, channel);
gimp_image_undo_push_channel_reorder (image, undo_desc, channel);
gimp_container_reorder (container, GIMP_OBJECT (channel), new_index);
if (new_container != container)
{
g_object_ref (channel);
gimp_container_remove (container, GIMP_OBJECT (channel));
gimp_viewable_set_parent (GIMP_VIEWABLE (channel),
GIMP_VIEWABLE (new_parent));
gimp_container_insert (new_container, GIMP_OBJECT (channel), new_index);
g_object_unref (channel);
}
else
{
gimp_container_reorder (container, GIMP_OBJECT (channel), new_index);
}
}
return TRUE;
@ -3785,7 +3891,8 @@ gimp_image_raise_vectors (GimpImage *image,
GimpVectors *vectors,
GError **error)
{
gint index;
GimpVectors *parent;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE);
@ -3800,19 +3907,27 @@ gimp_image_raise_vectors (GimpImage *image,
return FALSE;
}
return gimp_image_position_vectors (image, vectors, index - 1,
TRUE, _("Raise Path"));
parent = GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));
return gimp_image_reorder_vectors (image, vectors,
parent, index - 1,
TRUE, _("Raise Path"));
}
gboolean
gimp_image_raise_vectors_to_top (GimpImage *image,
GimpVectors *vectors)
{
GimpVectors *parent;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE);
return gimp_image_position_vectors (image, vectors, 0,
TRUE, _("Raise Path to Top"));
parent = GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));
return gimp_image_reorder_vectors (image, vectors,
parent, 0,
TRUE, _("Raise Path to Top"));
}
gboolean
@ -3821,6 +3936,7 @@ gimp_image_lower_vectors (GimpImage *image,
GError **error)
{
GimpContainer *container;
GimpVectors *parent;
gint index;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@ -3838,8 +3954,11 @@ gimp_image_lower_vectors (GimpImage *image,
return FALSE;
}
return gimp_image_position_vectors (image, vectors, index + 1,
TRUE, _("Lower Path"));
parent = GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));
return gimp_image_reorder_vectors (image, vectors,
parent, index + 1,
TRUE, _("Lower Path"));
}
gboolean
@ -3847,6 +3966,7 @@ gimp_image_lower_vectors_to_bottom (GimpImage *image,
GimpVectors *vectors)
{
GimpContainer *container;
GimpVectors *parent;
gint length;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
@ -3856,40 +3976,67 @@ gimp_image_lower_vectors_to_bottom (GimpImage *image,
length = gimp_container_get_n_children (container);
return gimp_image_position_vectors (image, vectors, length - 1,
TRUE, _("Lower Path to Bottom"));
parent = GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));
return gimp_image_reorder_vectors (image, vectors,
parent, length - 1,
TRUE, _("Lower Path to Bottom"));
}
gboolean
gimp_image_position_vectors (GimpImage *image,
GimpVectors *vectors,
gint new_index,
gboolean push_undo,
const gchar *undo_desc)
gimp_image_reorder_vectors (GimpImage *image,
GimpVectors *vectors,
GimpVectors *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc)
{
GimpContainer *container;
gint index;
gint num_vectors;
GimpContainer *new_container;
g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE);
g_return_val_if_fail (GIMP_IS_VECTORS (vectors), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (vectors)), FALSE);
g_return_val_if_fail (gimp_item_get_image (GIMP_ITEM (vectors)) == image,
FALSE);
g_return_val_if_fail (new_parent == NULL ||
GIMP_IS_VECTORS (new_parent), FALSE);
g_return_val_if_fail (new_parent == NULL ||
gimp_item_is_attached (GIMP_ITEM (new_parent)), FALSE);
g_return_val_if_fail (new_parent == NULL ||
gimp_item_get_image (GIMP_ITEM (new_parent)) == image,
FALSE);
container = gimp_item_get_container (GIMP_ITEM (vectors));
index = gimp_item_get_index (GIMP_ITEM (vectors));
if (index < 0)
return FALSE;
new_container = gimp_image_get_reorder_pos (GIMP_ITEM (vectors),
GIMP_ITEM (new_parent),
&new_index,
image->vectors);
num_vectors = gimp_container_get_n_children (container);
new_index = CLAMP (new_index, 0, num_vectors - 1);
if (new_index != index)
if (new_container != container ||
new_index != gimp_item_get_index (GIMP_ITEM (vectors)))
{
if (push_undo)
gimp_image_undo_push_vectors_reposition (image, undo_desc, vectors);
gimp_image_undo_push_vectors_reorder (image, undo_desc, vectors);
gimp_container_reorder (container, GIMP_OBJECT (vectors), new_index);
if (new_container != container)
{
g_object_ref (vectors);
gimp_container_remove (container, GIMP_OBJECT (vectors));
gimp_viewable_set_parent (GIMP_VIEWABLE (vectors),
GIMP_VIEWABLE (new_parent));
gimp_container_insert (new_container, GIMP_OBJECT (vectors), new_index);
g_object_unref (vectors);
}
else
{
gimp_container_reorder (container, GIMP_OBJECT (vectors), new_index);
}
}
return TRUE;

9
app/core/gimpimage.h
View File

@ -493,8 +493,9 @@ gboolean gimp_image_raise_layer_to_top (GimpImage *image,
GimpLayer *layer);
gboolean gimp_image_lower_layer_to_bottom (GimpImage *image,
GimpLayer *layer);
gboolean gimp_image_position_layer (GimpImage *image,
gboolean gimp_image_reorder_layer (GimpImage *image,
GimpLayer *layer,
GimpLayer *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc);
@ -519,8 +520,9 @@ gboolean gimp_image_lower_channel (GimpImage *image,
GError **error);
gboolean gimp_image_lower_channel_to_bottom (GimpImage *image,
GimpChannel *channel);
gboolean gimp_image_position_channel (GimpImage *image,
gboolean gimp_image_reorder_channel (GimpImage *image,
GimpChannel *channel,
GimpChannel *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc);
@ -545,8 +547,9 @@ gboolean gimp_image_lower_vectors (GimpImage *image,
GError **error);
gboolean gimp_image_lower_vectors_to_bottom (GimpImage *image,
GimpVectors *vectors);
gboolean gimp_image_position_vectors (GimpImage *image,
gboolean gimp_image_reorder_vectors (GimpImage *image,
GimpVectors *vectors,
GimpVectors *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc);

19
app/core/gimplayerpropundo.c
View File

@ -79,7 +79,8 @@ gimp_layer_prop_undo_constructor (GType type,
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_LAYER_REPOSITION:
case GIMP_UNDO_LAYER_REORDER:
layer_prop_undo->parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)));
layer_prop_undo->position = gimp_item_get_index (GIMP_ITEM (layer));
break;
@ -114,14 +115,20 @@ gimp_layer_prop_undo_pop (GimpUndo *undo,
switch (undo->undo_type)
{
case GIMP_UNDO_LAYER_REPOSITION:
case GIMP_UNDO_LAYER_REORDER:
{
gint position;
GimpLayer *parent;
gint position;
parent = GIMP_LAYER (gimp_viewable_get_parent (GIMP_VIEWABLE (layer)));
position = gimp_item_get_index (GIMP_ITEM (layer));
gimp_image_position_layer (undo->image, layer,
layer_prop_undo->position,
FALSE, NULL);
gimp_image_reorder_layer (undo->image, layer,
layer_prop_undo->parent,
layer_prop_undo->position,
FALSE, NULL);
layer_prop_undo->parent = parent;
layer_prop_undo->position = position;
}
break;

11
app/core/gimplayerpropundo.h
View File

@ -34,12 +34,13 @@ typedef struct _GimpLayerPropUndoClass GimpLayerPropUndoClass;
struct _GimpLayerPropUndo
{
GimpItemUndo parent_instance;
GimpItemUndo parent_instance;
gint position;
GimpLayerModeEffects mode;
gdouble opacity;
gboolean lock_alpha;
GimpLayer *parent;
gint position;
GimpLayerModeEffects mode;
gdouble opacity;
gboolean lock_alpha;
};
struct _GimpLayerPropUndoClass

19
app/vectors/gimpvectorspropundo.c
View File

@ -78,7 +78,8 @@ gimp_vectors_prop_undo_constructor (GType type,
switch (GIMP_UNDO (object)->undo_type)
{
case GIMP_UNDO_VECTORS_REPOSITION:
case GIMP_UNDO_VECTORS_REORDER:
vectors_prop_undo->parent = GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));
vectors_prop_undo->position = gimp_item_get_index (GIMP_ITEM (vectors));
break;
@ -101,14 +102,20 @@ gimp_vectors_prop_undo_pop (GimpUndo *undo,
switch (undo->undo_type)
{
case GIMP_UNDO_VECTORS_REPOSITION:
case GIMP_UNDO_VECTORS_REORDER:
{
gint position;
GimpVectors *parent;
gint position;
parent = GIMP_VECTORS (gimp_viewable_get_parent (GIMP_VIEWABLE (vectors)));
position = gimp_item_get_index (GIMP_ITEM (vectors));
gimp_image_position_vectors (undo->image, vectors,
vectors_prop_undo->position,
FALSE, NULL);
gimp_image_reorder_vectors (undo->image, vectors,
vectors_prop_undo->parent,
vectors_prop_undo->position,
FALSE, NULL);
vectors_prop_undo->parent = parent;
vectors_prop_undo->position = position;
}
break;

1
app/vectors/gimpvectorspropundo.h
View File

@ -36,6 +36,7 @@ struct _GimpVectorsPropUndo
{
GimpItemUndo parent_instance;
GimpVectors *parent;
gint position;
};

2
app/widgets/gimpchanneltreeview.c
View File

@ -115,7 +115,7 @@ gimp_channel_tree_view_class_init (GimpChannelTreeViewClass *klass)
iv_class->get_container = gimp_image_get_channels;
iv_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_channel;
iv_class->set_active_item = (GimpSetItemFunc) gimp_image_set_active_channel;
iv_class->reorder_item = (GimpReorderItemFunc) gimp_image_position_channel;
iv_class->reorder_item = (GimpReorderItemFunc) gimp_image_reorder_channel;
iv_class->add_item = (GimpAddItemFunc) gimp_image_add_channel;
iv_class->remove_item = (GimpRemoveItemFunc) gimp_image_remove_channel;
iv_class->new_item = gimp_channel_tree_view_item_new;

30
app/widgets/gimpcontainertreeview.c
View File

@ -213,6 +213,7 @@ gimp_container_tree_view_constructor (GType type,
gtk_tree_view_insert_column (tree_view->view, tree_view->main_column, 0);
gtk_tree_view_set_expander_column (tree_view->view, tree_view->main_column);
gtk_tree_view_set_enable_tree_lines (tree_view->view, TRUE);
tree_view->renderer_cell = gimp_cell_renderer_viewable_new ();
gtk_tree_view_column_pack_start (tree_view->main_column,
@ -653,12 +654,17 @@ gimp_container_tree_view_reorder_item (GimpContainerView *view,
if (iter)
{
GimpViewable *parent;
GimpContainer *container;
GtkTreePath *path;
GtkTreeIter selected_iter;
gboolean selected;
container = gimp_container_view_get_container (view);
parent = gimp_viewable_get_parent (viewable);
if (parent)
container = gimp_viewable_get_children (parent);
else
container = gimp_container_view_get_container (view);
selected = gtk_tree_selection_get_selected (tree_view->priv->selection,
NULL, &selected_iter);
@ -690,18 +696,24 @@ gimp_container_tree_view_reorder_item (GimpContainerView *view,
}
else
{
GtkTreeIter place_iter;
gint old_index;
GtkTreePath *path;
GtkTreeIter place_iter;
gint depth;
gint *indices;
gint old_index;
path = gtk_tree_model_get_path (tree_view->model, iter);
old_index = gtk_tree_path_get_indices (path)[0];
gtk_tree_path_free (path);
indices = gtk_tree_path_get_indices (path);
depth = gtk_tree_path_get_depth (path);
old_index = indices[depth - 1];
if (new_index != old_index)
{
path = gtk_tree_path_new_from_indices (new_index, -1);
indices[depth - 1] = new_index;
gtk_tree_model_get_iter (tree_view->model, &place_iter, path);
gtk_tree_path_free (path);
if (new_index > old_index)
gtk_tree_store_move_after (GTK_TREE_STORE (tree_view->model),
@ -710,6 +722,8 @@ gimp_container_tree_view_reorder_item (GimpContainerView *view,
gtk_tree_store_move_before (GTK_TREE_STORE (tree_view->model),
iter, &place_iter);
}
gtk_tree_path_free (path);
}
if (selected)

49
app/widgets/gimpitemtreeview.c
View File

@ -815,41 +815,30 @@ gimp_item_tree_view_drop_viewable (GimpContainerTreeView *tree_view,
}
else if (dest_viewable)
{
GimpContainer *src_container;
GimpContainer *dest_container;
gint src_index;
gint dest_index;
GimpItem *src_parent;
GimpItem *dest_parent;
gint src_index;
gint dest_index;
src_container = gimp_item_get_container (GIMP_ITEM (src_viewable));
src_index = gimp_item_get_index (GIMP_ITEM (src_viewable));
src_parent = GIMP_ITEM (gimp_viewable_get_parent (src_viewable));
src_index = gimp_item_get_index (GIMP_ITEM (src_viewable));
dest_container = gimp_item_get_container (GIMP_ITEM (dest_viewable));
dest_index = gimp_item_get_index (GIMP_ITEM (dest_viewable));
dest_index = gimp_item_tree_view_get_drop_index (item_view, dest_viewable,
drop_pos,
(GimpViewable **) &dest_parent);
if (src_container == dest_container)
if (src_parent == dest_parent)
{
if (drop_pos == GTK_TREE_VIEW_DROP_AFTER &&
src_index > dest_index)
{
dest_index++;
}
else if (drop_pos == GTK_TREE_VIEW_DROP_BEFORE &&
src_index < dest_index)
{
dest_index--;
}
if (src_index < dest_index)
dest_index--;
}
item_view_class->reorder_item (item_view->priv->image,
GIMP_ITEM (src_viewable),
dest_index,
TRUE,
item_view_class->reorder_desc);
}
else
{
g_printerr ("%s: dnd between containers (%d -> %d)\n",
G_STRFUNC, src_index, dest_index);
}
item_view_class->reorder_item (item_view->priv->image,
GIMP_ITEM (src_viewable),
dest_parent,
dest_index,
TRUE,
item_view_class->reorder_desc);
}
gimp_image_flush (item_view->priv->image);

1
app/widgets/gimpitemtreeview.h
View File

@ -31,6 +31,7 @@ typedef void (* GimpSetItemFunc) (GimpImage *image,
GimpItem *item);
typedef void (* GimpReorderItemFunc) (GimpImage *image,
GimpItem *item,
GimpItem *new_parent,
gint new_index,
gboolean push_undo,
const gchar *undo_desc);

2
app/widgets/gimplayertreeview.c
View File

@ -222,7 +222,7 @@ gimp_layer_tree_view_class_init (GimpLayerTreeViewClass *klass)
item_view_class->get_container = gimp_image_get_layers;
item_view_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_layer;
item_view_class->set_active_item = (GimpSetItemFunc) gimp_image_set_active_layer;
item_view_class->reorder_item = (GimpReorderItemFunc) gimp_image_position_layer;
item_view_class->reorder_item = (GimpReorderItemFunc) gimp_image_reorder_layer;
item_view_class->add_item = (GimpAddItemFunc) gimp_image_add_layer;
item_view_class->remove_item = (GimpRemoveItemFunc) gimp_image_remove_layer;
item_view_class->new_item = gimp_layer_tree_view_item_new;

2
app/widgets/gimpvectorstreeview.c
View File

@ -97,7 +97,7 @@ gimp_vectors_tree_view_class_init (GimpVectorsTreeViewClass *klass)
iv_class->get_container = gimp_image_get_vectors;
iv_class->get_active_item = (GimpGetItemFunc) gimp_image_get_active_vectors;
iv_class->set_active_item = (GimpSetItemFunc) gimp_image_set_active_vectors;
iv_class->reorder_item = (GimpReorderItemFunc) gimp_image_position_vectors;
iv_class->reorder_item = (GimpReorderItemFunc) gimp_image_reorder_vectors;
iv_class->add_item = (GimpAddItemFunc) gimp_image_add_vectors;
iv_class->remove_item = (GimpRemoveItemFunc) gimp_image_remove_vectors;
iv_class->new_item = gimp_vectors_tree_view_item_new;