[gimp] libgimpbase,*: clean up enum values in gimpbaseenums.h
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] libgimpbase,*: clean up enum values in gimpbaseenums.h
- Date: Tue, 29 Apr 2014 19:00:39 +0000 (UTC)
commit 22c222291d9a661a534c966f0dedacbcf447fab7
Author: Michael Natterer <mitch gimp org>
Date: Tue Apr 29 20:55:08 2014 +0200
libgimpbase,*: clean up enum values in gimpbaseenums.h
GIMP_ADD_foo_MASK -> GIMP_ADD_MASK_foo
GIMP_foo_MODE -> GIMP_BLEND_foo
GIMP_foo_CLONE -> GIMP_CLONE_foo
GIMP_foo -> GIMP_DODGE_BURN_TYPE_foo
GIMP_foo -> GIMP_TRANSFER_foo
Add compat values for the old names and compat code to script-fu
and pygimp.
app/actions/layers-commands.c | 4 +-
app/core/gimpdrawable-blend.c | 12 ++--
app/core/gimpdrawable-bucket-fill.c | 16 +++---
app/core/gimplayer.c | 24 ++++----
app/dialogs/layer-add-mask-dialog.c | 2 +-
app/gegl/gimp-gegl-loops.c | 8 +-
app/operations/gimpcolorbalanceconfig.c | 18 ++++--
app/operations/gimpoperationcolorbalance.c | 18 +++---
app/paint/gimpclone.c | 6 +-
app/paint/gimpcloneoptions.c | 2 +-
app/paint/gimpdodgeburnoptions.c | 4 +-
app/paint/gimpperspectiveclone.c | 8 +-
app/pdb/color-cmds.c | 2 +-
app/pdb/drawable-color-cmds.c | 2 +-
app/pdb/edit-cmds.c | 22 ++++----
app/pdb/layer-cmds.c | 4 +-
app/pdb/paint-tools-cmds.c | 6 +-
app/tools/gimpblendtool.c | 2 +-
app/tools/gimpbucketfilloptions.c | 4 +-
app/tools/gimpbucketfilltool.c | 20 +++---
app/tools/gimpcloneoptions-gui.c | 4 +-
app/tools/gimpdodgeburntool.c | 17 +++---
libgimpbase/gimpbaseenums.c | 84 ++++++++++++++--------------
libgimpbase/gimpbaseenums.h | 77 ++++++++++++++++++-------
plug-ins/file-psd/psd-load.c | 12 +++-
plug-ins/gfig/gfig-dialog.c | 12 ++--
plug-ins/pygimp/gimpenumsmodule.c | 53 +++++++++++++++++
plug-ins/script-fu/scheme-wrapper.c | 47 +++++++++++++---
tools/pdbgen/enums.pl | 66 +++++++++++-----------
tools/pdbgen/pdb/edit.pdb | 16 +++---
tools/pdbgen/pdb/layer.pdb | 2 +-
31 files changed, 353 insertions(+), 221 deletions(-)
---
diff --git a/app/actions/layers-commands.c b/app/actions/layers-commands.c
index 8c370cc..90976ac 100644
--- a/app/actions/layers-commands.c
+++ b/app/actions/layers-commands.c
@@ -144,7 +144,7 @@ static gchar *layer_name = NULL;
static GimpUnit layer_resize_unit = GIMP_UNIT_PIXEL;
static GimpUnit layer_scale_unit = GIMP_UNIT_PIXEL;
static GimpInterpolationType layer_scale_interp = -1;
-static GimpAddMaskType layer_add_mask_type = GIMP_ADD_WHITE_MASK;
+static GimpAddMaskType layer_add_mask_type = GIMP_ADD_MASK_WHITE;
static gboolean layer_mask_invert = FALSE;
@@ -1108,7 +1108,7 @@ layers_add_mask_response (GtkWidget *widget,
GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer));
GimpLayerMask *mask;
- if (dialog->add_mask_type == GIMP_ADD_CHANNEL_MASK &&
+ if (dialog->add_mask_type == GIMP_ADD_MASK_CHANNEL &&
! dialog->channel)
{
gimp_message_literal (image->gimp,
diff --git a/app/core/gimpdrawable-blend.c b/app/core/gimpdrawable-blend.c
index d23edf3..f3cdecc 100644
--- a/app/core/gimpdrawable-blend.c
+++ b/app/core/gimpdrawable-blend.c
@@ -757,7 +757,7 @@ gradient_render_pixel (gdouble x,
color->r = color->g = color->b = 0;
color->a = GIMP_OPACITY_TRANSPARENT;
}
- else if (rbd->blend_mode == GIMP_CUSTOM_MODE)
+ else if (rbd->blend_mode == GIMP_BLEND_CUSTOM)
{
#ifdef USE_GRADIENT_CACHE
*color = rbd->gradient_cache[(gint) (factor * (rbd->gradient_cache_size - 1))];
@@ -778,7 +778,7 @@ gradient_render_pixel (gdouble x,
color->b = rbd->fg.b + (rbd->bg.b - rbd->fg.b) * factor;
color->a = rbd->fg.a + (rbd->bg.a - rbd->fg.a) * factor;
- if (rbd->blend_mode == GIMP_FG_BG_HSV_MODE)
+ if (rbd->blend_mode == GIMP_BLEND_FG_BG_HSV)
{
GimpHSV hsv = *((GimpHSV *) color);
@@ -878,10 +878,10 @@ gradient_fill_region (GimpImage *image,
switch (blend_mode)
{
- case GIMP_FG_BG_RGB_MODE:
+ case GIMP_BLEND_FG_BG_RGB:
break;
- case GIMP_FG_BG_HSV_MODE:
+ case GIMP_BLEND_FG_BG_HSV:
/* Convert to HSV */
{
GimpHSV fg_hsv;
@@ -895,14 +895,14 @@ gradient_fill_region (GimpImage *image,
}
break;
- case GIMP_FG_TRANSPARENT_MODE:
+ case GIMP_BLEND_FG_TRANSPARENT:
/* Color does not change, just the opacity */
rbd.bg = rbd.fg;
rbd.bg.a = GIMP_OPACITY_TRANSPARENT;
break;
- case GIMP_CUSTOM_MODE:
+ case GIMP_BLEND_CUSTOM:
break;
default:
diff --git a/app/core/gimpdrawable-bucket-fill.c b/app/core/gimpdrawable-bucket-fill.c
index ee7199a..caebaac 100644
--- a/app/core/gimpdrawable-bucket-fill.c
+++ b/app/core/gimpdrawable-bucket-fill.c
@@ -83,15 +83,15 @@ gimp_drawable_bucket_fill (GimpDrawable *drawable,
g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
- if (fill_mode == GIMP_FG_BUCKET_FILL)
+ if (fill_mode == GIMP_BUCKET_FILL_FG)
{
gimp_context_get_foreground (context, &color);
}
- else if (fill_mode == GIMP_BG_BUCKET_FILL)
+ else if (fill_mode == GIMP_BUCKET_FILL_BG)
{
gimp_context_get_background (context, &color);
}
- else if (fill_mode == GIMP_PATTERN_BUCKET_FILL)
+ else if (fill_mode == GIMP_BUCKET_FILL_PATTERN)
{
pattern = gimp_context_get_pattern (context);
@@ -146,9 +146,9 @@ gimp_drawable_bucket_fill_internal (GimpDrawable *drawable,
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));
- g_return_if_fail (fill_mode != GIMP_PATTERN_BUCKET_FILL ||
+ g_return_if_fail (fill_mode != GIMP_BUCKET_FILL_PATTERN ||
GIMP_IS_PATTERN (pattern));
- g_return_if_fail (fill_mode == GIMP_PATTERN_BUCKET_FILL ||
+ g_return_if_fail (fill_mode == GIMP_BUCKET_FILL_PATTERN ||
color != NULL);
image = gimp_item_get_image (GIMP_ITEM (drawable));
@@ -226,8 +226,8 @@ gimp_drawable_bucket_fill_internal (GimpDrawable *drawable,
switch (fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
+ case GIMP_BUCKET_FILL_BG:
{
GeglColor *gegl_color = gimp_gegl_color_new (color);
@@ -236,7 +236,7 @@ gimp_drawable_bucket_fill_internal (GimpDrawable *drawable,
}
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
{
GeglBuffer *pattern_buffer = gimp_pattern_create_buffer (pattern);
diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c
index 6f959a1..2155333 100644
--- a/app/core/gimplayer.c
+++ b/app/core/gimplayer.c
@@ -1439,7 +1439,7 @@ gimp_layer_create_mask (const GimpLayer *layer,
GimpRGB black = { 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE };
g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
- g_return_val_if_fail (add_mask_type != GIMP_ADD_CHANNEL_MASK ||
+ g_return_val_if_fail (add_mask_type != GIMP_ADD_MASK_CHANNEL ||
GIMP_IS_CHANNEL (channel), NULL);
drawable = GIMP_DRAWABLE (layer);
@@ -1458,11 +1458,11 @@ gimp_layer_create_mask (const GimpLayer *layer,
switch (add_mask_type)
{
- case GIMP_ADD_WHITE_MASK:
+ case GIMP_ADD_MASK_WHITE:
gimp_channel_all (GIMP_CHANNEL (mask), FALSE);
return mask;
- case GIMP_ADD_BLACK_MASK:
+ case GIMP_ADD_MASK_BLACK:
gimp_channel_clear (GIMP_CHANNEL (mask), NULL, FALSE);
return mask;
@@ -1472,12 +1472,12 @@ gimp_layer_create_mask (const GimpLayer *layer,
switch (add_mask_type)
{
- case GIMP_ADD_WHITE_MASK:
- case GIMP_ADD_BLACK_MASK:
+ case GIMP_ADD_MASK_WHITE:
+ case GIMP_ADD_MASK_BLACK:
break;
- case GIMP_ADD_ALPHA_MASK:
- case GIMP_ADD_ALPHA_TRANSFER_MASK:
+ case GIMP_ADD_MASK_ALPHA:
+ case GIMP_ADD_MASK_ALPHA_TRANSFER:
if (gimp_drawable_has_alpha (drawable))
{
GeglBuffer *dest_buffer;
@@ -1493,7 +1493,7 @@ gimp_layer_create_mask (const GimpLayer *layer,
dest_buffer, NULL);
gegl_buffer_set_format (dest_buffer, NULL);
- if (add_mask_type == GIMP_ADD_ALPHA_TRANSFER_MASK)
+ if (add_mask_type == GIMP_ADD_MASK_ALPHA_TRANSFER)
{
gimp_drawable_push_undo (drawable,
C_("undo-type", "Transfer Alpha to Mask"),
@@ -1510,15 +1510,15 @@ gimp_layer_create_mask (const GimpLayer *layer,
}
break;
- case GIMP_ADD_SELECTION_MASK:
- case GIMP_ADD_CHANNEL_MASK:
+ case GIMP_ADD_MASK_SELECTION:
+ case GIMP_ADD_MASK_CHANNEL:
{
gboolean channel_empty;
gint offset_x, offset_y;
gint copy_x, copy_y;
gint copy_width, copy_height;
- if (add_mask_type == GIMP_ADD_SELECTION_MASK)
+ if (add_mask_type == GIMP_ADD_MASK_SELECTION)
channel = GIMP_CHANNEL (gimp_image_get_mask (image));
channel_empty = gimp_channel_is_empty (channel);
@@ -1559,7 +1559,7 @@ gimp_layer_create_mask (const GimpLayer *layer,
}
break;
- case GIMP_ADD_COPY_MASK:
+ case GIMP_ADD_MASK_COPY:
{
GeglBuffer *src_buffer;
GeglBuffer *dest_buffer;
diff --git a/app/dialogs/layer-add-mask-dialog.c b/app/dialogs/layer-add-mask-dialog.c
index e7504d7..d73134f 100644
--- a/app/dialogs/layer-add-mask-dialog.c
+++ b/app/dialogs/layer-add-mask-dialog.c
@@ -125,7 +125,7 @@ layer_add_mask_dialog_new (GimpLayer *layer,
context,
GIMP_VIEW_SIZE_SMALL, 1);
gimp_enum_radio_frame_add (GTK_FRAME (frame), combo,
- GIMP_ADD_CHANNEL_MASK, TRUE);
+ GIMP_ADD_MASK_CHANNEL, TRUE);
gtk_widget_show (combo);
g_signal_connect (combo, "select-item",
diff --git a/app/gegl/gimp-gegl-loops.c b/app/gegl/gimp-gegl-loops.c
index 2ed3673..141e1da 100644
--- a/app/gegl/gimp-gegl-loops.c
+++ b/app/gegl/gimp-gegl-loops.c
@@ -215,7 +215,7 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer,
{
GeglBufferIterator *iter;
- if (type == GIMP_BURN)
+ if (type == GIMP_DODGE_BURN_TYPE_BURN)
exposure = -exposure;
iter = gegl_buffer_iterator_new (src_buffer, src_rect, 0,
@@ -230,7 +230,7 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer,
{
gfloat factor;
- case GIMP_HIGHLIGHTS:
+ case GIMP_TRANSFER_HIGHLIGHTS:
factor = 1.0 + exposure * (0.333333);
while (gegl_buffer_iterator_next (iter))
@@ -250,7 +250,7 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer,
}
break;
- case GIMP_MIDTONES:
+ case GIMP_TRANSFER_MIDTONES:
if (exposure < 0)
factor = 1.0 - exposure * (0.333333);
else
@@ -273,7 +273,7 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer,
}
break;
- case GIMP_SHADOWS:
+ case GIMP_TRANSFER_SHADOWS:
if (exposure >= 0)
factor = 0.333333 * exposure;
else
diff --git a/app/operations/gimpcolorbalanceconfig.c b/app/operations/gimpcolorbalanceconfig.c
index 8a97349..b021640 100644
--- a/app/operations/gimpcolorbalanceconfig.c
+++ b/app/operations/gimpcolorbalanceconfig.c
@@ -93,7 +93,7 @@ gimp_color_balance_config_class_init (GimpColorBalanceConfigClass *klass)
"range",
"The affected range",
GIMP_TYPE_TRANSFER_MODE,
- GIMP_MIDTONES, 0);
+ GIMP_TRANSFER_MIDTONES, 0);
GIMP_CONFIG_INSTALL_PROP_DOUBLE (object_class, PROP_CYAN_RED,
"cyan-red",
@@ -222,7 +222,9 @@ gimp_color_balance_config_serialize (GimpConfig *config,
old_range = bc_config->range;
- for (range = GIMP_SHADOWS; range <= GIMP_HIGHLIGHTS; range++)
+ for (range = GIMP_TRANSFER_SHADOWS;
+ range <= GIMP_TRANSFER_HIGHLIGHTS;
+ range++)
{
bc_config->range = range;
@@ -280,7 +282,9 @@ gimp_color_balance_config_equal (GimpConfig *a,
GimpColorBalanceConfig *config_b = GIMP_COLOR_BALANCE_CONFIG (b);
GimpTransferMode range;
- for (range = GIMP_SHADOWS; range <= GIMP_HIGHLIGHTS; range++)
+ for (range = GIMP_TRANSFER_SHADOWS;
+ range <= GIMP_TRANSFER_HIGHLIGHTS;
+ range++)
{
if (config_a->cyan_red[range] != config_b->cyan_red[range] ||
config_a->magenta_green[range] != config_b->magenta_green[range] ||
@@ -302,7 +306,9 @@ gimp_color_balance_config_reset (GimpConfig *config)
GimpColorBalanceConfig *cb_config = GIMP_COLOR_BALANCE_CONFIG (config);
GimpTransferMode range;
- for (range = GIMP_SHADOWS; range <= GIMP_HIGHLIGHTS; range++)
+ for (range = GIMP_TRANSFER_SHADOWS;
+ range <= GIMP_TRANSFER_HIGHLIGHTS;
+ range++)
{
cb_config->range = range;
gimp_color_balance_config_reset_range (cb_config);
@@ -321,7 +327,9 @@ gimp_color_balance_config_copy (GimpConfig *src,
GimpColorBalanceConfig *dest_config = GIMP_COLOR_BALANCE_CONFIG (dest);
GimpTransferMode range;
- for (range = GIMP_SHADOWS; range <= GIMP_HIGHLIGHTS; range++)
+ for (range = GIMP_TRANSFER_SHADOWS;
+ range <= GIMP_TRANSFER_HIGHLIGHTS;
+ range++)
{
dest_config->cyan_red[range] = src_config->cyan_red[range];
dest_config->magenta_green[range] = src_config->magenta_green[range];
diff --git a/app/operations/gimpoperationcolorbalance.c b/app/operations/gimpoperationcolorbalance.c
index b6a9e72..76d985e 100644
--- a/app/operations/gimpoperationcolorbalance.c
+++ b/app/operations/gimpoperationcolorbalance.c
@@ -146,19 +146,19 @@ gimp_operation_color_balance_process (GeglOperation *operation,
gimp_rgb_to_hsl (&rgb, &hsl);
r_n = gimp_operation_color_balance_map (r, hsl.l,
- config->cyan_red[GIMP_SHADOWS],
- config->cyan_red[GIMP_MIDTONES],
- config->cyan_red[GIMP_HIGHLIGHTS]);
+ config->cyan_red[GIMP_TRANSFER_SHADOWS],
+ config->cyan_red[GIMP_TRANSFER_MIDTONES],
+ config->cyan_red[GIMP_TRANSFER_HIGHLIGHTS]);
g_n = gimp_operation_color_balance_map (g, hsl.l,
- config->magenta_green[GIMP_SHADOWS],
- config->magenta_green[GIMP_MIDTONES],
- config->magenta_green[GIMP_HIGHLIGHTS]);
+ config->magenta_green[GIMP_TRANSFER_SHADOWS],
+ config->magenta_green[GIMP_TRANSFER_MIDTONES],
+ config->magenta_green[GIMP_TRANSFER_HIGHLIGHTS]);
b_n = gimp_operation_color_balance_map (b, hsl.l,
- config->yellow_blue[GIMP_SHADOWS],
- config->yellow_blue[GIMP_MIDTONES],
- config->yellow_blue[GIMP_HIGHLIGHTS]);
+ config->yellow_blue[GIMP_TRANSFER_SHADOWS],
+ config->yellow_blue[GIMP_TRANSFER_MIDTONES],
+ config->yellow_blue[GIMP_TRANSFER_HIGHLIGHTS]);
if (config->preserve_luminosity)
{
diff --git a/app/paint/gimpclone.c b/app/paint/gimpclone.c
index 0188faf..a232adb 100644
--- a/app/paint/gimpclone.c
+++ b/app/paint/gimpclone.c
@@ -119,7 +119,7 @@ gimp_clone_start (GimpPaintCore *paint_core,
return FALSE;
}
- if (options->clone_type == GIMP_PATTERN_CLONE)
+ if (options->clone_type == GIMP_CLONE_PATTERN)
{
if (! gimp_context_get_pattern (GIMP_CONTEXT (options)))
{
@@ -171,7 +171,7 @@ gimp_clone_motion (GimpSourceCore *source_core,
paint_area_offset_y,
0, 0));
}
- else if (options->clone_type == GIMP_PATTERN_CLONE)
+ else if (options->clone_type == GIMP_CLONE_PATTERN)
{
GimpPattern *pattern = gimp_context_get_pattern (context);
GeglBuffer *src_buffer = gimp_pattern_create_buffer (pattern);
@@ -224,5 +224,5 @@ static gboolean
gimp_clone_use_source (GimpSourceCore *source_core,
GimpSourceOptions *options)
{
- return GIMP_CLONE_OPTIONS (options)->clone_type == GIMP_IMAGE_CLONE;
+ return GIMP_CLONE_OPTIONS (options)->clone_type == GIMP_CLONE_IMAGE;
}
diff --git a/app/paint/gimpcloneoptions.c b/app/paint/gimpcloneoptions.c
index 9786352..2466234 100644
--- a/app/paint/gimpcloneoptions.c
+++ b/app/paint/gimpcloneoptions.c
@@ -62,7 +62,7 @@ gimp_clone_options_class_init (GimpCloneOptionsClass *klass)
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLONE_TYPE,
"clone-type", NULL,
GIMP_TYPE_CLONE_TYPE,
- GIMP_IMAGE_CLONE,
+ GIMP_CLONE_IMAGE,
GIMP_PARAM_STATIC_STRINGS);
}
diff --git a/app/paint/gimpdodgeburnoptions.c b/app/paint/gimpdodgeburnoptions.c
index 57e8abc..70ca628 100644
--- a/app/paint/gimpdodgeburnoptions.c
+++ b/app/paint/gimpdodgeburnoptions.c
@@ -27,8 +27,8 @@
#include "gimpdodgeburnoptions.h"
-#define DODGE_BURN_DEFAULT_TYPE GIMP_DODGE
-#define DODGE_BURN_DEFAULT_MODE GIMP_MIDTONES
+#define DODGE_BURN_DEFAULT_TYPE GIMP_DODGE_BURN_TYPE_DODGE
+#define DODGE_BURN_DEFAULT_MODE GIMP_TRANSFER_MIDTONES
#define DODGE_BURN_DEFAULT_EXPOSURE 50.0
diff --git a/app/paint/gimpperspectiveclone.c b/app/paint/gimpperspectiveclone.c
index c2efe7f..6459eac 100644
--- a/app/paint/gimpperspectiveclone.c
+++ b/app/paint/gimpperspectiveclone.c
@@ -171,7 +171,7 @@ gimp_perspective_clone_paint (GimpPaintCore *paint_core,
switch (clone_options->clone_type)
{
- case GIMP_IMAGE_CLONE:
+ case GIMP_CLONE_IMAGE:
{
GimpPickable *src_pickable;
GimpImage *src_image;
@@ -208,7 +208,7 @@ gimp_perspective_clone_paint (GimpPaintCore *paint_core,
}
break;
- case GIMP_PATTERN_CLONE:
+ case GIMP_CLONE_PATTERN:
{
GimpPattern *pattern = gimp_context_get_pattern (context);
@@ -395,7 +395,7 @@ gimp_perspective_clone_get_source (GimpSourceCore *source_core,
switch (clone_options->clone_type)
{
- case GIMP_IMAGE_CLONE:
+ case GIMP_CLONE_IMAGE:
if (! gimp_rectangle_intersect (xmin, ymin,
xmax - xmin, ymax - ymin,
0, 0,
@@ -408,7 +408,7 @@ gimp_perspective_clone_get_source (GimpSourceCore *source_core,
}
break;
- case GIMP_PATTERN_CLONE:
+ case GIMP_CLONE_PATTERN:
gegl_node_set (clone->crop,
"x", (gdouble) xmin,
"y", (gdouble) ymin,
diff --git a/app/pdb/color-cmds.c b/app/pdb/color-cmds.c
index af63da6..a0ed290 100644
--- a/app/pdb/color-cmds.c
+++ b/app/pdb/color-cmds.c
@@ -1162,7 +1162,7 @@ register_color_procs (GimpPDB *pdb)
"transfer mode",
"Transfer mode",
GIMP_TYPE_TRANSFER_MODE,
- GIMP_SHADOWS,
+ GIMP_TRANSFER_SHADOWS,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("preserve-lum",
diff --git a/app/pdb/drawable-color-cmds.c b/app/pdb/drawable-color-cmds.c
index 685ed39..6a12875 100644
--- a/app/pdb/drawable-color-cmds.c
+++ b/app/pdb/drawable-color-cmds.c
@@ -776,7 +776,7 @@ register_drawable_color_procs (GimpPDB *pdb)
"transfer mode",
"Transfer mode",
GIMP_TYPE_TRANSFER_MODE,
- GIMP_SHADOWS,
+ GIMP_TRANSFER_SHADOWS,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("preserve-lum",
diff --git a/app/pdb/edit-cmds.c b/app/pdb/edit-cmds.c
index 03ac9c3..3f1ac61 100644
--- a/app/pdb/edit-cmds.c
+++ b/app/pdb/edit-cmds.c
@@ -603,19 +603,19 @@ edit_bucket_fill_invoker (GimpProcedure *procedure,
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
{
- GimpFillType fill_type = GIMP_FG_BUCKET_FILL;
+ GimpFillType fill_type = GIMP_FOREGROUND_FILL;
switch (fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
fill_type = GIMP_FOREGROUND_FILL;
break;
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_BG:
fill_type = GIMP_BACKGROUND_FILL;
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
fill_type = GIMP_PATTERN_FILL;
break;
}
@@ -683,19 +683,19 @@ edit_bucket_fill_full_invoker (GimpProcedure *procedure,
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
{
- GimpFillType fill_type = GIMP_FG_BUCKET_FILL;
+ GimpFillType fill_type = GIMP_FOREGROUND_FILL;
switch (fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
fill_type = GIMP_FOREGROUND_FILL;
break;
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_BG:
fill_type = GIMP_BACKGROUND_FILL;
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
fill_type = GIMP_PATTERN_FILL;
break;
}
@@ -1315,7 +1315,7 @@ register_edit_procs (GimpPDB *pdb)
"fill mode",
"The type of fill",
GIMP_TYPE_BUCKET_FILL_MODE,
- GIMP_FG_BUCKET_FILL,
+ GIMP_BUCKET_FILL_FG,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("paint-mode",
@@ -1382,7 +1382,7 @@ register_edit_procs (GimpPDB *pdb)
"fill mode",
"The type of fill",
GIMP_TYPE_BUCKET_FILL_MODE,
- GIMP_FG_BUCKET_FILL,
+ GIMP_BUCKET_FILL_FG,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("paint-mode",
@@ -1462,7 +1462,7 @@ register_edit_procs (GimpPDB *pdb)
"blend mode",
"The type of blend",
GIMP_TYPE_BLEND_MODE,
- GIMP_FG_BG_RGB_MODE,
+ GIMP_BLEND_FG_BG_RGB,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("paint-mode",
diff --git a/app/pdb/layer-cmds.c b/app/pdb/layer-cmds.c
index 0917bdd..df5c91d 100644
--- a/app/pdb/layer-cmds.c
+++ b/app/pdb/layer-cmds.c
@@ -620,7 +620,7 @@ layer_create_mask_invoker (GimpProcedure *procedure,
{
GimpChannel *channel = NULL;
- if (mask_type == GIMP_ADD_CHANNEL_MASK)
+ if (mask_type == GIMP_ADD_MASK_CHANNEL)
{
channel = gimp_image_get_active_channel (gimp_item_get_image (GIMP_ITEM (layer)));
@@ -1660,7 +1660,7 @@ register_layer_procs (GimpPDB *pdb)
"mask type",
"The type of mask",
GIMP_TYPE_ADD_MASK_TYPE,
- GIMP_ADD_WHITE_MASK,
+ GIMP_ADD_MASK_WHITE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_mask_id ("mask",
diff --git a/app/pdb/paint-tools-cmds.c b/app/pdb/paint-tools-cmds.c
index 7933577..2353a21 100644
--- a/app/pdb/paint-tools-cmds.c
+++ b/app/pdb/paint-tools-cmds.c
@@ -1049,7 +1049,7 @@ register_paint_tools_procs (GimpPDB *pdb)
"clone type",
"The type of clone",
GIMP_TYPE_CLONE_TYPE,
- GIMP_IMAGE_CLONE,
+ GIMP_CLONE_IMAGE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("src-x",
@@ -1223,14 +1223,14 @@ register_paint_tools_procs (GimpPDB *pdb)
"dodgeburn type",
"The type either dodge or burn",
GIMP_TYPE_DODGE_BURN_TYPE,
- GIMP_DODGE,
+ GIMP_DODGE_BURN_TYPE_DODGE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("dodgeburn-mode",
"dodgeburn mode",
"The mode",
GIMP_TYPE_TRANSFER_MODE,
- GIMP_SHADOWS,
+ GIMP_TRANSFER_SHADOWS,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("num-strokes",
diff --git a/app/tools/gimpblendtool.c b/app/tools/gimpblendtool.c
index 20cd26c..ae4e2a1 100644
--- a/app/tools/gimpblendtool.c
+++ b/app/tools/gimpblendtool.c
@@ -252,7 +252,7 @@ gimp_blend_tool_button_release (GimpTool *tool,
gimp_drawable_blend (drawable,
context,
- GIMP_CUSTOM_MODE,
+ GIMP_BLEND_CUSTOM,
gimp_context_get_paint_mode (context),
options->gradient_type,
gimp_context_get_opacity (context),
diff --git a/app/tools/gimpbucketfilloptions.c b/app/tools/gimpbucketfilloptions.c
index 1dfb776..94096be 100644
--- a/app/tools/gimpbucketfilloptions.c
+++ b/app/tools/gimpbucketfilloptions.c
@@ -87,7 +87,7 @@ gimp_bucket_fill_options_class_init (GimpBucketFillOptionsClass *klass)
GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_FILL_MODE,
"fill-mode", NULL,
GIMP_TYPE_BUCKET_FILL_MODE,
- GIMP_FG_BUCKET_FILL,
+ GIMP_BUCKET_FILL_FG,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_FILL_SELECTION,
"fill-selection",
@@ -238,7 +238,7 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
NULL, 2,
"pattern-view-type", "pattern-view-size");
gimp_enum_radio_frame_add (GTK_FRAME (frame), hbox,
- GIMP_PATTERN_BUCKET_FILL, TRUE);
+ GIMP_BUCKET_FILL_PATTERN, TRUE);
/* fill selection */
str = g_strdup_printf (_("Affected Area (%s)"),
diff --git a/app/tools/gimpbucketfilltool.c b/app/tools/gimpbucketfilltool.c
index 3722a23..99e4596 100644
--- a/app/tools/gimpbucketfilltool.c
+++ b/app/tools/gimpbucketfilltool.c
@@ -195,13 +195,13 @@ gimp_bucket_fill_tool_button_release (GimpTool *tool,
switch (options->fill_mode)
{
default:
- case GIMP_FG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
fill_type = GIMP_FOREGROUND_FILL;
break;
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_BG:
fill_type = GIMP_BACKGROUND_FILL;
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
fill_type = GIMP_PATTERN_FILL;
break;
}
@@ -257,12 +257,12 @@ gimp_bucket_fill_tool_modifier_key (GimpTool *tool,
{
switch (options->fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
- g_object_set (options, "fill-mode", GIMP_BG_BUCKET_FILL, NULL);
+ case GIMP_BUCKET_FILL_FG:
+ g_object_set (options, "fill-mode", GIMP_BUCKET_FILL_BG, NULL);
break;
- case GIMP_BG_BUCKET_FILL:
- g_object_set (options, "fill-mode", GIMP_FG_BUCKET_FILL, NULL);
+ case GIMP_BUCKET_FILL_BG:
+ g_object_set (options, "fill-mode", GIMP_BUCKET_FILL_FG, NULL);
break;
default:
@@ -296,15 +296,15 @@ gimp_bucket_fill_tool_cursor_update (GimpTool *tool,
{
switch (options->fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
modifier = GIMP_CURSOR_MODIFIER_FOREGROUND;
break;
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_BG:
modifier = GIMP_CURSOR_MODIFIER_BACKGROUND;
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
modifier = GIMP_CURSOR_MODIFIER_PATTERN;
break;
}
diff --git a/app/tools/gimpcloneoptions-gui.c b/app/tools/gimpcloneoptions-gui.c
index dc328cb..6ef4d70 100644
--- a/app/tools/gimpcloneoptions-gui.c
+++ b/app/tools/gimpcloneoptions-gui.c
@@ -85,7 +85,7 @@ gimp_clone_options_gui (GimpToolOptions *tool_options)
G_BINDING_SYNC_CREATE,
gimp_clone_options_sync_source,
NULL,
- GINT_TO_POINTER (GIMP_IMAGE_CLONE), NULL);
+ GINT_TO_POINTER (GIMP_CLONE_IMAGE), NULL);
hbox = gimp_prop_pattern_box_new (NULL, GIMP_CONTEXT (tool_options),
NULL, 2,
@@ -97,7 +97,7 @@ gimp_clone_options_gui (GimpToolOptions *tool_options)
G_BINDING_SYNC_CREATE,
gimp_clone_options_sync_source,
NULL,
- GINT_TO_POINTER (GIMP_PATTERN_CLONE), NULL);
+ GINT_TO_POINTER (GIMP_CLONE_PATTERN), NULL);
combo = gimp_prop_enum_combo_box_new (config, "align-mode", 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (combo), _("Alignment"));
diff --git a/app/tools/gimpdodgeburntool.c b/app/tools/gimpdodgeburntool.c
index 7adaced..99cdbcc 100644
--- a/app/tools/gimpdodgeburntool.c
+++ b/app/tools/gimpdodgeburntool.c
@@ -99,7 +99,7 @@ gimp_dodge_burn_tool_init (GimpDodgeBurnTool *dodgeburn)
gimp_tool_control_set_toggle_tool_cursor (tool->control,
GIMP_TOOL_CURSOR_BURN);
- gimp_dodge_burn_tool_status_update (tool, GIMP_BURN);
+ gimp_dodge_burn_tool_status_update (tool, GIMP_DODGE_BURN_TYPE_BURN);
}
static void
@@ -130,12 +130,12 @@ gimp_dodge_burn_tool_modifier_key (GimpTool *tool,
switch (options->type)
{
- case GIMP_DODGE:
- g_object_set (options, "type", GIMP_BURN, NULL);
+ case GIMP_DODGE_BURN_TYPE_DODGE:
+ g_object_set (options, "type", GIMP_DODGE_BURN_TYPE_BURN, NULL);
break;
- case GIMP_BURN:
- g_object_set (options, "type", GIMP_DODGE, NULL);
+ case GIMP_DODGE_BURN_TYPE_BURN:
+ g_object_set (options, "type", GIMP_DODGE_BURN_TYPE_DODGE, NULL);
break;
default:
@@ -155,7 +155,8 @@ gimp_dodge_burn_tool_cursor_update (GimpTool *tool,
{
GimpDodgeBurnOptions *options = GIMP_DODGE_BURN_TOOL_GET_OPTIONS (tool);
- gimp_tool_control_set_toggled (tool->control, (options->type == GIMP_BURN));
+ gimp_tool_control_set_toggled (tool->control,
+ options->type == GIMP_DODGE_BURN_TYPE_BURN);
GIMP_TOOL_CLASS (parent_class)->cursor_update (tool, coords, state,
display);
@@ -184,13 +185,13 @@ gimp_dodge_burn_tool_status_update (GimpTool *tool,
switch (type)
{
- case GIMP_DODGE:
+ case GIMP_DODGE_BURN_TYPE_DODGE:
paint_tool->status = _("Click to dodge");
paint_tool->status_line = _("Click to dodge the line");
paint_tool->status_ctrl = _("%s to burn");
break;
- case GIMP_BURN:
+ case GIMP_DODGE_BURN_TYPE_BURN:
paint_tool->status = _("Click to burn");
paint_tool->status_line = _("Click to burn the line");
paint_tool->status_ctrl = _("%s to dodge");
diff --git a/libgimpbase/gimpbaseenums.c b/libgimpbase/gimpbaseenums.c
index 6f91733..832aeba 100644
--- a/libgimpbase/gimpbaseenums.c
+++ b/libgimpbase/gimpbaseenums.c
@@ -13,25 +13,25 @@ gimp_add_mask_type_get_type (void)
{
static const GEnumValue values[] =
{
- { GIMP_ADD_WHITE_MASK, "GIMP_ADD_WHITE_MASK", "white-mask" },
- { GIMP_ADD_BLACK_MASK, "GIMP_ADD_BLACK_MASK", "black-mask" },
- { GIMP_ADD_ALPHA_MASK, "GIMP_ADD_ALPHA_MASK", "alpha-mask" },
- { GIMP_ADD_ALPHA_TRANSFER_MASK, "GIMP_ADD_ALPHA_TRANSFER_MASK", "alpha-transfer-mask" },
- { GIMP_ADD_SELECTION_MASK, "GIMP_ADD_SELECTION_MASK", "selection-mask" },
- { GIMP_ADD_COPY_MASK, "GIMP_ADD_COPY_MASK", "copy-mask" },
- { GIMP_ADD_CHANNEL_MASK, "GIMP_ADD_CHANNEL_MASK", "channel-mask" },
+ { GIMP_ADD_MASK_WHITE, "GIMP_ADD_MASK_WHITE", "white-mask" },
+ { GIMP_ADD_MASK_BLACK, "GIMP_ADD_MASK_BLACK", "black-mask" },
+ { GIMP_ADD_MASK_ALPHA, "GIMP_ADD_MASK_ALPHA", "alpha-mask" },
+ { GIMP_ADD_MASK_ALPHA_TRANSFER, "GIMP_ADD_MASK_ALPHA_TRANSFER", "alpha-transfer-mask" },
+ { GIMP_ADD_MASK_SELECTION, "GIMP_ADD_MASK_SELECTION", "selection-mask" },
+ { GIMP_ADD_MASK_COPY, "GIMP_ADD_MASK_COPY", "copy-mask" },
+ { GIMP_ADD_MASK_CHANNEL, "GIMP_ADD_MASK_CHANNEL", "channel-mask" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
- { GIMP_ADD_WHITE_MASK, NC_("add-mask-type", "_White (full opacity)"), NULL },
- { GIMP_ADD_BLACK_MASK, NC_("add-mask-type", "_Black (full transparency)"), NULL },
- { GIMP_ADD_ALPHA_MASK, NC_("add-mask-type", "Layer's _alpha channel"), NULL },
- { GIMP_ADD_ALPHA_TRANSFER_MASK, NC_("add-mask-type", "_Transfer layer's alpha channel"), NULL },
- { GIMP_ADD_SELECTION_MASK, NC_("add-mask-type", "_Selection"), NULL },
- { GIMP_ADD_COPY_MASK, NC_("add-mask-type", "_Grayscale copy of layer"), NULL },
- { GIMP_ADD_CHANNEL_MASK, NC_("add-mask-type", "C_hannel"), NULL },
+ { GIMP_ADD_MASK_WHITE, NC_("add-mask-type", "_White (full opacity)"), NULL },
+ { GIMP_ADD_MASK_BLACK, NC_("add-mask-type", "_Black (full transparency)"), NULL },
+ { GIMP_ADD_MASK_ALPHA, NC_("add-mask-type", "Layer's _alpha channel"), NULL },
+ { GIMP_ADD_MASK_ALPHA_TRANSFER, NC_("add-mask-type", "_Transfer layer's alpha channel"), NULL },
+ { GIMP_ADD_MASK_SELECTION, NC_("add-mask-type", "_Selection"), NULL },
+ { GIMP_ADD_MASK_COPY, NC_("add-mask-type", "_Grayscale copy of layer"), NULL },
+ { GIMP_ADD_MASK_CHANNEL, NC_("add-mask-type", "C_hannel"), NULL },
{ 0, NULL, NULL }
};
@@ -53,19 +53,19 @@ gimp_blend_mode_get_type (void)
{
static const GEnumValue values[] =
{
- { GIMP_FG_BG_RGB_MODE, "GIMP_FG_BG_RGB_MODE", "fg-bg-rgb-mode" },
- { GIMP_FG_BG_HSV_MODE, "GIMP_FG_BG_HSV_MODE", "fg-bg-hsv-mode" },
- { GIMP_FG_TRANSPARENT_MODE, "GIMP_FG_TRANSPARENT_MODE", "fg-transparent-mode" },
- { GIMP_CUSTOM_MODE, "GIMP_CUSTOM_MODE", "custom-mode" },
+ { GIMP_BLEND_FG_BG_RGB, "GIMP_BLEND_FG_BG_RGB", "fg-bg-rgb-mode" },
+ { GIMP_BLEND_FG_BG_HSV, "GIMP_BLEND_FG_BG_HSV", "fg-bg-hsv-mode" },
+ { GIMP_BLEND_FG_TRANSPARENT, "GIMP_BLEND_FG_TRANSPARENT", "fg-transparent-mode" },
+ { GIMP_BLEND_CUSTOM, "GIMP_BLEND_CUSTOM", "custom-mode" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
- { GIMP_FG_BG_RGB_MODE, NC_("blend-mode", "FG to BG (RGB)"), NULL },
- { GIMP_FG_BG_HSV_MODE, NC_("blend-mode", "FG to BG (HSV)"), NULL },
- { GIMP_FG_TRANSPARENT_MODE, NC_("blend-mode", "FG to transparent"), NULL },
- { GIMP_CUSTOM_MODE, NC_("blend-mode", "Custom gradient"), NULL },
+ { GIMP_BLEND_FG_BG_RGB, NC_("blend-mode", "FG to BG (RGB)"), NULL },
+ { GIMP_BLEND_FG_BG_HSV, NC_("blend-mode", "FG to BG (HSV)"), NULL },
+ { GIMP_BLEND_FG_TRANSPARENT, NC_("blend-mode", "FG to transparent"), NULL },
+ { GIMP_BLEND_CUSTOM, NC_("blend-mode", "Custom gradient"), NULL },
{ 0, NULL, NULL }
};
@@ -87,17 +87,17 @@ gimp_bucket_fill_mode_get_type (void)
{
static const GEnumValue values[] =
{
- { GIMP_FG_BUCKET_FILL, "GIMP_FG_BUCKET_FILL", "fg-bucket-fill" },
- { GIMP_BG_BUCKET_FILL, "GIMP_BG_BUCKET_FILL", "bg-bucket-fill" },
- { GIMP_PATTERN_BUCKET_FILL, "GIMP_PATTERN_BUCKET_FILL", "pattern-bucket-fill" },
+ { GIMP_BUCKET_FILL_FG, "GIMP_BUCKET_FILL_FG", "fg-bucket-fill" },
+ { GIMP_BUCKET_FILL_BG, "GIMP_BUCKET_FILL_BG", "bg-bucket-fill" },
+ { GIMP_BUCKET_FILL_PATTERN, "GIMP_BUCKET_FILL_PATTERN", "pattern-bucket-fill" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
- { GIMP_FG_BUCKET_FILL, NC_("bucket-fill-mode", "FG color fill"), NULL },
- { GIMP_BG_BUCKET_FILL, NC_("bucket-fill-mode", "BG color fill"), NULL },
- { GIMP_PATTERN_BUCKET_FILL, NC_("bucket-fill-mode", "Pattern fill"), NULL },
+ { GIMP_BUCKET_FILL_FG, NC_("bucket-fill-mode", "FG color fill"), NULL },
+ { GIMP_BUCKET_FILL_BG, NC_("bucket-fill-mode", "BG color fill"), NULL },
+ { GIMP_BUCKET_FILL_PATTERN, NC_("bucket-fill-mode", "Pattern fill"), NULL },
{ 0, NULL, NULL }
};
@@ -261,15 +261,15 @@ gimp_clone_type_get_type (void)
{
static const GEnumValue values[] =
{
- { GIMP_IMAGE_CLONE, "GIMP_IMAGE_CLONE", "image-clone" },
- { GIMP_PATTERN_CLONE, "GIMP_PATTERN_CLONE", "pattern-clone" },
+ { GIMP_CLONE_IMAGE, "GIMP_CLONE_IMAGE", "image-clone" },
+ { GIMP_CLONE_PATTERN, "GIMP_CLONE_PATTERN", "pattern-clone" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
- { GIMP_IMAGE_CLONE, NC_("clone-type", "Image"), NULL },
- { GIMP_PATTERN_CLONE, NC_("clone-type", "Pattern"), NULL },
+ { GIMP_CLONE_IMAGE, NC_("clone-type", "Image"), NULL },
+ { GIMP_CLONE_PATTERN, NC_("clone-type", "Pattern"), NULL },
{ 0, NULL, NULL }
};
@@ -323,15 +323,15 @@ gimp_dodge_burn_type_get_type (void)
{
static const GEnumValue values[] =
{
- { GIMP_DODGE, "GIMP_DODGE", "dodge" },
- { GIMP_BURN, "GIMP_BURN", "burn" },
+ { GIMP_DODGE_BURN_TYPE_DODGE, "GIMP_DODGE_BURN_TYPE_DODGE", "dodge" },
+ { GIMP_DODGE_BURN_TYPE_BURN, "GIMP_DODGE_BURN_TYPE_BURN", "burn" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
- { GIMP_DODGE, NC_("dodge-burn-type", "Dodge"), NULL },
- { GIMP_BURN, NC_("dodge-burn-type", "Burn"), NULL },
+ { GIMP_DODGE_BURN_TYPE_DODGE, NC_("dodge-burn-type", "Dodge"), NULL },
+ { GIMP_DODGE_BURN_TYPE_BURN, NC_("dodge-burn-type", "Burn"), NULL },
{ 0, NULL, NULL }
};
@@ -731,17 +731,17 @@ gimp_transfer_mode_get_type (void)
{
static const GEnumValue values[] =
{
- { GIMP_SHADOWS, "GIMP_SHADOWS", "shadows" },
- { GIMP_MIDTONES, "GIMP_MIDTONES", "midtones" },
- { GIMP_HIGHLIGHTS, "GIMP_HIGHLIGHTS", "highlights" },
+ { GIMP_TRANSFER_SHADOWS, "GIMP_TRANSFER_SHADOWS", "shadows" },
+ { GIMP_TRANSFER_MIDTONES, "GIMP_TRANSFER_MIDTONES", "midtones" },
+ { GIMP_TRANSFER_HIGHLIGHTS, "GIMP_TRANSFER_HIGHLIGHTS", "highlights" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
- { GIMP_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
- { GIMP_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
- { GIMP_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
+ { GIMP_TRANSFER_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
+ { GIMP_TRANSFER_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
+ { GIMP_TRANSFER_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
{ 0, NULL, NULL }
};
diff --git a/libgimpbase/gimpbaseenums.h b/libgimpbase/gimpbaseenums.h
index a63cc2f..faa2c71 100644
--- a/libgimpbase/gimpbaseenums.h
+++ b/libgimpbase/gimpbaseenums.h
@@ -40,13 +40,22 @@ GType gimp_add_mask_type_get_type (void) G_GNUC_CONST;
typedef enum
{
- GIMP_ADD_WHITE_MASK, /*< desc="_White (full opacity)" >*/
- GIMP_ADD_BLACK_MASK, /*< desc="_Black (full transparency)" >*/
- GIMP_ADD_ALPHA_MASK, /*< desc="Layer's _alpha channel" >*/
- GIMP_ADD_ALPHA_TRANSFER_MASK, /*< desc="_Transfer layer's alpha channel" >*/
- GIMP_ADD_SELECTION_MASK, /*< desc="_Selection" >*/
- GIMP_ADD_COPY_MASK, /*< desc="_Grayscale copy of layer" >*/
- GIMP_ADD_CHANNEL_MASK /*< desc="C_hannel" >*/
+ GIMP_ADD_MASK_WHITE, /*< nick=white-mask, desc="_White (full opacity)" >*/
+ GIMP_ADD_MASK_BLACK, /*< nick=black-mask, desc="_Black (full transparency)" >*/
+ GIMP_ADD_MASK_ALPHA, /*< nick=alpha-mask, desc="Layer's _alpha channel" >*/
+ GIMP_ADD_MASK_ALPHA_TRANSFER, /*< nick=alpha-transfer-mask, desc="_Transfer layer's alpha channel" >*/
+ GIMP_ADD_MASK_SELECTION, /*< nick=selection-mask, desc="_Selection" >*/
+ GIMP_ADD_MASK_COPY, /*< nick=copy-mask, desc="_Grayscale copy of layer" >*/
+ GIMP_ADD_MASK_CHANNEL, /*< nick=channel-mask, desc="C_hannel" >*/
+
+ /* the following aliases are deprecated */
+ GIMP_ADD_WHITE_MASK = GIMP_ADD_MASK_WHITE, /*< skip, pdb-skip >*/
+ GIMP_ADD_BLACK_MASK = GIMP_ADD_MASK_BLACK, /*< skip, pdb-skip >*/
+ GIMP_ADD_ALPHA_MASK = GIMP_ADD_MASK_ALPHA, /*< skip, pdb-skip >*/
+ GIMP_ADD_ALPHA_TRANSFER_MASK = GIMP_ADD_MASK_ALPHA_TRANSFER, /*< skip, pdb-skip >*/
+ GIMP_ADD_SELECTION_MASK = GIMP_ADD_MASK_SELECTION, /*< skip, pdb-skip >*/
+ GIMP_ADD_COPY_MASK = GIMP_ADD_MASK_COPY, /*< skip, pdb-skip >*/
+ GIMP_ADD_CHANNEL_MASK = GIMP_ADD_MASK_CHANNEL /*< skip, pdb-skip >*/
} GimpAddMaskType;
@@ -56,10 +65,16 @@ GType gimp_blend_mode_get_type (void) G_GNUC_CONST;
typedef enum
{
- GIMP_FG_BG_RGB_MODE, /*< desc="FG to BG (RGB)" >*/
- GIMP_FG_BG_HSV_MODE, /*< desc="FG to BG (HSV)" >*/
- GIMP_FG_TRANSPARENT_MODE, /*< desc="FG to transparent" >*/
- GIMP_CUSTOM_MODE /*< desc="Custom gradient" >*/
+ GIMP_BLEND_FG_BG_RGB, /*< nick=fg-bg-rgb-mode, desc="FG to BG (RGB)" >*/
+ GIMP_BLEND_FG_BG_HSV, /*< nick=fg-bg-hsv-mode, desc="FG to BG (HSV)" >*/
+ GIMP_BLEND_FG_TRANSPARENT, /*< nick=fg-transparent-mode, desc="FG to transparent" >*/
+ GIMP_BLEND_CUSTOM, /*< nick=custom-mode, desc="Custom gradient" >*/
+
+ /* the following aliases are deprecated */
+ GIMP_FG_BG_RGB_MODE = GIMP_BLEND_FG_BG_RGB, /*< skip, pdb-skip >*/
+ GIMP_FG_BG_HSV_MODE = GIMP_BLEND_FG_BG_HSV, /*< skip, pdb-skip >*/
+ GIMP_FG_TRANSPARENT_MODE = GIMP_BLEND_FG_TRANSPARENT, /*< skip, pdb-skip >*/
+ GIMP_CUSTOM_MODE = GIMP_BLEND_CUSTOM /*< skip, pdb-skip >*/
} GimpBlendMode;
@@ -69,9 +84,14 @@ GType gimp_bucket_fill_mode_get_type (void) G_GNUC_CONST;
typedef enum
{
- GIMP_FG_BUCKET_FILL, /*< desc="FG color fill" >*/
- GIMP_BG_BUCKET_FILL, /*< desc="BG color fill" >*/
- GIMP_PATTERN_BUCKET_FILL /*< desc="Pattern fill" >*/
+ GIMP_BUCKET_FILL_FG, /*< nick=fg-bucket-fill, desc="FG color fill" >*/
+ GIMP_BUCKET_FILL_BG, /*< nick=bg-bucket-fill, desc="BG color fill" >*/
+ GIMP_BUCKET_FILL_PATTERN, /*< nick=pattern-bucket-fill, desc="Pattern fill" >*/
+
+ /* the following aliases are deprecated */
+ GIMP_FG_BUCKET_FILL = GIMP_BUCKET_FILL_FG, /*< skip, pdb-skip >*/
+ GIMP_BG_BUCKET_FILL = GIMP_BUCKET_FILL_BG, /*< skip, pdb-skip >*/
+ GIMP_PATTERN_BUCKET_FILL = GIMP_BUCKET_FILL_PATTERN /*< skip, pdb-skip >*/
} GimpBucketFillMode;
@@ -136,8 +156,12 @@ GType gimp_clone_type_get_type (void) G_GNUC_CONST;
typedef enum
{
- GIMP_IMAGE_CLONE, /*< desc="Image" >*/
- GIMP_PATTERN_CLONE /*< desc="Pattern" >*/
+ GIMP_CLONE_IMAGE, /*< nick=image-clone, desc="Image" >*/
+ GIMP_CLONE_PATTERN, /*< nick=pattern-clone, desc="Pattern" >*/
+
+ /* the following aliases are deprecated */
+ GIMP_IMAGE_CLONE = GIMP_CLONE_IMAGE, /*< skip, pdb-skip >*/
+ GIMP_PATTERN_CLONE = GIMP_CLONE_PATTERN /*< skip, pdb-skip >*/
} GimpCloneType;
@@ -159,8 +183,12 @@ GType gimp_dodge_burn_type_get_type (void) G_GNUC_CONST;
typedef enum
{
- GIMP_DODGE, /*< desc="Dodge" >*/
- GIMP_BURN /*< desc="Burn" >*/
+ GIMP_DODGE_BURN_TYPE_DODGE, /*< desc="Dodge" >*/
+ GIMP_DODGE_BURN_TYPE_BURN, /*< desc="Burn" >*/
+
+ /* the following aliases are deprecated */
+ GIMP_DODGE = GIMP_DODGE_BURN_TYPE_DODGE, /*< skip, pdb-skip >*/
+ GIMP_BURN = GIMP_DODGE_BURN_TYPE_BURN /*< skip, pdb-skip >*/
} GimpDodgeBurnType;
@@ -259,6 +287,8 @@ typedef enum
GIMP_INTERPOLATION_CUBIC, /*< desc="Cubic" >*/
GIMP_INTERPOLATION_NOHALO, /*< desc="NoHalo" >*/
GIMP_INTERPOLATION_LOHALO, /*< desc="LoHalo" >*/
+
+ /* the following aliases are deprecated */
GIMP_INTERPOLATION_LANCZOS = GIMP_INTERPOLATION_NOHALO /*< skip, pdb-skip >*/
} GimpInterpolationType;
@@ -316,9 +346,14 @@ GType gimp_transfer_mode_get_type (void) G_GNUC_CONST;
typedef enum
{
- GIMP_SHADOWS, /*< desc="Shadows" >*/
- GIMP_MIDTONES, /*< desc="Midtones" >*/
- GIMP_HIGHLIGHTS /*< desc="Highlights" >*/
+ GIMP_TRANSFER_SHADOWS, /*< desc="Shadows" >*/
+ GIMP_TRANSFER_MIDTONES, /*< desc="Midtones" >*/
+ GIMP_TRANSFER_HIGHLIGHTS, /*< desc="Highlights" >*/
+
+ /* the following aliases are deprecated */
+ GIMP_SHADOWS = GIMP_TRANSFER_SHADOWS, /*< skip, pdb-skip >*/
+ GIMP_MIDTONES = GIMP_TRANSFER_MIDTONES, /*< skip, pdb-skip >*/
+ GIMP_HIGHLIGHTS = GIMP_TRANSFER_HIGHLIGHTS /*< skip, pdb-skip >*/
} GimpTransferMode;
diff --git a/plug-ins/file-psd/psd-load.c b/plug-ins/file-psd/psd-load.c
index 731278f..d025a27 100644
--- a/plug-ins/file-psd/psd-load.c
+++ b/plug-ins/file-psd/psd-load.c
@@ -1402,9 +1402,11 @@ add_layers (gint32 image_id,
{
IFDBG(3) g_debug ("Create empty mask");
if (lyr_a[lidx]->layer_mask.def_color == 255)
- mask_id = gimp_layer_create_mask (layer_id, GIMP_ADD_WHITE_MASK);
+ mask_id = gimp_layer_create_mask (layer_id,
+ GIMP_ADD_MASK_WHITE);
else
- mask_id = gimp_layer_create_mask (layer_id, GIMP_ADD_BLACK_MASK);
+ mask_id = gimp_layer_create_mask (layer_id,
+ GIMP_ADD_MASK_BLACK);
gimp_layer_add_mask (layer_id, mask_id);
gimp_layer_set_apply_mask (layer_id,
! lyr_a[lidx]->layer_mask.mask_flags.disabled);
@@ -1488,9 +1490,11 @@ add_layers (gint32 image_id,
IFDBG(3) g_debug ("Mask %d %d %d %d", lm_x, lm_y, lm_w, lm_h);
if (lyr_a[lidx]->layer_mask.def_color == 255)
- mask_id = gimp_layer_create_mask (layer_id, GIMP_ADD_WHITE_MASK);
+ mask_id = gimp_layer_create_mask (layer_id,
+ GIMP_ADD_MASK_WHITE);
else
- mask_id = gimp_layer_create_mask (layer_id, GIMP_ADD_BLACK_MASK);
+ mask_id = gimp_layer_create_mask (layer_id,
+ GIMP_ADD_MASK_BLACK);
IFDBG(3) g_debug ("New layer mask %d", mask_id);
gimp_layer_add_mask (layer_id, mask_id);
diff --git a/plug-ins/gfig/gfig-dialog.c b/plug-ins/gfig/gfig-dialog.c
index 5085ccb..99faa3c 100644
--- a/plug-ins/gfig/gfig-dialog.c
+++ b/plug-ins/gfig/gfig-dialog.c
@@ -1784,7 +1784,7 @@ gfig_paint (BrushType brush_type,
case BRUSH_PATTERN_TYPE:
gimp_clone (drawable_ID,
drawable_ID,
- GIMP_PATTERN_CLONE,
+ GIMP_CLONE_PATTERN,
0.0, 0.0,
seg_count, line_pnts);
break;
@@ -1912,16 +1912,16 @@ paint_layer_fill (gdouble x1, gdouble y1, gdouble x2, gdouble y2)
return;
case FILL_COLOR:
- fill_mode = GIMP_BG_BUCKET_FILL;
+ fill_mode = GIMP_BUCKET_FILL_FG;
break;
case FILL_PATTERN:
- fill_mode = GIMP_PATTERN_BUCKET_FILL;
+ fill_mode = GIMP_BUCKET_FILL_PATTERN;
break;
case FILL_GRADIENT:
gimp_edit_blend (gfig_context->drawable_id,
- GIMP_CUSTOM_MODE,
+ GIMP_BLEND_CUSTOM,
GIMP_NORMAL_MODE,
GIMP_GRADIENT_SHAPEBURST_DIMPLED,
100.0, /* opacity */
@@ -1937,7 +1937,7 @@ paint_layer_fill (gdouble x1, gdouble y1, gdouble x2, gdouble y2)
return;
case FILL_VERTICAL:
gimp_edit_blend (gfig_context->drawable_id,
- GIMP_CUSTOM_MODE,
+ GIMP_BLEND_CUSTOM,
GIMP_NORMAL_MODE,
GIMP_GRADIENT_LINEAR,
100.0,
@@ -1953,7 +1953,7 @@ paint_layer_fill (gdouble x1, gdouble y1, gdouble x2, gdouble y2)
return;
case FILL_HORIZONTAL:
gimp_edit_blend (gfig_context->drawable_id,
- GIMP_CUSTOM_MODE,
+ GIMP_BLEND_CUSTOM,
GIMP_NORMAL_MODE,
GIMP_GRADIENT_LINEAR,
100.0,
diff --git a/plug-ins/pygimp/gimpenumsmodule.c b/plug-ins/pygimp/gimpenumsmodule.c
index 1bc2a98..1b72b9c 100644
--- a/plug-ins/pygimp/gimpenumsmodule.c
+++ b/plug-ins/pygimp/gimpenumsmodule.c
@@ -87,6 +87,58 @@ add_misc_enums(PyObject *m)
}
static void
+add_compat_enums(PyObject *m)
+{
+ PyModule_AddIntConstant(m, "ADD_WHITE_MASK",
+ GIMP_ADD_MASK_WHITE);
+ PyModule_AddIntConstant(m, "ADD_BLACK_MASK",
+ GIMP_ADD_MASK_BLACK);
+ PyModule_AddIntConstant(m, "ADD_ALPHA_MASK",
+ GIMP_ADD_MASK_ALPHA);
+ PyModule_AddIntConstant(m, "ADD_ALPHA_TRANSFER_MASK",
+ GIMP_ADD_MASK_ALPHA_TRANSFER);
+ PyModule_AddIntConstant(m, "ADD_SELECTION_MASK",
+ GIMP_ADD_MASK_SELECTION);
+ PyModule_AddIntConstant(m, "ADD_COPY_MASK",
+ GIMP_ADD_MASK_COPY);
+ PyModule_AddIntConstant(m, "ADD_CHANNEL_MASK",
+ GIMP_ADD_MASK_CHANNEL);
+
+ PyModule_AddIntConstant(m, "FG_BG_RGB_MODE",
+ GIMP_BLEND_FG_BG_RGB);
+ PyModule_AddIntConstant(m, "FG_BG_HSV_MODE",
+ GIMP_BLEND_FG_BG_HSV);
+ PyModule_AddIntConstant(m, "FG_TRANSPARENT_MODE",
+ GIMP_BLEND_FG_TRANSPARENT);
+ PyModule_AddIntConstant(m, "CUSTOM_MODE",
+ GIMP_BLEND_CUSTOM);
+
+ PyModule_AddIntConstant(m, "FG_BUCKET_FILL",
+ GIMP_BUCKET_FILL_FG);
+ PyModule_AddIntConstant(m, "BG_BUCKET_FILL",
+ GIMP_BUCKET_FILL_BG);
+ PyModule_AddIntConstant(m, "PATTERN_BUCKET_FILL",
+ GIMP_BUCKET_FILL_PATTERN);
+
+ PyModule_AddIntConstant(m, "IMAGE_CLONE",
+ GIMP_CLONE_IMAGE);
+ PyModule_AddIntConstant(m, "PATTERN_CLONE",
+ GIMP_CLONE_PATTERN);
+
+ PyModule_AddIntConstant(m, "DODGE",
+ GIMP_DODGE_BURN_TYPE_DODGE);
+ PyModule_AddIntConstant(m, "BURN",
+ GIMP_DODGE_BURN_TYPE_BURN);
+
+ PyModule_AddIntConstant(m, "SHADOWS",
+ GIMP_TRANSFER_SHADOWS);
+ PyModule_AddIntConstant(m, "MIDTONES",
+ GIMP_TRANSFER_MIDTONES);
+ PyModule_AddIntConstant(m, "HIGHLIGHTS",
+ GIMP_TRANSFER_HIGHLIGHTS);
+}
+
+static void
add_registered_enums(PyObject *m)
{
int num_names, i;
@@ -125,6 +177,7 @@ init_gimpenums(void)
m = Py_InitModule3("_gimpenums", NULL, gimpenums_doc);
add_misc_enums(m);
+ add_compat_enums(m);
add_registered_enums(m);
/* Check for errors */
diff --git a/plug-ins/script-fu/scheme-wrapper.c b/plug-ins/script-fu/scheme-wrapper.c
index 8b16085..26ae2da 100644
--- a/plug-ins/script-fu/scheme-wrapper.c
+++ b/plug-ins/script-fu/scheme-wrapper.c
@@ -151,21 +151,21 @@ static const NamedConstant const old_constants[] =
{ "BLUR", GIMP_BLUR_CONVOLVE },
{ "SHARPEN", GIMP_SHARPEN_CONVOLVE },
- { "WHITE-MASK", GIMP_ADD_WHITE_MASK },
- { "BLACK-MASK", GIMP_ADD_BLACK_MASK },
- { "ALPHA-MASK", GIMP_ADD_ALPHA_MASK },
- { "SELECTION-MASK", GIMP_ADD_SELECTION_MASK },
- { "COPY-MASK", GIMP_ADD_COPY_MASK },
+ { "WHITE-MASK", GIMP_ADD_MASK_WHITE },
+ { "BLACK-MASK", GIMP_ADD_MASK_BLACK },
+ { "ALPHA-MASK", GIMP_ADD_MASK_ALPHA },
+ { "SELECTION-MASK", GIMP_ADD_MASK_SELECTION },
+ { "COPY-MASK", GIMP_ADD_MASK_COPY },
{ "ADD", GIMP_CHANNEL_OP_ADD },
{ "SUB", GIMP_CHANNEL_OP_SUBTRACT },
{ "REPLACE", GIMP_CHANNEL_OP_REPLACE },
{ "INTERSECT", GIMP_CHANNEL_OP_INTERSECT },
- { "FG-BG-RGB", GIMP_FG_BG_RGB_MODE },
- { "FG-BG-HSV", GIMP_FG_BG_HSV_MODE },
- { "FG-TRANS", GIMP_FG_TRANSPARENT_MODE },
- { "CUSTOM", GIMP_CUSTOM_MODE },
+ { "FG-BG-RGB", GIMP_BLEND_FG_BG_RGB },
+ { "FG-BG-HSV", GIMP_BLEND_FG_BG_HSV },
+ { "FG-TRANS", GIMP_BLEND_FG_TRANSPARENT },
+ { "CUSTOM", GIMP_BLEND_CUSTOM },
{ "FG-IMAGE-FILL", GIMP_FOREGROUND_FILL },
{ "BG-IMAGE-FILL", GIMP_BACKGROUND_FILL },
@@ -203,6 +203,35 @@ static const NamedConstant const old_constants[] =
{ "BLUE-LUT", GIMP_HISTOGRAM_BLUE },
{ "ALPHA-LUT", GIMP_HISTOGRAM_ALPHA },
+ /* the following enums got cleaned up with properly named values in 2.10 */
+
+ { "ADD-WHITE-MASK", GIMP_ADD_MASK_WHITE },
+ { "ADD-BLACK-MASK", GIMP_ADD_MASK_BLACK },
+ { "ADD-ALPHA-MASK", GIMP_ADD_MASK_ALPHA },
+ { "ADD-ALPHA-TRANSFER-MASK", GIMP_ADD_MASK_ALPHA_TRANSFER },
+ { "ADD-SELECTION-MASK", GIMP_ADD_MASK_SELECTION },
+ { "ADD-COPY-MASK", GIMP_ADD_MASK_COPY },
+ { "ADD-CHANNEL-MASK", GIMP_ADD_MASK_CHANNEL },
+
+ { "FG-BG-RGB-MODE", GIMP_BLEND_FG_BG_RGB },
+ { "FG-BG-HSV-MODE", GIMP_BLEND_FG_BG_HSV },
+ { "FG-TRANSPARENT-MODE", GIMP_BLEND_FG_TRANSPARENT },
+ { "CUSTOM-MODE", GIMP_BLEND_CUSTOM },
+
+ { "FG-BUCKET_FILL", GIMP_BUCKET_FILL_FG },
+ { "BG-BUCKET_FILL", GIMP_BUCKET_FILL_BG },
+ { "PATTERN-BUCKET_FILL", GIMP_BUCKET_FILL_PATTERN },
+
+ { "IMAGE-CLONE", GIMP_CLONE_IMAGE },
+ { "PATTERN-CLONE", GIMP_CLONE_PATTERN },
+
+ { "DODGE", GIMP_DODGE_BURN_TYPE_DODGE },
+ { "BURN", GIMP_DODGE_BURN_TYPE_BURN },
+
+ { "SHADOWS", GIMP_TRANSFER_SHADOWS },
+ { "MIDTONES", GIMP_TRANSFER_MIDTONES },
+ { "HIGHLIGHTS", GIMP_TRANSFER_HIGHLIGHTS },
+
{ NULL, 0 }
};
diff --git a/tools/pdbgen/enums.pl b/tools/pdbgen/enums.pl
index 781894d..6fb3255 100644
--- a/tools/pdbgen/enums.pl
+++ b/tools/pdbgen/enums.pl
@@ -22,36 +22,36 @@ package Gimp::CodeGen::enums;
GimpAddMaskType =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
- symbols => [ qw(GIMP_ADD_WHITE_MASK GIMP_ADD_BLACK_MASK
- GIMP_ADD_ALPHA_MASK GIMP_ADD_ALPHA_TRANSFER_MASK
- GIMP_ADD_SELECTION_MASK GIMP_ADD_COPY_MASK
- GIMP_ADD_CHANNEL_MASK) ],
- mapping => { GIMP_ADD_WHITE_MASK => '0',
- GIMP_ADD_BLACK_MASK => '1',
- GIMP_ADD_ALPHA_MASK => '2',
- GIMP_ADD_ALPHA_TRANSFER_MASK => '3',
- GIMP_ADD_SELECTION_MASK => '4',
- GIMP_ADD_COPY_MASK => '5',
- GIMP_ADD_CHANNEL_MASK => '6' }
+ symbols => [ qw(GIMP_ADD_MASK_WHITE GIMP_ADD_MASK_BLACK
+ GIMP_ADD_MASK_ALPHA GIMP_ADD_MASK_ALPHA_TRANSFER
+ GIMP_ADD_MASK_SELECTION GIMP_ADD_MASK_COPY
+ GIMP_ADD_MASK_CHANNEL) ],
+ mapping => { GIMP_ADD_MASK_WHITE => '0',
+ GIMP_ADD_MASK_BLACK => '1',
+ GIMP_ADD_MASK_ALPHA => '2',
+ GIMP_ADD_MASK_ALPHA_TRANSFER => '3',
+ GIMP_ADD_MASK_SELECTION => '4',
+ GIMP_ADD_MASK_COPY => '5',
+ GIMP_ADD_MASK_CHANNEL => '6' }
},
GimpBlendMode =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
- symbols => [ qw(GIMP_FG_BG_RGB_MODE GIMP_FG_BG_HSV_MODE
- GIMP_FG_TRANSPARENT_MODE GIMP_CUSTOM_MODE) ],
- mapping => { GIMP_FG_BG_RGB_MODE => '0',
- GIMP_FG_BG_HSV_MODE => '1',
- GIMP_FG_TRANSPARENT_MODE => '2',
- GIMP_CUSTOM_MODE => '3' }
+ symbols => [ qw(GIMP_BLEND_FG_BG_RGB GIMP_BLEND_FG_BG_HSV
+ GIMP_BLEND_FG_TRANSPARENT GIMP_BLEND_CUSTOM) ],
+ mapping => { GIMP_BLEND_FG_BG_RGB => '0',
+ GIMP_BLEND_FG_BG_HSV => '1',
+ GIMP_BLEND_FG_TRANSPARENT => '2',
+ GIMP_BLEND_CUSTOM => '3' }
},
GimpBucketFillMode =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
- symbols => [ qw(GIMP_FG_BUCKET_FILL GIMP_BG_BUCKET_FILL
- GIMP_PATTERN_BUCKET_FILL) ],
- mapping => { GIMP_FG_BUCKET_FILL => '0',
- GIMP_BG_BUCKET_FILL => '1',
- GIMP_PATTERN_BUCKET_FILL => '2' }
+ symbols => [ qw(GIMP_BUCKET_FILL_FG GIMP_BUCKET_FILL_BG
+ GIMP_BUCKET_FILL_PATTERN) ],
+ mapping => { GIMP_BUCKET_FILL_FG => '0',
+ GIMP_BUCKET_FILL_BG => '1',
+ GIMP_BUCKET_FILL_PATTERN => '2' }
},
GimpChannelOps =>
{ contig => 1,
@@ -79,9 +79,9 @@ package Gimp::CodeGen::enums;
GimpCloneType =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
- symbols => [ qw(GIMP_IMAGE_CLONE GIMP_PATTERN_CLONE) ],
- mapping => { GIMP_IMAGE_CLONE => '0',
- GIMP_PATTERN_CLONE => '1' }
+ symbols => [ qw(GIMP_CLONE_IMAGE GIMP_CLONE_PATTERN) ],
+ mapping => { GIMP_CLONE_IMAGE => '0',
+ GIMP_CLONE_PATTERN => '1' }
},
GimpDesaturateMode =>
{ contig => 1,
@@ -95,9 +95,10 @@ package Gimp::CodeGen::enums;
GimpDodgeBurnType =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
- symbols => [ qw(GIMP_DODGE GIMP_BURN) ],
- mapping => { GIMP_DODGE => '0',
- GIMP_BURN => '1' }
+ symbols => [ qw(GIMP_DODGE_BURN_TYPE_DODGE
+ GIMP_DODGE_BURN_TYPE_BURN) ],
+ mapping => { GIMP_DODGE_BURN_TYPE_DODGE => '0',
+ GIMP_DODGE_BURN_TYPE_BURN => '1' }
},
GimpForegroundExtractMode =>
{ contig => 1,
@@ -222,10 +223,11 @@ package Gimp::CodeGen::enums;
GimpTransferMode =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
- symbols => [ qw(GIMP_SHADOWS GIMP_MIDTONES GIMP_HIGHLIGHTS) ],
- mapping => { GIMP_SHADOWS => '0',
- GIMP_MIDTONES => '1',
- GIMP_HIGHLIGHTS => '2' }
+ symbols => [ qw(GIMP_TRANSFER_SHADOWS GIMP_TRANSFER_MIDTONES
+ GIMP_TRANSFER_HIGHLIGHTS) ],
+ mapping => { GIMP_TRANSFER_SHADOWS => '0',
+ GIMP_TRANSFER_MIDTONES => '1',
+ GIMP_TRANSFER_HIGHLIGHTS => '2' }
},
GimpTransformDirection =>
{ contig => 1,
diff --git a/tools/pdbgen/pdb/edit.pdb b/tools/pdbgen/pdb/edit.pdb
index 8abc97b..a25f9c4 100644
--- a/tools/pdbgen/pdb/edit.pdb
+++ b/tools/pdbgen/pdb/edit.pdb
@@ -640,19 +640,19 @@ HELP
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
{
- GimpFillType fill_type = GIMP_FG_BUCKET_FILL;
+ GimpFillType fill_type = GIMP_FOREGROUND_FILL;
switch (fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
fill_type = GIMP_FOREGROUND_FILL;
break;
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_BG:
fill_type = GIMP_BACKGROUND_FILL;
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
fill_type = GIMP_PATTERN_FILL;
break;
}
@@ -748,19 +748,19 @@ HELP
if (! gimp_channel_is_empty (gimp_image_get_mask (image)))
{
- GimpFillType fill_type = GIMP_FG_BUCKET_FILL;
+ GimpFillType fill_type = GIMP_FOREGROUND_FILL;
switch (fill_mode)
{
- case GIMP_FG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_FG:
fill_type = GIMP_FOREGROUND_FILL;
break;
- case GIMP_BG_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_BG:
fill_type = GIMP_BACKGROUND_FILL;
break;
- case GIMP_PATTERN_BUCKET_FILL:
+ case GIMP_BUCKET_FILL_PATTERN:
fill_type = GIMP_PATTERN_FILL;
break;
}
diff --git a/tools/pdbgen/pdb/layer.pdb b/tools/pdbgen/pdb/layer.pdb
index 53a2ca7..464dbb0 100644
--- a/tools/pdbgen/pdb/layer.pdb
+++ b/tools/pdbgen/pdb/layer.pdb
@@ -331,7 +331,7 @@ HELP
{
GimpChannel *channel = NULL;
- if (mask_type == GIMP_ADD_CHANNEL_MASK)
+ if (mask_type == GIMP_ADD_MASK_CHANNEL)
{
channel = gimp_image_get_active_channel (gimp_item_get_image (GIMP_ITEM (layer)));
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
