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

app/Makefile.am new files cut out of layer.[ch]. Renamed all functions to 

2001-01-28  Michael Natterer  <mitch@gimp.org>

	* app/Makefile.am
	* app/gimplayermask.[ch]: new files cut out of layer.[ch]. Renamed
	all functions to gimp_layes_mask_*(). removed artefacts like
	the ref/unref functions.

	* app/apptypes.h: removed the "LayerMask" typedef.

	* app/layer.[ch]: removed the layer mask stuff and renamed all
	functions to gimp_layer_*(). Added temporary typedefs for the old
	function names. The layer mask preview stuff is still there (should
	probably go to new layer_preview.{ch] files).

	* app/gimpimage.[ch]: added
	gimp_image_invalidate_[layer|channel]_previews() formerly known as
	[layer|channel]_invalidate_previews().

	* app/channel.[ch]: moved channel_layer_alpha() and
	channel_layer_mask() here because they are methods of the Channel.

	* app/channel_ops.c
	* app/convert.c
	* app/disp_callbacks.c
	* app/fileops.c
	* app/floating_sel.c
	* app/gimage.c
	* app/gimage_mask.c
	* app/gimpdnd.c
	* app/global_edit.c
	* app/layers_dialog.c
	* app/preferences_dialog.c
	* app/toolbox.c
	* app/undo.c
	* app/xcf.c
	* app/pdb/drawable_cmds.c
	* app/pdb/image_cmds.c
	* app/pdb/layer_cmds.c
	* app/tools/crop.c
	* app/tools/text_tool.c
	* app/tools/transform_core.c
	* tools/pdbgen/pdb.pl
	* tools/pdbgen/pdb/drawable.pdb: changed accordingly, cleanup.
This commit is contained in:
Michael Natterer 2001-01-28 16:44:22 +00:00 committed by Michael Natterer
parent 41746cb56e
commit 8ddebdf79a
81 changed files with 4075 additions and 3695 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
ChangeLog
View File

@ -1,3 +1,47 @@
2001-01-28 Michael Natterer <mitch@gimp.org>
* app/Makefile.am
* app/gimplayermask.[ch]: new files cut out of layer.[ch]. Renamed
all functions to gimp_layes_mask_*(). removed artefacts like
the ref/unref functions.
* app/apptypes.h: removed the "LayerMask" typedef.
* app/layer.[ch]: removed the layer mask stuff and renamed all
functions to gimp_layer_*(). Added temporary typedefs for the old
function names. The layer mask preview stuff is still there (should
probably go to new layer_preview.{ch] files).
* app/gimpimage.[ch]: added
gimp_image_invalidate_[layer|channel]_previews() formerly known as
[layer|channel]_invalidate_previews().
* app/channel.[ch]: moved channel_layer_alpha() and
channel_layer_mask() here because they are methods of the Channel.
* app/channel_ops.c
* app/convert.c
* app/disp_callbacks.c
* app/fileops.c
* app/floating_sel.c
* app/gimage.c
* app/gimage_mask.c
* app/gimpdnd.c
* app/global_edit.c
* app/layers_dialog.c
* app/preferences_dialog.c
* app/toolbox.c
* app/undo.c
* app/xcf.c
* app/pdb/drawable_cmds.c
* app/pdb/image_cmds.c
* app/pdb/layer_cmds.c
* app/tools/crop.c
* app/tools/text_tool.c
* app/tools/transform_core.c
* tools/pdbgen/pdb.pl
* tools/pdbgen/pdb/drawable.pdb: changed accordingly, cleanup.
2001-01-26 Daniel Egger <egger@suse.de>
* plug-ins/common/iwarp.c: Cleaned up code and

2
app/Makefile.am
View File

@ -125,6 +125,8 @@ gimp_SOURCES = \
gimphistogram.h \
gimpimage.c \
gimpimage.h \
gimplayermask.c \
gimplayermask.h \
gimplist.c \
gimplist.h \
gimplut.c \

7
app/apptypes.h
View File

@ -50,7 +50,6 @@ typedef struct _GimpLayer GimpLayer;
typedef struct _GimpLayerMask GimpLayerMask;
typedef GimpLayer Layer; /* convenience */
typedef GimpLayerMask LayerMask; /* convenience */
typedef struct _GimpImage GimpImage;
typedef GimpImage GImage;
@ -148,11 +147,11 @@ typedef struct _TransformCore TransformCore;
/* some undo stuff */
typedef struct _layer_undo LayerUndo;
typedef struct _LayerUndo LayerUndo;
typedef struct _layer_mask_undo LayerMaskUndo;
typedef struct _LayerMaskUndo LayerMaskUndo;
typedef struct _fs_to_layer_undo FStoLayerUndo;
typedef struct _FStoLayerUndo FStoLayerUndo;
typedef GSList PathUndo;

83
app/channel.c
View File

