procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-04 01:43:24 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

reordered values so layer and layer mask undos are grouped together.

Browse source 
2005-03-24  Michael Natterer  <mitch@gimp.org>

	* app/core/core-enums.[ch] (enum GimpUndoType) : reordered values
	so layer and layer mask undos are grouped together.

	* app/core/gimpimage-undo-push.[ch]: same here. Changed the new
	layer mask undos to have 3 simple push functions for the 3
	properties, just as the layer property undos. Also made the code
	look like the layer properties undo stuff.

	* app/core/gimplayermask.c (gimp_layer_mask_set_apply,edit,show):
	changed accordingly.
This commit is contained in:
Michael Natterer 2005-03-24 22:15:10 +00:00 • committed by Michael Natterer
parent 2617fe3fe4
commit b17e5b4aad
6 changed files with 355 additions and 290 deletions
Download patch file Download diff file Expand all files Collapse all files

16
ChangeLog
View file

@ -1,3 +1,16 @@
2005-03-24 Michael Natterer <mitch@gimp.org>
* app/core/core-enums.[ch] (enum GimpUndoType) : reordered values
so layer and layer mask undos are grouped together.
* app/core/gimpimage-undo-push.[ch]: same here. Changed the new
layer mask undos to have 3 simple push functions for the 3
properties, just as the layer property undos. Also made the code
look like the layer properties undo stuff.
* app/core/gimplayermask.c (gimp_layer_mask_set_apply,edit,show):
changed accordingly.
2005-03-24 Sven Neumann <sven@gimp.org>
* plug-ins/bmp/bmp.h (Bitmap_Head_Struct)
@ -39,9 +52,8 @@
* app/core/gimp.h: added "GSList *plug_in_menu_branches".
* app/plug-in/plug-in-types.h
* app/plug-in/plug-ins.[ch]: added API to register plug-in menu
branches, just as for locale and help domans. Cleaned up handling
branches, just as for locale and help domains. Cleaned up handling
of locale and help domains.
(plug_ins_exit): free the registered menu branches.

20
app/core/core-enums.c
View file

