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

libgimpbase: remove almost all deprecated compat cruft 

Keep infrastructure for compat enums around because we will
mose definitely need it again.
This commit is contained in:
Michael Natterer 2018-04-28 14:00:23 +02:00
parent c50fb989c8
commit 1671da428c
14 changed files with 70 additions and 1155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
app/app.c
View File

@ -86,8 +86,10 @@ static gboolean app_exit_after_callback (Gimp *gimp,
gboolean kill_it,
GMainLoop **loop);
#if 0
/* left here as documentation how to do compat enums */
GType gimp_convert_dither_type_compat_get_type (void); /* compat cruft */
GType gimp_layer_mode_effects_get_type (void); /* compat cruft */
#endif
/* local variables */
@ -102,7 +104,9 @@ void
app_libs_init (GOptionContext *context,
gboolean no_interface)
{
#if 0
GQuark quark;
#endif
/* disable OpenCL before GEGL is even initialized; this way we only
* enable if wanted in gimprc, instead of always enabling, and then
@ -122,13 +126,15 @@ app_libs_init (GOptionContext *context,
}
#endif
#if 0
/* left here as documentation how to do compat enums */
/* keep compat enum code in sync with pdb/enumcode.pl */
quark = g_quark_from_static_string ("gimp-compat-enum");
g_type_set_qdata (GIMP_TYPE_CONVERT_DITHER_TYPE, quark,
(gpointer) gimp_convert_dither_type_compat_get_type ());
g_type_set_qdata (GIMP_TYPE_LAYER_MODE, quark,
(gpointer) gimp_layer_mode_effects_get_type ());
#endif
}
void

14
libgimp/gimpenums.c.tail
View File

@ -65,7 +65,6 @@ static const GimpGetTypeFunc get_type_funcs[] =
gimp_transfer_mode_get_type,
gimp_transform_direction_get_type,
gimp_transform_resize_get_type,
gimp_user_directory_get_type,
gimp_vectors_stroke_type_get_type
};
@ -133,14 +132,15 @@ static const gchar * const type_names[] =
"GimpTransferMode",
"GimpTransformDirection",
"GimpTransformResize",
"GimpUserDirectory",
"GimpVectorsStrokeType"
};
static gboolean enums_initialized = FALSE;
#if 0
/* keep around as documentation how to do compat enums */
GType gimp_convert_dither_type_compat_get_type (void);
GType gimp_layer_mode_effects_get_type (void);
#endif
/**
* gimp_enums_init:
@ -157,7 +157,9 @@ void
gimp_enums_init (void)
{
const GimpGetTypeFunc *funcs = get_type_funcs;
#if 0
GQuark quark;
#endif
gint i;
if (enums_initialized)
@ -170,13 +172,15 @@ gimp_enums_init (void)
g_type_class_ref (type);
}
#if 0
/* keep around as documentation how to do compat enums */
/* 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_CONVERT_DITHER_TYPE, quark,
(gpointer) gimp_convert_dither_type_compat_get_type ());
g_type_set_qdata (GIMP_TYPE_LAYER_MODE, quark,
(gpointer) gimp_layer_mode_effects_get_type ());
#endif
gimp_base_compat_enums_init ();

32
libgimpbase/gimpbase-private.c
View File

@ -52,6 +52,7 @@ gimp_base_init (GimpUnitVtable *vtable)
void
gimp_base_compat_enums_init (void)
{
#if 0
static gboolean gimp_base_compat_initialized = FALSE;
GQuark quark;
@ -60,34 +61,13 @@ gimp_base_compat_enums_init (void)
quark = g_quark_from_static_string ("gimp-compat-enum");
/* This is how a compat enum is registered, leave one here for
* documentation purposes, remove it as soon as we get a real
* compat enum again
*/
g_type_set_qdata (GIMP_TYPE_ADD_MASK_TYPE, quark,
(gpointer) GIMP_TYPE_ADD_MASK_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_BLEND_MODE, quark,
(gpointer) GIMP_TYPE_BLEND_MODE_COMPAT);
g_type_set_qdata (GIMP_TYPE_BUCKET_FILL_MODE, quark,
(gpointer) GIMP_TYPE_BUCKET_FILL_MODE_COMPAT);
g_type_set_qdata (GIMP_TYPE_CHANNEL_TYPE, quark,
(gpointer) GIMP_TYPE_CHANNEL_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_CLONE_TYPE, quark,
(gpointer) GIMP_TYPE_CLONE_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_CONVERT_PALETTE_TYPE, quark,
(gpointer) GIMP_TYPE_CONVERT_PALETTE_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_CONVOLVE_TYPE, quark,
(gpointer) GIMP_TYPE_CONVOLVE_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_DESATURATE_MODE, quark,
(gpointer) GIMP_TYPE_DESATURATE_MODE_COMPAT);
g_type_set_qdata (GIMP_TYPE_DODGE_BURN_TYPE, quark,
(gpointer) GIMP_TYPE_DODGE_BURN_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_FILL_TYPE, quark,
(gpointer) GIMP_TYPE_FILL_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_HUE_RANGE, quark,
(gpointer) GIMP_TYPE_HUE_RANGE_COMPAT);
g_type_set_qdata (GIMP_TYPE_ICON_TYPE, quark,
(gpointer) GIMP_TYPE_ICON_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_INTERPOLATION_TYPE, quark,
(gpointer) GIMP_TYPE_INTERPOLATION_TYPE_COMPAT);
g_type_set_qdata (GIMP_TYPE_TRANSFER_MODE, quark,
(gpointer) GIMP_TYPE_TRANSFER_MODE_COMPAT);
gimp_base_compat_initialized = TRUE;
#endif
}

18
libgimpbase/gimpbase.def
View File

@ -1,30 +1,22 @@
EXPORTS
gimp_add_mask_type_compat_get_type
gimp_add_mask_type_get_type
gimp_any_to_utf8
gimp_base_compat_enums_init
gimp_base_init
gimp_blend_mode_compat_get_type
gimp_blend_mode_get_type
gimp_brush_generated_shape_get_type
gimp_bucket_fill_mode_compat_get_type
gimp_bucket_fill_mode_get_type
gimp_canonicalize_identifier
gimp_cap_style_get_type
gimp_channel_ops_get_type
gimp_channel_type_compat_get_type
gimp_channel_type_get_type
gimp_check_size_get_type
gimp_check_type_get_type
gimp_checks_get_shades
gimp_clone_type_compat_get_type
gimp_clone_type_get_type
gimp_color_tag_get_type
gimp_component_type_get_type
gimp_convert_dither_type_compat_get_type
gimp_convert_palette_type_compat_get_type
gimp_convert_palette_type_get_type
gimp_convolve_type_compat_get_type
gimp_convolve_type_get_type
gimp_cpu_accel_get_support
gimp_cpu_accel_set_use
@ -32,11 +24,9 @@ EXPORTS
gimp_data_directory_file
gimp_datafiles_check_extension
gimp_datafiles_read_directories
gimp_desaturate_mode_compat_get_type
gimp_desaturate_mode_get_type
gimp_directory
gimp_directory_file
gimp_dodge_burn_type_compat_get_type
gimp_dodge_burn_type_get_type
gimp_enum_get_desc
gimp_enum_get_value
@ -51,7 +41,6 @@ EXPORTS
gimp_file_has_extension
gimp_file_show_in_file_manager
gimp_filename_to_utf8
gimp_fill_type_compat_get_type
gimp_fill_type_get_type
gimp_flags_get_first_desc
gimp_flags_get_first_value
@ -67,15 +56,12 @@ EXPORTS
gimp_gradient_type_get_type
gimp_grid_style_get_type
gimp_gtkrc
gimp_hue_range_compat_get_type
gimp_hue_range_get_type
gimp_icon_type_compat_get_type
gimp_icon_type_get_type
gimp_image_base_type_get_type
gimp_image_type_get_type
gimp_ink_blob_type_get_type
gimp_installation_directory
gimp_interpolation_type_compat_get_type
gimp_interpolation_type_get_type
gimp_join_style_get_type
gimp_layer_mode_effects_get_type
@ -86,7 +72,6 @@ EXPORTS
gimp_memsize_deserialize
gimp_memsize_get_type
gimp_memsize_serialize
gimp_memsize_to_string
gimp_merge_type_get_type
gimp_message_handler_type_get_type
gimp_metadata_add_xmp_history
@ -170,7 +155,6 @@ EXPORTS
gimp_text_direction_get_type
gimp_text_hint_style_get_type
gimp_text_justification_get_type
gimp_transfer_mode_compat_get_type
gimp_transfer_mode_get_type
gimp_transform_direction_get_type
gimp_transform_resize_get_type
@ -196,8 +180,6 @@ EXPORTS
gimp_unit_set_deletion_flag
gimp_units_to_pixels
gimp_units_to_points
gimp_user_directory
gimp_user_directory_get_type
gimp_utf8_strtrim
gimp_value_array_append
gimp_value_array_get_type

