GType
gimp_cursor_format_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CURSOR_FORMAT_BITMAP, "GIMP_CURSOR_FORMAT_BITMAP", "bitmap" },
{ GIMP_CURSOR_FORMAT_PIXBUF, "GIMP_CURSOR_FORMAT_PIXBUF", "pixbuf" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CURSOR_FORMAT_BITMAP, N_("Black & white"), NULL },
{ GIMP_CURSOR_FORMAT_PIXBUF, N_("Fancy"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpCursorFormat", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_size_entry_update_policy_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_SIZE_ENTRY_UPDATE_NONE, "GIMP_SIZE_ENTRY_UPDATE_NONE", "none" },
{ GIMP_SIZE_ENTRY_UPDATE_SIZE, "GIMP_SIZE_ENTRY_UPDATE_SIZE", "size" },
{ GIMP_SIZE_ENTRY_UPDATE_RESOLUTION, "GIMP_SIZE_ENTRY_UPDATE_RESOLUTION", "resolution" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_SIZE_ENTRY_UPDATE_NONE, "GIMP_SIZE_ENTRY_UPDATE_NONE", NULL },
{ GIMP_SIZE_ENTRY_UPDATE_SIZE, "GIMP_SIZE_ENTRY_UPDATE_SIZE", NULL },
{ GIMP_SIZE_ENTRY_UPDATE_RESOLUTION, "GIMP_SIZE_ENTRY_UPDATE_RESOLUTION", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpSizeEntryUpdatePolicy", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "size-entry-update-policy");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_chain_position_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CHAIN_TOP, "GIMP_CHAIN_TOP", "top" },
{ GIMP_CHAIN_LEFT, "GIMP_CHAIN_LEFT", "left" },
{ GIMP_CHAIN_BOTTOM, "GIMP_CHAIN_BOTTOM", "bottom" },
{ GIMP_CHAIN_RIGHT, "GIMP_CHAIN_RIGHT", "right" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CHAIN_TOP, "GIMP_CHAIN_TOP", NULL },
{ GIMP_CHAIN_LEFT, "GIMP_CHAIN_LEFT", NULL },
{ GIMP_CHAIN_BOTTOM, "GIMP_CHAIN_BOTTOM", NULL },
{ GIMP_CHAIN_RIGHT, "GIMP_CHAIN_RIGHT", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpChainPosition", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "chain-position");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_convert_dither_type_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, NC_("convert-dither-type", "None"), NULL },
{ GIMP_FS_DITHER, NC_("convert-dither-type", "Floyd-Steinberg (normal)"), NULL },
{ GIMP_FSLOWBLEED_DITHER, NC_("convert-dither-type", "Floyd-Steinberg (reduced color bleeding)"), NULL },
{ GIMP_FIXED_DITHER, NC_("convert-dither-type", "Positioned"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpConvertDitherType", values);
gimp_type_set_translation_context (type, "convert-dither-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
/* enumerations from "./gimpwidgetsenums.h" */
GType
gimp_aspect_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ASPECT_SQUARE, "GIMP_ASPECT_SQUARE", "square" },
{ GIMP_ASPECT_PORTRAIT, "GIMP_ASPECT_PORTRAIT", "portrait" },
{ GIMP_ASPECT_LANDSCAPE, "GIMP_ASPECT_LANDSCAPE", "landscape" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ASPECT_SQUARE, NC_("aspect-type", "Square"), NULL },
{ GIMP_ASPECT_PORTRAIT, NC_("aspect-type", "Portrait"), NULL },
{ GIMP_ASPECT_LANDSCAPE, NC_("aspect-type", "Landscape"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpAspectType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "aspect-type");
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_context (type, "cap-style");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_view_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_VIEW_TYPE_LIST, "GIMP_VIEW_TYPE_LIST", "list" },
{ GIMP_VIEW_TYPE_GRID, "GIMP_VIEW_TYPE_GRID", "grid" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_VIEW_TYPE_LIST, NC_("view-type", "View as list"), NULL },
{ GIMP_VIEW_TYPE_GRID, NC_("view-type", "View as grid"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpViewType", values);
gimp_type_set_translation_context (type, "view-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_gradient_color_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_GRADIENT_COLOR_FIXED, "GIMP_GRADIENT_COLOR_FIXED", "fixed" },
{ GIMP_GRADIENT_COLOR_FOREGROUND, "GIMP_GRADIENT_COLOR_FOREGROUND", "foreground" },
{ GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT", "foreground-transparent" },
{ GIMP_GRADIENT_COLOR_BACKGROUND, "GIMP_GRADIENT_COLOR_BACKGROUND", "background" },
{ GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT", "background-transparent" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_GRADIENT_COLOR_FIXED, "GIMP_GRADIENT_COLOR_FIXED", NULL },
{ GIMP_GRADIENT_COLOR_FOREGROUND, "GIMP_GRADIENT_COLOR_FOREGROUND", NULL },
{ GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_FOREGROUND_TRANSPARENT", NULL },
{ GIMP_GRADIENT_COLOR_BACKGROUND, "GIMP_GRADIENT_COLOR_BACKGROUND", NULL },
{ GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, "GIMP_GRADIENT_COLOR_BACKGROUND_TRANSPARENT", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpGradientColor", values);
gimp_type_set_translation_context (type, "gradient-color");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_convolution_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_NORMAL_CONVOL, "GIMP_NORMAL_CONVOL", "normal-convol" },
{ GIMP_ABSOLUTE_CONVOL, "GIMP_ABSOLUTE_CONVOL", "absolute-convol" },
{ GIMP_NEGATIVE_CONVOL, "GIMP_NEGATIVE_CONVOL", "negative-convol" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_NORMAL_CONVOL, "GIMP_NORMAL_CONVOL", NULL },
{ GIMP_ABSOLUTE_CONVOL, "GIMP_ABSOLUTE_CONVOL", NULL },
{ GIMP_NEGATIVE_CONVOL, "GIMP_NEGATIVE_CONVOL", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpConvolutionType", values);
gimp_type_set_translation_context (type, "convolution-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_color_dialog_state_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_DIALOG_OK, "GIMP_COLOR_DIALOG_OK", "ok" },
{ GIMP_COLOR_DIALOG_CANCEL, "GIMP_COLOR_DIALOG_CANCEL", "cancel" },
{ GIMP_COLOR_DIALOG_UPDATE, "GIMP_COLOR_DIALOG_UPDATE", "update" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_DIALOG_OK, "GIMP_COLOR_DIALOG_OK", NULL },
{ GIMP_COLOR_DIALOG_CANCEL, "GIMP_COLOR_DIALOG_CANCEL", NULL },
{ GIMP_COLOR_DIALOG_UPDATE, "GIMP_COLOR_DIALOG_UPDATE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpColorDialogState", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_color_frame_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_FRAME_MODE_PIXEL, "GIMP_COLOR_FRAME_MODE_PIXEL", "pixel" },
{ GIMP_COLOR_FRAME_MODE_RGB, "GIMP_COLOR_FRAME_MODE_RGB", "rgb" },
{ GIMP_COLOR_FRAME_MODE_HSV, "GIMP_COLOR_FRAME_MODE_HSV", "hsv" },
{ GIMP_COLOR_FRAME_MODE_CMYK, "GIMP_COLOR_FRAME_MODE_CMYK", "cmyk" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_FRAME_MODE_PIXEL, N_("Pixel"), NULL },
{ GIMP_COLOR_FRAME_MODE_RGB, N_("RGB"), NULL },
{ GIMP_COLOR_FRAME_MODE_HSV, N_("HSV"), NULL },
{ GIMP_COLOR_FRAME_MODE_CMYK, N_("CMYK"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpColorFrameMode", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_window_hint_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_WINDOW_HINT_NORMAL, "GIMP_WINDOW_HINT_NORMAL", "normal" },
{ GIMP_WINDOW_HINT_UTILITY, "GIMP_WINDOW_HINT_UTILITY", "utility" },
{ GIMP_WINDOW_HINT_KEEP_ABOVE, "GIMP_WINDOW_HINT_KEEP_ABOVE", "keep-above" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_WINDOW_HINT_NORMAL, N_("Normal window"), NULL },
{ GIMP_WINDOW_HINT_UTILITY, N_("Utility window"), NULL },
{ GIMP_WINDOW_HINT_KEEP_ABOVE, N_("Keep above"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpWindowHint", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_histogram_scale_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_HISTOGRAM_SCALE_LINEAR, "GIMP_HISTOGRAM_SCALE_LINEAR", "linear" },
{ GIMP_HISTOGRAM_SCALE_LOGARITHMIC, "GIMP_HISTOGRAM_SCALE_LOGARITHMIC", "logarithmic" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_HISTOGRAM_SCALE_LINEAR, N_("Linear"), NULL },
{ GIMP_HISTOGRAM_SCALE_LOGARITHMIC, N_("Logarithmic"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpHistogramScale", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_help_browser_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_HELP_BROWSER_GIMP, "GIMP_HELP_BROWSER_GIMP", "gimp" },
{ GIMP_HELP_BROWSER_WEB_BROWSER, "GIMP_HELP_BROWSER_WEB_BROWSER", "web-browser" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_HELP_BROWSER_GIMP, N_("GIMP help browser"), NULL },
{ GIMP_HELP_BROWSER_WEB_BROWSER, N_("Web browser"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpHelpBrowserType", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_stroke_method_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_STROKE_METHOD_LIBART, "GIMP_STROKE_METHOD_LIBART", "libart" },
{ GIMP_STROKE_METHOD_PAINT_CORE, "GIMP_STROKE_METHOD_PAINT_CORE", "paint-core" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_STROKE_METHOD_LIBART, NC_("stroke-method", "Stroke line"), NULL },
{ GIMP_STROKE_METHOD_PAINT_CORE, 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_context (type, "stroke-method");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_message_severity_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_MESSAGE_INFO, "GIMP_MESSAGE_INFO", "info" },
{ GIMP_MESSAGE_WARNING, "GIMP_MESSAGE_WARNING", "warning" },
{ GIMP_MESSAGE_ERROR, "GIMP_MESSAGE_ERROR", "error" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_MESSAGE_INFO, NC_("message-severity", "Message"), NULL },
{ GIMP_MESSAGE_WARNING, NC_("message-severity", "Warning"), NULL },
{ GIMP_MESSAGE_ERROR, NC_("message-severity", "Error"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpMessageSeverity", values);
gimp_type_set_translation_context (type, "message-severity");
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_context (type, "join-style");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_color_profile_policy_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_PROFILE_POLICY_ASK, "GIMP_COLOR_PROFILE_POLICY_ASK", "ask" },
{ GIMP_COLOR_PROFILE_POLICY_KEEP, "GIMP_COLOR_PROFILE_POLICY_KEEP", "keep" },
{ GIMP_COLOR_PROFILE_POLICY_CONVERT, "GIMP_COLOR_PROFILE_POLICY_CONVERT", "convert" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_PROFILE_POLICY_ASK, NC_("color-profile-policy", "Ask what to do"), NULL },
{ GIMP_COLOR_PROFILE_POLICY_KEEP, NC_("color-profile-policy", "Keep embedded profile"), NULL },
{ GIMP_COLOR_PROFILE_POLICY_CONVERT, NC_("color-profile-policy", "Convert to RGB workspace"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpColorProfilePolicy", values);
gimp_type_set_translation_context (type, "color-profile-policy");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_item_set_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ITEM_SET_NONE, "GIMP_ITEM_SET_NONE", "none" },
{ GIMP_ITEM_SET_ALL, "GIMP_ITEM_SET_ALL", "all" },
{ GIMP_ITEM_SET_IMAGE_SIZED, "GIMP_ITEM_SET_IMAGE_SIZED", "image-sized" },
{ GIMP_ITEM_SET_VISIBLE, "GIMP_ITEM_SET_VISIBLE", "visible" },
{ GIMP_ITEM_SET_LINKED, "GIMP_ITEM_SET_LINKED", "linked" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ITEM_SET_NONE, NC_("item-set", "None"), NULL },
{ GIMP_ITEM_SET_ALL, NC_("item-set", "All layers"), NULL },
{ GIMP_ITEM_SET_IMAGE_SIZED, NC_("item-set", "Image-sized layers"), NULL },
{ GIMP_ITEM_SET_VISIBLE, NC_("item-set", "All visible layers"), NULL },
{ GIMP_ITEM_SET_LINKED, NC_("item-set", "All linked layers"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpItemSet", values);
gimp_type_set_translation_context (type, "item-set");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_image_map_region_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_IMAGE_MAP_REGION_SELECTION, "GIMP_IMAGE_MAP_REGION_SELECTION", "selection" },
{ GIMP_IMAGE_MAP_REGION_DRAWABLE, "GIMP_IMAGE_MAP_REGION_DRAWABLE", "drawable" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_IMAGE_MAP_REGION_SELECTION, NC_("image-map-region", "Use the selection as input"), NULL },
{ GIMP_IMAGE_MAP_REGION_DRAWABLE, NC_("image-map-region", "Use the entire layer as input"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpImageMapRegion", values);
gimp_type_set_translation_context (type, "image-map-region");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_thumbnail_size_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_THUMBNAIL_SIZE_NONE, "GIMP_THUMBNAIL_SIZE_NONE", "none" },
{ GIMP_THUMBNAIL_SIZE_NORMAL, "GIMP_THUMBNAIL_SIZE_NORMAL", "normal" },
{ GIMP_THUMBNAIL_SIZE_LARGE, "GIMP_THUMBNAIL_SIZE_LARGE", "large" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_THUMBNAIL_SIZE_NONE, NC_("thumbnail-size", "No thumbnails"), NULL },
{ GIMP_THUMBNAIL_SIZE_NORMAL, NC_("thumbnail-size", "Normal (128x128)"), NULL },
{ GIMP_THUMBNAIL_SIZE_LARGE, NC_("thumbnail-size", "Large (256x256)"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpThumbnailSize", values);
gimp_type_set_translation_context (type, "thumbnail-size");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_curve_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CURVE_SMOOTH, "GIMP_CURVE_SMOOTH", "smooth" },
{ GIMP_CURVE_FREE, "GIMP_CURVE_FREE", "free" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CURVE_SMOOTH, NC_("curve-type", "Smooth"), NULL },
{ GIMP_CURVE_FREE, NC_("curve-type", "Freehand"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpCurveType", values);
gimp_type_set_translation_context (type, "curve-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_undo_mode_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_UNDO_MODE_UNDO, "GIMP_UNDO_MODE_UNDO", "undo" },
{ GIMP_UNDO_MODE_REDO, "GIMP_UNDO_MODE_REDO", "redo" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_UNDO_MODE_UNDO, "GIMP_UNDO_MODE_UNDO", NULL },
{ GIMP_UNDO_MODE_REDO, "GIMP_UNDO_MODE_REDO", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpUndoMode", values);
gimp_type_set_translation_context (type, "undo-mode");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_matting_engine_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_MATTING_ENGINE_GLOBAL, "GIMP_MATTING_ENGINE_GLOBAL", "global" },
{ GIMP_MATTING_ENGINE_LEVIN, "GIMP_MATTING_ENGINE_LEVIN", "levin" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_MATTING_ENGINE_GLOBAL, NC_("matting-engine", "Matting Global"), NULL },
{ GIMP_MATTING_ENGINE_LEVIN, NC_("matting-engine", "Matting Levin"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpMattingEngine", values);
gimp_type_set_translation_context (type, "matting-engine");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_page_selector_target_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_PAGE_SELECTOR_TARGET_LAYERS, "GIMP_PAGE_SELECTOR_TARGET_LAYERS", "layers" },
{ GIMP_PAGE_SELECTOR_TARGET_IMAGES, "GIMP_PAGE_SELECTOR_TARGET_IMAGES", "images" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_PAGE_SELECTOR_TARGET_LAYERS, NC_("page-selector-target", "Layers"), NULL },
{ GIMP_PAGE_SELECTOR_TARGET_IMAGES, NC_("page-selector-target", "Images"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpPageSelectorTarget", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "page-selector-target");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_fill_style_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_FILL_STYLE_SOLID, "GIMP_FILL_STYLE_SOLID", "solid" },
{ GIMP_FILL_STYLE_PATTERN, "GIMP_FILL_STYLE_PATTERN", "pattern" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_FILL_STYLE_SOLID, NC_("fill-style", "Solid color"), NULL },
{ GIMP_FILL_STYLE_PATTERN, NC_("fill-style", "Pattern"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpFillStyle", values);
gimp_type_set_translation_context (type, "fill-style");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_zoom_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_ZOOM_IN, "GIMP_ZOOM_IN", "in" },
{ GIMP_ZOOM_OUT, "GIMP_ZOOM_OUT", "out" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_ZOOM_IN, NC_("zoom-type", "Zoom in"), NULL },
{ GIMP_ZOOM_OUT, NC_("zoom-type", "Zoom out"), NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpZoomType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "zoom-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_container_policy_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_CONTAINER_POLICY_STRONG, "GIMP_CONTAINER_POLICY_STRONG", "strong" },
{ GIMP_CONTAINER_POLICY_WEAK, "GIMP_CONTAINER_POLICY_WEAK", "weak" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_CONTAINER_POLICY_STRONG, "GIMP_CONTAINER_POLICY_STRONG", NULL },
{ GIMP_CONTAINER_POLICY_WEAK, "GIMP_CONTAINER_POLICY_WEAK", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpContainerPolicy", values);
gimp_type_set_translation_context (type, "container-policy");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_color_area_type_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_AREA_FLAT, "GIMP_COLOR_AREA_FLAT", "flat" },
{ GIMP_COLOR_AREA_SMALL_CHECKS, "GIMP_COLOR_AREA_SMALL_CHECKS", "small-checks" },
{ GIMP_COLOR_AREA_LARGE_CHECKS, "GIMP_COLOR_AREA_LARGE_CHECKS", "large-checks" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_AREA_FLAT, "GIMP_COLOR_AREA_FLAT", NULL },
{ GIMP_COLOR_AREA_SMALL_CHECKS, "GIMP_COLOR_AREA_SMALL_CHECKS", NULL },
{ GIMP_COLOR_AREA_LARGE_CHECKS, "GIMP_COLOR_AREA_LARGE_CHECKS", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (G_UNLIKELY (! type))
{
type = g_enum_register_static ("GimpColorAreaType", values);
gimp_type_set_translation_domain (type, GETTEXT_PACKAGE "-libgimp");
gimp_type_set_translation_context (type, "color-area-type");
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
GType
gimp_color_pick_state_get_type (void)
{
static const GEnumValue values[] =
{
{ GIMP_COLOR_PICK_STATE_NEW, "GIMP_COLOR_PICK_STATE_NEW", "new" },
{ GIMP_COLOR_PICK_STATE_UPDATE, "GIMP_COLOR_PICK_STATE_UPDATE", "update" },
{ 0, NULL, NULL }
};
static const GimpEnumDesc descs[] =
{
{ GIMP_COLOR_PICK_STATE_NEW, "GIMP_COLOR_PICK_STATE_NEW", NULL },
{ GIMP_COLOR_PICK_STATE_UPDATE, "GIMP_COLOR_PICK_STATE_UPDATE", NULL },
{ 0, NULL, NULL }
};
static GType type = 0;
if (! type)
{
type = g_enum_register_static ("GimpColorPickState", values);
gimp_enum_set_value_descriptions (type, descs);
}
return type;
}