@ -732,17 +732,17 @@ 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_MASK_ADD, "GIMP_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
{ GIMP_UNDO_LAYER_MASK_REMOVE, "GIMP_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
{ GIMP_UNDO_LAYER_MASK_APPLY, "GIMP_UNDO_LAYER_MASK_APPLY", "layer-mask-apply" },
{ GIMP_UNDO_LAYER_MASK_EDIT, "GIMP_UNDO_LAYER_MASK_EDIT", "layer-mask-edit" },
{ GIMP_UNDO_LAYER_MASK_SHOW, "GIMP_UNDO_LAYER_MASK_SHOW", "layer-mask-show" },
{ GIMP_UNDO_LAYER_REPOSITION, "GIMP_UNDO_LAYER_REPOSITION", "layer-reposition" },
{ GIMP_UNDO_LAYER_MODE, "GIMP_UNDO_LAYER_MODE", "layer-mode" },
{ GIMP_UNDO_LAYER_OPACITY, "GIMP_UNDO_LAYER_OPACITY", "layer-opacity" },
{ GIMP_UNDO_LAYER_PRESERVE_TRANS, "GIMP_UNDO_LAYER_PRESERVE_TRANS", "layer-preserve-trans" },
{ GIMP_UNDO_TEXT_LAYER, "GIMP_UNDO_TEXT_LAYER", "text-layer" },
{ GIMP_UNDO_TEXT_LAYER_MODIFIED, "GIMP_UNDO_TEXT_LAYER_MODIFIED", "text-layer-modified" },
{ GIMP_UNDO_LAYER_MASK_ADD, "GIMP_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
{ GIMP_UNDO_LAYER_MASK_REMOVE, "GIMP_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
{ GIMP_UNDO_LAYER_MASK_APPLY, "GIMP_UNDO_LAYER_MASK_APPLY", "layer-mask-apply" },
{ GIMP_UNDO_LAYER_MASK_EDIT, "GIMP_UNDO_LAYER_MASK_EDIT", "layer-mask-edit" },
{ 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" },
@ -818,17 +818,17 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_ITEM_LINKED, N_("Set item linked"), NULL },
{ GIMP_UNDO_LAYER_ADD, N_("New layer"), NULL },
{ GIMP_UNDO_LAYER_REMOVE, N_("Delete layer"), NULL },
{ GIMP_UNDO_LAYER_MASK_ADD, N_("Add layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_REMOVE, N_("Delete layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_APPLY, N_("Apply layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_EDIT, N_("Edit layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_SHOW, N_("Show layer mask"), NULL },
{ GIMP_UNDO_LAYER_REPOSITION, N_("Reposition layer"), NULL },
{ GIMP_UNDO_LAYER_MODE, N_("Set layer mode"), NULL },
{ GIMP_UNDO_LAYER_OPACITY, N_("Set layer opacity"), NULL },
{ GIMP_UNDO_LAYER_PRESERVE_TRANS, N_("Set preserve trans"), NULL },
{ GIMP_UNDO_TEXT_LAYER, N_("Text"), NULL },
{ GIMP_UNDO_TEXT_LAYER_MODIFIED, N_("Text modified"), NULL },
{ GIMP_UNDO_LAYER_MASK_ADD, N_("Add layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_REMOVE, N_("Delete layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_APPLY, N_("Apply layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_EDIT, N_("Edit layer mask"), NULL },
{ GIMP_UNDO_LAYER_MASK_SHOW, N_("Show layer mask"), NULL },
{ GIMP_UNDO_CHANNEL_ADD, N_("New channel"), NULL },
{ GIMP_UNDO_CHANNEL_REMOVE, N_("Delete channel"), NULL },
{ GIMP_UNDO_CHANNEL_REPOSITION, N_("Reposition channel"), NULL },

10
app/core/core-enums.h
View file

@ -382,17 +382,17 @@ typedef enum /*< pdb-skip >*/
GIMP_UNDO_ITEM_LINKED, /*< desc="Set item linked" >*/
GIMP_UNDO_LAYER_ADD, /*< desc="New layer" >*/
GIMP_UNDO_LAYER_REMOVE, /*< desc="Delete layer" >*/
GIMP_UNDO_LAYER_MASK_ADD, /*< desc="Add layer mask" >*/
GIMP_UNDO_LAYER_MASK_REMOVE, /*< desc="Delete layer mask" >*/
GIMP_UNDO_LAYER_MASK_APPLY, /*< desc="Apply layer mask" >*/
GIMP_UNDO_LAYER_MASK_EDIT, /*< desc="Edit layer mask" >*/
GIMP_UNDO_LAYER_MASK_SHOW, /*< desc="Show layer mask" >*/
GIMP_UNDO_LAYER_REPOSITION, /*< desc="Reposition layer" >*/
GIMP_UNDO_LAYER_MODE, /*< desc="Set layer mode" >*/
GIMP_UNDO_LAYER_OPACITY, /*< desc="Set layer opacity" >*/
GIMP_UNDO_LAYER_PRESERVE_TRANS, /*< desc="Set preserve trans" >*/
GIMP_UNDO_TEXT_LAYER, /*< desc="Text" >*/
GIMP_UNDO_TEXT_LAYER_MODIFIED, /*< desc="Text modified" >*/
GIMP_UNDO_LAYER_MASK_ADD, /*< desc="Add layer mask" >*/
GIMP_UNDO_LAYER_MASK_REMOVE, /*< desc="Delete layer mask" >*/
GIMP_UNDO_LAYER_MASK_APPLY, /*< desc="Apply layer mask" >*/
GIMP_UNDO_LAYER_MASK_EDIT, /*< desc="Edit layer mask" >*/
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" >*/

544
app/core/gimpimage-undo-push.c
View file

@ -1570,232 +1570,6 @@ undo_free_layer (GimpUndo *undo,
}
/********************************/
/* Layer Mask Add/Remove Undo */
/********************************/
typedef struct _LayerMaskUndo LayerMaskUndo;
struct _LayerMaskUndo
{
GimpLayerMask *mask;
};
static gboolean undo_push_layer_mask (GimpImage *gimage,
const gchar *undo_desc,
GimpUndoType type,
GimpLayer *layer,
GimpLayerMask *mask);
static gboolean undo_pop_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
static void undo_free_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode);
gboolean
gimp_image_undo_push_layer_mask_add (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask)
{
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 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_IS_LAYER_MASK (mask), FALSE);
g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (mask)), FALSE);
return undo_push_layer_mask (gimage, undo_desc, GIMP_UNDO_LAYER_MASK_ADD,
layer, mask);
}
gboolean
gimp_image_undo_push_layer_mask_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask)
{
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 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_IS_LAYER_MASK (mask), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (mask)), FALSE);
g_return_val_if_fail (mask->layer == layer, FALSE);
g_return_val_if_fail (layer->mask == mask, FALSE);
return undo_push_layer_mask (gimage, undo_desc, GIMP_UNDO_LAYER_MASK_REMOVE,
layer, mask);
}
static gboolean
undo_push_layer_mask (GimpImage *gimage,
const gchar *undo_desc,
GimpUndoType type,
GimpLayer *layer,
GimpLayerMask *mask)
{
GimpUndo *new;
gint64 size;
size = sizeof (LayerMaskUndo);
if (type == GIMP_UNDO_LAYER_MASK_REMOVE)
size += gimp_object_get_memsize (GIMP_OBJECT (mask), NULL);
if ((new = gimp_image_undo_push (gimage, GIMP_TYPE_ITEM_UNDO,
size, sizeof (LayerMaskUndo),
type, undo_desc,
GIMP_DIRTY_IMAGE_STRUCTURE,
undo_pop_layer_mask,
undo_free_layer_mask,
"item", layer,
NULL)))
{
LayerMaskUndo *lmu = new->data;
lmu->mask = g_object_ref (mask);
return TRUE;
}
return FALSE;
}
static gboolean
undo_pop_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
LayerMaskUndo *lmu = undo->data;
GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
if ((undo_mode == GIMP_UNDO_MODE_UNDO &&
undo->undo_type == GIMP_UNDO_LAYER_MASK_ADD) ||
(undo_mode == GIMP_UNDO_MODE_REDO &&
undo->undo_type == GIMP_UNDO_LAYER_MASK_REMOVE))
{
/* remove layer mask */
undo->size += gimp_object_get_memsize (GIMP_OBJECT (lmu->mask), NULL);
gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE);
}
else
{
/* restore layer */
undo->size -= gimp_object_get_memsize (GIMP_OBJECT (lmu->mask), NULL);
gimp_layer_add_mask (layer, lmu->mask, FALSE);
GIMP_ITEM (lmu->mask)->removed = FALSE;
}
return TRUE;
}
static void
undo_free_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode)
{
LayerMaskUndo *lmu = undo->data;
g_object_unref (lmu->mask);
g_free (lmu);
}
/********************************/
/* Layer Mask Property Undo */
/********************************/
typedef struct _LayerMaskPropertyUndo LayerMaskPropertyUndo;
struct _LayerMaskPropertyUndo
{
GimpLayerMask *mask;
gboolean apply;
gboolean edit;
gboolean show;
};
static gboolean undo_pop_layer_mask_properties (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
gboolean
gimp_image_undo_push_layer_mask_properties (GimpImage *gimage,
const gchar *undo_desc,
GimpUndoType type,
GimpLayer *layer,
GimpLayerMask *mask)
{
GimpUndo *new;
gint64 size;
size = sizeof (LayerMaskPropertyUndo);
if ((new = gimp_image_undo_push (gimage, GIMP_TYPE_ITEM_UNDO,
size, sizeof (LayerMaskPropertyUndo),
type, undo_desc,
GIMP_DIRTY_ITEM_META,
undo_pop_layer_mask_properties,
undo_free_layer_mask,
"item", layer,
NULL)))
{
LayerMaskPropertyUndo *lmp_undo = new->data;
lmp_undo->mask = g_object_ref (mask);
lmp_undo->apply = mask->apply_mask;
lmp_undo->edit = mask->edit_mask;
lmp_undo->show = mask->show_mask;
return TRUE;
}
return FALSE;
}
static gboolean
undo_pop_layer_mask_properties (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
LayerMaskPropertyUndo *lmp_undo = undo->data;
GimpLayerMask *mask;
gboolean val;
mask = lmp_undo->mask;
switch (undo->undo_type)
{
case GIMP_UNDO_LAYER_MASK_APPLY:
val = (undo_mode == GIMP_UNDO_MODE_UNDO) ?
lmp_undo->apply : ! lmp_undo->apply;
gimp_layer_mask_set_apply (mask, val, FALSE);
break;
case GIMP_UNDO_LAYER_MASK_EDIT:
val = (undo_mode == GIMP_UNDO_MODE_UNDO) ?
lmp_undo->edit : ! lmp_undo->edit;
gimp_layer_mask_set_edit (mask, val, FALSE);
break;
case GIMP_UNDO_LAYER_MASK_SHOW:
val = (undo_mode == GIMP_UNDO_MODE_UNDO) ?
lmp_undo->show : ! lmp_undo->show;
gimp_layer_mask_set_show (mask, val, FALSE);
break;
default:
return FALSE;
break;
}
return TRUE;
}
/***************************/
/* Layer re-position Undo */
/***************************/
@ -1962,29 +1736,41 @@ undo_pop_layer_properties (GimpUndo *undo,
LayerPropertiesUndo *lpu = undo->data;
GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
if (undo->undo_type == GIMP_UNDO_LAYER_MODE)
switch (undo->undo_type)
{
GimpLayerModeEffects mode;
case GIMP_UNDO_LAYER_MODE:
{
GimpLayerModeEffects mode;
mode = gimp_layer_get_mode (layer);
gimp_layer_set_mode (layer, lpu->old_mode, FALSE);
lpu->old_mode = mode;
}
else if (undo->undo_type == GIMP_UNDO_LAYER_OPACITY)
{
gdouble opacity;
mode = gimp_layer_get_mode (layer);
gimp_layer_set_mode (layer, lpu->old_mode, FALSE);
lpu->old_mode = mode;
}
break;
opacity = gimp_layer_get_opacity (layer);
gimp_layer_set_opacity (layer, lpu->old_opacity, FALSE);
lpu->old_opacity = opacity;
}
else if (undo->undo_type == GIMP_UNDO_LAYER_PRESERVE_TRANS)
{
gboolean preserve_trans;
case GIMP_UNDO_LAYER_OPACITY:
{
gdouble opacity;
preserve_trans = gimp_layer_get_preserve_trans (layer);
gimp_layer_set_preserve_trans (layer, lpu->old_preserve_trans, FALSE);
lpu->old_preserve_trans = preserve_trans;
opacity = gimp_layer_get_opacity (layer);
gimp_layer_set_opacity (layer, lpu->old_opacity, FALSE);
lpu->old_opacity = opacity;
}
break;
case GIMP_UNDO_LAYER_PRESERVE_TRANS:
{
gboolean preserve_trans;
preserve_trans = gimp_layer_get_preserve_trans (layer);
gimp_layer_set_preserve_trans (layer, lpu->old_preserve_trans, FALSE);
lpu->old_preserve_trans = preserve_trans;
}
break;
default:
g_return_val_if_reached (FALSE);
break;
}
return TRUE;
@ -2113,6 +1899,274 @@ undo_free_text_layer_modified (GimpUndo *undo,
}
/********************************/
/* Layer Mask Add/Remove Undo */
/********************************/
typedef struct _LayerMaskUndo LayerMaskUndo;
struct _LayerMaskUndo
{
GimpLayerMask *mask;
};
static gboolean undo_push_layer_mask (GimpImage *gimage,
const gchar *undo_desc,
GimpUndoType type,
GimpLayer *layer,
GimpLayerMask *mask);
static gboolean undo_pop_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
static void undo_free_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode);
gboolean
gimp_image_undo_push_layer_mask_add (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask)
{
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 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_IS_LAYER_MASK (mask), FALSE);
g_return_val_if_fail (! gimp_item_is_attached (GIMP_ITEM (mask)), FALSE);
return undo_push_layer_mask (gimage, undo_desc, GIMP_UNDO_LAYER_MASK_ADD,
layer, mask);
}
gboolean
gimp_image_undo_push_layer_mask_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask)
{
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), 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_IS_LAYER_MASK (mask), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (mask)), FALSE);
g_return_val_if_fail (mask->layer == layer, FALSE);
g_return_val_if_fail (layer->mask == mask, FALSE);
return undo_push_layer_mask (gimage, undo_desc, GIMP_UNDO_LAYER_MASK_REMOVE,
layer, mask);
}
static gboolean
undo_push_layer_mask (GimpImage *gimage,
const gchar *undo_desc,
GimpUndoType type,
GimpLayer *layer,
GimpLayerMask *mask)
{
GimpUndo *new;
gint64 size;
size = sizeof (LayerMaskUndo);
if (type == GIMP_UNDO_LAYER_MASK_REMOVE)
size += gimp_object_get_memsize (GIMP_OBJECT (mask), NULL);
if ((new = gimp_image_undo_push (gimage, GIMP_TYPE_ITEM_UNDO,
size, sizeof (LayerMaskUndo),
type, undo_desc,
GIMP_DIRTY_IMAGE_STRUCTURE,
undo_pop_layer_mask,
undo_free_layer_mask,
"item", layer,
NULL)))
{
LayerMaskUndo *lmu = new->data;
lmu->mask = g_object_ref (mask);
return TRUE;
}
return FALSE;
}
static gboolean
undo_pop_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
LayerMaskUndo *lmu = undo->data;
GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
if ((undo_mode == GIMP_UNDO_MODE_UNDO &&
undo->undo_type == GIMP_UNDO_LAYER_MASK_ADD) ||
(undo_mode == GIMP_UNDO_MODE_REDO &&
undo->undo_type == GIMP_UNDO_LAYER_MASK_REMOVE))
{
/* remove layer mask */
undo->size += gimp_object_get_memsize (GIMP_OBJECT (lmu->mask), NULL);
gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE);
}
else
{
/* restore layer */
undo->size -= gimp_object_get_memsize (GIMP_OBJECT (lmu->mask), NULL);
gimp_layer_add_mask (layer, lmu->mask, FALSE);
GIMP_ITEM (lmu->mask)->removed = FALSE;
}
return TRUE;
}
static void
undo_free_layer_mask (GimpUndo *undo,
GimpUndoMode undo_mode)
{
LayerMaskUndo *lmu = undo->data;
g_object_unref (lmu->mask);
g_free (lmu);
}
/******************************/
/* Layer Mask Property Undo */
/******************************/
typedef struct _LayerMaskPropertyUndo LayerMaskPropertyUndo;
struct _LayerMaskPropertyUndo
{
gboolean old_apply;
gboolean old_edit;
gboolean old_show;
};
static gboolean undo_push_layer_mask_properties (GimpImage *gimage,
GimpUndoType undo_type,
const gchar *undo_desc,
GimpLayerMask *mask);
static gboolean undo_pop_layer_mask_properties (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum);
static void undo_free_layer_mask_properties (GimpUndo *undo,
GimpUndoMode undo_mode);
gboolean
gimp_image_undo_push_layer_mask_apply (GimpImage *gimage,
const gchar *undo_desc,
GimpLayerMask *mask)
{
return undo_push_layer_mask_properties (gimage, GIMP_UNDO_LAYER_MASK_APPLY,
undo_desc, mask);
}
gboolean
gimp_image_undo_push_layer_mask_edit (GimpImage *gimage,
const gchar *undo_desc,
GimpLayerMask *mask)
{
return undo_push_layer_mask_properties (gimage, GIMP_UNDO_LAYER_MASK_EDIT,
undo_desc, mask);
}
gboolean
gimp_image_undo_push_layer_mask_show (GimpImage *gimage,
const gchar *undo_desc,
GimpLayerMask *mask)
{
return undo_push_layer_mask_properties (gimage, GIMP_UNDO_LAYER_MASK_SHOW,
undo_desc, mask);
}
static gboolean
undo_push_layer_mask_properties (GimpImage *gimage,
GimpUndoType undo_type,
const gchar *undo_desc,
GimpLayerMask *mask)
{
GimpUndo *new;
gint64 size;
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), FALSE);
g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (mask)), FALSE);
size = sizeof (LayerMaskPropertyUndo);
if ((new = gimp_image_undo_push (gimage, GIMP_TYPE_ITEM_UNDO,
size, sizeof (LayerMaskPropertyUndo),
undo_type, undo_desc,
GIMP_DIRTY_ITEM_META,
undo_pop_layer_mask_properties,
undo_free_layer_mask_properties,
"item", mask,
NULL)))
{
LayerMaskPropertyUndo *lmp_undo = new->data;
lmp_undo->old_apply = gimp_layer_mask_get_apply (mask);
lmp_undo->old_edit = gimp_layer_mask_get_edit (mask);
lmp_undo->old_show = gimp_layer_mask_get_show (mask);
return TRUE;
}
return FALSE;
}
static gboolean
undo_pop_layer_mask_properties (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
LayerMaskPropertyUndo *lmp_undo = undo->data;
GimpLayerMask *mask;
gboolean val;
mask = GIMP_LAYER_MASK (GIMP_ITEM_UNDO (undo)->item);
switch (undo->undo_type)
{
case GIMP_UNDO_LAYER_MASK_APPLY:
val = gimp_layer_mask_get_apply (mask);
gimp_layer_mask_set_apply (mask, lmp_undo->old_apply, FALSE);
lmp_undo->old_apply = val;
break;
case GIMP_UNDO_LAYER_MASK_EDIT:
val = gimp_layer_mask_get_edit (mask);
gimp_layer_mask_set_edit (mask, lmp_undo->old_edit, FALSE);
lmp_undo->old_edit = val;
break;
case GIMP_UNDO_LAYER_MASK_SHOW:
val = gimp_layer_mask_get_show (mask);
gimp_layer_mask_set_show (mask, lmp_undo->old_show, FALSE);
lmp_undo->old_show = val;
break;
default:
g_return_val_if_reached (FALSE);
break;
}
return TRUE;
}
static void
undo_free_layer_mask_properties (GimpUndo *undo,
GimpUndoMode undo_mode)
{
g_free (undo->data);
}
/*****************************/
/* Add/Remove Channel Undo */
/*****************************/

