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

app/base/base-enums.h moved all remaining enums to base-enums.h 

2001-12-11  Sven Neumann  <sven@gimp.org>

	* app/base/base-enums.h
	* app/base/base-types.h: moved all remaining enums to base-enums.h

	* app/core/core-enums.h
	* app/core/core-types.h: moved GimpImageType to core-enums.h and
	changed the values from RGB_GIMAGE to GIMP_RGB_IMAGE and the like.

	* app/core/gimpchannel.c
	* app/core/gimpdrawable-preview.c
	* app/core/gimpdrawable-transform.c
	* app/core/gimpdrawable.c
	* app/core/gimpimage-contiguous-region.c
	* app/core/gimpimage-convert.c
	* app/core/gimpimage-mask.c
	* app/core/gimpimage-merge.c
	* app/core/gimpimage-new.c
	* app/core/gimpimage-projection.c
	* app/core/gimpimage.[ch]
	* app/core/gimplayer.c
	* app/core/gimplayermask.c
	* app/core/gimppalette-import.c
	* app/display/gimpdisplayshell-dnd.c
	* app/display/gimpdisplayshell-render.c
	* app/gui/file-save-dialog.c
	* app/gui/toolbox.c
	* app/plug-in/plug-in.c
	* app/tools/gimpblendtool.c
	* app/tools/gimpcolorpickertool.c
	* app/tools/gimpdodgeburntool.c: changed accordingly.

	* tools/pdbgen/Makefile.am: no need to parse app/base/base-types.h
	any longer.

	* app/pdb/color_cmds.c
	* app/pdb/drawable_cmds.c
	* app/pdb/layer_cmds.c
	* app/pdb/paint_tools_cmds.c
	* tools/pdbgen/enums.pl: regenerated.
This commit is contained in:
Sven Neumann 2001-12-11 18:11:56 +00:00 committed by Sven Neumann
parent a611f06361
commit 03a6c04419
59 changed files with 481 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
ChangeLog
View File

@ -1,3 +1,44 @@
2001-12-11 Sven Neumann <sven@gimp.org>
* app/base/base-enums.h
* app/base/base-types.h: moved all remaining enums to base-enums.h
* app/core/core-enums.h
* app/core/core-types.h: moved GimpImageType to core-enums.h and
changed the values from RGB_GIMAGE to GIMP_RGB_IMAGE and the like.
* app/core/gimpchannel.c
* app/core/gimpdrawable-preview.c
* app/core/gimpdrawable-transform.c
* app/core/gimpdrawable.c
* app/core/gimpimage-contiguous-region.c
* app/core/gimpimage-convert.c
* app/core/gimpimage-mask.c
* app/core/gimpimage-merge.c
* app/core/gimpimage-new.c
* app/core/gimpimage-projection.c
* app/core/gimpimage.[ch]
* app/core/gimplayer.c
* app/core/gimplayermask.c
* app/core/gimppalette-import.c
* app/display/gimpdisplayshell-dnd.c
* app/display/gimpdisplayshell-render.c
* app/gui/file-save-dialog.c
* app/gui/toolbox.c
* app/plug-in/plug-in.c
* app/tools/gimpblendtool.c
* app/tools/gimpcolorpickertool.c
* app/tools/gimpdodgeburntool.c: changed accordingly.
* tools/pdbgen/Makefile.am: no need to parse app/base/base-types.h
any longer.
* app/pdb/color_cmds.c
* app/pdb/drawable_cmds.c
* app/pdb/layer_cmds.c
* app/pdb/paint_tools_cmds.c
* tools/pdbgen/enums.pl: regenerated.
2001-12-11 Sven Neumann <sven@gimp.org>
* app/core/core-types.h: removed GimpImageBaseType enum ...

12
app/actions/plug-in-commands.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

65
app/base/base-enums.h
View File

@ -19,8 +19,22 @@
#ifndef __BASE_ENUMS_H__
#define __BASE_ENUMS_H__
/* These enums that are registered with the type system. */
#if 0
This file is parsed by two scripts, enumgen.pl in tools/pdbgen
and glib-mkenums. All enums that are not marked with /*< pdb-skip >*/
are exported to libgimp and the PDB. Enums that are not marked with
/*< skip >*/ are registered with the GType system. If you want the
enum to be skipped by both scripts, you have to use /*< pdb-skip >*/
_before_ /*< skip >*/.
All enum values that are marked with /*< skip >*/ are skipped for
both targets.
#endif
/*
* these enums that are registered with the type system
*/
#define GIMP_TYPE_INTERPOLATION_TYPE (gimp_interpolation_type_get_type ())
@ -66,11 +80,23 @@ typedef enum
} GimpLayerModeEffects;
#define GIMP_TYPE_CHECK_SIZE (gimp_check_size_get_type ())
GType gimp_check_size_get_type (void) G_GNUC_CONST;
typedef enum /*< pdb-skip >*/
{
GIMP_SMALL_CHECKS = 0,
GIMP_MEDIUM_CHECKS = 1,
GIMP_LARGE_CHECKS = 2
} GimpCheckSize;
#define GIMP_TYPE_CHECK_TYPE (gimp_check_type_get_type ())
GType gimp_check_type_get_type (void) G_GNUC_CONST;
typedef enum /*< pdb-skip >*/
typedef enum /*< pdb-skip >*/
{
GIMP_LIGHT_CHECKS = 0,
GIMP_GRAY_CHECKS = 1,
@ -81,16 +107,35 @@ typedef enum /*< pdb-skip >*/
} GimpCheckType;
#define GIMP_TYPE_CHECK_SIZE (gimp_check_size_get_type ())
/*
* non-registered enums; register them if needed
*/
GType gimp_check_size_get_type (void) G_GNUC_CONST;
typedef enum /*< pdb-skip >*/
typedef enum /*< skip >*/
{
GIMP_SMALL_CHECKS = 0,
GIMP_MEDIUM_CHECKS = 1,
GIMP_LARGE_CHECKS = 2
} GimpCheckSize;
GIMP_NORMAL_CONVOL, /* Negative numbers truncated */
GIMP_ABSOLUTE_CONVOL, /* Absolute value */
GIMP_NEGATIVE_CONVOL /* add 127 to values */
} GimpConvolutionType;
typedef enum /*< skip >*/
{
GIMP_VALUE_LUT,
GIMP_RED_LUT,
GIMP_GREEN_LUT,
GIMP_BLUE_LUT,
GIMP_ALPHA_LUT,
GIMP_GRAY_LUT = 0 /*< skip >*/
} GimpChannelLutType;
typedef enum /*< pdb-skip >*/ /*< skip >*/
{
GIMP_HISTOGRAM_VALUE = 0,
GIMP_HISTOGRAM_RED = 1,
GIMP_HISTOGRAM_GREEN = 2,
GIMP_HISTOGRAM_BLUE = 3,
GIMP_HISTOGRAM_ALPHA = 4
} GimpHistogramChannel;
#endif /* __BASE_ENUMS_H__ */

32
app/base/base-types.h
View File

