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

app, libgimp*, plug-ins: replace enum GimpLayerModeEffects by GimpLayerMode 

with proper value names. Mark most values as _BROKEN because they use
weird alpha compositing that has to die. Move GimpLayerModeEffects to
libgimpbase, deprecate it, and set it as compat enum for GimpLayerMode.
Add the GimpLayerModeEffects values as compat constants to script-fu
and pygimp.
This commit is contained in:
Michael Natterer 2017-01-08 23:00:19 +01:00
parent 4fb62427a2
commit 66060e3307
171 changed files with 1921 additions and 1445 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
app/actions/context-commands.c
View File

@ -48,35 +48,35 @@
#include "gimp-intl.h"
static const GimpLayerModeEffects paint_modes[] =
static const GimpLayerMode paint_modes[] =
{
GIMP_NORMAL_MODE,
GIMP_DISSOLVE_MODE,
GIMP_BEHIND_MODE,
GIMP_COLOR_ERASE_MODE,
GIMP_MULTIPLY_MODE,
GIMP_DIVIDE_MODE,
GIMP_SCREEN_MODE,
GIMP_NEW_OVERLAY_MODE,
GIMP_DODGE_MODE,
GIMP_BURN_MODE,
GIMP_HARDLIGHT_MODE,
GIMP_SOFTLIGHT_MODE,
GIMP_GRAIN_EXTRACT_MODE,
GIMP_GRAIN_MERGE_MODE,
GIMP_DIFFERENCE_MODE,
GIMP_ADDITION_MODE,
GIMP_SUBTRACT_MODE,
GIMP_DARKEN_ONLY_MODE,
GIMP_LIGHTEN_ONLY_MODE,
GIMP_HUE_MODE,
GIMP_SATURATION_MODE,
GIMP_COLOR_MODE,
GIMP_VALUE_MODE,
GIMP_LCH_HUE_MODE,
GIMP_LCH_CHROMA_MODE,
GIMP_LCH_COLOR_MODE,
GIMP_LCH_LIGHTNESS_MODE
GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LAYER_MODE_BEHIND,
GIMP_LAYER_MODE_COLOR_ERASE,
GIMP_LAYER_MODE_MULTIPLY_BROKEN,
GIMP_LAYER_MODE_DIVIDE_BROKEN,
GIMP_LAYER_MODE_SCREEN_BROKEN,
GIMP_LAYER_MODE_OVERLAY,
GIMP_LAYER_MODE_DODGE_BROKEN,
GIMP_LAYER_MODE_BURN_BROKEN,
GIMP_LAYER_MODE_HARDLIGHT_BROKEN,
GIMP_LAYER_MODE_SOFTLIGHT_BROKEN,
GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN,
GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN,
GIMP_LAYER_MODE_DIFFERENCE_BROKEN,
GIMP_LAYER_MODE_ADDITION_BROKEN,
GIMP_LAYER_MODE_SUBTRACT_BROKEN,
GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN,
GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN,
GIMP_LAYER_MODE_HSV_HUE_BROKEN,
GIMP_LAYER_MODE_HSV_SATURATION_BROKEN,
GIMP_LAYER_MODE_HSV_COLOR_BROKEN,
GIMP_LAYER_MODE_HSV_VALUE_BROKEN,
GIMP_LAYER_MODE_LCH_HUE,
GIMP_LAYER_MODE_LCH_CHROMA,
GIMP_LAYER_MODE_LCH_COLOR,
GIMP_LAYER_MODE_LCH_LIGHTNESS
};
@ -85,7 +85,7 @@ static const GimpLayerModeEffects paint_modes[] =
static void context_select_object (GimpActionSelectType select_type,
GimpContext *context,
GimpContainer *container);
static gint context_paint_mode_index (GimpLayerModeEffects paint_mode);
static gint context_paint_mode_index (GimpLayerMode paint_mode);
static void context_select_color (GimpActionSelectType select_type,
GimpRGB *color,
@ -399,10 +399,10 @@ context_paint_mode_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpContext *context;
GimpToolInfo *tool_info;
GimpLayerModeEffects paint_mode;
gint index;
GimpContext *context;
GimpToolInfo *tool_info;
GimpLayerMode paint_mode;
gint index;
return_if_no_context (context, data);
paint_mode = gimp_context_get_paint_mode (context);
@ -420,7 +420,7 @@ context_paint_mode_cmd_callback (GtkAction *action,
GimpDisplay *display;
const char *value_desc;
gimp_enum_get_value (GIMP_TYPE_LAYER_MODE_EFFECTS, index,
gimp_enum_get_value (GIMP_TYPE_LAYER_MODE, index,
NULL, NULL, &value_desc, NULL);
display = action_data_get_display (data);
@ -748,7 +748,7 @@ context_select_object (GimpActionSelectType select_type,
}
static gint
context_paint_mode_index (GimpLayerModeEffects paint_mode)
context_paint_mode_index (GimpLayerMode paint_mode)
{
gint i = 0;

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

@ -81,33 +81,33 @@
#include "gimp-intl.h"
static const GimpLayerModeEffects layer_modes[] =
static const GimpLayerMode layer_modes[] =
{
GIMP_NORMAL_MODE,
GIMP_DISSOLVE_MODE,
GIMP_MULTIPLY_MODE,
GIMP_DIVIDE_MODE,
GIMP_SCREEN_MODE,
GIMP_NEW_OVERLAY_MODE,
GIMP_DODGE_MODE,
GIMP_BURN_MODE,
GIMP_HARDLIGHT_MODE,
GIMP_SOFTLIGHT_MODE,
GIMP_GRAIN_EXTRACT_MODE,
GIMP_GRAIN_MERGE_MODE,
GIMP_DIFFERENCE_MODE,
GIMP_ADDITION_MODE,
GIMP_SUBTRACT_MODE,
GIMP_DARKEN_ONLY_MODE,
GIMP_LIGHTEN_ONLY_MODE,
GIMP_HUE_MODE,
GIMP_SATURATION_MODE,
GIMP_COLOR_MODE,
GIMP_VALUE_MODE,
GIMP_LCH_HUE_MODE,
GIMP_LCH_CHROMA_MODE,
GIMP_LCH_COLOR_MODE,
GIMP_LCH_LIGHTNESS_MODE
GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LAYER_MODE_MULTIPLY_BROKEN,
GIMP_LAYER_MODE_DIVIDE_BROKEN,
GIMP_LAYER_MODE_SCREEN_BROKEN,
GIMP_LAYER_MODE_OVERLAY,
GIMP_LAYER_MODE_DODGE_BROKEN,
GIMP_LAYER_MODE_BURN_BROKEN,
GIMP_LAYER_MODE_HARDLIGHT_BROKEN,
GIMP_LAYER_MODE_SOFTLIGHT_BROKEN,
GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN,
GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN,
GIMP_LAYER_MODE_DIFFERENCE_BROKEN,
GIMP_LAYER_MODE_ADDITION_BROKEN,
GIMP_LAYER_MODE_SUBTRACT_BROKEN,
GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN,
GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN,
GIMP_LAYER_MODE_HSV_HUE_BROKEN,
GIMP_LAYER_MODE_HSV_SATURATION_BROKEN,
GIMP_LAYER_MODE_HSV_COLOR_BROKEN,
GIMP_LAYER_MODE_HSV_VALUE_BROKEN,
GIMP_LAYER_MODE_LCH_HUE,
GIMP_LAYER_MODE_LCH_CHROMA,
GIMP_LAYER_MODE_LCH_COLOR,
GIMP_LAYER_MODE_LCH_LIGHTNESS
};
@ -118,7 +118,7 @@ static void layers_new_callback (GtkWidget *dialog,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gint layer_width,
@ -138,7 +138,7 @@ static void layers_edit_attributes_callback (GtkWidget *dialog,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gint layer_width,
@ -182,7 +182,7 @@ static void layers_resize_callback (GtkWidget *dialog,
gboolean unused2,
gpointer data);
static gint layers_mode_index (GimpLayerModeEffects layer_mode);
static gint layers_mode_index (GimpLayerMode layer_mode);
/* private variables */
@ -346,15 +346,15 @@ void
layers_new_last_vals_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *image;
GtkWidget *widget;
GimpLayer *floating_sel;
GimpLayer *new_layer;
gint width, height;
gint off_x, off_y;
gdouble opacity;
GimpLayerModeEffects mode;
GimpDialogConfig *config;
GimpImage *image;
GtkWidget *widget;
GimpLayer *floating_sel;
GimpLayer *new_layer;
gint width, height;
gint off_x, off_y;
gdouble opacity;
GimpLayerMode mode;
GimpDialogConfig *config;
return_if_no_image (image, data);
return_if_no_widget (widget, data);
@ -386,7 +386,7 @@ layers_new_last_vals_cmd_callback (GtkAction *action,
off_x = 0;
off_y = 0;
opacity = 1.0;
mode = GIMP_NORMAL_MODE;
mode = GIMP_LAYER_MODE_NORMAL;
}
gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
@ -432,7 +432,7 @@ layers_new_from_visible_cmd_callback (GtkAction *action,
TRUE),
_("Visible"),
GIMP_OPACITY_OPAQUE,
GIMP_NORMAL_MODE,
GIMP_LAYER_MODE_NORMAL,
profile);
gimp_image_add_layer (image, layer, GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
@ -1109,12 +1109,12 @@ layers_mode_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpImage *image;
GimpLayer *layer;
GimpLayerModeEffects layer_mode;
gint index;
GimpUndo *undo;
gboolean push_undo = TRUE;
GimpImage *image;
GimpLayer *layer;
GimpLayerMode layer_mode;
gint index;
GimpUndo *undo;
gboolean push_undo = TRUE;
return_if_no_layer (image, layer, data);
undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
@ -1221,26 +1221,26 @@ layers_color_tag_cmd_callback (GtkAction *action,
/* private functions */
static void
layers_new_callback (GtkWidget *dialog,
GimpImage *image,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gint layer_width,
gint layer_height,
gint layer_offset_x,
gint layer_offset_y,
gboolean layer_visible,
gboolean layer_linked,
GimpColorTag layer_color_tag,
gboolean layer_lock_pixels,
gboolean layer_lock_position,
gboolean layer_lock_alpha,
gboolean rename_text_layer, /* unused */
gpointer user_data)
layers_new_callback (GtkWidget *dialog,
GimpImage *image,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gint layer_width,
gint layer_height,
gint layer_offset_x,
gint layer_offset_y,
gboolean layer_visible,
gboolean layer_linked,
GimpColorTag layer_color_tag,
gboolean layer_lock_pixels,
gboolean layer_lock_position,
gboolean layer_lock_alpha,
gboolean rename_text_layer, /* unused */
gpointer user_data)
{
GimpDialogConfig *config = GIMP_DIALOG_CONFIG (image->gimp->config);
@ -1284,26 +1284,26 @@ layers_new_callback (GtkWidget *dialog,
}
static void
layers_edit_attributes_callback (GtkWidget *dialog,
GimpImage *image,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
gdouble layer_opacity,
GimpFillType unused1,
gint unused2,
gint unused3,
gint layer_offset_x,
gint layer_offset_y,
gboolean layer_visible,
gboolean layer_linked,
GimpColorTag layer_color_tag,
gboolean layer_lock_pixels,
gboolean layer_lock_position,
gboolean layer_lock_alpha,
gboolean rename_text_layer,
gpointer user_data)
layers_edit_attributes_callback (GtkWidget *dialog,
GimpImage *image,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType unused1,
gint unused2,
gint unused3,
gint layer_offset_x,
gint layer_offset_y,
gboolean layer_visible,
gboolean layer_linked,
GimpColorTag layer_color_tag,
gboolean layer_lock_pixels,
gboolean layer_lock_position,
gboolean layer_lock_alpha,
gboolean rename_text_layer,
gpointer user_data)
{
GimpItem *item = GIMP_ITEM (layer);
@ -1528,7 +1528,7 @@ layers_resize_callback (GtkWidget *dialog,
}
static gint
layers_mode_index (GimpLayerModeEffects layer_mode)
layers_mode_index (GimpLayerMode layer_mode)
{
gint i = 0;

10
app/app.c
View File

@ -38,7 +38,9 @@
#include <winnls.h>
#endif
#undef GIMP_DISABLE_DEPRECATED /* for compat enums */
#include "libgimpbase/gimpbase.h"
#define GIMP_DISABLE_DEPRECATED
#include "libgimpconfig/gimpconfig.h"
#include "core/core-types.h"
@ -91,6 +93,8 @@ void
app_libs_init (GOptionContext *context,
gboolean no_interface)
{
GQuark quark;
/* disable OpenCL before GEGL is even initialized; this way we only
* enable if wanted in gimprc, instead of always enabling, and then
* disabling again if wanted in gimprc
@ -108,6 +112,12 @@ app_libs_init (GOptionContext *context,
gui_libs_init (context);
}
#endif
/* keep compat enum code in sync with tools/pdbgen/enumcode.pl */
quark = g_quark_from_static_string ("gimp-compat-enum");
g_type_set_qdata (GIMP_TYPE_LAYER_MODE, quark,
(gpointer) GIMP_TYPE_LAYER_MODE_EFFECTS);
}
void

4
app/config/gimpdialogconfig.c
View File

@ -298,8 +298,8 @@ gimp_dialog_config_class_init (GimpDialogConfigClass *klass)
"layer-new-mode",
"Default new layer mode",
LAYER_NEW_MODE_BLURB,
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_DOUBLE (object_class, PROP_LAYER_NEW_OPACITY,

2
app/config/gimpdialogconfig.h
View File

@ -65,7 +65,7 @@ struct _GimpDialogConfig
gboolean image_resize_resize_text_layers;
gchar *layer_new_name;
GimpLayerModeEffects layer_new_mode;
GimpLayerMode layer_new_mode;
gdouble layer_new_opacity;
GimpFillType layer_new_fill_type;

130
app/core/core-enums.c
View File

@ -285,77 +285,77 @@ gimp_histogram_channel_get_type (void)
}
GType
gimp_layer_mode_effects_get_type (void)
gimp_layer_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_NORMAL_MODE, "GIMP_NORMAL_MODE", "normal-mode" },
{ GIMP_DISSOLVE_MODE, "GIMP_DISSOLVE_MODE", "dissolve-mode" },
{ GIMP_BEHIND_MODE, "GIMP_BEHIND_MODE", "behind-mode" },
{ GIMP_MULTIPLY_MODE, "GIMP_MULTIPLY_MODE", "multiply-mode" },
{ GIMP_SCREEN_MODE, "GIMP_SCREEN_MODE", "screen-mode" },
{ GIMP_OVERLAY_MODE, "GIMP_OVERLAY_MODE", "overlay-mode" },
{ GIMP_DIFFERENCE_MODE, "GIMP_DIFFERENCE_MODE", "difference-mode" },
{ GIMP_ADDITION_MODE, "GIMP_ADDITION_MODE", "addition-mode" },
{ GIMP_SUBTRACT_MODE, "GIMP_SUBTRACT_MODE", "subtract-mode" },
{ GIMP_DARKEN_ONLY_MODE, "GIMP_DARKEN_ONLY_MODE", "darken-only-mode" },
{ GIMP_LIGHTEN_ONLY_MODE, "GIMP_LIGHTEN_ONLY_MODE", "lighten-only-mode" },
{ GIMP_HUE_MODE, "GIMP_HUE_MODE", "hue-mode" },
{ GIMP_SATURATION_MODE, "GIMP_SATURATION_MODE", "saturation-mode" },
{ GIMP_COLOR_MODE, "GIMP_COLOR_MODE", "color-mode" },
{ GIMP_VALUE_MODE, "GIMP_VALUE_MODE", "value-mode" },
{ GIMP_DIVIDE_MODE, "GIMP_DIVIDE_MODE", "divide-mode" },
{ GIMP_DODGE_MODE, "GIMP_DODGE_MODE", "dodge-mode" },
{ GIMP_BURN_MODE, "GIMP_BURN_MODE", "burn-mode" },
{ GIMP_HARDLIGHT_MODE, "GIMP_HARDLIGHT_MODE", "hardlight-mode" },
{ GIMP_SOFTLIGHT_MODE, "GIMP_SOFTLIGHT_MODE", "softlight-mode" },
{ GIMP_GRAIN_EXTRACT_MODE, "GIMP_GRAIN_EXTRACT_MODE", "grain-extract-mode" },
{ GIMP_GRAIN_MERGE_MODE, "GIMP_GRAIN_MERGE_MODE", "grain-merge-mode" },
{ GIMP_COLOR_ERASE_MODE, "GIMP_COLOR_ERASE_MODE", "color-erase-mode" },
{ GIMP_NEW_OVERLAY_MODE, "GIMP_NEW_OVERLAY_MODE", "new-overlay-mode" },
{ GIMP_LCH_HUE_MODE, "GIMP_LCH_HUE_MODE", "lch-hue-mode" },
{ GIMP_LCH_CHROMA_MODE, "GIMP_LCH_CHROMA_MODE", "lch-chroma-mode" },
{ GIMP_LCH_COLOR_MODE, "GIMP_LCH_COLOR_MODE", "lch-color-mode" },
{ GIMP_LCH_LIGHTNESS_MODE, "GIMP_LCH_LIGHTNESS_MODE", "lch-lightness-mode" },
{ GIMP_ERASE_MODE, "GIMP_ERASE_MODE", "erase-mode" },
{ GIMP_REPLACE_MODE, "GIMP_REPLACE_MODE", "replace-mode" },
{ GIMP_ANTI_ERASE_MODE, "GIMP_ANTI_ERASE_MODE", "anti-erase-mode" },
{ GIMP_LAYER_MODE_NORMAL, "GIMP_LAYER_MODE_NORMAL", "normal" },
{ GIMP_LAYER_MODE_DISSOLVE, "GIMP_LAYER_MODE_DISSOLVE", "dissolve" },
{ GIMP_LAYER_MODE_BEHIND, "GIMP_LAYER_MODE_BEHIND", "behind" },
{ GIMP_LAYER_MODE_MULTIPLY_BROKEN, "GIMP_LAYER_MODE_MULTIPLY_BROKEN", "multiply-broken" },
{ GIMP_LAYER_MODE_SCREEN_BROKEN, "GIMP_LAYER_MODE_SCREEN_BROKEN", "screen-broken" },
{ GIMP_LAYER_MODE_OVERLAY_BROKEN, "GIMP_LAYER_MODE_OVERLAY_BROKEN", "overlay-broken" },
{ GIMP_LAYER_MODE_DIFFERENCE_BROKEN, "GIMP_LAYER_MODE_DIFFERENCE_BROKEN", "difference-broken" },
{ GIMP_LAYER_MODE_ADDITION_BROKEN, "GIMP_LAYER_MODE_ADDITION_BROKEN", "addition-broken" },
{ GIMP_LAYER_MODE_SUBTRACT_BROKEN, "GIMP_LAYER_MODE_SUBTRACT_BROKEN", "subtract-broken" },
{ GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN, "GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN", "darken-only-broken" },
{ GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN, "GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN", "lighten-only-broken" },
{ GIMP_LAYER_MODE_HSV_HUE_BROKEN, "GIMP_LAYER_MODE_HSV_HUE_BROKEN", "hsv-hue-broken" },
{ GIMP_LAYER_MODE_HSV_SATURATION_BROKEN, "GIMP_LAYER_MODE_HSV_SATURATION_BROKEN", "hsv-saturation-broken" },
{ GIMP_LAYER_MODE_HSV_COLOR_BROKEN, "GIMP_LAYER_MODE_HSV_COLOR_BROKEN", "hsv-color-broken" },
{ GIMP_LAYER_MODE_HSV_VALUE_BROKEN, "GIMP_LAYER_MODE_HSV_VALUE_BROKEN", "hsv-value-broken" },
{ GIMP_LAYER_MODE_DIVIDE_BROKEN, "GIMP_LAYER_MODE_DIVIDE_BROKEN", "divide-broken" },
{ GIMP_LAYER_MODE_DODGE_BROKEN, "GIMP_LAYER_MODE_DODGE_BROKEN", "dodge-broken" },
{ GIMP_LAYER_MODE_BURN_BROKEN, "GIMP_LAYER_MODE_BURN_BROKEN", "burn-broken" },
{ GIMP_LAYER_MODE_HARDLIGHT_BROKEN, "GIMP_LAYER_MODE_HARDLIGHT_BROKEN", "hardlight-broken" },
{ GIMP_LAYER_MODE_SOFTLIGHT_BROKEN, "GIMP_LAYER_MODE_SOFTLIGHT_BROKEN", "softlight-broken" },
{ GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN, "GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN", "grain-extract-broken" },
{ GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN, "GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN", "grain-merge-broken" },
{ GIMP_LAYER_MODE_COLOR_ERASE, "GIMP_LAYER_MODE_COLOR_ERASE", "color-erase" },
{ GIMP_LAYER_MODE_OVERLAY, "GIMP_LAYER_MODE_OVERLAY", "overlay" },
{ GIMP_LAYER_MODE_LCH_HUE, "GIMP_LAYER_MODE_LCH_HUE", "lch-hue" },
{ GIMP_LAYER_MODE_LCH_CHROMA, "GIMP_LAYER_MODE_LCH_CHROMA", "lch-chroma" },
{ GIMP_LAYER_MODE_LCH_COLOR, "GIMP_LAYER_MODE_LCH_COLOR", "lch-color" },
{ GIMP_LAYER_MODE_LCH_LIGHTNESS, "GIMP_LAYER_MODE_LCH_LIGHTNESS", "lch-lightness" },
{ GIMP_LAYER_MODE_ERASE, "GIMP_LAYER_MODE_ERASE", "erase" },
{ GIMP_LAYER_MODE_REPLACE, "GIMP_LAYER_MODE_REPLACE", "replace" },
{ GIMP_LAYER_MODE_ANTI_ERASE, "GIMP_LAYER_MODE_ANTI_ERASE", "anti-erase" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_NORMAL_MODE, NC_("layer-mode-effects", "Normal"), NULL },
{ GIMP_DISSOLVE_MODE, NC_("layer-mode-effects", "Dissolve"), NULL },
{ GIMP_BEHIND_MODE, NC_("layer-mode-effects", "Behind"), NULL },
{ GIMP_MULTIPLY_MODE, NC_("layer-mode-effects", "Multiply"), NULL },
{ GIMP_SCREEN_MODE, NC_("layer-mode-effects", "Screen"), NULL },
{ GIMP_OVERLAY_MODE, NC_("layer-mode-effects", "Old broken Overlay"), NULL },
{ GIMP_DIFFERENCE_MODE, NC_("layer-mode-effects", "Difference"), NULL },
{ GIMP_ADDITION_MODE, NC_("layer-mode-effects", "Addition"), NULL },
{ GIMP_SUBTRACT_MODE, NC_("layer-mode-effects", "Subtract"), NULL },
{ GIMP_DARKEN_ONLY_MODE, NC_("layer-mode-effects", "Darken only"), NULL },
{ GIMP_LIGHTEN_ONLY_MODE, NC_("layer-mode-effects", "Lighten only"), NULL },
{ GIMP_HUE_MODE, NC_("layer-mode-effects", "Hue (HSV)"), NULL },
{ GIMP_SATURATION_MODE, NC_("layer-mode-effects", "Saturation (HSV)"), NULL },
{ GIMP_COLOR_MODE, NC_("layer-mode-effects", "Color (HSV)"), NULL },
{ GIMP_VALUE_MODE, NC_("layer-mode-effects", "Value (HSV)"), NULL },
{ GIMP_DIVIDE_MODE, NC_("layer-mode-effects", "Divide"), NULL },
{ GIMP_DODGE_MODE, NC_("layer-mode-effects", "Dodge"), NULL },
{ GIMP_BURN_MODE, NC_("layer-mode-effects", "Burn"), NULL },
{ GIMP_HARDLIGHT_MODE, NC_("layer-mode-effects", "Hard light"), NULL },
{ GIMP_SOFTLIGHT_MODE, NC_("layer-mode-effects", "Soft light"), NULL },
{ GIMP_GRAIN_EXTRACT_MODE, NC_("layer-mode-effects", "Grain extract"), NULL },
{ GIMP_GRAIN_MERGE_MODE, NC_("layer-mode-effects", "Grain merge"), NULL },
{ GIMP_COLOR_ERASE_MODE, NC_("layer-mode-effects", "Color erase"), NULL },
{ GIMP_NEW_OVERLAY_MODE, NC_("layer-mode-effects", "Overlay"), NULL },
{ GIMP_LCH_HUE_MODE, NC_("layer-mode-effects", "Hue (LCH)"), NULL },
{ GIMP_LCH_CHROMA_MODE, NC_("layer-mode-effects", "Chroma (LCH)"), NULL },
{ GIMP_LCH_COLOR_MODE, NC_("layer-mode-effects", "Color (LCH)"), NULL },
{ GIMP_LCH_LIGHTNESS_MODE, NC_("layer-mode-effects", "Lightness (LCH)"), NULL },
{ GIMP_ERASE_MODE, NC_("layer-mode-effects", "Erase"), NULL },
{ GIMP_REPLACE_MODE, NC_("layer-mode-effects", "Replace"), NULL },
{ GIMP_ANTI_ERASE_MODE, NC_("layer-mode-effects", "Anti erase"), NULL },
{ GIMP_LAYER_MODE_NORMAL, NC_("layer-mode", "Normal"), NULL },
{ GIMP_LAYER_MODE_DISSOLVE, NC_("layer-mode", "Dissolve"), NULL },
{ GIMP_LAYER_MODE_BEHIND, NC_("layer-mode", "Behind"), NULL },
{ GIMP_LAYER_MODE_MULTIPLY_BROKEN, NC_("layer-mode", "Multiply"), NULL },
{ GIMP_LAYER_MODE_SCREEN_BROKEN, NC_("layer-mode", "Screen"), NULL },
{ GIMP_LAYER_MODE_OVERLAY_BROKEN, NC_("layer-mode", "Old broken Overlay"), NULL },
{ GIMP_LAYER_MODE_DIFFERENCE_BROKEN, NC_("layer-mode", "Difference"), NULL },
{ GIMP_LAYER_MODE_ADDITION_BROKEN, NC_("layer-mode", "Addition"), NULL },
{ GIMP_LAYER_MODE_SUBTRACT_BROKEN, NC_("layer-mode", "Subtract"), NULL },
{ GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN, NC_("layer-mode", "Darken only"), NULL },
{ GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN, NC_("layer-mode", "Lighten only"), NULL },
{ GIMP_LAYER_MODE_HSV_HUE_BROKEN, NC_("layer-mode", "Hue (HSV)"), NULL },
{ GIMP_LAYER_MODE_HSV_SATURATION_BROKEN, NC_("layer-mode", "Saturation (HSV)"), NULL },
{ GIMP_LAYER_MODE_HSV_COLOR_BROKEN, NC_("layer-mode", "Color (HSV)"), NULL },
{ GIMP_LAYER_MODE_HSV_VALUE_BROKEN, NC_("layer-mode", "Value (HSV)"), NULL },
{ GIMP_LAYER_MODE_DIVIDE_BROKEN, NC_("layer-mode", "Divide"), NULL },
{ GIMP_LAYER_MODE_DODGE_BROKEN, NC_("layer-mode", "Dodge"), NULL },
{ GIMP_LAYER_MODE_BURN_BROKEN, NC_("layer-mode", "Burn"), NULL },
{ GIMP_LAYER_MODE_HARDLIGHT_BROKEN, NC_("layer-mode", "Hard light"), NULL },
{ GIMP_LAYER_MODE_SOFTLIGHT_BROKEN, NC_("layer-mode", "Soft light"), NULL },
{ GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN, NC_("layer-mode", "Grain extract"), NULL },
{ GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN, NC_("layer-mode", "Grain merge"), NULL },
{ GIMP_LAYER_MODE_COLOR_ERASE, NC_("layer-mode", "Color erase"), NULL },
{ GIMP_LAYER_MODE_OVERLAY, NC_("layer-mode", "Overlay"), NULL },
{ GIMP_LAYER_MODE_LCH_HUE, NC_("layer-mode", "Hue (LCH)"), NULL },
{ GIMP_LAYER_MODE_LCH_CHROMA, NC_("layer-mode", "Chroma (LCH)"), NULL },
{ GIMP_LAYER_MODE_LCH_COLOR, NC_("layer-mode", "Color (LCH)"), NULL },
{ GIMP_LAYER_MODE_LCH_LIGHTNESS, NC_("layer-mode", "Lightness (LCH)"), NULL },
{ GIMP_LAYER_MODE_ERASE, NC_("layer-mode", "Erase"), NULL },
{ GIMP_LAYER_MODE_REPLACE, NC_("layer-mode", "Replace"), NULL },
{ GIMP_LAYER_MODE_ANTI_ERASE, NC_("layer-mode", "Anti erase"), NULL },
{ 0, NULL, NULL }
};
@ -363,8 +363,8 @@ gimp_layer_mode_effects_get_type (void)
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpLayerModeEffects", values);
gimp_type_set_translation_context (type, "layer-mode-effects");
type = g_enum_register_static ("GimpLayerMode", values);
gimp_type_set_translation_context (type, "layer-mode");
gimp_enum_set_value_descriptions (type, descs);
}

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

@ -148,46 +148,46 @@ typedef enum
} GimpHistogramChannel;
#define GIMP_TYPE_LAYER_MODE_EFFECTS (gimp_layer_mode_effects_get_type ())
#define GIMP_TYPE_LAYER_MODE (gimp_layer_mode_get_type ())
GType gimp_layer_mode_effects_get_type (void) G_GNUC_CONST;
GType gimp_layer_mode_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_NORMAL_MODE, /*< desc="Normal" >*/
GIMP_DISSOLVE_MODE, /*< desc="Dissolve" >*/
GIMP_BEHIND_MODE, /*< desc="Behind" >*/
GIMP_MULTIPLY_MODE, /*< desc="Multiply" >*/
GIMP_SCREEN_MODE, /*< desc="Screen" >*/
GIMP_OVERLAY_MODE, /*< desc="Old broken Overlay" >*/
GIMP_DIFFERENCE_MODE, /*< desc="Difference" >*/
GIMP_ADDITION_MODE, /*< desc="Addition" >*/
GIMP_SUBTRACT_MODE, /*< desc="Subtract" >*/
GIMP_DARKEN_ONLY_MODE, /*< desc="Darken only" >*/
GIMP_LIGHTEN_ONLY_MODE, /*< desc="Lighten only" >*/
GIMP_HUE_MODE, /*< desc="Hue (HSV)" >*/
GIMP_SATURATION_MODE, /*< desc="Saturation (HSV)" >*/
GIMP_COLOR_MODE, /*< desc="Color (HSV)" >*/
GIMP_VALUE_MODE, /*< desc="Value (HSV)" >*/
GIMP_DIVIDE_MODE, /*< desc="Divide" >*/
GIMP_DODGE_MODE, /*< desc="Dodge" >*/
GIMP_BURN_MODE, /*< desc="Burn" >*/
GIMP_HARDLIGHT_MODE, /*< desc="Hard light" >*/
GIMP_SOFTLIGHT_MODE, /*< desc="Soft light" >*/
GIMP_GRAIN_EXTRACT_MODE, /*< desc="Grain extract" >*/
GIMP_GRAIN_MERGE_MODE, /*< desc="Grain merge" >*/
GIMP_COLOR_ERASE_MODE, /*< desc="Color erase" >*/
GIMP_NEW_OVERLAY_MODE, /*< desc="Overlay" >*/
GIMP_LCH_HUE_MODE, /*< desc="Hue (LCH)" >*/
GIMP_LCH_CHROMA_MODE, /*< desc="Chroma (LCH)" >*/
GIMP_LCH_COLOR_MODE, /*< desc="Color (LCH)" >*/
GIMP_LCH_LIGHTNESS_MODE, /*< desc="Lightness (LCH)" >*/
GIMP_LAYER_MODE_NORMAL, /*< desc="Normal" >*/
GIMP_LAYER_MODE_DISSOLVE, /*< desc="Dissolve" >*/
GIMP_LAYER_MODE_BEHIND, /*< desc="Behind" >*/
GIMP_LAYER_MODE_MULTIPLY_BROKEN, /*< desc="Multiply" >*/
GIMP_LAYER_MODE_SCREEN_BROKEN, /*< desc="Screen" >*/
GIMP_LAYER_MODE_OVERLAY_BROKEN, /*< desc="Old broken Overlay" >*/
GIMP_LAYER_MODE_DIFFERENCE_BROKEN, /*< desc="Difference" >*/
GIMP_LAYER_MODE_ADDITION_BROKEN, /*< desc="Addition" >*/
GIMP_LAYER_MODE_SUBTRACT_BROKEN, /*< desc="Subtract" >*/
GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN, /*< desc="Darken only" >*/
GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN, /*< desc="Lighten only" >*/
GIMP_LAYER_MODE_HSV_HUE_BROKEN, /*< desc="Hue (HSV)" >*/
GIMP_LAYER_MODE_HSV_SATURATION_BROKEN, /*< desc="Saturation (HSV)" >*/
GIMP_LAYER_MODE_HSV_COLOR_BROKEN, /*< desc="Color (HSV)" >*/
GIMP_LAYER_MODE_HSV_VALUE_BROKEN, /*< desc="Value (HSV)" >*/
GIMP_LAYER_MODE_DIVIDE_BROKEN, /*< desc="Divide" >*/
GIMP_LAYER_MODE_DODGE_BROKEN, /*< desc="Dodge" >*/
GIMP_LAYER_MODE_BURN_BROKEN, /*< desc="Burn" >*/
GIMP_LAYER_MODE_HARDLIGHT_BROKEN, /*< desc="Hard light" >*/
GIMP_LAYER_MODE_SOFTLIGHT_BROKEN, /*< desc="Soft light" >*/
GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN, /*< desc="Grain extract" >*/
GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN, /*< desc="Grain merge" >*/
GIMP_LAYER_MODE_COLOR_ERASE, /*< desc="Color erase" >*/
GIMP_LAYER_MODE_OVERLAY, /*< desc="Overlay" >*/
GIMP_LAYER_MODE_LCH_HUE, /*< desc="Hue (LCH)" >*/
GIMP_LAYER_MODE_LCH_CHROMA, /*< desc="Chroma (LCH)" >*/
GIMP_LAYER_MODE_LCH_COLOR, /*< desc="Color (LCH)" >*/
GIMP_LAYER_MODE_LCH_LIGHTNESS, /*< desc="Lightness (LCH)" >*/
/* internal modes, not available to the PDB */
GIMP_ERASE_MODE = 1000, /*< pdb-skip, desc="Erase" >*/
GIMP_REPLACE_MODE = 1001, /*< pdb-skip, desc="Replace" >*/
GIMP_ANTI_ERASE_MODE = 1002 /*< pdb-skip, desc="Anti erase" >*/
} GimpLayerModeEffects;
GIMP_LAYER_MODE_ERASE = 1000, /*< pdb-skip, desc="Erase" >*/
GIMP_LAYER_MODE_REPLACE = 1001, /*< pdb-skip, desc="Replace" >*/
GIMP_LAYER_MODE_ANTI_ERASE = 1002 /*< pdb-skip, desc="Anti erase" >*/
} GimpLayerMode;
#define GIMP_TYPE_MATTING_ENGINE (gimp_matting_engine_get_type ())

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

@ -419,7 +419,8 @@ gimp_edit_paste (GimpImage *image,
layer = gimp_layer_new_from_buffer (GIMP_BUFFER (paste), image,
floating_format,
_("Pasted Layer"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
}
if (! layer)

2
app/core/gimp-utils.c
View File

@ -868,7 +868,7 @@ gimp_create_image_from_buffer (Gimp *gimp,
layer = gimp_layer_new_from_gegl_buffer (buffer, image, format,
image_name,
GIMP_OPACITY_OPAQUE,
GIMP_NORMAL_MODE,
GIMP_LAYER_MODE_NORMAL,
NULL /* same image */);
gimp_image_add_layer (image, layer, NULL, -1, FALSE);

22
app/core/gimpchannel.c
View File

@ -163,7 +163,7 @@ static void gimp_channel_apply_buffer (GimpDrawable *drawable,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y);
@ -1007,16 +1007,16 @@ gimp_channel_get_active_mask (GimpDrawable *drawable)
}
static void
gimp_channel_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y)
gimp_channel_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y)
{
gimp_drawable_invalidate_boundary (drawable);

32
app/core/gimpcontext.c
View File

@ -153,7 +153,7 @@ static void gimp_context_real_set_opacity (GimpContext *context,
/* paint mode */
static void gimp_context_real_set_paint_mode (GimpContext *context,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
/* brush */
static void gimp_context_brush_dirty (GimpBrush *brush,
@ -471,7 +471,7 @@ gimp_context_class_init (GimpContextClass *klass)
NULL, NULL,
gimp_marshal_VOID__ENUM,
G_TYPE_NONE, 1,
GIMP_TYPE_LAYER_MODE_EFFECTS);
GIMP_TYPE_LAYER_MODE);
gimp_context_signals[BRUSH_CHANGED] =
g_signal_new ("brush-changed",
@ -695,8 +695,8 @@ gimp_context_class_init (GimpContextClass *klass)
gimp_context_prop_names[GIMP_CONTEXT_PROP_PAINT_MODE],
_("Paint Mode"),
_("Paint Mode"),
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_STATIC_STRINGS);
GIMP_CONFIG_PROP_OBJECT (object_class, GIMP_CONTEXT_PROP_BRUSH,
@ -1339,16 +1339,18 @@ gimp_context_deserialize (GimpConfig *config,
gint nest_level,
gpointer data)
{
GimpContext *context = GIMP_CONTEXT (config);
GimpLayerModeEffects old_paint_mode = context->paint_mode;
gboolean success;
GimpContext *context = GIMP_CONTEXT (config);
GimpLayerMode old_paint_mode = context->paint_mode;
gboolean success;
success = gimp_config_deserialize_properties (config, scanner, nest_level);
if (context->paint_mode != old_paint_mode)
{
if (context->paint_mode == GIMP_OVERLAY_MODE)
g_object_set (context, "paint-mode", GIMP_SOFTLIGHT_MODE, NULL);
if (context->paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
g_object_set (context,
"paint-mode", GIMP_LAYER_MODE_SOFTLIGHT_BROKEN,
NULL);
}
return success;
@ -2584,17 +2586,17 @@ gimp_context_real_set_opacity (GimpContext *context,
/*****************************************************************************/
/* paint mode **************************************************************/
GimpLayerModeEffects
GimpLayerMode
gimp_context_get_paint_mode (GimpContext *context)
{
g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_NORMAL_MODE);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_LAYER_MODE_NORMAL);
return context->paint_mode;
}
void
gimp_context_set_paint_mode (GimpContext *context,
GimpLayerModeEffects paint_mode)
gimp_context_set_paint_mode (GimpContext *context,
GimpLayerMode paint_mode)
{
g_return_if_fail (GIMP_IS_CONTEXT (context));
context_find_defined (context, GIMP_CONTEXT_PROP_PAINT_MODE);
@ -2613,8 +2615,8 @@ gimp_context_paint_mode_changed (GimpContext *context)
}
static void
gimp_context_real_set_paint_mode (GimpContext *context,
GimpLayerModeEffects paint_mode)
gimp_context_real_set_paint_mode (GimpContext *context,
GimpLayerMode paint_mode)
{
if (context->paint_mode == paint_mode)
return;

9
app/core/gimpcontext.h
View File

@ -68,7 +68,7 @@ struct _GimpContext
GimpRGB background;
gdouble opacity;
GimpLayerModeEffects paint_mode;
GimpLayerMode paint_mode;
GimpBrush *brush;
gchar *brush_name;
@ -125,7 +125,7 @@ struct _GimpContextClass
void (* opacity_changed) (GimpContext *context,
gdouble opacity);
void (* paint_mode_changed) (GimpContext *context,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
void (* brush_changed) (GimpContext *context,
GimpBrush *brush);
void (* dynamics_changed) (GimpContext *context,
@ -271,10 +271,9 @@ void gimp_context_opacity_changed (GimpContext *context);
/* paint mode */
GimpLayerModeEffects
gimp_context_get_paint_mode (GimpContext *context);
GimpLayerMode gimp_context_get_paint_mode (GimpContext *context);
void gimp_context_set_paint_mode (GimpContext *context,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
void gimp_context_paint_mode_changed (GimpContext *context);

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

@ -67,24 +67,24 @@ typedef struct
/* public functions */
void
gimp_drawable_blend (GimpDrawable *drawable,
GimpContext *context,
GimpGradient *gradient,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble startx,
gdouble starty,
gdouble endx,
gdouble endy,
GimpProgress *progress)
gimp_drawable_blend (GimpDrawable *drawable,
GimpContext *context,
GimpGradient *gradient,
GimpLayerMode paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble startx,
gdouble starty,
gdouble endx,
gdouble endy,
GimpProgress *progress)
{
GimpImage *image;
GeglBuffer *buffer;

36
app/core/gimpdrawable-blend.h
View File

@ -19,24 +19,24 @@
#define __GIMP_DRAWABLE_BLEND_H__
void gimp_drawable_blend (GimpDrawable *drawable,
GimpContext *context,
GimpGradient *gradient,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble startx,
gdouble starty,
gdouble endx,
gdouble endy,
GimpProgress *progress);
void gimp_drawable_blend (GimpDrawable *drawable,
GimpContext *context,
GimpGradient *gradient,
GimpLayerMode paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble startx,
gdouble starty,
gdouble endx,
gdouble endy,
GimpProgress *progress);
GeglBuffer *
gimp_drawable_blend_shapeburst_distmap (GimpDrawable *drawable,

20
app/core/gimpdrawable-combine.c
View File

@ -40,16 +40,16 @@
void
gimp_drawable_real_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y)
gimp_drawable_real_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y)
{
GimpItem *item = GIMP_ITEM (drawable);
GimpImage *image = gimp_item_get_image (item);

40
app/core/gimpdrawable-combine.h
View File

@ -21,26 +21,26 @@
/* virtual functions of GimpDrawable, don't call directly */
void gimp_drawable_real_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y);
void gimp_drawable_real_replace_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GeglBuffer *mask,
const GeglRectangle *mask_region,
gint x,
gint y);
void gimp_drawable_real_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y);
void gimp_drawable_real_replace_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GeglBuffer *mask,
const GeglRectangle *mask_region,
gint x,
gint y);
#endif /* __GIMP_DRAWABLE_COMBINE_H__ */

3
app/core/gimpdrawable-shadow.c
View File

@ -101,7 +101,8 @@ gimp_drawable_merge_shadow_buffer (GimpDrawable *drawable,
gimp_drawable_apply_buffer (drawable, buffer,
GEGL_RECTANGLE (x, y, width, height),
push_undo, undo_desc,
GIMP_OPACITY_OPAQUE, GIMP_REPLACE_MODE,
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_REPLACE,
NULL, x, y);
g_object_unref (buffer);

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

@ -1002,7 +1002,8 @@ gimp_drawable_transform_paste (GimpDrawable *drawable,
gimp_layer_new_from_gegl_buffer (buffer, image,
gimp_drawable_get_format_with_alpha (drawable),
_("Transformation"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE,
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL,
buffer_profile);
gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y);

20
app/core/gimpdrawable.c
View File

@ -1091,16 +1091,16 @@ gimp_drawable_convert_type (GimpDrawable *drawable,
}
void
gimp_drawable_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y)
gimp_drawable_apply_buffer (GimpDrawable *drawable,
GeglBuffer *buffer,
const GeglRectangle *buffer_region,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y)
{
g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)));

4
app/core/gimpdrawable.h
View File

@ -75,7 +75,7 @@ struct _GimpDrawableClass
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y);
@ -155,7 +155,7 @@ void gimp_drawable_apply_buffer (GimpDrawable *drawable,
gboolean push_undo,
const gchar *undo_desc,
gdouble opacity,
GimpLayerModeEffects mode,
GimpLayerMode mode,
GeglBuffer *base_buffer,
gint base_x,
gint base_y);

44
app/core/gimpdrawablefilter.c
View File

@ -57,29 +57,29 @@ enum
struct _GimpDrawableFilter
{
GimpFilter parent_instance;
GimpFilter parent_instance;
GimpDrawable *drawable;
GeglNode *operation;
GimpDrawable *drawable;
GeglNode *operation;
GimpFilterRegion region;
gboolean preview_enabled;
GimpAlignmentType preview_alignment;
gdouble preview_position;
gdouble opacity;
GimpLayerModeEffects paint_mode;
gboolean color_managed;
gboolean gamma_hack;
GimpFilterRegion region;
gboolean preview_enabled;
GimpAlignmentType preview_alignment;
gdouble preview_position;
gdouble opacity;
GimpLayerMode paint_mode;
gboolean color_managed;
gboolean gamma_hack;
GeglRectangle filter_area;
GeglRectangle filter_area;
GeglNode *translate;
GeglNode *crop;
GeglNode *cast_before;
GeglNode *transform_before;
GeglNode *transform_after;
GeglNode *cast_after;
GimpApplicator *applicator;
GeglNode *translate;
GeglNode *crop;
GeglNode *cast_before;
GeglNode *transform_before;
GeglNode *transform_after;
GeglNode *cast_after;
GimpApplicator *applicator;
};
@ -148,7 +148,7 @@ gimp_drawable_filter_init (GimpDrawableFilter *drawable_filter)
drawable_filter->preview_alignment = GIMP_ALIGN_LEFT;
drawable_filter->preview_position = 1.0;
drawable_filter->opacity = GIMP_OPACITY_OPAQUE;
drawable_filter->paint_mode = GIMP_REPLACE_MODE;
drawable_filter->paint_mode = GIMP_LAYER_MODE_REPLACE;
}
static void
@ -332,8 +332,8 @@ gimp_drawable_filter_set_opacity (GimpDrawableFilter *filter,
}
void
gimp_drawable_filter_set_mode (GimpDrawableFilter *filter,
GimpLayerModeEffects paint_mode)
gimp_drawable_filter_set_mode (GimpDrawableFilter *filter,
GimpLayerMode paint_mode)
{
g_return_if_fail (GIMP_IS_DRAWABLE_FILTER (filter));

48
app/core/gimpdrawablefilter.h
View File

@ -50,35 +50,35 @@ struct _GimpDrawableFilterClass
GType gimp_drawable_filter_get_type (void) G_GNUC_CONST;
GimpDrawableFilter *
gimp_drawable_filter_new (GimpDrawable *drawable,
const gchar *undo_desc,
GeglNode *operation,
const gchar *icon_name);
gimp_drawable_filter_new (GimpDrawable *drawable,
const gchar *undo_desc,
GeglNode *operation,
const gchar *icon_name);
void gimp_drawable_filter_set_region (GimpDrawableFilter *filter,
GimpFilterRegion region);
void gimp_drawable_filter_set_preview (GimpDrawableFilter *filter,
gboolean enabled,
GimpAlignmentType alignment,
gdouble split_position);
void gimp_drawable_filter_set_opacity (GimpDrawableFilter *filter,
gdouble opacity);
void gimp_drawable_filter_set_mode (GimpDrawableFilter *filter,
GimpLayerModeEffects paint_mode);
void gimp_drawable_filter_set_region (GimpDrawableFilter *filter,
GimpFilterRegion region);
void gimp_drawable_filter_set_preview (GimpDrawableFilter *filter,
gboolean enabled,
GimpAlignmentType alignment,
gdouble split_position);
void gimp_drawable_filter_set_opacity (GimpDrawableFilter *filter,
gdouble opacity);
void gimp_drawable_filter_set_mode (GimpDrawableFilter *filter,
GimpLayerMode paint_mode);
void gimp_drawable_filter_set_color_managed
(GimpDrawableFilter *filter,
gboolean managed);
void gimp_drawable_filter_set_gamma_hack (GimpDrawableFilter *filter,
gboolean gamma_hack);
(GimpDrawableFilter *filter,
gboolean managed);
void gimp_drawable_filter_set_gamma_hack (GimpDrawableFilter *filter,
gboolean gamma_hack);
void gimp_drawable_filter_apply (GimpDrawableFilter *filter,
const GeglRectangle *area);
void gimp_drawable_filter_apply (GimpDrawableFilter *filter,
const GeglRectangle *area);
gboolean gimp_drawable_filter_commit (GimpDrawableFilter *filter,
GimpProgress *progress,
gboolean cancellable);
void gimp_drawable_filter_abort (GimpDrawableFilter *filter);
gboolean gimp_drawable_filter_commit (GimpDrawableFilter *filter,
GimpProgress *progress,
gboolean cancellable);
void gimp_drawable_filter_abort (GimpDrawableFilter *filter);
#endif /* __GIMP_DRAWABLE_FILTER_H__ */

14
app/core/gimpdrawableundo.h
View File

@ -35,16 +35,16 @@ typedef struct _GimpDrawableUndoClass GimpDrawableUndoClass;
struct _GimpDrawableUndo
{
GimpItemUndo parent_instance;
GimpItemUndo parent_instance;
GeglBuffer *buffer;
gint x;
gint y;
GeglBuffer *buffer;
gint x;
gint y;
/* stuff for "Fade" */
GeglBuffer *applied_buffer;
GimpLayerModeEffects paint_mode;
gdouble opacity;
GeglBuffer *applied_buffer;
GimpLayerMode paint_mode;
gdouble opacity;
};
struct _GimpDrawableUndoClass

3
app/core/gimpfilloptions.c
View File

@ -315,7 +315,8 @@ gimp_fill_options_set_by_fill_type (GimpFillOptions *options,
case GIMP_FILL_TRANSPARENT:
gimp_context_get_background (context, &color);
gimp_context_set_paint_mode (GIMP_CONTEXT (options), GIMP_ERASE_MODE);
gimp_context_set_paint_mode (GIMP_CONTEXT (options),
GIMP_LAYER_MODE_ERASE);
undo_desc = C_("undo-type", "Fill with Transparency");
break;

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

@ -528,7 +528,8 @@ gimp_image_merge_layers (GimpImage *image,
merge_layer = gimp_layer_new (image, (x2 - x1), (y2 - y1),
gimp_image_get_layer_format (image, FALSE),
gimp_object_get_name (layer),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
if (! merge_layer)
{
g_warning ("%s: could not allocate merge layer.", G_STRFUNC);
@ -560,7 +561,8 @@ gimp_image_merge_layers (GimpImage *image,
gimp_layer_new (image, (x2 - x1), (y2 - y1),
gimp_drawable_get_format_with_alpha (GIMP_DRAWABLE (layer)),
"merged layer",
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
if (!merge_layer)
{
@ -596,22 +598,22 @@ gimp_image_merge_layers (GimpImage *image,
for (layers = reverse_list; layers; layers = g_slist_next (layers))
{
GeglBuffer *merge_buffer;
GeglBuffer *layer_buffer;
GimpApplicator *applicator;
GimpLayerModeEffects mode;
GeglBuffer *merge_buffer;
GeglBuffer *layer_buffer;
GimpApplicator *applicator;
GimpLayerMode mode;
layer = layers->data;
gimp_item_get_offset (GIMP_ITEM (layer), &off_x, &off_y);
/* DISSOLVE_MODE is special since it is the only mode that does not
/* MODE_DISSOLVE is special since it is the only mode that does not
* work on the projection with the lower layer, but only locally on
* the layers alpha channel.
*/
mode = gimp_layer_get_mode (layer);
if (layer == bottom_layer && mode != GIMP_DISSOLVE_MODE)
mode = GIMP_NORMAL_MODE;
if (layer == bottom_layer && mode != GIMP_LAYER_MODE_DISSOLVE)
mode = GIMP_LAYER_MODE_NORMAL;
merge_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (merge_layer));
layer_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer));

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

@ -148,7 +148,8 @@ gimp_image_new_from_template (Gimp *gimp,
layer = gimp_layer_new (image, width, height,
gimp_image_get_layer_format (image, has_alpha),
_("Background"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
gimp_drawable_fill (GIMP_DRAWABLE (layer),
context, gimp_template_get_fill_type (template));
@ -223,7 +224,7 @@ gimp_image_new_from_drawable (Gimp *gimp,
gimp_item_translate (GIMP_ITEM (new_layer), -off_x, -off_y, FALSE);
gimp_item_set_visible (GIMP_ITEM (new_layer), TRUE, FALSE);
gimp_item_set_linked (GIMP_ITEM (new_layer), FALSE, FALSE);
gimp_layer_set_mode (new_layer, GIMP_NORMAL_MODE, FALSE);
gimp_layer_set_mode (new_layer, GIMP_LAYER_MODE_NORMAL, FALSE);
gimp_layer_set_opacity (new_layer, GIMP_OPACITY_OPAQUE, FALSE);
if (gimp_layer_can_lock_alpha (new_layer))
gimp_layer_set_lock_alpha (new_layer, FALSE, FALSE);
@ -324,7 +325,8 @@ gimp_image_new_from_buffer (Gimp *gimp,
gimp_image_get_layer_format (image,
has_alpha),
_("Pasted Layer"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
gimp_image_add_layer (image, layer, NULL, 0, TRUE);
@ -382,7 +384,8 @@ gimp_image_new_from_pixbuf (Gimp *gimp,
gimp_image_get_layer_format (new_image,
has_alpha),
layer_name,
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
gimp_image_add_layer (new_image, layer, NULL, 0, TRUE);

18
app/core/gimpimage.c
View File

@ -2394,19 +2394,19 @@ gimp_image_get_xcf_version (GimpImage *image,
switch (gimp_layer_get_mode (layer))
{
/* new layer modes not supported by gimp-1.2 */
case GIMP_SOFTLIGHT_MODE:
case GIMP_GRAIN_EXTRACT_MODE:
case GIMP_GRAIN_MERGE_MODE:
case GIMP_COLOR_ERASE_MODE:
case GIMP_LAYER_MODE_SOFTLIGHT_BROKEN:
case GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN:
case GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN:
case GIMP_LAYER_MODE_COLOR_ERASE:
version = MAX (2, version);
break;
/* new layer modes not supported by gimp-2.8 */
case GIMP_NEW_OVERLAY_MODE:
case GIMP_LCH_HUE_MODE:
case GIMP_LCH_CHROMA_MODE:
case GIMP_LCH_COLOR_MODE:
case GIMP_LCH_LIGHTNESS_MODE:
case GIMP_LAYER_MODE_OVERLAY:
case GIMP_LAYER_MODE_LCH_HUE:
case GIMP_LAYER_MODE_LCH_CHROMA:
case GIMP_LAYER_MODE_LCH_COLOR:
case GIMP_LAYER_MODE_LCH_LIGHTNESS:
version = MAX (9, version);
break;

52
app/core/gimplayer-new.c
View File

@ -47,13 +47,13 @@ static void gimp_layer_new_convert_buffer (GimpLayer *layer,
/* public functions */
GimpLayer *
gimp_layer_new (GimpImage *image,
gint width,
gint height,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode)
gimp_layer_new (GimpImage *image,
gint width,
gint height,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode)
{
GimpLayer *layer;
@ -91,12 +91,12 @@ gimp_layer_new (GimpImage *image,
* Return value: The new layer.
**/
GimpLayer *
gimp_layer_new_from_buffer (GimpBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode)
gimp_layer_new_from_buffer (GimpBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode)
{
g_return_val_if_fail (GIMP_IS_BUFFER (buffer), NULL);
g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL);
@ -124,13 +124,13 @@ gimp_layer_new_from_buffer (GimpBuffer *buffer,
* Return value: The new layer.
**/
GimpLayer *
gimp_layer_new_from_gegl_buffer (GeglBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode,
GimpColorProfile *buffer_profile)
gimp_layer_new_from_gegl_buffer (GeglBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode,
GimpColorProfile *buffer_profile)
{
GimpLayer *layer;
@ -170,12 +170,12 @@ gimp_layer_new_from_gegl_buffer (GeglBuffer *buffer,
* Return value: The new layer.
**/
GimpLayer *
gimp_layer_new_from_pixbuf (GdkPixbuf *pixbuf,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode)
gimp_layer_new_from_pixbuf (GdkPixbuf *pixbuf,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode)
{
GimpLayer *layer;
GeglBuffer *buffer;

52
app/core/gimplayer-new.h
View File

@ -19,33 +19,33 @@
#define __GIMP_LAYER_NEW_H__
GimpLayer * gimp_layer_new (GimpImage *image,
gint width,
gint height,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode);
GimpLayer * gimp_layer_new (GimpImage *image,
gint width,
gint height,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode);
GimpLayer * gimp_layer_new_from_buffer (GimpBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode);
GimpLayer * gimp_layer_new_from_gegl_buffer (GeglBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode,
GimpColorProfile *buffer_profile);
GimpLayer * gimp_layer_new_from_pixbuf (GdkPixbuf *pixbuf,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode);
GimpLayer * gimp_layer_new_from_buffer (GimpBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode);
GimpLayer * gimp_layer_new_from_gegl_buffer (GeglBuffer *buffer,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode,
GimpColorProfile *buffer_profile);
GimpLayer * gimp_layer_new_from_pixbuf (GdkPixbuf *pixbuf,
GimpImage *dest_image,
const Babl *format,
const gchar *name,
gdouble opacity,
GimpLayerMode mode);
#endif /* __GIMP_LAYER_NEW_H__ */

28
app/core/gimplayer.c
View File

@ -363,8 +363,8 @@ gimp_layer_class_init (GimpLayerClass *klass)
g_object_class_install_property (object_class, PROP_MODE,
g_param_spec_enum ("mode", NULL, NULL,
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READABLE));
g_object_class_install_property (object_class, PROP_LOCK_ALPHA,
@ -390,7 +390,7 @@ static void
gimp_layer_init (GimpLayer *layer)
{
layer->opacity = GIMP_OPACITY_OPAQUE;
layer->mode = GIMP_NORMAL_MODE;
layer->mode = GIMP_LAYER_MODE_NORMAL;
layer->lock_alpha = FALSE;
layer->mask = NULL;
@ -508,23 +508,23 @@ gimp_layer_finalize (GObject *object)
static void
gimp_layer_update_mode_node (GimpLayer *layer)
{
GeglNode *mode_node;
GimpLayerModeEffects visible_mode;
gboolean linear;
GeglNode *mode_node;
GimpLayerMode visible_mode;
gboolean linear;
mode_node = gimp_drawable_get_mode_node (GIMP_DRAWABLE (layer));
if (layer->mask && layer->show_mask)
{
visible_mode = GIMP_NORMAL_MODE;
visible_mode = GIMP_LAYER_MODE_NORMAL;
linear = TRUE;
}
else
{
if (layer->mode != GIMP_DISSOLVE_MODE &&
if (layer->mode != GIMP_LAYER_MODE_DISSOLVE &&
gimp_filter_get_is_last_node (GIMP_FILTER (layer)))
{
visible_mode = GIMP_NORMAL_MODE;
visible_mode = GIMP_LAYER_MODE_NORMAL;
}
else
{
@ -2064,9 +2064,9 @@ gimp_layer_get_opacity (GimpLayer *layer)
}
void
gimp_layer_set_mode (GimpLayer *layer,
GimpLayerModeEffects mode,
gboolean push_undo)
gimp_layer_set_mode (GimpLayer *layer,
GimpLayerMode mode,
gboolean push_undo)
{
g_return_if_fail (GIMP_IS_LAYER (layer));
@ -2094,10 +2094,10 @@ gimp_layer_set_mode (GimpLayer *layer,
}
}
GimpLayerModeEffects
GimpLayerMode
gimp_layer_get_mode (GimpLayer *layer)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), GIMP_NORMAL_MODE);
g_return_val_if_fail (GIMP_IS_LAYER (layer), GIMP_LAYER_MODE_NORMAL);
return layer->mode;
}

24
app/core/gimplayer.h
View File

@ -34,19 +34,19 @@ typedef struct _GimpLayerClass GimpLayerClass;
struct _GimpLayer
{
GimpDrawable parent_instance;
GimpDrawable parent_instance;
gdouble opacity; /* layer opacity */
GimpLayerModeEffects mode; /* layer combination mode */
gboolean lock_alpha; /* lock the alpha channel */
gdouble opacity; /* layer opacity */
GimpLayerMode mode; /* layer combination mode */
gboolean lock_alpha; /* lock the alpha channel */
GimpLayerMask *mask; /* possible layer mask */
gboolean apply_mask; /* controls mask application */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show mask or layer? */
GimpLayerMask *mask; /* possible layer mask */
gboolean apply_mask; /* controls mask application */
gboolean edit_mask; /* edit mask or layer? */
gboolean show_mask; /* show mask or layer? */
GeglNode *layer_offset_node;
GeglNode *mask_offset_node;
GeglNode *layer_offset_node;
GeglNode *mask_offset_node;
/* Floating selections */
struct
@ -123,9 +123,9 @@ void gimp_layer_set_opacity (GimpLayer *layer,
gdouble gimp_layer_get_opacity (GimpLayer *layer);
void gimp_layer_set_mode (GimpLayer *layer,
GimpLayerModeEffects mode,
GimpLayerMode mode,
gboolean push_undo);
GimpLayerModeEffects gimp_layer_get_mode (GimpLayer *layer);
GimpLayerMode gimp_layer_get_mode (GimpLayer *layer);
void gimp_layer_set_lock_alpha (GimpLayer *layer,
gboolean lock_alpha,

2
app/core/gimplayerpropundo.c
View File

@ -102,7 +102,7 @@ gimp_layer_prop_undo_pop (GimpUndo *undo,
{
case GIMP_UNDO_LAYER_MODE:
{
GimpLayerModeEffects mode;
GimpLayerMode mode;
mode = gimp_layer_get_mode (layer);
gimp_layer_set_mode (layer, layer_prop_undo->mode, FALSE);

8
app/core/gimplayerpropundo.h
View File

@ -35,11 +35,11 @@ typedef struct _GimpLayerPropUndoClass GimpLayerPropUndoClass;
struct _GimpLayerPropUndo
{
GimpItemUndo parent_instance;
GimpItemUndo parent_instance;
GimpLayerModeEffects mode;
gdouble opacity;
gboolean lock_alpha;
GimpLayerMode mode;
gdouble opacity;
gboolean lock_alpha;
};
struct _GimpLayerPropUndoClass

2
app/core/gimpselection.c
View File

@ -893,7 +893,7 @@ gimp_selection_float (GimpSelection *selection,
gimp_drawable_get_format_with_alpha (drawable),
_("Floated Layer"),
GIMP_OPACITY_OPAQUE,
GIMP_NORMAL_MODE,
GIMP_LAYER_MODE_NORMAL,
profile);
/* Set the offsets */

12
app/dialogs/fade-dialog.c
View File

@ -44,13 +44,13 @@
typedef struct
{
GimpImage *image;
GimpDrawable *drawable;
GimpContext *context;
GimpImage *image;
GimpDrawable *drawable;
GimpContext *context;
gboolean applied;
GimpLayerModeEffects orig_paint_mode;
gdouble orig_opacity;
gboolean applied;
GimpLayerMode orig_paint_mode;
gdouble orig_opacity;
} FadeDialog;

4
app/dialogs/layer-options-dialog.c
View File

@ -50,7 +50,7 @@ typedef struct _LayerOptionsDialog LayerOptionsDialog;
struct _LayerOptionsDialog
{
GimpLayer *layer;
GimpLayerModeEffects mode;
GimpLayerMode mode;
gdouble opacity;
GimpFillType fill_type;
gboolean lock_alpha;
@ -94,7 +94,7 @@ layer_options_dialog_new (GimpImage *image,
const gchar *desc,
const gchar *help_id,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gboolean layer_visible,

42
app/dialogs/layer-options-dialog.h
View File

@ -19,26 +19,26 @@
#define __LAYER_OPTIONS_DIALOG_H__
typedef void (* GimpLayerOptionsCallback) (GtkWidget *dialog,
GimpImage *image,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gint layer_width,
gint layer_height,
gint layer_offset_x,
gint layer_offset_y,
gboolean layer_visible,
gboolean layer_linked,
GimpColorTag layer_color_tag,
gboolean layer_lock_content,
gboolean layer_lock_position,
gboolean layer_lock_alpha,
gboolean rename_text_layer,
gpointer user_data);
typedef void (* GimpLayerOptionsCallback) (GtkWidget *dialog,
GimpImage *image,
GimpLayer *layer,
GimpContext *context,
const gchar *layer_name,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gint layer_width,
gint layer_height,
gint layer_offset_x,
gint layer_offset_y,
gboolean layer_visible,
gboolean layer_linked,
GimpColorTag layer_color_tag,
gboolean layer_lock_content,
gboolean layer_lock_position,
gboolean layer_lock_alpha,
gboolean rename_text_layer,
gpointer user_data);
GtkWidget * layer_options_dialog_new (GimpImage *image,
@ -51,7 +51,7 @@ GtkWidget * layer_options_dialog_new (GimpImage *image,
const gchar *desc,
const gchar *help_id,
const gchar *layer_name,
GimpLayerModeEffects layer_mode,
GimpLayerMode layer_mode,
gdouble layer_opacity,
GimpFillType layer_fill_type,
gboolean layer_visible,

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

@ -724,7 +724,8 @@ gimp_display_shell_drop_pixbuf (GtkWidget *widget,
gimp_layer_new_from_pixbuf (pixbuf, image,
gimp_image_get_layer_format (image, has_alpha),
_("Dropped Buffer"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
if (new_layer)
{

159
app/gegl/gimp-gegl-nodes.c
View File

@ -139,9 +139,9 @@ gimp_gegl_add_buffer_source (GeglNode *parent,
}
void
gimp_gegl_mode_node_set_mode (GeglNode *node,
GimpLayerModeEffects mode,
gboolean linear)
gimp_gegl_mode_node_set_mode (GeglNode *node,
GimpLayerMode mode,
gboolean linear)
{
const gchar *operation = "gimp:normal-mode";
gdouble opacity;
@ -150,37 +150,128 @@ gimp_gegl_mode_node_set_mode (GeglNode *node,
switch (mode)
{
case GIMP_NORMAL_MODE: operation = "gimp:normal-mode"; break;
case GIMP_DISSOLVE_MODE: operation = "gimp:dissolve-mode"; break;
case GIMP_BEHIND_MODE: operation = "gimp:behind-mode"; break;
case GIMP_MULTIPLY_MODE: operation = "gimp:multiply-mode"; break;
case GIMP_SCREEN_MODE: operation = "gimp:screen-mode"; break;
case GIMP_OVERLAY_MODE: operation = "gimp:softlight-mode"; break;
case GIMP_DIFFERENCE_MODE: operation = "gimp:difference-mode"; break;
case GIMP_ADDITION_MODE: operation = "gimp:addition-mode"; break;
case GIMP_SUBTRACT_MODE: operation = "gimp:subtract-mode"; break;
case GIMP_DARKEN_ONLY_MODE: operation = "gimp:darken-only-mode"; break;
case GIMP_LIGHTEN_ONLY_MODE: operation = "gimp:lighten-only-mode"; break;
case GIMP_HUE_MODE: operation = "gimp:hue-mode"; break;
case GIMP_SATURATION_MODE: operation = "gimp:saturation-mode"; break;
case GIMP_COLOR_MODE: operation = "gimp:color-mode"; break;
case GIMP_VALUE_MODE: operation = "gimp:value-mode"; break;
case GIMP_DIVIDE_MODE: operation = "gimp:divide-mode"; break;
case GIMP_DODGE_MODE: operation = "gimp:dodge-mode"; break;
case GIMP_BURN_MODE: operation = "gimp:burn-mode"; break;
case GIMP_HARDLIGHT_MODE: operation = "gimp:hardlight-mode"; break;
case GIMP_SOFTLIGHT_MODE: operation = "gimp:softlight-mode"; break;
case GIMP_GRAIN_EXTRACT_MODE: operation = "gimp:grain-extract-mode"; break;
case GIMP_GRAIN_MERGE_MODE: operation = "gimp:grain-merge-mode"; break;
case GIMP_COLOR_ERASE_MODE: operation = "gimp:color-erase-mode"; break;
case GIMP_NEW_OVERLAY_MODE: operation = "gimp:overlay-mode"; break;
case GIMP_ERASE_MODE: operation = "gimp:erase-mode"; break;
case GIMP_REPLACE_MODE: operation = "gimp:replace-mode"; break;
case GIMP_ANTI_ERASE_MODE: operation = "gimp:anti-erase-mode"; break;
case GIMP_LCH_HUE_MODE: operation = "gimp:lch-hue-mode"; break;
case GIMP_LCH_CHROMA_MODE: operation = "gimp:lch-chroma-mode"; break;
case GIMP_LCH_COLOR_MODE: operation = "gimp:lch-color-mode"; break;
case GIMP_LCH_LIGHTNESS_MODE: operation = "gimp:lch-lightness-mode"; break;
case GIMP_LAYER_MODE_NORMAL:
operation = "gimp:normal-mode";
break;
case GIMP_LAYER_MODE_DISSOLVE:
operation = "gimp:dissolve-mode";
break;
case GIMP_LAYER_MODE_BEHIND:
operation = "gimp:behind-mode";
break;
case GIMP_LAYER_MODE_MULTIPLY_BROKEN:
operation = "gimp:multiply-mode";
break;
case GIMP_LAYER_MODE_SCREEN_BROKEN:
operation = "gimp:screen-mode";
break;
case GIMP_LAYER_MODE_OVERLAY_BROKEN:
operation = "gimp:softlight-mode";
break;
case GIMP_LAYER_MODE_DIFFERENCE_BROKEN:
operation = "gimp:difference-mode";
break;
case GIMP_LAYER_MODE_ADDITION_BROKEN:
operation = "gimp:addition-mode";
break;
case GIMP_LAYER_MODE_SUBTRACT_BROKEN:
operation = "gimp:subtract-mode";
break;
case GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN:
operation = "gimp:darken-only-mode";
break;
case GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN:
operation = "gimp:lighten-only-mode";
break;
case GIMP_LAYER_MODE_HSV_HUE_BROKEN:
operation = "gimp:hue-mode";
break;
case GIMP_LAYER_MODE_HSV_SATURATION_BROKEN:
operation = "gimp:saturation-mode";
break;
case GIMP_LAYER_MODE_HSV_COLOR_BROKEN:
operation = "gimp:color-mode";
break;
case GIMP_LAYER_MODE_HSV_VALUE_BROKEN:
operation = "gimp:value-mode";
break;
case GIMP_LAYER_MODE_DIVIDE_BROKEN:
operation = "gimp:divide-mode";
break;
case GIMP_LAYER_MODE_DODGE_BROKEN:
operation = "gimp:dodge-mode";
break;
case GIMP_LAYER_MODE_BURN_BROKEN:
operation = "gimp:burn-mode";
break;
case GIMP_LAYER_MODE_HARDLIGHT_BROKEN:
operation = "gimp:hardlight-mode";
break;
case GIMP_LAYER_MODE_SOFTLIGHT_BROKEN:
operation = "gimp:softlight-mode";
break;
case GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN:
operation = "gimp:grain-extract-mode";
break;
case GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN:
operation = "gimp:grain-merge-mode";
break;
case GIMP_LAYER_MODE_COLOR_ERASE:
operation = "gimp:color-erase-mode";
break;
case GIMP_LAYER_MODE_OVERLAY:
operation = "gimp:overlay-mode";
break;
case GIMP_LAYER_MODE_LCH_HUE:
operation = "gimp:lch-hue-mode";
break;
case GIMP_LAYER_MODE_LCH_CHROMA:
operation = "gimp:lch-chroma-mode";
break;
case GIMP_LAYER_MODE_LCH_COLOR:
operation = "gimp:lch-color-mode";
break;
case GIMP_LAYER_MODE_LCH_LIGHTNESS:
operation = "gimp:lch-lightness-mode";
break;
case GIMP_LAYER_MODE_ERASE:
operation = "gimp:erase-mode"; break;
case GIMP_LAYER_MODE_REPLACE:
operation = "gimp:replace-mode";
break;
case GIMP_LAYER_MODE_ANTI_ERASE:
operation = "gimp:anti-erase-mode";
break;
default:
break;
}

36
app/gegl/gimp-gegl-nodes.h
View File

@ -22,25 +22,25 @@
#define __GIMP_GEGL_NODES_H__
GeglNode * gimp_gegl_create_flatten_node (const GimpRGB *background);
GeglNode * gimp_gegl_create_apply_opacity_node (GeglBuffer *mask,
gint mask_offset_x,
gint mask_offset_y,
gdouble opacity);
GeglNode * gimp_gegl_add_buffer_source (GeglNode *parent,
GeglBuffer *buffer,
gint offset_x,
gint offset_y);
GeglNode * gimp_gegl_create_flatten_node (const GimpRGB *background);
GeglNode * gimp_gegl_create_apply_opacity_node (GeglBuffer *mask,
gint mask_offset_x,
gint mask_offset_y,
gdouble opacity);
GeglNode * gimp_gegl_add_buffer_source (GeglNode *parent,
GeglBuffer *buffer,
gint offset_x,
gint offset_y);
void gimp_gegl_mode_node_set_mode (GeglNode *node,
GimpLayerModeEffects mode,
gboolean linear);
void gimp_gegl_mode_node_set_opacity (GeglNode *node,
gdouble opacity);
void gimp_gegl_node_set_matrix (GeglNode *node,
const GimpMatrix3 *matrix);
void gimp_gegl_node_set_color (GeglNode *node,
const GimpRGB *color);
void gimp_gegl_mode_node_set_mode (GeglNode *node,
GimpLayerMode mode,
gboolean linear);
void gimp_gegl_mode_node_set_opacity (GeglNode *node,
gdouble opacity);
void gimp_gegl_node_set_matrix (GeglNode *node,
const GimpMatrix3 *matrix);
void gimp_gegl_node_set_color (GeglNode *node,
const GimpRGB *color);
#endif /* __GIMP_GEGL_NODES_H__ */

6
app/gegl/gimpapplicator.c
View File

@ -58,7 +58,7 @@ static void
gimp_applicator_init (GimpApplicator *applicator)
{
applicator->opacity = 1.0;
applicator->paint_mode = GIMP_NORMAL_MODE;
applicator->paint_mode = GIMP_LAYER_MODE_NORMAL;
applicator->affect = GIMP_COMPONENT_MASK_ALL;
}
@ -449,8 +449,8 @@ gimp_applicator_set_opacity (GimpApplicator *applicator,
}
void
gimp_applicator_set_mode (GimpApplicator *applicator,
GimpLayerModeEffects paint_mode)
gimp_applicator_set_mode (GimpApplicator *applicator,
GimpLayerMode paint_mode)
{
g_return_if_fail (GIMP_IS_APPLICATOR (applicator));

64
app/gegl/gimpapplicator.h
View File

@ -34,49 +34,49 @@ typedef struct _GimpApplicatorClass GimpApplicatorClass;
struct _GimpApplicator
{
GObject parent_instance;
GObject parent_instance;
GeglNode *node;
GeglNode *input_node;
GeglNode *aux_node;
GeglNode *output_node;
GeglNode *node;
GeglNode *input_node;
GeglNode *aux_node;
GeglNode *output_node;
GeglBuffer *apply_buffer;
GeglNode *apply_src_node;
GeglBuffer *apply_buffer;
GeglNode *apply_src_node;
gint apply_offset_x;
gint apply_offset_y;
GeglNode *apply_offset_node;
gint apply_offset_x;
gint apply_offset_y;
GeglNode *apply_offset_node;
GeglNode *dup_apply_buffer_node;
GeglNode *dup_apply_buffer_node;
gboolean preview_enabled;
GeglRectangle preview_rect;
GeglNode *preview_cache_node;
GeglNode *preview_crop_node;
gboolean preview_enabled;
GeglRectangle preview_rect;
GeglNode *preview_cache_node;
GeglNode *preview_crop_node;
gdouble opacity;
GimpLayerModeEffects paint_mode;
gboolean linear;
GeglNode *mode_node;
gdouble opacity;
GimpLayerMode paint_mode;
gboolean linear;
GeglNode *mode_node;
GimpComponentMask affect;
GeglNode *affect_node;
GimpComponentMask affect;
GeglNode *affect_node;
GeglNode *output_cache_node;
GeglNode *output_cache_node;
GeglBuffer *src_buffer;
GeglNode *src_node;
GeglBuffer *src_buffer;
GeglNode *src_node;
GeglBuffer *dest_buffer;
GeglNode *dest_node;
GeglBuffer *dest_buffer;
GeglNode *dest_node;
GeglBuffer *mask_buffer;
GeglNode *mask_node;
GeglBuffer *mask_buffer;
GeglNode *mask_node;
gint mask_offset_x;
gint mask_offset_y;
GeglNode *mask_offset_node;
gint mask_offset_x;
gint mask_offset_y;
GeglNode *mask_offset_node;
};
struct _GimpApplicatorClass
@ -112,7 +112,7 @@ void gimp_applicator_set_apply_offset (GimpApplicator *applicator,
void gimp_applicator_set_opacity (GimpApplicator *applicator,
gdouble opacity);
void gimp_applicator_set_mode (GimpApplicator *applicator,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
void gimp_applicator_set_affect (GimpApplicator *applicator,
GimpComponentMask affect);

182
app/operations/gimplayermodefunctions.c
View File

@ -59,57 +59,149 @@
GimpLayerModeFunction
get_layer_mode_function (GimpLayerModeEffects paint_mode,
gboolean linear_mode)
get_layer_mode_function (GimpLayerMode paint_mode,
gboolean linear_mode)
{
GimpLayerModeFunction func = gimp_operation_normal_mode_process_pixels;
switch (paint_mode)
{
case GIMP_NORMAL_MODE: func = gimp_operation_normal_mode_process_pixels; break;
case GIMP_DISSOLVE_MODE: func = gimp_operation_dissolve_mode_process_pixels; break;
case GIMP_BEHIND_MODE: func = gimp_operation_behind_mode_process_pixels; break;
case GIMP_MULTIPLY_MODE: func = gimp_operation_multiply_mode_process_pixels; break;
case GIMP_SCREEN_MODE: func = gimp_operation_screen_mode_process_pixels; break;
case GIMP_OVERLAY_MODE: func = gimp_operation_softlight_mode_process_pixels; break;
case GIMP_DIFFERENCE_MODE: func = gimp_operation_difference_mode_process_pixels; break;
case GIMP_ADDITION_MODE: func = gimp_operation_addition_mode_process_pixels; break;
case GIMP_SUBTRACT_MODE: func = gimp_operation_subtract_mode_process_pixels; break;
case GIMP_DARKEN_ONLY_MODE: func = gimp_operation_darken_only_mode_process_pixels; break;
case GIMP_LIGHTEN_ONLY_MODE: func = gimp_operation_lighten_only_mode_process_pixels; break;
case GIMP_HUE_MODE: func = gimp_operation_hue_mode_process_pixels; break;
case GIMP_SATURATION_MODE: func = gimp_operation_saturation_mode_process_pixels; break;
case GIMP_COLOR_MODE: func = gimp_operation_color_mode_process_pixels; break;
case GIMP_VALUE_MODE: func = gimp_operation_value_mode_process_pixels; break;
case GIMP_DIVIDE_MODE: func = gimp_operation_divide_mode_process_pixels; break;
case GIMP_DODGE_MODE: func = gimp_operation_dodge_mode_process_pixels; break;
case GIMP_BURN_MODE: func = gimp_operation_burn_mode_process_pixels; break;
case GIMP_HARDLIGHT_MODE: func = gimp_operation_hardlight_mode_process_pixels; break;
case GIMP_SOFTLIGHT_MODE: func = gimp_operation_softlight_mode_process_pixels; break;
case GIMP_GRAIN_EXTRACT_MODE: func = gimp_operation_grain_extract_mode_process_pixels; break;
case GIMP_GRAIN_MERGE_MODE: func = gimp_operation_grain_merge_mode_process_pixels; break;
case GIMP_COLOR_ERASE_MODE: func = gimp_operation_color_erase_mode_process_pixels; break;
case GIMP_NEW_OVERLAY_MODE: func = gimp_operation_overlay_mode_process_pixels; break;
case GIMP_LCH_HUE_MODE: func = linear_mode ?
gimp_operation_lch_hue_mode_process_pixels_linear :
gimp_operation_lch_hue_mode_process_pixels; break;
case GIMP_LCH_CHROMA_MODE: func = linear_mode ?
gimp_operation_lch_chroma_mode_process_pixels_linear :
gimp_operation_lch_chroma_mode_process_pixels; break;
case GIMP_LCH_COLOR_MODE: func = linear_mode ?
gimp_operation_lch_color_mode_process_pixels_linear :
gimp_operation_lch_color_mode_process_pixels; break;
case GIMP_LCH_LIGHTNESS_MODE: func = linear_mode ?
gimp_operation_lch_lightness_mode_process_pixels_linear :
gimp_operation_lch_lightness_mode_process_pixels; break;
case GIMP_ERASE_MODE: func = gimp_operation_erase_mode_process_pixels; break;
case GIMP_REPLACE_MODE: func = gimp_operation_replace_mode_process_pixels; break;
case GIMP_ANTI_ERASE_MODE: func = gimp_operation_anti_erase_mode_process_pixels; break;
case GIMP_LAYER_MODE_NORMAL:
func = gimp_operation_normal_mode_process_pixels;
break;
default:
g_warning ("No direct function for layer mode (%d), using gimp:normal-mode", paint_mode);
func = gimp_operation_normal_mode_process_pixels;
break;
case GIMP_LAYER_MODE_DISSOLVE:
func = gimp_operation_dissolve_mode_process_pixels;
break;
case GIMP_LAYER_MODE_BEHIND:
func = gimp_operation_behind_mode_process_pixels;
break;
case GIMP_LAYER_MODE_MULTIPLY_BROKEN:
func = gimp_operation_multiply_mode_process_pixels;
break;
case GIMP_LAYER_MODE_SCREEN_BROKEN:
func = gimp_operation_screen_mode_process_pixels;
break;
case GIMP_LAYER_MODE_OVERLAY_BROKEN:
func = gimp_operation_softlight_mode_process_pixels;
break;
case GIMP_LAYER_MODE_DIFFERENCE_BROKEN:
func = gimp_operation_difference_mode_process_pixels;
break;
case GIMP_LAYER_MODE_ADDITION_BROKEN:
func = gimp_operation_addition_mode_process_pixels;
break;
case GIMP_LAYER_MODE_SUBTRACT_BROKEN:
func = gimp_operation_subtract_mode_process_pixels;
break;
case GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN:
func = gimp_operation_darken_only_mode_process_pixels;
break;
case GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN:
func = gimp_operation_lighten_only_mode_process_pixels;
break;
case GIMP_LAYER_MODE_HSV_HUE_BROKEN:
func = gimp_operation_hue_mode_process_pixels;
break;
case GIMP_LAYER_MODE_HSV_SATURATION_BROKEN:
func = gimp_operation_saturation_mode_process_pixels;
break;
case GIMP_LAYER_MODE_HSV_COLOR_BROKEN:
func = gimp_operation_color_mode_process_pixels;
break;
case GIMP_LAYER_MODE_HSV_VALUE_BROKEN:
func = gimp_operation_value_mode_process_pixels;
break;
case GIMP_LAYER_MODE_DIVIDE_BROKEN:
func = gimp_operation_divide_mode_process_pixels;
break;
case GIMP_LAYER_MODE_DODGE_BROKEN:
func = gimp_operation_dodge_mode_process_pixels;
break;
case GIMP_LAYER_MODE_BURN_BROKEN:
func = gimp_operation_burn_mode_process_pixels;
break;
case GIMP_LAYER_MODE_HARDLIGHT_BROKEN:
func = gimp_operation_hardlight_mode_process_pixels;
break;
case GIMP_LAYER_MODE_SOFTLIGHT_BROKEN:
func = gimp_operation_softlight_mode_process_pixels;
break;
case GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN:
func = gimp_operation_grain_extract_mode_process_pixels;
break;
case GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN:
func = gimp_operation_grain_merge_mode_process_pixels;
break;
case GIMP_LAYER_MODE_COLOR_ERASE:
func = gimp_operation_color_erase_mode_process_pixels;
break;
case GIMP_LAYER_MODE_OVERLAY:
func = gimp_operation_overlay_mode_process_pixels;
break;
case GIMP_LAYER_MODE_LCH_HUE:
func = linear_mode ?
gimp_operation_lch_hue_mode_process_pixels_linear :
gimp_operation_lch_hue_mode_process_pixels;
break;
case GIMP_LAYER_MODE_LCH_CHROMA:
func = linear_mode ?
gimp_operation_lch_chroma_mode_process_pixels_linear :
gimp_operation_lch_chroma_mode_process_pixels;
break;
case GIMP_LAYER_MODE_LCH_COLOR:
func = linear_mode ?
gimp_operation_lch_color_mode_process_pixels_linear :
gimp_operation_lch_color_mode_process_pixels;
break;
case GIMP_LAYER_MODE_LCH_LIGHTNESS:
func = linear_mode ?
gimp_operation_lch_lightness_mode_process_pixels_linear :
gimp_operation_lch_lightness_mode_process_pixels;
break;
case GIMP_LAYER_MODE_ERASE:
func = gimp_operation_erase_mode_process_pixels;
break;
case GIMP_LAYER_MODE_REPLACE:
func = gimp_operation_replace_mode_process_pixels;
break;
case GIMP_LAYER_MODE_ANTI_ERASE:
func = gimp_operation_anti_erase_mode_process_pixels;
break;
default:
g_warning ("No direct function for layer mode (%d), using gimp:normal-mode", paint_mode);
func = gimp_operation_normal_mode_process_pixels;
break;
}
return func;

4
app/operations/gimplayermodefunctions.h
View File

@ -21,7 +21,7 @@
#ifndef __GIMP_LAYER_MODE_FUNCTIONS_H__
#define __GIMP_LAYER_MODE_FUNCTIONS_H__
GimpLayerModeFunction get_layer_mode_function (GimpLayerModeEffects paint_mode,
gboolean linear_mode);
GimpLayerModeFunction get_layer_mode_function (GimpLayerMode paint_mode,
gboolean linear_mode);
#endif /* __GIMP_LAYER_MODE_FUNCTIONS_H__ */

5
app/paint/gimpbrushcore.c
View File

@ -966,7 +966,7 @@ gimp_brush_core_paste_canvas (GimpBrushCore *core,
const GimpCoords *coords,
gdouble brush_opacity,
gdouble image_opacity,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpBrushApplicationMode brush_hardness,
gdouble dynamic_force,
GimpPaintApplicationMode mode,
@ -996,7 +996,8 @@ gimp_brush_core_paste_canvas (GimpBrushCore *core,
off_x, off_y,
drawable,
brush_opacity,
image_opacity, paint_mode,
image_opacity,
paint_mode,
mode);
}
}

2
app/paint/gimpbrushcore.h
View File

@ -104,7 +104,7 @@ void gimp_brush_core_paste_canvas (GimpBrushCore *core,
const GimpCoords *coords,
gdouble brush_opacity,
gdouble image_opacity,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpBrushApplicationMode brush_hardness,
gdouble dynamic_hardness,
GimpPaintApplicationMode mode,

42
app/paint/gimperaser.c
View File

@ -123,24 +123,24 @@ gimp_eraser_motion (GimpPaintCore *paint_core,
GimpPaintOptions *paint_options,
GimpSymmetry *sym)
{
GimpEraserOptions *options = GIMP_ERASER_OPTIONS (paint_options);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpDynamics *dynamics = GIMP_BRUSH_CORE (paint_core)->dynamics;
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
gdouble fade_point;
gdouble opacity;
GimpLayerModeEffects paint_mode;
GeglBuffer *paint_buffer;
gint paint_buffer_x;
gint paint_buffer_y;
GimpRGB background;
GeglColor *color;
gdouble force;
const GimpCoords *coords;
GeglNode *op;
gint n_strokes;
gint paint_width, paint_height;
gint i;
GimpEraserOptions *options = GIMP_ERASER_OPTIONS (paint_options);
GimpContext *context = GIMP_CONTEXT (paint_options);
GimpDynamics *dynamics = GIMP_BRUSH_CORE (paint_core)->dynamics;
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
gdouble fade_point;
gdouble opacity;
GimpLayerMode paint_mode;
GeglBuffer *paint_buffer;
gint paint_buffer_x;
gint paint_buffer_y;
GimpRGB background;
GeglColor *color;
gdouble force;
const GimpCoords *coords;
GeglNode *op;
gint n_strokes;
gint paint_width, paint_height;
gint i;
fade_point = gimp_paint_options_get_fade (paint_options, image,
paint_core->pixel_dist);
@ -160,11 +160,11 @@ gimp_eraser_motion (GimpPaintCore *paint_core,
color = gimp_gegl_color_new (&background);
if (options->anti_erase)
paint_mode = GIMP_ANTI_ERASE_MODE;
paint_mode = GIMP_LAYER_MODE_ANTI_ERASE;
else if (gimp_drawable_has_alpha (drawable))
paint_mode = GIMP_ERASE_MODE;
paint_mode = GIMP_LAYER_MODE_ERASE;
else
paint_mode = GIMP_NORMAL_MODE;
paint_mode = GIMP_LAYER_MODE_NORMAL;
gimp_brush_core_eval_transform_dynamics (GIMP_BRUSH_CORE (paint_core),
drawable,

25
app/paint/gimppaintcore-loops.c
View File

@ -282,17 +282,17 @@ paint_mask_to_paint_buffer (const GimpTempBuf *paint_mask,
}
void
do_layer_blend (GeglBuffer *src_buffer,
GeglBuffer *dst_buffer,
GimpTempBuf *paint_buf,
GeglBuffer *mask_buffer,
gfloat opacity,
gint x_offset,
gint y_offset,
gint mask_x_offset,
gint mask_y_offset,
gboolean linear_mode,
GimpLayerModeEffects paint_mode)
do_layer_blend (GeglBuffer *src_buffer,
GeglBuffer *dst_buffer,
GimpTempBuf *paint_buf,
GeglBuffer *mask_buffer,
gfloat opacity,
gint x_offset,
gint y_offset,
gint mask_x_offset,
gint mask_y_offset,
gboolean linear_mode,
GimpLayerMode paint_mode)
{
GeglRectangle roi;
GeglRectangle mask_roi;
@ -303,7 +303,8 @@ do_layer_blend (GeglBuffer *src_buffer,
const guint paint_stride = gimp_temp_buf_get_width (paint_buf);
gfloat *paint_data = (gfloat *) gimp_temp_buf_get_data (paint_buf);
GimpLayerModeFunction apply_func = get_layer_mode_function (paint_mode, linear_mode);
GimpLayerModeFunction apply_func = get_layer_mode_function (paint_mode,
linear_mode);
if (linear_mode)
iterator_format = babl_format ("RGBA float");

22
app/paint/gimppaintcore-loops.h
View File

@ -35,17 +35,17 @@ void paint_mask_to_paint_buffer (const GimpTempBuf *paint_mask,
GimpTempBuf *paint_buf,
gfloat paint_opacity);
void do_layer_blend (GeglBuffer *src_buffer,
GeglBuffer *dst_buffer,
GimpTempBuf *paint_buf,
GeglBuffer *mask_buffer,
gfloat opacity,
gint x_offset,
gint y_offset,
gint mask_x_offset,
gint mask_y_offset,
gboolean linear_mode,
GimpLayerModeEffects paint_mode);
void do_layer_blend (GeglBuffer *src_buffer,
GeglBuffer *dst_buffer,
GimpTempBuf *paint_buf,
GeglBuffer *mask_buffer,
gfloat opacity,
gint x_offset,
gint y_offset,
gint mask_x_offset,
gint mask_y_offset,
gboolean linear_mode,
GimpLayerMode paint_mode);
void mask_components_onto (GeglBuffer *src_buffer,
GeglBuffer *aux_buffer,

5
app/paint/gimppaintcore.c
View File

@ -822,7 +822,7 @@ gimp_paint_core_paste (GimpPaintCore *core,
GimpDrawable *drawable,
gdouble paint_opacity,
gdouble image_opacity,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpPaintApplicationMode mode)
{
gint width = gegl_buffer_get_width (core->paint_buffer);
@ -1031,7 +1031,8 @@ gimp_paint_core_replace (GimpPaintCore *core,
paint_mask_offset_y,
drawable,
paint_opacity,
image_opacity, GIMP_NORMAL_MODE,
image_opacity,
GIMP_LAYER_MODE_NORMAL,
mode);
return;
}

2
app/paint/gimppaintcore.h
View File

@ -184,7 +184,7 @@ void gimp_paint_core_paste (GimpPaintCore *core,
GimpDrawable *drawable,
gdouble paint_opacity,
gdouble image_opacity,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpPaintApplicationMode mode);
void gimp_paint_core_replace (GimpPaintCore *core,

16
app/pdb/brush-select-cmds.c
View File

@ -61,8 +61,8 @@ brushes_popup_invoker (GimpProcedure *procedure,
if (success)
{
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
if (gimp->no_interface ||
! gimp_pdb_lookup_procedure (gimp->pdb, brush_callback) ||
@ -129,8 +129,8 @@ brushes_set_popup_invoker (GimpProcedure *procedure,
if (success)
{
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
if (gimp->no_interface ||
! gimp_pdb_lookup_procedure (gimp->pdb, brush_callback) ||
@ -203,8 +203,8 @@ register_brush_select_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The initial paint mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -277,8 +277,8 @@ register_brush_select_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The initial paint mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

8
app/pdb/brushes-cmds.c
View File

@ -207,8 +207,8 @@ brushes_get_brush_data_invoker (GimpProcedure *procedure,
{
GimpBrush *brush;
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
if (name && strlen (name))
brush = gimp_pdb_get_brush (gimp, name, FALSE, error);
@ -439,8 +439,8 @@ register_brushes_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_int32 ("width",

12
app/pdb/context-cmds.c
View File

@ -419,8 +419,8 @@ context_set_paint_mode_invoker (GimpProcedure *procedure,
if (success)
{
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
gimp_context_set_paint_mode (context, paint_mode);
}
@ -3138,8 +3138,8 @@ register_context_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -3162,8 +3162,8 @@ register_context_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

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

@ -621,8 +621,8 @@ edit_bucket_fill_invoker (GimpProcedure *procedure,
if (gimp_fill_options_set_by_fill_mode (options, context,
fill_mode, error))
{
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
gimp_context_set_opacity (GIMP_CONTEXT (options), opacity / 100.0);
gimp_context_set_paint_mode (GIMP_CONTEXT (options), paint_mode);
@ -698,8 +698,8 @@ edit_bucket_fill_full_invoker (GimpProcedure *procedure,
if (gimp_fill_options_set_by_fill_mode (options, context,
fill_mode, error))
{
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
gimp_context_set_opacity (GIMP_CONTEXT (options), opacity / 100.0);
gimp_context_set_paint_mode (GIMP_CONTEXT (options), paint_mode);
@ -794,8 +794,8 @@ edit_blend_invoker (GimpProcedure *procedure,
{
GimpGradient *gradient;
if (paint_mode == GIMP_OVERLAY_MODE)
paint_mode = GIMP_SOFTLIGHT_MODE;
if (paint_mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
paint_mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
if (progress)
gimp_progress_start (progress, FALSE, _("Blending"));
@ -1348,8 +1348,8 @@ register_edit_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint application mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("opacity",
@ -1415,8 +1415,8 @@ register_edit_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint application mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_double ("opacity",
@ -1495,8 +1495,8 @@ register_edit_procs (GimpPDB *pdb)
g_param_spec_enum ("paint-mode",
"paint mode",
"The paint application mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("gradient-type",

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

@ -88,8 +88,8 @@ layer_new_invoker (GimpProcedure *procedure,
gboolean has_alpha = FALSE;
const Babl *format;
if (mode == GIMP_OVERLAY_MODE)
mode = GIMP_SOFTLIGHT_MODE;
if (mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
switch (type)
{
@ -181,7 +181,7 @@ layer_new_from_visible_invoker (GimpProcedure *procedure,
TRUE),
name,
GIMP_OPACITY_OPAQUE,
GIMP_NORMAL_MODE,
GIMP_LAYER_MODE_NORMAL,
profile);
}
@ -1140,8 +1140,8 @@ layer_set_mode_invoker (GimpProcedure *procedure,
if (success)
{
if (mode == GIMP_OVERLAY_MODE)
mode = GIMP_SOFTLIGHT_MODE;
if (mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
gimp_layer_set_mode (layer, mode, TRUE);
}
@ -1211,8 +1211,8 @@ register_layer_procs (GimpPDB *pdb)
g_param_spec_enum ("mode",
"mode",
"The layer combination mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_layer_id ("layer",
@ -2147,8 +2147,8 @@ register_layer_procs (GimpPDB *pdb)
g_param_spec_enum ("mode",
"mode",
"The layer combination mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -2177,8 +2177,8 @@ register_layer_procs (GimpPDB *pdb)
g_param_spec_enum ("mode",
"mode",
"The new layer combination mode",
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);

2
app/tests/gimp-app-test-utils.c
View File

@ -138,7 +138,7 @@ gimp_test_utils_create_image (Gimp *gimp,
gimp_image_get_layer_format (image, TRUE),
"layer1",
1.0,
GIMP_NORMAL_MODE);
GIMP_LAYER_MODE_NORMAL);
gimp_image_add_layer (image,
layer,

12
app/tests/test-core.c
View File

@ -126,8 +126,8 @@ rotate_non_overlapping (GimpTestFixture *fixture,
GIMP_TEST_IMAGE_SIZE,
babl_format ("R'G'B'A u8"),
"Test Layer",
1.0,
GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
g_assert_cmpint (GIMP_IS_LAYER (layer), ==, TRUE);
@ -166,8 +166,8 @@ add_layer (GimpTestFixture *fixture,
GIMP_TEST_IMAGE_SIZE,
babl_format ("R'G'B'A u8"),
"Test Layer",
1.0,
GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
g_assert_cmpint (GIMP_IS_LAYER (layer), ==, TRUE);
@ -203,8 +203,8 @@ remove_layer (GimpTestFixture *fixture,
GIMP_TEST_IMAGE_SIZE,
babl_format ("R'G'B'A u8"),
"Test Layer",
1.0,
GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
g_assert_cmpint (GIMP_IS_LAYER (layer), ==, TRUE);

3
app/tests/test-ui.c
View File

@ -235,7 +235,8 @@ create_new_image_via_dialog (gconstpointer data)
gimp_image_get_height (image),
gimp_image_get_layer_format (image, TRUE),
"Layer for testing",
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
gimp_image_add_layer (image, layer,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);

8
app/tests/test-xcf.c
View File

@ -67,15 +67,15 @@
#define GIMP_MAINIMAGE_LAYER1_WIDTH 50
#define GIMP_MAINIMAGE_LAYER1_HEIGHT 51
#define GIMP_MAINIMAGE_LAYER1_FORMAT babl_format ("R'G'B'A u8")
#define GIMP_MAINIMAGE_LAYER1_OPACITY 1.0
#define GIMP_MAINIMAGE_LAYER1_MODE GIMP_NORMAL_MODE
#define GIMP_MAINIMAGE_LAYER1_OPACITY GIMP_OPACITY_OPAQUE
#define GIMP_MAINIMAGE_LAYER1_MODE GIMP_LAYER_MODE_NORMAL
#define GIMP_MAINIMAGE_LAYER2_NAME "layer2"
#define GIMP_MAINIMAGE_LAYER2_WIDTH 25
#define GIMP_MAINIMAGE_LAYER2_HEIGHT 251
#define GIMP_MAINIMAGE_LAYER2_FORMAT babl_format ("R'G'B' u8")
#define GIMP_MAINIMAGE_LAYER2_OPACITY 0.0
#define GIMP_MAINIMAGE_LAYER2_MODE GIMP_MULTIPLY_MODE
#define GIMP_MAINIMAGE_LAYER2_OPACITY GIMP_OPACITY_TRANSPARENT
#define GIMP_MAINIMAGE_LAYER2_MODE GIMP_LAYER_MODE_MULTIPLY_BROKEN
#define GIMP_MAINIMAGE_GROUP1_NAME "group1"

2
app/tools/gimpwarptool.c
View File

@ -918,7 +918,7 @@ gimp_warp_tool_animate (GimpWarpTool *wt)
gimp_item_set_offset (GIMP_ITEM (layer), 0, 0);
gimp_item_set_visible (GIMP_ITEM (layer), TRUE, FALSE);
gimp_layer_set_mode (layer, GIMP_NORMAL_MODE, FALSE);
gimp_layer_set_mode (layer, GIMP_LAYER_MODE_NORMAL, FALSE);
gimp_layer_set_opacity (layer, GIMP_OPACITY_OPAQUE, FALSE);
gimp_image_add_layer (image, layer, NULL, 0, FALSE);

14
app/widgets/gimpbrushselect.c
View File

@ -69,7 +69,7 @@ static void gimp_brush_select_opacity_changed (GimpContext *context
gdouble opacity,
GimpBrushSelect *select);
static void gimp_brush_select_mode_changed (GimpContext *context,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpBrushSelect *select);
static void gimp_brush_select_opacity_update (GtkAdjustment *adj,
@ -106,8 +106,8 @@ gimp_brush_select_class_init (GimpBrushSelectClass *klass)
g_object_class_install_property (object_class, PROP_PAINT_MODE,
g_param_spec_enum ("paint-mode", NULL, NULL,
GIMP_TYPE_LAYER_MODE_EFFECTS,
GIMP_NORMAL_MODE,
GIMP_TYPE_LAYER_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_PARAM_WRITABLE |
G_PARAM_CONSTRUCT));
@ -307,9 +307,9 @@ gimp_brush_select_opacity_changed (GimpContext *context,
}
static void
gimp_brush_select_mode_changed (GimpContext *context,
GimpLayerModeEffects paint_mode,
GimpBrushSelect *select)
gimp_brush_select_mode_changed (GimpContext *context,
GimpLayerMode paint_mode,
GimpBrushSelect *select)
{
g_signal_handlers_block_by_func (select->paint_mode_menu,
gimp_brush_select_mode_update,
@ -343,7 +343,7 @@ gimp_brush_select_mode_update (GtkWidget *widget,
&paint_mode))
{
gimp_context_set_paint_mode (GIMP_PDB_DIALOG (select)->context,
(GimpLayerModeEffects) paint_mode);
(GimpLayerMode) paint_mode);
}
}

12
app/widgets/gimpbrushselect.h
View File

@ -38,14 +38,14 @@ typedef struct _GimpBrushSelectClass GimpBrushSelectClass;
struct _GimpBrushSelect
{
GimpPdbDialog parent_instance;
GimpPdbDialog parent_instance;
gdouble initial_opacity;
GimpLayerModeEffects initial_mode;
gdouble initial_opacity;
GimpLayerMode initial_mode;
gint spacing;
GtkAdjustment *opacity_data;
GtkWidget *paint_mode_menu;
gint spacing;
GtkAdjustment *opacity_data;
GtkWidget *paint_mode_menu;
};
struct _GimpBrushSelectClass

13
app/widgets/gimplayertreeview.c
View File

@ -271,7 +271,7 @@ gimp_layer_tree_view_init (GimpLayerTreeView *view)
NULL, view->priv->paint_mode_menu);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (view->priv->paint_mode_menu),
GIMP_NORMAL_MODE,
GIMP_LAYER_MODE_NORMAL,
G_CALLBACK (gimp_layer_tree_view_paint_mode_menu_callback),
view);
@ -808,7 +808,8 @@ gimp_layer_tree_view_drop_pixbuf (GimpContainerTreeView *tree_view,
gimp_layer_new_from_pixbuf (pixbuf, image,
gimp_image_get_layer_format (image, TRUE),
_("Dropped Buffer"),
GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
gimp_image_add_layer (image, new_layer, parent, index, TRUE);
@ -848,7 +849,9 @@ gimp_layer_tree_view_item_new (GimpImage *image)
gimp_image_get_width (image),
gimp_image_get_height (image),
gimp_image_get_layer_format (image, TRUE),
NULL, 1.0, GIMP_NORMAL_MODE);
NULL,
GIMP_OPACITY_OPAQUE,
GIMP_LAYER_MODE_NORMAL);
gimp_image_add_layer (image, new_layer,
GIMP_IMAGE_ACTIVE_PARENT, -1, TRUE);
@ -938,7 +941,7 @@ gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget,
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget),
&mode) &&
gimp_layer_get_mode (layer) != (GimpLayerModeEffects) mode)
gimp_layer_get_mode (layer) != (GimpLayerMode) mode)
{
GimpUndo *undo;
gboolean push_undo = TRUE;
@ -951,7 +954,7 @@ gimp_layer_tree_view_paint_mode_menu_callback (GtkWidget *widget,
push_undo = FALSE;
BLOCK();
gimp_layer_set_mode (layer, (GimpLayerModeEffects) mode, push_undo);
gimp_layer_set_mode (layer, (GimpLayerMode) mode, push_undo);
UNBLOCK();
gimp_image_flush (image);

84
app/widgets/gimpwidgets-constructors.c
View File

@ -103,79 +103,79 @@ gimp_paint_mode_menu_new (gboolean with_behind_mode,
GtkListStore *store;
GtkWidget *combo;
store = gimp_enum_store_new_with_values (GIMP_TYPE_LAYER_MODE_EFFECTS,
store = gimp_enum_store_new_with_values (GIMP_TYPE_LAYER_MODE,
25,
GIMP_NORMAL_MODE,
GIMP_DISSOLVE_MODE,
GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LIGHTEN_ONLY_MODE,
GIMP_SCREEN_MODE,
GIMP_DODGE_MODE,
GIMP_ADDITION_MODE,
GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN,
GIMP_LAYER_MODE_SCREEN_BROKEN,
GIMP_LAYER_MODE_DODGE_BROKEN,
GIMP_LAYER_MODE_ADDITION_BROKEN,
GIMP_DARKEN_ONLY_MODE,
GIMP_MULTIPLY_MODE,
GIMP_BURN_MODE,
GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN,
GIMP_LAYER_MODE_MULTIPLY_BROKEN,
GIMP_LAYER_MODE_BURN_BROKEN,
GIMP_NEW_OVERLAY_MODE,
GIMP_SOFTLIGHT_MODE,
GIMP_HARDLIGHT_MODE,
GIMP_LAYER_MODE_OVERLAY,
GIMP_LAYER_MODE_SOFTLIGHT_BROKEN,
GIMP_LAYER_MODE_HARDLIGHT_BROKEN,
GIMP_DIFFERENCE_MODE,
GIMP_SUBTRACT_MODE,
GIMP_GRAIN_EXTRACT_MODE,
GIMP_GRAIN_MERGE_MODE,
GIMP_DIVIDE_MODE,
GIMP_LAYER_MODE_DIFFERENCE_BROKEN,
GIMP_LAYER_MODE_SUBTRACT_BROKEN,
GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN,
GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN,
GIMP_LAYER_MODE_DIVIDE_BROKEN,
GIMP_HUE_MODE,
GIMP_SATURATION_MODE,
GIMP_COLOR_MODE,
GIMP_VALUE_MODE,
GIMP_LAYER_MODE_HSV_HUE_BROKEN,
GIMP_LAYER_MODE_HSV_SATURATION_BROKEN,
GIMP_LAYER_MODE_HSV_COLOR_BROKEN,
GIMP_LAYER_MODE_HSV_VALUE_BROKEN,
GIMP_LCH_HUE_MODE,
GIMP_LCH_CHROMA_MODE,
GIMP_LCH_COLOR_MODE,
GIMP_LCH_LIGHTNESS_MODE);
GIMP_LAYER_MODE_LCH_HUE,
GIMP_LAYER_MODE_LCH_CHROMA,
GIMP_LAYER_MODE_LCH_COLOR,
GIMP_LAYER_MODE_LCH_LIGHTNESS);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_DISSOLVE_MODE, -1);
GIMP_LAYER_MODE_DISSOLVE, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_ADDITION_MODE, -1);
GIMP_LAYER_MODE_ADDITION_BROKEN, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_BURN_MODE, -1);
GIMP_LAYER_MODE_BURN_BROKEN, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_HARDLIGHT_MODE, -1);
GIMP_LAYER_MODE_HARDLIGHT_BROKEN, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_DIVIDE_MODE, -1);
GIMP_LAYER_MODE_DIVIDE_BROKEN, -1);
gimp_int_store_insert_separator_after (GIMP_INT_STORE (store),
GIMP_VALUE_MODE, -1);
GIMP_LAYER_MODE_HSV_VALUE_BROKEN, -1);
if (with_behind_mode)
{
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_DISSOLVE_MODE,
GIMP_BEHIND_MODE);
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LAYER_MODE_BEHIND);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_BEHIND_MODE,
GIMP_COLOR_ERASE_MODE);
GIMP_LAYER_MODE_BEHIND,
GIMP_LAYER_MODE_COLOR_ERASE);
}
if (with_replace_modes)
{
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_NORMAL_MODE,
GIMP_REPLACE_MODE);
GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_REPLACE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_COLOR_ERASE_MODE,
GIMP_ERASE_MODE);
GIMP_LAYER_MODE_COLOR_ERASE,
GIMP_LAYER_MODE_ERASE);
gimp_enum_store_insert_value_after (GIMP_ENUM_STORE (store),
GIMP_ERASE_MODE,
GIMP_ANTI_ERASE_MODE);
GIMP_LAYER_MODE_ERASE,
GIMP_LAYER_MODE_ANTI_ERASE);
}
combo = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store));

8
app/xcf/xcf-load.c
View File

@ -1093,10 +1093,10 @@ xcf_load_layer_props (XcfInfo *info,
info->cp += xcf_read_int32 (info->input, &mode, 1);
if (mode == GIMP_OVERLAY_MODE)
mode = GIMP_SOFTLIGHT_MODE;
if (mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
gimp_layer_set_mode (*layer, (GimpLayerModeEffects) mode, FALSE);
gimp_layer_set_mode (*layer, (GimpLayerMode) mode, FALSE);
}
break;
@ -1525,7 +1525,7 @@ xcf_load_layer (XcfInfo *info,
/* create a new layer */
layer = gimp_layer_new (image, width, height,
format, name, 255, GIMP_NORMAL_MODE);
format, name, 255, GIMP_LAYER_MODE_NORMAL);
g_free (name);
if (! layer)
return NULL;

4
app/xcf/xcf-save.c
View File

@ -726,8 +726,8 @@ xcf_save_prop (XcfInfo *info,
mode = va_arg (args, gint32);
size = 4;
if (mode == GIMP_OVERLAY_MODE)
mode = GIMP_SOFTLIGHT_MODE;
if (mode == GIMP_LAYER_MODE_OVERLAY_BROKEN)
mode = GIMP_LAYER_MODE_SOFTLIGHT_BROKEN;
xcf_write_prop_type_check_error (info, prop_type);
xcf_write_int32_check_error (info, &size, 1);

2
libgimp/gimp.def
View File

@ -604,7 +604,7 @@ EXPORTS
gimp_layer_get_show_mask
gimp_layer_group_new
gimp_layer_is_floating_sel
gimp_layer_mode_effects_get_type
gimp_layer_mode_get_type
gimp_layer_new
gimp_layer_new_from_drawable
gimp_layer_new_from_pixbuf

4
libgimp/gimpbrushes.c
View File

@ -59,7 +59,7 @@ gimp_brushes_set_opacity (gdouble opacity)
*
* Returns: The paint mode.
*/
GimpLayerModeEffects
GimpLayerMode
gimp_brushes_get_paint_mode (void)
{
return gimp_context_get_paint_mode ();
@ -74,7 +74,7 @@ gimp_brushes_get_paint_mode (void)
* Returns: TRUE on success.
*/
gboolean
gimp_brushes_set_paint_mode (GimpLayerModeEffects paint_mode)
gimp_brushes_set_paint_mode (GimpLayerMode paint_mode)
{
return gimp_context_set_paint_mode (paint_mode);
}

10
libgimp/gimpbrushes.h
View File

@ -30,15 +30,15 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
GIMP_DEPRECATED_FOR(gimp_context_get_opacity)
gdouble gimp_brushes_get_opacity (void);
gdouble gimp_brushes_get_opacity (void);
GIMP_DEPRECATED_FOR(gimp_context_set_opacity)
gboolean gimp_brushes_set_opacity (gdouble opacity);
gboolean gimp_brushes_set_opacity (gdouble opacity);
GIMP_DEPRECATED_FOR(gimp_context_get_paint_mode)
GimpLayerModeEffects gimp_brushes_get_paint_mode (void);
GimpLayerMode gimp_brushes_get_paint_mode (void);
GIMP_DEPRECATED_FOR(gimp_context_set_paint_mode)
gboolean gimp_brushes_set_paint_mode (GimpLayerModeEffects paint_mode);
gboolean gimp_brushes_set_paint_mode (GimpLayerMode paint_mode);
GIMP_DEPRECATED_FOR(gimp_context_set_brush)
gboolean gimp_brushes_set_brush (const gchar *name);
gboolean gimp_brushes_set_brush (const gchar *name);
G_END_DECLS

16
libgimp/gimpbrushes_pdb.c
View File

@ -215,14 +215,14 @@ gimp_brushes_set_spacing (gint spacing)
* Returns: The brush name.
**/
gchar *
gimp_brushes_get_brush_data (const gchar *name,
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data)
gimp_brushes_get_brush_data (const gchar *name,
gdouble *opacity,
gint *spacing,
GimpLayerMode *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data)
{
GimpParam *return_vals;
gint nreturn_vals;

28
libgimp/gimpbrushes_pdb.h
View File

@ -33,25 +33,25 @@ G_BEGIN_DECLS
gboolean gimp_brushes_refresh (void);
gchar** gimp_brushes_get_list (const gchar *filter,
gint *num_brushes);
gchar** gimp_brushes_get_list (const gchar *filter,
gint *num_brushes);
GIMP_DEPRECATED_FOR(gimp_context_get_brush)
gchar* gimp_brushes_get_brush (gint *width,
gint *height,
gint *spacing);
gchar* gimp_brushes_get_brush (gint *width,
gint *height,
gint *spacing);
GIMP_DEPRECATED_FOR(gimp_brush_get_spacing)
gint gimp_brushes_get_spacing (void);
GIMP_DEPRECATED_FOR(gimp_brush_set_spacing)
gboolean gimp_brushes_set_spacing (gint spacing);
gboolean gimp_brushes_set_spacing (gint spacing);
GIMP_DEPRECATED_FOR(gimp_brush_get_pixels)
gchar* gimp_brushes_get_brush_data (const gchar *name,
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data);
gchar* gimp_brushes_get_brush_data (const gchar *name,
gdouble *opacity,
gint *spacing,
GimpLayerMode *paint_mode,
gint *width,
gint *height,
gint *length,
guint8 **mask_data);
G_END_DECLS

16
libgimp/gimpbrushmenu.c
View File

@ -50,7 +50,7 @@ static void compat_callback (GimpBrushSelectButton *brush_button,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
gint width,
gint height,
const guchar *mask_data,
@ -80,7 +80,7 @@ gimp_brush_select_widget_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpRunBrushCallback callback,
gpointer data)
{
@ -132,11 +132,11 @@ gimp_brush_select_widget_close (GtkWidget *widget)
* call to gimp_brush_select_widget_new().
*/
void
gimp_brush_select_widget_set (GtkWidget *widget,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
gimp_brush_select_widget_set (GtkWidget *widget,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode)
{
g_return_if_fail (widget != NULL);
@ -150,7 +150,7 @@ compat_callback (GimpBrushSelectButton *brush_button,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
gint width,
gint height,
const guchar *mask_data,

4
libgimp/gimpbrushmenu.h
View File

@ -36,7 +36,7 @@ GtkWidget * gimp_brush_select_widget_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpRunBrushCallback callback,
gpointer data);
@ -47,7 +47,7 @@ void gimp_brush_select_widget_set (GtkWidget *widget,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
G_END_DECLS

2
libgimp/gimpbrushselect.c
View File

@ -64,7 +64,7 @@ gimp_brush_select_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpRunBrushCallback callback,
gpointer data)
{

4
libgimp/gimpbrushselect.h
View File

@ -31,7 +31,7 @@ G_BEGIN_DECLS
typedef void (* GimpRunBrushCallback) (const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
gint width,
gint height,
const guchar *mask_data,
@ -43,7 +43,7 @@ const gchar * gimp_brush_select_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
GimpRunBrushCallback callback,
gpointer data);
void gimp_brush_select_destroy (const gchar *brush_callback);

22
libgimp/gimpbrushselect_pdb.c
View File

@ -50,12 +50,12 @@
* Returns: TRUE on success.
**/
gboolean
gimp_brushes_popup (const gchar *brush_callback,
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
gimp_brushes_popup (const gchar *brush_callback,
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -122,11 +122,11 @@ gimp_brushes_close_popup (const gchar *brush_callback)
* Returns: TRUE on success.
**/
gboolean
gimp_brushes_set_popup (const gchar *brush_callback,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
gimp_brushes_set_popup (const gchar *brush_callback,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode)
{
GimpParam *return_vals;
gint nreturn_vals;

24
libgimp/gimpbrushselect_pdb.h
View File

@ -32,18 +32,18 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
gboolean gimp_brushes_popup (const gchar *brush_callback,
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
gboolean gimp_brushes_close_popup (const gchar *brush_callback);
gboolean gimp_brushes_set_popup (const gchar *brush_callback,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
gboolean gimp_brushes_popup (const gchar *brush_callback,
const gchar *popup_title,
const gchar *initial_brush,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode);
gboolean gimp_brushes_close_popup (const gchar *brush_callback);
gboolean gimp_brushes_set_popup (const gchar *brush_callback,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode);
G_END_DECLS

60
libgimp/gimpbrushselectbutton.c
View File

@ -53,19 +53,19 @@ typedef struct _GimpBrushSelectButtonPrivate GimpBrushSelectButtonPrivate;
struct _GimpBrushSelectButtonPrivate
{
gchar *title;
gchar *title;
gchar *brush_name; /* Local copy */
gdouble opacity;
gint spacing;
GimpLayerModeEffects paint_mode;
gint width;
gint height;
guchar *mask_data; /* local copy */
gchar *brush_name; /* Local copy */
gdouble opacity;
gint spacing;
GimpLayerMode paint_mode;
gint width;
gint height;
guchar *mask_data; /* local copy */
GtkWidget *inside;
GtkWidget *preview;
GtkWidget *popup;
GtkWidget *inside;
GtkWidget *preview;
GtkWidget *popup;
};
enum
@ -103,7 +103,7 @@ static void gimp_brush_select_button_clicked (GimpBrushSelectButton *button);
static void gimp_brush_select_button_callback (const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
gint width,
gint height,
const guchar *mask_data,
@ -225,7 +225,7 @@ gimp_brush_select_button_class_init (GimpBrushSelectButtonClass *klass)
/**
* GimpBrushSelectButton:paint-mode:
*
* The name of the currently selected brush.
* The paint mode.
*
* Since: 2.4
*/
@ -233,7 +233,7 @@ gimp_brush_select_button_class_init (GimpBrushSelectButtonClass *klass)
g_param_spec_int ("brush-paint-mode",
"Brush paint mode",
"The paint mode of the currently selected brush",
-1, GIMP_COLOR_ERASE_MODE,
-1, GIMP_LAYER_MODE_LCH_LIGHTNESS,
-1,
GIMP_PARAM_READWRITE));
@ -324,11 +324,11 @@ gimp_brush_select_button_init (GimpBrushSelectButton *button)
* Since: 2.4
*/
GtkWidget *
gimp_brush_select_button_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
gimp_brush_select_button_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode)
{
GtkWidget *button;
@ -368,7 +368,7 @@ const gchar *
gimp_brush_select_button_get_brush (GimpBrushSelectButton *button,
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode)
GimpLayerMode *paint_mode)
{
GimpBrushSelectButtonPrivate *priv;
@ -406,7 +406,7 @@ gimp_brush_select_button_set_brush (GimpBrushSelectButton *button,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode)
GimpLayerMode paint_mode)
{
GimpSelectButton *select_button;
@ -572,15 +572,15 @@ gimp_brush_select_button_get_property (GObject *object,
}
static void
gimp_brush_select_button_callback (const gchar *name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
gint width,
gint height,
const guchar *mask_data,
gboolean dialog_closing,
gpointer data)
gimp_brush_select_button_callback (const gchar *name,
gdouble opacity,
gint spacing,
GimpLayerMode paint_mode,
gint width,
gint height,
const guchar *mask_data,
gboolean dialog_closing,
gpointer data)
{
GimpBrushSelectButton *button;
GimpBrushSelectButtonPrivate *priv;

8
libgimp/gimpbrushselectbutton.h
View File

@ -56,7 +56,7 @@ struct _GimpBrushSelectButtonClass
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode,
GimpLayerMode paint_mode,
gint width,
gint height,
const guchar *mask_data,
@ -76,17 +76,17 @@ GtkWidget * gimp_brush_select_button_new (const gchar *title,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
const gchar * gimp_brush_select_button_get_brush (GimpBrushSelectButton *button,
gdouble *opacity,
gint *spacing,
GimpLayerModeEffects *paint_mode);
GimpLayerMode *paint_mode);
void gimp_brush_select_button_set_brush (GimpBrushSelectButton *button,
const gchar *brush_name,
gdouble opacity,
gint spacing,
GimpLayerModeEffects paint_mode);
GimpLayerMode paint_mode);
G_END_DECLS

6
libgimp/gimpcontext_pdb.c
View File

@ -585,12 +585,12 @@ gimp_context_set_opacity (gdouble opacity)
*
* Since: 2.2
**/
GimpLayerModeEffects
GimpLayerMode
gimp_context_get_paint_mode (void)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpLayerModeEffects paint_mode = 0;
GimpLayerMode paint_mode = 0;
return_vals = gimp_run_procedure ("gimp-context-get-paint-mode",
&nreturn_vals,
@ -617,7 +617,7 @@ gimp_context_get_paint_mode (void)
* Since: 2.2
**/
gboolean
gimp_context_set_paint_mode (GimpLayerModeEffects paint_mode)
gimp_context_set_paint_mode (GimpLayerMode paint_mode)
{
GimpParam *return_vals;
gint nreturn_vals;

4
libgimp/gimpcontext_pdb.h
View File

@ -49,8 +49,8 @@ gboolean gimp_context_set_default_colors (void);
gboolean gimp_context_swap_colors (void);
gdouble gimp_context_get_opacity (void);
gboolean gimp_context_set_opacity (gdouble opacity);
GimpLayerModeEffects gimp_context_get_paint_mode (void);
gboolean gimp_context_set_paint_mode (GimpLayerModeEffects paint_mode);
GimpLayerMode gimp_context_get_paint_mode (void);
gboolean gimp_context_set_paint_mode (GimpLayerMode paint_mode);
gdouble gimp_context_get_line_width (void);
gboolean gimp_context_set_line_width (gdouble line_width);
GimpUnit gimp_context_get_line_width_unit (void);

68
libgimp/gimpedit_pdb.c
View File

@ -517,14 +517,14 @@ gimp_edit_fill (gint32 drawable_ID,
* Returns: TRUE on success.
**/
gboolean
gimp_edit_bucket_fill (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y)
gimp_edit_bucket_fill (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerMode paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -583,16 +583,16 @@ gimp_edit_bucket_fill (gint32 drawable_ID,
* Since: 2.4
**/
gboolean
gimp_edit_bucket_fill_full (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gboolean fill_transparent,
GimpSelectCriterion select_criterion,
gdouble x,
gdouble y)
gimp_edit_bucket_fill_full (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerMode paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gboolean fill_transparent,
GimpSelectCriterion select_criterion,
gdouble x,
gdouble y)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -649,22 +649,22 @@ gimp_edit_bucket_fill_full (gint32 drawable_ID,
* Returns: TRUE on success.
**/
gboolean
gimp_edit_blend (gint32 drawable_ID,
GimpBlendMode blend_mode,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
gimp_edit_blend (gint32 drawable_ID,
GimpBlendMode blend_mode,
GimpLayerMode paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GimpParam *return_vals;
gint nreturn_vals;

110
libgimp/gimpedit_pdb.h
View File

@ -32,62 +32,62 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
gboolean gimp_edit_cut (gint32 drawable_ID);
gboolean gimp_edit_copy (gint32 drawable_ID);
gboolean gimp_edit_copy_visible (gint32 image_ID);
gint32 gimp_edit_paste (gint32 drawable_ID,
gboolean paste_into);
gboolean gimp_edit_cut (gint32 drawable_ID);
gboolean gimp_edit_copy (gint32 drawable_ID);
gboolean gimp_edit_copy_visible (gint32 image_ID);
gint32 gimp_edit_paste (gint32 drawable_ID,
gboolean paste_into);
gint32 gimp_edit_paste_as_new_image (void);
gchar* gimp_edit_named_cut (gint32 drawable_ID,
const gchar *buffer_name);
gchar* gimp_edit_named_copy (gint32 drawable_ID,
const gchar *buffer_name);
gchar* gimp_edit_named_copy_visible (gint32 image_ID,
const gchar *buffer_name);
gint32 gimp_edit_named_paste (gint32 drawable_ID,
const gchar *buffer_name,
gboolean paste_into);
gint32 gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
gboolean gimp_edit_clear (gint32 drawable_ID);
gboolean gimp_edit_fill (gint32 drawable_ID,
GimpFillType fill_type);
gboolean gimp_edit_bucket_fill (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y);
gboolean gimp_edit_bucket_fill_full (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerModeEffects paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gboolean fill_transparent,
GimpSelectCriterion select_criterion,
gdouble x,
gdouble y);
gboolean gimp_edit_blend (gint32 drawable_ID,
GimpBlendMode blend_mode,
GimpLayerModeEffects paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2);
gboolean gimp_edit_stroke (gint32 drawable_ID);
gboolean gimp_edit_stroke_vectors (gint32 drawable_ID,
gint32 vectors_ID);
gchar* gimp_edit_named_cut (gint32 drawable_ID,
const gchar *buffer_name);
gchar* gimp_edit_named_copy (gint32 drawable_ID,
const gchar *buffer_name);
gchar* gimp_edit_named_copy_visible (gint32 image_ID,
const gchar *buffer_name);
gint32 gimp_edit_named_paste (gint32 drawable_ID,
const gchar *buffer_name,
gboolean paste_into);
gint32 gimp_edit_named_paste_as_new_image (const gchar *buffer_name);
gboolean gimp_edit_clear (gint32 drawable_ID);
gboolean gimp_edit_fill (gint32 drawable_ID,
GimpFillType fill_type);
gboolean gimp_edit_bucket_fill (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerMode paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gdouble x,
gdouble y);
gboolean gimp_edit_bucket_fill_full (gint32 drawable_ID,
GimpBucketFillMode fill_mode,
GimpLayerMode paint_mode,
gdouble opacity,
gdouble threshold,
gboolean sample_merged,
gboolean fill_transparent,
GimpSelectCriterion select_criterion,
gdouble x,
gdouble y);
gboolean gimp_edit_blend (gint32 drawable_ID,
GimpBlendMode blend_mode,
GimpLayerMode paint_mode,
GimpGradientType gradient_type,
gdouble opacity,
gdouble offset,
GimpRepeatMode repeat,
gboolean reverse,
gboolean supersample,
gint max_depth,
gdouble threshold,
gboolean dither,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2);
gboolean gimp_edit_stroke (gint32 drawable_ID);
gboolean gimp_edit_stroke_vectors (gint32 drawable_ID,
gint32 vectors_ID);
G_END_DECLS

11
libgimp/gimpenums.c.tail
View File

@ -35,7 +35,7 @@ static const GimpGetTypeFunc get_type_funcs[] =
gimp_ink_blob_type_get_type,
gimp_interpolation_type_get_type,
gimp_join_style_get_type,
gimp_layer_mode_effects_get_type,
gimp_layer_mode_get_type,
gimp_mask_apply_mode_get_type,
gimp_merge_type_get_type,
gimp_message_handler_type_get_type,
@ -99,7 +99,7 @@ static const gchar * const type_names[] =
"GimpInkBlobType",
"GimpInterpolationType",
"GimpJoinStyle",
"GimpLayerModeEffects",
"GimpLayerMode",
"GimpMaskApplyMode",
"GimpMergeType",
"GimpMessageHandlerType",
@ -146,6 +146,7 @@ void
gimp_enums_init (void)
{
const GimpGetTypeFunc *funcs = get_type_funcs;
GQuark quark;
gint i;
if (enums_initialized)
@ -158,6 +159,12 @@ gimp_enums_init (void)
g_type_class_ref (type);
}
/* keep compat enum code in sync with app/app.c (app_libs_init) */
quark = g_quark_from_static_string ("gimp-compat-enum");
g_type_set_qdata (GIMP_TYPE_LAYER_MODE, quark,
(gpointer) GIMP_TYPE_LAYER_MODE_EFFECTS);
enums_initialized = TRUE;
}

62
libgimp/gimpenums.h
View File

@ -63,41 +63,41 @@ typedef enum
} GimpHistogramChannel;
#define GIMP_TYPE_LAYER_MODE_EFFECTS (gimp_layer_mode_effects_get_type ())
#define GIMP_TYPE_LAYER_MODE (gimp_layer_mode_get_type ())
GType gimp_layer_mode_effects_get_type (void) G_GNUC_CONST;
GType gimp_layer_mode_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_NORMAL_MODE,
GIMP_DISSOLVE_MODE,
GIMP_BEHIND_MODE,
GIMP_MULTIPLY_MODE,
GIMP_SCREEN_MODE,
GIMP_OVERLAY_MODE,
GIMP_DIFFERENCE_MODE,
GIMP_ADDITION_MODE,
GIMP_SUBTRACT_MODE,
GIMP_DARKEN_ONLY_MODE,
GIMP_LIGHTEN_ONLY_MODE,
GIMP_HUE_MODE,
GIMP_SATURATION_MODE,
GIMP_COLOR_MODE,
GIMP_VALUE_MODE,
GIMP_DIVIDE_MODE,
GIMP_DODGE_MODE,
GIMP_BURN_MODE,
GIMP_HARDLIGHT_MODE,
GIMP_SOFTLIGHT_MODE,
GIMP_GRAIN_EXTRACT_MODE,
GIMP_GRAIN_MERGE_MODE,
GIMP_COLOR_ERASE_MODE,
GIMP_NEW_OVERLAY_MODE,
GIMP_LCH_HUE_MODE,
GIMP_LCH_CHROMA_MODE,
GIMP_LCH_COLOR_MODE,
GIMP_LCH_LIGHTNESS_MODE
} GimpLayerModeEffects;
GIMP_LAYER_MODE_NORMAL,
GIMP_LAYER_MODE_DISSOLVE,
GIMP_LAYER_MODE_BEHIND,
GIMP_LAYER_MODE_MULTIPLY_BROKEN,
GIMP_LAYER_MODE_SCREEN_BROKEN,
GIMP_LAYER_MODE_OVERLAY_BROKEN,
GIMP_LAYER_MODE_DIFFERENCE_BROKEN,
GIMP_LAYER_MODE_ADDITION_BROKEN,
GIMP_LAYER_MODE_SUBTRACT_BROKEN,
GIMP_LAYER_MODE_DARKEN_ONLY_BROKEN,
GIMP_LAYER_MODE_LIGHTEN_ONLY_BROKEN,
GIMP_LAYER_MODE_HSV_HUE_BROKEN,
GIMP_LAYER_MODE_HSV_SATURATION_BROKEN,
GIMP_LAYER_MODE_HSV_COLOR_BROKEN,
GIMP_LAYER_MODE_HSV_VALUE_BROKEN,
GIMP_LAYER_MODE_DIVIDE_BROKEN,
GIMP_LAYER_MODE_DODGE_BROKEN,
GIMP_LAYER_MODE_BURN_BROKEN,
GIMP_LAYER_MODE_HARDLIGHT_BROKEN,
GIMP_LAYER_MODE_SOFTLIGHT_BROKEN,
GIMP_LAYER_MODE_GRAIN_EXTRACT_BROKEN,
GIMP_LAYER_MODE_GRAIN_MERGE_BROKEN,
GIMP_LAYER_MODE_COLOR_ERASE,
GIMP_LAYER_MODE_OVERLAY,
GIMP_LAYER_MODE_LCH_HUE,
GIMP_LAYER_MODE_LCH_CHROMA,
GIMP_LAYER_MODE_LCH_COLOR,
GIMP_LAYER_MODE_LCH_LIGHTNESS
} GimpLayerMode;
void gimp_enums_init (void);

2
libgimp/gimpexport.c
View File

@ -95,7 +95,7 @@ export_merge (gint32 image_ID,
gimp_image_width (image_ID),
gimp_image_height (image_ID),
gimp_drawable_type (*drawable_ID) | 1,
100.0, GIMP_NORMAL_MODE);
100.0, GIMP_LAYER_MODE_NORMAL);
gimp_image_insert_layer (image_ID, transp, -1, 1);
gimp_selection_none (image_ID);
gimp_edit_clear (transp);

2
libgimp/gimpimagemetadata.c
View File

@ -604,7 +604,7 @@ gimp_image_metadata_load_thumbnail (GFile *file,
layer_ID = gimp_layer_new_from_pixbuf (image_ID, _("Background"),
pixbuf,
100.0, GIMP_NORMAL_MODE,
100.0, GIMP_LAYER_MODE_NORMAL,
0.0, 0.0);
g_object_unref (pixbuf);

30
libgimp/gimplayer.c
View File

@ -49,13 +49,13 @@
* Returns: The newly created layer.
*/
gint32
gimp_layer_new (gint32 image_ID,
const gchar *name,
gint width,
gint height,
GimpImageType type,
gdouble opacity,
GimpLayerModeEffects mode)
gimp_layer_new (gint32 image_ID,
const gchar *name,
gint width,
gint height,
GimpImageType type,
gdouble opacity,
GimpLayerMode mode)
{
return _gimp_layer_new (image_ID,
width,
@ -109,13 +109,13 @@ gimp_layer_copy (gint32 layer_ID)
* Since: 2.4
*/
gint32
gimp_layer_new_from_pixbuf (gint32 image_ID,
const gchar *name,
GdkPixbuf *pixbuf,
gdouble opacity,
GimpLayerModeEffects mode,
gdouble progress_start,
gdouble progress_end)
gimp_layer_new_from_pixbuf (gint32 image_ID,
const gchar *name,
GdkPixbuf *pixbuf,
gdouble opacity,
GimpLayerMode mode,
gdouble progress_start,
gdouble progress_end)
{
gint32 layer;
gint width;
@ -274,7 +274,7 @@ gimp_layer_new_from_surface (gint32 image_ID,
layer = gimp_layer_new (image_ID, name, width, height,
format == CAIRO_FORMAT_RGB24 ?
GIMP_RGB_IMAGE : GIMP_RGBA_IMAGE,
100.0, GIMP_NORMAL_MODE);
100.0, GIMP_LAYER_MODE_NORMAL);
if (layer == -1)
return -1;

46
libgimp/gimplayer.h
View File

@ -30,33 +30,33 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
gint32 gimp_layer_new (gint32 image_ID,
const gchar *name,
gint width,
gint height,
GimpImageType type,
gdouble opacity,
GimpLayerModeEffects mode);
gint32 gimp_layer_copy (gint32 layer_ID);
gint32 gimp_layer_new (gint32 image_ID,
const gchar *name,
gint width,
gint height,
GimpImageType type,
gdouble opacity,
GimpLayerMode mode);
gint32 gimp_layer_copy (gint32 layer_ID);
gint32 gimp_layer_new_from_pixbuf (gint32 image_ID,
const gchar *name,
GdkPixbuf *pixbuf,
gdouble opacity,
GimpLayerModeEffects mode,
gdouble progress_start,
gdouble progress_end);
gint32 gimp_layer_new_from_surface (gint32 image_ID,
const gchar *name,
cairo_surface_t *surface,
gdouble progress_start,
gdouble progress_end);
gint32 gimp_layer_new_from_pixbuf (gint32 image_ID,
const gchar *name,
GdkPixbuf *pixbuf,
gdouble opacity,
GimpLayerMode mode,
gdouble progress_start,
gdouble progress_end);
gint32 gimp_layer_new_from_surface (gint32 image_ID,
const gchar *name,
cairo_surface_t *surface,
gdouble progress_start,
gdouble progress_end);
GIMP_DEPRECATED_FOR(gimp_layer_get_lock_alpha)
gboolean gimp_layer_get_preserve_trans (gint32 layer_ID);
gboolean gimp_layer_get_preserve_trans (gint32 layer_ID);
GIMP_DEPRECATED_FOR(gimp_layer_set_lock_alpha)
gboolean gimp_layer_set_preserve_trans (gint32 layer_ID,
gboolean preserve_trans);
gboolean gimp_layer_set_preserve_trans (gint32 layer_ID,
gboolean preserve_trans);
G_END_DECLS

22
libgimp/gimplayer_pdb.c
View File

@ -56,13 +56,13 @@
* Returns: The newly created layer.
**/
gint32
_gimp_layer_new (gint32 image_ID,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode)
_gimp_layer_new (gint32 image_ID,
gint width,
gint height,
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerMode mode)
{
GimpParam *return_vals;
gint nreturn_vals;
@ -1101,12 +1101,12 @@ gimp_layer_set_opacity (gint32 layer_ID,
*
* Returns: The layer combination mode.
**/
GimpLayerModeEffects
GimpLayerMode
gimp_layer_get_mode (gint32 layer_ID)
{
GimpParam *return_vals;
gint nreturn_vals;
GimpLayerModeEffects mode = 0;
GimpLayerMode mode = 0;
return_vals = gimp_run_procedure ("gimp-layer-get-mode",
&nreturn_vals,
@ -1133,8 +1133,8 @@ gimp_layer_get_mode (gint32 layer_ID)
* Returns: TRUE on success.
**/
gboolean
gimp_layer_set_mode (gint32 layer_ID,
GimpLayerModeEffects mode)
gimp_layer_set_mode (gint32 layer_ID,
GimpLayerMode mode)
{
GimpParam *return_vals;
gint nreturn_vals;

6
libgimp/gimplayer_pdb.h
View File

@ -38,7 +38,7 @@ G_GNUC_INTERNAL gint32 _gimp_layer_new (gint32 i
GimpImageType type,
const gchar *name,
gdouble opacity,
GimpLayerModeEffects mode);
GimpLayerMode mode);
gint32 gimp_layer_new_from_visible (gint32 image_ID,
gint32 dest_image_ID,
const gchar *name);
@ -95,9 +95,9 @@ gboolean gimp_layer_set_edit_mask (gint32 l
gdouble gimp_layer_get_opacity (gint32 layer_ID);
gboolean gimp_layer_set_opacity (gint32 layer_ID,
gdouble opacity);
GimpLayerModeEffects gimp_layer_get_mode (gint32 layer_ID);
GimpLayerMode gimp_layer_get_mode (gint32 layer_ID);
gboolean gimp_layer_set_mode (gint32 layer_ID,
GimpLayerModeEffects mode);
GimpLayerMode mode);
G_END_DECLS

1
libgimpbase/gimpbase.def
View File

@ -60,6 +60,7 @@ EXPORTS
gimp_installation_directory
gimp_interpolation_type_get_type
gimp_join_style_get_type
gimp_layer_mode_effects_get_type
gimp_locale_directory
gimp_locale_directory_file
gimp_major_version

72
libgimpbase/gimpbaseenums.c
View File

@ -1020,6 +1020,78 @@ gimp_join_style_get_type (void)
return type;
}
GType
gimp_layer_mode_effects_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_NORMAL_MODE, "GIMP_NORMAL_MODE", "normal-mode" },
{ GIMP_DISSOLVE_MODE, "GIMP_DISSOLVE_MODE", "dissolve-mode" },
{ GIMP_BEHIND_MODE, "GIMP_BEHIND_MODE", "behind-mode" },
{ GIMP_MULTIPLY_MODE, "GIMP_MULTIPLY_MODE", "multiply-mode" },
{ GIMP_SCREEN_MODE, "GIMP_SCREEN_MODE", "screen-mode" },
{ GIMP_OVERLAY_MODE, "GIMP_OVERLAY_MODE", "overlay-mode" },
{ GIMP_DIFFERENCE_MODE, "GIMP_DIFFERENCE_MODE", "difference-mode" },
{ GIMP_ADDITION_MODE, "GIMP_ADDITION_MODE", "addition-mode" },
{ GIMP_SUBTRACT_MODE, "GIMP_SUBTRACT_MODE", "subtract-mode" },
{ GIMP_DARKEN_ONLY_MODE, "GIMP_DARKEN_ONLY_MODE", "darken-only-mode" },
{ GIMP_LIGHTEN_ONLY_MODE, "GIMP_LIGHTEN_ONLY_MODE", "lighten-only-mode" },
{ GIMP_HUE_MODE, "GIMP_HUE_MODE", "hue-mode" },
{ GIMP_SATURATION_MODE, "GIMP_SATURATION_MODE", "saturation-mode" },
{ GIMP_COLOR_MODE, "GIMP_COLOR_MODE", "color-mode" },
{ GIMP_VALUE_MODE, "GIMP_VALUE_MODE", "value-mode" },
{ GIMP_DIVIDE_MODE, "GIMP_DIVIDE_MODE", "divide-mode" },
{ GIMP_DODGE_MODE, "GIMP_DODGE_MODE", "dodge-mode" },
{ GIMP_BURN_MODE, "GIMP_BURN_MODE", "burn-mode" },
{ GIMP_HARDLIGHT_MODE, "GIMP_HARDLIGHT_MODE", "hardlight-mode" },
{ GIMP_SOFTLIGHT_MODE, "GIMP_SOFTLIGHT_MODE", "softlight-mode" },
{ GIMP_GRAIN_EXTRACT_MODE, "GIMP_GRAIN_EXTRACT_MODE", "grain-extract-mode" },
{ GIMP_GRAIN_MERGE_MODE, "GIMP_GRAIN_MERGE_MODE", "grain-merge-mode" },
{ GIMP_COLOR_ERASE_MODE, "GIMP_COLOR_ERASE_MODE", "color-erase-mode" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_NORMAL_MODE, "GIMP_NORMAL_MODE", NULL },
{ GIMP_DISSOLVE_MODE, "GIMP_DISSOLVE_MODE", NULL },
{ GIMP_BEHIND_MODE, "GIMP_BEHIND_MODE", NULL },
{ GIMP_MULTIPLY_MODE, "GIMP_MULTIPLY_MODE", NULL },
{ GIMP_SCREEN_MODE, "GIMP_SCREEN_MODE", NULL },
{ GIMP_OVERLAY_MODE, "GIMP_OVERLAY_MODE", NULL },
{ GIMP_DIFFERENCE_MODE, "GIMP_DIFFERENCE_MODE", NULL },
{ GIMP_ADDITION_MODE, "GIMP_ADDITION_MODE", NULL },
{ GIMP_SUBTRACT_MODE, "GIMP_SUBTRACT_MODE", NULL },
{ GIMP_DARKEN_ONLY_MODE, "GIMP_DARKEN_ONLY_MODE", NULL },
{ GIMP_LIGHTEN_ONLY_MODE, "GIMP_LIGHTEN_ONLY_MODE", NULL },
{ GIMP_HUE_MODE, "GIMP_HUE_MODE", NULL },
{ GIMP_SATURATION_MODE, "GIMP_SATURATION_MODE", NULL },
{ GIMP_COLOR_MODE, "GIMP_COLOR_MODE", NULL },
{ GIMP_VALUE_MODE, "GIMP_VALUE_MODE", NULL },
{ GIMP_DIVIDE_MODE, "GIMP_DIVIDE_MODE", NULL },
{ GIMP_DODGE_MODE, "GIMP_DODGE_MODE", NULL },
{ GIMP_BURN_MODE, "GIMP_BURN_MODE", NULL },
{ GIMP_HARDLIGHT_MODE, "GIMP_HARDLIGHT_MODE", NULL },
{ GIMP_SOFTLIGHT_MODE, "GIMP_SOFTLIGHT_MODE", NULL },
{ GIMP_GRAIN_EXTRACT_MODE, "GIMP_GRAIN_EXTRACT_MODE", NULL },
{ GIMP_GRAIN_MERGE_MODE, "GIMP_GRAIN_MERGE_MODE", NULL },
{ GIMP_COLOR_ERASE_MODE, "GIMP_COLOR_ERASE_MODE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpLayerModeEffects", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "layer-mode-effects");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_mask_apply_mode_get_type (void)
{

34
libgimpbase/gimpbaseenums.h
View File

@ -483,6 +483,40 @@ typedef enum
} GimpJoinStyle;
#ifndef GIMP_DISABLE_DEPRECATED
#define GIMP_TYPE_LAYER_MODE_EFFECTS (gimp_layer_mode_effects_get_type ())
GType gimp_layer_mode_effects_get_type (void) G_GNUC_CONST;
typedef enum /*< pdb-skip >*/
{
GIMP_NORMAL_MODE,
GIMP_DISSOLVE_MODE,
GIMP_BEHIND_MODE,
GIMP_MULTIPLY_MODE,
GIMP_SCREEN_MODE,
GIMP_OVERLAY_MODE,
GIMP_DIFFERENCE_MODE,
GIMP_ADDITION_MODE,
GIMP_SUBTRACT_MODE,
GIMP_DARKEN_ONLY_MODE,
GIMP_LIGHTEN_ONLY_MODE,
GIMP_HUE_MODE,
GIMP_SATURATION_MODE,
GIMP_COLOR_MODE,
GIMP_VALUE_MODE,
GIMP_DIVIDE_MODE,
GIMP_DODGE_MODE,
GIMP_BURN_MODE,
GIMP_HARDLIGHT_MODE,
GIMP_SOFTLIGHT_MODE,
GIMP_GRAIN_EXTRACT_MODE,
GIMP_GRAIN_MERGE_MODE,
GIMP_COLOR_ERASE_MODE
} GimpLayerModeEffects;
#endif /* GIMP_DISABLE_DEPRECATED */
#define GIMP_TYPE_MASK_APPLY_MODE (gimp_mask_apply_mode_get_type ())
GType gimp_mask_apply_mode_get_type (void) G_GNUC_CONST;

4
plug-ins/common/animation-optimize.c
View File

@ -642,7 +642,7 @@ do_optimizations (GimpRunMode run_mode,
width, height,
drawabletype_alpha,
100.0,
GIMP_NORMAL_MODE);
GIMP_LAYER_MODE_NORMAL);
gimp_image_insert_layer (new_image_id, new_layer_id, -1, 0);
@ -1065,7 +1065,7 @@ do_optimizations (GimpRunMode run_mode,
bbox_bottom-bbox_top,
drawabletype_alpha,
100.0,
GIMP_NORMAL_MODE);
GIMP_LAYER_MODE_NORMAL);
g_free (newlayer_name);
gimp_image_insert_layer (new_image_id, new_layer_id, -1, 0);

3
plug-ins/common/compose.c
View File

@ -1020,7 +1020,8 @@ create_new_image (const gchar *filename,
gimp_image_set_filename (image_ID, filename);
*layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
gdtype, 100, GIMP_NORMAL_MODE);
gdtype,
100, GIMP_LAYER_MODE_NORMAL);
gimp_image_insert_layer (image_ID, *layer_ID, -1, 0);
*buffer = gimp_drawable_get_buffer (*layer_ID);

2
plug-ins/common/curve-bend.c
View File

@ -2753,7 +2753,7 @@ p_add_layer (gint width,
char *l_name;
char *l_name2;
gdouble l_opacity;
GimpLayerModeEffects l_mode;
GimpLayerMode l_mode;
gint l_visible;
gint32 image_id;
gint stack_position;

3
plug-ins/common/decompose.c
View File

@ -607,7 +607,8 @@ create_new_layer (gint32 image_ID,
layername = _("Background");
layer_ID = gimp_layer_new (image_ID, layername, width, height,
gdtype, 100, GIMP_NORMAL_MODE);
gdtype,
100, GIMP_LAYER_MODE_NORMAL);
gimp_image_insert_layer (image_ID, layer_ID, -1, position);
return layer_ID;

2
plug-ins/common/edge-dog.c
View File

@ -993,7 +993,7 @@ preview_update_preview (GimpPreview *preview,
preview_id = gimp_layer_new (image_id, "preview", width, height,
gimp_drawable_type (drawable->drawable_id),
100,
GIMP_NORMAL_MODE);
GIMP_LAYER_MODE_NORMAL);
preview_drawable = gimp_drawable_get (preview_id);
gimp_image_insert_layer (image_id, preview_id, -1, 0);
gimp_layer_set_offsets (preview_id, 0, 0);

Some files were not shown because too many files have changed in this diff Show More