34
app/core/gimpimage-undo-push.h
View file

@ -92,19 +92,6 @@ gboolean gimp_image_undo_push_layer_remove (GimpImage *gimage,
GimpLayer *layer,
gint prev_position,
GimpLayer *prev_layer);
gboolean gimp_image_undo_push_layer_mask_add (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_properties (GimpImage *gimage,
const gchar *undo_desc,
GimpUndoType undo_type,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_reposition (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer);
@ -130,6 +117,27 @@ gboolean gimp_image_undo_push_text_layer_modified (GimpImage *gimage,
GimpTextLayer *layer);
/* layer mask undos */
gboolean gimp_image_undo_push_layer_mask_add (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_remove (GimpImage *gimage,
const gchar *undo_desc,
GimpLayer *layer,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_apply (GimpImage *gimage,
const gchar *undo_desc,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_edit (GimpImage *gimage,
const gchar *undo_desc,
GimpLayerMask *mask);
gboolean gimp_image_undo_push_layer_mask_show (GimpImage *gimage,
const gchar *undo_desc,
GimpLayerMask *mask);
/* channel undos */
gboolean gimp_image_undo_push_channel_add (GimpImage *gimage,

21
app/core/gimplayermask.c
View file

@ -261,11 +261,8 @@ gimp_layer_mask_set_apply (GimpLayerMask *layer_mask,
GimpImage *gimage = GIMP_ITEM (layer_mask)->gimage;
if (push_undo)
gimp_image_undo_push_layer_mask_properties (gimage,
_("Apply Layer Mask"),
GIMP_UNDO_LAYER_MASK_APPLY,
layer_mask->layer,
layer_mask);
gimp_image_undo_push_layer_mask_apply (gimage, _("Apply Layer Mask"),
layer_mask);
layer_mask->apply_mask = apply ? TRUE : FALSE;
@ -303,11 +300,8 @@ gimp_layer_mask_set_edit (GimpLayerMask *layer_mask,
GimpImage *gimage = GIMP_ITEM (layer_mask)->gimage;
if (push_undo)
gimp_image_undo_push_layer_mask_properties (gimage,
_("Edit Layer Mask"),
GIMP_UNDO_LAYER_MASK_EDIT,
layer_mask->layer,
layer_mask);
gimp_image_undo_push_layer_mask_edit (gimage, _("Edit Layer Mask"),
layer_mask);
layer_mask->edit_mask = edit ? TRUE : FALSE;
@ -335,11 +329,8 @@ gimp_layer_mask_set_show (GimpLayerMask *layer_mask,
GimpImage *gimage = GIMP_ITEM (layer_mask)->gimage;
if (push_undo)
gimp_image_undo_push_layer_mask_properties (gimage,
_("Show Layer Mask"),
GIMP_UNDO_LAYER_MASK_SHOW,
layer_mask->layer,
layer_mask);
gimp_image_undo_push_layer_mask_show (gimage, _("Show Layer Mask"),
layer_mask);
layer_mask->show_mask = show ? TRUE : FALSE;