@ -39,37 +39,7 @@
#define ALPHA_I_PIX 1
/* enums */
/* Types of convolutions */
typedef enum
{
GIMP_NORMAL_CONVOL, /* Negative numbers truncated */
GIMP_ABSOLUTE_CONVOL, /* Absolute value */
GIMP_NEGATIVE_CONVOL /* add 127 to values */
} GimpConvolutionType;
typedef enum
{
GIMP_VALUE_LUT,
GIMP_RED_LUT,
GIMP_GREEN_LUT,
GIMP_BLUE_LUT,
GIMP_ALPHA_LUT,
GIMP_GRAY_LUT = 0 /*< skip >*/
} GimpChannelLutType;
typedef enum /*< pdb-skip >*/
{
GIMP_HISTOGRAM_VALUE = 0,
GIMP_HISTOGRAM_RED = 1,
GIMP_HISTOGRAM_GREEN = 2,
GIMP_HISTOGRAM_BLUE = 3,
GIMP_HISTOGRAM_ALPHA = 4
} GimpHistogramChannel;
/* types */
/* types */
typedef struct _BoundSeg BoundSeg;

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

@ -19,8 +19,22 @@
#ifndef __CORE_ENUMS_H__
#define __CORE_ENUMS_H__
/* These enums that are registered with the type system. */
#if 0
This file is parsed by two scripts, enumgen.pl in tools/pdbgen
and glib-mkenums. All enums that are not marked with /*< pdb-skip >*/
are exported to libgimp and the PDB. Enums that are not marked with
/*< skip >*/ are registered with the GType system. If you want the
enum to be skipped by both scripts, you have to use /*< pdb-skip >*/
_before_ /*< skip >*/.
All enum values that are marked with /*< skip >*/ are skipped for
both targets.
#endif
/*
* these enums that are registered with the type system
*/
#define GIMP_TYPE_IMAGE_BASE_TYPE (gimp_image_base_type_get_type ())
@ -38,7 +52,7 @@ typedef enum
GType gimp_preview_size_get_type (void) G_GNUC_CONST;
typedef enum /*< pdb-skip >*/
typedef enum /*< pdb-skip >*/
{
GIMP_PREVIEW_SIZE_NONE = 0,
GIMP_PREVIEW_SIZE_TINY = 16,
@ -52,4 +66,42 @@ typedef enum /*< pdb-skip >*/
GIMP_PREVIEW_SIZE_GIGANTIC = 256
} GimpPreviewSize;
/*
* non-registered enums; register them if needed
*/
typedef enum /*< skip >*/
{
GIMP_RGB_IMAGE,
GIMP_RGBA_IMAGE,
GIMP_GRAY_IMAGE,
GIMP_GRAYA_IMAGE,
GIMP_INDEXED_IMAGE,
GIMP_INDEXEDA_IMAGE
} GimpImageType;
typedef enum /*< pdb-skip >*/ /*< skip >*/
{
GIMP_SELECTION_OFF,
GIMP_SELECTION_LAYER_OFF,
GIMP_SELECTION_ON,
GIMP_SELECTION_PAUSE,
GIMP_SELECTION_RESUME
} GimpSelectionControl;
typedef enum /*< skip >*/
{
GIMP_SHADOWS,
GIMP_MIDTONES,
GIMP_HIGHLIGHTS
} GimpTransferMode;
typedef enum /*< pdb-skip >*/ /*< skip >*/
{
GIMP_TRANSFORM_FORWARD,
GIMP_TRANSFORM_BACKWARD
} GimpTransformDirection;
#endif /* __CORE_TYPES_H__ */

32
app/core/core-types.h
View File

@ -34,16 +34,6 @@
/* enums */
typedef enum
{
RGB_GIMAGE, /*< nick=RGB_IMAGE >*/
RGBA_GIMAGE, /*< nick=RGBA_IMAGE >*/
GRAY_GIMAGE, /*< nick=GRAY_IMAGE >*/
GRAYA_GIMAGE, /*< nick=GRAYA_IMAGE >*/
INDEXED_GIMAGE, /*< nick=INDEXED_IMAGE >*/
INDEXEDA_GIMAGE /*< nick=INDEXEDA_IMAGE >*/
} GimpImageType;
typedef enum
{
RED_CHANNEL,
@ -92,15 +82,6 @@ typedef enum /*< chop=CHANNEL_OP_ >*/
CHANNEL_OP_INTERSECT
} ChannelOps;
typedef enum /*< pdb-skip >*/
{
GIMP_SELECTION_OFF,
GIMP_SELECTION_LAYER_OFF,
GIMP_SELECTION_ON,
GIMP_SELECTION_PAUSE,
GIMP_SELECTION_RESUME
} GimpSelectionControl;
typedef enum
{
FOREGROUND_FILL, /*< nick=FG_IMAGE_FILL >*/
@ -110,13 +91,6 @@ typedef enum
NO_FILL /*< nick=NO_IMAGE_FILL >*/
} GimpFillType;
typedef enum
{
GIMP_SHADOWS,
GIMP_MIDTONES,
GIMP_HIGHLIGHTS
} GimpTransferMode;
typedef enum
{
OFFSET_BACKGROUND,
@ -203,12 +177,6 @@ typedef enum
REPEAT_TRIANGULAR
} RepeatMode;
typedef enum /*< pdb-skip >*/
{
GIMP_TRANSFORM_FORWARD,
GIMP_TRANSFORM_BACKWARD
} GimpTransformDirection;
/* base objects */

6
app/core/gimp-transform-region.c
View File

