graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-24 05:22:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
gimp/app/core/core-enums.c
Michael Natterer be70105d3b Moved the undo system to the core: Keep GimpUndoStack objects as undo and 
2003-02-12  Michael Natterer  <mitch@gimp.org>

	Moved the undo system to the core: Keep GimpUndoStack objects as
	undo and redo stack. Use GimpUndo objects as members of the
	stacks. GimpUndoStack is derived from GimpUndo and keeps undo
	groups, so undo group handling is much simpler than before
	(the whole group is just a single GimpUndo object on the
	stack and not everything between group boundary markers).

	* app/Makefile.am
	* app/undo_types.h: removed.

	* app/config/gimpcoreconfig.[ch]: added "gulong undo_size".
	* app/config/gimprc-blurbs.h: and its blurb.

	* app/core/core-enums.[ch]: added GimpUndoMode and GimpUndoType.

	* app/core/core-types.h: removed UndoType, added GimpUndoAccumulator,
	GimpUndoPopFunc and GimpUndoFreeFunc.

	* app/core/gimpundo.[ch]: do everything the old "Undo" struct did.
	Removed the virtual push() function and added free().

	* app/core/gimpundostack.[ch]: keeps the new undo/redo stacks
	and also acts as undo group.

	* app/core/gimpimage-undo.[ch]: moved the undo apparatus here.

	* app/core/gimpimage.[ch]: removed the old stuff.

	* app/core/gimpmarshal.list: added marshaller needed for GimpUndo.

	* app/undo.[ch]: removed the whole undo mechanism. Only the
	actual undo pushing functions are left.

	* app/undo_history.c
	* app/gui/edit-commands.c
	* app/gui/file-commands.c
	* app/gui/image-menu.c
	* app/gui/preferences-dialog.c
	* app/tools/gimpeditselectiontool.c: changed accordingly.
2003-02-12 17:11:34 +00:00

526 lines
16 KiB
C
Raw Blame History