42
libgimpbase/gimpbaseenums.c
View File

@ -1958,48 +1958,6 @@ gimp_transform_resize_get_type (void)
return type;
}
GType
gimp_user_directory_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_USER_DIRECTORY_DESKTOP, "GIMP_USER_DIRECTORY_DESKTOP", "desktop" },
{ GIMP_USER_DIRECTORY_DOCUMENTS, "GIMP_USER_DIRECTORY_DOCUMENTS", "documents" },
{ GIMP_USER_DIRECTORY_DOWNLOAD, "GIMP_USER_DIRECTORY_DOWNLOAD", "download" },
{ GIMP_USER_DIRECTORY_MUSIC, "GIMP_USER_DIRECTORY_MUSIC", "music" },
{ GIMP_USER_DIRECTORY_PICTURES, "GIMP_USER_DIRECTORY_PICTURES", "pictures" },
{ GIMP_USER_DIRECTORY_PUBLIC_SHARE, "GIMP_USER_DIRECTORY_PUBLIC_SHARE", "public-share" },
{ GIMP_USER_DIRECTORY_TEMPLATES, "GIMP_USER_DIRECTORY_TEMPLATES", "templates" },
{ GIMP_USER_DIRECTORY_VIDEOS, "GIMP_USER_DIRECTORY_VIDEOS", "videos" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_USER_DIRECTORY_DESKTOP, "GIMP_USER_DIRECTORY_DESKTOP", NULL },
{ GIMP_USER_DIRECTORY_DOCUMENTS, "GIMP_USER_DIRECTORY_DOCUMENTS", NULL },
{ GIMP_USER_DIRECTORY_DOWNLOAD, "GIMP_USER_DIRECTORY_DOWNLOAD", NULL },
{ GIMP_USER_DIRECTORY_MUSIC, "GIMP_USER_DIRECTORY_MUSIC", NULL },
{ GIMP_USER_DIRECTORY_PICTURES, "GIMP_USER_DIRECTORY_PICTURES", NULL },
{ GIMP_USER_DIRECTORY_PUBLIC_SHARE, "GIMP_USER_DIRECTORY_PUBLIC_SHARE", NULL },
{ GIMP_USER_DIRECTORY_TEMPLATES, "GIMP_USER_DIRECTORY_TEMPLATES", NULL },
{ GIMP_USER_DIRECTORY_VIDEOS, "GIMP_USER_DIRECTORY_VIDEOS", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpUserDirectory", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "user-directory");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_vectors_stroke_type_get_type (void)
{

243
libgimpbase/gimpbaseenums.h
View File

@ -36,21 +36,13 @@ G_BEGIN_DECLS
/**
* GimpAddMaskType:
* @GIMP_ADD_MASK_WHITE: White (full opacity)
* @GIMP_ADD_MASK_BLACK: Black (full transparency)
* @GIMP_ADD_MASK_ALPHA: Layer's alpha channel
* @GIMP_ADD_MASK_ALPHA_TRANSFER: Transfer layer's alpha channel
* @GIMP_ADD_MASK_SELECTION: Selection
* @GIMP_ADD_MASK_COPY: Grayscale copy of layer
* @GIMP_ADD_MASK_CHANNEL: Channel
* @GIMP_ADD_WHITE_MASK: Deprecated alias for @GIMP_ADD_MASK_WHITE
* @GIMP_ADD_BLACK_MASK: Deprecated alias for @GIMP_ADD_MASK_BLACK
* @GIMP_ADD_ALPHA_MASK: Deprecated alias for @GIMP_ADD_MASK_ALPHA
* @GIMP_ADD_ALPHA_TRANSFER_MASK: Deprecated alias for
* @GIMP_ADD_MASK_ALPHA_TRANSFER
* @GIMP_ADD_SELECTION_MASK: Deprecated alias for @GIMP_ADD_MASK_SELECTION
* @GIMP_ADD_COPY_MASK: Deprecated alias for @GIMP_ADD_MASK_COPY
* @GIMP_ADD_CHANNEL_MASK: Deprecated aliaa for @GIMP_ADD_MASK_CHANNEL
* @GIMP_ADD_MASK_WHITE: White (full opacity)
* @GIMP_ADD_MASK_BLACK: Black (full transparency)
* @GIMP_ADD_MASK_ALPHA: Layer's alpha channel
* @GIMP_ADD_MASK_ALPHA_TRANSFER: Transfer layer's alpha channel
* @GIMP_ADD_MASK_SELECTION: Selection
* @GIMP_ADD_MASK_COPY: Grayscale copy of layer
* @GIMP_ADD_MASK_CHANNEL: Channel
*
* Modes of initialising a layer mask.
**/
@ -66,17 +58,7 @@ typedef enum
GIMP_ADD_MASK_ALPHA_TRANSFER, /*< desc="_Transfer layer's alpha channel" >*/
GIMP_ADD_MASK_SELECTION, /*< desc="_Selection" >*/
GIMP_ADD_MASK_COPY, /*< desc="_Grayscale copy of layer" >*/
GIMP_ADD_MASK_CHANNEL, /*< desc="C_hannel" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_ADD_WHITE_MASK = GIMP_ADD_MASK_WHITE, /*< skip, pdb-skip >*/
GIMP_ADD_BLACK_MASK = GIMP_ADD_MASK_BLACK, /*< skip, pdb-skip >*/
GIMP_ADD_ALPHA_MASK = GIMP_ADD_MASK_ALPHA, /*< skip, pdb-skip >*/
GIMP_ADD_ALPHA_TRANSFER_MASK = GIMP_ADD_MASK_ALPHA_TRANSFER, /*< skip, pdb-skip >*/
GIMP_ADD_SELECTION_MASK = GIMP_ADD_MASK_SELECTION, /*< skip, pdb-skip >*/
GIMP_ADD_COPY_MASK = GIMP_ADD_MASK_COPY, /*< skip, pdb-skip >*/
GIMP_ADD_CHANNEL_MASK = GIMP_ADD_MASK_CHANNEL /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_ADD_MASK_CHANNEL /*< desc="C_hannel" >*/
} GimpAddMaskType;
@ -86,10 +68,6 @@ typedef enum
* @GIMP_BLEND_FG_BG_HSV: FG to BG (HSV)
* @GIMP_BLEND_FG_TRANSPARENT: FG to transparent
* @GIMP_BLEND_CUSTOM: Custom gradient
* @GIMP_FG_BG_RGB_MODE: Deprecated alias for @GIMP_BLEND_FG_BG_RGB
* @GIMP_FG_BG_HSV_MODE: Deprecated alias for @GIMP_BLEND_FG_BG_HSV
* @GIMP_FG_TRANSPARENT_MODE: Deprecated alias for @GIMP_BLEND_FG_TRANSPARENT
* @GIMP_CUSTOM_MODE: Deprecated alias for @GIMP_BLEND_CUSTOM
*
* Types of gradients.
**/
@ -102,14 +80,7 @@ typedef enum
GIMP_BLEND_FG_BG_RGB, /*< desc="FG to BG (RGB)" >*/
GIMP_BLEND_FG_BG_HSV, /*< desc="FG to BG (HSV)" >*/
GIMP_BLEND_FG_TRANSPARENT, /*< desc="FG to transparent" >*/
GIMP_BLEND_CUSTOM, /*< desc="Custom gradient" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_FG_BG_RGB_MODE = GIMP_BLEND_FG_BG_RGB, /*< skip, pdb-skip >*/
GIMP_FG_BG_HSV_MODE = GIMP_BLEND_FG_BG_HSV, /*< skip, pdb-skip >*/
GIMP_FG_TRANSPARENT_MODE = GIMP_BLEND_FG_TRANSPARENT, /*< skip, pdb-skip >*/
GIMP_CUSTOM_MODE = GIMP_BLEND_CUSTOM /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_BLEND_CUSTOM /*< desc="Custom gradient" >*/
} GimpBlendMode;
@ -138,9 +109,6 @@ typedef enum
* @GIMP_BUCKET_FILL_FG: FG color fill
* @GIMP_BUCKET_FILL_BG: BG color fill
* @GIMP_BUCKET_FILL_PATTERN: Pattern fill
* @GIMP_FG_BUCKET_FILL: Deprecated alias for @GIMP_BUCKET_FILL_FG
* @GIMP_BG_BUCKET_FILL: Deprecated alias for @GIMP_BUCKET_FILL_BG
* @GIMP_PATTERN_BUCKET_FILL: Deprecated alias for @GIMP_BUCKET_FILL_PATTERN
*
* Bucket fill modes.
*/
@ -152,13 +120,7 @@ typedef enum
{
GIMP_BUCKET_FILL_FG, /*< desc="FG color fill" >*/
GIMP_BUCKET_FILL_BG, /*< desc="BG color fill" >*/
GIMP_BUCKET_FILL_PATTERN, /*< desc="Pattern fill" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_FG_BUCKET_FILL = GIMP_BUCKET_FILL_FG, /*< skip, pdb-skip >*/
GIMP_BG_BUCKET_FILL = GIMP_BUCKET_FILL_BG, /*< skip, pdb-skip >*/
GIMP_PATTERN_BUCKET_FILL = GIMP_BUCKET_FILL_PATTERN /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_BUCKET_FILL_PATTERN /*< desc="Pattern fill" >*/
} GimpBucketFillMode;
@ -212,12 +174,6 @@ typedef enum
* @GIMP_CHANNEL_GRAY: Gray
* @GIMP_CHANNEL_INDEXED: Indexed
* @GIMP_CHANNEL_ALPHA: Alpha
* @GIMP_RED_CHANNEL: Deprecated alias for @GIMP_CHANNEL_RED
* @GIMP_GREEN_CHANNEL: Deprecated alias for @GIMP_CHANNEL_GREEN
* @GIMP_BLUE_CHANNEL: Deprecated alias for @GIMP_CHANNEL_BLUE
* @GIMP_GRAY_CHANNEL: Deprecated alias for @GIMP_CHANNEL_GRAY
* @GIMP_INDEXED_CHANNEL: Deprecated alias for @GIMP_CHANNEL_INDEXED
* @GIMP_ALPHA_CHANNEL: Deprecated alias for @GIMP_CHANNEL_ALPHA
*
* Channels (as in color components).
**/
@ -232,16 +188,7 @@ typedef enum
GIMP_CHANNEL_BLUE, /*< desc="Blue" >*/
GIMP_CHANNEL_GRAY, /*< desc="Gray" >*/
GIMP_CHANNEL_INDEXED, /*< desc="Indexed" >*/
GIMP_CHANNEL_ALPHA, /*< desc="Alpha" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_RED_CHANNEL = GIMP_CHANNEL_RED, /*< skip, pdb-skip >*/
GIMP_GREEN_CHANNEL = GIMP_CHANNEL_GREEN, /*< skip, pdb-skip >*/
GIMP_BLUE_CHANNEL = GIMP_CHANNEL_BLUE, /*< skip, pdb-skip >*/
GIMP_GRAY_CHANNEL = GIMP_CHANNEL_GRAY, /*< skip, pdb-skip >*/
GIMP_INDEXED_CHANNEL = GIMP_CHANNEL_INDEXED, /*< skip, pdb-skip >*/
GIMP_ALPHA_CHANNEL = GIMP_CHANNEL_ALPHA /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_CHANNEL_ALPHA /*< desc="Alpha" >*/
} GimpChannelType;
@ -295,8 +242,6 @@ typedef enum /*< pdb-skip >*/
* GimpCloneType:
* @GIMP_CLONE_IMAGE: Clone from an image/drawable source
* @GIMP_CLONE_PATTERN: Clone from a pattern source
* @GIMP_IMAGE_CLONE: Deprecated alias for @GIMP_CLONE_IMAGE
* @GIMP_PATTERN_CLONE: Deprecated alias for @GIMP_CLONE_PATTERN
*
* Clone sources.
**/
@ -307,12 +252,7 @@ GType gimp_clone_type_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_CLONE_IMAGE, /*< desc="Image" >*/
GIMP_CLONE_PATTERN, /*< desc="Pattern" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_IMAGE_CLONE = GIMP_CLONE_IMAGE, /*< skip, pdb-skip >*/
GIMP_PATTERN_CLONE = GIMP_CLONE_PATTERN /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_CLONE_PATTERN /*< desc="Pattern" >*/
} GimpCloneType;
@ -385,16 +325,6 @@ typedef enum
* @GIMP_CONVERT_PALETTE_WEB: Use web-optimized palette
* @GIMP_CONVERT_PALETTE_MONO: Use black and white (1-bit) palette
* @GIMP_CONVERT_PALETTE_CUSTOM: Use custom palette
* @GIMP_MAKE_PALETTE: Deprecated alias for
* @GIMP_CONVERT_PALETTE_GENERATE
* @GIMP_REUSE_PALETTE: Deprecated alias for
* @GIMP_CONVERT_PALETTE_REUSE
* @GIMP_WEB_PALETTE: Deprecated alias for
* @GIMP_CONVERT_PALETTE_WEB
* @GIMP_MONO_PALETTE: Deprecated alias for
@GIMP_CONVERT_PALETTE_MONO
* @GIMP_CUSTOM_PALETTE: Deprecated alias for
* @GIMP_CONVERT_PALETTE_CUSTOM
*
* Types of palettes for indexed conversion.
**/
@ -408,15 +338,7 @@ typedef enum
GIMP_CONVERT_PALETTE_REUSE, /*< skip >*/
GIMP_CONVERT_PALETTE_WEB, /*< desc="Use web-optimized palette" >*/
GIMP_CONVERT_PALETTE_MONO, /*< desc="Use black and white (1-bit) palette" >*/
GIMP_CONVERT_PALETTE_CUSTOM, /*< desc="Use custom palette" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_MAKE_PALETTE = GIMP_CONVERT_PALETTE_GENERATE, /*< skip, pdb-skip >*/
GIMP_REUSE_PALETTE = GIMP_CONVERT_PALETTE_REUSE, /*< skip, pdb-skip >*/
GIMP_WEB_PALETTE = GIMP_CONVERT_PALETTE_WEB, /*< skip, pdb-skip >*/
GIMP_MONO_PALETTE = GIMP_CONVERT_PALETTE_MONO, /*< skip, pdb-skip >*/
GIMP_CUSTOM_PALETTE = GIMP_CONVERT_PALETTE_CUSTOM /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_CONVERT_PALETTE_CUSTOM /*< desc="Use custom palette" >*/
} GimpConvertPaletteType;
@ -424,8 +346,6 @@ typedef enum
* GimpConvolveType:
* @GIMP_CONVOLVE_BLUR: Blur
* @GIMP_CONVOLVE_SHARPEN: Sharpen
* @GIMP_BLUR_CONVOLVE: Deprecated alias for @GIMP_CONVOLVE_BLUR
* @GIMP_SHARPEN_CONVOLVE: Deprecated alias for @GIMP_CONVOLVE_SHARPEN
*
* Types of convolutions.
**/
@ -436,12 +356,7 @@ GType gimp_convolve_type_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_CONVOLVE_BLUR, /*< desc="Blur" >*/
GIMP_CONVOLVE_SHARPEN, /*< desc="Sharpen" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_BLUR_CONVOLVE = GIMP_CONVOLVE_BLUR, /*< skip, pdb-skip >*/
GIMP_SHARPEN_CONVOLVE = GIMP_CONVOLVE_SHARPEN /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_CONVOLVE_SHARPEN /*< desc="Sharpen" >*/
} GimpConvolveType;
@ -452,7 +367,6 @@ typedef enum
* @GIMP_DESATURATE_AVERAGE: Average (HSI Intensity)
* @GIMP_DESATURATE_LUMINANCE: Luminance
* @GIMP_DESATURATE_VALUE: Value (HSV)
* @GIMP_DESATURATE_LUMINOSITY: Deprecated alias for @GIMP_DESATURATE_LUMA
*
* Grayscale conversion methods.
**/
@ -466,11 +380,7 @@ typedef enum
GIMP_DESATURATE_LUMA, /*< desc="Luma" >*/
GIMP_DESATURATE_AVERAGE, /*< desc="Average (HSI Intensity)" >*/
GIMP_DESATURATE_LUMINANCE, /*< desc="Luminance" >*/
GIMP_DESATURATE_VALUE, /*< desc="Value (HSV)" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_DESATURATE_LUMINOSITY = GIMP_DESATURATE_LUMA /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_DESATURATE_VALUE /*< desc="Value (HSV)" >*/
} GimpDesaturateMode;
@ -478,8 +388,6 @@ typedef enum
* GimpDodgeBurnType:
* @GIMP_DODGE_BURN_TYPE_DODGE: Dodge
* @GIMP_DODGE_BURN_TYPE_BURN: Burn
* @GIMP_DODGE: Deprecated alias for @GIMP_DODGE_BURN_TYPE_DODGE
* @GIMP_BURN: Deprecated alias for @GIMP_DODGE_BURN_TYPE_BURN
*
* Methods for the dodge/burn operation.
**/
@ -490,12 +398,7 @@ GType gimp_dodge_burn_type_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_DODGE_BURN_TYPE_DODGE, /*< desc="Dodge" >*/
GIMP_DODGE_BURN_TYPE_BURN, /*< desc="Burn" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_DODGE = GIMP_DODGE_BURN_TYPE_DODGE, /*< skip, pdb-skip >*/
GIMP_BURN = GIMP_DODGE_BURN_TYPE_BURN /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_DODGE_BURN_TYPE_BURN /*< desc="Burn" >*/
} GimpDodgeBurnType;
@ -506,11 +409,6 @@ typedef enum
* @GIMP_FILL_WHITE: White
* @GIMP_FILL_TRANSPARENT: Transparency
* @GIMP_FILL_PATTERN: Pattern
* @GIMP_FOREGROUND_FILL: Deprecated alias for @GIMP_FILL_FOREGROUND
* @GIMP_BACKGROUND_FILL: Deprecated alias for @GIMP_FILL_BACKGROUND
* @GIMP_WHITE_FILL: Deprecated alias for @GIMP_FILL_WHITE
* @GIMP_TRANSPARENT_FILL: Deprecated alias for @GIMP_FILL_TRANSPARENT
* @GIMP_PATTERN_FILL: Deprecated alias for @GIMP_FILL_PATTERN
*
* Types of filling.
**/
@ -524,15 +422,7 @@ typedef enum
GIMP_FILL_BACKGROUND, /*< desc="Background color" >*/
GIMP_FILL_WHITE, /*< desc="White" >*/
GIMP_FILL_TRANSPARENT, /*< desc="Transparency" >*/
GIMP_FILL_PATTERN, /*< desc="Pattern" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_FOREGROUND_FILL = GIMP_FILL_FOREGROUND, /*< skip, pdb-skip >*/
GIMP_BACKGROUND_FILL = GIMP_FILL_BACKGROUND, /*< skip, pdb-skip >*/
GIMP_WHITE_FILL = GIMP_FILL_WHITE, /*< skip, pdb-skip >*/
GIMP_TRANSPARENT_FILL = GIMP_FILL_TRANSPARENT, /*< skip, pdb-skip >*/
GIMP_PATTERN_FILL = GIMP_FILL_PATTERN /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_FILL_PATTERN /*< desc="Pattern" >*/
} GimpFillType;
@ -689,13 +579,6 @@ typedef enum
* @GIMP_HUE_RANGE_CYAN: Cyan hues
* @GIMP_HUE_RANGE_BLUE: Blue hues
* @GIMP_HUE_RANGE_MAGENTA: Magenta hues
* @GIMP_ALL_HUES: Deprecated alias for @GIMP_HUE_RANGE_ALL
* @GIMP_RED_HUES: Deprecated alias for @GIMP_HUE_RANGE_RED
* @GIMP_YELLOW_HUES: Deprecated alias for @GIMP_HUE_RANGE_YELLOW
* @GIMP_GREEN_HUES: Deprecated alias for @GIMP_HUE_RANGE_GREEN
* @GIMP_CYAN_HUES: Deprecated alias for @GIMP_HUE_RANGE_CYAN
* @GIMP_BLUE_HUES: Deprecated alias for @GIMP_HUE_RANGE_BLUE
* @GIMP_MAGENTA_HUES: Deprecated alias for @GIMP_HUE_RANGE_MAGENTA
*
* Hue ranges.
**/
@ -711,17 +594,7 @@ typedef enum
GIMP_HUE_RANGE_GREEN,
GIMP_HUE_RANGE_CYAN,
GIMP_HUE_RANGE_BLUE,
GIMP_HUE_RANGE_MAGENTA,
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_ALL_HUES = GIMP_HUE_RANGE_ALL, /*< skip, pdb-skip >*/
GIMP_RED_HUES = GIMP_HUE_RANGE_RED, /*< skip, pdb-skip >*/
GIMP_YELLOW_HUES = GIMP_HUE_RANGE_YELLOW, /*< skip, pdb-skip >*/
GIMP_GREEN_HUES = GIMP_HUE_RANGE_GREEN, /*< skip, pdb-skip >*/
GIMP_CYAN_HUES = GIMP_HUE_RANGE_CYAN, /*< skip, pdb-skip >*/
GIMP_BLUE_HUES = GIMP_HUE_RANGE_BLUE, /*< skip, pdb-skip >*/
GIMP_MAGENTA_HUES = GIMP_HUE_RANGE_MAGENTA /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_HUE_RANGE_MAGENTA
} GimpHueRange;
@ -730,9 +603,6 @@ typedef enum
* @GIMP_ICON_TYPE_ICON_NAME: Icon name
* @GIMP_ICON_TYPE_INLINE_PIXBUF: Inline pixbuf
* @GIMP_ICON_TYPE_IMAGE_FILE: Image file
* @GIMP_ICON_TYPE_STOCK_ID: Deprecated alias for
* @GIMP_ICON_TYPE_ICON_NAME, old stock IDs
* are interpreted as icon names
*
* Icon types for plug-ins to register.
**/
@ -744,11 +614,7 @@ typedef enum
{
GIMP_ICON_TYPE_ICON_NAME, /*< desc="Icon name" >*/
GIMP_ICON_TYPE_INLINE_PIXBUF, /*< desc="Inline pixbuf" >*/
GIMP_ICON_TYPE_IMAGE_FILE, /*< desc="Image file" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_ICON_TYPE_STOCK_ID = GIMP_ICON_TYPE_ICON_NAME /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_ICON_TYPE_IMAGE_FILE /*< desc="Image file" >*/
} GimpIconType;
@ -820,12 +686,11 @@ typedef enum
/**
* GimpInterpolationType:
* @GIMP_INTERPOLATION_NONE: None
* @GIMP_INTERPOLATION_LINEAR: Linear
* @GIMP_INTERPOLATION_CUBIC: Cubic
* @GIMP_INTERPOLATION_NOHALO: NoHalo
* @GIMP_INTERPOLATION_LOHALO: LoHalo
* @GIMP_INTERPOLATION_LANCZOS: Deprecated alias for @GIMP_INTERPOLATION_NOHALO
* @GIMP_INTERPOLATION_NONE: None
* @GIMP_INTERPOLATION_LINEAR: Linear
* @GIMP_INTERPOLATION_CUBIC: Cubic
* @GIMP_INTERPOLATION_NOHALO: NoHalo
* @GIMP_INTERPOLATION_LOHALO: LoHalo
*
* Interpolation types.
**/
@ -839,11 +704,7 @@ typedef enum
GIMP_INTERPOLATION_LINEAR, /*< desc="Linear" >*/
GIMP_INTERPOLATION_CUBIC, /*< desc="Cubic" >*/
GIMP_INTERPOLATION_NOHALO, /*< desc="NoHalo" >*/
GIMP_INTERPOLATION_LOHALO, /*< desc="LoHalo" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_INTERPOLATION_LANCZOS = GIMP_INTERPOLATION_NOHALO /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_INTERPOLATION_LOHALO /*< desc="LoHalo" >*/
} GimpInterpolationType;
@ -1008,9 +869,6 @@ typedef enum
* @GIMP_PDB_PARASITE: Parasite
* @GIMP_PDB_STATUS: Procedure return status
* @GIMP_PDB_END: Marker for last enum value
* @GIMP_PDB_PATH: Deprecated alias for @GIMP_PDB_VECTORS
* @GIMP_PDB_BOUNDARY: Deprecated alias for @GIMP_PDB_COLORARRAY
* @GIMP_PDB_REGION: Deprecated alias for @GIMP_PDB_ITEM
*
* Parameter types of the PDB.
**/
@ -1042,13 +900,7 @@ typedef enum
GIMP_PDB_VECTORS,
GIMP_PDB_PARASITE,
GIMP_PDB_STATUS,
GIMP_PDB_END,
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_PDB_PATH = GIMP_PDB_VECTORS, /*< skip >*/
GIMP_PDB_BOUNDARY = GIMP_PDB_COLORARRAY, /*< skip >*/
GIMP_PDB_REGION = GIMP_PDB_ITEM /*< skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_PDB_END
} GimpPDBArgType;
@ -1403,9 +1255,6 @@ typedef enum
* @GIMP_TRANSFER_SHADOWS: Shadows
* @GIMP_TRANSFER_MIDTONES: Midtones
* @GIMP_TRANSFER_HIGHLIGHTS: Highlights
* @GIMP_SHADOWS: Deprecated alias for @GIMP_TRANSFER_SHADOWS
* @GIMP_MIDTONES: Deprecated alias for @GIMP_TRANSFER_MIDTONES
* @GIMP_HIGHLIGHTS: Deprecated alias for @GIMP_TRANSFER_HIGHLIGHTS
*
* For choosing which brightness ranges to transform.
**/
@ -1417,13 +1266,7 @@ typedef enum
{
GIMP_TRANSFER_SHADOWS, /*< desc="Shadows" >*/
GIMP_TRANSFER_MIDTONES, /*< desc="Midtones" >*/
GIMP_TRANSFER_HIGHLIGHTS, /*< desc="Highlights" >*/
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_SHADOWS = GIMP_TRANSFER_SHADOWS, /*< skip, pdb-skip >*/
GIMP_MIDTONES = GIMP_TRANSFER_MIDTONES, /*< skip, pdb-skip >*/
GIMP_HIGHLIGHTS = GIMP_TRANSFER_HIGHLIGHTS /*< skip, pdb-skip >*/
#endif /* GIMP_DISABLE_DEPRECATED */
GIMP_TRANSFER_HIGHLIGHTS /*< desc="Highlights" >*/
} GimpTransferMode;
@ -1494,38 +1337,6 @@ typedef enum /*< skip >*/
} GimpUnit;
#ifndef GIMP_DISABLE_DEPRECATED
/**
* GimpUserDirectory:
* @GIMP_USER_DIRECTORY_DESKTOP: Deprecated
* @GIMP_USER_DIRECTORY_DOCUMENTS: Deprecated
* @GIMP_USER_DIRECTORY_DOWNLOAD: Deprecated
* @GIMP_USER_DIRECTORY_MUSIC: Deprecated
* @GIMP_USER_DIRECTORY_PICTURES: Deprecated
* @GIMP_USER_DIRECTORY_PUBLIC_SHARE: Deprecated
* @GIMP_USER_DIRECTORY_TEMPLATES: Deprecated
* @GIMP_USER_DIRECTORY_VIDEOS: Deprecated
*
* Deprecated enum, don't use.
**/
#define GIMP_TYPE_USER_DIRECTORY (gimp_user_directory_get_type ())
GType gimp_user_directory_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_USER_DIRECTORY_DESKTOP,
GIMP_USER_DIRECTORY_DOCUMENTS,
GIMP_USER_DIRECTORY_DOWNLOAD,
GIMP_USER_DIRECTORY_MUSIC,
GIMP_USER_DIRECTORY_PICTURES,
GIMP_USER_DIRECTORY_PUBLIC_SHARE,
GIMP_USER_DIRECTORY_TEMPLATES,
GIMP_USER_DIRECTORY_VIDEOS
} GimpUserDirectory;
#endif /* !GIMP_DISABLE_DEPRECATED */
/**
* GimpVectorsStrokeType:
* @GIMP_VECTORS_STROKE_TYPE_BEZIER: A bezier stroke

570
libgimpbase/gimpcompatenums.c
View File

@ -7,575 +7,5 @@
#include "gimpcompatenums.h"
#include "libgimp/libgimp-intl.h"
/* enumerations from "gimpcompatenums.h" */
GType
gimp_add_mask_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ADD_WHITE_MASK, "GIMP_ADD_WHITE_MASK", "white-mask" },
{ GIMP_ADD_BLACK_MASK, "GIMP_ADD_BLACK_MASK", "black-mask" },
{ GIMP_ADD_ALPHA_MASK, "GIMP_ADD_ALPHA_MASK", "alpha-mask" },
{ GIMP_ADD_ALPHA_TRANSFER_MASK, "GIMP_ADD_ALPHA_TRANSFER_MASK", "alpha-transfer-mask" },
{ GIMP_ADD_SELECTION_MASK, "GIMP_ADD_SELECTION_MASK", "selection-mask" },
{ GIMP_ADD_COPY_MASK, "GIMP_ADD_COPY_MASK", "copy-mask" },
{ GIMP_ADD_CHANNEL_MASK, "GIMP_ADD_CHANNEL_MASK", "channel-mask" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ADD_WHITE_MASK, "GIMP_ADD_WHITE_MASK", NULL },
{ GIMP_ADD_BLACK_MASK, "GIMP_ADD_BLACK_MASK", NULL },
{ GIMP_ADD_ALPHA_MASK, "GIMP_ADD_ALPHA_MASK", NULL },
{ GIMP_ADD_ALPHA_TRANSFER_MASK, "GIMP_ADD_ALPHA_TRANSFER_MASK", NULL },
{ GIMP_ADD_SELECTION_MASK, "GIMP_ADD_SELECTION_MASK", NULL },
{ GIMP_ADD_COPY_MASK, "GIMP_ADD_COPY_MASK", NULL },
{ GIMP_ADD_CHANNEL_MASK, "GIMP_ADD_CHANNEL_MASK", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpAddMaskTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "add-mask-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_blend_mode_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_FG_BG_RGB_MODE, "GIMP_FG_BG_RGB_MODE", "fg-bg-rgb-mode" },
{ GIMP_FG_BG_HSV_MODE, "GIMP_FG_BG_HSV_MODE", "fg-bg-hsv-mode" },
{ GIMP_FG_TRANSPARENT_MODE, "GIMP_FG_TRANSPARENT_MODE", "fg-transparent-mode" },
{ GIMP_CUSTOM_MODE, "GIMP_CUSTOM_MODE", "custom-mode" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_FG_BG_RGB_MODE, "GIMP_FG_BG_RGB_MODE", NULL },
{ GIMP_FG_BG_HSV_MODE, "GIMP_FG_BG_HSV_MODE", NULL },
{ GIMP_FG_TRANSPARENT_MODE, "GIMP_FG_TRANSPARENT_MODE", NULL },
{ GIMP_CUSTOM_MODE, "GIMP_CUSTOM_MODE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpBlendModeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "blend-mode-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_bucket_fill_mode_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_FG_BUCKET_FILL, "GIMP_FG_BUCKET_FILL", "fg-bucket-fill" },
{ GIMP_BG_BUCKET_FILL, "GIMP_BG_BUCKET_FILL", "bg-bucket-fill" },
{ GIMP_PATTERN_BUCKET_FILL, "GIMP_PATTERN_BUCKET_FILL", "pattern-bucket-fill" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_FG_BUCKET_FILL, "GIMP_FG_BUCKET_FILL", NULL },
{ GIMP_BG_BUCKET_FILL, "GIMP_BG_BUCKET_FILL", NULL },
{ GIMP_PATTERN_BUCKET_FILL, "GIMP_PATTERN_BUCKET_FILL", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpBucketFillModeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "bucket-fill-mode-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_channel_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_RED_CHANNEL, "GIMP_RED_CHANNEL", "red-channel" },
{ GIMP_GREEN_CHANNEL, "GIMP_GREEN_CHANNEL", "green-channel" },
{ GIMP_BLUE_CHANNEL, "GIMP_BLUE_CHANNEL", "blue-channel" },
{ GIMP_GRAY_CHANNEL, "GIMP_GRAY_CHANNEL", "gray-channel" },
{ GIMP_INDEXED_CHANNEL, "GIMP_INDEXED_CHANNEL", "indexed-channel" },
{ GIMP_ALPHA_CHANNEL, "GIMP_ALPHA_CHANNEL", "alpha-channel" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_RED_CHANNEL, "GIMP_RED_CHANNEL", NULL },
{ GIMP_GREEN_CHANNEL, "GIMP_GREEN_CHANNEL", NULL },
{ GIMP_BLUE_CHANNEL, "GIMP_BLUE_CHANNEL", NULL },
{ GIMP_GRAY_CHANNEL, "GIMP_GRAY_CHANNEL", NULL },
{ GIMP_INDEXED_CHANNEL, "GIMP_INDEXED_CHANNEL", NULL },
{ GIMP_ALPHA_CHANNEL, "GIMP_ALPHA_CHANNEL", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpChannelTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "channel-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_clone_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_IMAGE_CLONE, "GIMP_IMAGE_CLONE", "image-clone" },
{ GIMP_PATTERN_CLONE, "GIMP_PATTERN_CLONE", "pattern-clone" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_IMAGE_CLONE, "GIMP_IMAGE_CLONE", NULL },
{ GIMP_PATTERN_CLONE, "GIMP_PATTERN_CLONE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpCloneTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "clone-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_convert_dither_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_NO_DITHER, "GIMP_NO_DITHER", "no-dither" },
{ GIMP_FS_DITHER, "GIMP_FS_DITHER", "fs-dither" },
{ GIMP_FSLOWBLEED_DITHER, "GIMP_FSLOWBLEED_DITHER", "fslowbleed-dither" },
{ GIMP_FIXED_DITHER, "GIMP_FIXED_DITHER", "fixed-dither" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_NO_DITHER, "GIMP_NO_DITHER", NULL },
{ GIMP_FS_DITHER, "GIMP_FS_DITHER", NULL },
{ GIMP_FSLOWBLEED_DITHER, "GIMP_FSLOWBLEED_DITHER", NULL },
{ GIMP_FIXED_DITHER, "GIMP_FIXED_DITHER", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpConvertDitherTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "convert-dither-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_convert_palette_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_MAKE_PALETTE, "GIMP_MAKE_PALETTE", "make-palette" },
{ GIMP_REUSE_PALETTE, "GIMP_REUSE_PALETTE", "reuse-palette" },
{ GIMP_WEB_PALETTE, "GIMP_WEB_PALETTE", "web-palette" },
{ GIMP_MONO_PALETTE, "GIMP_MONO_PALETTE", "mono-palette" },
{ GIMP_CUSTOM_PALETTE, "GIMP_CUSTOM_PALETTE", "custom-palette" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_MAKE_PALETTE, "GIMP_MAKE_PALETTE", NULL },
{ GIMP_REUSE_PALETTE, "GIMP_REUSE_PALETTE", NULL },
{ GIMP_WEB_PALETTE, "GIMP_WEB_PALETTE", NULL },
{ GIMP_MONO_PALETTE, "GIMP_MONO_PALETTE", NULL },
{ GIMP_CUSTOM_PALETTE, "GIMP_CUSTOM_PALETTE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpConvertPaletteTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "convert-palette-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_convolve_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_BLUR_CONVOLVE, "GIMP_BLUR_CONVOLVE", "blur-convolve" },
{ GIMP_SHARPEN_CONVOLVE, "GIMP_SHARPEN_CONVOLVE", "sharpen-convolve" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_BLUR_CONVOLVE, "GIMP_BLUR_CONVOLVE", NULL },
{ GIMP_SHARPEN_CONVOLVE, "GIMP_SHARPEN_CONVOLVE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpConvolveTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "convolve-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_desaturate_mode_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_DESATURATE_LUMINOSITY, "GIMP_DESATURATE_LUMINOSITY", "luminosity" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_DESATURATE_LUMINOSITY, "GIMP_DESATURATE_LUMINOSITY", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpDesaturateModeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "desaturate-mode-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_dodge_burn_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_DODGE, "GIMP_DODGE", "dodge" },
{ GIMP_BURN, "GIMP_BURN", "burn" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_DODGE, "GIMP_DODGE", NULL },
{ GIMP_BURN, "GIMP_BURN", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpDodgeBurnTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "dodge-burn-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_fill_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_FOREGROUND_FILL, "GIMP_FOREGROUND_FILL", "foreground-fill" },
{ GIMP_BACKGROUND_FILL, "GIMP_BACKGROUND_FILL", "background-fill" },
{ GIMP_WHITE_FILL, "GIMP_WHITE_FILL", "white-fill" },
{ GIMP_TRANSPARENT_FILL, "GIMP_TRANSPARENT_FILL", "transparent-fill" },
{ GIMP_PATTERN_FILL, "GIMP_PATTERN_FILL", "pattern-fill" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_FOREGROUND_FILL, "GIMP_FOREGROUND_FILL", NULL },
{ GIMP_BACKGROUND_FILL, "GIMP_BACKGROUND_FILL", NULL },
{ GIMP_WHITE_FILL, "GIMP_WHITE_FILL", NULL },
{ GIMP_TRANSPARENT_FILL, "GIMP_TRANSPARENT_FILL", NULL },
{ GIMP_PATTERN_FILL, "GIMP_PATTERN_FILL", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpFillTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "fill-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_hue_range_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ALL_HUES, "GIMP_ALL_HUES", "all-hues" },
{ GIMP_RED_HUES, "GIMP_RED_HUES", "red-hues" },
{ GIMP_YELLOW_HUES, "GIMP_YELLOW_HUES", "yellow-hues" },
{ GIMP_GREEN_HUES, "GIMP_GREEN_HUES", "green-hues" },
{ GIMP_CYAN_HUES, "GIMP_CYAN_HUES", "cyan-hues" },
{ GIMP_BLUE_HUES, "GIMP_BLUE_HUES", "blue-hues" },
{ GIMP_MAGENTA_HUES, "GIMP_MAGENTA_HUES", "magenta-hues" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ALL_HUES, "GIMP_ALL_HUES", NULL },
{ GIMP_RED_HUES, "GIMP_RED_HUES", NULL },
{ GIMP_YELLOW_HUES, "GIMP_YELLOW_HUES", NULL },
{ GIMP_GREEN_HUES, "GIMP_GREEN_HUES", NULL },
{ GIMP_CYAN_HUES, "GIMP_CYAN_HUES", NULL },
{ GIMP_BLUE_HUES, "GIMP_BLUE_HUES", NULL },
{ GIMP_MAGENTA_HUES, "GIMP_MAGENTA_HUES", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpHueRangeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "hue-range-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_icon_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ICON_TYPE_STOCK_ID, "GIMP_ICON_TYPE_STOCK_ID", "id" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ICON_TYPE_STOCK_ID, "GIMP_ICON_TYPE_STOCK_ID", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpIconTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "icon-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_interpolation_type_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_INTERPOLATION_LANCZOS, "GIMP_INTERPOLATION_LANCZOS", "lanczos" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_INTERPOLATION_LANCZOS, "GIMP_INTERPOLATION_LANCZOS", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpInterpolationTypeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "interpolation-type-compat");
gimp_enum_set_value_descriptions (type, descs);
}
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_transfer_mode_compat_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_SHADOWS, "GIMP_SHADOWS", "shadows" },
{ GIMP_MIDTONES, "GIMP_MIDTONES", "midtones" },
{ GIMP_HIGHLIGHTS, "GIMP_HIGHLIGHTS", "highlights" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_SHADOWS, "GIMP_SHADOWS", NULL },
{ GIMP_MIDTONES, "GIMP_MIDTONES", NULL },
{ GIMP_HIGHLIGHTS, "GIMP_HIGHLIGHTS", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpTransferModeCompat", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "transfer-mode-compat");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
/* Generated data ends here */

212
libgimpbase/gimpcompatenums.h
View File

@ -27,11 +27,16 @@ G_BEGIN_DECLS
*/
#if 0
/* Leave one enum here for documentation purposes, remove it as
* soon as we need a real compat enum again, also don't have
* that "skip" on the compat enum...
*/
#define GIMP_TYPE_ADD_MASK_TYPE_COMPAT (gimp_add_mask_type_compat_get_type ())
GType gimp_add_mask_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
typedef enum /*< skip >*/
{
GIMP_ADD_WHITE_MASK = GIMP_ADD_MASK_WHITE,
GIMP_ADD_BLACK_MASK = GIMP_ADD_MASK_BLACK,
@ -41,210 +46,7 @@ typedef enum
GIMP_ADD_COPY_MASK = GIMP_ADD_MASK_COPY,
GIMP_ADD_CHANNEL_MASK = GIMP_ADD_MASK_CHANNEL
} GimpAddMaskTypeCompat;
#define GIMP_TYPE_BLEND_MODE_COMPAT (gimp_blend_mode_compat_get_type ())
GType gimp_blend_mode_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_FG_BG_RGB_MODE = GIMP_BLEND_FG_BG_RGB,
GIMP_FG_BG_HSV_MODE = GIMP_BLEND_FG_BG_HSV,
GIMP_FG_TRANSPARENT_MODE = GIMP_BLEND_FG_TRANSPARENT,
GIMP_CUSTOM_MODE = GIMP_BLEND_CUSTOM
} GimpBlendModeCompat;
#define GIMP_TYPE_BUCKET_FILL_MODE_COMPAT (gimp_bucket_fill_mode_compat_get_type ())
GType gimp_bucket_fill_mode_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_FG_BUCKET_FILL = GIMP_BUCKET_FILL_FG,
GIMP_BG_BUCKET_FILL = GIMP_BUCKET_FILL_BG,
GIMP_PATTERN_BUCKET_FILL = GIMP_BUCKET_FILL_PATTERN
} GimpBucketFillModeCompat;
#define GIMP_TYPE_CHANNEL_TYPE_COMPAT (gimp_channel_type_compat_get_type ())
GType gimp_channel_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_RED_CHANNEL = GIMP_CHANNEL_RED,
GIMP_GREEN_CHANNEL = GIMP_CHANNEL_GREEN,
GIMP_BLUE_CHANNEL = GIMP_CHANNEL_BLUE,
GIMP_GRAY_CHANNEL = GIMP_CHANNEL_GRAY,
GIMP_INDEXED_CHANNEL = GIMP_CHANNEL_INDEXED,
GIMP_ALPHA_CHANNEL = GIMP_CHANNEL_ALPHA
} GimpChannelTypeCompat;
#define GIMP_TYPE_CLONE_TYPE_COMPAT (gimp_clone_type_compat_get_type ())
GType gimp_clone_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_IMAGE_CLONE = GIMP_CLONE_IMAGE,
GIMP_PATTERN_CLONE = GIMP_CLONE_PATTERN
} GimpCloneTypeCompat;
#define GIMP_TYPE_CONVERT_DITHER_TYPE_COMPAT (gimp_convert_dither_type_compat_get_type ())
GType gimp_convert_dither_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_NO_DITHER,
GIMP_FS_DITHER,
GIMP_FSLOWBLEED_DITHER,
GIMP_FIXED_DITHER
} GimpConvertDitherTypeCompat;
#define GIMP_TYPE_CONVERT_PALETTE_TYPE_COMPAT (gimp_convert_palette_type_compat_get_type ())
GType gimp_convert_palette_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_MAKE_PALETTE,
GIMP_REUSE_PALETTE,
GIMP_WEB_PALETTE,
GIMP_MONO_PALETTE,
GIMP_CUSTOM_PALETTE
} GimpConvertPaletteTypeCompat;
#define GIMP_TYPE_CONVOLVE_TYPE_COMPAT (gimp_convolve_type_compat_get_type ())
GType gimp_convolve_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_BLUR_CONVOLVE = GIMP_CONVOLVE_BLUR,
GIMP_SHARPEN_CONVOLVE = GIMP_CONVOLVE_SHARPEN
} GimpConvolveTypeCompat;
#define GIMP_TYPE_DESATURATE_MODE_COMPAT (gimp_desaturate_mode_compat_get_type ())
GType gimp_desaturate_mode_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_DESATURATE_LUMINOSITY = GIMP_DESATURATE_LUMA
} GimpDesaturateModeCompat;
#define GIMP_TYPE_DODGE_BURN_TYPE_COMPAT (gimp_dodge_burn_type_compat_get_type ())
GType gimp_dodge_burn_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_DODGE = GIMP_DODGE_BURN_TYPE_DODGE,
GIMP_BURN = GIMP_DODGE_BURN_TYPE_BURN
} GimpDodgeBurnTypeCompat;
#define GIMP_TYPE_FILL_TYPE_COMPAT (gimp_fill_type_compat_get_type ())
GType gimp_fill_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_FOREGROUND_FILL = GIMP_FILL_FOREGROUND,
GIMP_BACKGROUND_FILL = GIMP_FILL_BACKGROUND,
GIMP_WHITE_FILL = GIMP_FILL_WHITE,
GIMP_TRANSPARENT_FILL = GIMP_FILL_TRANSPARENT,
GIMP_PATTERN_FILL = GIMP_FILL_PATTERN
} GimpFillTypeCompat;
#define GIMP_TYPE_HUE_RANGE_COMPAT (gimp_hue_range_compat_get_type ())
GType gimp_hue_range_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_ALL_HUES = GIMP_HUE_RANGE_ALL,
GIMP_RED_HUES = GIMP_HUE_RANGE_RED,
GIMP_YELLOW_HUES = GIMP_HUE_RANGE_YELLOW,
GIMP_GREEN_HUES = GIMP_HUE_RANGE_GREEN,
GIMP_CYAN_HUES = GIMP_HUE_RANGE_CYAN,
GIMP_BLUE_HUES = GIMP_HUE_RANGE_BLUE,
GIMP_MAGENTA_HUES = GIMP_HUE_RANGE_MAGENTA
} GimpHueRangeCompat;
#define GIMP_TYPE_ICON_TYPE_COMPAT (gimp_icon_type_compat_get_type ())
GType gimp_icon_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_ICON_TYPE_STOCK_ID = GIMP_ICON_TYPE_ICON_NAME
} GimpIconTypeCompat;
#define GIMP_TYPE_INTERPOLATION_TYPE_COMPAT (gimp_interpolation_type_compat_get_type ())
GType gimp_interpolation_type_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_INTERPOLATION_LANCZOS = GIMP_INTERPOLATION_NOHALO
} GimpInterpolationTypeCompat;
#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
{
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;
#define GIMP_TYPE_TRANSFER_MODE_COMPAT (gimp_transfer_mode_compat_get_type ())
GType gimp_transfer_mode_compat_get_type (void) G_GNUC_CONST;
typedef enum
{
GIMP_SHADOWS = GIMP_TRANSFER_SHADOWS,
GIMP_MIDTONES = GIMP_TRANSFER_MIDTONES,
GIMP_HIGHLIGHTS = GIMP_TRANSFER_HIGHLIGHTS
} GimpTransferModeCompat;
#endif
G_END_DECLS

17
libgimpbase/gimpenv.c
View File

@ -781,23 +781,6 @@ gimp_plug_in_directory_file (const gchar *first_element,
return file;
}
/**
* gimp_user_directory:
* @type: the type of user directory to retrieve
*
* This procedure is deprecated! Use g_get_user_special_dir() instead.
*
* Returns: The path to the specified user directory, or %NULL if the
* logical ID was not found.
*
* Since: 2.4
**/
const gchar *
gimp_user_directory (GimpUserDirectory type)
{
return g_get_user_special_dir ((GUserDirectory) type);
}
/**
* gimp_personal_rc_file:
* @basename: The basename of a rc_file.

5
libgimpbase/gimpenv.h
View File

@ -65,11 +65,6 @@ GFile * gimp_sysconf_directory_file (const gchar *first_element,
GFile * gimp_plug_in_directory_file (const gchar *first_element,
...) G_GNUC_MALLOC;
#ifndef GIMP_DISABLE_DEPRECATED
GIMP_DEPRECATED_FOR(g_get_user_special_dir)
const gchar * gimp_user_directory (GimpUserDirectory type) G_GNUC_CONST;
#endif /* !GIMP_DISABLE_DEPRECATED */
const gchar * gimp_gtkrc (void) G_GNUC_CONST;
gchar * gimp_personal_rc_file (const gchar *basename) G_GNUC_MALLOC;

15
libgimpbase/gimpmemsize.c
View File

@ -159,21 +159,6 @@ gimp_memsize_deserialize (const gchar *string,
}
/**
* gimp_memsize_to_string:
* @memsize: A memory size in bytes.
*
* This function is deprecated! Use g_format_size() instead.
*
* Return value: A newly allocated human-readable, translated string.
**/
gchar *
gimp_memsize_to_string (guint64 memsize)
{
return g_format_size (memsize);
}
static void
memsize_to_string (const GValue *src_value,
GValue *dest_value)

3
libgimpbase/gimpmemsize.h
View File

@ -41,9 +41,6 @@ gchar * gimp_memsize_serialize (guint64 memsize) G_GNUC_MALLOC;
gboolean gimp_memsize_deserialize (const gchar *string,
guint64 *memsize);
GIMP_DEPRECATED_FOR(g_format_size)
gchar * gimp_memsize_to_string (guint64 memsize) G_GNUC_MALLOC;
/*
* GIMP_TYPE_PARAM_MEMSIZE

12
pdb/enumcode.pl
View File

@ -170,8 +170,10 @@ print ENUMFILE <<CODE;
static gboolean enums_initialized = FALSE;
#if 0
/* keep around as documentation how to do compat enums */
GType gimp_convert_dither_type_compat_get_type (void);
GType gimp_layer_mode_effects_get_type (void);
#endif
/**
* gimp_enums_init:
@ -188,7 +190,9 @@ void
gimp_enums_init (void)
{
const GimpGetTypeFunc *funcs = get_type_funcs;
#if 0
GQuark quark;
#endif
gint i;
if (enums_initialized)
@ -201,13 +205,15 @@ gimp_enums_init (void)
g_type_class_ref (type);
}
#if 0
/* keep around as documentation how to do compat enums */
/* 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_CONVERT_DITHER_TYPE, quark,
(gpointer) gimp_convert_dither_type_compat_get_type ());
g_type_set_qdata (GIMP_TYPE_LAYER_MODE, quark,
(gpointer) gimp_layer_mode_effects_get_type ());
#endif
gimp_base_compat_enums_init ();

30
pdb/enums.pl
View File

@ -398,7 +398,7 @@ package Gimp::CodeGen::enums;
GIMP_PAINT_INCREMENTAL => '1' }
},
GimpPDBArgType =>
{ contig => 0,
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
symbols => [ qw(GIMP_PDB_INT32 GIMP_PDB_INT16 GIMP_PDB_INT8
GIMP_PDB_FLOAT GIMP_PDB_STRING GIMP_PDB_INT32ARRAY
@ -408,8 +408,7 @@ package Gimp::CodeGen::enums;
GIMP_PDB_IMAGE GIMP_PDB_LAYER GIMP_PDB_CHANNEL
GIMP_PDB_DRAWABLE GIMP_PDB_SELECTION
GIMP_PDB_COLORARRAY GIMP_PDB_VECTORS
GIMP_PDB_PARASITE GIMP_PDB_STATUS GIMP_PDB_END
GIMP_PDB_PATH GIMP_PDB_BOUNDARY GIMP_PDB_REGION) ],
GIMP_PDB_PARASITE GIMP_PDB_STATUS GIMP_PDB_END) ],
mapping => { GIMP_PDB_INT32 => '0',
GIMP_PDB_INT16 => '1',
GIMP_PDB_INT8 => '2',
@ -432,10 +431,7 @@ package Gimp::CodeGen::enums;
GIMP_PDB_VECTORS => '19',
GIMP_PDB_PARASITE => '20',
GIMP_PDB_STATUS => '21',
GIMP_PDB_END => '22',
GIMP_PDB_PATH => 'GIMP_PDB_VECTORS',
GIMP_PDB_BOUNDARY => 'GIMP_PDB_COLORARRAY',
GIMP_PDB_REGION => 'GIMP_PDB_ITEM' }
GIMP_PDB_END => '22' }
},
GimpPDBErrorHandler =>
{ contig => 1,
@ -650,26 +646,6 @@ package Gimp::CodeGen::enums;
GIMP_UNIT_PICA => '4',
GIMP_UNIT_END => '5' }
},
GimpUserDirectory =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',
symbols => [ qw(GIMP_USER_DIRECTORY_DESKTOP
GIMP_USER_DIRECTORY_DOCUMENTS
GIMP_USER_DIRECTORY_DOWNLOAD
GIMP_USER_DIRECTORY_MUSIC
GIMP_USER_DIRECTORY_PICTURES
GIMP_USER_DIRECTORY_PUBLIC_SHARE
GIMP_USER_DIRECTORY_TEMPLATES
GIMP_USER_DIRECTORY_VIDEOS) ],
mapping => { GIMP_USER_DIRECTORY_DESKTOP => '0',
GIMP_USER_DIRECTORY_DOCUMENTS => '1',
GIMP_USER_DIRECTORY_DOWNLOAD => '2',
GIMP_USER_DIRECTORY_MUSIC => '3',
GIMP_USER_DIRECTORY_PICTURES => '4',
GIMP_USER_DIRECTORY_PUBLIC_SHARE => '5',
GIMP_USER_DIRECTORY_TEMPLATES => '6',
GIMP_USER_DIRECTORY_VIDEOS => '7' }
},
GimpVectorsStrokeType =>
{ contig => 1,
header => 'libgimpbase/gimpbaseenums.h',