@ -546,24 +546,6 @@ channel_preview_private (Channel *channel,
}
}
void
channel_invalidate_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
tmp = gimage->channels;
while (tmp)
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
tmp = g_slist_next (tmp);
}
}
Tattoo
channel_get_tattoo (const Channel *channel)
{
@ -1674,8 +1656,31 @@ channel_translate (Channel *mask,
}
void
channel_layer_alpha (Channel *mask,
Layer *layer)
channel_load (Channel *mask,
Channel *channel)
{
PixelRegion srcPR, destPR;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;
}
void
channel_layer_alpha (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
@ -1710,23 +1715,39 @@ channel_layer_alpha (Channel *mask,
}
void
channel_load (Channel *mask,
Channel *channel)
channel_layer_mask (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
gint x1, y1, x2, y2;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
/* clear the mask */
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
0, 0,
GIMP_DRAWABLE(mask)->width, GIMP_DRAWABLE(mask)->height,
TRUE);
color_region (&destPR, &empty);
x1 = CLAMP (GIMP_DRAWABLE(layer)->offset_x, 0, GIMP_DRAWABLE(mask)->width);
y1 = CLAMP (GIMP_DRAWABLE(layer)->offset_y, 0, GIMP_DRAWABLE(mask)->height);
x2 = CLAMP (GIMP_DRAWABLE(layer)->offset_x + GIMP_DRAWABLE(layer)->width,
0, GIMP_DRAWABLE(mask)->width);
y2 = CLAMP (GIMP_DRAWABLE(layer)->offset_y + GIMP_DRAWABLE(layer)->height,
0, GIMP_DRAWABLE(mask)->height);
pixel_region_init (&srcPR, GIMP_DRAWABLE(layer->mask)->tiles,
(x1 - GIMP_DRAWABLE(layer)->offset_x),
(y1 - GIMP_DRAWABLE(layer)->offset_y),
(x2 - x1), (y2 - y1),
FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
x1, y1,
(x2 - x1), (y2 - y1),
TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;

7
app/channel.h
View File

@ -127,8 +127,6 @@ TempBuf * channel_preview (Channel *channel,
gint width,
gint height);
void channel_invalidate_previews (GimpImage *gimage);
Tattoo channel_get_tattoo (const Channel *channel);
void channel_set_tattoo (Channel *channel,
Tattoo value);
@ -215,6 +213,11 @@ void channel_translate (Channel *mask,
void channel_load (Channel *mask,
Channel *channel);
void channel_layer_alpha (Channel *mask,
GimpLayer *layer);
void channel_layer_mask (Channel *mask,
GimpLayer *layer);
void channel_invalidate_bounds (Channel *channel);

1
app/channel_ops.c
View File

@ -29,6 +29,7 @@
#include "apptypes.h"
#include "apptypes.h"
#include "channel.h"
#include "channel_ops.h"
#include "cursorutil.h"
#include "drawable.h"

2
app/convert.c
View File

@ -1457,7 +1457,7 @@ convert_image (GImage *gimage,
undo_push_group_end (gimage);
/* shrink wrap and update all views */
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_title (gimage);
gdisplays_update_full (gimage);

1
app/core/gimp-edit.c
View File

@ -34,6 +34,7 @@
#include "gimage.h"
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimplayermask.h"
#include "global_edit.h"
#include "layer.h"
#include "paint_funcs.h"

83
app/core/gimpchannel-combine.c
View File

@ -546,24 +546,6 @@ channel_preview_private (Channel *channel,
}
}
void
channel_invalidate_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
tmp = gimage->channels;
while (tmp)
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
tmp = g_slist_next (tmp);
}
}
Tattoo
channel_get_tattoo (const Channel *channel)
{
@ -1674,8 +1656,31 @@ channel_translate (Channel *mask,
}
void
channel_layer_alpha (Channel *mask,
Layer *layer)
channel_load (Channel *mask,
Channel *channel)
{
PixelRegion srcPR, destPR;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;
}
void
channel_layer_alpha (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
@ -1710,23 +1715,39 @@ channel_layer_alpha (Channel *mask,
}
void
channel_load (Channel *mask,
Channel *channel)
channel_layer_mask (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
gint x1, y1, x2, y2;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
/* clear the mask */
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
0, 0,
GIMP_DRAWABLE(mask)->width, GIMP_DRAWABLE(mask)->height,
TRUE);
color_region (&destPR, &empty);
x1 = CLAMP (GIMP_DRAWABLE(layer)->offset_x, 0, GIMP_DRAWABLE(mask)->width);
y1 = CLAMP (GIMP_DRAWABLE(layer)->offset_y, 0, GIMP_DRAWABLE(mask)->height);
x2 = CLAMP (GIMP_DRAWABLE(layer)->offset_x + GIMP_DRAWABLE(layer)->width,
0, GIMP_DRAWABLE(mask)->width);
y2 = CLAMP (GIMP_DRAWABLE(layer)->offset_y + GIMP_DRAWABLE(layer)->height,
0, GIMP_DRAWABLE(mask)->height);
pixel_region_init (&srcPR, GIMP_DRAWABLE(layer->mask)->tiles,
(x1 - GIMP_DRAWABLE(layer)->offset_x),
(y1 - GIMP_DRAWABLE(layer)->offset_y),
(x2 - x1), (y2 - y1),
FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
x1, y1,
(x2 - x1), (y2 - y1),
TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;

7
app/core/gimpchannel-combine.h
View File

@ -127,8 +127,6 @@ TempBuf * channel_preview (Channel *channel,
gint width,
gint height);
void channel_invalidate_previews (GimpImage *gimage);
Tattoo channel_get_tattoo (const Channel *channel);
void channel_set_tattoo (Channel *channel,
Tattoo value);
@ -215,6 +213,11 @@ void channel_translate (Channel *mask,
void channel_load (Channel *mask,
Channel *channel);
void channel_layer_alpha (Channel *mask,
GimpLayer *layer);
void channel_layer_mask (Channel *mask,
GimpLayer *layer);
void channel_invalidate_bounds (Channel *channel);

83
app/core/gimpchannel.c
View File

@ -546,24 +546,6 @@ channel_preview_private (Channel *channel,
}
}
void
channel_invalidate_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
tmp = gimage->channels;
while (tmp)
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
tmp = g_slist_next (tmp);
}
}
Tattoo
channel_get_tattoo (const Channel *channel)
{
@ -1674,8 +1656,31 @@ channel_translate (Channel *mask,
}
void
channel_layer_alpha (Channel *mask,
Layer *layer)
channel_load (Channel *mask,
Channel *channel)
{
PixelRegion srcPR, destPR;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;
}
void
channel_layer_alpha (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
@ -1710,23 +1715,39 @@ channel_layer_alpha (Channel *mask,
}
void
channel_load (Channel *mask,
Channel *channel)
channel_layer_mask (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
gint x1, y1, x2, y2;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
/* clear the mask */
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
0, 0,
GIMP_DRAWABLE(mask)->width, GIMP_DRAWABLE(mask)->height,
TRUE);
color_region (&destPR, &empty);
x1 = CLAMP (GIMP_DRAWABLE(layer)->offset_x, 0, GIMP_DRAWABLE(mask)->width);
y1 = CLAMP (GIMP_DRAWABLE(layer)->offset_y, 0, GIMP_DRAWABLE(mask)->height);
x2 = CLAMP (GIMP_DRAWABLE(layer)->offset_x + GIMP_DRAWABLE(layer)->width,
0, GIMP_DRAWABLE(mask)->width);
y2 = CLAMP (GIMP_DRAWABLE(layer)->offset_y + GIMP_DRAWABLE(layer)->height,
0, GIMP_DRAWABLE(mask)->height);
pixel_region_init (&srcPR, GIMP_DRAWABLE(layer->mask)->tiles,
(x1 - GIMP_DRAWABLE(layer)->offset_x),
(y1 - GIMP_DRAWABLE(layer)->offset_y),
(x2 - x1), (y2 - y1),
FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
x1, y1,
(x2 - x1), (y2 - y1),
TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;

7
app/core/gimpchannel.h
View File

@ -127,8 +127,6 @@ TempBuf * channel_preview (Channel *channel,
gint width,
gint height);
void channel_invalidate_previews (GimpImage *gimage);
Tattoo channel_get_tattoo (const Channel *channel);
void channel_set_tattoo (Channel *channel,
Tattoo value);
@ -215,6 +213,11 @@ void channel_translate (Channel *mask,
void channel_load (Channel *mask,
Channel *channel);
void channel_layer_alpha (Channel *mask,
GimpLayer *layer);
void channel_layer_mask (Channel *mask,
GimpLayer *layer);
void channel_invalidate_bounds (Channel *channel);

1
app/core/gimpdrawable-offset.c
View File

@ -29,6 +29,7 @@
#include "apptypes.h"
#include "apptypes.h"
#include "channel.h"
#include "channel_ops.h"
#include "cursorutil.h"
#include "drawable.h"

1
app/core/gimpedit.c
View File

@ -34,6 +34,7 @@
#include "gimage.h"
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimplayermask.h"
#include "global_edit.h"
#include "layer.h"
#include "paint_funcs.h"

2
app/core/gimpimage-convert.c
View File

@ -1457,7 +1457,7 @@ convert_image (GImage *gimage,
undo_push_group_end (gimage);
/* shrink wrap and update all views */
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_title (gimage);
gdisplays_update_full (gimage);

1
app/core/gimpimage-duplicate.c
View File

@ -29,6 +29,7 @@
#include "apptypes.h"
#include "apptypes.h"
#include "channel.h"
#include "channel_ops.h"
#include "cursorutil.h"
#include "drawable.h"

49
app/core/gimpimage-guides.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpimage-guides.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

4
app/core/gimpimage-mask.c
View File

@ -24,10 +24,12 @@
#include "appenv.h"
#include "boundary.h"
#include "channel.h"
#include "drawable.h"
#include "floating_sel.h"
#include "gdisplay.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimage_mask.h"
#include "gimprc.h"
#include "layer.h"
@ -331,7 +333,7 @@ gimage_mask_extract (GImage *gimage,
else if (cut_gimage && GIMP_IS_LAYER_MASK (drawable))
{
gimp_image_remove_layer_mask (gimage,
layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
DISCARD);
}
else if (cut_gimage && GIMP_IS_CHANNEL (drawable))

49
app/core/gimpimage-merge.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpimage-merge.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

49
app/core/gimpimage-projection.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpimage-projection.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

49
app/core/gimpimage-resize.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpimage-resize.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

49
app/core/gimpimage-scale.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpimage-scale.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

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

@ -34,6 +34,7 @@
#include "gdisplay_ops.h"
#include "gimage.h"
#include "gimage_mask.h"
#include "gimplayermask.h"
#include "gimpparasite.h"
#include "gimprc.h"
#include "layer.h"
@ -72,7 +73,7 @@ typedef enum
} UndoState;
typedef gboolean (* UndoPopFunc) (GImage *, UndoState, UndoType, gpointer);
typedef gboolean (* UndoPopFunc) (GimpImage *, UndoState, UndoType, gpointer);
typedef void (* UndoFreeFunc) (UndoState, UndoType, gpointer);
typedef struct _Undo Undo;
@ -91,47 +92,47 @@ struct _Undo
/* Pop functions */
static gboolean undo_pop_image (GImage *,
static gboolean undo_pop_image (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_mask (GImage *,
static gboolean undo_pop_mask (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_displace (GImage *,
static gboolean undo_pop_layer_displace (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_transform (GImage *,
static gboolean undo_pop_transform (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_paint (GImage *,
static gboolean undo_pop_paint (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer (GImage *,
static gboolean undo_pop_layer (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_mod (GImage *,
static gboolean undo_pop_layer_mod (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_mask (GImage *,
static gboolean undo_pop_layer_mask (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_channel (GImage *,
static gboolean undo_pop_channel (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_channel_mod (GImage *,
static gboolean undo_pop_channel_mod (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_fs_to_layer (GImage *,
static gboolean undo_pop_fs_to_layer (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_fs_rigor (GImage *,
static gboolean undo_pop_fs_rigor (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_fs_relax (GImage *,
static gboolean undo_pop_fs_relax (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_gimage_mod (GImage *,
static gboolean undo_pop_gimage_mod (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_guide (GImage *,
static gboolean undo_pop_guide (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_parasite (GImage *,
static gboolean undo_pop_parasite (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_qmask (GImage *,
static gboolean undo_pop_qmask (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_resolution (GImage *,
static gboolean undo_pop_resolution (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_rename (GImage *,
static gboolean undo_pop_layer_rename (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_reposition (GImage *,
static gboolean undo_pop_layer_reposition (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_cantundo (GImage *,
static gboolean undo_pop_cantundo (GimpImage *,
UndoState, UndoType, gpointer);
@ -207,9 +208,9 @@ channel_size (Channel *channel)
static void
undo_free_list (GImage *gimage,
UndoState state,
GSList *list)
undo_free_list (GimpImage *gimage,
UndoState state,
GSList *list)
{
GSList *orig;
Undo *undo;
@ -234,7 +235,7 @@ undo_free_list (GImage *gimage,
static GSList *
remove_stack_bottom (GImage *gimage)
remove_stack_bottom (GimpImage *gimage)
{
GSList *list;
GSList *last;
@ -303,7 +304,7 @@ undo_new (UndoType type,
static gboolean
undo_free_up_space (GImage *gimage)
undo_free_up_space (GimpImage *gimage)
{
/* If there are 0 levels of undo return FALSE. */
if (levels_of_undo == 0)
@ -320,10 +321,10 @@ undo_free_up_space (GImage *gimage)
static Undo *
undo_push (GImage *gimage,
glong size,
UndoType type,
gboolean dirties_image)
undo_push (GimpImage *gimage,
glong size,
UndoType type,
gboolean dirties_image)
{
Undo *new;
@ -376,7 +377,7 @@ undo_push (GImage *gimage,
static gboolean
pop_stack (GImage *gimage,
pop_stack (GimpImage *gimage,
GSList **stack_ptr,
GSList **unstack_ptr,
UndoState state)
@ -490,7 +491,7 @@ pop_stack (GImage *gimage,
gboolean
undo_pop (GImage *gimage)
undo_pop (GimpImage *gimage)
{
/* Very bad idea to pop an action off the undo stack if we're in the
* middle of a group, since the whole group won't be popped. Might
@ -504,7 +505,7 @@ undo_pop (GImage *gimage)
gboolean
undo_redo (GImage *gimage)
undo_redo (GimpImage *gimage)
{
/* ditto for redo stack */
g_return_val_if_fail (gimage->pushing_undo_group == UNDO_NULL, FALSE);
@ -558,7 +559,7 @@ undo_get_topitem_type (GSList *stack)
const gchar *
undo_get_undo_name (GImage *gimage)
undo_get_undo_name (GimpImage *gimage)
{
g_return_val_if_fail (gimage != NULL, NULL);
@ -570,7 +571,7 @@ undo_get_undo_name (GImage *gimage)
}
UndoType
undo_get_undo_top_type (GImage *gimage)
undo_get_undo_top_type (GimpImage *gimage)
{
g_return_val_if_fail (gimage != NULL, UNDO_NULL);
@ -583,7 +584,7 @@ undo_get_undo_top_type (GImage *gimage)
const gchar *
undo_get_redo_name (GImage *gimage)
undo_get_redo_name (GimpImage *gimage)
{
g_return_val_if_fail (gimage != NULL, NULL);
@ -631,7 +632,7 @@ undo_map_over_stack (GSList *stack,
}
void
undo_map_over_undo_stack (GImage *gimage,
undo_map_over_undo_stack (GimpImage *gimage,
undo_map_fn fn,
gpointer data)
{
@ -641,7 +642,7 @@ undo_map_over_undo_stack (GImage *gimage,
}
void
undo_map_over_redo_stack (GImage *gimage,
undo_map_over_redo_stack (GimpImage *gimage,
undo_map_fn fn,
gpointer data)
{
@ -652,7 +653,7 @@ undo_map_over_redo_stack (GImage *gimage,
void
undo_free (GImage *gimage)
undo_free (GimpImage *gimage)
{
undo_free_list (gimage, UNDO, gimage->undo_stack);
undo_free_list (gimage, REDO, gimage->redo_stack);
@ -683,7 +684,7 @@ undo_free (GImage *gimage)
/* group Undo funcs */
gboolean
undo_push_group_start (GImage *gimage,
undo_push_group_start (GimpImage *gimage,
UndoType type)
{
Undo *boundary_marker;
@ -733,7 +734,7 @@ undo_push_group_start (GImage *gimage,
gboolean
undo_push_group_end (GImage *gimage)
undo_push_group_end (GimpImage *gimage)
{
Undo *boundary_marker;
@ -778,7 +779,7 @@ struct _ImageUndo
gboolean
undo_push_image (GImage *gimage,
undo_push_image (GimpImage *gimage,
GimpDrawable *drawable,
gint x1,
gint y1,
@ -834,7 +835,7 @@ undo_push_image (GImage *gimage,
gboolean
undo_push_image_mod (GImage *gimage,
undo_push_image_mod (GimpImage *gimage,
GimpDrawable *drawable,
gint x1,
gint y1,
@ -893,7 +894,7 @@ undo_push_image_mod (GImage *gimage,
static gboolean
undo_pop_image (GImage *gimage,
undo_pop_image (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer image_undo_ptr)
@ -984,8 +985,8 @@ undo_free_image (UndoState state,
/* Mask Undo functions */
gboolean
undo_push_mask (GImage *gimage,
gpointer mask_ptr)
undo_push_mask (GimpImage *gimage,
gpointer mask_ptr)
{
Undo *new;
MaskUndo *mask_undo;
@ -1019,19 +1020,19 @@ undo_push_mask (GImage *gimage,
static gboolean
undo_pop_mask (GImage *gimage,
UndoState state,
UndoType type,
gpointer mask_ptr)
undo_pop_mask (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer mask_ptr)
{
MaskUndo *mask_undo;
TileManager *new_tiles;
Channel *sel_mask;
PixelRegion srcPR, destPR;
gint selection;
gint x1, y1, x2, y2;
gint width, height;
guchar empty = 0;
gint selection;
gint x1, y1, x2, y2;
gint width, height;
guchar empty = 0;
width = height = 0;
@ -1135,7 +1136,7 @@ struct _LayerDisplayUndo
};
gboolean
undo_push_layer_displace (GImage *gimage,
undo_push_layer_displace (GimpImage *gimage,
GimpLayer *layer)
{
Undo *new;
@ -1161,13 +1162,13 @@ undo_push_layer_displace (GImage *gimage,
static gboolean
undo_pop_layer_displace (GImage *gimage,
UndoState state,
UndoType type,
gpointer info_ptr)
undo_pop_layer_displace (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer info_ptr)
{
Layer *layer;
gint old_offsets[2];
GimpLayer *layer;
gint old_offsets[2];
LayerDisplaceUndo *ldu;
ldu = (LayerDisplaceUndo *) info_ptr;
@ -1234,8 +1235,8 @@ undo_free_layer_displace (UndoState state,
/* Transform Undo */
gboolean
undo_push_transform (GImage *gimage,
gpointer tu_ptr)
undo_push_transform (GimpImage *gimage,
gpointer tu_ptr)
{
Undo *new;
@ -1257,7 +1258,7 @@ undo_push_transform (GImage *gimage,
static gboolean
undo_pop_transform (GImage *gimage,
undo_pop_transform (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer tu_ptr)
@ -1265,8 +1266,8 @@ undo_pop_transform (GImage *gimage,
TransformCore *tc;
TransformUndo *tu;
TileManager *temp;
gdouble d;
gint i;
gdouble d;
gint i;
/* Can't have ANY tool selected - maybe a plugin running */
if (active_tool == NULL)
@ -1325,8 +1326,8 @@ undo_free_transform (UndoState state,
/* Paint Undo */
gboolean
undo_push_paint (GImage *gimage,
gpointer pu_ptr)
undo_push_paint (GimpImage *gimage,
gpointer pu_ptr)
{
Undo *new;
@ -1348,7 +1349,7 @@ undo_push_paint (GImage *gimage,
static gboolean
undo_pop_paint (GImage *gimage,
undo_pop_paint (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer pu_ptr)
@ -1409,9 +1410,9 @@ undo_free_paint (UndoState state,
/* New Layer Undo */
gboolean
undo_push_layer (GImage *gimage,
UndoType type,
gpointer lu_ptr)
undo_push_layer (GimpImage *gimage,
UndoType type,
gpointer lu_ptr)
{
LayerUndo *lu;
Undo *new;
@ -1445,7 +1446,7 @@ undo_push_layer (GImage *gimage,
static gboolean
undo_pop_layer (GImage *gimage,
undo_pop_layer (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer lu_ptr)
@ -1533,10 +1534,10 @@ undo_free_layer (UndoState state,
/* Layer Mod Undo */
gboolean
undo_push_layer_mod (GImage *gimage,
gpointer layer_ptr)
undo_push_layer_mod (GimpImage *gimage,
gpointer layer_ptr)
{
Layer *layer;
GimpLayer *layer;
Undo *new;
TileManager *tiles;
gpointer *data;
@ -1574,7 +1575,7 @@ undo_push_layer_mod (GImage *gimage,
static gboolean
undo_pop_layer_mod (GImage *gimage,
undo_pop_layer_mod (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -1583,10 +1584,10 @@ undo_pop_layer_mod (GImage *gimage,
gint layer_type;
TileManager *tiles;
TileManager *temp;
Layer *layer;
GimpLayer *layer;
data = (gpointer *) data_ptr;
layer = (Layer *) data[0];
layer = (GimpLayer *) data[0];
tiles = (TileManager *) data[1];
@ -1656,9 +1657,9 @@ undo_free_layer_mod (UndoState state,
/* Layer Mask Undo */
gboolean
undo_push_layer_mask (GImage *gimage,
UndoType type,
gpointer lmu_ptr)
undo_push_layer_mask (GimpImage *gimage,
UndoType type,
gpointer lmu_ptr)
{
LayerMaskUndo *lmu;
Undo *new;
@ -1683,7 +1684,8 @@ undo_push_layer_mask (GImage *gimage,
else
{
if (type == LAYER_MASK_REMOVE_UNDO)
layer_mask_delete (lmu->mask);
gtk_object_unref (GTK_OBJECT (lmu->mask));
g_free (lmu);
return FALSE;
}
@ -1691,7 +1693,7 @@ undo_push_layer_mask (GImage *gimage,
static gboolean
undo_pop_layer_mask (GImage *gimage,
undo_pop_layer_mask (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer lmu_ptr)
@ -1758,7 +1760,7 @@ undo_free_layer_mask (UndoState state,
*/
if ((state == REDO && type == LAYER_MASK_ADD_UNDO) ||
(state == UNDO && type == LAYER_MASK_REMOVE_UNDO))
layer_mask_delete (lmu->mask);
gtk_object_unref (GTK_OBJECT (lmu->mask));
g_free (lmu);
}
@ -1768,13 +1770,13 @@ undo_free_layer_mask (UndoState state,
/* New Channel Undo */
gboolean
undo_push_channel (GImage *gimage,
UndoType type,
gpointer cu_ptr)
undo_push_channel (GimpImage *gimage,
UndoType type,
gpointer cu_ptr)
{
ChannelUndo *cu;
Undo *new;
gint size;
Undo *new;
gint size;
g_return_val_if_fail (type == CHANNEL_ADD_UNDO ||
type == CHANNEL_REMOVE_UNDO,
@ -1803,7 +1805,7 @@ undo_push_channel (GImage *gimage,
static gboolean
undo_pop_channel (GImage *gimage,
undo_pop_channel (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer cu_ptr)
@ -1879,8 +1881,8 @@ undo_free_channel (UndoState state,
/* Channel Mod Undo */
gboolean
undo_push_channel_mod (GImage *gimage,
gpointer channel_ptr)
undo_push_channel_mod (GimpImage *gimage,
gpointer channel_ptr)
{
Channel *channel;
TileManager *tiles;
@ -1915,7 +1917,7 @@ undo_push_channel_mod (GImage *gimage,
static gboolean
undo_pop_channel_mod (GImage *gimage,
undo_pop_channel_mod (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -1972,11 +1974,11 @@ undo_free_channel_mod (UndoState state,
/* Floating Selection to Layer Undo */
gboolean
undo_push_fs_to_layer (GImage *gimage,
gpointer fsu_ptr)
undo_push_fs_to_layer (GimpImage *gimage,
gpointer fsu_ptr)
{
FStoLayerUndo *fsu;
Undo *new;
Undo *new;
fsu = (FStoLayerUndo *) fsu_ptr;
@ -1999,7 +2001,7 @@ undo_push_fs_to_layer (GImage *gimage,
static gboolean
undo_pop_fs_to_layer (GImage *gimage,
undo_pop_fs_to_layer (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer fsu_ptr)
@ -2079,8 +2081,8 @@ undo_free_fs_to_layer (UndoState state,
/* Floating Selection Rigor Undo */
gboolean
undo_push_fs_rigor (GImage *gimage,
gint layer_ID)
undo_push_fs_rigor (GimpImage *gimage,
gint layer_ID)
{
Undo *new;
@ -2101,7 +2103,7 @@ undo_push_fs_rigor (GImage *gimage,
static gboolean
undo_pop_fs_rigor (GImage *gimage,
undo_pop_fs_rigor (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer layer_ptr)
@ -2158,8 +2160,8 @@ undo_free_fs_rigor (UndoState state,
/* Floating Selection Relax Undo */
gboolean
undo_push_fs_relax (GImage *gimage,
gint32 layer_ID)
undo_push_fs_relax (GimpImage *gimage,
gint32 layer_ID)
{
Undo *new;
@ -2180,7 +2182,7 @@ undo_push_fs_relax (GImage *gimage,
static gboolean
undo_pop_fs_relax (GImage *gimage,
undo_pop_fs_relax (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer layer_ptr)
@ -2237,7 +2239,7 @@ undo_free_fs_relax (UndoState state,
/* GImage Mod Undo */
gboolean
undo_push_gimage_mod (GImage *gimage)
undo_push_gimage_mod (GimpImage *gimage)
{
Undo *new;
gint *data;
@ -2262,7 +2264,7 @@ undo_push_gimage_mod (GImage *gimage)
static gboolean
undo_pop_gimage_mod (GImage *gimage,
undo_pop_gimage_mod (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2284,8 +2286,8 @@ undo_pop_gimage_mod (GImage *gimage,
gimp_image_projection_realloc (gimage);
gimage_mask_invalidate (gimage);
channel_invalidate_previews (gimage);
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_full (gimage);
gdisplays_update_title (gimage);
@ -2314,13 +2316,13 @@ typedef struct _QmaskUndo QmaskUndo;
struct _QmaskUndo
{
GImage *gimage;
gboolean qmask;
GimpImage *gimage;
gboolean qmask;
};
gboolean
undo_push_qmask (GImage *gimage)
undo_push_qmask (GimpImage *gimage)
{
Undo *new;
QmaskUndo *data;
@ -2343,7 +2345,7 @@ undo_push_qmask (GImage *gimage)
}
static gboolean
undo_pop_qmask (GImage *gimage,
undo_pop_qmask (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2379,14 +2381,14 @@ typedef struct _GuideUndo GuideUndo;
struct _GuideUndo
{
GImage *gimage;
Guide *guide;
Guide orig;
GimpImage *gimage;
Guide *guide;
Guide orig;
};
gboolean
undo_push_guide (GImage *gimage,
gpointer guide)
undo_push_guide (GimpImage *gimage,
gpointer guide)
{
Undo *new;
GuideUndo *data;
@ -2413,7 +2415,7 @@ undo_push_guide (GImage *gimage,
static gboolean
undo_pop_guide (GImage *gimage,
undo_pop_guide (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2469,7 +2471,7 @@ struct _ResolutionUndo
};
gboolean
undo_push_resolution (GImage *gimage)
undo_push_resolution (GimpImage *gimage)
{
Undo *new;
ResolutionUndo *data;
@ -2493,7 +2495,7 @@ undo_push_resolution (GImage *gimage)
}
static gboolean
undo_pop_resolution (GImage *gimage,
undo_pop_resolution (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2541,15 +2543,15 @@ typedef struct _ParasiteUndo ParasiteUndo;
struct _ParasiteUndo
{
GImage *gimage;
GimpImage *gimage;
GimpDrawable *drawable;
GimpParasite *parasite;
gchar *name;
};
gboolean
undo_push_image_parasite (GImage *gimage,
gpointer parasite)
undo_push_image_parasite (GimpImage *gimage,
gpointer parasite)
{
Undo *new;
ParasiteUndo *data;
@ -2574,7 +2576,7 @@ undo_push_image_parasite (GImage *gimage,
}
gboolean
undo_push_image_parasite_remove (GImage *gimage,
undo_push_image_parasite_remove (GimpImage *gimage,
const gchar *name)
{
Undo *new;
@ -2600,7 +2602,7 @@ undo_push_image_parasite_remove (GImage *gimage,
}
gboolean
undo_push_drawable_parasite (GImage *gimage,
undo_push_drawable_parasite (GimpImage *gimage,
GimpDrawable *drawable,
gpointer parasite)
{
@ -2626,7 +2628,7 @@ undo_push_drawable_parasite (GImage *gimage,
}
gboolean
undo_push_drawable_parasite_remove (GImage *gimage,
undo_push_drawable_parasite_remove (GimpImage *gimage,
GimpDrawable *drawable,
const gchar *name)
{
@ -2653,7 +2655,7 @@ undo_push_drawable_parasite_remove (GImage *gimage,
static gboolean
undo_pop_parasite (GImage *gimage,
undo_pop_parasite (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2732,7 +2734,7 @@ struct _LayerRepositionUndo
};
gboolean
undo_push_layer_reposition (GImage *gimage,
undo_push_layer_reposition (GimpImage *gimage,
GimpLayer *layer)
{
Undo *new;
@ -2756,13 +2758,13 @@ undo_push_layer_reposition (GImage *gimage,
}
static gboolean
undo_pop_layer_reposition (GImage *gimage,
undo_pop_layer_reposition (GimpImage *gimage,
UndoState state,
UndoType type,
void *data_ptr)
{
LayerRepositionUndo *data = data_ptr;
gint tmp;
gint tmp;
/* what's the layer's current index? */
tmp = g_slist_index (gimage->layers, data->layer);
@ -2795,7 +2797,7 @@ struct _LayerRenameUndo
};
gboolean
undo_push_layer_rename (GImage *gimage,
undo_push_layer_rename (GimpImage *gimage,
GimpLayer *layer)
{
Undo *new;
@ -2819,13 +2821,13 @@ undo_push_layer_rename (GImage *gimage,
}
static gboolean
undo_pop_layer_rename (GImage *gimage,
undo_pop_layer_rename (GimpImage *gimage,
UndoState state,
UndoType type,
void *data_ptr)
{
LayerRenameUndo *data = data_ptr;
gchar *tmp;
gchar *tmp;
tmp = g_strdup (layer_get_name (data->layer));
layer_set_name (data->layer, data->old_name);
@ -2854,7 +2856,7 @@ undo_free_layer_rename (UndoState state,
*/
gboolean
undo_push_cantundo (GImage *gimage,
undo_push_cantundo (GimpImage *gimage,
const gchar *action)
{
Undo *new;
@ -2875,7 +2877,7 @@ undo_push_cantundo (GImage *gimage,
}
static gboolean
undo_pop_cantundo (GImage *gimage,
undo_pop_cantundo (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)

49
app/core/gimpimage.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpimage.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

1
app/core/gimplayer-floating-sel.c
View File

@ -32,6 +32,7 @@
#include "gdisplay.h"
#include "gimage_mask.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "paint_funcs.h"
#include "pixel_region.h"
#include "tile_manager.h"

901
app/core/gimplayer.c
View File

File diff suppressed because it is too large Load Diff

254
app/core/gimplayer.h
View File

@ -16,29 +16,55 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __LAYER_H__
#define __LAYER_H__
#ifndef __GIMP_LAYER_H__
#define __GIMP_LAYER_H__
#include "channel.h"
#include "gimpdrawable.h"
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
/* EEK */
#define GIMP_TYPE_LAYER_MASK (gimp_layer_mask_get_type ())
#define GIMP_LAYER_MASK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
#define layer_new gimp_layer_new
#define layer_copy gimp_layer_copy
#define layer_create_mask gimp_layer_create_mask
#define layer_scale gimp_layer_scale
#define layer_resize gimp_layer_resize
#define layer_delete gimp_layer_delete
#define layer_translate gimp_layer_translate
#define layer_get_name gimp_layer_get_name
#define layer_set_name gimp_layer_set_name
#define layer_get_tattoo gimp_layer_get_tattoo
#define layer_set_tattoo gimp_layer_set_tattoo
#define layer_add_alpha gimp_layer_add_alpha
#define layer_has_alpha gimp_layer_has_alpha
#define layer_preview gimp_layer_preview
#define layer_is_floating_sel gimp_layer_is_floating_sel
#define layer_invalidate_previews gimp_layer_invalidate_previews
#define layer_linked gimp_layer_linked
#define layer_get_mask gimp_layer_get_mask
#define layer_new_from_tiles gimp_layer_new_from_tiles
#define layer_resize_to_image gimp_layer_resize_to_image
#define layer_invalidate_boundary gimp_layer_invalidate_boundary
#define layer_scale_by_factors gimp_layer_scale_by_factors
#define layer_boundary gimp_layer_boundary
#define layer_pick_correlate gimp_layer_pick_correlate
#define layer_apply_mask gimp_layer_apply_mask
#define layer_add_mask gimp_layer_add_mask
#define layer_check_scaling gimp_layer_check_scaling
#define gimp_drawable_layer GIMP_IS_LAYER
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
typedef struct _GimpLayerClass GimpLayerClass;
typedef struct _GimpLayerMaskClass GimpLayerMaskClass;
struct _GimpLayer
{
@ -47,7 +73,7 @@ struct _GimpLayer
gboolean linked; /* control linkage */
gboolean preserve_trans; /* preserve transparency */
LayerMask *mask; /* possible layer mask */
GimpLayerMask *mask; /* possible layer mask */
gint apply_mask; /* controls mask application */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show mask or layer? */
@ -73,142 +99,94 @@ struct _GimpLayerClass
GimpDrawableClass parent_class;
};
struct _GimpLayerMask
{
GimpChannel parent_instance;
Layer *layer;
};
struct _GimpLayerMaskClass
{
GimpChannelClass parent_class;
};
/* Special undo types */
struct _layer_undo
struct _LayerUndo
{
Layer *layer; /* the actual layer */
gint prev_position; /* former position in list */
Layer *prev_layer; /* previous active layer */
GimpLayer *layer; /* the actual layer */
gint prev_position; /* former position in list */
GimpLayer *prev_layer; /* previous active layer */
};
struct _layer_mask_undo
struct _FStoLayerUndo
{
Layer *layer; /* the layer */
gboolean apply_mask; /* apply mask? */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show the mask? */
LayerMask *mask; /* the layer mask */
gint mode; /* the application mode */
};
struct _fs_to_layer_undo
{
Layer *layer; /* the layer */
GimpLayer *layer; /* the layer */
GimpDrawable *drawable; /* drawable of floating sel */
};
/* function declarations */
GtkType gimp_layer_get_type (void);
GtkType gimp_layer_get_type (void);
Layer * layer_new (GimpImage *gimage,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gint opacity,
LayerModeEffects mode);
Layer * layer_copy (Layer *layer,
gboolean add_alpha);
GimpLayer * gimp_layer_new (GimpImage *gimage,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gint opacity,
LayerModeEffects mode);
GimpLayer * gimp_layer_copy (GimpLayer *layer,
gboolean add_alpha);
Layer * layer_new_from_tiles (GimpImage *gimage,
GimpImageType layer_type,
TileManager *tiles,
gchar *name,
gint opacity,
LayerModeEffects mode);
gboolean layer_check_scaling (Layer *layer,
gint new_width,
gint new_height);
LayerMask * layer_create_mask (Layer *layer,
AddMaskType add_mask_type);
LayerMask * layer_add_mask (Layer *layer,
LayerMask *mask);
void layer_delete (Layer *layer);
void layer_apply_mask (Layer *layer,
MaskApplyMode mode);
void layer_translate (Layer *layer,
gint off_x,
gint off_y);
void layer_add_alpha (Layer *layer);
gboolean layer_scale_by_factors (Layer *layer,
gdouble w_factor,
gdouble h_factor);
void layer_scale (Layer *layer,
gint new_width,
gint new_height,
gboolean local_origin);
void layer_resize (Layer *layer,
gint new_width,
gint new_height,
gint offx,
gint offy);
void layer_resize_to_image (Layer *layer);
BoundSeg * layer_boundary (Layer *layer,
gint *num_segs);
void layer_invalidate_boundary (Layer *layer);
gint layer_pick_correlate (Layer *layer,
gint x,
gint y);
GimpLayer * gimp_layer_new_from_tiles (GimpImage *gimage,
GimpImageType layer_type,
TileManager *tiles,
gchar *name,
gint opacity,
LayerModeEffects mode);
gboolean gimp_layer_check_scaling (GimpLayer *layer,
gint new_width,
gint new_height);
GimpLayerMask * gimp_layer_create_mask (GimpLayer *layer,
AddMaskType add_mask_type);
GimpLayerMask * gimp_layer_add_mask (GimpLayer *layer,
GimpLayerMask *mask);
void gimp_layer_delete (GimpLayer *layer);
void gimp_layer_apply_mask (GimpLayer *layer,
MaskApplyMode mode);
void gimp_layer_translate (GimpLayer *layer,
gint off_x,
gint off_y);
void gimp_layer_add_alpha (GimpLayer *layer);
gboolean gimp_layer_scale_by_factors (GimpLayer *layer,
gdouble w_factor,
gdouble h_factor);
void gimp_layer_scale (GimpLayer *layer,
gint new_width,
gint new_height,
gboolean local_origin);
void gimp_layer_resize (GimpLayer *layer,
gint new_width,
gint new_height,
gint offx,
gint offy);
void gimp_layer_resize_to_image (GimpLayer *layer);
BoundSeg * gimp_layer_boundary (GimpLayer *layer,
gint *num_segs);
void gimp_layer_invalidate_boundary (GimpLayer *layer);
gint gimp_layer_pick_correlate (GimpLayer *layer,
gint x,
gint y);
void gimp_layer_set_name (GimpLayer *layer,
const gchar *name);
const gchar * gimp_layer_get_name (const GimpLayer *layer);
GimpLayerMask * gimp_layer_get_mask (GimpLayer *layer);
gboolean gimp_layer_has_alpha (GimpLayer *layer);
gboolean gimp_layer_is_floating_sel (GimpLayer *layer);
gboolean gimp_layer_linked (GimpLayer *layer);
Tattoo gimp_layer_get_tattoo (const GimpLayer *layer);
void gimp_layer_set_tattoo (GimpLayer *layer,
Tattoo value);
TempBuf * gimp_layer_preview (GimpLayer *layer,
gint width,
gint height);
TempBuf * gimp_layer_mask_preview (GimpLayer *layer,
gint width,
gint height);
GtkType gimp_layer_mask_get_type (void);
LayerMask * layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color);
LayerMask * layer_mask_copy (LayerMask *layer_mask);
void layer_mask_delete (LayerMask *layer_mask);
LayerMask * layer_mask_ref (LayerMask *layer_mask);
void layer_mask_unref (LayerMask *layer_mask);
void layer_mask_set_layer (LayerMask *layer_mask,
Layer *layer);
Layer * layer_mask_get_layer (LayerMask *layer_mask);
/* access functions */
void layer_set_name (Layer *layer,
const gchar *name);
const gchar * layer_get_name (const Layer *layer);
guchar * layer_data (Layer *layer);
LayerMask * layer_get_mask (Layer *layer);
gboolean layer_has_alpha (Layer *layer);
gboolean layer_is_floating_sel (Layer *layer);
gboolean layer_linked (Layer *layer);
TempBuf * layer_preview (Layer *layer,
gint width,
gint height);
TempBuf * layer_mask_preview (Layer *layer,
gint width,
gint height);
void layer_invalidate_previews (GimpImage *gimage);
Tattoo layer_get_tattoo (const Layer *layer);
void layer_set_tattoo (Layer *layer,
Tattoo value);
#define gimp_drawable_layer GIMP_IS_LAYER
#define gimp_drawable_layer_mask GIMP_IS_LAYER_MASK
void channel_layer_alpha (Channel *mask,
Layer *layer);
/* from channel.c */
void channel_layer_mask (Channel *mask,
Layer *layer);
#endif /* __LAYER_H__ */
#endif /* __GIMP_LAYER_H__ */

213
app/core/gimplayermask.c Normal file
View File

@ -0,0 +1,213 @@
/* 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 <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "apptypes.h"
#include "boundary.h"
#include "drawable.h"
#include "floating_sel.h"
#include "gdisplay.h"
#include "gimage_mask.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimppreviewcache.h"
#include "layer.h"
#include "parasitelist.h"
#include "paint_funcs.h"
#include "pixel_region.h"
#include "undo.h"
#include "temp_buf.h"
#include "tile_manager.h"
#include "tile.h"
#include "libgimp/gimpparasite.h"
#include "libgimp/gimpintl.h"
static void gimp_layer_mask_class_init (GimpLayerMaskClass *klass);
static void gimp_layer_mask_init (GimpLayerMask *layermask);
static void gimp_layer_mask_destroy (GtkObject *object);
static GimpChannelClass *parent_class = NULL;
GtkType
gimp_layer_mask_get_type (void)
{
static GtkType layer_mask_type = 0;
if (! layer_mask_type)
{
GtkTypeInfo layer_mask_info =
{
"GimpLayerMask",
sizeof (GimpLayerMask),
sizeof (GimpLayerMaskClass),
(GtkClassInitFunc) gimp_layer_mask_class_init,
(GtkObjectInitFunc) gimp_layer_mask_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
layer_mask_type = gtk_type_unique (GIMP_TYPE_CHANNEL, &layer_mask_info);
}
return layer_mask_type;
}
static void
gimp_layer_mask_class_init (GimpLayerMaskClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_CHANNEL);
/*
gtk_object_class_add_signals (object_class, layer_mask_signals, LAST_SIGNAL);
*/
object_class->destroy = gimp_layer_mask_destroy;
}
static void
gimp_layer_mask_init (GimpLayerMask *layer_mask)
{
layer_mask->layer = NULL;
}
static void
gimp_layer_mask_destroy (GtkObject *object)
{
GimpLayerMask *layer_mask;
g_return_if_fail (object != NULL);
g_return_if_fail (GIMP_IS_LAYER_MASK (object));
layer_mask = GIMP_LAYER_MASK (object);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
GimpLayerMask *
gimp_layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color)
{
GimpLayerMask *layer_mask;
layer_mask = gtk_type_new (GIMP_TYPE_LAYER_MASK);
gimp_drawable_configure (GIMP_DRAWABLE (layer_mask),
gimage, width, height, GRAY_GIMAGE, name);
/* set the layer_mask color and opacity */
GIMP_CHANNEL (layer_mask)->color = *color;
GIMP_CHANNEL (layer_mask)->show_masked = TRUE;
/* selection mask variables */
GIMP_CHANNEL (layer_mask)->empty = TRUE;
GIMP_CHANNEL (layer_mask)->segs_in = NULL;
GIMP_CHANNEL (layer_mask)->segs_out = NULL;
GIMP_CHANNEL (layer_mask)->num_segs_in = 0;
GIMP_CHANNEL (layer_mask)->num_segs_out = 0;
GIMP_CHANNEL (layer_mask)->bounds_known = TRUE;
GIMP_CHANNEL (layer_mask)->boundary_known = TRUE;
GIMP_CHANNEL (layer_mask)->x1 = 0;
GIMP_CHANNEL (layer_mask)->y1 = 0;
GIMP_CHANNEL (layer_mask)->x2 = width;
GIMP_CHANNEL (layer_mask)->y2 = height;
return layer_mask;
}
GimpLayerMask *
gimp_layer_mask_copy (GimpLayerMask *layer_mask)
{
gchar *layer_mask_name;
GimpLayerMask *new_layer_mask;
PixelRegion srcPR, destPR;
/* formulate the new layer_mask name */
layer_mask_name =
g_strdup_printf (_("%s copy"),
gimp_object_get_name (GIMP_OBJECT (layer_mask)));
/* allocate a new layer_mask object */
new_layer_mask = gimp_layer_mask_new (GIMP_DRAWABLE (layer_mask)->gimage,
GIMP_DRAWABLE (layer_mask)->width,
GIMP_DRAWABLE (layer_mask)->height,
layer_mask_name,
&GIMP_CHANNEL (layer_mask)->color);
GIMP_DRAWABLE(new_layer_mask)->visible =
GIMP_DRAWABLE(layer_mask)->visible;
GIMP_DRAWABLE(new_layer_mask)->offset_x =
GIMP_DRAWABLE(layer_mask)->offset_x;
GIMP_DRAWABLE(new_layer_mask)->offset_y =
GIMP_DRAWABLE(layer_mask)->offset_y;
GIMP_CHANNEL(new_layer_mask)->show_masked =
GIMP_CHANNEL(layer_mask)->show_masked;
/* copy the contents across layer masks */
pixel_region_init (&srcPR, GIMP_DRAWABLE (layer_mask)->tiles,
0, 0,
GIMP_DRAWABLE (layer_mask)->width,
GIMP_DRAWABLE (layer_mask)->height,
FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (new_layer_mask)->tiles,
0, 0,
GIMP_DRAWABLE (layer_mask)->width,
GIMP_DRAWABLE (layer_mask)->height,
TRUE);
copy_region (&srcPR, &destPR);
/* free up the layer_mask_name memory */
g_free (layer_mask_name);
return new_layer_mask;
}
void
gimp_layer_mask_set_layer (GimpLayerMask *mask,
GimpLayer *layer)
{
mask->layer = layer;
}
GimpLayer *
gimp_layer_mask_get_layer (GimpLayerMask *mask)
{
return mask->layer;
}

81
app/core/gimplayermask.h Normal file
View File

@ -0,0 +1,81 @@
/* 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_LAYER_MASK_H__
#define __GIMP_LAYER_MASK_H__
#include "channel.h"
#define gimp_drawable_layer_mask GIMP_IS_LAYER_MASK
#define GIMP_TYPE_LAYER_MASK (gimp_layer_mask_get_type ())
#define GIMP_LAYER_MASK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
typedef struct _GimpLayerMaskClass GimpLayerMaskClass;
struct _GimpLayerMask
{
GimpChannel parent_instance;
GimpLayer *layer;
};
struct _GimpLayerMaskClass
{
GimpChannelClass parent_class;
};
/* Special undo type */
struct _LayerMaskUndo
{
GimpLayer *layer; /* the layer */
gboolean apply_mask; /* apply mask? */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show the mask? */
GimpLayerMask *mask; /* the layer mask */
gint mode; /* the application mode */
};
/* function declarations */
GtkType gimp_layer_mask_get_type (void);
GimpLayerMask * gimp_layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color);
GimpLayerMask * gimp_layer_mask_copy (GimpLayerMask *layer_mask);
void gimp_layer_mask_set_layer (GimpLayerMask *layer_mask,
GimpLayer *layer);
Layer * gimp_layer_mask_get_layer (GimpLayerMask *layer_mask);
#endif /* __GIMP_LAYER_MASK_H__ */

49
app/core/gimpprojection-construct.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/core/gimpprojection-construct.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

4
app/dialogs/preferences-dialog.c
View File

@ -908,7 +908,7 @@ prefs_cancel_callback (GtkWidget *widget,
transparency_size = old_transparency_size;
render_setup (transparency_type, transparency_size);
gimage_foreach ((GFunc) layer_invalidate_previews, NULL);
gimage_foreach ((GFunc) gimp_image_invalidate_layer_previews, NULL);
gimage_invalidate_previews ();
gdisplays_expose_full ();
gdisplays_flush ();
@ -995,7 +995,7 @@ prefs_toggle_callback (GtkWidget *widget,
*val = (gint) gtk_object_get_user_data (GTK_OBJECT (widget));
render_setup (transparency_type, transparency_size);
gimage_foreach ((GFunc) layer_invalidate_previews, NULL);
gimage_foreach ((GFunc) gimp_image_invalidate_layer_previews, NULL);
gimage_invalidate_previews ();
gdisplays_expose_full ();
gdisplays_flush ();

24
app/disp_callbacks.c
View File

@ -751,21 +751,21 @@ gdisplay_drag_drop (GtkWidget *widget,
if (!gimp_busy && (src_widget = gtk_drag_get_source_widget (context)))
{
GimpDrawable *drawable = NULL;
Layer *layer = NULL;
Channel *channel = NULL;
LayerMask *layer_mask = NULL;
GImage *component = NULL;
ChannelType component_type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
Channel *channel = NULL;
GimpLayerMask *layer_mask = NULL;
GimpImage *component = NULL;
ChannelType component_type = -1;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer = (GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_channel");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
layer_mask = (GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GimpImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
if (layer)
{

24
app/display/gimpdisplay-callbacks.c
View File

@ -751,21 +751,21 @@ gdisplay_drag_drop (GtkWidget *widget,
if (!gimp_busy && (src_widget = gtk_drag_get_source_widget (context)))
{
GimpDrawable *drawable = NULL;
Layer *layer = NULL;
Channel *channel = NULL;
LayerMask *layer_mask = NULL;
GImage *component = NULL;
ChannelType component_type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
Channel *channel = NULL;
GimpLayerMask *layer_mask = NULL;
GimpImage *component = NULL;
ChannelType component_type = -1;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer = (GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_channel");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
layer_mask = (GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GimpImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
if (layer)
{

24
app/display/gimpdisplayshell-callbacks.c
View File

@ -751,21 +751,21 @@ gdisplay_drag_drop (GtkWidget *widget,
if (!gimp_busy && (src_widget = gtk_drag_get_source_widget (context)))
{
GimpDrawable *drawable = NULL;
Layer *layer = NULL;
Channel *channel = NULL;
LayerMask *layer_mask = NULL;
GImage *component = NULL;
ChannelType component_type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
Channel *channel = NULL;
GimpLayerMask *layer_mask = NULL;
GimpImage *component = NULL;
ChannelType component_type = -1;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer = (GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_channel");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
layer_mask = (GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GimpImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
if (layer)
{

4
app/fileops.c
View File

@ -888,8 +888,8 @@ file_open_image (const gchar *filename,
if (gimage)
{
layer_invalidate_previews (gimage);
channel_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
}
return pdb_id_to_image (gimage_id);

1
app/floating_sel.c
View File

@ -32,6 +32,7 @@
#include "gdisplay.h"
#include "gimage_mask.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "paint_funcs.h"
#include "pixel_region.h"
#include "tile_manager.h"

20
app/gimage.c
View File

@ -56,7 +56,7 @@ static void gimage_repaint_handler (GimpImage* gimage,
gint, gint, gint, gint);
GImage *
GimpImage *
gimage_new (gint width,
gint height,
GimpImageBaseType base_type)
@ -91,7 +91,7 @@ gimage_new (gint width,
}
/* Ack, GImages have their own ref counts! This is going to cause
/* Ack, GimpImages have their own ref counts! This is going to cause
trouble.. It should be pretty easy to convert to proper GtkObject
ref counting, though. */
@ -101,7 +101,7 @@ gimage_new (gint width,
(Sven, 23.01.2000) */
void
gimage_delete (GImage *gimage)
gimage_delete (GimpImage *gimage)
{
if (gimage->disp_count <= 0)
gtk_object_unref (GTK_OBJECT (gimage));
@ -208,8 +208,8 @@ gimage_resize_handler (GimpImage *gimage)
undo_push_group_end (gimage);
/* shrink wrap and update all views */
channel_invalidate_previews (gimage);
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_resize_cursor_label (gimage);
gdisplays_update_full (gimage);
@ -236,7 +236,7 @@ gimage_repaint_handler (GimpImage *gimage,
/* These really belong in the layer class */
void
gimage_set_layer_mask_apply (GImage *gimage,
gimage_set_layer_mask_apply (GimpImage *gimage,
GimpLayer *layer)
{
int off_x, off_y;
@ -255,9 +255,9 @@ gimage_set_layer_mask_apply (GImage *gimage,
}
void
gimage_set_layer_mask_edit (GImage *gimage,
Layer *layer,
gboolean edit)
gimage_set_layer_mask_edit (GimpImage *gimage,
Layer *layer,
gboolean edit)
{
/* find the layer */
if (!layer)
@ -268,7 +268,7 @@ gimage_set_layer_mask_edit (GImage *gimage,
}
void
gimage_set_layer_mask_show (GImage *gimage,
gimage_set_layer_mask_show (GimpImage *gimage,
GimpLayer *layer)
{
gint off_x, off_y;

4
app/gimage_mask.c
View File

@ -24,10 +24,12 @@
#include "appenv.h"
#include "boundary.h"
#include "channel.h"
#include "drawable.h"
#include "floating_sel.h"
#include "gdisplay.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimage_mask.h"
#include "gimprc.h"
#include "layer.h"
@ -331,7 +333,7 @@ gimage_mask_extract (GImage *gimage,
else if (cut_gimage && GIMP_IS_LAYER_MASK (drawable))
{
gimp_image_remove_layer_mask (gimage,
layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
DISCARD);
}
else if (cut_gimage && GIMP_IS_CHANNEL (drawable))

83
app/gimpchannel.c
View File

@ -546,24 +546,6 @@ channel_preview_private (Channel *channel,
}
}
void
channel_invalidate_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
tmp = gimage->channels;
while (tmp)
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
tmp = g_slist_next (tmp);
}
}
Tattoo
channel_get_tattoo (const Channel *channel)
{
@ -1674,8 +1656,31 @@ channel_translate (Channel *mask,
}
void
channel_layer_alpha (Channel *mask,
Layer *layer)
channel_load (Channel *mask,
Channel *channel)
{
PixelRegion srcPR, destPR;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;
}
void
channel_layer_alpha (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
@ -1710,23 +1715,39 @@ channel_layer_alpha (Channel *mask,
}
void
channel_load (Channel *mask,
Channel *channel)
channel_layer_mask (Channel *mask,
GimpLayer *layer)
{
PixelRegion srcPR, destPR;
guchar empty = 0;
gint x1, y1, x2, y2;
/* push the current mask onto the undo stack */
channel_push_undo (mask);
/* copy the channel to the mask */
pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
0, 0,
GIMP_DRAWABLE (channel)->width,
GIMP_DRAWABLE (channel)->height, TRUE);
/* clear the mask */
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
0, 0,
GIMP_DRAWABLE(mask)->width, GIMP_DRAWABLE(mask)->height,
TRUE);
color_region (&destPR, &empty);
x1 = CLAMP (GIMP_DRAWABLE(layer)->offset_x, 0, GIMP_DRAWABLE(mask)->width);
y1 = CLAMP (GIMP_DRAWABLE(layer)->offset_y, 0, GIMP_DRAWABLE(mask)->height);
x2 = CLAMP (GIMP_DRAWABLE(layer)->offset_x + GIMP_DRAWABLE(layer)->width,
0, GIMP_DRAWABLE(mask)->width);
y2 = CLAMP (GIMP_DRAWABLE(layer)->offset_y + GIMP_DRAWABLE(layer)->height,
0, GIMP_DRAWABLE(mask)->height);
pixel_region_init (&srcPR, GIMP_DRAWABLE(layer->mask)->tiles,
(x1 - GIMP_DRAWABLE(layer)->offset_x),
(y1 - GIMP_DRAWABLE(layer)->offset_y),
(x2 - x1), (y2 - y1),
FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE(mask)->tiles,
x1, y1,
(x2 - x1), (y2 - y1),
TRUE);
copy_region (&srcPR, &destPR);
mask->bounds_known = FALSE;

7
app/gimpchannel.h
View File

@ -127,8 +127,6 @@ TempBuf * channel_preview (Channel *channel,
gint width,
gint height);
void channel_invalidate_previews (GimpImage *gimage);
Tattoo channel_get_tattoo (const Channel *channel);
void channel_set_tattoo (Channel *channel,
Tattoo value);
@ -215,6 +213,11 @@ void channel_translate (Channel *mask,
void channel_load (Channel *mask,
Channel *channel);
void channel_layer_alpha (Channel *mask,
GimpLayer *layer);
void channel_layer_mask (Channel *mask,
GimpLayer *layer);
void channel_invalidate_bounds (Channel *channel);

6
app/gimpdnd.c
View File

@ -35,6 +35,7 @@
#include "gimpcontextpreview.h"
#include "gimpdnd.h"
#include "gimpbrushlist.h"
#include "gimplayermask.h"
#include "gimprc.h"
#include "gradient.h"
#include "gradient_header.h"
@ -1090,8 +1091,9 @@ gimp_dnd_set_drawable_preview_icon (GtkWidget *widget,
else if (GIMP_IS_LAYER_MASK (drawable))
{
tmpbuf =
layer_mask_preview (layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
width, height);
gimp_layer_mask_preview
(gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
width, height);
}
else if (GIMP_IS_CHANNEL (drawable))
{

1
app/gimpdrawable-offset.c
View File

@ -29,6 +29,7 @@
#include "apptypes.h"
#include "apptypes.h"
#include "channel.h"
#include "channel_ops.h"
#include "cursorutil.h"
#include "drawable.h"

2
app/gimpimage-convert.c
View File

@ -1457,7 +1457,7 @@ convert_image (GImage *gimage,
undo_push_group_end (gimage);
/* shrink wrap and update all views */
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_title (gimage);
gdisplays_update_full (gimage);

1
app/gimpimage-duplicate.c
View File

@ -29,6 +29,7 @@
#include "apptypes.h"
#include "apptypes.h"
#include "channel.h"
#include "channel_ops.h"
#include "cursorutil.h"
#include "drawable.h"

49
app/gimpimage.c
View File

@ -35,6 +35,7 @@
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimpmarshal.h"
#include "gimprc.h"
#include "gimpparasite.h"
@ -2099,6 +2100,40 @@ gimp_image_validate (TileManager *tm,
gimp_image_construct (gimage, x, y, w, h);
}
void
gimp_image_invalidate_layer_previews (GimpImage *gimage)
{
GSList *tmp;
GimpLayer *layer;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->layers; tmp; tmp = g_slist_next (tmp))
{
layer = (Layer *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (layer), TRUE);
}
}
void
gimp_image_invalidate_channel_previews (GimpImage *gimage)
{
GSList *tmp;
Channel *channel;
g_return_if_fail (gimage != NULL);
g_return_if_fail (GIMP_IS_IMAGE (gimage));
for (tmp = gimage->channels; tmp; tmp = g_slist_next (tmp))
{
channel = (Channel *) tmp->data;
gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
}
}
gint
gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg)
@ -3222,10 +3257,10 @@ gimp_image_remove_layer (GimpImage *gimage,
return NULL;
}
LayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask)
GimpLayerMask *
gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask)
{
LayerMaskUndo *lmu;
@ -3258,7 +3293,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
return NULL;
}
layer_add_mask (layer, mask);
gimp_layer_add_mask (layer, mask);
/* Prepare a layer undo and push it */
lmu = g_new (LayerMaskUndo, 1);
@ -3274,7 +3309,7 @@ gimp_image_add_layer_mask (GimpImage *gimage,
Channel *
gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
GimpLayer *layer,
MaskApplyMode mode)
{
LayerMaskUndo *lmu;
@ -3964,7 +3999,7 @@ gimp_image_construct_composite_preview (GimpImage *gimage,
if (layer->mask && layer->apply_mask)
{
mask_buf = layer_mask_preview (layer, w, h);
mask_buf = gimp_layer_mask_preview (layer, w, h);
maskPR.bytes = mask_buf->bytes;
maskPR.rowstride = mask_buf->width;
maskPR.data = mask_buf_data (mask_buf) +

215
app/gimpimage.h
View File

@ -282,113 +282,118 @@ void gimp_image_colormap_changed (const GimpImage *image,
/* layer/channel functions */
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
LayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
Layer *layer,
LayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
gint gimp_image_get_layer_index (const GimpImage *gimage,
const Layer *layer_arg);
Layer * gimp_image_get_layer_by_index (const GimpImage *gimage,
gint layer_index);
gint gimp_image_get_channel_index (const GimpImage *gimage,
const Channel *channel_arg);
Layer * gimp_image_get_active_layer (const GimpImage *gimage);
Channel * gimp_image_get_active_channel (const GimpImage *gimage);
Layer * gimp_image_get_layer_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_tattoo (const GimpImage *gimage,
Tattoo tatoo);
Channel * gimp_image_get_channel_by_name (const GimpImage *gimage,
const gchar *name);
Channel * gimp_image_get_mask (const GimpImage *gimage);
gboolean gimp_image_get_component_active (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_get_component_visible (const GimpImage *gimage,
ChannelType type);
gboolean gimp_image_layer_boundary (const GimpImage *gimage,
BoundSeg **segs,
gint *n_segs);
Layer * gimp_image_set_active_layer (GimpImage *gimage,
Layer *layer);
Channel * gimp_image_set_active_channel (GimpImage *gimage,
Channel *channel);
Channel * gimp_image_unset_active_channel (GimpImage *gimage);
void gimp_image_set_component_active (GimpImage *gimage,
ChannelType type,
gboolean active);
void gimp_image_set_component_visible (GimpImage *gimage,
ChannelType type,
gboolean visible);
Layer * gimp_image_pick_correlate_layer (const GimpImage *gimage,
gint x,
gint y);
Layer * gimp_image_raise_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_raise_layer_to_top (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_lower_layer_to_bottom (GimpImage *gimage,
Layer *layer_arg);
Layer * gimp_image_position_layer (GimpImage *gimage,
Layer *layer_arg,
gint new_index,
gboolean push_undo);
Layer * gimp_image_merge_visible_layers (GimpImage *gimage,
MergeType merge_type);
Layer * gimp_image_merge_down (GimpImage *gimage,
Layer *current_layer,
MergeType merge_type);
Layer * gimp_image_flatten (GimpImage *gimage);
Layer * gimp_image_merge_layers (GimpImage *gimage,
GSList *merge_list,
MergeType merge_type);
Layer * gimp_image_add_layer (GimpImage *gimage,
Layer *float_layer,
gint position);
Layer * gimp_image_remove_layer (GimpImage *gimage,
Layer *layer);
GimpLayerMask * gimp_image_add_layer_mask (GimpImage *gimage,
GimpLayer *layer,
GimpLayerMask *mask);
Channel * gimp_image_remove_layer_mask (GimpImage *gimage,
Layer *layer,
MaskApplyMode mode);
Channel * gimp_image_raise_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_lower_channel (GimpImage *gimage,
Channel *channel_arg);
Channel * gimp_image_position_channel (GimpImage *gimage,
Channel *channel_arg,
gint position);
Channel * gimp_image_add_channel (GimpImage *gimage,
Channel *channel,
gint position);
Channel * gimp_image_remove_channel (GimpImage *gimage,
Channel *channel);
void gimp_image_construct (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
void gimp_image_invalidate_layer_previews (GimpImage *gimage);
void gimp_image_invalidate_channel_previews (GimpImage *gimage);
void gimp_image_invalidate_without_render (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_invalidate (GimpImage *gimage,
gint x,
gint y,
gint w,
gint h,
gint x1,
gint y1,
gint x2,
gint y2);
void gimp_image_validate (TileManager *tm,
Tile *tile);
/* Access functions */

901
app/gimplayer.c
View File

File diff suppressed because it is too large Load Diff

254
app/gimplayer.h
View File

@ -16,29 +16,55 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __LAYER_H__
#define __LAYER_H__
#ifndef __GIMP_LAYER_H__
#define __GIMP_LAYER_H__
#include "channel.h"
#include "gimpdrawable.h"
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
/* EEK */
#define GIMP_TYPE_LAYER_MASK (gimp_layer_mask_get_type ())
#define GIMP_LAYER_MASK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
#define layer_new gimp_layer_new
#define layer_copy gimp_layer_copy
#define layer_create_mask gimp_layer_create_mask
#define layer_scale gimp_layer_scale
#define layer_resize gimp_layer_resize
#define layer_delete gimp_layer_delete
#define layer_translate gimp_layer_translate
#define layer_get_name gimp_layer_get_name
#define layer_set_name gimp_layer_set_name
#define layer_get_tattoo gimp_layer_get_tattoo
#define layer_set_tattoo gimp_layer_set_tattoo
#define layer_add_alpha gimp_layer_add_alpha
#define layer_has_alpha gimp_layer_has_alpha
#define layer_preview gimp_layer_preview
#define layer_is_floating_sel gimp_layer_is_floating_sel
#define layer_invalidate_previews gimp_layer_invalidate_previews
#define layer_linked gimp_layer_linked
#define layer_get_mask gimp_layer_get_mask
#define layer_new_from_tiles gimp_layer_new_from_tiles
#define layer_resize_to_image gimp_layer_resize_to_image
#define layer_invalidate_boundary gimp_layer_invalidate_boundary
#define layer_scale_by_factors gimp_layer_scale_by_factors
#define layer_boundary gimp_layer_boundary
#define layer_pick_correlate gimp_layer_pick_correlate
#define layer_apply_mask gimp_layer_apply_mask
#define layer_add_mask gimp_layer_add_mask
#define layer_check_scaling gimp_layer_check_scaling
#define gimp_drawable_layer GIMP_IS_LAYER
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
typedef struct _GimpLayerClass GimpLayerClass;
typedef struct _GimpLayerMaskClass GimpLayerMaskClass;
struct _GimpLayer
{
@ -47,7 +73,7 @@ struct _GimpLayer
gboolean linked; /* control linkage */
gboolean preserve_trans; /* preserve transparency */
LayerMask *mask; /* possible layer mask */
GimpLayerMask *mask; /* possible layer mask */
gint apply_mask; /* controls mask application */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show mask or layer? */
@ -73,142 +99,94 @@ struct _GimpLayerClass
GimpDrawableClass parent_class;
};
struct _GimpLayerMask
{
GimpChannel parent_instance;
Layer *layer;
};
struct _GimpLayerMaskClass
{
GimpChannelClass parent_class;
};
/* Special undo types */
struct _layer_undo
struct _LayerUndo
{
Layer *layer; /* the actual layer */
gint prev_position; /* former position in list */
Layer *prev_layer; /* previous active layer */
GimpLayer *layer; /* the actual layer */
gint prev_position; /* former position in list */
GimpLayer *prev_layer; /* previous active layer */
};
struct _layer_mask_undo
struct _FStoLayerUndo
{
Layer *layer; /* the layer */
gboolean apply_mask; /* apply mask? */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show the mask? */
LayerMask *mask; /* the layer mask */
gint mode; /* the application mode */
};
struct _fs_to_layer_undo
{
Layer *layer; /* the layer */
GimpLayer *layer; /* the layer */
GimpDrawable *drawable; /* drawable of floating sel */
};
/* function declarations */
GtkType gimp_layer_get_type (void);
GtkType gimp_layer_get_type (void);
Layer * layer_new (GimpImage *gimage,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gint opacity,
LayerModeEffects mode);
Layer * layer_copy (Layer *layer,
gboolean add_alpha);
GimpLayer * gimp_layer_new (GimpImage *gimage,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gint opacity,
LayerModeEffects mode);
GimpLayer * gimp_layer_copy (GimpLayer *layer,
gboolean add_alpha);
Layer * layer_new_from_tiles (GimpImage *gimage,
GimpImageType layer_type,
TileManager *tiles,
gchar *name,
gint opacity,
LayerModeEffects mode);
gboolean layer_check_scaling (Layer *layer,
gint new_width,
gint new_height);
LayerMask * layer_create_mask (Layer *layer,
AddMaskType add_mask_type);
LayerMask * layer_add_mask (Layer *layer,
LayerMask *mask);
void layer_delete (Layer *layer);
void layer_apply_mask (Layer *layer,
MaskApplyMode mode);
void layer_translate (Layer *layer,
gint off_x,
gint off_y);
void layer_add_alpha (Layer *layer);
gboolean layer_scale_by_factors (Layer *layer,
gdouble w_factor,
gdouble h_factor);
void layer_scale (Layer *layer,
gint new_width,
gint new_height,
gboolean local_origin);
void layer_resize (Layer *layer,
gint new_width,
gint new_height,
gint offx,
gint offy);
void layer_resize_to_image (Layer *layer);
BoundSeg * layer_boundary (Layer *layer,
gint *num_segs);
void layer_invalidate_boundary (Layer *layer);
gint layer_pick_correlate (Layer *layer,
gint x,
gint y);
GimpLayer * gimp_layer_new_from_tiles (GimpImage *gimage,
GimpImageType layer_type,
TileManager *tiles,
gchar *name,
gint opacity,
LayerModeEffects mode);
gboolean gimp_layer_check_scaling (GimpLayer *layer,
gint new_width,
gint new_height);
GimpLayerMask * gimp_layer_create_mask (GimpLayer *layer,
AddMaskType add_mask_type);
GimpLayerMask * gimp_layer_add_mask (GimpLayer *layer,
GimpLayerMask *mask);
void gimp_layer_delete (GimpLayer *layer);
void gimp_layer_apply_mask (GimpLayer *layer,
MaskApplyMode mode);
void gimp_layer_translate (GimpLayer *layer,
gint off_x,
gint off_y);
void gimp_layer_add_alpha (GimpLayer *layer);
gboolean gimp_layer_scale_by_factors (GimpLayer *layer,
gdouble w_factor,
gdouble h_factor);
void gimp_layer_scale (GimpLayer *layer,
gint new_width,
gint new_height,
gboolean local_origin);
void gimp_layer_resize (GimpLayer *layer,
gint new_width,
gint new_height,
gint offx,
gint offy);
void gimp_layer_resize_to_image (GimpLayer *layer);
BoundSeg * gimp_layer_boundary (GimpLayer *layer,
gint *num_segs);
void gimp_layer_invalidate_boundary (GimpLayer *layer);
gint gimp_layer_pick_correlate (GimpLayer *layer,
gint x,
gint y);
void gimp_layer_set_name (GimpLayer *layer,
const gchar *name);
const gchar * gimp_layer_get_name (const GimpLayer *layer);
GimpLayerMask * gimp_layer_get_mask (GimpLayer *layer);
gboolean gimp_layer_has_alpha (GimpLayer *layer);
gboolean gimp_layer_is_floating_sel (GimpLayer *layer);
gboolean gimp_layer_linked (GimpLayer *layer);
Tattoo gimp_layer_get_tattoo (const GimpLayer *layer);
void gimp_layer_set_tattoo (GimpLayer *layer,
Tattoo value);
TempBuf * gimp_layer_preview (GimpLayer *layer,
gint width,
gint height);
TempBuf * gimp_layer_mask_preview (GimpLayer *layer,
gint width,
gint height);
GtkType gimp_layer_mask_get_type (void);
LayerMask * layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color);
LayerMask * layer_mask_copy (LayerMask *layer_mask);
void layer_mask_delete (LayerMask *layer_mask);
LayerMask * layer_mask_ref (LayerMask *layer_mask);
void layer_mask_unref (LayerMask *layer_mask);
void layer_mask_set_layer (LayerMask *layer_mask,
Layer *layer);
Layer * layer_mask_get_layer (LayerMask *layer_mask);
/* access functions */
void layer_set_name (Layer *layer,
const gchar *name);
const gchar * layer_get_name (const Layer *layer);
guchar * layer_data (Layer *layer);
LayerMask * layer_get_mask (Layer *layer);
gboolean layer_has_alpha (Layer *layer);
gboolean layer_is_floating_sel (Layer *layer);
gboolean layer_linked (Layer *layer);
TempBuf * layer_preview (Layer *layer,
gint width,
gint height);
TempBuf * layer_mask_preview (Layer *layer,
gint width,
gint height);
void layer_invalidate_previews (GimpImage *gimage);
Tattoo layer_get_tattoo (const Layer *layer);
void layer_set_tattoo (Layer *layer,
Tattoo value);
#define gimp_drawable_layer GIMP_IS_LAYER
#define gimp_drawable_layer_mask GIMP_IS_LAYER_MASK
void channel_layer_alpha (Channel *mask,
Layer *layer);
/* from channel.c */
void channel_layer_mask (Channel *mask,
Layer *layer);
#endif /* __LAYER_H__ */
#endif /* __GIMP_LAYER_H__ */

213
app/gimplayermask.c Normal file
View File

@ -0,0 +1,213 @@
/* 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 <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include "libgimpmath/gimpmath.h"
#include "apptypes.h"
#include "boundary.h"
#include "drawable.h"
#include "floating_sel.h"
#include "gdisplay.h"
#include "gimage_mask.h"
#include "gimpimage.h"
#include "gimplayermask.h"
#include "gimppreviewcache.h"
#include "layer.h"
#include "parasitelist.h"
#include "paint_funcs.h"
#include "pixel_region.h"
#include "undo.h"
#include "temp_buf.h"
#include "tile_manager.h"
#include "tile.h"
#include "libgimp/gimpparasite.h"
#include "libgimp/gimpintl.h"
static void gimp_layer_mask_class_init (GimpLayerMaskClass *klass);
static void gimp_layer_mask_init (GimpLayerMask *layermask);
static void gimp_layer_mask_destroy (GtkObject *object);
static GimpChannelClass *parent_class = NULL;
GtkType
gimp_layer_mask_get_type (void)
{
static GtkType layer_mask_type = 0;
if (! layer_mask_type)
{
GtkTypeInfo layer_mask_info =
{
"GimpLayerMask",
sizeof (GimpLayerMask),
sizeof (GimpLayerMaskClass),
(GtkClassInitFunc) gimp_layer_mask_class_init,
(GtkObjectInitFunc) gimp_layer_mask_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
layer_mask_type = gtk_type_unique (GIMP_TYPE_CHANNEL, &layer_mask_info);
}
return layer_mask_type;
}
static void
gimp_layer_mask_class_init (GimpLayerMaskClass *klass)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) klass;
parent_class = gtk_type_class (GIMP_TYPE_CHANNEL);
/*
gtk_object_class_add_signals (object_class, layer_mask_signals, LAST_SIGNAL);
*/
object_class->destroy = gimp_layer_mask_destroy;
}
static void
gimp_layer_mask_init (GimpLayerMask *layer_mask)
{
layer_mask->layer = NULL;
}
static void
gimp_layer_mask_destroy (GtkObject *object)
{
GimpLayerMask *layer_mask;
g_return_if_fail (object != NULL);
g_return_if_fail (GIMP_IS_LAYER_MASK (object));
layer_mask = GIMP_LAYER_MASK (object);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
GimpLayerMask *
gimp_layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color)
{
GimpLayerMask *layer_mask;
layer_mask = gtk_type_new (GIMP_TYPE_LAYER_MASK);
gimp_drawable_configure (GIMP_DRAWABLE (layer_mask),
gimage, width, height, GRAY_GIMAGE, name);
/* set the layer_mask color and opacity */
GIMP_CHANNEL (layer_mask)->color = *color;
GIMP_CHANNEL (layer_mask)->show_masked = TRUE;
/* selection mask variables */
GIMP_CHANNEL (layer_mask)->empty = TRUE;
GIMP_CHANNEL (layer_mask)->segs_in = NULL;
GIMP_CHANNEL (layer_mask)->segs_out = NULL;
GIMP_CHANNEL (layer_mask)->num_segs_in = 0;
GIMP_CHANNEL (layer_mask)->num_segs_out = 0;
GIMP_CHANNEL (layer_mask)->bounds_known = TRUE;
GIMP_CHANNEL (layer_mask)->boundary_known = TRUE;
GIMP_CHANNEL (layer_mask)->x1 = 0;
GIMP_CHANNEL (layer_mask)->y1 = 0;
GIMP_CHANNEL (layer_mask)->x2 = width;
GIMP_CHANNEL (layer_mask)->y2 = height;
return layer_mask;
}
GimpLayerMask *
gimp_layer_mask_copy (GimpLayerMask *layer_mask)
{
gchar *layer_mask_name;
GimpLayerMask *new_layer_mask;
PixelRegion srcPR, destPR;
/* formulate the new layer_mask name */
layer_mask_name =
g_strdup_printf (_("%s copy"),
gimp_object_get_name (GIMP_OBJECT (layer_mask)));
/* allocate a new layer_mask object */
new_layer_mask = gimp_layer_mask_new (GIMP_DRAWABLE (layer_mask)->gimage,
GIMP_DRAWABLE (layer_mask)->width,
GIMP_DRAWABLE (layer_mask)->height,
layer_mask_name,
&GIMP_CHANNEL (layer_mask)->color);
GIMP_DRAWABLE(new_layer_mask)->visible =
GIMP_DRAWABLE(layer_mask)->visible;
GIMP_DRAWABLE(new_layer_mask)->offset_x =
GIMP_DRAWABLE(layer_mask)->offset_x;
GIMP_DRAWABLE(new_layer_mask)->offset_y =
GIMP_DRAWABLE(layer_mask)->offset_y;
GIMP_CHANNEL(new_layer_mask)->show_masked =
GIMP_CHANNEL(layer_mask)->show_masked;
/* copy the contents across layer masks */
pixel_region_init (&srcPR, GIMP_DRAWABLE (layer_mask)->tiles,
0, 0,
GIMP_DRAWABLE (layer_mask)->width,
GIMP_DRAWABLE (layer_mask)->height,
FALSE);
pixel_region_init (&destPR, GIMP_DRAWABLE (new_layer_mask)->tiles,
0, 0,
GIMP_DRAWABLE (layer_mask)->width,
GIMP_DRAWABLE (layer_mask)->height,
TRUE);
copy_region (&srcPR, &destPR);
/* free up the layer_mask_name memory */
g_free (layer_mask_name);
return new_layer_mask;
}
void
gimp_layer_mask_set_layer (GimpLayerMask *mask,
GimpLayer *layer)
{
mask->layer = layer;
}
GimpLayer *
gimp_layer_mask_get_layer (GimpLayerMask *mask)
{
return mask->layer;
}

81
app/gimplayermask.h Normal file
View File

@ -0,0 +1,81 @@
/* 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_LAYER_MASK_H__
#define __GIMP_LAYER_MASK_H__
#include "channel.h"
#define gimp_drawable_layer_mask GIMP_IS_LAYER_MASK
#define GIMP_TYPE_LAYER_MASK (gimp_layer_mask_get_type ())
#define GIMP_LAYER_MASK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
typedef struct _GimpLayerMaskClass GimpLayerMaskClass;
struct _GimpLayerMask
{
GimpChannel parent_instance;
GimpLayer *layer;
};
struct _GimpLayerMaskClass
{
GimpChannelClass parent_class;
};
/* Special undo type */
struct _LayerMaskUndo
{
GimpLayer *layer; /* the layer */
gboolean apply_mask; /* apply mask? */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show the mask? */
GimpLayerMask *mask; /* the layer mask */
gint mode; /* the application mode */
};
/* function declarations */
GtkType gimp_layer_mask_get_type (void);
GimpLayerMask * gimp_layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color);
GimpLayerMask * gimp_layer_mask_copy (GimpLayerMask *layer_mask);
void gimp_layer_mask_set_layer (GimpLayerMask *layer_mask,
GimpLayer *layer);
Layer * gimp_layer_mask_get_layer (GimpLayerMask *layer_mask);
#endif /* __GIMP_LAYER_MASK_H__ */

1
app/global_edit.c
View File

@ -34,6 +34,7 @@
#include "gimage.h"
#include "gimage_mask.h"
#include "gimpcontext.h"
#include "gimplayermask.h"
#include "global_edit.h"
#include "layer.h"
#include "paint_funcs.h"

46
app/gui/layers-dialog.c
View File

@ -34,6 +34,7 @@
#include "gimage.h"
#include "gimage_mask.h"
#include "gimpdnd.h"
#include "gimplayermask.h"
#include "gimprc.h"
#include "image_render.h"
#include "layer.h"
@ -92,9 +93,9 @@ struct _LayersDialog
gint gimage_width, gimage_height;
gdouble ratio;
Layer *active_layer;
GimpLayer *active_layer;
Channel *active_channel;
Layer *floating_sel;
GimpLayer *floating_sel;
GSList *layer_widgets;
};
@ -116,7 +117,7 @@ struct _LayerWidget
/* state information */
GimpImage *gimage;
Layer *layer;
GimpLayer *layer;
gint width, height;
gint active_preview;
@ -1339,7 +1340,7 @@ layers_dialog_add_layer_mask (Layer *layer)
if (! GTK_WIDGET_VISIBLE (layer_widget->mask_preview))
{
gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
"gimp_layer_mask", layer_get_mask (layer));
"gimp_layer_mask", gimp_layer_get_mask (layer));
gtk_widget_show (layer_widget->mask_preview);
}
@ -2021,13 +2022,16 @@ layers_dialog_drag_trashcan_callback (GtkWidget *widget,
if ((src_widget = gtk_drag_get_source_widget (context)))
{
Layer *layer;
LayerMask *layer_mask;
GimpLayer *layer;
GimpLayerMask *layer_mask;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
layer =
(GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer_mask =
(GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
if (layer &&
layer == layersD->active_layer)
@ -2037,7 +2041,7 @@ layers_dialog_drag_trashcan_callback (GtkWidget *widget,
return_val = TRUE;
}
else if (layer_mask &&
layer_mask_get_layer (layer_mask) == layersD->active_layer)
gimp_layer_mask_get_layer (layer_mask) == layersD->active_layer)
{
layers_dialog_delete_layer_mask_callback (widget, NULL);
@ -2097,7 +2101,7 @@ layer_widget_create (GimpImage *gimage,
layer_widget->mask_pixmap = NULL;
layer_widget->width = -1;
layer_widget->height = -1;
layer_widget->layer_mask = (layer_get_mask (layer) != NULL);
layer_widget->layer_mask = (gimp_layer_get_mask (layer) != NULL);
layer_widget->apply_mask = layer->apply_mask;
layer_widget->edit_mask = layer->edit_mask;
layer_widget->show_mask = layer->show_mask;
@ -2196,7 +2200,7 @@ layer_widget_create (GimpImage *gimage,
if (layer_get_mask (layer) != NULL)
{
gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
"gimp_layer_mask", layer_get_mask (layer));
"gimp_layer_mask", gimp_layer_get_mask (layer));
gtk_widget_show (layer_widget->mask_preview);
}
@ -3031,17 +3035,17 @@ layer_widget_preview_redraw (LayerWidget *layer_widget,
switch (preview_type)
{
case LAYER_PREVIEW:
preview_buf = layer_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
preview_buf = gimp_layer_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
layer_widget->layer_pixmap_valid = TRUE;
break;
case MASK_PREVIEW:
preview_buf = layer_mask_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
preview_buf = gimp_layer_mask_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
break;
}
@ -3797,8 +3801,8 @@ add_mask_query_ok_callback (GtkWidget *widget,
{
AddMaskOptions *options;
GimpImage *gimage;
LayerMask *mask;
Layer *layer;
GimpLayerMask *mask;
GimpLayer *layer;
options = (AddMaskOptions *) data;
if ((layer = (options->layer)) &&

4
app/gui/preferences-dialog.c
View File

@ -908,7 +908,7 @@ prefs_cancel_callback (GtkWidget *widget,
transparency_size = old_transparency_size;
render_setup (transparency_type, transparency_size);
gimage_foreach ((GFunc) layer_invalidate_previews, NULL);
gimage_foreach ((GFunc) gimp_image_invalidate_layer_previews, NULL);
gimage_invalidate_previews ();
gdisplays_expose_full ();
gdisplays_flush ();
@ -995,7 +995,7 @@ prefs_toggle_callback (GtkWidget *widget,
*val = (gint) gtk_object_get_user_data (GTK_OBJECT (widget));
render_setup (transparency_type, transparency_size);
gimage_foreach ((GFunc) layer_invalidate_previews, NULL);
gimage_foreach ((GFunc) gimp_image_invalidate_layer_previews, NULL);
gimage_invalidate_previews ();
gdisplays_expose_full ();
gdisplays_flush ();

57
app/gui/toolbox.c
View File

@ -657,19 +657,19 @@ toolbox_drag_drop (GtkWidget *widget,
if ((src_widget = gtk_drag_get_source_widget (context)))
{
GimpDrawable *drawable = NULL;
Layer *layer = NULL;
Channel *channel = NULL;
LayerMask *layer_mask = NULL;
GImage *component = NULL;
ChannelType component_type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
Channel *channel = NULL;
GimpLayerMask *layer_mask = NULL;
GimpImage *component = NULL;
ChannelType component_type = -1;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer = (GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_channel");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
layer_mask = (GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
@ -694,12 +694,12 @@ toolbox_drag_drop (GtkWidget *widget,
if (drawable)
{
GImage *gimage;
GImage *new_gimage;
Layer *new_layer;
gint width, height;
gint off_x, off_y;
gint bytes;
GimpImage *gimage;
GimpImage *new_gimage;
GimpLayer *new_layer;
gint width, height;
gint off_x, off_y;
gint bytes;
GimpImageBaseType type;
@ -735,7 +735,7 @@ toolbox_drag_drop (GtkWidget *widget,
if (layer)
{
new_layer = layer_copy (layer, FALSE);
new_layer = gimp_layer_copy (layer, FALSE);
}
else
{
@ -754,26 +754,27 @@ toolbox_drag_drop (GtkWidget *widget,
add_alpha_region (&srcPR, &destPR);
new_layer = layer_new_from_tiles (new_gimage,
gimp_image_base_type_with_alpha(new_gimage),
tiles,
"", OPAQUE_OPACITY, NORMAL_MODE);
new_layer =
gimp_layer_new_from_tiles (new_gimage,
gimp_image_base_type_with_alpha (new_gimage),
tiles,
"", OPAQUE_OPACITY, NORMAL_MODE);
tile_manager_destroy (tiles);
}
gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage);
layer_set_name (GIMP_LAYER (new_layer),
gimp_object_get_name (GIMP_OBJECT (drawable)));
gimp_layer_set_name (GIMP_LAYER (new_layer),
gimp_object_get_name (GIMP_OBJECT (drawable)));
if (layer)
{
LayerMask *mask;
LayerMask *new_mask;
GimpLayerMask *mask;
GimpLayerMask *new_mask;
mask = layer_get_mask (layer);
new_mask = layer_get_mask (new_layer);
mask = gimp_layer_get_mask (layer);
new_mask = gimp_layer_get_mask (new_layer);
if (new_mask)
{
@ -783,7 +784,7 @@ toolbox_drag_drop (GtkWidget *widget,
}
gimp_drawable_offsets (GIMP_DRAWABLE (new_layer), &off_x, &off_y);
layer_translate (new_layer, -off_x, -off_y);
gimp_layer_translate (new_layer, -off_x, -off_y);
gimp_image_add_layer (new_gimage, new_layer, 0);

901
app/layer.c
View File

File diff suppressed because it is too large Load Diff

254
app/layer.h
View File

@ -16,29 +16,55 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __LAYER_H__
#define __LAYER_H__
#ifndef __GIMP_LAYER_H__
#define __GIMP_LAYER_H__
#include "channel.h"
#include "gimpdrawable.h"
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
/* EEK */
#define GIMP_TYPE_LAYER_MASK (gimp_layer_mask_get_type ())
#define GIMP_LAYER_MASK(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
#define GIMP_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
#define GIMP_IS_LAYER_MASK(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
#define GIMP_IS_LAYER_MASK_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
#define layer_new gimp_layer_new
#define layer_copy gimp_layer_copy
#define layer_create_mask gimp_layer_create_mask
#define layer_scale gimp_layer_scale
#define layer_resize gimp_layer_resize
#define layer_delete gimp_layer_delete
#define layer_translate gimp_layer_translate
#define layer_get_name gimp_layer_get_name
#define layer_set_name gimp_layer_set_name
#define layer_get_tattoo gimp_layer_get_tattoo
#define layer_set_tattoo gimp_layer_set_tattoo
#define layer_add_alpha gimp_layer_add_alpha
#define layer_has_alpha gimp_layer_has_alpha
#define layer_preview gimp_layer_preview
#define layer_is_floating_sel gimp_layer_is_floating_sel
#define layer_invalidate_previews gimp_layer_invalidate_previews
#define layer_linked gimp_layer_linked
#define layer_get_mask gimp_layer_get_mask
#define layer_new_from_tiles gimp_layer_new_from_tiles
#define layer_resize_to_image gimp_layer_resize_to_image
#define layer_invalidate_boundary gimp_layer_invalidate_boundary
#define layer_scale_by_factors gimp_layer_scale_by_factors
#define layer_boundary gimp_layer_boundary
#define layer_pick_correlate gimp_layer_pick_correlate
#define layer_apply_mask gimp_layer_apply_mask
#define layer_add_mask gimp_layer_add_mask
#define layer_check_scaling gimp_layer_check_scaling
#define gimp_drawable_layer GIMP_IS_LAYER
#define GIMP_TYPE_LAYER (gimp_layer_get_type ())
#define GIMP_LAYER(obj) (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
#define GIMP_LAYER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
#define GIMP_IS_LAYER(obj) (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
#define GIMP_IS_LAYER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
typedef struct _GimpLayerClass GimpLayerClass;
typedef struct _GimpLayerMaskClass GimpLayerMaskClass;
struct _GimpLayer
{
@ -47,7 +73,7 @@ struct _GimpLayer
gboolean linked; /* control linkage */
gboolean preserve_trans; /* preserve transparency */
LayerMask *mask; /* possible layer mask */
GimpLayerMask *mask; /* possible layer mask */
gint apply_mask; /* controls mask application */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show mask or layer? */
@ -73,142 +99,94 @@ struct _GimpLayerClass
GimpDrawableClass parent_class;
};
struct _GimpLayerMask
{
GimpChannel parent_instance;
Layer *layer;
};
struct _GimpLayerMaskClass
{
GimpChannelClass parent_class;
};
/* Special undo types */
struct _layer_undo
struct _LayerUndo
{
Layer *layer; /* the actual layer */
gint prev_position; /* former position in list */
Layer *prev_layer; /* previous active layer */
GimpLayer *layer; /* the actual layer */
gint prev_position; /* former position in list */
GimpLayer *prev_layer; /* previous active layer */
};
struct _layer_mask_undo
struct _FStoLayerUndo
{
Layer *layer; /* the layer */
gboolean apply_mask; /* apply mask? */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show the mask? */
LayerMask *mask; /* the layer mask */
gint mode; /* the application mode */
};
struct _fs_to_layer_undo
{
Layer *layer; /* the layer */
GimpLayer *layer; /* the layer */
GimpDrawable *drawable; /* drawable of floating sel */
};
/* function declarations */
GtkType gimp_layer_get_type (void);
GtkType gimp_layer_get_type (void);
Layer * layer_new (GimpImage *gimage,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gint opacity,
LayerModeEffects mode);
Layer * layer_copy (Layer *layer,
gboolean add_alpha);
GimpLayer * gimp_layer_new (GimpImage *gimage,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gint opacity,
LayerModeEffects mode);
GimpLayer * gimp_layer_copy (GimpLayer *layer,
gboolean add_alpha);
Layer * layer_new_from_tiles (GimpImage *gimage,
GimpImageType layer_type,
TileManager *tiles,
gchar *name,
gint opacity,
LayerModeEffects mode);
gboolean layer_check_scaling (Layer *layer,
gint new_width,
gint new_height);
LayerMask * layer_create_mask (Layer *layer,
AddMaskType add_mask_type);
LayerMask * layer_add_mask (Layer *layer,
LayerMask *mask);
void layer_delete (Layer *layer);
void layer_apply_mask (Layer *layer,
MaskApplyMode mode);
void layer_translate (Layer *layer,
gint off_x,
gint off_y);
void layer_add_alpha (Layer *layer);
gboolean layer_scale_by_factors (Layer *layer,
gdouble w_factor,
gdouble h_factor);
void layer_scale (Layer *layer,
gint new_width,
gint new_height,
gboolean local_origin);
void layer_resize (Layer *layer,
gint new_width,
gint new_height,
gint offx,
gint offy);
void layer_resize_to_image (Layer *layer);
BoundSeg * layer_boundary (Layer *layer,
gint *num_segs);
void layer_invalidate_boundary (Layer *layer);
gint layer_pick_correlate (Layer *layer,
gint x,
gint y);
GimpLayer * gimp_layer_new_from_tiles (GimpImage *gimage,
GimpImageType layer_type,
TileManager *tiles,
gchar *name,
gint opacity,
LayerModeEffects mode);
gboolean gimp_layer_check_scaling (GimpLayer *layer,
gint new_width,
gint new_height);
GimpLayerMask * gimp_layer_create_mask (GimpLayer *layer,
AddMaskType add_mask_type);
GimpLayerMask * gimp_layer_add_mask (GimpLayer *layer,
GimpLayerMask *mask);
void gimp_layer_delete (GimpLayer *layer);
void gimp_layer_apply_mask (GimpLayer *layer,
MaskApplyMode mode);
void gimp_layer_translate (GimpLayer *layer,
gint off_x,
gint off_y);
void gimp_layer_add_alpha (GimpLayer *layer);
gboolean gimp_layer_scale_by_factors (GimpLayer *layer,
gdouble w_factor,
gdouble h_factor);
void gimp_layer_scale (GimpLayer *layer,
gint new_width,
gint new_height,
gboolean local_origin);
void gimp_layer_resize (GimpLayer *layer,
gint new_width,
gint new_height,
gint offx,
gint offy);
void gimp_layer_resize_to_image (GimpLayer *layer);
BoundSeg * gimp_layer_boundary (GimpLayer *layer,
gint *num_segs);
void gimp_layer_invalidate_boundary (GimpLayer *layer);
gint gimp_layer_pick_correlate (GimpLayer *layer,
gint x,
gint y);
void gimp_layer_set_name (GimpLayer *layer,
const gchar *name);
const gchar * gimp_layer_get_name (const GimpLayer *layer);
GimpLayerMask * gimp_layer_get_mask (GimpLayer *layer);
gboolean gimp_layer_has_alpha (GimpLayer *layer);
gboolean gimp_layer_is_floating_sel (GimpLayer *layer);
gboolean gimp_layer_linked (GimpLayer *layer);
Tattoo gimp_layer_get_tattoo (const GimpLayer *layer);
void gimp_layer_set_tattoo (GimpLayer *layer,
Tattoo value);
TempBuf * gimp_layer_preview (GimpLayer *layer,
gint width,
gint height);
TempBuf * gimp_layer_mask_preview (GimpLayer *layer,
gint width,
gint height);
GtkType gimp_layer_mask_get_type (void);
LayerMask * layer_mask_new (GimpImage *gimage,
gint width,
gint height,
const gchar *name,
const GimpRGB *color);
LayerMask * layer_mask_copy (LayerMask *layer_mask);
void layer_mask_delete (LayerMask *layer_mask);
LayerMask * layer_mask_ref (LayerMask *layer_mask);
void layer_mask_unref (LayerMask *layer_mask);
void layer_mask_set_layer (LayerMask *layer_mask,
Layer *layer);
Layer * layer_mask_get_layer (LayerMask *layer_mask);
/* access functions */
void layer_set_name (Layer *layer,
const gchar *name);
const gchar * layer_get_name (const Layer *layer);
guchar * layer_data (Layer *layer);
LayerMask * layer_get_mask (Layer *layer);
gboolean layer_has_alpha (Layer *layer);
gboolean layer_is_floating_sel (Layer *layer);
gboolean layer_linked (Layer *layer);
TempBuf * layer_preview (Layer *layer,
gint width,
gint height);
TempBuf * layer_mask_preview (Layer *layer,
gint width,
gint height);
void layer_invalidate_previews (GimpImage *gimage);
Tattoo layer_get_tattoo (const Layer *layer);
void layer_set_tattoo (Layer *layer,
Tattoo value);
#define gimp_drawable_layer GIMP_IS_LAYER
#define gimp_drawable_layer_mask GIMP_IS_LAYER_MASK
void channel_layer_alpha (Channel *mask,
Layer *layer);
/* from channel.c */
void channel_layer_mask (Channel *mask,
Layer *layer);
#endif /* __LAYER_H__ */
#endif /* __GIMP_LAYER_H__ */

46
app/layers_dialog.c
View File

@ -34,6 +34,7 @@
#include "gimage.h"
#include "gimage_mask.h"
#include "gimpdnd.h"
#include "gimplayermask.h"
#include "gimprc.h"
#include "image_render.h"
#include "layer.h"
@ -92,9 +93,9 @@ struct _LayersDialog
gint gimage_width, gimage_height;
gdouble ratio;
Layer *active_layer;
GimpLayer *active_layer;
Channel *active_channel;
Layer *floating_sel;
GimpLayer *floating_sel;
GSList *layer_widgets;
};
@ -116,7 +117,7 @@ struct _LayerWidget
/* state information */
GimpImage *gimage;
Layer *layer;
GimpLayer *layer;
gint width, height;
gint active_preview;
@ -1339,7 +1340,7 @@ layers_dialog_add_layer_mask (Layer *layer)
if (! GTK_WIDGET_VISIBLE (layer_widget->mask_preview))
{
gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
"gimp_layer_mask", layer_get_mask (layer));
"gimp_layer_mask", gimp_layer_get_mask (layer));
gtk_widget_show (layer_widget->mask_preview);
}
@ -2021,13 +2022,16 @@ layers_dialog_drag_trashcan_callback (GtkWidget *widget,
if ((src_widget = gtk_drag_get_source_widget (context)))
{
Layer *layer;
LayerMask *layer_mask;
GimpLayer *layer;
GimpLayerMask *layer_mask;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
layer =
(GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer_mask =
(GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
if (layer &&
layer == layersD->active_layer)
@ -2037,7 +2041,7 @@ layers_dialog_drag_trashcan_callback (GtkWidget *widget,
return_val = TRUE;
}
else if (layer_mask &&
layer_mask_get_layer (layer_mask) == layersD->active_layer)
gimp_layer_mask_get_layer (layer_mask) == layersD->active_layer)
{
layers_dialog_delete_layer_mask_callback (widget, NULL);
@ -2097,7 +2101,7 @@ layer_widget_create (GimpImage *gimage,
layer_widget->mask_pixmap = NULL;
layer_widget->width = -1;
layer_widget->height = -1;
layer_widget->layer_mask = (layer_get_mask (layer) != NULL);
layer_widget->layer_mask = (gimp_layer_get_mask (layer) != NULL);
layer_widget->apply_mask = layer->apply_mask;
layer_widget->edit_mask = layer->edit_mask;
layer_widget->show_mask = layer->show_mask;
@ -2196,7 +2200,7 @@ layer_widget_create (GimpImage *gimage,
if (layer_get_mask (layer) != NULL)
{
gtk_object_set_data (GTK_OBJECT (layer_widget->mask_preview),
"gimp_layer_mask", layer_get_mask (layer));
"gimp_layer_mask", gimp_layer_get_mask (layer));
gtk_widget_show (layer_widget->mask_preview);
}
@ -3031,17 +3035,17 @@ layer_widget_preview_redraw (LayerWidget *layer_widget,
switch (preview_type)
{
case LAYER_PREVIEW:
preview_buf = layer_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
preview_buf = gimp_layer_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
layer_widget->layer_pixmap_valid = TRUE;
break;
case MASK_PREVIEW:
preview_buf = layer_mask_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
preview_buf = gimp_layer_mask_preview (layer_widget->layer,
layer_widget->width,
layer_widget->height);
break;
}
@ -3797,8 +3801,8 @@ add_mask_query_ok_callback (GtkWidget *widget,
{
AddMaskOptions *options;
GimpImage *gimage;
LayerMask *mask;
Layer *layer;
GimpLayerMask *mask;
GimpLayer *layer;
options = (AddMaskOptions *) data;
if ((layer = (options->layer)) &&

1
app/pdb/drawable_cmds.c
View File

@ -29,6 +29,7 @@
#include "channel.h"
#include "drawable.h"
#include "gimplayermask.h"
#include "layer.h"
#include "temp_buf.h"
#include "tile.h"

2
app/pdb/image_cmds.c
View File

@ -1338,7 +1338,7 @@ image_add_layer_mask_invoker (Argument *args)
gboolean success = TRUE;
GimpImage *gimage;
GimpLayer *layer;
LayerMask *mask;
GimpLayerMask *mask;
gimage = pdb_id_to_image (args[0].value.pdb_int);
if (gimage == NULL)

2
app/pdb/layer_cmds.c
View File

@ -293,7 +293,7 @@ layer_create_mask_invoker (Argument *args)
Argument *return_args;
GimpLayer *layer;
gint32 mask_type;
LayerMask *mask = NULL;
GimpLayerMask *mask = NULL;
layer = (GimpLayer *) gimp_drawable_get_by_ID (args[0].value.pdb_int);
if (layer == NULL)

4
app/preferences_dialog.c
View File

@ -908,7 +908,7 @@ prefs_cancel_callback (GtkWidget *widget,
transparency_size = old_transparency_size;
render_setup (transparency_type, transparency_size);
gimage_foreach ((GFunc) layer_invalidate_previews, NULL);
gimage_foreach ((GFunc) gimp_image_invalidate_layer_previews, NULL);
gimage_invalidate_previews ();
gdisplays_expose_full ();
gdisplays_flush ();
@ -995,7 +995,7 @@ prefs_toggle_callback (GtkWidget *widget,
*val = (gint) gtk_object_get_user_data (GTK_OBJECT (widget));
render_setup (transparency_type, transparency_size);
gimage_foreach ((GFunc) layer_invalidate_previews, NULL);
gimage_foreach ((GFunc) gimp_image_invalidate_layer_previews, NULL);
gimage_invalidate_previews ();
gdisplays_expose_full ();
gdisplays_flush ();

57
app/toolbox.c
View File

@ -657,19 +657,19 @@ toolbox_drag_drop (GtkWidget *widget,
if ((src_widget = gtk_drag_get_source_widget (context)))
{
GimpDrawable *drawable = NULL;
Layer *layer = NULL;
Channel *channel = NULL;
LayerMask *layer_mask = NULL;
GImage *component = NULL;
ChannelType component_type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
Channel *channel = NULL;
GimpLayerMask *layer_mask = NULL;
GimpImage *component = NULL;
ChannelType component_type = -1;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer = (GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_channel");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
layer_mask = (GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
@ -694,12 +694,12 @@ toolbox_drag_drop (GtkWidget *widget,
if (drawable)
{
GImage *gimage;
GImage *new_gimage;
Layer *new_layer;
gint width, height;
gint off_x, off_y;
gint bytes;
GimpImage *gimage;
GimpImage *new_gimage;
GimpLayer *new_layer;
gint width, height;
gint off_x, off_y;
gint bytes;
GimpImageBaseType type;
@ -735,7 +735,7 @@ toolbox_drag_drop (GtkWidget *widget,
if (layer)
{
new_layer = layer_copy (layer, FALSE);
new_layer = gimp_layer_copy (layer, FALSE);
}
else
{
@ -754,26 +754,27 @@ toolbox_drag_drop (GtkWidget *widget,
add_alpha_region (&srcPR, &destPR);
new_layer = layer_new_from_tiles (new_gimage,
gimp_image_base_type_with_alpha(new_gimage),
tiles,
"", OPAQUE_OPACITY, NORMAL_MODE);
new_layer =
gimp_layer_new_from_tiles (new_gimage,
gimp_image_base_type_with_alpha (new_gimage),
tiles,
"", OPAQUE_OPACITY, NORMAL_MODE);
tile_manager_destroy (tiles);
}
gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage);
layer_set_name (GIMP_LAYER (new_layer),
gimp_object_get_name (GIMP_OBJECT (drawable)));
gimp_layer_set_name (GIMP_LAYER (new_layer),
gimp_object_get_name (GIMP_OBJECT (drawable)));
if (layer)
{
LayerMask *mask;
LayerMask *new_mask;
GimpLayerMask *mask;
GimpLayerMask *new_mask;
mask = layer_get_mask (layer);
new_mask = layer_get_mask (new_layer);
mask = gimp_layer_get_mask (layer);
new_mask = gimp_layer_get_mask (new_layer);
if (new_mask)
{
@ -783,7 +784,7 @@ toolbox_drag_drop (GtkWidget *widget,
}
gimp_drawable_offsets (GIMP_DRAWABLE (new_layer), &off_x, &off_y);
layer_translate (new_layer, -off_x, -off_y);
gimp_layer_translate (new_layer, -off_x, -off_y);
gimp_image_add_layer (new_gimage, new_layer, 0);

5
app/tools/crop.c
View File

@ -997,12 +997,13 @@ crop_image (GImage *gimage,
crop_adjust_guides (gimage, x1, y1, x2, y2);
/* shrink wrap and update all views */
channel_invalidate_previews (gimage);
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_full (gimage);
gdisplays_shrink_wrap (gimage);
}
gimp_remove_busy_cursors (NULL);
gdisplays_flush ();
}

5
app/tools/gimpcroptool.c
View File

@ -997,12 +997,13 @@ crop_image (GImage *gimage,
crop_adjust_guides (gimage, x1, y1, x2, y2);
/* shrink wrap and update all views */
channel_invalidate_previews (gimage);
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_full (gimage);
gdisplays_shrink_wrap (gimage);
}
gimp_remove_busy_cursors (NULL);
gdisplays_flush ();
}

1
app/tools/gimptexttool.c
View File

@ -35,6 +35,7 @@
#include "apptypes.h"
#include "channel.h"
#include "drawable.h"
#include "errors.h"
#include "floating_sel.h"

1
app/tools/text_tool.c
View File

@ -35,6 +35,7 @@
#include "apptypes.h"
#include "channel.h"
#include "drawable.h"
#include "errors.h"
#include "floating_sel.h"

1
app/tools/transform_core.c
View File

@ -28,6 +28,7 @@
#include "apptypes.h"
#include "appenv.h"
#include "channel.h"
#include "cursorutil.h"
#include "draw_core.h"
#include "drawable.h"

274
app/undo.c
View File

@ -34,6 +34,7 @@
#include "gdisplay_ops.h"
#include "gimage.h"
#include "gimage_mask.h"
#include "gimplayermask.h"
#include "gimpparasite.h"
#include "gimprc.h"
#include "layer.h"
@ -72,7 +73,7 @@ typedef enum
} UndoState;
typedef gboolean (* UndoPopFunc) (GImage *, UndoState, UndoType, gpointer);
typedef gboolean (* UndoPopFunc) (GimpImage *, UndoState, UndoType, gpointer);
typedef void (* UndoFreeFunc) (UndoState, UndoType, gpointer);
typedef struct _Undo Undo;
@ -91,47 +92,47 @@ struct _Undo
/* Pop functions */
static gboolean undo_pop_image (GImage *,
static gboolean undo_pop_image (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_mask (GImage *,
static gboolean undo_pop_mask (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_displace (GImage *,
static gboolean undo_pop_layer_displace (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_transform (GImage *,
static gboolean undo_pop_transform (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_paint (GImage *,
static gboolean undo_pop_paint (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer (GImage *,
static gboolean undo_pop_layer (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_mod (GImage *,
static gboolean undo_pop_layer_mod (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_mask (GImage *,
static gboolean undo_pop_layer_mask (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_channel (GImage *,
static gboolean undo_pop_channel (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_channel_mod (GImage *,
static gboolean undo_pop_channel_mod (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_fs_to_layer (GImage *,
static gboolean undo_pop_fs_to_layer (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_fs_rigor (GImage *,
static gboolean undo_pop_fs_rigor (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_fs_relax (GImage *,
static gboolean undo_pop_fs_relax (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_gimage_mod (GImage *,
static gboolean undo_pop_gimage_mod (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_guide (GImage *,
static gboolean undo_pop_guide (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_parasite (GImage *,
static gboolean undo_pop_parasite (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_qmask (GImage *,
static gboolean undo_pop_qmask (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_resolution (GImage *,
static gboolean undo_pop_resolution (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_rename (GImage *,
static gboolean undo_pop_layer_rename (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_layer_reposition (GImage *,
static gboolean undo_pop_layer_reposition (GimpImage *,
UndoState, UndoType, gpointer);
static gboolean undo_pop_cantundo (GImage *,
static gboolean undo_pop_cantundo (GimpImage *,
UndoState, UndoType, gpointer);
@ -207,9 +208,9 @@ channel_size (Channel *channel)
static void
undo_free_list (GImage *gimage,
UndoState state,
GSList *list)
undo_free_list (GimpImage *gimage,
UndoState state,
GSList *list)
{
GSList *orig;
Undo *undo;
@ -234,7 +235,7 @@ undo_free_list (GImage *gimage,
static GSList *
remove_stack_bottom (GImage *gimage)
remove_stack_bottom (GimpImage *gimage)
{
GSList *list;
GSList *last;
@ -303,7 +304,7 @@ undo_new (UndoType type,
static gboolean
undo_free_up_space (GImage *gimage)
undo_free_up_space (GimpImage *gimage)
{
/* If there are 0 levels of undo return FALSE. */
if (levels_of_undo == 0)
@ -320,10 +321,10 @@ undo_free_up_space (GImage *gimage)
static Undo *
undo_push (GImage *gimage,
glong size,
UndoType type,
gboolean dirties_image)
undo_push (GimpImage *gimage,
glong size,
UndoType type,
gboolean dirties_image)
{
Undo *new;
@ -376,7 +377,7 @@ undo_push (GImage *gimage,
static gboolean
pop_stack (GImage *gimage,
pop_stack (GimpImage *gimage,
GSList **stack_ptr,
GSList **unstack_ptr,
UndoState state)
@ -490,7 +491,7 @@ pop_stack (GImage *gimage,
gboolean
undo_pop (GImage *gimage)
undo_pop (GimpImage *gimage)
{
/* Very bad idea to pop an action off the undo stack if we're in the
* middle of a group, since the whole group won't be popped. Might
@ -504,7 +505,7 @@ undo_pop (GImage *gimage)
gboolean
undo_redo (GImage *gimage)
undo_redo (GimpImage *gimage)
{
/* ditto for redo stack */
g_return_val_if_fail (gimage->pushing_undo_group == UNDO_NULL, FALSE);
@ -558,7 +559,7 @@ undo_get_topitem_type (GSList *stack)
const gchar *
undo_get_undo_name (GImage *gimage)
undo_get_undo_name (GimpImage *gimage)
{
g_return_val_if_fail (gimage != NULL, NULL);
@ -570,7 +571,7 @@ undo_get_undo_name (GImage *gimage)
}
UndoType
undo_get_undo_top_type (GImage *gimage)
undo_get_undo_top_type (GimpImage *gimage)
{
g_return_val_if_fail (gimage != NULL, UNDO_NULL);
@ -583,7 +584,7 @@ undo_get_undo_top_type (GImage *gimage)
const gchar *
undo_get_redo_name (GImage *gimage)
undo_get_redo_name (GimpImage *gimage)
{
g_return_val_if_fail (gimage != NULL, NULL);
@ -631,7 +632,7 @@ undo_map_over_stack (GSList *stack,
}
void
undo_map_over_undo_stack (GImage *gimage,
undo_map_over_undo_stack (GimpImage *gimage,
undo_map_fn fn,
gpointer data)
{
@ -641,7 +642,7 @@ undo_map_over_undo_stack (GImage *gimage,
}
void
undo_map_over_redo_stack (GImage *gimage,
undo_map_over_redo_stack (GimpImage *gimage,
undo_map_fn fn,
gpointer data)
{
@ -652,7 +653,7 @@ undo_map_over_redo_stack (GImage *gimage,
void
undo_free (GImage *gimage)
undo_free (GimpImage *gimage)
{
undo_free_list (gimage, UNDO, gimage->undo_stack);
undo_free_list (gimage, REDO, gimage->redo_stack);
@ -683,7 +684,7 @@ undo_free (GImage *gimage)
/* group Undo funcs */
gboolean
undo_push_group_start (GImage *gimage,
undo_push_group_start (GimpImage *gimage,
UndoType type)
{
Undo *boundary_marker;
@ -733,7 +734,7 @@ undo_push_group_start (GImage *gimage,
gboolean
undo_push_group_end (GImage *gimage)
undo_push_group_end (GimpImage *gimage)
{
Undo *boundary_marker;
@ -778,7 +779,7 @@ struct _ImageUndo
gboolean
undo_push_image (GImage *gimage,
undo_push_image (GimpImage *gimage,
GimpDrawable *drawable,
gint x1,
gint y1,
@ -834,7 +835,7 @@ undo_push_image (GImage *gimage,
gboolean
undo_push_image_mod (GImage *gimage,
undo_push_image_mod (GimpImage *gimage,
GimpDrawable *drawable,
gint x1,
gint y1,
@ -893,7 +894,7 @@ undo_push_image_mod (GImage *gimage,
static gboolean
undo_pop_image (GImage *gimage,
undo_pop_image (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer image_undo_ptr)
@ -984,8 +985,8 @@ undo_free_image (UndoState state,
/* Mask Undo functions */
gboolean
undo_push_mask (GImage *gimage,
gpointer mask_ptr)
undo_push_mask (GimpImage *gimage,
gpointer mask_ptr)
{
Undo *new;
MaskUndo *mask_undo;
@ -1019,19 +1020,19 @@ undo_push_mask (GImage *gimage,
static gboolean
undo_pop_mask (GImage *gimage,
UndoState state,
UndoType type,
gpointer mask_ptr)
undo_pop_mask (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer mask_ptr)
{
MaskUndo *mask_undo;
TileManager *new_tiles;
Channel *sel_mask;
PixelRegion srcPR, destPR;
gint selection;
gint x1, y1, x2, y2;
gint width, height;
guchar empty = 0;
gint selection;
gint x1, y1, x2, y2;
gint width, height;
guchar empty = 0;
width = height = 0;
@ -1135,7 +1136,7 @@ struct _LayerDisplayUndo
};
gboolean
undo_push_layer_displace (GImage *gimage,
undo_push_layer_displace (GimpImage *gimage,
GimpLayer *layer)
{
Undo *new;
@ -1161,13 +1162,13 @@ undo_push_layer_displace (GImage *gimage,
static gboolean
undo_pop_layer_displace (GImage *gimage,
UndoState state,
UndoType type,
gpointer info_ptr)
undo_pop_layer_displace (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer info_ptr)
{
Layer *layer;
gint old_offsets[2];
GimpLayer *layer;
gint old_offsets[2];
LayerDisplaceUndo *ldu;
ldu = (LayerDisplaceUndo *) info_ptr;
@ -1234,8 +1235,8 @@ undo_free_layer_displace (UndoState state,
/* Transform Undo */
gboolean
undo_push_transform (GImage *gimage,
gpointer tu_ptr)
undo_push_transform (GimpImage *gimage,
gpointer tu_ptr)
{
Undo *new;
@ -1257,7 +1258,7 @@ undo_push_transform (GImage *gimage,
static gboolean
undo_pop_transform (GImage *gimage,
undo_pop_transform (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer tu_ptr)
@ -1265,8 +1266,8 @@ undo_pop_transform (GImage *gimage,
TransformCore *tc;
TransformUndo *tu;
TileManager *temp;
gdouble d;
gint i;
gdouble d;
gint i;
/* Can't have ANY tool selected - maybe a plugin running */
if (active_tool == NULL)
@ -1325,8 +1326,8 @@ undo_free_transform (UndoState state,
/* Paint Undo */
gboolean
undo_push_paint (GImage *gimage,
gpointer pu_ptr)
undo_push_paint (GimpImage *gimage,
gpointer pu_ptr)
{
Undo *new;
@ -1348,7 +1349,7 @@ undo_push_paint (GImage *gimage,
static gboolean
undo_pop_paint (GImage *gimage,
undo_pop_paint (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer pu_ptr)
@ -1409,9 +1410,9 @@ undo_free_paint (UndoState state,
/* New Layer Undo */
gboolean
undo_push_layer (GImage *gimage,
UndoType type,
gpointer lu_ptr)
undo_push_layer (GimpImage *gimage,
UndoType type,
gpointer lu_ptr)
{
LayerUndo *lu;
Undo *new;
@ -1445,7 +1446,7 @@ undo_push_layer (GImage *gimage,
static gboolean
undo_pop_layer (GImage *gimage,
undo_pop_layer (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer lu_ptr)
@ -1533,10 +1534,10 @@ undo_free_layer (UndoState state,
/* Layer Mod Undo */
gboolean
undo_push_layer_mod (GImage *gimage,
gpointer layer_ptr)
undo_push_layer_mod (GimpImage *gimage,
gpointer layer_ptr)
{
Layer *layer;
GimpLayer *layer;
Undo *new;
TileManager *tiles;
gpointer *data;
@ -1574,7 +1575,7 @@ undo_push_layer_mod (GImage *gimage,
static gboolean
undo_pop_layer_mod (GImage *gimage,
undo_pop_layer_mod (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -1583,10 +1584,10 @@ undo_pop_layer_mod (GImage *gimage,
gint layer_type;
TileManager *tiles;
TileManager *temp;
Layer *layer;
GimpLayer *layer;
data = (gpointer *) data_ptr;
layer = (Layer *) data[0];
layer = (GimpLayer *) data[0];
tiles = (TileManager *) data[1];
@ -1656,9 +1657,9 @@ undo_free_layer_mod (UndoState state,
/* Layer Mask Undo */
gboolean
undo_push_layer_mask (GImage *gimage,
UndoType type,
gpointer lmu_ptr)
undo_push_layer_mask (GimpImage *gimage,
UndoType type,
gpointer lmu_ptr)
{
LayerMaskUndo *lmu;
Undo *new;
@ -1683,7 +1684,8 @@ undo_push_layer_mask (GImage *gimage,
else
{
if (type == LAYER_MASK_REMOVE_UNDO)
layer_mask_delete (lmu->mask);
gtk_object_unref (GTK_OBJECT (lmu->mask));
g_free (lmu);
return FALSE;
}
@ -1691,7 +1693,7 @@ undo_push_layer_mask (GImage *gimage,
static gboolean
undo_pop_layer_mask (GImage *gimage,
undo_pop_layer_mask (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer lmu_ptr)
@ -1758,7 +1760,7 @@ undo_free_layer_mask (UndoState state,
*/
if ((state == REDO && type == LAYER_MASK_ADD_UNDO) ||
(state == UNDO && type == LAYER_MASK_REMOVE_UNDO))
layer_mask_delete (lmu->mask);
gtk_object_unref (GTK_OBJECT (lmu->mask));
g_free (lmu);
}
@ -1768,13 +1770,13 @@ undo_free_layer_mask (UndoState state,
/* New Channel Undo */
gboolean
undo_push_channel (GImage *gimage,
UndoType type,
gpointer cu_ptr)
undo_push_channel (GimpImage *gimage,
UndoType type,
gpointer cu_ptr)
{
ChannelUndo *cu;
Undo *new;
gint size;
Undo *new;
gint size;
g_return_val_if_fail (type == CHANNEL_ADD_UNDO ||
type == CHANNEL_REMOVE_UNDO,
@ -1803,7 +1805,7 @@ undo_push_channel (GImage *gimage,
static gboolean
undo_pop_channel (GImage *gimage,
undo_pop_channel (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer cu_ptr)
@ -1879,8 +1881,8 @@ undo_free_channel (UndoState state,
/* Channel Mod Undo */
gboolean
undo_push_channel_mod (GImage *gimage,
gpointer channel_ptr)
undo_push_channel_mod (GimpImage *gimage,
gpointer channel_ptr)
{
Channel *channel;
TileManager *tiles;
@ -1915,7 +1917,7 @@ undo_push_channel_mod (GImage *gimage,
static gboolean
undo_pop_channel_mod (GImage *gimage,
undo_pop_channel_mod (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -1972,11 +1974,11 @@ undo_free_channel_mod (UndoState state,
/* Floating Selection to Layer Undo */
gboolean
undo_push_fs_to_layer (GImage *gimage,
gpointer fsu_ptr)
undo_push_fs_to_layer (GimpImage *gimage,
gpointer fsu_ptr)
{
FStoLayerUndo *fsu;
Undo *new;
Undo *new;
fsu = (FStoLayerUndo *) fsu_ptr;
@ -1999,7 +2001,7 @@ undo_push_fs_to_layer (GImage *gimage,
static gboolean
undo_pop_fs_to_layer (GImage *gimage,
undo_pop_fs_to_layer (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer fsu_ptr)
@ -2079,8 +2081,8 @@ undo_free_fs_to_layer (UndoState state,
/* Floating Selection Rigor Undo */
gboolean
undo_push_fs_rigor (GImage *gimage,
gint layer_ID)
undo_push_fs_rigor (GimpImage *gimage,
gint layer_ID)
{
Undo *new;
@ -2101,7 +2103,7 @@ undo_push_fs_rigor (GImage *gimage,
static gboolean
undo_pop_fs_rigor (GImage *gimage,
undo_pop_fs_rigor (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer layer_ptr)
@ -2158,8 +2160,8 @@ undo_free_fs_rigor (UndoState state,
/* Floating Selection Relax Undo */
gboolean
undo_push_fs_relax (GImage *gimage,
gint32 layer_ID)
undo_push_fs_relax (GimpImage *gimage,
gint32 layer_ID)
{
Undo *new;
@ -2180,7 +2182,7 @@ undo_push_fs_relax (GImage *gimage,
static gboolean
undo_pop_fs_relax (GImage *gimage,
undo_pop_fs_relax (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer layer_ptr)
@ -2237,7 +2239,7 @@ undo_free_fs_relax (UndoState state,
/* GImage Mod Undo */
gboolean
undo_push_gimage_mod (GImage *gimage)
undo_push_gimage_mod (GimpImage *gimage)
{
Undo *new;
gint *data;
@ -2262,7 +2264,7 @@ undo_push_gimage_mod (GImage *gimage)
static gboolean
undo_pop_gimage_mod (GImage *gimage,
undo_pop_gimage_mod (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2284,8 +2286,8 @@ undo_pop_gimage_mod (GImage *gimage,
gimp_image_projection_realloc (gimage);
gimage_mask_invalidate (gimage);
channel_invalidate_previews (gimage);
layer_invalidate_previews (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_image_invalidate_preview (gimage);
gdisplays_update_full (gimage);
gdisplays_update_title (gimage);
@ -2314,13 +2316,13 @@ typedef struct _QmaskUndo QmaskUndo;
struct _QmaskUndo
{
GImage *gimage;
gboolean qmask;
GimpImage *gimage;
gboolean qmask;
};
gboolean
undo_push_qmask (GImage *gimage)
undo_push_qmask (GimpImage *gimage)
{
Undo *new;
QmaskUndo *data;
@ -2343,7 +2345,7 @@ undo_push_qmask (GImage *gimage)
}
static gboolean
undo_pop_qmask (GImage *gimage,
undo_pop_qmask (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2379,14 +2381,14 @@ typedef struct _GuideUndo GuideUndo;
struct _GuideUndo
{
GImage *gimage;
Guide *guide;
Guide orig;
GimpImage *gimage;
Guide *guide;
Guide orig;
};
gboolean
undo_push_guide (GImage *gimage,
gpointer guide)
undo_push_guide (GimpImage *gimage,
gpointer guide)
{
Undo *new;
GuideUndo *data;
@ -2413,7 +2415,7 @@ undo_push_guide (GImage *gimage,
static gboolean
undo_pop_guide (GImage *gimage,
undo_pop_guide (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2469,7 +2471,7 @@ struct _ResolutionUndo
};
gboolean
undo_push_resolution (GImage *gimage)
undo_push_resolution (GimpImage *gimage)
{
Undo *new;
ResolutionUndo *data;
@ -2493,7 +2495,7 @@ undo_push_resolution (GImage *gimage)
}
static gboolean
undo_pop_resolution (GImage *gimage,
undo_pop_resolution (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2541,15 +2543,15 @@ typedef struct _ParasiteUndo ParasiteUndo;
struct _ParasiteUndo
{
GImage *gimage;
GimpImage *gimage;
GimpDrawable *drawable;
GimpParasite *parasite;
gchar *name;
};
gboolean
undo_push_image_parasite (GImage *gimage,
gpointer parasite)
undo_push_image_parasite (GimpImage *gimage,
gpointer parasite)
{
Undo *new;
ParasiteUndo *data;
@ -2574,7 +2576,7 @@ undo_push_image_parasite (GImage *gimage,
}
gboolean
undo_push_image_parasite_remove (GImage *gimage,
undo_push_image_parasite_remove (GimpImage *gimage,
const gchar *name)
{
Undo *new;
@ -2600,7 +2602,7 @@ undo_push_image_parasite_remove (GImage *gimage,
}
gboolean
undo_push_drawable_parasite (GImage *gimage,
undo_push_drawable_parasite (GimpImage *gimage,
GimpDrawable *drawable,
gpointer parasite)
{
@ -2626,7 +2628,7 @@ undo_push_drawable_parasite (GImage *gimage,
}
gboolean
undo_push_drawable_parasite_remove (GImage *gimage,
undo_push_drawable_parasite_remove (GimpImage *gimage,
GimpDrawable *drawable,
const gchar *name)
{
@ -2653,7 +2655,7 @@ undo_push_drawable_parasite_remove (GImage *gimage,
static gboolean
undo_pop_parasite (GImage *gimage,
undo_pop_parasite (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)
@ -2732,7 +2734,7 @@ struct _LayerRepositionUndo
};
gboolean
undo_push_layer_reposition (GImage *gimage,
undo_push_layer_reposition (GimpImage *gimage,
GimpLayer *layer)
{
Undo *new;
@ -2756,13 +2758,13 @@ undo_push_layer_reposition (GImage *gimage,
}
static gboolean
undo_pop_layer_reposition (GImage *gimage,
undo_pop_layer_reposition (GimpImage *gimage,
UndoState state,
UndoType type,
void *data_ptr)
{
LayerRepositionUndo *data = data_ptr;
gint tmp;
gint tmp;
/* what's the layer's current index? */
tmp = g_slist_index (gimage->layers, data->layer);
@ -2795,7 +2797,7 @@ struct _LayerRenameUndo
};
gboolean
undo_push_layer_rename (GImage *gimage,
undo_push_layer_rename (GimpImage *gimage,
GimpLayer *layer)
{
Undo *new;
@ -2819,13 +2821,13 @@ undo_push_layer_rename (GImage *gimage,
}
static gboolean
undo_pop_layer_rename (GImage *gimage,
undo_pop_layer_rename (GimpImage *gimage,
UndoState state,
UndoType type,
void *data_ptr)
{
LayerRenameUndo *data = data_ptr;
gchar *tmp;
gchar *tmp;
tmp = g_strdup (layer_get_name (data->layer));
layer_set_name (data->layer, data->old_name);
@ -2854,7 +2856,7 @@ undo_free_layer_rename (UndoState state,
*/
gboolean
undo_push_cantundo (GImage *gimage,
undo_push_cantundo (GimpImage *gimage,
const gchar *action)
{
Undo *new;
@ -2875,7 +2877,7 @@ undo_push_cantundo (GImage *gimage,
}
static gboolean
undo_pop_cantundo (GImage *gimage,
undo_pop_cantundo (GimpImage *gimage,
UndoState state,
UndoType type,
gpointer data_ptr)

6
app/widgets/gimpdnd.c
View File

@ -35,6 +35,7 @@
#include "gimpcontextpreview.h"
#include "gimpdnd.h"
#include "gimpbrushlist.h"
#include "gimplayermask.h"
#include "gimprc.h"
#include "gradient.h"
#include "gradient_header.h"
@ -1090,8 +1091,9 @@ gimp_dnd_set_drawable_preview_icon (GtkWidget *widget,
else if (GIMP_IS_LAYER_MASK (drawable))
{
tmpbuf =
layer_mask_preview (layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
width, height);
gimp_layer_mask_preview
(gimp_layer_mask_get_layer (GIMP_LAYER_MASK (drawable)),
width, height);
}
else if (GIMP_IS_CHANNEL (drawable))
{

57
app/widgets/gimptoolbox.c
View File

@ -657,19 +657,19 @@ toolbox_drag_drop (GtkWidget *widget,
if ((src_widget = gtk_drag_get_source_widget (context)))
{
GimpDrawable *drawable = NULL;
Layer *layer = NULL;
Channel *channel = NULL;
LayerMask *layer_mask = NULL;
GImage *component = NULL;
ChannelType component_type = -1;
GimpDrawable *drawable = NULL;
GimpLayer *layer = NULL;
Channel *channel = NULL;
GimpLayerMask *layer_mask = NULL;
GimpImage *component = NULL;
ChannelType component_type = -1;
layer = (Layer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
layer = (GimpLayer *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer");
channel = (Channel *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_channel");
layer_mask = (LayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
layer_mask = (GimpLayerMask *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_layer_mask");
component = (GImage *) gtk_object_get_data (GTK_OBJECT (src_widget),
"gimp_component");
@ -694,12 +694,12 @@ toolbox_drag_drop (GtkWidget *widget,
if (drawable)
{
GImage *gimage;
GImage *new_gimage;
Layer *new_layer;
gint width, height;
gint off_x, off_y;
gint bytes;
GimpImage *gimage;
GimpImage *new_gimage;
GimpLayer *new_layer;
gint width, height;
gint off_x, off_y;
gint bytes;
GimpImageBaseType type;
@ -735,7 +735,7 @@ toolbox_drag_drop (GtkWidget *widget,
if (layer)
{
new_layer = layer_copy (layer, FALSE);
new_layer = gimp_layer_copy (layer, FALSE);
}
else
{
@ -754,26 +754,27 @@ toolbox_drag_drop (GtkWidget *widget,
add_alpha_region (&srcPR, &destPR);
new_layer = layer_new_from_tiles (new_gimage,
gimp_image_base_type_with_alpha(new_gimage),
tiles,
"", OPAQUE_OPACITY, NORMAL_MODE);
new_layer =
gimp_layer_new_from_tiles (new_gimage,
gimp_image_base_type_with_alpha (new_gimage),
tiles,
"", OPAQUE_OPACITY, NORMAL_MODE);
tile_manager_destroy (tiles);
}
gimp_drawable_set_gimage (GIMP_DRAWABLE (new_layer), new_gimage);
layer_set_name (GIMP_LAYER (new_layer),
gimp_object_get_name (GIMP_OBJECT (drawable)));
gimp_layer_set_name (GIMP_LAYER (new_layer),
gimp_object_get_name (GIMP_OBJECT (drawable)));
if (layer)
{
LayerMask *mask;
LayerMask *new_mask;
GimpLayerMask *mask;
GimpLayerMask *new_mask;
mask = layer_get_mask (layer);
new_mask = layer_get_mask (new_layer);
mask = gimp_layer_get_mask (layer);
new_mask = gimp_layer_get_mask (new_layer);
if (new_mask)
{
@ -783,7 +784,7 @@ toolbox_drag_drop (GtkWidget *widget,
}
gimp_drawable_offsets (GIMP_DRAWABLE (new_layer), &off_x, &off_y);
layer_translate (new_layer, -off_x, -off_y);
gimp_layer_translate (new_layer, -off_x, -off_y);
gimp_image_add_layer (new_gimage, new_layer, 0);

107
app/xcf.c
View File

@ -43,6 +43,7 @@
#include "floating_sel.h"
#include "gimage.h"
#include "gimage_mask.h"
#include "gimplayermask.h"
#include "gimprc.h"
#include "layer.h"
#include "plug_in.h"
@ -136,33 +137,33 @@ static void xcf_save_tile_rle (XcfInfo *info,
Tile *tile,
guchar *rlebuf);
static GImage* xcf_load_image (XcfInfo *info);
static gboolean xcf_load_image_props (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_layer_props (XcfInfo *info,
GImage *gimage,
Layer *layer);
static gboolean xcf_load_channel_props (XcfInfo *info,
GImage *gimage,
Channel *channel);
static gboolean xcf_load_prop (XcfInfo *info,
PropType *prop_type,
guint32 *prop_size);
static Layer* xcf_load_layer (XcfInfo *info,
GImage *gimage);
static Channel* xcf_load_channel (XcfInfo *info,
GImage *gimage);
static LayerMask* xcf_load_layer_mask (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_hierarchy (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_level (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_tile (XcfInfo *info,
Tile *tile);
static gboolean xcf_load_tile_rle (XcfInfo *info,
Tile *tile,
gint data_length);
static GimpImage * xcf_load_image (XcfInfo *info);
static gboolean xcf_load_image_props (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_layer_props (XcfInfo *info,
GImage *gimage,
Layer *layer);
static gboolean xcf_load_channel_props (XcfInfo *info,
GImage *gimage,
Channel *channel);
static gboolean xcf_load_prop (XcfInfo *info,
PropType *prop_type,
guint32 *prop_size);
static GimpLayer * xcf_load_layer (XcfInfo *info,
GImage *gimage);
static Channel * xcf_load_channel (XcfInfo *info,
GImage *gimage);
static GimpLayerMask * xcf_load_layer_mask (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_hierarchy (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_level (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_tile (XcfInfo *info,
Tile *tile);
static gboolean xcf_load_tile_rle (XcfInfo *info,
Tile *tile,
gint data_length);
#ifdef SWAP_FROM_FILE
static gboolean xcf_swap_func (gint fd,
@ -2225,22 +2226,22 @@ xcf_load_prop (XcfInfo *info,
return TRUE;
}
static Layer*
static GimpLayer *
xcf_load_layer (XcfInfo *info,
GImage *gimage)
{
Layer *layer;
LayerMask *layer_mask;
guint32 hierarchy_offset;
guint32 layer_mask_offset;
gboolean apply_mask;
gboolean edit_mask;
gboolean show_mask;
gint width;
gint height;
gint type;
gint add_floating_sel;
gchar *name;
GimpLayer *layer;
GimpLayerMask *layer_mask;
guint32 hierarchy_offset;
guint32 layer_mask_offset;
gboolean apply_mask;
gboolean edit_mask;
gboolean show_mask;
gint width;
gint height;
gint type;
gint add_floating_sel;
gchar *name;
/* check and see if this is the drawable the floating selection
* is attached to. if it is then we'll do the attachment at
@ -2283,14 +2284,14 @@ xcf_load_layer (XcfInfo *info,
goto error;
/* set the offsets of the layer_mask */
GIMP_DRAWABLE(layer_mask)->offset_x = GIMP_DRAWABLE(layer)->offset_x;
GIMP_DRAWABLE(layer_mask)->offset_y = GIMP_DRAWABLE(layer)->offset_y;
GIMP_DRAWABLE (layer_mask)->offset_x = GIMP_DRAWABLE (layer)->offset_x;
GIMP_DRAWABLE (layer_mask)->offset_y = GIMP_DRAWABLE (layer)->offset_y;
apply_mask = layer->apply_mask;
edit_mask = layer->edit_mask;
show_mask = layer->show_mask;
layer_add_mask (layer, layer_mask);
gimp_layer_add_mask (layer, layer_mask);
layer->apply_mask = apply_mask;
layer->edit_mask = edit_mask;
@ -2370,17 +2371,17 @@ error:
return NULL;
}
static LayerMask*
static GimpLayerMask *
xcf_load_layer_mask (XcfInfo *info,
GImage *gimage)
{
LayerMask *layer_mask;
guint32 hierarchy_offset;
gint width;
gint height;
gint add_floating_sel;
gchar *name;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
GimpLayerMask *layer_mask;
guint32 hierarchy_offset;
gint width;
gint height;
gint add_floating_sel;
gchar *name;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
/* check and see if this is the drawable the floating selection
* is attached to. if it is then we'll do the attachment at
@ -2394,7 +2395,7 @@ xcf_load_layer_mask (XcfInfo *info,
info->cp += xcf_read_string (info->fp, &name, 1);
/* create a new layer mask */
layer_mask = layer_mask_new (gimage, width, height, name, &color);
layer_mask = gimp_layer_mask_new (gimage, width, height, name, &color);
g_free (name);
if (!layer_mask)
return NULL;
@ -2423,7 +2424,7 @@ xcf_load_layer_mask (XcfInfo *info,
return layer_mask;
error:
layer_mask_delete (layer_mask);
gtk_object_unref (GTK_OBJECT (layer_mask));
return NULL;
}

107
app/xcf/xcf.c
View File

@ -43,6 +43,7 @@
#include "floating_sel.h"
#include "gimage.h"
#include "gimage_mask.h"
#include "gimplayermask.h"
#include "gimprc.h"
#include "layer.h"
#include "plug_in.h"
@ -136,33 +137,33 @@ static void xcf_save_tile_rle (XcfInfo *info,
Tile *tile,
guchar *rlebuf);
static GImage* xcf_load_image (XcfInfo *info);
static gboolean xcf_load_image_props (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_layer_props (XcfInfo *info,
GImage *gimage,
Layer *layer);
static gboolean xcf_load_channel_props (XcfInfo *info,
GImage *gimage,
Channel *channel);
static gboolean xcf_load_prop (XcfInfo *info,
PropType *prop_type,
guint32 *prop_size);
static Layer* xcf_load_layer (XcfInfo *info,
GImage *gimage);
static Channel* xcf_load_channel (XcfInfo *info,
GImage *gimage);
static LayerMask* xcf_load_layer_mask (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_hierarchy (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_level (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_tile (XcfInfo *info,
Tile *tile);
static gboolean xcf_load_tile_rle (XcfInfo *info,
Tile *tile,
gint data_length);
static GimpImage * xcf_load_image (XcfInfo *info);
static gboolean xcf_load_image_props (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_layer_props (XcfInfo *info,
GImage *gimage,
Layer *layer);
static gboolean xcf_load_channel_props (XcfInfo *info,
GImage *gimage,
Channel *channel);
static gboolean xcf_load_prop (XcfInfo *info,
PropType *prop_type,
guint32 *prop_size);
static GimpLayer * xcf_load_layer (XcfInfo *info,
GImage *gimage);
static Channel * xcf_load_channel (XcfInfo *info,
GImage *gimage);
static GimpLayerMask * xcf_load_layer_mask (XcfInfo *info,
GImage *gimage);
static gboolean xcf_load_hierarchy (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_level (XcfInfo *info,
TileManager *tiles);
static gboolean xcf_load_tile (XcfInfo *info,
Tile *tile);
static gboolean xcf_load_tile_rle (XcfInfo *info,
Tile *tile,
gint data_length);
#ifdef SWAP_FROM_FILE
static gboolean xcf_swap_func (gint fd,
@ -2225,22 +2226,22 @@ xcf_load_prop (XcfInfo *info,
return TRUE;
}
static Layer*
static GimpLayer *
xcf_load_layer (XcfInfo *info,
GImage *gimage)
{
Layer *layer;
LayerMask *layer_mask;
guint32 hierarchy_offset;
guint32 layer_mask_offset;
gboolean apply_mask;
gboolean edit_mask;
gboolean show_mask;
gint width;
gint height;
gint type;
gint add_floating_sel;
gchar *name;
GimpLayer *layer;
GimpLayerMask *layer_mask;
guint32 hierarchy_offset;
guint32 layer_mask_offset;
gboolean apply_mask;
gboolean edit_mask;
gboolean show_mask;
gint width;
gint height;
gint type;
gint add_floating_sel;
gchar *name;
/* check and see if this is the drawable the floating selection
* is attached to. if it is then we'll do the attachment at
@ -2283,14 +2284,14 @@ xcf_load_layer (XcfInfo *info,
goto error;
/* set the offsets of the layer_mask */
GIMP_DRAWABLE(layer_mask)->offset_x = GIMP_DRAWABLE(layer)->offset_x;
GIMP_DRAWABLE(layer_mask)->offset_y = GIMP_DRAWABLE(layer)->offset_y;
GIMP_DRAWABLE (layer_mask)->offset_x = GIMP_DRAWABLE (layer)->offset_x;
GIMP_DRAWABLE (layer_mask)->offset_y = GIMP_DRAWABLE (layer)->offset_y;
apply_mask = layer->apply_mask;
edit_mask = layer->edit_mask;
show_mask = layer->show_mask;
layer_add_mask (layer, layer_mask);
gimp_layer_add_mask (layer, layer_mask);
layer->apply_mask = apply_mask;
layer->edit_mask = edit_mask;
@ -2370,17 +2371,17 @@ error:
return NULL;
}
static LayerMask*
static GimpLayerMask *
xcf_load_layer_mask (XcfInfo *info,
GImage *gimage)
{
LayerMask *layer_mask;
guint32 hierarchy_offset;
gint width;
gint height;
gint add_floating_sel;
gchar *name;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
GimpLayerMask *layer_mask;
guint32 hierarchy_offset;
gint width;
gint height;
gint add_floating_sel;
gchar *name;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
/* check and see if this is the drawable the floating selection
* is attached to. if it is then we'll do the attachment at
@ -2394,7 +2395,7 @@ xcf_load_layer_mask (XcfInfo *info,
info->cp += xcf_read_string (info->fp, &name, 1);
/* create a new layer mask */
layer_mask = layer_mask_new (gimage, width, height, name, &color);
layer_mask = gimp_layer_mask_new (gimage, width, height, name, &color);
g_free (name);
if (!layer_mask)
return NULL;
@ -2423,7 +2424,7 @@ xcf_load_layer_mask (XcfInfo *info,
return layer_mask;
error:
layer_mask_delete (layer_mask);
gtk_object_unref (GTK_OBJECT (layer_mask));
return NULL;
}

2
tools/pdbgen/pdb.pl
View File

@ -66,7 +66,7 @@ package Gimp::CodeGen::pdb;
id_func => '(GimpChannel *) gimp_drawable_get_by_ID',
id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' },
layer_mask => { name => 'CHANNEL',
type => 'LayerMask *',
type => 'GimpLayerMask *',
headers => [ qw("drawable.h" "channel.h") ],
id_func => '(GimpLayerMask *) gimp_drawable_get_by_ID',
id_ret_func => 'gimp_drawable_get_ID (GIMP_DRAWABLE ($var))' },

3
tools/pdbgen/pdb/drawable.pdb
View File

@ -499,7 +499,8 @@ CODE
);
}
@headers = qw("drawable.h" "tile.h" "tile_manager.h" "temp_buf.h");
@headers = qw("gimplayermask.h" "drawable.h" "tile.h" "tile_manager.h"
"temp_buf.h");
@procs = qw(drawable_merge_shadow drawable_fill drawable_update
drawable_mask_bounds drawable_image drawable_type