@ -132,15 +132,15 @@ gimp_drawable_transform_tiles_affine (GimpDrawable *drawable,
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
bg_col[ALPHA_PIX] = TRANSPARENT_OPACITY;
alpha = ALPHA_PIX;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
bg_col[ALPHA_G_PIX] = TRANSPARENT_OPACITY;
alpha = ALPHA_G_PIX;
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
bg_col[ALPHA_I_PIX] = TRANSPARENT_OPACITY;
alpha = ALPHA_I_PIX;
/* If the gimage is indexed color, ignore smoothing value */

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

@ -168,7 +168,7 @@ gimp_channel_new (GimpImage *gimage,
channel = g_object_new (GIMP_TYPE_CHANNEL, NULL);
gimp_drawable_configure (GIMP_DRAWABLE (channel),
gimage, width, height, GRAY_GIMAGE, name);
gimage, width, height, GIMP_GRAY_IMAGE, name);
/* set the channel color and opacity */
channel->color = *color;

2
app/core/gimpchannel.c
View File

@ -168,7 +168,7 @@ gimp_channel_new (GimpImage *gimage,
channel = g_object_new (GIMP_TYPE_CHANNEL, NULL);
gimp_drawable_configure (GIMP_DRAWABLE (channel),
gimage, width, height, GRAY_GIMAGE, name);
gimage, width, height, GIMP_GRAY_IMAGE, name);
/* set the channel color and opacity */
channel->color = *color;

8
app/core/gimpdrawable-preview.c
View File

@ -116,17 +116,17 @@ gimp_drawable_preview_private (GimpDrawable *drawable,
{
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
type = GIMP_RGB;
bytes = gimp_drawable_bytes (drawable);
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
type = GIMP_GRAY;
bytes = gimp_drawable_bytes (drawable);
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
type = GIMP_INDEXED;
bytes = (gimp_drawable_type (drawable) == INDEXED_GIMAGE) ? 3 : 4;
bytes = (gimp_drawable_type (drawable) == GIMP_INDEXED_IMAGE) ? 3 : 4;
break;
}

6
app/core/gimpdrawable-transform.c
View File

@ -132,15 +132,15 @@ gimp_drawable_transform_tiles_affine (GimpDrawable *drawable,
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
bg_col[ALPHA_PIX] = TRANSPARENT_OPACITY;
alpha = ALPHA_PIX;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
bg_col[ALPHA_G_PIX] = TRANSPARENT_OPACITY;
alpha = ALPHA_G_PIX;
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
bg_col[ALPHA_I_PIX] = TRANSPARENT_OPACITY;
alpha = ALPHA_I_PIX;
/* If the gimage is indexed color, ignore smoothing value */

48
app/core/gimpdrawable.c
View File

@ -348,17 +348,17 @@ gimp_drawable_configure (GimpDrawable *drawable,
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
bpp = 3; alpha = FALSE; break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
bpp = 1; alpha = FALSE; break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
bpp = 4; alpha = TRUE; break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
bpp = 2; alpha = TRUE; break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
bpp = 1; alpha = FALSE; break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
bpp = 2; alpha = TRUE; break;
default:
g_warning ("%s: Layer type %d not supported.",
@ -522,34 +522,34 @@ gimp_drawable_fill (GimpDrawable *drawable,
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
gimp_rgba_get_uchar (color,
&c[RED_PIX],
&c[GREEN_PIX],
&c[BLUE_PIX],
&c[ALPHA_PIX]);
if (gimp_drawable_type (drawable) != RGBA_GIMAGE)
if (gimp_drawable_type (drawable) != GIMP_RGBA_IMAGE)
c[ALPHA_PIX] = 255;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
gimp_rgba_get_uchar (color,
&c[GRAY_PIX],
NULL,
NULL,
&c[ALPHA_G_PIX]);
if (gimp_drawable_type (drawable) != GRAYA_GIMAGE)
if (gimp_drawable_type (drawable) != GIMP_GRAYA_IMAGE)
c[ALPHA_G_PIX] = 255;
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
gimp_rgb_get_uchar (color,
&c[RED_PIX],
&c[GREEN_PIX],
&c[BLUE_PIX]);
gimp_image_transform_color (gimage, drawable, c, &i, GIMP_RGB);
c[INDEXED_PIX] = i;
if (gimp_drawable_type (drawable) == INDEXEDA_GIMAGE)
if (gimp_drawable_type (drawable) == GIMP_INDEXEDA_IMAGE)
gimp_rgba_get_uchar (color,
NULL,
NULL,
@ -697,14 +697,14 @@ gimp_drawable_type_with_alpha (const GimpDrawable *drawable)
{
switch (type)
{
case RGB_GIMAGE:
return RGBA_GIMAGE;
case GIMP_RGB_IMAGE:
return GIMP_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
return GRAYA_GIMAGE;
case GIMP_GRAY_IMAGE:
return GIMP_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
return INDEXEDA_GIMAGE;
case GIMP_INDEXED_IMAGE:
return GIMP_INDEXEDA_IMAGE;
break;
default:
g_assert_not_reached ();
@ -908,8 +908,8 @@ gimp_drawable_is_rgb (const GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
if (gimp_drawable_type (drawable) == RGBA_GIMAGE ||
gimp_drawable_type (drawable) == RGB_GIMAGE)
if (gimp_drawable_type (drawable) == GIMP_RGBA_IMAGE ||
gimp_drawable_type (drawable) == GIMP_RGB_IMAGE)
return TRUE;
else
return FALSE;
@ -920,8 +920,8 @@ gimp_drawable_is_gray (const GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
if (gimp_drawable_type (drawable) == GRAYA_GIMAGE ||
gimp_drawable_type (drawable) == GRAY_GIMAGE)
if (gimp_drawable_type (drawable) == GIMP_GRAYA_IMAGE ||
gimp_drawable_type (drawable) == GIMP_GRAY_IMAGE)
return TRUE;
else
return FALSE;
@ -932,8 +932,8 @@ gimp_drawable_is_indexed (const GimpDrawable *drawable)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
if (gimp_drawable_type (drawable) == INDEXEDA_GIMAGE ||
gimp_drawable_type (drawable) == INDEXED_GIMAGE)
if (gimp_drawable_type (drawable) == GIMP_INDEXEDA_IMAGE ||
gimp_drawable_type (drawable) == GIMP_INDEXED_IMAGE)
return TRUE;
else
return FALSE;

14
app/core/gimpimage-contiguous-region.c
View File

@ -102,9 +102,9 @@ gimp_image_contiguous_region_by_seed (GimpImage *gimage,
pixel_region_init (&srcPR, gimp_image_projection (gimage), 0, 0,
gimage->width, gimage->height, FALSE);
type = gimp_image_projection_type (gimage);
has_alpha = (type == RGBA_GIMAGE ||
type == GRAYA_GIMAGE ||
type == INDEXEDA_GIMAGE);
has_alpha = (type == GIMP_RGBA_IMAGE ||
type == GIMP_GRAYA_IMAGE ||
type == GIMP_INDEXEDA_IMAGE);
}
else
{
@ -181,10 +181,10 @@ gimp_image_contiguous_region_by_color (GimpImage *gimage,
{
bytes = gimp_image_projection_bytes (gimage);
d_type = gimp_image_projection_type (gimage);
has_alpha = (d_type == RGBA_GIMAGE ||
d_type == GRAYA_GIMAGE ||
d_type == INDEXEDA_GIMAGE);
indexed = d_type == INDEXEDA_GIMAGE || d_type == INDEXED_GIMAGE;
has_alpha = (d_type == GIMP_RGBA_IMAGE ||
d_type == GIMP_GRAYA_IMAGE ||
d_type == GIMP_INDEXEDA_IMAGE);
indexed = d_type == GIMP_INDEXEDA_IMAGE || d_type == GIMP_INDEXED_IMAGE;
width = gimage->width;
height = gimage->height;
pixel_region_init (&imagePR, gimp_image_projection (gimage),

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

@ -688,7 +688,7 @@ gimp_image_convert (GimpImage *gimage,
g_return_if_fail (GIMP_IS_IMAGE (gimage));
quantobj = NULL;
new_layer_type = RGBA_GIMAGE;
new_layer_type = GIMP_RGBA_IMAGE;
new_layer_bytes = 4;
theCustomPalette = custom_palette;
@ -816,15 +816,15 @@ gimp_image_convert (GimpImage *gimage,
switch (new_type)
{
case GIMP_RGB:
new_layer_type = (has_alpha) ? RGBA_GIMAGE : RGB_GIMAGE;
new_layer_type = (has_alpha) ? GIMP_RGBA_IMAGE : GIMP_RGB_IMAGE;
new_layer_bytes = (has_alpha) ? 4 : 3;
break;
case GIMP_GRAY:
new_layer_type = (has_alpha) ? GRAYA_GIMAGE : GRAY_GIMAGE;
new_layer_type = (has_alpha) ? GIMP_GRAYA_IMAGE : GIMP_GRAY_IMAGE;
new_layer_bytes = (has_alpha) ? 2 : 1;
break;
case GIMP_INDEXED:
new_layer_type = (has_alpha) ? INDEXEDA_GIMAGE : INDEXED_GIMAGE;
new_layer_type = (has_alpha) ? GIMP_INDEXEDA_IMAGE : GIMP_INDEXED_IMAGE;
new_layer_bytes = (has_alpha) ? 2 : 1;
break;
default:

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

@ -238,15 +238,15 @@ gimp_image_mask_extract (GimpImage *gimage,
/* How many bytes in the temp buffer? */
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
bytes = add_alpha ? 4 : drawable->bytes;
type = GIMP_RGB;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
bytes = add_alpha ? 2 : drawable->bytes;
type = GIMP_GRAY;
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
if (keep_indexed)
{
bytes = add_alpha ? 2 : drawable->bytes;

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

@ -224,7 +224,7 @@ gimp_image_merge_layers (GimpImage *gimage,
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
layer = NULL;
type = RGBA_GIMAGE;
type = GIMP_RGBA_IMAGE;
x1 = y1 = 0;
x2 = y2 = 0;
bottom_layer = NULL;
@ -303,13 +303,13 @@ gimp_image_merge_layers (GimpImage *gimage,
name = g_strdup (gimp_object_get_name (GIMP_OBJECT (layer)));
if (merge_type == FLATTEN_IMAGE ||
gimp_drawable_type (GIMP_DRAWABLE (layer)) == INDEXED_GIMAGE)
gimp_drawable_type (GIMP_DRAWABLE (layer)) == GIMP_INDEXED_IMAGE)
{
switch (gimp_image_base_type (gimage))
{
case GIMP_RGB: type = RGB_GIMAGE; break;
case GIMP_GRAY: type = GRAY_GIMAGE; break;
case GIMP_INDEXED: type = INDEXED_GIMAGE; break;
case GIMP_RGB: type = GIMP_RGB_IMAGE; break;
case GIMP_GRAY: type = GIMP_GRAY_IMAGE; break;
case GIMP_INDEXED: type = GIMP_INDEXED_IMAGE; break;
}
merge_layer = gimp_layer_new (gimage, (x2 - x1), (y2 - y1),

6
app/core/gimpimage-new.c
View File

@ -241,13 +241,13 @@ gimp_image_new_create_image (Gimp *gimp,
case FOREGROUND_FILL:
case BACKGROUND_FILL:
case WHITE_FILL:
type = (values->type == GIMP_RGB) ? RGB_GIMAGE : GRAY_GIMAGE;
type = (values->type == GIMP_RGB) ? GIMP_RGB_IMAGE : GIMP_GRAY_IMAGE;
break;
case TRANSPARENT_FILL:
type = (values->type == GIMP_RGB) ? RGBA_GIMAGE : GRAYA_GIMAGE;
type = (values->type == GIMP_RGB) ? GIMP_RGBA_IMAGE : GIMP_GRAYA_IMAGE;
break;
default:
type = RGB_GIMAGE;
type = GIMP_RGB_IMAGE;
break;
}

24
app/core/gimpimage-pick-color.c
View File

@ -305,7 +305,7 @@ gimp_color_picker_tool_button_press (GimpTool *tool,
/* if the gdisplay is for a color image, the dialog must have RGB */
switch (gimp_drawable_type (tool->drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
info_dialog_add_label (gimp_color_picker_tool_info, _("Red:"), red_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Green:"), green_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Blue:"), blue_buf);
@ -313,7 +313,7 @@ gimp_color_picker_tool_button_press (GimpTool *tool,
info_dialog_add_label (gimp_color_picker_tool_info, _("Hex Triplet:"), hex_buf);
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
info_dialog_add_label (gimp_color_picker_tool_info, _("Index:"), index_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Red:"), red_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Green:"), green_buf);
@ -322,7 +322,7 @@ gimp_color_picker_tool_button_press (GimpTool *tool,
info_dialog_add_label (gimp_color_picker_tool_info, _("Hex Triplet"), hex_buf);
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
info_dialog_add_label (gimp_color_picker_tool_info, _("Intensity:"), gray_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Alpha:"), alpha_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Hex Triplet:"), hex_buf);
@ -698,12 +698,12 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
switch (sample_type)
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
g_snprintf (index_buf, MAX_INFO_BUF, _("N/A"));
g_snprintf (red_buf, MAX_INFO_BUF, "%d", col_value [RED_PIX]);
g_snprintf (green_buf, MAX_INFO_BUF, "%d", col_value [GREEN_PIX]);
g_snprintf (blue_buf, MAX_INFO_BUF, "%d", col_value [BLUE_PIX]);
if (sample_type == RGBA_GIMAGE)
if (sample_type == GIMP_RGBA_IMAGE)
g_snprintf (alpha_buf, MAX_INFO_BUF, "%d", col_value [ALPHA_PIX]);
else
g_snprintf (alpha_buf, MAX_INFO_BUF, _("N/A"));
@ -715,16 +715,16 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
r = col_value [RED_PIX];
g = col_value [GREEN_PIX];
b = col_value [BLUE_PIX];
if (sample_type == RGBA_GIMAGE)
if (sample_type == GIMP_RGBA_IMAGE)
a = col_value [ALPHA_PIX];
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
g_snprintf (index_buf, MAX_INFO_BUF, "%d", col_value [4]);
g_snprintf (red_buf, MAX_INFO_BUF, "%d", col_value [RED_PIX]);
g_snprintf (green_buf, MAX_INFO_BUF, "%d", col_value [GREEN_PIX]);
g_snprintf (blue_buf, MAX_INFO_BUF, "%d", col_value [BLUE_PIX]);
if (sample_type == INDEXEDA_GIMAGE)
if (sample_type == GIMP_INDEXEDA_IMAGE)
g_snprintf (alpha_buf, MAX_INFO_BUF, "%d", col_value [ALPHA_PIX]);
else
g_snprintf (alpha_buf, MAX_INFO_BUF, _("N/A"));
@ -736,13 +736,13 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
r = col_value [RED_PIX];
g = col_value [GREEN_PIX];
b = col_value [BLUE_PIX];
if (sample_type == INDEXEDA_GIMAGE)
if (sample_type == GIMP_INDEXEDA_IMAGE)
a = col_value [ALPHA_PIX];
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
g_snprintf (gray_buf, MAX_INFO_BUF, "%d", col_value [GRAY_PIX]);
if (sample_type == GRAYA_GIMAGE)
if (sample_type == GIMP_GRAYA_IMAGE)
g_snprintf (alpha_buf, MAX_INFO_BUF, "%d", col_value [ALPHA_PIX]);
else
g_snprintf (alpha_buf, MAX_INFO_BUF, _("N/A"));
@ -754,7 +754,7 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
r = col_value [GRAY_PIX];
g = col_value [GRAY_PIX];
b = col_value [GRAY_PIX];
if (sample_type == GRAYA_GIMAGE)
if (sample_type == GIMP_GRAYA_IMAGE)
a = col_value [ALPHA_PIX];
break;
}

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

@ -107,11 +107,11 @@ gimp_image_projection_allocate (GimpImage *gimage)
case GIMP_RGB:
case GIMP_INDEXED:
gimage->proj_bytes = 4;
gimage->proj_type = RGBA_GIMAGE;
gimage->proj_type = GIMP_RGBA_IMAGE;
break;
case GIMP_GRAY:
gimage->proj_bytes = 2;
gimage->proj_type = GRAYA_GIMAGE;
gimage->proj_type = GIMP_GRAYA_IMAGE;
break;
default:
g_assert_not_reached ();
@ -439,21 +439,21 @@ gimp_image_construct_layers (GimpImage *gimage,
*/
switch (gimp_drawable_type (GIMP_DRAWABLE (layer)))
{
case RGB_GIMAGE: case GRAY_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_GRAY_IMAGE:
/* no mask possible */
project_intensity (gimage, layer, &src2PR, &src1PR, mask);
break;
case RGBA_GIMAGE: case GRAYA_GIMAGE:
case GIMP_RGBA_IMAGE: case GIMP_GRAYA_IMAGE:
project_intensity_alpha (gimage, layer, &src2PR, &src1PR, mask);
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
/* no mask possible */
project_indexed (gimage, layer, &src2PR, &src1PR);
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
project_indexed_alpha (gimage, layer, &src2PR, &src1PR, mask);
break;

44
app/core/gimpimage.c
View File

@ -114,17 +114,17 @@ static void gimp_image_real_colormap_changed (GimpImage *gimage,
static gint valid_combinations[][MAX_CHANNELS + 1] =
{
/* RGB GIMAGE */
/* GIMP_RGB_IMAGE */
{ -1, -1, -1, COMBINE_INTEN_INTEN, COMBINE_INTEN_INTEN_A },
/* RGBA GIMAGE */
/* GIMP_RGBA_IMAGE */
{ -1, -1, -1, COMBINE_INTEN_A_INTEN, COMBINE_INTEN_A_INTEN_A },
/* GRAY GIMAGE */
/* GIMP_GRAY_IMAGE */
{ -1, COMBINE_INTEN_INTEN, COMBINE_INTEN_INTEN_A, -1, -1 },
/* GRAYA GIMAGE */
/* GIMP_GRAYA_IMAGE */
{ -1, COMBINE_INTEN_A_INTEN, COMBINE_INTEN_A_INTEN_A, -1, -1 },
/* INDEXED GIMAGE */
/* GIMP_INDEXED_IMAGE */
{ -1, COMBINE_INDEXED_INDEXED, COMBINE_INDEXED_INDEXED_A, -1, -1 },
/* INDEXEDA GIMAGE */
/* GIMP_INDEXEDA_IMAGE */
{ -1, -1, COMBINE_INDEXED_A_INDEXED_A, -1, -1 },
};
@ -408,7 +408,7 @@ gimp_image_init (GimpImage *gimage)
gimage->shadow = NULL;
gimage->construct_flag = FALSE;
gimage->proj_type = RGBA_GIMAGE;
gimage->proj_type = GIMP_RGBA_IMAGE;
gimage->projection = NULL;
gimage->guides = NULL;
@ -765,7 +765,7 @@ gimp_image_get_new_preview (GimpViewable *viewable,
*/
switch (gimp_drawable_type (GIMP_DRAWABLE (layer)))
{
case RGB_GIMAGE: case GRAY_GIMAGE: case INDEXED_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_GRAY_IMAGE: case GIMP_INDEXED_IMAGE:
if (! construct_flag)
initial_region (&src2PR, &src1PR,
mask, NULL, layer->opacity,
@ -776,7 +776,7 @@ gimp_image_get_new_preview (GimpViewable *viewable,
layer->mode, visible, COMBINE_INTEN_A_INTEN);
break;
case RGBA_GIMAGE: case GRAYA_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_RGBA_IMAGE: case GIMP_GRAYA_IMAGE: case GIMP_INDEXEDA_IMAGE:
if (! construct_flag)
initial_region (&src2PR, &src1PR,
mask, NULL, layer->opacity,
@ -888,14 +888,14 @@ gimp_image_base_type_with_alpha (const GimpImage *gimage)
switch (gimage->base_type)
{
case GIMP_RGB:
return RGBA_GIMAGE;
return GIMP_RGBA_IMAGE;
case GIMP_GRAY:
return GRAYA_GIMAGE;
return GIMP_GRAYA_IMAGE;
case GIMP_INDEXED:
return INDEXEDA_GIMAGE;
return GIMP_INDEXEDA_IMAGE;
}
return RGB_GIMAGE;
return GIMP_RGB_IMAGE;
}
CombinationMode
@ -1531,13 +1531,13 @@ gimp_image_get_color (const GimpImage *gimage,
switch (d_type)
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
map_to_color (0, NULL, src, rgb);
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
map_to_color (1, NULL, src, rgb);
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
map_to_color (2, gimage->cmap, src, rgb);
break;
}
@ -1562,19 +1562,19 @@ gimp_image_transform_color (const GimpImage *gimage,
case GIMP_RGB:
switch (d_type)
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
/* Straight copy */
*dest++ = *src++;
*dest++ = *src++;
*dest++ = *src++;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
/* NTSC conversion */
*dest = INTENSITY (src[RED_PIX],
src[GREEN_PIX],
src[BLUE_PIX]);
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
/* Least squares method */
*dest = gimp_image_color_hash_rgb_to_indexed (gimage,
src[RED_PIX],
@ -1587,17 +1587,17 @@ gimp_image_transform_color (const GimpImage *gimage,
case GIMP_GRAY:
switch (d_type)
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
/* Gray to RG&B */
*dest++ = *src;
*dest++ = *src;
*dest++ = *src;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
/* Straight copy */
*dest = *src;
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
/* Least squares method */
*dest = gimp_image_color_hash_rgb_to_indexed (gimage,
src[GRAY_PIX],

6
app/core/gimpimage.h
View File

@ -25,9 +25,9 @@
#define COLORMAP_SIZE 768
#define GIMP_IMAGE_TYPE_HAS_ALPHA(t) ((t) == RGBA_GIMAGE || \
(t) == GRAYA_GIMAGE || \
(t) == INDEXEDA_GIMAGE)
#define GIMP_IMAGE_TYPE_HAS_ALPHA(t) ((t) == GIMP_RGBA_IMAGE || \
(t) == GIMP_GRAYA_IMAGE || \
(t) == GIMP_INDEXEDA_IMAGE)
struct _GimpGuide

38
app/core/gimplayer.c
View File

@ -341,14 +341,14 @@ gimp_layer_copy (GimpLayer *layer,
{
switch (GIMP_DRAWABLE (layer)->type)
{
case RGB_GIMAGE:
new_type = RGBA_GIMAGE;
case GIMP_RGB_IMAGE:
new_type = GIMP_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
new_type = GRAYA_GIMAGE;
case GIMP_GRAY_IMAGE:
new_type = GIMP_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
new_type = INDEXEDA_GIMAGE;
case GIMP_INDEXED_IMAGE:
new_type = GIMP_INDEXEDA_IMAGE;
break;
default:
new_type = GIMP_DRAWABLE (layer)->type;
@ -483,9 +483,9 @@ gimp_layer_new_from_tiles (GimpImage *gimage,
FALSE);
if ((tile_manager_bpp (tiles) == 4 &&
GIMP_DRAWABLE (new_layer)->type == RGBA_GIMAGE) ||
GIMP_DRAWABLE (new_layer)->type == GIMP_RGBA_IMAGE) ||
(tile_manager_bpp (tiles) == 2 &&
GIMP_DRAWABLE (new_layer)->type == GRAYA_GIMAGE))
GIMP_DRAWABLE (new_layer)->type == GIMP_GRAYA_IMAGE))
/* If we want a layer the same type as the buffer */
copy_region (&bufPR, &layerPR);
else
@ -805,18 +805,18 @@ gimp_layer_add_alpha (GimpLayer *layer)
/* Don't bother if the layer already has alpha */
switch (GIMP_DRAWABLE (layer)->type)
{
case RGB_GIMAGE:
type = RGBA_GIMAGE;
case GIMP_RGB_IMAGE:
type = GIMP_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
type = GRAYA_GIMAGE;
case GIMP_GRAY_IMAGE:
type = GIMP_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
type = INDEXEDA_GIMAGE;
case GIMP_INDEXED_IMAGE:
type = GIMP_INDEXEDA_IMAGE;
break;
case RGBA_GIMAGE:
case GRAYA_GIMAGE:
case INDEXEDA_GIMAGE:
case GIMP_RGBA_IMAGE:
case GIMP_GRAYA_IMAGE:
case GIMP_INDEXEDA_IMAGE:
default:
return;
break;
@ -896,8 +896,8 @@ gimp_layer_scale_lowlevel (GimpLayer *layer,
* resampling because that doesn't necessarily make sense for INDEXED
* images.
*/
if ((GIMP_DRAWABLE (layer)->type == INDEXED_GIMAGE) ||
(GIMP_DRAWABLE (layer)->type == INDEXEDA_GIMAGE))
if ((GIMP_DRAWABLE (layer)->type == GIMP_INDEXED_IMAGE) ||
(GIMP_DRAWABLE (layer)->type == GIMP_INDEXEDA_IMAGE))
scale_region_no_resample (&srcPR, &destPR);
else
scale_region (&srcPR, &destPR);

2
app/core/gimplayermask.c
View File

@ -139,7 +139,7 @@ gimp_layer_mask_new (GimpImage *gimage,
layer_mask = g_object_new (GIMP_TYPE_LAYER_MASK, NULL);
gimp_drawable_configure (GIMP_DRAWABLE (layer_mask),
gimage, width, height, GRAY_GIMAGE, name);
gimage, width, height, GIMP_GRAY_IMAGE, name);
/* set the layer_mask color and opacity */
GIMP_CHANNEL (layer_mask)->color = *color;

2
app/core/gimppalette-import.c
View File

@ -281,7 +281,7 @@ gimp_palette_import_from_image (GimpImage *gimage,
bytes = gimp_image_projection_bytes (gimage);
d_type = gimp_image_projection_type (gimage);
has_alpha = GIMP_IMAGE_TYPE_HAS_ALPHA (d_type);
indexed = d_type == INDEXEDA_GIMAGE || d_type == INDEXED_GIMAGE;
indexed = d_type == GIMP_INDEXEDA_IMAGE || d_type == GIMP_INDEXED_IMAGE;
width = gimage->width;
height = gimage->height;

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

@ -107,11 +107,11 @@ gimp_image_projection_allocate (GimpImage *gimage)
case GIMP_RGB:
case GIMP_INDEXED:
gimage->proj_bytes = 4;
gimage->proj_type = RGBA_GIMAGE;
gimage->proj_type = GIMP_RGBA_IMAGE;
break;
case GIMP_GRAY:
gimage->proj_bytes = 2;
gimage->proj_type = GRAYA_GIMAGE;
gimage->proj_type = GIMP_GRAYA_IMAGE;
break;
default:
g_assert_not_reached ();
@ -439,21 +439,21 @@ gimp_image_construct_layers (GimpImage *gimage,
*/
switch (gimp_drawable_type (GIMP_DRAWABLE (layer)))
{
case RGB_GIMAGE: case GRAY_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_GRAY_IMAGE:
/* no mask possible */
project_intensity (gimage, layer, &src2PR, &src1PR, mask);
break;
case RGBA_GIMAGE: case GRAYA_GIMAGE:
case GIMP_RGBA_IMAGE: case GIMP_GRAYA_IMAGE:
project_intensity_alpha (gimage, layer, &src2PR, &src1PR, mask);
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
/* no mask possible */
project_indexed (gimage, layer, &src2PR, &src1PR);
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
project_indexed_alpha (gimage, layer, &src2PR, &src1PR, mask);
break;

24
app/dialogs/file-save-dialog.c
View File

@ -174,22 +174,22 @@ file_save_dialog_show (GimpImage *gimage)
switch (gimp_drawable_type (gimp_image_active_drawable (gimage)))
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGB_IMAGE);
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGBA_IMAGE);
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAY_IMAGE);
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAYA_IMAGE);
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXED_IMAGE);
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXEDA_IMAGE);
break;
}
@ -229,22 +229,22 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
switch (gimp_drawable_type (gimp_image_active_drawable (gimage)))
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGB_IMAGE);
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGBA_IMAGE);
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAY_IMAGE);
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAYA_IMAGE);
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXED_IMAGE);
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXEDA_IMAGE);
break;
}

6
app/display/gimpdisplayshell-dnd.c
View File

@ -81,13 +81,13 @@ gimp_display_shell_drop_drawable (GtkWidget *widget,
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
bytes = 4; type = GIMP_RGB;
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
bytes = 2; type = GIMP_GRAY;
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
bytes = 4; type = GIMP_INDEXED;
break;
default:

8
app/display/gimpdisplayshell-render.c
View File

@ -258,7 +258,7 @@ gimp_display_shell_render (GimpDisplayShell *shell,
/* Currently, only RGBA and GRAYA projection types are used - the rest
* are in case of future need. -- austin, 28th Nov 1998.
*/
if (image_type != RGBA_GIMAGE && image_type != GRAYA_GIMAGE)
if (image_type != GIMP_RGBA_IMAGE && image_type != GIMP_GRAYA_IMAGE)
g_warning ("using untested projection type %d", image_type);
(* render_funcs[image_type]) (&info);
@ -794,9 +794,9 @@ render_image_init_info (RenderInfo *info,
switch (gimp_image_projection_type (shell->gdisp->gimage))
{
case RGBA_GIMAGE:
case GRAYA_GIMAGE:
case INDEXEDA_GIMAGE:
case GIMP_RGBA_IMAGE:
case GIMP_GRAYA_IMAGE:
case GIMP_INDEXEDA_IMAGE:
info->alpha =
render_image_init_alpha (gimp_image_projection_opacity (shell->gdisp->gimage));
break;

24
app/gui/file-save-dialog.c
View File

@ -174,22 +174,22 @@ file_save_dialog_show (GimpImage *gimage)
switch (gimp_drawable_type (gimp_image_active_drawable (gimage)))
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGB_IMAGE);
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGBA_IMAGE);
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAY_IMAGE);
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAYA_IMAGE);
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXED_IMAGE);
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXEDA_IMAGE);
break;
}
@ -229,22 +229,22 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
switch (gimp_drawable_type (gimp_image_active_drawable (gimage)))
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGB_IMAGE);
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_RGBA_IMAGE);
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAY_IMAGE);
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_GRAYA_IMAGE);
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXED_IMAGE);
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
file_dialog_update_menus (gimage->gimp->save_procs, PLUG_IN_INDEXEDA_IMAGE);
break;
}

12
app/gui/plug-in-commands.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/gui/plug-in-menus.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

6
app/gui/toolbox.c
View File

@ -479,11 +479,11 @@ toolbox_drop_drawable (GtkWidget *widget,
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
type = GIMP_RGB; break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
type = GIMP_GRAY; break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
type = GIMP_INDEXED; break;
default:
type = GIMP_RGB; break;

12
app/menus/plug-in-menus.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

4
app/paint/gimpdodgeburn.c
View File

@ -375,8 +375,8 @@ gimp_dodgeburn_tool_motion (GimpPaintTool *paint_tool,
return;
/* If the image type is indexed, don't dodgeburn */
if ((gimp_drawable_type (drawable) == INDEXED_GIMAGE) ||
(gimp_drawable_type (drawable) == INDEXEDA_GIMAGE))
if ((gimp_drawable_type (drawable) == GIMP_INDEXED_IMAGE) ||
(gimp_drawable_type (drawable) == GIMP_INDEXEDA_IMAGE))
return;
if (pressure_options->size)

4
app/pdb/color_cmds.c
View File

@ -29,13 +29,13 @@
#include "tools/tools-types.h"
#include "procedural_db.h"
#include "base/base-types.h"
#include "base/base-enums.h"
#include "base/gimphistogram.h"
#include "base/gimplut.h"
#include "base/lut-funcs.h"
#include "base/pixel-processor.h"
#include "base/pixel-region.h"
#include "core/core-types.h"
#include "core/core-enums.h"
#include "core/gimpdrawable-desaturate.h"
#include "core/gimpdrawable-equalize.h"
#include "core/gimpdrawable-invert.h"

5
app/pdb/drawable_cmds.c
View File

@ -32,6 +32,7 @@
#include "base/temp-buf.h"
#include "base/tile-manager.h"
#include "base/tile.h"
#include "core/core-enums.h"
#include "core/core-types.h"
#include "core/gimp.h"
#include "core/gimpchannel.h"
@ -450,7 +451,7 @@ static ProcArg drawable_type_outargs[] =
{
GIMP_PDB_INT32,
"type",
"The drawable's type: { RGB_IMAGE (0), RGBA_IMAGE (1), GRAY_IMAGE (2), GRAYA_IMAGE (3), INDEXED_IMAGE (4), INDEXEDA_IMAGE (5) }"
"The drawable's type: { GIMP_RGB_IMAGE (0), GIMP_RGBA_IMAGE (1), GIMP_GRAY_IMAGE (2), GIMP_GRAYA_IMAGE (3), GIMP_INDEXED_IMAGE (4), GIMP_INDEXEDA_IMAGE (5) }"
}
};
@ -558,7 +559,7 @@ static ProcArg drawable_type_with_alpha_outargs[] =
{
GIMP_PDB_INT32,
"type_with_alpha",
"The drawable's type with alpha: { RGBA_IMAGE (1), GRAYA_IMAGE (3), INDEXEDA_IMAGE (5) }"
"The drawable's type with alpha: { GIMP_RGB_IMAGE (0), GIMP_RGBA_IMAGE (1), GIMP_GRAY_IMAGE (2), GIMP_GRAYA_IMAGE (3), GIMP_INDEXED_IMAGE (4), GIMP_INDEXEDA_IMAGE (5) }"
}
};

5
app/pdb/layer_cmds.c
View File

@ -29,6 +29,7 @@
#include "procedural_db.h"
#include "base/base-enums.h"
#include "core/core-enums.h"
#include "core/core-types.h"
#include "core/gimpimage.h"
#include "core/gimplayer.h"
@ -135,7 +136,7 @@ layer_new_invoker (Gimp *gimp,
success = FALSE;
type = args[3].value.pdb_int;
if (type < RGB_GIMAGE || type > INDEXEDA_GIMAGE)
if (type < GIMP_RGB_IMAGE || type > GIMP_INDEXEDA_IMAGE)
success = FALSE;
name = (gchar *) args[4].value.pdb_pointer;
@ -185,7 +186,7 @@ static ProcArg layer_new_inargs[] =
{
GIMP_PDB_INT32,
"type",
"The layer type: { RGB_IMAGE (0), RGBA_IMAGE (1), GRAY_IMAGE (2), GRAYA_IMAGE (3), INDEXED_IMAGE (4), INDEXEDA_IMAGE (5) }"
"The layer type: { GIMP_RGB_IMAGE (0), GIMP_RGBA_IMAGE (1), GIMP_GRAY_IMAGE (2), GIMP_GRAYA_IMAGE (3), GIMP_INDEXED_IMAGE (4), GIMP_INDEXEDA_IMAGE (5) }"
},
{
GIMP_PDB_STRING,

2
app/pdb/paint_tools_cmds.c
View File

@ -30,7 +30,7 @@
#include "procedural_db.h"
#include "base/tile-manager.h"
#include "core/core-types.h"
#include "core/core-enums.h"
#include "core/gimpdrawable.h"
#include "core/gimpimage-mask-select.h"
#include "tools/gimpairbrushtool.h"

12
app/plug-in/gimpplugin-message.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/gimpplugin-progress.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/gimpplugin.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/gimppluginmanager-call.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/gimppluginmanager-run.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/gimppluginmanager.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/gimppluginshm.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in-def.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in-message.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in-params.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in-progress.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in-run.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in-shm.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-in.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

12
app/plug-in/plug-ins.c
View File

@ -1400,22 +1400,22 @@ plug_in_set_menu_sensitivity (GimpImageType type)
{
switch (type)
{
case RGB_GIMAGE:
case GIMP_RGB_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGB_IMAGE;
break;
case RGBA_GIMAGE:
case GIMP_RGBA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_RGBA_IMAGE;
break;
case GRAY_GIMAGE:
case GIMP_GRAY_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAY_IMAGE;
break;
case GRAYA_GIMAGE:
case GIMP_GRAYA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_GRAYA_IMAGE;
break;
case INDEXED_GIMAGE:
case GIMP_INDEXED_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXED_IMAGE;
break;
case INDEXEDA_GIMAGE:
case GIMP_INDEXEDA_IMAGE:
sensitive = proc_def->image_types_val & PLUG_IN_INDEXEDA_IMAGE;
break;
default:

6
app/tools/gimpblendtool.c
View File

@ -240,7 +240,7 @@ gimp_blend_tool_button_press (GimpTool *tool,
switch (gimp_drawable_type (gimp_image_active_drawable (gdisp->gimage)))
{
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
g_message (_("Blend: Invalid for indexed images."));
return;
@ -466,8 +466,8 @@ gimp_blend_tool_cursor_update (GimpTool *tool,
switch (gimp_drawable_type (gimp_image_active_drawable (gdisp->gimage)))
{
case INDEXED_GIMAGE:
case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
gimp_display_shell_install_tool_cursor (shell,
GIMP_BAD_CURSOR,
GIMP_BLEND_TOOL_CURSOR,

24
app/tools/gimpcolorpickertool.c
View File

@ -305,7 +305,7 @@ gimp_color_picker_tool_button_press (GimpTool *tool,
/* if the gdisplay is for a color image, the dialog must have RGB */
switch (gimp_drawable_type (tool->drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
info_dialog_add_label (gimp_color_picker_tool_info, _("Red:"), red_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Green:"), green_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Blue:"), blue_buf);
@ -313,7 +313,7 @@ gimp_color_picker_tool_button_press (GimpTool *tool,
info_dialog_add_label (gimp_color_picker_tool_info, _("Hex Triplet:"), hex_buf);
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
info_dialog_add_label (gimp_color_picker_tool_info, _("Index:"), index_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Red:"), red_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Green:"), green_buf);
@ -322,7 +322,7 @@ gimp_color_picker_tool_button_press (GimpTool *tool,
info_dialog_add_label (gimp_color_picker_tool_info, _("Hex Triplet"), hex_buf);
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
info_dialog_add_label (gimp_color_picker_tool_info, _("Intensity:"), gray_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Alpha:"), alpha_buf);
info_dialog_add_label (gimp_color_picker_tool_info, _("Hex Triplet:"), hex_buf);
@ -698,12 +698,12 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
switch (sample_type)
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
g_snprintf (index_buf, MAX_INFO_BUF, _("N/A"));
g_snprintf (red_buf, MAX_INFO_BUF, "%d", col_value [RED_PIX]);
g_snprintf (green_buf, MAX_INFO_BUF, "%d", col_value [GREEN_PIX]);
g_snprintf (blue_buf, MAX_INFO_BUF, "%d", col_value [BLUE_PIX]);
if (sample_type == RGBA_GIMAGE)
if (sample_type == GIMP_RGBA_IMAGE)
g_snprintf (alpha_buf, MAX_INFO_BUF, "%d", col_value [ALPHA_PIX]);
else
g_snprintf (alpha_buf, MAX_INFO_BUF, _("N/A"));
@ -715,16 +715,16 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
r = col_value [RED_PIX];
g = col_value [GREEN_PIX];
b = col_value [BLUE_PIX];
if (sample_type == RGBA_GIMAGE)
if (sample_type == GIMP_RGBA_IMAGE)
a = col_value [ALPHA_PIX];
break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
g_snprintf (index_buf, MAX_INFO_BUF, "%d", col_value [4]);
g_snprintf (red_buf, MAX_INFO_BUF, "%d", col_value [RED_PIX]);
g_snprintf (green_buf, MAX_INFO_BUF, "%d", col_value [GREEN_PIX]);
g_snprintf (blue_buf, MAX_INFO_BUF, "%d", col_value [BLUE_PIX]);
if (sample_type == INDEXEDA_GIMAGE)
if (sample_type == GIMP_INDEXEDA_IMAGE)
g_snprintf (alpha_buf, MAX_INFO_BUF, "%d", col_value [ALPHA_PIX]);
else
g_snprintf (alpha_buf, MAX_INFO_BUF, _("N/A"));
@ -736,13 +736,13 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
r = col_value [RED_PIX];
g = col_value [GREEN_PIX];
b = col_value [BLUE_PIX];
if (sample_type == INDEXEDA_GIMAGE)
if (sample_type == GIMP_INDEXEDA_IMAGE)
a = col_value [ALPHA_PIX];
break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
g_snprintf (gray_buf, MAX_INFO_BUF, "%d", col_value [GRAY_PIX]);
if (sample_type == GRAYA_GIMAGE)
if (sample_type == GIMP_GRAYA_IMAGE)
g_snprintf (alpha_buf, MAX_INFO_BUF, "%d", col_value [ALPHA_PIX]);
else
g_snprintf (alpha_buf, MAX_INFO_BUF, _("N/A"));
@ -754,7 +754,7 @@ gimp_color_picker_tool_info_update (GimpTool *tool,
r = col_value [GRAY_PIX];
g = col_value [GRAY_PIX];
b = col_value [GRAY_PIX];
if (sample_type == GRAYA_GIMAGE)
if (sample_type == GIMP_GRAYA_IMAGE)
a = col_value [ALPHA_PIX];
break;
}

4
app/tools/gimpdodgeburntool.c
View File

@ -375,8 +375,8 @@ gimp_dodgeburn_tool_motion (GimpPaintTool *paint_tool,
return;
/* If the image type is indexed, don't dodgeburn */
if ((gimp_drawable_type (drawable) == INDEXED_GIMAGE) ||
(gimp_drawable_type (drawable) == INDEXEDA_GIMAGE))
if ((gimp_drawable_type (drawable) == GIMP_INDEXED_IMAGE) ||
(gimp_drawable_type (drawable) == GIMP_INDEXEDA_IMAGE))
return;
if (pressure_options->size)

6
app/widgets/gimptoolbox.c
View File

@ -479,11 +479,11 @@ toolbox_drop_drawable (GtkWidget *widget,
switch (gimp_drawable_type (drawable))
{
case RGB_GIMAGE: case RGBA_GIMAGE:
case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
type = GIMP_RGB; break;
case GRAY_GIMAGE: case GRAYA_GIMAGE:
case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
type = GIMP_GRAY; break;
case INDEXED_GIMAGE: case INDEXEDA_GIMAGE:
case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
type = GIMP_INDEXED; break;
default:
type = GIMP_RGB; break;

1
tools/pdbgen/Makefile.am
View File

@ -54,7 +54,6 @@ enum_headers = \
../../libgimpbase/gimpbasetypes.h \
../../app/paint-funcs/paint-funcs-types.h \
../../app/base/base-enums.h \
../../app/base/base-types.h \
../../app/core/core-types.h \
../../app/core/core-enums.h \
../../app/plug-in/plug-in-types.h \

51
tools/pdbgen/enums.pl
View File

@ -152,7 +152,7 @@ package Gimp::CodeGen::enums;
},
GimpConvolutionType =>
{ contig => 1,
header => 'base/base-types.h',
header => 'base/base-enums.h',
symbols => [ qw(GIMP_NORMAL_CONVOL GIMP_ABSOLUTE_CONVOL
GIMP_NEGATIVE_CONVOL) ],
mapping => { GIMP_NORMAL_CONVOL => '0',
@ -161,7 +161,7 @@ package Gimp::CodeGen::enums;
},
GimpChannelLutType =>
{ contig => 1,
header => 'base/base-types.h',
header => 'base/base-enums.h',
symbols => [ qw(GIMP_VALUE_LUT GIMP_RED_LUT GIMP_GREEN_LUT
GIMP_BLUE_LUT GIMP_ALPHA_LUT) ],
mapping => { GIMP_VALUE_LUT => '0',
@ -170,24 +170,6 @@ package Gimp::CodeGen::enums;
GIMP_BLUE_LUT => '3',
GIMP_ALPHA_LUT => '4' }
},
GimpImageType =>
{ contig => 1,
header => 'core/core-types.h',
symbols => [ qw(RGB_GIMAGE RGBA_GIMAGE GRAY_GIMAGE GRAYA_GIMAGE
INDEXED_GIMAGE INDEXEDA_GIMAGE) ],
mapping => { RGB_GIMAGE => '0',
RGBA_GIMAGE => '1',
GRAY_GIMAGE => '2',
GRAYA_GIMAGE => '3',
INDEXED_GIMAGE => '4',
INDEXEDA_GIMAGE => '5' },
nicks => { RGB_GIMAGE => 'RGB_IMAGE',
RGBA_GIMAGE => 'RGBA_IMAGE',
GRAY_GIMAGE => 'GRAY_IMAGE',
GRAYA_GIMAGE => 'GRAYA_IMAGE',
INDEXED_GIMAGE => 'INDEXED_IMAGE',
INDEXEDA_GIMAGE => 'INDEXEDA_IMAGE' }
},
ChannelType =>
{ contig => 1,
header => 'core/core-types.h',
@ -261,14 +243,6 @@ package Gimp::CodeGen::enums;
TRANSPARENT_FILL => 'TRANS_IMAGE_FILL',
NO_FILL => 'NO_IMAGE_FILL' }
},
GimpTransferMode =>
{ contig => 1,
header => 'core/core-types.h',
symbols => [ qw(GIMP_SHADOWS GIMP_MIDTONES GIMP_HIGHLIGHTS) ],
mapping => { GIMP_SHADOWS => '0',
GIMP_MIDTONES => '1',
GIMP_HIGHLIGHTS => '2' }
},
GimpOffsetType =>
{ contig => 1,
header => 'core/core-types.h',
@ -365,6 +339,27 @@ package Gimp::CodeGen::enums;
GIMP_GRAY => '1',
GIMP_INDEXED => '2' }
},
GimpImageType =>
{ contig => 1,
header => 'core/core-enums.h',
symbols => [ qw(GIMP_RGB_IMAGE GIMP_RGBA_IMAGE GIMP_GRAY_IMAGE
GIMP_GRAYA_IMAGE GIMP_INDEXED_IMAGE
GIMP_INDEXEDA_IMAGE) ],
mapping => { GIMP_RGB_IMAGE => '0',
GIMP_RGBA_IMAGE => '1',
GIMP_GRAY_IMAGE => '2',
GIMP_GRAYA_IMAGE => '3',
GIMP_INDEXED_IMAGE => '4',
GIMP_INDEXEDA_IMAGE => '5' }
},
GimpTransferMode =>
{ contig => 1,
header => 'core/core-enums.h',
symbols => [ qw(GIMP_SHADOWS GIMP_MIDTONES GIMP_HIGHLIGHTS) ],
mapping => { GIMP_SHADOWS => '0',
GIMP_MIDTONES => '1',
GIMP_HIGHLIGHTS => '2' }
},
RunModeType =>
{ contig => 1,
header => 'plug-in/plug-in-types.h',