fca2e84f4f
The whole bucket fill specific enum stuff is on its way out, so let's
keep this one out of libgimp for now until we decide how to present
line art filling in the PDB.
(cherry picked from commit 368f2e596a)
2044 lines
68 KiB
C
2044 lines
68 KiB
C
|
|
/* Generated data (by gimp-mkenums) */
|
|
|
|
#include "config.h"
|
|
#include <glib-object.h>
|
|
#undef GIMP_DISABLE_DEPRECATED
|
|
#include "gimpbasetypes.h"
|
|
#include "libgimp/libgimp-intl.h"
|
|
|
|
/* enumerations from "gimpbaseenums.h" */
|
|
GType
|
|
gimp_add_mask_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_ADD_MASK_WHITE, "GIMP_ADD_MASK_WHITE", "white" },
|
|
{ GIMP_ADD_MASK_BLACK, "GIMP_ADD_MASK_BLACK", "black" },
|
|
{ GIMP_ADD_MASK_ALPHA, "GIMP_ADD_MASK_ALPHA", "alpha" },
|
|
{ GIMP_ADD_MASK_ALPHA_TRANSFER, "GIMP_ADD_MASK_ALPHA_TRANSFER", "alpha-transfer" },
|
|
{ GIMP_ADD_MASK_SELECTION, "GIMP_ADD_MASK_SELECTION", "selection" },
|
|
{ GIMP_ADD_MASK_COPY, "GIMP_ADD_MASK_COPY", "copy" },
|
|
{ GIMP_ADD_MASK_CHANNEL, "GIMP_ADD_MASK_CHANNEL", "channel" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_ADD_MASK_WHITE, NC_("add-mask-type", "_White (full opacity)"), NULL },
|
|
{ GIMP_ADD_MASK_BLACK, NC_("add-mask-type", "_Black (full transparency)"), NULL },
|
|
{ GIMP_ADD_MASK_ALPHA, NC_("add-mask-type", "Layer's _alpha channel"), NULL },
|
|
{ GIMP_ADD_MASK_ALPHA_TRANSFER, NC_("add-mask-type", "_Transfer layer's alpha channel"), NULL },
|
|
{ GIMP_ADD_MASK_SELECTION, NC_("add-mask-type", "_Selection"), NULL },
|
|
{ GIMP_ADD_MASK_COPY, NC_("add-mask-type", "_Grayscale copy of layer"), NULL },
|
|
{ GIMP_ADD_MASK_CHANNEL, NC_("add-mask-type", "C_hannel"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpAddMaskType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "add-mask-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_blend_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_BLEND_FG_BG_RGB, "GIMP_BLEND_FG_BG_RGB", "fg-bg-rgb" },
|
|
{ GIMP_BLEND_FG_BG_HSV, "GIMP_BLEND_FG_BG_HSV", "fg-bg-hsv" },
|
|
{ GIMP_BLEND_FG_TRANSPARENT, "GIMP_BLEND_FG_TRANSPARENT", "fg-transparent" },
|
|
{ GIMP_BLEND_CUSTOM, "GIMP_BLEND_CUSTOM", "custom" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_BLEND_FG_BG_RGB, NC_("blend-mode", "FG to BG (RGB)"), NULL },
|
|
{ GIMP_BLEND_FG_BG_HSV, NC_("blend-mode", "FG to BG (HSV)"), NULL },
|
|
{ GIMP_BLEND_FG_TRANSPARENT, NC_("blend-mode", "FG to transparent"), NULL },
|
|
{ GIMP_BLEND_CUSTOM, NC_("blend-mode", "Custom gradient"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpBlendMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "blend-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_brush_generated_shape_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_BRUSH_GENERATED_CIRCLE, "GIMP_BRUSH_GENERATED_CIRCLE", "circle" },
|
|
{ GIMP_BRUSH_GENERATED_SQUARE, "GIMP_BRUSH_GENERATED_SQUARE", "square" },
|
|
{ GIMP_BRUSH_GENERATED_DIAMOND, "GIMP_BRUSH_GENERATED_DIAMOND", "diamond" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_BRUSH_GENERATED_CIRCLE, NC_("brush-generated-shape", "Circle"), NULL },
|
|
{ GIMP_BRUSH_GENERATED_SQUARE, NC_("brush-generated-shape", "Square"), NULL },
|
|
{ GIMP_BRUSH_GENERATED_DIAMOND, NC_("brush-generated-shape", "Diamond"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpBrushGeneratedShape", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "brush-generated-shape");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_bucket_fill_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_BUCKET_FILL_FG, "GIMP_BUCKET_FILL_FG", "fg" },
|
|
{ GIMP_BUCKET_FILL_BG, "GIMP_BUCKET_FILL_BG", "bg" },
|
|
{ GIMP_BUCKET_FILL_PATTERN, "GIMP_BUCKET_FILL_PATTERN", "pattern" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_BUCKET_FILL_FG, NC_("bucket-fill-mode", "FG color fill"), NULL },
|
|
{ GIMP_BUCKET_FILL_BG, NC_("bucket-fill-mode", "BG color fill"), NULL },
|
|
{ GIMP_BUCKET_FILL_PATTERN, NC_("bucket-fill-mode", "Pattern fill"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpBucketFillMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "bucket-fill-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_cap_style_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CAP_BUTT, "GIMP_CAP_BUTT", "butt" },
|
|
{ GIMP_CAP_ROUND, "GIMP_CAP_ROUND", "round" },
|
|
{ GIMP_CAP_SQUARE, "GIMP_CAP_SQUARE", "square" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CAP_BUTT, NC_("cap-style", "Butt"), NULL },
|
|
{ GIMP_CAP_ROUND, NC_("cap-style", "Round"), NULL },
|
|
{ GIMP_CAP_SQUARE, NC_("cap-style", "Square"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpCapStyle", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "cap-style");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_channel_ops_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CHANNEL_OP_ADD, "GIMP_CHANNEL_OP_ADD", "add" },
|
|
{ GIMP_CHANNEL_OP_SUBTRACT, "GIMP_CHANNEL_OP_SUBTRACT", "subtract" },
|
|
{ GIMP_CHANNEL_OP_REPLACE, "GIMP_CHANNEL_OP_REPLACE", "replace" },
|
|
{ GIMP_CHANNEL_OP_INTERSECT, "GIMP_CHANNEL_OP_INTERSECT", "intersect" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CHANNEL_OP_ADD, NC_("channel-ops", "Add to the current selection"), NULL },
|
|
{ GIMP_CHANNEL_OP_SUBTRACT, NC_("channel-ops", "Subtract from the current selection"), NULL },
|
|
{ GIMP_CHANNEL_OP_REPLACE, NC_("channel-ops", "Replace the current selection"), NULL },
|
|
{ GIMP_CHANNEL_OP_INTERSECT, NC_("channel-ops", "Intersect with the current selection"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpChannelOps", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "channel-ops");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_channel_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CHANNEL_RED, "GIMP_CHANNEL_RED", "red" },
|
|
{ GIMP_CHANNEL_GREEN, "GIMP_CHANNEL_GREEN", "green" },
|
|
{ GIMP_CHANNEL_BLUE, "GIMP_CHANNEL_BLUE", "blue" },
|
|
{ GIMP_CHANNEL_GRAY, "GIMP_CHANNEL_GRAY", "gray" },
|
|
{ GIMP_CHANNEL_INDEXED, "GIMP_CHANNEL_INDEXED", "indexed" },
|
|
{ GIMP_CHANNEL_ALPHA, "GIMP_CHANNEL_ALPHA", "alpha" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CHANNEL_RED, NC_("channel-type", "Red"), NULL },
|
|
{ GIMP_CHANNEL_GREEN, NC_("channel-type", "Green"), NULL },
|
|
{ GIMP_CHANNEL_BLUE, NC_("channel-type", "Blue"), NULL },
|
|
{ GIMP_CHANNEL_GRAY, NC_("channel-type", "Gray"), NULL },
|
|
{ GIMP_CHANNEL_INDEXED, NC_("channel-type", "Indexed"), NULL },
|
|
{ GIMP_CHANNEL_ALPHA, NC_("channel-type", "Alpha"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpChannelType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "channel-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_check_size_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CHECK_SIZE_SMALL_CHECKS, "GIMP_CHECK_SIZE_SMALL_CHECKS", "small-checks" },
|
|
{ GIMP_CHECK_SIZE_MEDIUM_CHECKS, "GIMP_CHECK_SIZE_MEDIUM_CHECKS", "medium-checks" },
|
|
{ GIMP_CHECK_SIZE_LARGE_CHECKS, "GIMP_CHECK_SIZE_LARGE_CHECKS", "large-checks" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CHECK_SIZE_SMALL_CHECKS, NC_("check-size", "Small"), NULL },
|
|
{ GIMP_CHECK_SIZE_MEDIUM_CHECKS, NC_("check-size", "Medium"), NULL },
|
|
{ GIMP_CHECK_SIZE_LARGE_CHECKS, NC_("check-size", "Large"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpCheckSize", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "check-size");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_check_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CHECK_TYPE_LIGHT_CHECKS, "GIMP_CHECK_TYPE_LIGHT_CHECKS", "light-checks" },
|
|
{ GIMP_CHECK_TYPE_GRAY_CHECKS, "GIMP_CHECK_TYPE_GRAY_CHECKS", "gray-checks" },
|
|
{ GIMP_CHECK_TYPE_DARK_CHECKS, "GIMP_CHECK_TYPE_DARK_CHECKS", "dark-checks" },
|
|
{ GIMP_CHECK_TYPE_WHITE_ONLY, "GIMP_CHECK_TYPE_WHITE_ONLY", "white-only" },
|
|
{ GIMP_CHECK_TYPE_GRAY_ONLY, "GIMP_CHECK_TYPE_GRAY_ONLY", "gray-only" },
|
|
{ GIMP_CHECK_TYPE_BLACK_ONLY, "GIMP_CHECK_TYPE_BLACK_ONLY", "black-only" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CHECK_TYPE_LIGHT_CHECKS, NC_("check-type", "Light checks"), NULL },
|
|
{ GIMP_CHECK_TYPE_GRAY_CHECKS, NC_("check-type", "Mid-tone checks"), NULL },
|
|
{ GIMP_CHECK_TYPE_DARK_CHECKS, NC_("check-type", "Dark checks"), NULL },
|
|
{ GIMP_CHECK_TYPE_WHITE_ONLY, NC_("check-type", "White only"), NULL },
|
|
{ GIMP_CHECK_TYPE_GRAY_ONLY, NC_("check-type", "Gray only"), NULL },
|
|
{ GIMP_CHECK_TYPE_BLACK_ONLY, NC_("check-type", "Black only"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpCheckType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "check-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_clone_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CLONE_IMAGE, "GIMP_CLONE_IMAGE", "image" },
|
|
{ GIMP_CLONE_PATTERN, "GIMP_CLONE_PATTERN", "pattern" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CLONE_IMAGE, NC_("clone-type", "Image"), NULL },
|
|
{ GIMP_CLONE_PATTERN, NC_("clone-type", "Pattern"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpCloneType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "clone-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_color_tag_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_COLOR_TAG_NONE, "GIMP_COLOR_TAG_NONE", "none" },
|
|
{ GIMP_COLOR_TAG_BLUE, "GIMP_COLOR_TAG_BLUE", "blue" },
|
|
{ GIMP_COLOR_TAG_GREEN, "GIMP_COLOR_TAG_GREEN", "green" },
|
|
{ GIMP_COLOR_TAG_YELLOW, "GIMP_COLOR_TAG_YELLOW", "yellow" },
|
|
{ GIMP_COLOR_TAG_ORANGE, "GIMP_COLOR_TAG_ORANGE", "orange" },
|
|
{ GIMP_COLOR_TAG_BROWN, "GIMP_COLOR_TAG_BROWN", "brown" },
|
|
{ GIMP_COLOR_TAG_RED, "GIMP_COLOR_TAG_RED", "red" },
|
|
{ GIMP_COLOR_TAG_VIOLET, "GIMP_COLOR_TAG_VIOLET", "violet" },
|
|
{ GIMP_COLOR_TAG_GRAY, "GIMP_COLOR_TAG_GRAY", "gray" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_COLOR_TAG_NONE, NC_("color-tag", "None"), NULL },
|
|
{ GIMP_COLOR_TAG_BLUE, NC_("color-tag", "Blue"), NULL },
|
|
{ GIMP_COLOR_TAG_GREEN, NC_("color-tag", "Green"), NULL },
|
|
{ GIMP_COLOR_TAG_YELLOW, NC_("color-tag", "Yellow"), NULL },
|
|
{ GIMP_COLOR_TAG_ORANGE, NC_("color-tag", "Orange"), NULL },
|
|
{ GIMP_COLOR_TAG_BROWN, NC_("color-tag", "Brown"), NULL },
|
|
{ GIMP_COLOR_TAG_RED, NC_("color-tag", "Red"), NULL },
|
|
{ GIMP_COLOR_TAG_VIOLET, NC_("color-tag", "Violet"), NULL },
|
|
{ GIMP_COLOR_TAG_GRAY, NC_("color-tag", "Gray"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpColorTag", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "color-tag");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_component_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_COMPONENT_TYPE_U8, "GIMP_COMPONENT_TYPE_U8", "u8" },
|
|
{ GIMP_COMPONENT_TYPE_U16, "GIMP_COMPONENT_TYPE_U16", "u16" },
|
|
{ GIMP_COMPONENT_TYPE_U32, "GIMP_COMPONENT_TYPE_U32", "u32" },
|
|
{ GIMP_COMPONENT_TYPE_HALF, "GIMP_COMPONENT_TYPE_HALF", "half" },
|
|
{ GIMP_COMPONENT_TYPE_FLOAT, "GIMP_COMPONENT_TYPE_FLOAT", "float" },
|
|
{ GIMP_COMPONENT_TYPE_DOUBLE, "GIMP_COMPONENT_TYPE_DOUBLE", "double" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_COMPONENT_TYPE_U8, NC_("component-type", "8-bit integer"), NULL },
|
|
{ GIMP_COMPONENT_TYPE_U16, NC_("component-type", "16-bit integer"), NULL },
|
|
{ GIMP_COMPONENT_TYPE_U32, NC_("component-type", "32-bit integer"), NULL },
|
|
{ GIMP_COMPONENT_TYPE_HALF, NC_("component-type", "16-bit floating point"), NULL },
|
|
{ GIMP_COMPONENT_TYPE_FLOAT, NC_("component-type", "32-bit floating point"), NULL },
|
|
{ GIMP_COMPONENT_TYPE_DOUBLE, NC_("component-type", "64-bit floating point"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpComponentType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "component-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_convert_palette_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CONVERT_PALETTE_GENERATE, "GIMP_CONVERT_PALETTE_GENERATE", "generate" },
|
|
{ GIMP_CONVERT_PALETTE_WEB, "GIMP_CONVERT_PALETTE_WEB", "web" },
|
|
{ GIMP_CONVERT_PALETTE_MONO, "GIMP_CONVERT_PALETTE_MONO", "mono" },
|
|
{ GIMP_CONVERT_PALETTE_CUSTOM, "GIMP_CONVERT_PALETTE_CUSTOM", "custom" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CONVERT_PALETTE_GENERATE, NC_("convert-palette-type", "Generate optimum palette"), NULL },
|
|
{ GIMP_CONVERT_PALETTE_WEB, NC_("convert-palette-type", "Use web-optimized palette"), NULL },
|
|
{ GIMP_CONVERT_PALETTE_MONO, NC_("convert-palette-type", "Use black and white (1-bit) palette"), NULL },
|
|
{ GIMP_CONVERT_PALETTE_CUSTOM, NC_("convert-palette-type", "Use custom palette"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpConvertPaletteType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "convert-palette-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_convolve_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_CONVOLVE_BLUR, "GIMP_CONVOLVE_BLUR", "blur" },
|
|
{ GIMP_CONVOLVE_SHARPEN, "GIMP_CONVOLVE_SHARPEN", "sharpen" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_CONVOLVE_BLUR, NC_("convolve-type", "Blur"), NULL },
|
|
{ GIMP_CONVOLVE_SHARPEN, NC_("convolve-type", "Sharpen"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpConvolveType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "convolve-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_desaturate_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_DESATURATE_LIGHTNESS, "GIMP_DESATURATE_LIGHTNESS", "lightness" },
|
|
{ GIMP_DESATURATE_LUMA, "GIMP_DESATURATE_LUMA", "luma" },
|
|
{ GIMP_DESATURATE_AVERAGE, "GIMP_DESATURATE_AVERAGE", "average" },
|
|
{ GIMP_DESATURATE_LUMINANCE, "GIMP_DESATURATE_LUMINANCE", "luminance" },
|
|
{ GIMP_DESATURATE_VALUE, "GIMP_DESATURATE_VALUE", "value" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_DESATURATE_LIGHTNESS, NC_("desaturate-mode", "Lightness (HSL)"), NULL },
|
|
{ GIMP_DESATURATE_LUMA, NC_("desaturate-mode", "Luma"), NULL },
|
|
{ GIMP_DESATURATE_AVERAGE, NC_("desaturate-mode", "Average (HSI Intensity)"), NULL },
|
|
{ GIMP_DESATURATE_LUMINANCE, NC_("desaturate-mode", "Luminance"), NULL },
|
|
{ GIMP_DESATURATE_VALUE, NC_("desaturate-mode", "Value (HSV)"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpDesaturateMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "desaturate-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_dodge_burn_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_DODGE_BURN_TYPE_DODGE, "GIMP_DODGE_BURN_TYPE_DODGE", "dodge" },
|
|
{ GIMP_DODGE_BURN_TYPE_BURN, "GIMP_DODGE_BURN_TYPE_BURN", "burn" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_DODGE_BURN_TYPE_DODGE, NC_("dodge-burn-type", "Dodge"), NULL },
|
|
{ GIMP_DODGE_BURN_TYPE_BURN, NC_("dodge-burn-type", "Burn"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpDodgeBurnType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "dodge-burn-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_fill_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_FILL_FOREGROUND, "GIMP_FILL_FOREGROUND", "foreground" },
|
|
{ GIMP_FILL_BACKGROUND, "GIMP_FILL_BACKGROUND", "background" },
|
|
{ GIMP_FILL_WHITE, "GIMP_FILL_WHITE", "white" },
|
|
{ GIMP_FILL_TRANSPARENT, "GIMP_FILL_TRANSPARENT", "transparent" },
|
|
{ GIMP_FILL_PATTERN, "GIMP_FILL_PATTERN", "pattern" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_FILL_FOREGROUND, NC_("fill-type", "Foreground color"), NULL },
|
|
{ GIMP_FILL_BACKGROUND, NC_("fill-type", "Background color"), NULL },
|
|
{ GIMP_FILL_WHITE, NC_("fill-type", "White"), NULL },
|
|
{ GIMP_FILL_TRANSPARENT, NC_("fill-type", "Transparency"), NULL },
|
|
{ GIMP_FILL_PATTERN, NC_("fill-type", "Pattern"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpFillType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "fill-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_foreground_extract_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_FOREGROUND_EXTRACT_SIOX, "GIMP_FOREGROUND_EXTRACT_SIOX", "siox" },
|
|
{ GIMP_FOREGROUND_EXTRACT_MATTING, "GIMP_FOREGROUND_EXTRACT_MATTING", "matting" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_FOREGROUND_EXTRACT_SIOX, "GIMP_FOREGROUND_EXTRACT_SIOX", NULL },
|
|
{ GIMP_FOREGROUND_EXTRACT_MATTING, "GIMP_FOREGROUND_EXTRACT_MATTING", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpForegroundExtractMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "foreground-extract-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_gradient_blend_color_space_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, "GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL", "rgb-perceptual" },
|
|
{ GIMP_GRADIENT_BLEND_RGB_LINEAR, "GIMP_GRADIENT_BLEND_RGB_LINEAR", "rgb-linear" },
|
|
{ GIMP_GRADIENT_BLEND_CIE_LAB, "GIMP_GRADIENT_BLEND_CIE_LAB", "cie-lab" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, NC_("gradient-blend-color-space", "Perceptual RGB"), NULL },
|
|
{ GIMP_GRADIENT_BLEND_RGB_LINEAR, NC_("gradient-blend-color-space", "Linear RGB"), NULL },
|
|
{ GIMP_GRADIENT_BLEND_CIE_LAB, NC_("gradient-blend-color-space", "CIE Lab"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpGradientBlendColorSpace", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "gradient-blend-color-space");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_gradient_segment_color_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_GRADIENT_SEGMENT_RGB, "GIMP_GRADIENT_SEGMENT_RGB", "rgb" },
|
|
{ GIMP_GRADIENT_SEGMENT_HSV_CCW, "GIMP_GRADIENT_SEGMENT_HSV_CCW", "hsv-ccw" },
|
|
{ GIMP_GRADIENT_SEGMENT_HSV_CW, "GIMP_GRADIENT_SEGMENT_HSV_CW", "hsv-cw" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_GRADIENT_SEGMENT_RGB, NC_("gradient-segment-color", "RGB"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_HSV_CCW, NC_("gradient-segment-color", "HSV (counter-clockwise hue)"), NULL },
|
|
/* Translators: this is an abbreviated version of "HSV (counter-clockwise hue)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_SEGMENT_HSV_CCW, NC_("gradient-segment-color", "HSV (ccw)"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_HSV_CW, NC_("gradient-segment-color", "HSV (clockwise hue)"), NULL },
|
|
/* Translators: this is an abbreviated version of "HSV (clockwise hue)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_SEGMENT_HSV_CW, NC_("gradient-segment-color", "HSV (cw)"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpGradientSegmentColor", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "gradient-segment-color");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_gradient_segment_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_GRADIENT_SEGMENT_LINEAR, "GIMP_GRADIENT_SEGMENT_LINEAR", "linear" },
|
|
{ GIMP_GRADIENT_SEGMENT_CURVED, "GIMP_GRADIENT_SEGMENT_CURVED", "curved" },
|
|
{ GIMP_GRADIENT_SEGMENT_SINE, "GIMP_GRADIENT_SEGMENT_SINE", "sine" },
|
|
{ GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING", "sphere-increasing" },
|
|
{ GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, "GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING", "sphere-decreasing" },
|
|
{ GIMP_GRADIENT_SEGMENT_STEP, "GIMP_GRADIENT_SEGMENT_STEP", "step" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_GRADIENT_SEGMENT_LINEAR, NC_("gradient-segment-type", "Linear"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_CURVED, NC_("gradient-segment-type", "Curved"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_SINE, NC_("gradient-segment-type", "Sinusoidal"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, NC_("gradient-segment-type", "Spherical (increasing)"), NULL },
|
|
/* Translators: this is an abbreviated version of "Spherical (increasing)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, NC_("gradient-segment-type", "Spherical (inc)"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, NC_("gradient-segment-type", "Spherical (decreasing)"), NULL },
|
|
/* Translators: this is an abbreviated version of "Spherical (decreasing)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, NC_("gradient-segment-type", "Spherical (dec)"), NULL },
|
|
{ GIMP_GRADIENT_SEGMENT_STEP, NC_("gradient-segment-type", "Step"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpGradientSegmentType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "gradient-segment-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_gradient_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_GRADIENT_LINEAR, "GIMP_GRADIENT_LINEAR", "linear" },
|
|
{ GIMP_GRADIENT_BILINEAR, "GIMP_GRADIENT_BILINEAR", "bilinear" },
|
|
{ GIMP_GRADIENT_RADIAL, "GIMP_GRADIENT_RADIAL", "radial" },
|
|
{ GIMP_GRADIENT_SQUARE, "GIMP_GRADIENT_SQUARE", "square" },
|
|
{ GIMP_GRADIENT_CONICAL_SYMMETRIC, "GIMP_GRADIENT_CONICAL_SYMMETRIC", "conical-symmetric" },
|
|
{ GIMP_GRADIENT_CONICAL_ASYMMETRIC, "GIMP_GRADIENT_CONICAL_ASYMMETRIC", "conical-asymmetric" },
|
|
{ GIMP_GRADIENT_SHAPEBURST_ANGULAR, "GIMP_GRADIENT_SHAPEBURST_ANGULAR", "shapeburst-angular" },
|
|
{ GIMP_GRADIENT_SHAPEBURST_SPHERICAL, "GIMP_GRADIENT_SHAPEBURST_SPHERICAL", "shapeburst-spherical" },
|
|
{ GIMP_GRADIENT_SHAPEBURST_DIMPLED, "GIMP_GRADIENT_SHAPEBURST_DIMPLED", "shapeburst-dimpled" },
|
|
{ GIMP_GRADIENT_SPIRAL_CLOCKWISE, "GIMP_GRADIENT_SPIRAL_CLOCKWISE", "spiral-clockwise" },
|
|
{ GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, "GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE", "spiral-anticlockwise" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_GRADIENT_LINEAR, NC_("gradient-type", "Linear"), NULL },
|
|
{ GIMP_GRADIENT_BILINEAR, NC_("gradient-type", "Bi-linear"), NULL },
|
|
{ GIMP_GRADIENT_RADIAL, NC_("gradient-type", "Radial"), NULL },
|
|
{ GIMP_GRADIENT_SQUARE, NC_("gradient-type", "Square"), NULL },
|
|
{ GIMP_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (symmetric)"), NULL },
|
|
/* Translators: this is an abbreviated version of "Conical (symmetric)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (sym)"), NULL },
|
|
{ GIMP_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asymmetric)"), NULL },
|
|
/* Translators: this is an abbreviated version of "Conical (asymmetric)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asym)"), NULL },
|
|
{ GIMP_GRADIENT_SHAPEBURST_ANGULAR, NC_("gradient-type", "Shaped (angular)"), NULL },
|
|
{ GIMP_GRADIENT_SHAPEBURST_SPHERICAL, NC_("gradient-type", "Shaped (spherical)"), NULL },
|
|
{ GIMP_GRADIENT_SHAPEBURST_DIMPLED, NC_("gradient-type", "Shaped (dimpled)"), NULL },
|
|
{ GIMP_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (clockwise)"), NULL },
|
|
/* Translators: this is an abbreviated version of "Spiral (clockwise)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (cw)"), NULL },
|
|
{ GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (counter-clockwise)"), NULL },
|
|
/* Translators: this is an abbreviated version of "Spiral (counter-clockwise)".
|
|
Keep it short. */
|
|
{ GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (ccw)"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpGradientType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "gradient-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_grid_style_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_GRID_DOTS, "GIMP_GRID_DOTS", "dots" },
|
|
{ GIMP_GRID_INTERSECTIONS, "GIMP_GRID_INTERSECTIONS", "intersections" },
|
|
{ GIMP_GRID_ON_OFF_DASH, "GIMP_GRID_ON_OFF_DASH", "on-off-dash" },
|
|
{ GIMP_GRID_DOUBLE_DASH, "GIMP_GRID_DOUBLE_DASH", "double-dash" },
|
|
{ GIMP_GRID_SOLID, "GIMP_GRID_SOLID", "solid" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_GRID_DOTS, NC_("grid-style", "Intersections (dots)"), NULL },
|
|
{ GIMP_GRID_INTERSECTIONS, NC_("grid-style", "Intersections (crosshairs)"), NULL },
|
|
{ GIMP_GRID_ON_OFF_DASH, NC_("grid-style", "Dashed"), NULL },
|
|
{ GIMP_GRID_DOUBLE_DASH, NC_("grid-style", "Double dashed"), NULL },
|
|
{ GIMP_GRID_SOLID, NC_("grid-style", "Solid"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpGridStyle", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "grid-style");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_hue_range_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_HUE_RANGE_ALL, "GIMP_HUE_RANGE_ALL", "all" },
|
|
{ GIMP_HUE_RANGE_RED, "GIMP_HUE_RANGE_RED", "red" },
|
|
{ GIMP_HUE_RANGE_YELLOW, "GIMP_HUE_RANGE_YELLOW", "yellow" },
|
|
{ GIMP_HUE_RANGE_GREEN, "GIMP_HUE_RANGE_GREEN", "green" },
|
|
{ GIMP_HUE_RANGE_CYAN, "GIMP_HUE_RANGE_CYAN", "cyan" },
|
|
{ GIMP_HUE_RANGE_BLUE, "GIMP_HUE_RANGE_BLUE", "blue" },
|
|
{ GIMP_HUE_RANGE_MAGENTA, "GIMP_HUE_RANGE_MAGENTA", "magenta" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_HUE_RANGE_ALL, "GIMP_HUE_RANGE_ALL", NULL },
|
|
{ GIMP_HUE_RANGE_RED, "GIMP_HUE_RANGE_RED", NULL },
|
|
{ GIMP_HUE_RANGE_YELLOW, "GIMP_HUE_RANGE_YELLOW", NULL },
|
|
{ GIMP_HUE_RANGE_GREEN, "GIMP_HUE_RANGE_GREEN", NULL },
|
|
{ GIMP_HUE_RANGE_CYAN, "GIMP_HUE_RANGE_CYAN", NULL },
|
|
{ GIMP_HUE_RANGE_BLUE, "GIMP_HUE_RANGE_BLUE", NULL },
|
|
{ GIMP_HUE_RANGE_MAGENTA, "GIMP_HUE_RANGE_MAGENTA", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpHueRange", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "hue-range");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_icon_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_ICON_TYPE_ICON_NAME, "GIMP_ICON_TYPE_ICON_NAME", "icon-name" },
|
|
{ GIMP_ICON_TYPE_INLINE_PIXBUF, "GIMP_ICON_TYPE_INLINE_PIXBUF", "inline-pixbuf" },
|
|
{ GIMP_ICON_TYPE_IMAGE_FILE, "GIMP_ICON_TYPE_IMAGE_FILE", "image-file" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_ICON_TYPE_ICON_NAME, NC_("icon-type", "Icon name"), NULL },
|
|
{ GIMP_ICON_TYPE_INLINE_PIXBUF, NC_("icon-type", "Inline pixbuf"), NULL },
|
|
{ GIMP_ICON_TYPE_IMAGE_FILE, NC_("icon-type", "Image file"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpIconType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "icon-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_image_base_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_RGB, "GIMP_RGB", "rgb" },
|
|
{ GIMP_GRAY, "GIMP_GRAY", "gray" },
|
|
{ GIMP_INDEXED, "GIMP_INDEXED", "indexed" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_RGB, NC_("image-base-type", "RGB color"), NULL },
|
|
{ GIMP_GRAY, NC_("image-base-type", "Grayscale"), NULL },
|
|
{ GIMP_INDEXED, NC_("image-base-type", "Indexed color"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpImageBaseType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "image-base-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_image_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_RGB_IMAGE, "GIMP_RGB_IMAGE", "rgb-image" },
|
|
{ GIMP_RGBA_IMAGE, "GIMP_RGBA_IMAGE", "rgba-image" },
|
|
{ GIMP_GRAY_IMAGE, "GIMP_GRAY_IMAGE", "gray-image" },
|
|
{ GIMP_GRAYA_IMAGE, "GIMP_GRAYA_IMAGE", "graya-image" },
|
|
{ GIMP_INDEXED_IMAGE, "GIMP_INDEXED_IMAGE", "indexed-image" },
|
|
{ GIMP_INDEXEDA_IMAGE, "GIMP_INDEXEDA_IMAGE", "indexeda-image" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_RGB_IMAGE, NC_("image-type", "RGB"), NULL },
|
|
{ GIMP_RGBA_IMAGE, NC_("image-type", "RGB-alpha"), NULL },
|
|
{ GIMP_GRAY_IMAGE, NC_("image-type", "Grayscale"), NULL },
|
|
{ GIMP_GRAYA_IMAGE, NC_("image-type", "Grayscale-alpha"), NULL },
|
|
{ GIMP_INDEXED_IMAGE, NC_("image-type", "Indexed"), NULL },
|
|
{ GIMP_INDEXEDA_IMAGE, NC_("image-type", "Indexed-alpha"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpImageType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "image-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_ink_blob_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_INK_BLOB_TYPE_CIRCLE, "GIMP_INK_BLOB_TYPE_CIRCLE", "circle" },
|
|
{ GIMP_INK_BLOB_TYPE_SQUARE, "GIMP_INK_BLOB_TYPE_SQUARE", "square" },
|
|
{ GIMP_INK_BLOB_TYPE_DIAMOND, "GIMP_INK_BLOB_TYPE_DIAMOND", "diamond" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_INK_BLOB_TYPE_CIRCLE, NC_("ink-blob-type", "Circle"), NULL },
|
|
{ GIMP_INK_BLOB_TYPE_SQUARE, NC_("ink-blob-type", "Square"), NULL },
|
|
{ GIMP_INK_BLOB_TYPE_DIAMOND, NC_("ink-blob-type", "Diamond"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpInkBlobType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "ink-blob-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_interpolation_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_INTERPOLATION_NONE, "GIMP_INTERPOLATION_NONE", "none" },
|
|
{ GIMP_INTERPOLATION_LINEAR, "GIMP_INTERPOLATION_LINEAR", "linear" },
|
|
{ GIMP_INTERPOLATION_CUBIC, "GIMP_INTERPOLATION_CUBIC", "cubic" },
|
|
{ GIMP_INTERPOLATION_NOHALO, "GIMP_INTERPOLATION_NOHALO", "nohalo" },
|
|
{ GIMP_INTERPOLATION_LOHALO, "GIMP_INTERPOLATION_LOHALO", "lohalo" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_INTERPOLATION_NONE, NC_("interpolation-type", "None"), NULL },
|
|
{ GIMP_INTERPOLATION_LINEAR, NC_("interpolation-type", "Linear"), NULL },
|
|
{ GIMP_INTERPOLATION_CUBIC, NC_("interpolation-type", "Cubic"), NULL },
|
|
{ GIMP_INTERPOLATION_NOHALO, NC_("interpolation-type", "NoHalo"), NULL },
|
|
{ GIMP_INTERPOLATION_LOHALO, NC_("interpolation-type", "LoHalo"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpInterpolationType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "interpolation-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_join_style_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_JOIN_MITER, "GIMP_JOIN_MITER", "miter" },
|
|
{ GIMP_JOIN_ROUND, "GIMP_JOIN_ROUND", "round" },
|
|
{ GIMP_JOIN_BEVEL, "GIMP_JOIN_BEVEL", "bevel" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_JOIN_MITER, NC_("join-style", "Miter"), NULL },
|
|
{ GIMP_JOIN_ROUND, NC_("join-style", "Round"), NULL },
|
|
{ GIMP_JOIN_BEVEL, NC_("join-style", "Bevel"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpJoinStyle", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "join-style");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_mask_apply_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_MASK_APPLY, "GIMP_MASK_APPLY", "apply" },
|
|
{ GIMP_MASK_DISCARD, "GIMP_MASK_DISCARD", "discard" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_MASK_APPLY, "GIMP_MASK_APPLY", NULL },
|
|
{ GIMP_MASK_DISCARD, "GIMP_MASK_DISCARD", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpMaskApplyMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "mask-apply-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_merge_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_EXPAND_AS_NECESSARY, "GIMP_EXPAND_AS_NECESSARY", "expand-as-necessary" },
|
|
{ GIMP_CLIP_TO_IMAGE, "GIMP_CLIP_TO_IMAGE", "clip-to-image" },
|
|
{ GIMP_CLIP_TO_BOTTOM_LAYER, "GIMP_CLIP_TO_BOTTOM_LAYER", "clip-to-bottom-layer" },
|
|
{ GIMP_FLATTEN_IMAGE, "GIMP_FLATTEN_IMAGE", "flatten-image" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_EXPAND_AS_NECESSARY, NC_("merge-type", "Expanded as necessary"), NULL },
|
|
{ GIMP_CLIP_TO_IMAGE, NC_("merge-type", "Clipped to image"), NULL },
|
|
{ GIMP_CLIP_TO_BOTTOM_LAYER, NC_("merge-type", "Clipped to bottom layer"), NULL },
|
|
{ GIMP_FLATTEN_IMAGE, NC_("merge-type", "Flatten"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpMergeType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "merge-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_message_handler_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", "message-box" },
|
|
{ GIMP_CONSOLE, "GIMP_CONSOLE", "console" },
|
|
{ GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", "error-console" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_MESSAGE_BOX, "GIMP_MESSAGE_BOX", NULL },
|
|
{ GIMP_CONSOLE, "GIMP_CONSOLE", NULL },
|
|
{ GIMP_ERROR_CONSOLE, "GIMP_ERROR_CONSOLE", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpMessageHandlerType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "message-handler-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_offset_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", "background" },
|
|
{ GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", "transparent" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_OFFSET_BACKGROUND, "GIMP_OFFSET_BACKGROUND", NULL },
|
|
{ GIMP_OFFSET_TRANSPARENT, "GIMP_OFFSET_TRANSPARENT", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpOffsetType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "offset-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_orientation_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_ORIENTATION_HORIZONTAL, "GIMP_ORIENTATION_HORIZONTAL", "horizontal" },
|
|
{ GIMP_ORIENTATION_VERTICAL, "GIMP_ORIENTATION_VERTICAL", "vertical" },
|
|
{ GIMP_ORIENTATION_UNKNOWN, "GIMP_ORIENTATION_UNKNOWN", "unknown" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_ORIENTATION_HORIZONTAL, NC_("orientation-type", "Horizontal"), NULL },
|
|
{ GIMP_ORIENTATION_VERTICAL, NC_("orientation-type", "Vertical"), NULL },
|
|
{ GIMP_ORIENTATION_UNKNOWN, NC_("orientation-type", "Unknown"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpOrientationType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "orientation-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_paint_application_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PAINT_CONSTANT, "GIMP_PAINT_CONSTANT", "constant" },
|
|
{ GIMP_PAINT_INCREMENTAL, "GIMP_PAINT_INCREMENTAL", "incremental" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PAINT_CONSTANT, NC_("paint-application-mode", "Constant"), NULL },
|
|
{ GIMP_PAINT_INCREMENTAL, NC_("paint-application-mode", "Incremental"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpPaintApplicationMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "paint-application-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_pdb_arg_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PDB_INT32, "GIMP_PDB_INT32", "int32" },
|
|
{ GIMP_PDB_INT16, "GIMP_PDB_INT16", "int16" },
|
|
{ GIMP_PDB_INT8, "GIMP_PDB_INT8", "int8" },
|
|
{ GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", "float" },
|
|
{ GIMP_PDB_STRING, "GIMP_PDB_STRING", "string" },
|
|
{ GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", "int32array" },
|
|
{ GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", "int16array" },
|
|
{ GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", "int8array" },
|
|
{ GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", "floatarray" },
|
|
{ GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", "stringarray" },
|
|
{ GIMP_PDB_COLOR, "GIMP_PDB_COLOR", "color" },
|
|
{ GIMP_PDB_ITEM, "GIMP_PDB_ITEM", "item" },
|
|
{ GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", "display" },
|
|
{ GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", "image" },
|
|
{ GIMP_PDB_LAYER, "GIMP_PDB_LAYER", "layer" },
|
|
{ GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", "channel" },
|
|
{ GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", "drawable" },
|
|
{ GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", "selection" },
|
|
{ GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", "colorarray" },
|
|
{ GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", "vectors" },
|
|
{ GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", "parasite" },
|
|
{ GIMP_PDB_STATUS, "GIMP_PDB_STATUS", "status" },
|
|
{ GIMP_PDB_END, "GIMP_PDB_END", "end" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PDB_INT32, "GIMP_PDB_INT32", NULL },
|
|
{ GIMP_PDB_INT16, "GIMP_PDB_INT16", NULL },
|
|
{ GIMP_PDB_INT8, "GIMP_PDB_INT8", NULL },
|
|
{ GIMP_PDB_FLOAT, "GIMP_PDB_FLOAT", NULL },
|
|
{ GIMP_PDB_STRING, "GIMP_PDB_STRING", NULL },
|
|
{ GIMP_PDB_INT32ARRAY, "GIMP_PDB_INT32ARRAY", NULL },
|
|
{ GIMP_PDB_INT16ARRAY, "GIMP_PDB_INT16ARRAY", NULL },
|
|
{ GIMP_PDB_INT8ARRAY, "GIMP_PDB_INT8ARRAY", NULL },
|
|
{ GIMP_PDB_FLOATARRAY, "GIMP_PDB_FLOATARRAY", NULL },
|
|
{ GIMP_PDB_STRINGARRAY, "GIMP_PDB_STRINGARRAY", NULL },
|
|
{ GIMP_PDB_COLOR, "GIMP_PDB_COLOR", NULL },
|
|
{ GIMP_PDB_ITEM, "GIMP_PDB_ITEM", NULL },
|
|
{ GIMP_PDB_DISPLAY, "GIMP_PDB_DISPLAY", NULL },
|
|
{ GIMP_PDB_IMAGE, "GIMP_PDB_IMAGE", NULL },
|
|
{ GIMP_PDB_LAYER, "GIMP_PDB_LAYER", NULL },
|
|
{ GIMP_PDB_CHANNEL, "GIMP_PDB_CHANNEL", NULL },
|
|
{ GIMP_PDB_DRAWABLE, "GIMP_PDB_DRAWABLE", NULL },
|
|
{ GIMP_PDB_SELECTION, "GIMP_PDB_SELECTION", NULL },
|
|
{ GIMP_PDB_COLORARRAY, "GIMP_PDB_COLORARRAY", NULL },
|
|
{ GIMP_PDB_VECTORS, "GIMP_PDB_VECTORS", NULL },
|
|
{ GIMP_PDB_PARASITE, "GIMP_PDB_PARASITE", NULL },
|
|
{ GIMP_PDB_STATUS, "GIMP_PDB_STATUS", NULL },
|
|
{ GIMP_PDB_END, "GIMP_PDB_END", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpPDBArgType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "pdb-arg-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_pdb_error_handler_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", "internal" },
|
|
{ GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", "plugin" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PDB_ERROR_HANDLER_INTERNAL, "GIMP_PDB_ERROR_HANDLER_INTERNAL", NULL },
|
|
{ GIMP_PDB_ERROR_HANDLER_PLUGIN, "GIMP_PDB_ERROR_HANDLER_PLUGIN", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpPDBErrorHandler", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "pdb-error-handler");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_pdb_proc_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_INTERNAL, "GIMP_INTERNAL", "internal" },
|
|
{ GIMP_PLUGIN, "GIMP_PLUGIN", "plugin" },
|
|
{ GIMP_EXTENSION, "GIMP_EXTENSION", "extension" },
|
|
{ GIMP_TEMPORARY, "GIMP_TEMPORARY", "temporary" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_INTERNAL, NC_("pdb-proc-type", "Internal GIMP procedure"), NULL },
|
|
{ GIMP_PLUGIN, NC_("pdb-proc-type", "GIMP Plug-In"), NULL },
|
|
{ GIMP_EXTENSION, NC_("pdb-proc-type", "GIMP Extension"), NULL },
|
|
{ GIMP_TEMPORARY, NC_("pdb-proc-type", "Temporary Procedure"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpPDBProcType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "pdb-proc-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_pdb_status_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", "execution-error" },
|
|
{ GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", "calling-error" },
|
|
{ GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", "pass-through" },
|
|
{ GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", "success" },
|
|
{ GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", "cancel" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PDB_EXECUTION_ERROR, "GIMP_PDB_EXECUTION_ERROR", NULL },
|
|
{ GIMP_PDB_CALLING_ERROR, "GIMP_PDB_CALLING_ERROR", NULL },
|
|
{ GIMP_PDB_PASS_THROUGH, "GIMP_PDB_PASS_THROUGH", NULL },
|
|
{ GIMP_PDB_SUCCESS, "GIMP_PDB_SUCCESS", NULL },
|
|
{ GIMP_PDB_CANCEL, "GIMP_PDB_CANCEL", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpPDBStatusType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "pdb-status-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_precision_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PRECISION_U8_LINEAR, "GIMP_PRECISION_U8_LINEAR", "u8-linear" },
|
|
{ GIMP_PRECISION_U8_GAMMA, "GIMP_PRECISION_U8_GAMMA", "u8-gamma" },
|
|
{ GIMP_PRECISION_U16_LINEAR, "GIMP_PRECISION_U16_LINEAR", "u16-linear" },
|
|
{ GIMP_PRECISION_U16_GAMMA, "GIMP_PRECISION_U16_GAMMA", "u16-gamma" },
|
|
{ GIMP_PRECISION_U32_LINEAR, "GIMP_PRECISION_U32_LINEAR", "u32-linear" },
|
|
{ GIMP_PRECISION_U32_GAMMA, "GIMP_PRECISION_U32_GAMMA", "u32-gamma" },
|
|
{ GIMP_PRECISION_HALF_LINEAR, "GIMP_PRECISION_HALF_LINEAR", "half-linear" },
|
|
{ GIMP_PRECISION_HALF_GAMMA, "GIMP_PRECISION_HALF_GAMMA", "half-gamma" },
|
|
{ GIMP_PRECISION_FLOAT_LINEAR, "GIMP_PRECISION_FLOAT_LINEAR", "float-linear" },
|
|
{ GIMP_PRECISION_FLOAT_GAMMA, "GIMP_PRECISION_FLOAT_GAMMA", "float-gamma" },
|
|
{ GIMP_PRECISION_DOUBLE_LINEAR, "GIMP_PRECISION_DOUBLE_LINEAR", "double-linear" },
|
|
{ GIMP_PRECISION_DOUBLE_GAMMA, "GIMP_PRECISION_DOUBLE_GAMMA", "double-gamma" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PRECISION_U8_LINEAR, NC_("precision", "8-bit linear integer"), NULL },
|
|
{ GIMP_PRECISION_U8_GAMMA, NC_("precision", "8-bit gamma integer"), NULL },
|
|
{ GIMP_PRECISION_U16_LINEAR, NC_("precision", "16-bit linear integer"), NULL },
|
|
{ GIMP_PRECISION_U16_GAMMA, NC_("precision", "16-bit gamma integer"), NULL },
|
|
{ GIMP_PRECISION_U32_LINEAR, NC_("precision", "32-bit linear integer"), NULL },
|
|
{ GIMP_PRECISION_U32_GAMMA, NC_("precision", "32-bit gamma integer"), NULL },
|
|
{ GIMP_PRECISION_HALF_LINEAR, NC_("precision", "16-bit linear floating point"), NULL },
|
|
{ GIMP_PRECISION_HALF_GAMMA, NC_("precision", "16-bit gamma floating point"), NULL },
|
|
{ GIMP_PRECISION_FLOAT_LINEAR, NC_("precision", "32-bit linear floating point"), NULL },
|
|
{ GIMP_PRECISION_FLOAT_GAMMA, NC_("precision", "32-bit gamma floating point"), NULL },
|
|
{ GIMP_PRECISION_DOUBLE_LINEAR, NC_("precision", "64-bit linear floating point"), NULL },
|
|
{ GIMP_PRECISION_DOUBLE_GAMMA, NC_("precision", "64-bit gamma floating point"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpPrecision", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "precision");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_progress_command_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", "start" },
|
|
{ GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", "end" },
|
|
{ GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", "set-text" },
|
|
{ GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", "set-value" },
|
|
{ GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", "pulse" },
|
|
{ GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", "get-window" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PROGRESS_COMMAND_START, "GIMP_PROGRESS_COMMAND_START", NULL },
|
|
{ GIMP_PROGRESS_COMMAND_END, "GIMP_PROGRESS_COMMAND_END", NULL },
|
|
{ GIMP_PROGRESS_COMMAND_SET_TEXT, "GIMP_PROGRESS_COMMAND_SET_TEXT", NULL },
|
|
{ GIMP_PROGRESS_COMMAND_SET_VALUE, "GIMP_PROGRESS_COMMAND_SET_VALUE", NULL },
|
|
{ GIMP_PROGRESS_COMMAND_PULSE, "GIMP_PROGRESS_COMMAND_PULSE", NULL },
|
|
{ GIMP_PROGRESS_COMMAND_GET_WINDOW, "GIMP_PROGRESS_COMMAND_GET_WINDOW", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpProgressCommand", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "progress-command");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_repeat_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_REPEAT_NONE, "GIMP_REPEAT_NONE", "none" },
|
|
{ GIMP_REPEAT_SAWTOOTH, "GIMP_REPEAT_SAWTOOTH", "sawtooth" },
|
|
{ GIMP_REPEAT_TRIANGULAR, "GIMP_REPEAT_TRIANGULAR", "triangular" },
|
|
{ GIMP_REPEAT_TRUNCATE, "GIMP_REPEAT_TRUNCATE", "truncate" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_REPEAT_NONE, NC_("repeat-mode", "None (extend)"), NULL },
|
|
{ GIMP_REPEAT_SAWTOOTH, NC_("repeat-mode", "Sawtooth wave"), NULL },
|
|
{ GIMP_REPEAT_TRIANGULAR, NC_("repeat-mode", "Triangular wave"), NULL },
|
|
{ GIMP_REPEAT_TRUNCATE, NC_("repeat-mode", "Truncate"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpRepeatMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "repeat-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_rotation_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_ROTATE_90, "GIMP_ROTATE_90", "90" },
|
|
{ GIMP_ROTATE_180, "GIMP_ROTATE_180", "180" },
|
|
{ GIMP_ROTATE_270, "GIMP_ROTATE_270", "270" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_ROTATE_90, "GIMP_ROTATE_90", NULL },
|
|
{ GIMP_ROTATE_180, "GIMP_ROTATE_180", NULL },
|
|
{ GIMP_ROTATE_270, "GIMP_ROTATE_270", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpRotationType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "rotation-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_run_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_RUN_INTERACTIVE, "GIMP_RUN_INTERACTIVE", "interactive" },
|
|
{ GIMP_RUN_NONINTERACTIVE, "GIMP_RUN_NONINTERACTIVE", "noninteractive" },
|
|
{ GIMP_RUN_WITH_LAST_VALS, "GIMP_RUN_WITH_LAST_VALS", "with-last-vals" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_RUN_INTERACTIVE, NC_("run-mode", "Run interactively"), NULL },
|
|
{ GIMP_RUN_NONINTERACTIVE, NC_("run-mode", "Run non-interactively"), NULL },
|
|
{ GIMP_RUN_WITH_LAST_VALS, NC_("run-mode", "Run with last used values"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpRunMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "run-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_select_criterion_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_SELECT_CRITERION_COMPOSITE, "GIMP_SELECT_CRITERION_COMPOSITE", "composite" },
|
|
{ GIMP_SELECT_CRITERION_R, "GIMP_SELECT_CRITERION_R", "r" },
|
|
{ GIMP_SELECT_CRITERION_G, "GIMP_SELECT_CRITERION_G", "g" },
|
|
{ GIMP_SELECT_CRITERION_B, "GIMP_SELECT_CRITERION_B", "b" },
|
|
{ GIMP_SELECT_CRITERION_H, "GIMP_SELECT_CRITERION_H", "h" },
|
|
{ GIMP_SELECT_CRITERION_S, "GIMP_SELECT_CRITERION_S", "s" },
|
|
{ GIMP_SELECT_CRITERION_V, "GIMP_SELECT_CRITERION_V", "v" },
|
|
{ GIMP_SELECT_CRITERION_A, "GIMP_SELECT_CRITERION_A", "a" },
|
|
{ GIMP_SELECT_CRITERION_LCH_L, "GIMP_SELECT_CRITERION_LCH_L", "lch-l" },
|
|
{ GIMP_SELECT_CRITERION_LCH_C, "GIMP_SELECT_CRITERION_LCH_C", "lch-c" },
|
|
{ GIMP_SELECT_CRITERION_LCH_H, "GIMP_SELECT_CRITERION_LCH_H", "lch-h" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_SELECT_CRITERION_COMPOSITE, NC_("select-criterion", "Composite"), NULL },
|
|
{ GIMP_SELECT_CRITERION_R, NC_("select-criterion", "Red"), NULL },
|
|
{ GIMP_SELECT_CRITERION_G, NC_("select-criterion", "Green"), NULL },
|
|
{ GIMP_SELECT_CRITERION_B, NC_("select-criterion", "Blue"), NULL },
|
|
{ GIMP_SELECT_CRITERION_H, NC_("select-criterion", "HSV Hue"), NULL },
|
|
{ GIMP_SELECT_CRITERION_S, NC_("select-criterion", "HSV Saturation"), NULL },
|
|
{ GIMP_SELECT_CRITERION_V, NC_("select-criterion", "HSV Value"), NULL },
|
|
{ GIMP_SELECT_CRITERION_A, NC_("select-criterion", "Alpha"), NULL },
|
|
{ GIMP_SELECT_CRITERION_LCH_L, NC_("select-criterion", "LCh Lightness"), NULL },
|
|
{ GIMP_SELECT_CRITERION_LCH_C, NC_("select-criterion", "LCh Chroma"), NULL },
|
|
{ GIMP_SELECT_CRITERION_LCH_H, NC_("select-criterion", "LCh Hue"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpSelectCriterion", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "select-criterion");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_size_type_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_PIXELS, "GIMP_PIXELS", "pixels" },
|
|
{ GIMP_POINTS, "GIMP_POINTS", "points" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_PIXELS, NC_("size-type", "Pixels"), NULL },
|
|
{ GIMP_POINTS, NC_("size-type", "Points"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpSizeType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "size-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_stack_trace_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", "never" },
|
|
{ GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", "query" },
|
|
{ GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", "always" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_STACK_TRACE_NEVER, "GIMP_STACK_TRACE_NEVER", NULL },
|
|
{ GIMP_STACK_TRACE_QUERY, "GIMP_STACK_TRACE_QUERY", NULL },
|
|
{ GIMP_STACK_TRACE_ALWAYS, "GIMP_STACK_TRACE_ALWAYS", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpStackTraceMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "stack-trace-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_stroke_method_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_STROKE_LINE, "GIMP_STROKE_LINE", "line" },
|
|
{ GIMP_STROKE_PAINT_METHOD, "GIMP_STROKE_PAINT_METHOD", "paint-method" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_STROKE_LINE, NC_("stroke-method", "Stroke line"), NULL },
|
|
{ GIMP_STROKE_PAINT_METHOD, NC_("stroke-method", "Stroke with a paint tool"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpStrokeMethod", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "stroke-method");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_text_direction_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_TEXT_DIRECTION_LTR, "GIMP_TEXT_DIRECTION_LTR", "ltr" },
|
|
{ GIMP_TEXT_DIRECTION_RTL, "GIMP_TEXT_DIRECTION_RTL", "rtl" },
|
|
{ GIMP_TEXT_DIRECTION_TTB_RTL, "GIMP_TEXT_DIRECTION_TTB_RTL", "ttb-rtl" },
|
|
{ GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT, "GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT", "ttb-rtl-upright" },
|
|
{ GIMP_TEXT_DIRECTION_TTB_LTR, "GIMP_TEXT_DIRECTION_TTB_LTR", "ttb-ltr" },
|
|
{ GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT, "GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT", "ttb-ltr-upright" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_TEXT_DIRECTION_LTR, NC_("text-direction", "From left to right"), NULL },
|
|
{ GIMP_TEXT_DIRECTION_RTL, NC_("text-direction", "From right to left"), NULL },
|
|
{ GIMP_TEXT_DIRECTION_TTB_RTL, NC_("text-direction", "Vertical, right to left (mixed orientation)"), NULL },
|
|
{ GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT, NC_("text-direction", "Vertical, right to left (upright orientation)"), NULL },
|
|
{ GIMP_TEXT_DIRECTION_TTB_LTR, NC_("text-direction", "Vertical, left to right (mixed orientation)"), NULL },
|
|
{ GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT, NC_("text-direction", "Vertical, left to right (upright orientation)"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpTextDirection", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "text-direction");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_text_hint_style_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_TEXT_HINT_STYLE_NONE, "GIMP_TEXT_HINT_STYLE_NONE", "none" },
|
|
{ GIMP_TEXT_HINT_STYLE_SLIGHT, "GIMP_TEXT_HINT_STYLE_SLIGHT", "slight" },
|
|
{ GIMP_TEXT_HINT_STYLE_MEDIUM, "GIMP_TEXT_HINT_STYLE_MEDIUM", "medium" },
|
|
{ GIMP_TEXT_HINT_STYLE_FULL, "GIMP_TEXT_HINT_STYLE_FULL", "full" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_TEXT_HINT_STYLE_NONE, NC_("text-hint-style", "None"), NULL },
|
|
{ GIMP_TEXT_HINT_STYLE_SLIGHT, NC_("text-hint-style", "Slight"), NULL },
|
|
{ GIMP_TEXT_HINT_STYLE_MEDIUM, NC_("text-hint-style", "Medium"), NULL },
|
|
{ GIMP_TEXT_HINT_STYLE_FULL, NC_("text-hint-style", "Full"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpTextHintStyle", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "text-hint-style");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_text_justification_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_TEXT_JUSTIFY_LEFT, "GIMP_TEXT_JUSTIFY_LEFT", "left" },
|
|
{ GIMP_TEXT_JUSTIFY_RIGHT, "GIMP_TEXT_JUSTIFY_RIGHT", "right" },
|
|
{ GIMP_TEXT_JUSTIFY_CENTER, "GIMP_TEXT_JUSTIFY_CENTER", "center" },
|
|
{ GIMP_TEXT_JUSTIFY_FILL, "GIMP_TEXT_JUSTIFY_FILL", "fill" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_TEXT_JUSTIFY_LEFT, NC_("text-justification", "Left justified"), NULL },
|
|
{ GIMP_TEXT_JUSTIFY_RIGHT, NC_("text-justification", "Right justified"), NULL },
|
|
{ GIMP_TEXT_JUSTIFY_CENTER, NC_("text-justification", "Centered"), NULL },
|
|
{ GIMP_TEXT_JUSTIFY_FILL, NC_("text-justification", "Filled"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpTextJustification", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "text-justification");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_transfer_mode_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_TRANSFER_SHADOWS, "GIMP_TRANSFER_SHADOWS", "shadows" },
|
|
{ GIMP_TRANSFER_MIDTONES, "GIMP_TRANSFER_MIDTONES", "midtones" },
|
|
{ GIMP_TRANSFER_HIGHLIGHTS, "GIMP_TRANSFER_HIGHLIGHTS", "highlights" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_TRANSFER_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
|
|
{ GIMP_TRANSFER_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
|
|
{ GIMP_TRANSFER_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpTransferMode", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "transfer-mode");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_transform_direction_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_TRANSFORM_FORWARD, "GIMP_TRANSFORM_FORWARD", "forward" },
|
|
{ GIMP_TRANSFORM_BACKWARD, "GIMP_TRANSFORM_BACKWARD", "backward" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_TRANSFORM_FORWARD, NC_("transform-direction", "Normal (Forward)"), NULL },
|
|
{ GIMP_TRANSFORM_BACKWARD, NC_("transform-direction", "Corrective (Backward)"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpTransformDirection", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "transform-direction");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
GType
|
|
gimp_transform_resize_get_type (void)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_TRANSFORM_RESIZE_ADJUST, "GIMP_TRANSFORM_RESIZE_ADJUST", "adjust" },
|
|
{ GIMP_TRANSFORM_RESIZE_CLIP, "GIMP_TRANSFORM_RESIZE_CLIP", "clip" },
|
|
{ GIMP_TRANSFORM_RESIZE_CROP, "GIMP_TRANSFORM_RESIZE_CROP", "crop" },
|
|
{ GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, "GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT", "crop-with-aspect" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_TRANSFORM_RESIZE_ADJUST, NC_("transform-resize", "Adjust"), NULL },
|
|
{ GIMP_TRANSFORM_RESIZE_CLIP, NC_("transform-resize", "Clip"), NULL },
|
|
{ GIMP_TRANSFORM_RESIZE_CROP, NC_("transform-resize", "Crop to result"), NULL },
|
|
{ GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT, NC_("transform-resize", "Crop with aspect"), NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpTransformResize", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "transform-resize");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
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)
|
|
{
|
|
static const GEnumValue values[] =
|
|
{
|
|
{ GIMP_VECTORS_STROKE_TYPE_BEZIER, "GIMP_VECTORS_STROKE_TYPE_BEZIER", "bezier" },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static const GimpEnumDesc descs[] =
|
|
{
|
|
{ GIMP_VECTORS_STROKE_TYPE_BEZIER, "GIMP_VECTORS_STROKE_TYPE_BEZIER", NULL },
|
|
{ 0, NULL, NULL }
|
|
};
|
|
|
|
static GType type = 0;
|
|
|
|
if (G_UNLIKELY (! type))
|
|
{
|
|
type = g_enum_register_static ("GimpVectorsStrokeType", values);
|
|
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
|
|
gimp_type_set_translation_context (type, "vectors-stroke-type");
|
|
gimp_enum_set_value_descriptions (type, descs);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
|
|
/* Generated data ends here */
|
|
|