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

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.
This commit is contained in:
Michael Natterer 2014-04-29 20:55:08 +02:00
parent 86a2f3851f
commit 22c222291d
31 changed files with 353 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/actions/layers-commands.c
View File

@ -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,

12
app/core/gimpdrawable-blend.c
View File

@ -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:

16
app/core/gimpdrawable-bucket-fill.c
View File

@ -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);

24
app/core/gimplayer.c
View File

@ -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;

2
app/dialogs/layer-add-mask-dialog.c
View File

@ -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",

8
app/gegl/gimp-gegl-loops.c
View File

@ -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

18
app/operations/gimpcolorbalanceconfig.c
View File

@ -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];

18
app/operations/gimpoperationcolorbalance.c
View File

@ -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)
{

6
app/paint/gimpclone.c
View File

@ -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;
}

2
app/paint/gimpcloneoptions.c
View File

@ -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);
}

4
app/paint/gimpdodgeburnoptions.c
View File

@ -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

8
app/paint/gimpperspectiveclone.c
View File

@ -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,

2
app/pdb/color-cmds.c
View File

@ -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",

2
app/pdb/drawable-color-cmds.c
View File

@ -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",

22
app/pdb/edit-cmds.c
View File

@ -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",

4
app/pdb/layer-cmds.c
View File

@ -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",

6
app/pdb/paint-tools-cmds.c
View File

@ -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",

2
app/tools/gimpblendtool.c
View File

@ -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),

4
app/tools/gimpbucketfilloptions.c
View File

@ -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)"),

20
app/tools/gimpbucketfilltool.c
View File

@ -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;
}

4
app/tools/gimpcloneoptions-gui.c
View File

@ -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"));

17
app/tools/gimpdodgeburntool.c
View File

@ -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");

84
libgimpbase/gimpbaseenums.c
View File

@ -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 }
};

77
libgimpbase/gimpbaseenums.h
View File

@ -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;

12
plug-ins/file-psd/psd-load.c
View File

@ -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);

12
plug-ins/gfig/gfig-dialog.c
View File

@ -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,

53
plug-ins/pygimp/gimpenumsmodule.c
View File

@ -86,6 +86,58 @@ add_misc_enums(PyObject *m)
GIMP_PIXEL_FETCHER_EDGE_BACKGROUND);
}
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)
{
@ -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 */

47
plug-ins/script-fu/scheme-wrapper.c
View File

@ -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 }
};

66
tools/pdbgen/enums.pl
View File

@ -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,

16
tools/pdbgen/pdb/edit.pdb
View File

@ -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;
}

2
tools/pdbgen/pdb/layer.pdb
View File

@ -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)));