/* Generated data (by gimp-mkenums) */
#include "config.h"
#include <glib-object.h>
#include "core-enums.h"
#include "libgimp/gimpintl.h"
/* enumerations from "./core-enums.h" */
static const GEnumValue gimp_orientation_type_enum_values[] =
{
{ GIMP_ORIENTATION_HORIZONTAL, N_("Horizontal"), "horizontal" },
{ GIMP_ORIENTATION_VERTICAL, N_("Vertical"), "vertical" },
{ GIMP_ORIENTATION_UNKNOWN, N_("Unknown"), "unknown" },
{ 0, NULL, NULL }
};
GType
gimp_orientation_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpOrientationType", gimp_orientation_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_blend_mode_enum_values[] =
{
{ GIMP_FG_BG_RGB_MODE, N_("FG to BG (RGB)"), "fg-bg-rgb-mode" },
{ GIMP_FG_BG_HSV_MODE, N_("FG to BG (HSV)"), "fg-bg-hsv-mode" },
{ GIMP_FG_TRANSPARENT_MODE, N_("FG to Transparent"), "fg-transparent-mode" },
{ GIMP_CUSTOM_MODE, N_("Custom Gradient"), "custom-mode" },
{ 0, NULL, NULL }
};
GType
gimp_blend_mode_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpBlendMode", gimp_blend_mode_enum_values);
return enum_type;
}
static const GEnumValue gimp_bucket_fill_mode_enum_values[] =
{
{ GIMP_FG_BUCKET_FILL, N_("FG Color Fill"), "fg-bucket-fill" },
{ GIMP_BG_BUCKET_FILL, N_("BG Color Fill"), "bg-bucket-fill" },
{ GIMP_PATTERN_BUCKET_FILL, N_("Pattern Fill"), "pattern-bucket-fill" },
{ 0, NULL, NULL }
};
GType
gimp_bucket_fill_mode_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpBucketFillMode", gimp_bucket_fill_mode_enum_values);
return enum_type;
}
static const GEnumValue gimp_channel_type_enum_values[] =
{
{ GIMP_RED_CHANNEL, "GIMP_RED_CHANNEL", "red-channel" },
{ GIMP_GREEN_CHANNEL, "GIMP_GREEN_CHANNEL", "green-channel" },
{ GIMP_BLUE_CHANNEL, "GIMP_BLUE_CHANNEL", "blue-channel" },
{ GIMP_GRAY_CHANNEL, "GIMP_GRAY_CHANNEL", "gray-channel" },
{ GIMP_INDEXED_CHANNEL, "GIMP_INDEXED_CHANNEL", "indexed-channel" },
{ GIMP_ALPHA_CHANNEL, "GIMP_ALPHA_CHANNEL", "alpha-channel" },
{ 0, NULL, NULL }
};
GType
gimp_channel_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpChannelType", gimp_channel_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_convert_dither_type_enum_values[] =
{
{ GIMP_NO_DITHER, N_("No Color Dithering"), "no-dither" },
{ GIMP_FS_DITHER, N_("Floyd-Steinberg Color Dithering (Normal)"), "fs-dither" },
{ GIMP_FSLOWBLEED_DITHER, N_("Floyd-Steinberg Color Dithering (Reduced Color Bleeding)"), "fslowbleed-dither" },
{ GIMP_FIXED_DITHER, N_("Positioned Color Dithering"), "fixed-dither" },
{ 0, NULL, NULL }
};
GType
gimp_convert_dither_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpConvertDitherType", gimp_convert_dither_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_gravity_type_enum_values[] =
{
{ GIMP_GRAVITY_NONE, "GIMP_GRAVITY_NONE", "none" },
{ GIMP_GRAVITY_NORTH_WEST, "GIMP_GRAVITY_NORTH_WEST", "north-west" },
{ GIMP_GRAVITY_NORTH, "GIMP_GRAVITY_NORTH", "north" },
{ GIMP_GRAVITY_NORTH_EAST, "GIMP_GRAVITY_NORTH_EAST", "north-east" },
{ GIMP_GRAVITY_WEST, "GIMP_GRAVITY_WEST", "west" },
{ GIMP_GRAVITY_CENTER, "GIMP_GRAVITY_CENTER", "center" },
{ GIMP_GRAVITY_EAST, "GIMP_GRAVITY_EAST", "east" },
{ GIMP_GRAVITY_SOUTH_WEST, "GIMP_GRAVITY_SOUTH_WEST", "south-west" },
{ GIMP_GRAVITY_SOUTH, "GIMP_GRAVITY_SOUTH", "south" },
{ GIMP_GRAVITY_SOUTH_EAST, "GIMP_GRAVITY_SOUTH_EAST", "south-east" },
{ 0, NULL, NULL }
};
GType
gimp_gravity_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpGravityType", gimp_gravity_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_fill_type_enum_values[] =
{
{ GIMP_FOREGROUND_FILL, N_("Foreground"), "foreground-fill" },
{ GIMP_BACKGROUND_FILL, N_("Background"), "background-fill" },
{ GIMP_WHITE_FILL, N_("White"), "white-fill" },
{ GIMP_TRANSPARENT_FILL, N_("Transparent"), "transparent-fill" },
{ GIMP_NO_FILL, N_("None"), "no-fill" },
{ 0, NULL, NULL }
};
GType
gimp_fill_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpFillType", gimp_fill_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_gradient_type_enum_values[] =
{
{ GIMP_LINEAR, N_("Linear"), "linear" },
{ GIMP_BILINEAR, N_("Bi-Linear"), "bilinear" },
{ GIMP_RADIAL, N_("Radial"), "radial" },
{ GIMP_SQUARE, N_("Square"), "square" },
{ GIMP_CONICAL_SYMMETRIC, N_("Conical (symmetric)"), "conical-symmetric" },
{ GIMP_CONICAL_ASYMMETRIC, N_("Conical (asymmetric)"), "conical-asymmetric" },
{ GIMP_SHAPEBURST_ANGULAR, N_("Shapeburst (angular)"), "shapeburst-angular" },
{ GIMP_SHAPEBURST_SPHERICAL, N_("Shapeburst (spherical)"), "shapeburst-spherical" },
{ GIMP_SHAPEBURST_DIMPLED, N_("Shapeburst (dimpled)"), "shapeburst-dimpled" },
{ GIMP_SPIRAL_CLOCKWISE, N_("Spiral (clockwise)"), "spiral-clockwise" },
{ GIMP_SPIRAL_ANTICLOCKWISE, N_("Spiral (anticlockwise)"), "spiral-anticlockwise" },
{ 0, NULL, NULL }
};
GType
gimp_gradient_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpGradientType", gimp_gradient_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_image_base_type_enum_values[] =
{
{ GIMP_RGB, N_("RGB"), "rgb" },
{ GIMP_GRAY, N_("Grayscale"), "gray" },
{ GIMP_INDEXED, N_("Indexed"), "indexed" },
{ 0, NULL, NULL }
};
GType
gimp_image_base_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpImageBaseType", gimp_image_base_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_image_type_enum_values[] =
{
{ GIMP_RGB_IMAGE, N_("RGB"), "rgb-image" },
{ GIMP_RGBA_IMAGE, N_("RGB-Alpha"), "rgba-image" },
{ GIMP_GRAY_IMAGE, N_("Grayscale"), "gray-image" },
{ GIMP_GRAYA_IMAGE, N_("Grayscale-Alpha"), "graya-image" },
{ GIMP_INDEXED_IMAGE, N_("Indexed"), "indexed-image" },
{ GIMP_INDEXEDA_IMAGE, N_("Indexed-Alpha"), "indexeda-image" },
{ 0, NULL, NULL }
};
GType
gimp_image_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpImageType", gimp_image_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_preview_size_enum_values[] =
{
{ GIMP_PREVIEW_SIZE_NONE, N_("None"), "none" },
{ GIMP_PREVIEW_SIZE_TINY, N_("Tiny"), "tiny" },
{ GIMP_PREVIEW_SIZE_EXTRA_SMALL, N_("Very Small"), "extra-small" },
{ GIMP_PREVIEW_SIZE_SMALL, N_("Small"), "small" },
{ GIMP_PREVIEW_SIZE_MEDIUM, N_("Medium"), "medium" },
{ GIMP_PREVIEW_SIZE_LARGE, N_("Large"), "large" },
{ GIMP_PREVIEW_SIZE_EXTRA_LARGE, N_("Very Large"), "extra-large" },
{ GIMP_PREVIEW_SIZE_HUGE, N_("Huge"), "huge" },
{ GIMP_PREVIEW_SIZE_ENORMOUS, N_("Enormous"), "enormous" },
{ GIMP_PREVIEW_SIZE_GIGANTIC, N_("Gigantic"), "gigantic" },
{ 0, NULL, NULL }
};
GType
gimp_preview_size_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpPreviewSize", gimp_preview_size_enum_values);
return enum_type;
}
static const GEnumValue gimp_repeat_mode_enum_values[] =
{
{ GIMP_REPEAT_NONE, N_("None"), "none" },
{ GIMP_REPEAT_SAWTOOTH, N_("Sawtooth Wave"), "sawtooth" },
{ GIMP_REPEAT_TRIANGULAR, N_("Triangular Wave"), "triangular" },
{ 0, NULL, NULL }
};
GType
gimp_repeat_mode_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpRepeatMode", gimp_repeat_mode_enum_values);
return enum_type;
}
static const GEnumValue gimp_selection_control_enum_values[] =
{
{ GIMP_SELECTION_OFF, "GIMP_SELECTION_OFF", "off" },
{ GIMP_SELECTION_LAYER_OFF, "GIMP_SELECTION_LAYER_OFF", "layer-off" },
{ GIMP_SELECTION_ON, "GIMP_SELECTION_ON", "on" },
{ GIMP_SELECTION_PAUSE, "GIMP_SELECTION_PAUSE", "pause" },
{ GIMP_SELECTION_RESUME, "GIMP_SELECTION_RESUME", "resume" },
{ 0, NULL, NULL }
};
GType
gimp_selection_control_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpSelectionControl", gimp_selection_control_enum_values);
return enum_type;
}
static const GEnumValue gimp_thumbnail_size_enum_values[] =
{
{ GIMP_THUMBNAIL_SIZE_NONE, N_("No Thumbnails"), "none" },
{ GIMP_THUMBNAIL_SIZE_NORMAL, N_("Normal (128x128)"), "normal" },
{ GIMP_THUMBNAIL_SIZE_LARGE, N_("Large (256x256)"), "large" },
{ 0, NULL, NULL }
};
GType
gimp_thumbnail_size_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpThumbnailSize", gimp_thumbnail_size_enum_values);
return enum_type;
}
static const GEnumValue gimp_transform_direction_enum_values[] =
{
{ GIMP_TRANSFORM_FORWARD, N_("Forward (Traditional)"), "forward" },
{ GIMP_TRANSFORM_BACKWARD, N_("Backward (Corrective)"), "backward" },
{ 0, NULL, NULL }
};
GType
gimp_transform_direction_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpTransformDirection", gimp_transform_direction_enum_values);
return enum_type;
}
static const GEnumValue gimp_channel_ops_enum_values[] =
{
{ GIMP_CHANNEL_OP_ADD, N_("Add to the current selection"), "add" },
{ GIMP_CHANNEL_OP_SUBTRACT, N_("Subtract from the current selection"), "subtract" },
{ GIMP_CHANNEL_OP_REPLACE, N_("Replace the current selection"), "replace" },
{ GIMP_CHANNEL_OP_INTERSECT, N_("Intersect with the current selection"), "intersect" },
{ 0, NULL, NULL }
};
GType
gimp_channel_ops_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpChannelOps", gimp_channel_ops_enum_values);
return enum_type;
}
static const GEnumValue gimp_undo_mode_enum_values[] =
{
{ GIMP_UNDO_MODE_UNDO, "GIMP_UNDO_MODE_UNDO", "undo" },
{ GIMP_UNDO_MODE_REDO, "GIMP_UNDO_MODE_REDO", "redo" },
{ 0, NULL, NULL }
};
GType
gimp_undo_mode_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpUndoMode", gimp_undo_mode_enum_values);
return enum_type;
}
static const GEnumValue gimp_undo_type_enum_values[] =
{
{ NO_UNDO_GROUP, N_("<<invalid>>"), "no-undo-group" },
{ FIRST_UNDO_GROUP, "FIRST_UNDO_GROUP", "first-undo-group" },
{ IMAGE_SCALE_UNDO_GROUP, N_("Scale Image"), "image-scale-undo-group" },
{ IMAGE_RESIZE_UNDO_GROUP, N_("Resize Image"), "image-resize-undo-group" },
{ IMAGE_CONVERT_UNDO_GROUP, N_("Convert Image"), "image-convert-undo-group" },
{ IMAGE_CROP_UNDO_GROUP, N_("Crop Image"), "image-crop-undo-group" },
{ IMAGE_LAYERS_MERGE_UNDO_GROUP, N_("Merge Layers"), "image-layers-merge-undo-group" },
{ IMAGE_QMASK_UNDO_GROUP, N_("QuickMask"), "image-qmask-undo-group" },
{ IMAGE_GUIDE_UNDO_GROUP, N_("Guide"), "image-guide-undo-group" },
{ LAYER_PROPERTIES_UNDO_GROUP, N_("Layer Properties"), "layer-properties-undo-group" },
{ LAYER_SCALE_UNDO_GROUP, N_("Scale Layer"), "layer-scale-undo-group" },
{ LAYER_RESIZE_UNDO_GROUP, N_("Resize Layer"), "layer-resize-undo-group" },
{ LAYER_DISPLACE_UNDO_GROUP, N_("Move Layer"), "layer-displace-undo-group" },
{ LAYER_LINKED_UNDO_GROUP, N_("Linked Layer"), "layer-linked-undo-group" },
{ LAYER_APPLY_MASK_UNDO_GROUP, N_("Apply Layer Mask"), "layer-apply-mask-undo-group" },
{ FS_FLOAT_UNDO_GROUP, N_("Float Selection"), "fs-float-undo-group" },
{ FS_ANCHOR_UNDO_GROUP, N_("Anchor Floating Selection"), "fs-anchor-undo-group" },
{ EDIT_PASTE_UNDO_GROUP, N_("Paste"), "edit-paste-undo-group" },
{ EDIT_CUT_UNDO_GROUP, N_("Cut"), "edit-cut-undo-group" },
{ EDIT_COPY_UNDO_GROUP, N_("Copy"), "edit-copy-undo-group" },
{ TEXT_UNDO_GROUP, N_("Text"), "text-undo-group" },
{ TRANSFORM_UNDO_GROUP, N_("Transform"), "transform-undo-group" },
{ PAINT_UNDO_GROUP, N_("Paint"), "paint-undo-group" },
{ PARASITE_ATTACH_UNDO_GROUP, N_("Attach Parasite"), "parasite-attach-undo-group" },
{ PARASITE_REMOVE_UNDO_GROUP, N_("Remove Parasite"), "parasite-remove-undo-group" },
{ MISC_UNDO_GROUP, N_("Plug-In"), "misc-undo-group" },
{ LAST_UNDO_GROUP, "LAST_UNDO_GROUP", "last-undo-group" },
{ IMAGE_UNDO, N_("Image"), "image-undo" },
{ IMAGE_MOD_UNDO, N_("Image Mod"), "image-mod-undo" },
{ IMAGE_TYPE_UNDO, N_("Image Type"), "image-type-undo" },
{ IMAGE_SIZE_UNDO, N_("Image Size"), "image-size-undo" },
{ IMAGE_RESOLUTION_UNDO, N_("Resolution Change"), "image-resolution-undo" },
{ IMAGE_QMASK_UNDO, N_("QuickMask"), "image-qmask-undo" },
{ IMAGE_GUIDE_UNDO, N_("Guide"), "image-guide-undo" },
{ MASK_UNDO, N_("Selection Mask"), "mask-undo" },
{ ITEM_RENAME_UNDO, N_("Rename Item"), "item-rename-undo" },
{ LAYER_ADD_UNDO, N_("New Layer"), "layer-add-undo" },
{ LAYER_REMOVE_UNDO, N_("Delete Layer"), "layer-remove-undo" },
{ LAYER_MOD_UNDO, N_("Layer Mod"), "layer-mod-undo" },
{ LAYER_MASK_ADD_UNDO, N_("Add Layer Mask"), "layer-mask-add-undo" },
{ LAYER_MASK_REMOVE_UNDO, N_("Delete Layer Mask"), "layer-mask-remove-undo" },
{ LAYER_REPOSITION_UNDO, N_("Layer Reposition"), "layer-reposition-undo" },
{ LAYER_DISPLACE_UNDO, N_("Layer Move"), "layer-displace-undo" },
{ CHANNEL_ADD_UNDO, N_("New Channel"), "channel-add-undo" },
{ CHANNEL_REMOVE_UNDO, N_("Delete Channel"), "channel-remove-undo" },
{ CHANNEL_MOD_UNDO, N_("Channel Mod"), "channel-mod-undo" },
{ CHANNEL_REPOSITION_UNDO, N_("Channel Reposition"), "channel-reposition-undo" },
{ VECTORS_ADD_UNDO, N_("New Vectors"), "vectors-add-undo" },
{ VECTORS_REMOVE_UNDO, N_("Delete Vectors"), "vectors-remove-undo" },
{ VECTORS_MOD_UNDO, N_("Vectors Mod"), "vectors-mod-undo" },
{ VECTORS_REPOSITION_UNDO, N_("Vectors Reposition"), "vectors-reposition-undo" },
{ FS_TO_LAYER_UNDO, N_("FS to Layer"), "fs-to-layer-undo" },
{ FS_RIGOR_UNDO, N_("FS Rigor"), "fs-rigor-undo" },
{ FS_RELAX_UNDO, N_("FS Relax"), "fs-relax-undo" },
{ TRANSFORM_UNDO, N_("Transform"), "transform-undo" },
{ PAINT_UNDO, N_("Paint"), "paint-undo" },
{ PARASITE_ATTACH_UNDO, N_("Attach Parasite"), "parasite-attach-undo" },
{ PARASITE_REMOVE_UNDO, N_("Remove Parasite"), "parasite-remove-undo" },
{ CANT_UNDO, N_("EEK: can't undo"), "cant-undo" },
{ 0, NULL, NULL }
};
GType
gimp_undo_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpUndoType", gimp_undo_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_convert_palette_type_enum_values[] =
{
{ GIMP_MAKE_PALETTE, "GIMP_MAKE_PALETTE", "make-palette" },
{ GIMP_REUSE_PALETTE, "GIMP_REUSE_PALETTE", "reuse-palette" },
{ GIMP_WEB_PALETTE, "GIMP_WEB_PALETTE", "web-palette" },
{ GIMP_MONO_PALETTE, "GIMP_MONO_PALETTE", "mono-palette" },
{ GIMP_CUSTOM_PALETTE, "GIMP_CUSTOM_PALETTE", "custom-palette" },
{ 0, NULL, NULL }
};
GType
gimp_convert_palette_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpConvertPaletteType", gimp_convert_palette_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_gradient_segment_type_enum_values[] =
{
{ GIMP_GRAD_LINEAR, "GIMP_GRAD_LINEAR", "linear" },
{ GIMP_GRAD_CURVED, "GIMP_GRAD_CURVED", "curved" },
{ GIMP_GRAD_SINE, "GIMP_GRAD_SINE", "sine" },
{ GIMP_GRAD_SPHERE_INCREASING, "GIMP_GRAD_SPHERE_INCREASING", "sphere-increasing" },
{ GIMP_GRAD_SPHERE_DECREASING, "GIMP_GRAD_SPHERE_DECREASING", "sphere-decreasing" },
{ 0, NULL, NULL }
};
GType
gimp_gradient_segment_type_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpGradientSegmentType", gimp_gradient_segment_type_enum_values);
return enum_type;
}
static const GEnumValue gimp_gradient_segment_color_enum_values[] =
{
{ GIMP_GRAD_RGB, "GIMP_GRAD_RGB", "rgb" },
{ GIMP_GRAD_HSV_CCW, "GIMP_GRAD_HSV_CCW", "hsv-ccw" },
{ GIMP_GRAD_HSV_CW, "GIMP_GRAD_HSV_CW", "hsv-cw" },
{ 0, NULL, NULL }
};
GType
gimp_gradient_segment_color_get_type (void)
{
static GType enum_type = 0;
if (!enum_type)
enum_type = g_enum_register_static ("GimpGradientSegmentColor", gimp_gradient_segment_color_enum_values);
return enum_type;
}
/* Generated data ends here */
Reference in a new issue View git blame Copy permalink