/* Generated data (by pika-mkenums) */

#include "stamp-core-enums.h"
#include "config.h"
#include <gio/gio.h>
#include "libpikabase/pikabase.h"
#include "core-enums.h"
#include "pika-intl.h"

/* enumerations from "core-enums.h" */
GType
pika_align_reference_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ALIGN_REFERENCE_IMAGE, "PIKA_ALIGN_REFERENCE_IMAGE", "image" },
    { PIKA_ALIGN_REFERENCE_SELECTION, "PIKA_ALIGN_REFERENCE_SELECTION", "selection" },
    { PIKA_ALIGN_REFERENCE_PICK, "PIKA_ALIGN_REFERENCE_PICK", "pick" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ALIGN_REFERENCE_IMAGE, NC_("align-reference-type", "Image"), NULL },
    { PIKA_ALIGN_REFERENCE_SELECTION, NC_("align-reference-type", "Selection"), NULL },
    { PIKA_ALIGN_REFERENCE_PICK, NC_("align-reference-type", "Picked reference object"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaAlignReferenceType", values);
      pika_type_set_translation_context (type, "align-reference-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_alignment_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ALIGN_LEFT, "PIKA_ALIGN_LEFT", "align-left" },
    { PIKA_ALIGN_HCENTER, "PIKA_ALIGN_HCENTER", "align-hcenter" },
    { PIKA_ALIGN_RIGHT, "PIKA_ALIGN_RIGHT", "align-right" },
    { PIKA_ALIGN_TOP, "PIKA_ALIGN_TOP", "align-top" },
    { PIKA_ALIGN_VCENTER, "PIKA_ALIGN_VCENTER", "align-vcenter" },
    { PIKA_ALIGN_BOTTOM, "PIKA_ALIGN_BOTTOM", "align-bottom" },
    { PIKA_ARRANGE_HFILL, "PIKA_ARRANGE_HFILL", "arrange-hfill" },
    { PIKA_ARRANGE_VFILL, "PIKA_ARRANGE_VFILL", "arrange-vfill" },
    { PIKA_DISTRIBUTE_EVEN_HORIZONTAL_GAP, "PIKA_DISTRIBUTE_EVEN_HORIZONTAL_GAP", "distribute-even-horizontal-gap" },
    { PIKA_DISTRIBUTE_EVEN_VERTICAL_GAP, "PIKA_DISTRIBUTE_EVEN_VERTICAL_GAP", "distribute-even-vertical-gap" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ALIGN_LEFT, NC_("alignment-type", "Align to the left"), NULL },
    { PIKA_ALIGN_HCENTER, NC_("alignment-type", "Center horizontally"), NULL },
    { PIKA_ALIGN_RIGHT, NC_("alignment-type", "Align to the right"), NULL },
    { PIKA_ALIGN_TOP, NC_("alignment-type", "Align to the top"), NULL },
    { PIKA_ALIGN_VCENTER, NC_("alignment-type", "Center vertically"), NULL },
    { PIKA_ALIGN_BOTTOM, NC_("alignment-type", "Align to the bottom"), NULL },
    { PIKA_ARRANGE_HFILL, NC_("alignment-type", "Distribute anchor points horizontally evenly"), NULL },
    { PIKA_ARRANGE_VFILL, NC_("alignment-type", "Distribute anchor points vertically evenly"), NULL },
    { PIKA_DISTRIBUTE_EVEN_HORIZONTAL_GAP, NC_("alignment-type", "Distribute horizontally with even horizontal gaps"), NULL },
    { PIKA_DISTRIBUTE_EVEN_VERTICAL_GAP, NC_("alignment-type", "Distribute vertically with even vertical gaps"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaAlignmentType", values);
      pika_type_set_translation_context (type, "alignment-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_bucket_fill_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_BUCKET_FILL_FG, "PIKA_BUCKET_FILL_FG", "fg" },
    { PIKA_BUCKET_FILL_BG, "PIKA_BUCKET_FILL_BG", "bg" },
    { PIKA_BUCKET_FILL_PATTERN, "PIKA_BUCKET_FILL_PATTERN", "pattern" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_BUCKET_FILL_FG, NC_("bucket-fill-mode", "FG color fill"), NULL },
    { PIKA_BUCKET_FILL_BG, NC_("bucket-fill-mode", "BG color fill"), NULL },
    { PIKA_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 ("PikaBucketFillMode", values);
      pika_type_set_translation_context (type, "bucket-fill-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_channel_border_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CHANNEL_BORDER_STYLE_HARD, "PIKA_CHANNEL_BORDER_STYLE_HARD", "hard" },
    { PIKA_CHANNEL_BORDER_STYLE_SMOOTH, "PIKA_CHANNEL_BORDER_STYLE_SMOOTH", "smooth" },
    { PIKA_CHANNEL_BORDER_STYLE_FEATHERED, "PIKA_CHANNEL_BORDER_STYLE_FEATHERED", "feathered" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CHANNEL_BORDER_STYLE_HARD, NC_("channel-border-style", "Hard"), NULL },
    { PIKA_CHANNEL_BORDER_STYLE_SMOOTH, NC_("channel-border-style", "Smooth"), NULL },
    { PIKA_CHANNEL_BORDER_STYLE_FEATHERED, NC_("channel-border-style", "Feathered"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaChannelBorderStyle", values);
      pika_type_set_translation_context (type, "channel-border-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_color_pick_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_COLOR_PICK_MODE_PIXEL, "PIKA_COLOR_PICK_MODE_PIXEL", "pixel" },
    { PIKA_COLOR_PICK_MODE_RGB_PERCENT, "PIKA_COLOR_PICK_MODE_RGB_PERCENT", "rgb-percent" },
    { PIKA_COLOR_PICK_MODE_RGB_U8, "PIKA_COLOR_PICK_MODE_RGB_U8", "rgb-u8" },
    { PIKA_COLOR_PICK_MODE_GRAYSCALE, "PIKA_COLOR_PICK_MODE_GRAYSCALE", "grayscale" },
    { PIKA_COLOR_PICK_MODE_HSV, "PIKA_COLOR_PICK_MODE_HSV", "hsv" },
    { PIKA_COLOR_PICK_MODE_LCH, "PIKA_COLOR_PICK_MODE_LCH", "lch" },
    { PIKA_COLOR_PICK_MODE_LAB, "PIKA_COLOR_PICK_MODE_LAB", "lab" },
    { PIKA_COLOR_PICK_MODE_CMYK, "PIKA_COLOR_PICK_MODE_CMYK", "cmyk" },
    { PIKA_COLOR_PICK_MODE_XYY, "PIKA_COLOR_PICK_MODE_XYY", "xyy" },
    { PIKA_COLOR_PICK_MODE_YUV, "PIKA_COLOR_PICK_MODE_YUV", "yuv" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_COLOR_PICK_MODE_PIXEL, NC_("color-pick-mode", "Pixel"), NULL },
    { PIKA_COLOR_PICK_MODE_RGB_PERCENT, NC_("color-pick-mode", "RGB (%)"), NULL },
    { PIKA_COLOR_PICK_MODE_RGB_U8, NC_("color-pick-mode", "RGB (0..255)"), NULL },
    { PIKA_COLOR_PICK_MODE_GRAYSCALE, NC_("color-pick-mode", "Grayscale (%)"), NULL },
    { PIKA_COLOR_PICK_MODE_HSV, NC_("color-pick-mode", "HSV"), NULL },
    { PIKA_COLOR_PICK_MODE_LCH, NC_("color-pick-mode", "CIE LCh"), NULL },
    { PIKA_COLOR_PICK_MODE_LAB, NC_("color-pick-mode", "CIE LAB"), NULL },
    { PIKA_COLOR_PICK_MODE_CMYK, NC_("color-pick-mode", "CMYK"), NULL },
    { PIKA_COLOR_PICK_MODE_XYY, NC_("color-pick-mode", "CIE xyY"), NULL },
    { PIKA_COLOR_PICK_MODE_YUV, NC_("color-pick-mode", "CIE Yu'v'"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaColorPickMode", values);
      pika_type_set_translation_context (type, "color-pick-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_color_profile_policy_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_COLOR_PROFILE_POLICY_ASK, "PIKA_COLOR_PROFILE_POLICY_ASK", "ask" },
    { PIKA_COLOR_PROFILE_POLICY_KEEP, "PIKA_COLOR_PROFILE_POLICY_KEEP", "keep" },
    { PIKA_COLOR_PROFILE_POLICY_CONVERT_BUILTIN, "PIKA_COLOR_PROFILE_POLICY_CONVERT_BUILTIN", "convert-builtin" },
    { PIKA_COLOR_PROFILE_POLICY_CONVERT_PREFERRED, "PIKA_COLOR_PROFILE_POLICY_CONVERT_PREFERRED", "convert-preferred" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_COLOR_PROFILE_POLICY_ASK, NC_("color-profile-policy", "Ask what to do"), NULL },
    { PIKA_COLOR_PROFILE_POLICY_KEEP, NC_("color-profile-policy", "Keep embedded profile"), NULL },
    { PIKA_COLOR_PROFILE_POLICY_CONVERT_BUILTIN, NC_("color-profile-policy", "Convert to built-in sRGB or grayscale profile"), NULL },
    { PIKA_COLOR_PROFILE_POLICY_CONVERT_PREFERRED, NC_("color-profile-policy", "Convert to preferred RGB or grayscale profile (defaulting to built-in)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaColorProfilePolicy", values);
      pika_type_set_translation_context (type, "color-profile-policy");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_component_mask_get_type (void)
{
  static const GFlagsValue values[] =
  {
    { PIKA_COMPONENT_MASK_RED, "PIKA_COMPONENT_MASK_RED", "red" },
    { PIKA_COMPONENT_MASK_GREEN, "PIKA_COMPONENT_MASK_GREEN", "green" },
    { PIKA_COMPONENT_MASK_BLUE, "PIKA_COMPONENT_MASK_BLUE", "blue" },
    { PIKA_COMPONENT_MASK_ALPHA, "PIKA_COMPONENT_MASK_ALPHA", "alpha" },
    { PIKA_COMPONENT_MASK_ALL, "PIKA_COMPONENT_MASK_ALL", "all" },
    { 0, NULL, NULL }
  };

  static const PikaFlagsDesc descs[] =
  {
    { PIKA_COMPONENT_MASK_RED, "PIKA_COMPONENT_MASK_RED", NULL },
    { PIKA_COMPONENT_MASK_GREEN, "PIKA_COMPONENT_MASK_GREEN", NULL },
    { PIKA_COMPONENT_MASK_BLUE, "PIKA_COMPONENT_MASK_BLUE", NULL },
    { PIKA_COMPONENT_MASK_ALPHA, "PIKA_COMPONENT_MASK_ALPHA", NULL },
    { PIKA_COMPONENT_MASK_ALL, "PIKA_COMPONENT_MASK_ALL", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_flags_register_static ("PikaComponentMask", values);
      pika_type_set_translation_context (type, "component-mask");
      pika_flags_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_container_policy_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CONTAINER_POLICY_STRONG, "PIKA_CONTAINER_POLICY_STRONG", "strong" },
    { PIKA_CONTAINER_POLICY_WEAK, "PIKA_CONTAINER_POLICY_WEAK", "weak" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CONTAINER_POLICY_STRONG, "PIKA_CONTAINER_POLICY_STRONG", NULL },
    { PIKA_CONTAINER_POLICY_WEAK, "PIKA_CONTAINER_POLICY_WEAK", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaContainerPolicy", values);
      pika_type_set_translation_context (type, "container-policy");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_convert_dither_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CONVERT_DITHER_NONE, "PIKA_CONVERT_DITHER_NONE", "none" },
    { PIKA_CONVERT_DITHER_FS, "PIKA_CONVERT_DITHER_FS", "fs" },
    { PIKA_CONVERT_DITHER_FS_LOWBLEED, "PIKA_CONVERT_DITHER_FS_LOWBLEED", "fs-lowbleed" },
    { PIKA_CONVERT_DITHER_FIXED, "PIKA_CONVERT_DITHER_FIXED", "fixed" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CONVERT_DITHER_NONE, NC_("convert-dither-type", "None"), NULL },
    { PIKA_CONVERT_DITHER_FS, NC_("convert-dither-type", "Floyd-Steinberg (normal)"), NULL },
    { PIKA_CONVERT_DITHER_FS_LOWBLEED, NC_("convert-dither-type", "Floyd-Steinberg (reduced color bleeding)"), NULL },
    { PIKA_CONVERT_DITHER_FIXED, NC_("convert-dither-type", "Positioned"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaConvertDitherType", values);
      pika_type_set_translation_context (type, "convert-dither-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_convolution_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_NORMAL_CONVOL, "PIKA_NORMAL_CONVOL", "normal-convol" },
    { PIKA_ABSOLUTE_CONVOL, "PIKA_ABSOLUTE_CONVOL", "absolute-convol" },
    { PIKA_NEGATIVE_CONVOL, "PIKA_NEGATIVE_CONVOL", "negative-convol" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_NORMAL_CONVOL, "PIKA_NORMAL_CONVOL", NULL },
    { PIKA_ABSOLUTE_CONVOL, "PIKA_ABSOLUTE_CONVOL", NULL },
    { PIKA_NEGATIVE_CONVOL, "PIKA_NEGATIVE_CONVOL", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaConvolutionType", values);
      pika_type_set_translation_context (type, "convolution-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_curve_point_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CURVE_POINT_SMOOTH, "PIKA_CURVE_POINT_SMOOTH", "smooth" },
    { PIKA_CURVE_POINT_CORNER, "PIKA_CURVE_POINT_CORNER", "corner" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CURVE_POINT_SMOOTH, NC_("curve-point-type", "Smooth"), NULL },
    { PIKA_CURVE_POINT_CORNER, NC_("curve-point-type", "Corner"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCurvePointType", values);
      pika_type_set_translation_context (type, "curve-point-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_curve_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CURVE_SMOOTH, "PIKA_CURVE_SMOOTH", "smooth" },
    { PIKA_CURVE_FREE, "PIKA_CURVE_FREE", "free" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CURVE_SMOOTH, NC_("curve-type", "Smooth"), NULL },
    { PIKA_CURVE_FREE, NC_("curve-type", "Freehand"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCurveType", values);
      pika_type_set_translation_context (type, "curve-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_dash_preset_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_DASH_CUSTOM, "PIKA_DASH_CUSTOM", "custom" },
    { PIKA_DASH_LINE, "PIKA_DASH_LINE", "line" },
    { PIKA_DASH_LONG_DASH, "PIKA_DASH_LONG_DASH", "long-dash" },
    { PIKA_DASH_MEDIUM_DASH, "PIKA_DASH_MEDIUM_DASH", "medium-dash" },
    { PIKA_DASH_SHORT_DASH, "PIKA_DASH_SHORT_DASH", "short-dash" },
    { PIKA_DASH_SPARSE_DOTS, "PIKA_DASH_SPARSE_DOTS", "sparse-dots" },
    { PIKA_DASH_NORMAL_DOTS, "PIKA_DASH_NORMAL_DOTS", "normal-dots" },
    { PIKA_DASH_DENSE_DOTS, "PIKA_DASH_DENSE_DOTS", "dense-dots" },
    { PIKA_DASH_STIPPLES, "PIKA_DASH_STIPPLES", "stipples" },
    { PIKA_DASH_DASH_DOT, "PIKA_DASH_DASH_DOT", "dash-dot" },
    { PIKA_DASH_DASH_DOT_DOT, "PIKA_DASH_DASH_DOT_DOT", "dash-dot-dot" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_DASH_CUSTOM, NC_("dash-preset", "Custom"), NULL },
    { PIKA_DASH_LINE, NC_("dash-preset", "Line"), NULL },
    { PIKA_DASH_LONG_DASH, NC_("dash-preset", "Long dashes"), NULL },
    { PIKA_DASH_MEDIUM_DASH, NC_("dash-preset", "Medium dashes"), NULL },
    { PIKA_DASH_SHORT_DASH, NC_("dash-preset", "Short dashes"), NULL },
    { PIKA_DASH_SPARSE_DOTS, NC_("dash-preset", "Sparse dots"), NULL },
    { PIKA_DASH_NORMAL_DOTS, NC_("dash-preset", "Normal dots"), NULL },
    { PIKA_DASH_DENSE_DOTS, NC_("dash-preset", "Dense dots"), NULL },
    { PIKA_DASH_STIPPLES, NC_("dash-preset", "Stipples"), NULL },
    { PIKA_DASH_DASH_DOT, NC_("dash-preset", "Dash, dot"), NULL },
    { PIKA_DASH_DASH_DOT_DOT, NC_("dash-preset", "Dash, dot, dot"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaDashPreset", values);
      pika_type_set_translation_context (type, "dash-preset");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_debug_policy_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_DEBUG_POLICY_WARNING, "PIKA_DEBUG_POLICY_WARNING", "warning" },
    { PIKA_DEBUG_POLICY_CRITICAL, "PIKA_DEBUG_POLICY_CRITICAL", "critical" },
    { PIKA_DEBUG_POLICY_FATAL, "PIKA_DEBUG_POLICY_FATAL", "fatal" },
    { PIKA_DEBUG_POLICY_NEVER, "PIKA_DEBUG_POLICY_NEVER", "never" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_DEBUG_POLICY_WARNING, NC_("debug-policy", "Debug warnings, critical errors and crashes"), NULL },
    { PIKA_DEBUG_POLICY_CRITICAL, NC_("debug-policy", "Debug critical errors and crashes"), NULL },
    { PIKA_DEBUG_POLICY_FATAL, NC_("debug-policy", "Debug crashes only"), NULL },
    { PIKA_DEBUG_POLICY_NEVER, NC_("debug-policy", "Never debug PIKA"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaDebugPolicy", values);
      pika_type_set_translation_context (type, "debug-policy");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_dirty_mask_get_type (void)
{
  static const GFlagsValue values[] =
  {
    { PIKA_DIRTY_NONE, "PIKA_DIRTY_NONE", "none" },
    { PIKA_DIRTY_IMAGE, "PIKA_DIRTY_IMAGE", "image" },
    { PIKA_DIRTY_IMAGE_SIZE, "PIKA_DIRTY_IMAGE_SIZE", "image-size" },
    { PIKA_DIRTY_IMAGE_META, "PIKA_DIRTY_IMAGE_META", "image-meta" },
    { PIKA_DIRTY_IMAGE_STRUCTURE, "PIKA_DIRTY_IMAGE_STRUCTURE", "image-structure" },
    { PIKA_DIRTY_ITEM, "PIKA_DIRTY_ITEM", "item" },
    { PIKA_DIRTY_ITEM_META, "PIKA_DIRTY_ITEM_META", "item-meta" },
    { PIKA_DIRTY_DRAWABLE, "PIKA_DIRTY_DRAWABLE", "drawable" },
    { PIKA_DIRTY_VECTORS, "PIKA_DIRTY_VECTORS", "vectors" },
    { PIKA_DIRTY_SELECTION, "PIKA_DIRTY_SELECTION", "selection" },
    { PIKA_DIRTY_ACTIVE_DRAWABLE, "PIKA_DIRTY_ACTIVE_DRAWABLE", "active-drawable" },
    { PIKA_DIRTY_ALL, "PIKA_DIRTY_ALL", "all" },
    { 0, NULL, NULL }
  };

  static const PikaFlagsDesc descs[] =
  {
    { PIKA_DIRTY_NONE, "PIKA_DIRTY_NONE", NULL },
    { PIKA_DIRTY_IMAGE, "PIKA_DIRTY_IMAGE", NULL },
    { PIKA_DIRTY_IMAGE_SIZE, "PIKA_DIRTY_IMAGE_SIZE", NULL },
    { PIKA_DIRTY_IMAGE_META, "PIKA_DIRTY_IMAGE_META", NULL },
    { PIKA_DIRTY_IMAGE_STRUCTURE, "PIKA_DIRTY_IMAGE_STRUCTURE", NULL },
    { PIKA_DIRTY_ITEM, "PIKA_DIRTY_ITEM", NULL },
    { PIKA_DIRTY_ITEM_META, "PIKA_DIRTY_ITEM_META", NULL },
    { PIKA_DIRTY_DRAWABLE, "PIKA_DIRTY_DRAWABLE", NULL },
    { PIKA_DIRTY_VECTORS, "PIKA_DIRTY_VECTORS", NULL },
    { PIKA_DIRTY_SELECTION, "PIKA_DIRTY_SELECTION", NULL },
    { PIKA_DIRTY_ACTIVE_DRAWABLE, "PIKA_DIRTY_ACTIVE_DRAWABLE", NULL },
    { PIKA_DIRTY_ALL, "PIKA_DIRTY_ALL", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_flags_register_static ("PikaDirtyMask", values);
      pika_type_set_translation_context (type, "dirty-mask");
      pika_flags_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_dynamics_output_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_DYNAMICS_OUTPUT_OPACITY, "PIKA_DYNAMICS_OUTPUT_OPACITY", "opacity" },
    { PIKA_DYNAMICS_OUTPUT_SIZE, "PIKA_DYNAMICS_OUTPUT_SIZE", "size" },
    { PIKA_DYNAMICS_OUTPUT_ANGLE, "PIKA_DYNAMICS_OUTPUT_ANGLE", "angle" },
    { PIKA_DYNAMICS_OUTPUT_COLOR, "PIKA_DYNAMICS_OUTPUT_COLOR", "color" },
    { PIKA_DYNAMICS_OUTPUT_HARDNESS, "PIKA_DYNAMICS_OUTPUT_HARDNESS", "hardness" },
    { PIKA_DYNAMICS_OUTPUT_FORCE, "PIKA_DYNAMICS_OUTPUT_FORCE", "force" },
    { PIKA_DYNAMICS_OUTPUT_ASPECT_RATIO, "PIKA_DYNAMICS_OUTPUT_ASPECT_RATIO", "aspect-ratio" },
    { PIKA_DYNAMICS_OUTPUT_SPACING, "PIKA_DYNAMICS_OUTPUT_SPACING", "spacing" },
    { PIKA_DYNAMICS_OUTPUT_RATE, "PIKA_DYNAMICS_OUTPUT_RATE", "rate" },
    { PIKA_DYNAMICS_OUTPUT_FLOW, "PIKA_DYNAMICS_OUTPUT_FLOW", "flow" },
    { PIKA_DYNAMICS_OUTPUT_JITTER, "PIKA_DYNAMICS_OUTPUT_JITTER", "jitter" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_DYNAMICS_OUTPUT_OPACITY, NC_("dynamics-output-type", "Opacity"), NULL },
    { PIKA_DYNAMICS_OUTPUT_SIZE, NC_("dynamics-output-type", "Size"), NULL },
    { PIKA_DYNAMICS_OUTPUT_ANGLE, NC_("dynamics-output-type", "Angle"), NULL },
    { PIKA_DYNAMICS_OUTPUT_COLOR, NC_("dynamics-output-type", "Color"), NULL },
    { PIKA_DYNAMICS_OUTPUT_HARDNESS, NC_("dynamics-output-type", "Hardness"), NULL },
    { PIKA_DYNAMICS_OUTPUT_FORCE, NC_("dynamics-output-type", "Force"), NULL },
    { PIKA_DYNAMICS_OUTPUT_ASPECT_RATIO, NC_("dynamics-output-type", "Aspect ratio"), NULL },
    { PIKA_DYNAMICS_OUTPUT_SPACING, NC_("dynamics-output-type", "Spacing"), NULL },
    { PIKA_DYNAMICS_OUTPUT_RATE, NC_("dynamics-output-type", "Rate"), NULL },
    { PIKA_DYNAMICS_OUTPUT_FLOW, NC_("dynamics-output-type", "Flow"), NULL },
    { PIKA_DYNAMICS_OUTPUT_JITTER, NC_("dynamics-output-type", "Jitter"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaDynamicsOutputType", values);
      pika_type_set_translation_context (type, "dynamics-output-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_custom_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CUSTOM_STYLE_SOLID_COLOR, "PIKA_CUSTOM_STYLE_SOLID_COLOR", "solid-color" },
    { PIKA_CUSTOM_STYLE_PATTERN, "PIKA_CUSTOM_STYLE_PATTERN", "pattern" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CUSTOM_STYLE_SOLID_COLOR, NC_("custom-style", "Solid color"), NULL },
    { PIKA_CUSTOM_STYLE_PATTERN, NC_("custom-style", "Pattern"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCustomStyle", values);
      pika_type_set_translation_context (type, "custom-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_fill_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_FILL_STYLE_FG_COLOR, "PIKA_FILL_STYLE_FG_COLOR", "fg-color" },
    { PIKA_FILL_STYLE_BG_COLOR, "PIKA_FILL_STYLE_BG_COLOR", "bg-color" },
    { PIKA_FILL_STYLE_PATTERN, "PIKA_FILL_STYLE_PATTERN", "pattern" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_FILL_STYLE_FG_COLOR, NC_("fill-style", "Foreground color"), NULL },
    { PIKA_FILL_STYLE_BG_COLOR, NC_("fill-style", "Background color"), NULL },
    { PIKA_FILL_STYLE_PATTERN, NC_("fill-style", "Pattern"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaFillStyle", values);
      pika_type_set_translation_context (type, "fill-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_filter_region_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_FILTER_REGION_SELECTION, "PIKA_FILTER_REGION_SELECTION", "selection" },
    { PIKA_FILTER_REGION_DRAWABLE, "PIKA_FILTER_REGION_DRAWABLE", "drawable" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_FILTER_REGION_SELECTION, NC_("filter-region", "Use the selection as input"), NULL },
    { PIKA_FILTER_REGION_DRAWABLE, NC_("filter-region", "Use the entire layer as input"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaFilterRegion", values);
      pika_type_set_translation_context (type, "filter-region");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_gradient_color_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRADIENT_COLOR_FIXED, "PIKA_GRADIENT_COLOR_FIXED", "fixed" },
    { PIKA_GRADIENT_COLOR_FOREGROUND, "PIKA_GRADIENT_COLOR_FOREGROUND", "foreground" },
    { PIKA_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, "PIKA_GRADIENT_COLOR_FOREGROUND_TRANSPARENT", "foreground-transparent" },
    { PIKA_GRADIENT_COLOR_BACKGROUND, "PIKA_GRADIENT_COLOR_BACKGROUND", "background" },
    { PIKA_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, "PIKA_GRADIENT_COLOR_BACKGROUND_TRANSPARENT", "background-transparent" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRADIENT_COLOR_FIXED, NC_("gradient-color", "Fixed"), NULL },
    { PIKA_GRADIENT_COLOR_FOREGROUND, NC_("gradient-color", "Foreground color"), NULL },
    /* Translators: this is an abbreviated version of "Foreground color".
       Keep it short. */
    { PIKA_GRADIENT_COLOR_FOREGROUND, NC_("gradient-color", "FG"), NULL },
    { PIKA_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, NC_("gradient-color", "Foreground color (transparent)"), NULL },
    /* Translators: this is an abbreviated version of "Foreground color (transparent)".
       Keep it short. */
    { PIKA_GRADIENT_COLOR_FOREGROUND_TRANSPARENT, NC_("gradient-color", "FG (t)"), NULL },
    { PIKA_GRADIENT_COLOR_BACKGROUND, NC_("gradient-color", "Background color"), NULL },
    /* Translators: this is an abbreviated version of "Background color".
       Keep it short. */
    { PIKA_GRADIENT_COLOR_BACKGROUND, NC_("gradient-color", "BG"), NULL },
    { PIKA_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, NC_("gradient-color", "Background color (transparent)"), NULL },
    /* Translators: this is an abbreviated version of "Background color (transparent)".
       Keep it short. */
    { PIKA_GRADIENT_COLOR_BACKGROUND_TRANSPARENT, NC_("gradient-color", "BG (t)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGradientColor", values);
      pika_type_set_translation_context (type, "gradient-color");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_gravity_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRAVITY_NONE, "PIKA_GRAVITY_NONE", "none" },
    { PIKA_GRAVITY_NORTH_WEST, "PIKA_GRAVITY_NORTH_WEST", "north-west" },
    { PIKA_GRAVITY_NORTH, "PIKA_GRAVITY_NORTH", "north" },
    { PIKA_GRAVITY_NORTH_EAST, "PIKA_GRAVITY_NORTH_EAST", "north-east" },
    { PIKA_GRAVITY_WEST, "PIKA_GRAVITY_WEST", "west" },
    { PIKA_GRAVITY_CENTER, "PIKA_GRAVITY_CENTER", "center" },
    { PIKA_GRAVITY_EAST, "PIKA_GRAVITY_EAST", "east" },
    { PIKA_GRAVITY_SOUTH_WEST, "PIKA_GRAVITY_SOUTH_WEST", "south-west" },
    { PIKA_GRAVITY_SOUTH, "PIKA_GRAVITY_SOUTH", "south" },
    { PIKA_GRAVITY_SOUTH_EAST, "PIKA_GRAVITY_SOUTH_EAST", "south-east" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRAVITY_NONE, "PIKA_GRAVITY_NONE", NULL },
    { PIKA_GRAVITY_NORTH_WEST, "PIKA_GRAVITY_NORTH_WEST", NULL },
    { PIKA_GRAVITY_NORTH, "PIKA_GRAVITY_NORTH", NULL },
    { PIKA_GRAVITY_NORTH_EAST, "PIKA_GRAVITY_NORTH_EAST", NULL },
    { PIKA_GRAVITY_WEST, "PIKA_GRAVITY_WEST", NULL },
    { PIKA_GRAVITY_CENTER, "PIKA_GRAVITY_CENTER", NULL },
    { PIKA_GRAVITY_EAST, "PIKA_GRAVITY_EAST", NULL },
    { PIKA_GRAVITY_SOUTH_WEST, "PIKA_GRAVITY_SOUTH_WEST", NULL },
    { PIKA_GRAVITY_SOUTH, "PIKA_GRAVITY_SOUTH", NULL },
    { PIKA_GRAVITY_SOUTH_EAST, "PIKA_GRAVITY_SOUTH_EAST", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGravityType", values);
      pika_type_set_translation_context (type, "gravity-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_guide_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GUIDE_STYLE_NONE, "PIKA_GUIDE_STYLE_NONE", "none" },
    { PIKA_GUIDE_STYLE_NORMAL, "PIKA_GUIDE_STYLE_NORMAL", "normal" },
    { PIKA_GUIDE_STYLE_MIRROR, "PIKA_GUIDE_STYLE_MIRROR", "mirror" },
    { PIKA_GUIDE_STYLE_MANDALA, "PIKA_GUIDE_STYLE_MANDALA", "mandala" },
    { PIKA_GUIDE_STYLE_SPLIT_VIEW, "PIKA_GUIDE_STYLE_SPLIT_VIEW", "split-view" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GUIDE_STYLE_NONE, "PIKA_GUIDE_STYLE_NONE", NULL },
    { PIKA_GUIDE_STYLE_NORMAL, "PIKA_GUIDE_STYLE_NORMAL", NULL },
    { PIKA_GUIDE_STYLE_MIRROR, "PIKA_GUIDE_STYLE_MIRROR", NULL },
    { PIKA_GUIDE_STYLE_MANDALA, "PIKA_GUIDE_STYLE_MANDALA", NULL },
    { PIKA_GUIDE_STYLE_SPLIT_VIEW, "PIKA_GUIDE_STYLE_SPLIT_VIEW", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGuideStyle", values);
      pika_type_set_translation_context (type, "guide-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_histogram_channel_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_HISTOGRAM_VALUE, "PIKA_HISTOGRAM_VALUE", "value" },
    { PIKA_HISTOGRAM_RED, "PIKA_HISTOGRAM_RED", "red" },
    { PIKA_HISTOGRAM_GREEN, "PIKA_HISTOGRAM_GREEN", "green" },
    { PIKA_HISTOGRAM_BLUE, "PIKA_HISTOGRAM_BLUE", "blue" },
    { PIKA_HISTOGRAM_ALPHA, "PIKA_HISTOGRAM_ALPHA", "alpha" },
    { PIKA_HISTOGRAM_LUMINANCE, "PIKA_HISTOGRAM_LUMINANCE", "luminance" },
    { PIKA_HISTOGRAM_RGB, "PIKA_HISTOGRAM_RGB", "rgb" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_HISTOGRAM_VALUE, NC_("histogram-channel", "Value"), NULL },
    { PIKA_HISTOGRAM_RED, NC_("histogram-channel", "Red"), NULL },
    { PIKA_HISTOGRAM_GREEN, NC_("histogram-channel", "Green"), NULL },
    { PIKA_HISTOGRAM_BLUE, NC_("histogram-channel", "Blue"), NULL },
    { PIKA_HISTOGRAM_ALPHA, NC_("histogram-channel", "Alpha"), NULL },
    { PIKA_HISTOGRAM_LUMINANCE, NC_("histogram-channel", "Luminance"), NULL },
    { PIKA_HISTOGRAM_RGB, NC_("histogram-channel", "RGB"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaHistogramChannel", values);
      pika_type_set_translation_context (type, "histogram-channel");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_item_set_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ITEM_SET_NONE, "PIKA_ITEM_SET_NONE", "none" },
    { PIKA_ITEM_SET_ALL, "PIKA_ITEM_SET_ALL", "all" },
    { PIKA_ITEM_SET_IMAGE_SIZED, "PIKA_ITEM_SET_IMAGE_SIZED", "image-sized" },
    { PIKA_ITEM_SET_VISIBLE, "PIKA_ITEM_SET_VISIBLE", "visible" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ITEM_SET_NONE, NC_("item-set", "None"), NULL },
    { PIKA_ITEM_SET_ALL, NC_("item-set", "All layers"), NULL },
    { PIKA_ITEM_SET_IMAGE_SIZED, NC_("item-set", "Image-sized layers"), NULL },
    { PIKA_ITEM_SET_VISIBLE, NC_("item-set", "All visible layers"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaItemSet", values);
      pika_type_set_translation_context (type, "item-set");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_matting_engine_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_MATTING_ENGINE_GLOBAL, "PIKA_MATTING_ENGINE_GLOBAL", "global" },
    { PIKA_MATTING_ENGINE_LEVIN, "PIKA_MATTING_ENGINE_LEVIN", "levin" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_MATTING_ENGINE_GLOBAL, NC_("matting-engine", "Matting Global"), NULL },
    { PIKA_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 ("PikaMattingEngine", values);
      pika_type_set_translation_context (type, "matting-engine");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_message_severity_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_MESSAGE_INFO, "PIKA_MESSAGE_INFO", "info" },
    { PIKA_MESSAGE_WARNING, "PIKA_MESSAGE_WARNING", "warning" },
    { PIKA_MESSAGE_ERROR, "PIKA_MESSAGE_ERROR", "error" },
    { PIKA_MESSAGE_BUG_WARNING, "PIKA_MESSAGE_BUG_WARNING", "bug-warning" },
    { PIKA_MESSAGE_BUG_CRITICAL, "PIKA_MESSAGE_BUG_CRITICAL", "bug-critical" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_MESSAGE_INFO, NC_("message-severity", "Message"), NULL },
    { PIKA_MESSAGE_WARNING, NC_("message-severity", "Warning"), NULL },
    { PIKA_MESSAGE_ERROR, NC_("message-severity", "Error"), NULL },
    { PIKA_MESSAGE_BUG_WARNING, NC_("message-severity", "WARNING"), NULL },
    { PIKA_MESSAGE_BUG_CRITICAL, NC_("message-severity", "CRITICAL"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaMessageSeverity", values);
      pika_type_set_translation_context (type, "message-severity");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_metadata_rotation_policy_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_METADATA_ROTATION_POLICY_ASK, "PIKA_METADATA_ROTATION_POLICY_ASK", "ask" },
    { PIKA_METADATA_ROTATION_POLICY_KEEP, "PIKA_METADATA_ROTATION_POLICY_KEEP", "keep" },
    { PIKA_METADATA_ROTATION_POLICY_ROTATE, "PIKA_METADATA_ROTATION_POLICY_ROTATE", "rotate" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_METADATA_ROTATION_POLICY_ASK, NC_("metadata-rotation-policy", "Ask what to do"), NULL },
    { PIKA_METADATA_ROTATION_POLICY_KEEP, NC_("metadata-rotation-policy", "Discard metadata without rotating"), NULL },
    { PIKA_METADATA_ROTATION_POLICY_ROTATE, NC_("metadata-rotation-policy", "Rotate the image then discard metadata"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaMetadataRotationPolicy", values);
      pika_type_set_translation_context (type, "metadata-rotation-policy");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_paste_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PASTE_TYPE_FLOATING, "PIKA_PASTE_TYPE_FLOATING", "floating" },
    { PIKA_PASTE_TYPE_FLOATING_IN_PLACE, "PIKA_PASTE_TYPE_FLOATING_IN_PLACE", "floating-in-place" },
    { PIKA_PASTE_TYPE_FLOATING_INTO, "PIKA_PASTE_TYPE_FLOATING_INTO", "floating-into" },
    { PIKA_PASTE_TYPE_FLOATING_INTO_IN_PLACE, "PIKA_PASTE_TYPE_FLOATING_INTO_IN_PLACE", "floating-into-in-place" },
    { PIKA_PASTE_TYPE_NEW_LAYER, "PIKA_PASTE_TYPE_NEW_LAYER", "new-layer" },
    { PIKA_PASTE_TYPE_NEW_LAYER_IN_PLACE, "PIKA_PASTE_TYPE_NEW_LAYER_IN_PLACE", "new-layer-in-place" },
    { PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING, "PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING", "new-layer-or-floating" },
    { PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING_IN_PLACE, "PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING_IN_PLACE", "new-layer-or-floating-in-place" },
    { PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING, "PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING", "new-merged-layer-or-floating" },
    { PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING_IN_PLACE, "PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING_IN_PLACE", "new-merged-layer-or-floating-in-place" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PASTE_TYPE_FLOATING, "PIKA_PASTE_TYPE_FLOATING", NULL },
    { PIKA_PASTE_TYPE_FLOATING_IN_PLACE, "PIKA_PASTE_TYPE_FLOATING_IN_PLACE", NULL },
    { PIKA_PASTE_TYPE_FLOATING_INTO, "PIKA_PASTE_TYPE_FLOATING_INTO", NULL },
    { PIKA_PASTE_TYPE_FLOATING_INTO_IN_PLACE, "PIKA_PASTE_TYPE_FLOATING_INTO_IN_PLACE", NULL },
    { PIKA_PASTE_TYPE_NEW_LAYER, "PIKA_PASTE_TYPE_NEW_LAYER", NULL },
    { PIKA_PASTE_TYPE_NEW_LAYER_IN_PLACE, "PIKA_PASTE_TYPE_NEW_LAYER_IN_PLACE", NULL },
    { PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING, "PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING", NULL },
    { PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING_IN_PLACE, "PIKA_PASTE_TYPE_NEW_LAYER_OR_FLOATING_IN_PLACE", NULL },
    { PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING, "PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING", NULL },
    { PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING_IN_PLACE, "PIKA_PASTE_TYPE_NEW_MERGED_LAYER_OR_FLOATING_IN_PLACE", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaPasteType", values);
      pika_type_set_translation_context (type, "paste-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_win32_pointer_input_api_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_WIN32_POINTER_INPUT_API_WINTAB, "PIKA_WIN32_POINTER_INPUT_API_WINTAB", "wintab" },
    { PIKA_WIN32_POINTER_INPUT_API_WINDOWS_INK, "PIKA_WIN32_POINTER_INPUT_API_WINDOWS_INK", "windows-ink" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_WIN32_POINTER_INPUT_API_WINTAB, NC_("win32-pointer-input-api", "Wintab"), NULL },
    { PIKA_WIN32_POINTER_INPUT_API_WINDOWS_INK, NC_("win32-pointer-input-api", "Windows Ink"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaWin32PointerInputAPI", values);
      pika_type_set_translation_context (type, "win32-pointer-input-api");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_thumbnail_size_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_THUMBNAIL_SIZE_NONE, "PIKA_THUMBNAIL_SIZE_NONE", "none" },
    { PIKA_THUMBNAIL_SIZE_NORMAL, "PIKA_THUMBNAIL_SIZE_NORMAL", "normal" },
    { PIKA_THUMBNAIL_SIZE_LARGE, "PIKA_THUMBNAIL_SIZE_LARGE", "large" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_THUMBNAIL_SIZE_NONE, NC_("thumbnail-size", "No thumbnails"), NULL },
    { PIKA_THUMBNAIL_SIZE_NORMAL, NC_("thumbnail-size", "Normal (128x128)"), NULL },
    { PIKA_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 ("PikaThumbnailSize", values);
      pika_type_set_translation_context (type, "thumbnail-size");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_trc_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TRC_LINEAR, "PIKA_TRC_LINEAR", "linear" },
    { PIKA_TRC_NON_LINEAR, "PIKA_TRC_NON_LINEAR", "non-linear" },
    { PIKA_TRC_PERCEPTUAL, "PIKA_TRC_PERCEPTUAL", "perceptual" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TRC_LINEAR, NC_("trc-type", "Linear"), NULL },
    { PIKA_TRC_NON_LINEAR, NC_("trc-type", "Non-Linear"), NULL },
    { PIKA_TRC_PERCEPTUAL, NC_("trc-type", "Perceptual"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTRCType", values);
      pika_type_set_translation_context (type, "trc-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_undo_event_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_UNDO_EVENT_UNDO_PUSHED, "PIKA_UNDO_EVENT_UNDO_PUSHED", "undo-pushed" },
    { PIKA_UNDO_EVENT_UNDO_EXPIRED, "PIKA_UNDO_EVENT_UNDO_EXPIRED", "undo-expired" },
    { PIKA_UNDO_EVENT_REDO_EXPIRED, "PIKA_UNDO_EVENT_REDO_EXPIRED", "redo-expired" },
    { PIKA_UNDO_EVENT_UNDO, "PIKA_UNDO_EVENT_UNDO", "undo" },
    { PIKA_UNDO_EVENT_REDO, "PIKA_UNDO_EVENT_REDO", "redo" },
    { PIKA_UNDO_EVENT_UNDO_FREE, "PIKA_UNDO_EVENT_UNDO_FREE", "undo-free" },
    { PIKA_UNDO_EVENT_UNDO_FREEZE, "PIKA_UNDO_EVENT_UNDO_FREEZE", "undo-freeze" },
    { PIKA_UNDO_EVENT_UNDO_THAW, "PIKA_UNDO_EVENT_UNDO_THAW", "undo-thaw" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_UNDO_EVENT_UNDO_PUSHED, "PIKA_UNDO_EVENT_UNDO_PUSHED", NULL },
    { PIKA_UNDO_EVENT_UNDO_EXPIRED, "PIKA_UNDO_EVENT_UNDO_EXPIRED", NULL },
    { PIKA_UNDO_EVENT_REDO_EXPIRED, "PIKA_UNDO_EVENT_REDO_EXPIRED", NULL },
    { PIKA_UNDO_EVENT_UNDO, "PIKA_UNDO_EVENT_UNDO", NULL },
    { PIKA_UNDO_EVENT_REDO, "PIKA_UNDO_EVENT_REDO", NULL },
    { PIKA_UNDO_EVENT_UNDO_FREE, "PIKA_UNDO_EVENT_UNDO_FREE", NULL },
    { PIKA_UNDO_EVENT_UNDO_FREEZE, "PIKA_UNDO_EVENT_UNDO_FREEZE", NULL },
    { PIKA_UNDO_EVENT_UNDO_THAW, "PIKA_UNDO_EVENT_UNDO_THAW", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaUndoEvent", values);
      pika_type_set_translation_context (type, "undo-event");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_undo_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_UNDO_MODE_UNDO, "PIKA_UNDO_MODE_UNDO", "undo" },
    { PIKA_UNDO_MODE_REDO, "PIKA_UNDO_MODE_REDO", "redo" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_UNDO_MODE_UNDO, "PIKA_UNDO_MODE_UNDO", NULL },
    { PIKA_UNDO_MODE_REDO, "PIKA_UNDO_MODE_REDO", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaUndoMode", values);
      pika_type_set_translation_context (type, "undo-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_undo_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_UNDO_GROUP_NONE, "PIKA_UNDO_GROUP_NONE", "group-none" },
    { PIKA_UNDO_GROUP_IMAGE_SCALE, "PIKA_UNDO_GROUP_IMAGE_SCALE", "group-image-scale" },
    { PIKA_UNDO_GROUP_IMAGE_RESIZE, "PIKA_UNDO_GROUP_IMAGE_RESIZE", "group-image-resize" },
    { PIKA_UNDO_GROUP_IMAGE_FLIP, "PIKA_UNDO_GROUP_IMAGE_FLIP", "group-image-flip" },
    { PIKA_UNDO_GROUP_IMAGE_ROTATE, "PIKA_UNDO_GROUP_IMAGE_ROTATE", "group-image-rotate" },
    { PIKA_UNDO_GROUP_IMAGE_TRANSFORM, "PIKA_UNDO_GROUP_IMAGE_TRANSFORM", "group-image-transform" },
    { PIKA_UNDO_GROUP_IMAGE_CROP, "PIKA_UNDO_GROUP_IMAGE_CROP", "group-image-crop" },
    { PIKA_UNDO_GROUP_IMAGE_CONVERT, "PIKA_UNDO_GROUP_IMAGE_CONVERT", "group-image-convert" },
    { PIKA_UNDO_GROUP_IMAGE_ITEM_REMOVE, "PIKA_UNDO_GROUP_IMAGE_ITEM_REMOVE", "group-image-item-remove" },
    { PIKA_UNDO_GROUP_IMAGE_ITEM_REORDER, "PIKA_UNDO_GROUP_IMAGE_ITEM_REORDER", "group-image-item-reorder" },
    { PIKA_UNDO_GROUP_IMAGE_LAYERS_MERGE, "PIKA_UNDO_GROUP_IMAGE_LAYERS_MERGE", "group-image-layers-merge" },
    { PIKA_UNDO_GROUP_IMAGE_VECTORS_MERGE, "PIKA_UNDO_GROUP_IMAGE_VECTORS_MERGE", "group-image-vectors-merge" },
    { PIKA_UNDO_GROUP_IMAGE_QUICK_MASK, "PIKA_UNDO_GROUP_IMAGE_QUICK_MASK", "group-image-quick-mask" },
    { PIKA_UNDO_GROUP_IMAGE_GRID, "PIKA_UNDO_GROUP_IMAGE_GRID", "group-image-grid" },
    { PIKA_UNDO_GROUP_GUIDE, "PIKA_UNDO_GROUP_GUIDE", "group-guide" },
    { PIKA_UNDO_GROUP_SAMPLE_POINT, "PIKA_UNDO_GROUP_SAMPLE_POINT", "group-sample-point" },
    { PIKA_UNDO_GROUP_DRAWABLE, "PIKA_UNDO_GROUP_DRAWABLE", "group-drawable" },
    { PIKA_UNDO_GROUP_DRAWABLE_MOD, "PIKA_UNDO_GROUP_DRAWABLE_MOD", "group-drawable-mod" },
    { PIKA_UNDO_GROUP_MASK, "PIKA_UNDO_GROUP_MASK", "group-mask" },
    { PIKA_UNDO_GROUP_ITEM_VISIBILITY, "PIKA_UNDO_GROUP_ITEM_VISIBILITY", "group-item-visibility" },
    { PIKA_UNDO_GROUP_ITEM_LOCK_CONTENTS, "PIKA_UNDO_GROUP_ITEM_LOCK_CONTENTS", "group-item-lock-contents" },
    { PIKA_UNDO_GROUP_ITEM_LOCK_POSITION, "PIKA_UNDO_GROUP_ITEM_LOCK_POSITION", "group-item-lock-position" },
    { PIKA_UNDO_GROUP_ITEM_LOCK_VISIBILITY, "PIKA_UNDO_GROUP_ITEM_LOCK_VISIBILITY", "group-item-lock-visibility" },
    { PIKA_UNDO_GROUP_ITEM_PROPERTIES, "PIKA_UNDO_GROUP_ITEM_PROPERTIES", "group-item-properties" },
    { PIKA_UNDO_GROUP_ITEM_DISPLACE, "PIKA_UNDO_GROUP_ITEM_DISPLACE", "group-item-displace" },
    { PIKA_UNDO_GROUP_ITEM_SCALE, "PIKA_UNDO_GROUP_ITEM_SCALE", "group-item-scale" },
    { PIKA_UNDO_GROUP_ITEM_RESIZE, "PIKA_UNDO_GROUP_ITEM_RESIZE", "group-item-resize" },
    { PIKA_UNDO_GROUP_LAYER_ADD, "PIKA_UNDO_GROUP_LAYER_ADD", "group-layer-add" },
    { PIKA_UNDO_GROUP_LAYER_ADD_ALPHA, "PIKA_UNDO_GROUP_LAYER_ADD_ALPHA", "group-layer-add-alpha" },
    { PIKA_UNDO_GROUP_LAYER_ADD_MASK, "PIKA_UNDO_GROUP_LAYER_ADD_MASK", "group-layer-add-mask" },
    { PIKA_UNDO_GROUP_LAYER_APPLY_MASK, "PIKA_UNDO_GROUP_LAYER_APPLY_MASK", "group-layer-apply-mask" },
    { PIKA_UNDO_GROUP_LAYER_REMOVE_ALPHA, "PIKA_UNDO_GROUP_LAYER_REMOVE_ALPHA", "group-layer-remove-alpha" },
    { PIKA_UNDO_GROUP_LAYER_LOCK_ALPHA, "PIKA_UNDO_GROUP_LAYER_LOCK_ALPHA", "group-layer-lock-alpha" },
    { PIKA_UNDO_GROUP_LAYER_OPACITY, "PIKA_UNDO_GROUP_LAYER_OPACITY", "group-layer-opacity" },
    { PIKA_UNDO_GROUP_LAYER_MODE, "PIKA_UNDO_GROUP_LAYER_MODE", "group-layer-mode" },
    { PIKA_UNDO_GROUP_CHANNEL_ADD, "PIKA_UNDO_GROUP_CHANNEL_ADD", "group-channel-add" },
    { PIKA_UNDO_GROUP_FS_TO_LAYER, "PIKA_UNDO_GROUP_FS_TO_LAYER", "group-fs-to-layer" },
    { PIKA_UNDO_GROUP_FS_FLOAT, "PIKA_UNDO_GROUP_FS_FLOAT", "group-fs-float" },
    { PIKA_UNDO_GROUP_FS_ANCHOR, "PIKA_UNDO_GROUP_FS_ANCHOR", "group-fs-anchor" },
    { PIKA_UNDO_GROUP_EDIT_PASTE, "PIKA_UNDO_GROUP_EDIT_PASTE", "group-edit-paste" },
    { PIKA_UNDO_GROUP_EDIT_CUT, "PIKA_UNDO_GROUP_EDIT_CUT", "group-edit-cut" },
    { PIKA_UNDO_GROUP_TEXT, "PIKA_UNDO_GROUP_TEXT", "group-text" },
    { PIKA_UNDO_GROUP_TRANSFORM, "PIKA_UNDO_GROUP_TRANSFORM", "group-transform" },
    { PIKA_UNDO_GROUP_PAINT, "PIKA_UNDO_GROUP_PAINT", "group-paint" },
    { PIKA_UNDO_GROUP_PARASITE_ATTACH, "PIKA_UNDO_GROUP_PARASITE_ATTACH", "group-parasite-attach" },
    { PIKA_UNDO_GROUP_PARASITE_REMOVE, "PIKA_UNDO_GROUP_PARASITE_REMOVE", "group-parasite-remove" },
    { PIKA_UNDO_GROUP_VECTORS_IMPORT, "PIKA_UNDO_GROUP_VECTORS_IMPORT", "group-vectors-import" },
    { PIKA_UNDO_GROUP_MISC, "PIKA_UNDO_GROUP_MISC", "group-misc" },
    { PIKA_UNDO_IMAGE_TYPE, "PIKA_UNDO_IMAGE_TYPE", "image-type" },
    { PIKA_UNDO_IMAGE_PRECISION, "PIKA_UNDO_IMAGE_PRECISION", "image-precision" },
    { PIKA_UNDO_IMAGE_SIZE, "PIKA_UNDO_IMAGE_SIZE", "image-size" },
    { PIKA_UNDO_IMAGE_RESOLUTION, "PIKA_UNDO_IMAGE_RESOLUTION", "image-resolution" },
    { PIKA_UNDO_IMAGE_GRID, "PIKA_UNDO_IMAGE_GRID", "image-grid" },
    { PIKA_UNDO_IMAGE_METADATA, "PIKA_UNDO_IMAGE_METADATA", "image-metadata" },
    { PIKA_UNDO_IMAGE_COLORMAP, "PIKA_UNDO_IMAGE_COLORMAP", "image-colormap" },
    { PIKA_UNDO_IMAGE_HIDDEN_PROFILE, "PIKA_UNDO_IMAGE_HIDDEN_PROFILE", "image-hidden-profile" },
    { PIKA_UNDO_GUIDE, "PIKA_UNDO_GUIDE", "guide" },
    { PIKA_UNDO_SAMPLE_POINT, "PIKA_UNDO_SAMPLE_POINT", "sample-point" },
    { PIKA_UNDO_DRAWABLE, "PIKA_UNDO_DRAWABLE", "drawable" },
    { PIKA_UNDO_DRAWABLE_MOD, "PIKA_UNDO_DRAWABLE_MOD", "drawable-mod" },
    { PIKA_UNDO_DRAWABLE_FORMAT, "PIKA_UNDO_DRAWABLE_FORMAT", "drawable-format" },
    { PIKA_UNDO_MASK, "PIKA_UNDO_MASK", "mask" },
    { PIKA_UNDO_ITEM_REORDER, "PIKA_UNDO_ITEM_REORDER", "item-reorder" },
    { PIKA_UNDO_ITEM_RENAME, "PIKA_UNDO_ITEM_RENAME", "item-rename" },
    { PIKA_UNDO_ITEM_DISPLACE, "PIKA_UNDO_ITEM_DISPLACE", "item-displace" },
    { PIKA_UNDO_ITEM_VISIBILITY, "PIKA_UNDO_ITEM_VISIBILITY", "item-visibility" },
    { PIKA_UNDO_ITEM_COLOR_TAG, "PIKA_UNDO_ITEM_COLOR_TAG", "item-color-tag" },
    { PIKA_UNDO_ITEM_LOCK_CONTENT, "PIKA_UNDO_ITEM_LOCK_CONTENT", "item-lock-content" },
    { PIKA_UNDO_ITEM_LOCK_POSITION, "PIKA_UNDO_ITEM_LOCK_POSITION", "item-lock-position" },
    { PIKA_UNDO_ITEM_LOCK_VISIBILITY, "PIKA_UNDO_ITEM_LOCK_VISIBILITY", "item-lock-visibility" },
    { PIKA_UNDO_LAYER_ADD, "PIKA_UNDO_LAYER_ADD", "layer-add" },
    { PIKA_UNDO_LAYER_REMOVE, "PIKA_UNDO_LAYER_REMOVE", "layer-remove" },
    { PIKA_UNDO_LAYER_MODE, "PIKA_UNDO_LAYER_MODE", "layer-mode" },
    { PIKA_UNDO_LAYER_OPACITY, "PIKA_UNDO_LAYER_OPACITY", "layer-opacity" },
    { PIKA_UNDO_LAYER_LOCK_ALPHA, "PIKA_UNDO_LAYER_LOCK_ALPHA", "layer-lock-alpha" },
    { PIKA_UNDO_GROUP_LAYER_SUSPEND_RESIZE, "PIKA_UNDO_GROUP_LAYER_SUSPEND_RESIZE", "group-layer-suspend-resize" },
    { PIKA_UNDO_GROUP_LAYER_RESUME_RESIZE, "PIKA_UNDO_GROUP_LAYER_RESUME_RESIZE", "group-layer-resume-resize" },
    { PIKA_UNDO_GROUP_LAYER_SUSPEND_MASK, "PIKA_UNDO_GROUP_LAYER_SUSPEND_MASK", "group-layer-suspend-mask" },
    { PIKA_UNDO_GROUP_LAYER_RESUME_MASK, "PIKA_UNDO_GROUP_LAYER_RESUME_MASK", "group-layer-resume-mask" },
    { PIKA_UNDO_GROUP_LAYER_START_TRANSFORM, "PIKA_UNDO_GROUP_LAYER_START_TRANSFORM", "group-layer-start-transform" },
    { PIKA_UNDO_GROUP_LAYER_END_TRANSFORM, "PIKA_UNDO_GROUP_LAYER_END_TRANSFORM", "group-layer-end-transform" },
    { PIKA_UNDO_GROUP_LAYER_CONVERT, "PIKA_UNDO_GROUP_LAYER_CONVERT", "group-layer-convert" },
    { PIKA_UNDO_TEXT_LAYER, "PIKA_UNDO_TEXT_LAYER", "text-layer" },
    { PIKA_UNDO_TEXT_LAYER_MODIFIED, "PIKA_UNDO_TEXT_LAYER_MODIFIED", "text-layer-modified" },
    { PIKA_UNDO_TEXT_LAYER_CONVERT, "PIKA_UNDO_TEXT_LAYER_CONVERT", "text-layer-convert" },
    { PIKA_UNDO_LAYER_MASK_ADD, "PIKA_UNDO_LAYER_MASK_ADD", "layer-mask-add" },
    { PIKA_UNDO_LAYER_MASK_REMOVE, "PIKA_UNDO_LAYER_MASK_REMOVE", "layer-mask-remove" },
    { PIKA_UNDO_LAYER_MASK_APPLY, "PIKA_UNDO_LAYER_MASK_APPLY", "layer-mask-apply" },
    { PIKA_UNDO_LAYER_MASK_SHOW, "PIKA_UNDO_LAYER_MASK_SHOW", "layer-mask-show" },
    { PIKA_UNDO_CHANNEL_ADD, "PIKA_UNDO_CHANNEL_ADD", "channel-add" },
    { PIKA_UNDO_CHANNEL_REMOVE, "PIKA_UNDO_CHANNEL_REMOVE", "channel-remove" },
    { PIKA_UNDO_CHANNEL_COLOR, "PIKA_UNDO_CHANNEL_COLOR", "channel-color" },
    { PIKA_UNDO_VECTORS_ADD, "PIKA_UNDO_VECTORS_ADD", "vectors-add" },
    { PIKA_UNDO_VECTORS_REMOVE, "PIKA_UNDO_VECTORS_REMOVE", "vectors-remove" },
    { PIKA_UNDO_VECTORS_MOD, "PIKA_UNDO_VECTORS_MOD", "vectors-mod" },
    { PIKA_UNDO_FS_TO_LAYER, "PIKA_UNDO_FS_TO_LAYER", "fs-to-layer" },
    { PIKA_UNDO_TRANSFORM_GRID, "PIKA_UNDO_TRANSFORM_GRID", "transform-grid" },
    { PIKA_UNDO_PAINT, "PIKA_UNDO_PAINT", "paint" },
    { PIKA_UNDO_INK, "PIKA_UNDO_INK", "ink" },
    { PIKA_UNDO_FOREGROUND_SELECT, "PIKA_UNDO_FOREGROUND_SELECT", "foreground-select" },
    { PIKA_UNDO_PARASITE_ATTACH, "PIKA_UNDO_PARASITE_ATTACH", "parasite-attach" },
    { PIKA_UNDO_PARASITE_REMOVE, "PIKA_UNDO_PARASITE_REMOVE", "parasite-remove" },
    { PIKA_UNDO_CANT, "PIKA_UNDO_CANT", "cant" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_UNDO_GROUP_NONE, NC_("undo-type", "<<invalid>>"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_SCALE, NC_("undo-type", "Scale image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_RESIZE, NC_("undo-type", "Resize image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_FLIP, NC_("undo-type", "Flip image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_ROTATE, NC_("undo-type", "Rotate image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_TRANSFORM, NC_("undo-type", "Transform image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_CROP, NC_("undo-type", "Crop image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_CONVERT, NC_("undo-type", "Convert image"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_ITEM_REMOVE, NC_("undo-type", "Remove item"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_ITEM_REORDER, NC_("undo-type", "Reorder item"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_LAYERS_MERGE, NC_("undo-type", "Merge layers"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_VECTORS_MERGE, NC_("undo-type", "Merge paths"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_QUICK_MASK, NC_("undo-type", "Quick Mask"), NULL },
    { PIKA_UNDO_GROUP_IMAGE_GRID, NC_("undo-type", "Grid"), NULL },
    { PIKA_UNDO_GROUP_GUIDE, NC_("undo-type", "Guide"), NULL },
    { PIKA_UNDO_GROUP_SAMPLE_POINT, NC_("undo-type", "Sample Point"), NULL },
    { PIKA_UNDO_GROUP_DRAWABLE, NC_("undo-type", "Layer/Channel"), NULL },
    { PIKA_UNDO_GROUP_DRAWABLE_MOD, NC_("undo-type", "Layer/Channel modification"), NULL },
    { PIKA_UNDO_GROUP_MASK, NC_("undo-type", "Selection mask"), NULL },
    { PIKA_UNDO_GROUP_ITEM_VISIBILITY, NC_("undo-type", "Item visibility"), NULL },
    { PIKA_UNDO_GROUP_ITEM_LOCK_CONTENTS, NC_("undo-type", "Lock/Unlock contents"), NULL },
    { PIKA_UNDO_GROUP_ITEM_LOCK_POSITION, NC_("undo-type", "Lock/Unlock position"), NULL },
    { PIKA_UNDO_GROUP_ITEM_LOCK_VISIBILITY, NC_("undo-type", "Lock/Unlock visibility"), NULL },
    { PIKA_UNDO_GROUP_ITEM_PROPERTIES, NC_("undo-type", "Item properties"), NULL },
    { PIKA_UNDO_GROUP_ITEM_DISPLACE, NC_("undo-type", "Move item"), NULL },
    { PIKA_UNDO_GROUP_ITEM_SCALE, NC_("undo-type", "Scale item"), NULL },
    { PIKA_UNDO_GROUP_ITEM_RESIZE, NC_("undo-type", "Resize item"), NULL },
    { PIKA_UNDO_GROUP_LAYER_ADD, NC_("undo-type", "Add layer"), NULL },
    { PIKA_UNDO_GROUP_LAYER_ADD_ALPHA, NC_("undo-type", "Add alpha channel"), NULL },
    { PIKA_UNDO_GROUP_LAYER_ADD_MASK, NC_("undo-type", "Add layer mask"), NULL },
    { PIKA_UNDO_GROUP_LAYER_APPLY_MASK, NC_("undo-type", "Apply layer mask"), NULL },
    { PIKA_UNDO_GROUP_LAYER_REMOVE_ALPHA, NC_("undo-type", "Remove alpha channel"), NULL },
    { PIKA_UNDO_GROUP_LAYER_LOCK_ALPHA, NC_("undo-type", "Lock/Unlock alpha channels"), NULL },
    { PIKA_UNDO_GROUP_LAYER_OPACITY, NC_("undo-type", "Set layers opacity"), NULL },
    { PIKA_UNDO_GROUP_LAYER_MODE, NC_("undo-type", "Set layers mode"), NULL },
    { PIKA_UNDO_GROUP_CHANNEL_ADD, NC_("undo-type", "Add channels"), NULL },
    { PIKA_UNDO_GROUP_FS_TO_LAYER, NC_("undo-type", "Floating selection to layer"), NULL },
    { PIKA_UNDO_GROUP_FS_FLOAT, NC_("undo-type", "Float selection"), NULL },
    { PIKA_UNDO_GROUP_FS_ANCHOR, NC_("undo-type", "Anchor floating selection"), NULL },
    { PIKA_UNDO_GROUP_EDIT_PASTE, NC_("undo-type", "Paste"), NULL },
    { PIKA_UNDO_GROUP_EDIT_CUT, NC_("undo-type", "Cut"), NULL },
    { PIKA_UNDO_GROUP_TEXT, NC_("undo-type", "Text"), NULL },
    { PIKA_UNDO_GROUP_TRANSFORM, NC_("undo-type", "Transform"), NULL },
    { PIKA_UNDO_GROUP_PAINT, NC_("undo-type", "Paint"), NULL },
    { PIKA_UNDO_GROUP_PARASITE_ATTACH, NC_("undo-type", "Attach parasite"), NULL },
    { PIKA_UNDO_GROUP_PARASITE_REMOVE, NC_("undo-type", "Remove parasite"), NULL },
    { PIKA_UNDO_GROUP_VECTORS_IMPORT, NC_("undo-type", "Import paths"), NULL },
    { PIKA_UNDO_GROUP_MISC, NC_("undo-type", "Plug-In"), NULL },
    { PIKA_UNDO_IMAGE_TYPE, NC_("undo-type", "Image type"), NULL },
    { PIKA_UNDO_IMAGE_PRECISION, NC_("undo-type", "Image precision"), NULL },
    { PIKA_UNDO_IMAGE_SIZE, NC_("undo-type", "Image size"), NULL },
    { PIKA_UNDO_IMAGE_RESOLUTION, NC_("undo-type", "Image resolution change"), NULL },
    { PIKA_UNDO_IMAGE_GRID, NC_("undo-type", "Grid"), NULL },
    { PIKA_UNDO_IMAGE_METADATA, NC_("undo-type", "Change metadata"), NULL },
    { PIKA_UNDO_IMAGE_COLORMAP, NC_("undo-type", "Change indexed palette"), NULL },
    { PIKA_UNDO_IMAGE_HIDDEN_PROFILE, NC_("undo-type", "Hide/Unhide color profile"), NULL },
    { PIKA_UNDO_GUIDE, NC_("undo-type", "Guide"), NULL },
    { PIKA_UNDO_SAMPLE_POINT, NC_("undo-type", "Sample Point"), NULL },
    { PIKA_UNDO_DRAWABLE, NC_("undo-type", "Layer/Channel"), NULL },
    { PIKA_UNDO_DRAWABLE_MOD, NC_("undo-type", "Layer/Channel modification"), NULL },
    { PIKA_UNDO_DRAWABLE_FORMAT, NC_("undo-type", "Layer/Channel format"), NULL },
    { PIKA_UNDO_MASK, NC_("undo-type", "Selection mask"), NULL },
    { PIKA_UNDO_ITEM_REORDER, NC_("undo-type", "Reorder item"), NULL },
    { PIKA_UNDO_ITEM_RENAME, NC_("undo-type", "Rename item"), NULL },
    { PIKA_UNDO_ITEM_DISPLACE, NC_("undo-type", "Move item"), NULL },
    { PIKA_UNDO_ITEM_VISIBILITY, NC_("undo-type", "Item visibility"), NULL },
    { PIKA_UNDO_ITEM_COLOR_TAG, NC_("undo-type", "Item color tag"), NULL },
    { PIKA_UNDO_ITEM_LOCK_CONTENT, NC_("undo-type", "Lock/Unlock content"), NULL },
    { PIKA_UNDO_ITEM_LOCK_POSITION, NC_("undo-type", "Lock/Unlock position"), NULL },
    { PIKA_UNDO_ITEM_LOCK_VISIBILITY, NC_("undo-type", "Lock/Unlock visibility"), NULL },
    { PIKA_UNDO_LAYER_ADD, NC_("undo-type", "New layer"), NULL },
    { PIKA_UNDO_LAYER_REMOVE, NC_("undo-type", "Delete layer"), NULL },
    { PIKA_UNDO_LAYER_MODE, NC_("undo-type", "Set layer mode"), NULL },
    { PIKA_UNDO_LAYER_OPACITY, NC_("undo-type", "Set layer opacity"), NULL },
    { PIKA_UNDO_LAYER_LOCK_ALPHA, NC_("undo-type", "Lock/Unlock alpha channel"), NULL },
    { PIKA_UNDO_GROUP_LAYER_SUSPEND_RESIZE, NC_("undo-type", "Suspend group layer resize"), NULL },
    { PIKA_UNDO_GROUP_LAYER_RESUME_RESIZE, NC_("undo-type", "Resume group layer resize"), NULL },
    { PIKA_UNDO_GROUP_LAYER_SUSPEND_MASK, NC_("undo-type", "Suspend group layer mask"), NULL },
    { PIKA_UNDO_GROUP_LAYER_RESUME_MASK, NC_("undo-type", "Resume group layer mask"), NULL },
    { PIKA_UNDO_GROUP_LAYER_START_TRANSFORM, NC_("undo-type", "Start transforming group layer"), NULL },
    { PIKA_UNDO_GROUP_LAYER_END_TRANSFORM, NC_("undo-type", "End transforming group layer"), NULL },
    { PIKA_UNDO_GROUP_LAYER_CONVERT, NC_("undo-type", "Convert group layer"), NULL },
    { PIKA_UNDO_TEXT_LAYER, NC_("undo-type", "Text layer"), NULL },
    { PIKA_UNDO_TEXT_LAYER_MODIFIED, NC_("undo-type", "Text layer modification"), NULL },
    { PIKA_UNDO_TEXT_LAYER_CONVERT, NC_("undo-type", "Convert text layer"), NULL },
    { PIKA_UNDO_LAYER_MASK_ADD, NC_("undo-type", "Add layer mask"), NULL },
    { PIKA_UNDO_LAYER_MASK_REMOVE, NC_("undo-type", "Delete layer mask"), NULL },
    { PIKA_UNDO_LAYER_MASK_APPLY, NC_("undo-type", "Apply layer mask"), NULL },
    { PIKA_UNDO_LAYER_MASK_SHOW, NC_("undo-type", "Show layer mask"), NULL },
    { PIKA_UNDO_CHANNEL_ADD, NC_("undo-type", "New channel"), NULL },
    { PIKA_UNDO_CHANNEL_REMOVE, NC_("undo-type", "Delete channel"), NULL },
    { PIKA_UNDO_CHANNEL_COLOR, NC_("undo-type", "Channel color"), NULL },
    { PIKA_UNDO_VECTORS_ADD, NC_("undo-type", "New path"), NULL },
    { PIKA_UNDO_VECTORS_REMOVE, NC_("undo-type", "Delete path"), NULL },
    { PIKA_UNDO_VECTORS_MOD, NC_("undo-type", "Path modification"), NULL },
    { PIKA_UNDO_FS_TO_LAYER, NC_("undo-type", "Floating selection to layer"), NULL },
    { PIKA_UNDO_TRANSFORM_GRID, NC_("undo-type", "Transform grid"), NULL },
    { PIKA_UNDO_PAINT, NC_("undo-type", "Paint"), NULL },
    { PIKA_UNDO_INK, NC_("undo-type", "Ink"), NULL },
    { PIKA_UNDO_FOREGROUND_SELECT, NC_("undo-type", "Select foreground"), NULL },
    { PIKA_UNDO_PARASITE_ATTACH, NC_("undo-type", "Attach parasite"), NULL },
    { PIKA_UNDO_PARASITE_REMOVE, NC_("undo-type", "Remove parasite"), NULL },
    { PIKA_UNDO_CANT, NC_("undo-type", "Not undoable"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaUndoType", values);
      pika_type_set_translation_context (type, "undo-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_view_size_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_VIEW_SIZE_TINY, "PIKA_VIEW_SIZE_TINY", "tiny" },
    { PIKA_VIEW_SIZE_EXTRA_SMALL, "PIKA_VIEW_SIZE_EXTRA_SMALL", "extra-small" },
    { PIKA_VIEW_SIZE_SMALL, "PIKA_VIEW_SIZE_SMALL", "small" },
    { PIKA_VIEW_SIZE_MEDIUM, "PIKA_VIEW_SIZE_MEDIUM", "medium" },
    { PIKA_VIEW_SIZE_LARGE, "PIKA_VIEW_SIZE_LARGE", "large" },
    { PIKA_VIEW_SIZE_EXTRA_LARGE, "PIKA_VIEW_SIZE_EXTRA_LARGE", "extra-large" },
    { PIKA_VIEW_SIZE_HUGE, "PIKA_VIEW_SIZE_HUGE", "huge" },
    { PIKA_VIEW_SIZE_ENORMOUS, "PIKA_VIEW_SIZE_ENORMOUS", "enormous" },
    { PIKA_VIEW_SIZE_GIGANTIC, "PIKA_VIEW_SIZE_GIGANTIC", "gigantic" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_VIEW_SIZE_TINY, NC_("view-size", "Tiny"), NULL },
    { PIKA_VIEW_SIZE_EXTRA_SMALL, NC_("view-size", "Very small"), NULL },
    { PIKA_VIEW_SIZE_SMALL, NC_("view-size", "Small"), NULL },
    { PIKA_VIEW_SIZE_MEDIUM, NC_("view-size", "Medium"), NULL },
    { PIKA_VIEW_SIZE_LARGE, NC_("view-size", "Large"), NULL },
    { PIKA_VIEW_SIZE_EXTRA_LARGE, NC_("view-size", "Very large"), NULL },
    { PIKA_VIEW_SIZE_HUGE, NC_("view-size", "Huge"), NULL },
    { PIKA_VIEW_SIZE_ENORMOUS, NC_("view-size", "Enormous"), NULL },
    { PIKA_VIEW_SIZE_GIGANTIC, NC_("view-size", "Gigantic"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaViewSize", values);
      pika_type_set_translation_context (type, "view-size");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_view_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_VIEW_TYPE_LIST, "PIKA_VIEW_TYPE_LIST", "list" },
    { PIKA_VIEW_TYPE_GRID, "PIKA_VIEW_TYPE_GRID", "grid" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_VIEW_TYPE_LIST, NC_("view-type", "View as list"), NULL },
    { PIKA_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 ("PikaViewType", values);
      pika_type_set_translation_context (type, "view-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_select_method_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_SELECT_PLAIN_TEXT, "PIKA_SELECT_PLAIN_TEXT", "plain-text" },
    { PIKA_SELECT_REGEX_PATTERN, "PIKA_SELECT_REGEX_PATTERN", "regex-pattern" },
    { PIKA_SELECT_GLOB_PATTERN, "PIKA_SELECT_GLOB_PATTERN", "glob-pattern" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_SELECT_PLAIN_TEXT, NC_("select-method", "Selection by basic text search"), NULL },
    { PIKA_SELECT_REGEX_PATTERN, NC_("select-method", "Selection by regular expression search"), NULL },
    { PIKA_SELECT_GLOB_PATTERN, NC_("select-method", "Selection by glob pattern search"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaSelectMethod", values);
      pika_type_set_translation_context (type, "select-method");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}


/* Generated data ends here */