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

#include "stamp-pikabaseenums.h"
#include "config.h"
#include <glib-object.h>
#undef PIKA_DISABLE_DEPRECATED
#include "pikabasetypes.h"
#include "libpika/libpika-intl.h"
#include "pikabaseenums.h"


/* enumerations from "pikabaseenums.h" */
GType
pika_add_mask_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ADD_MASK_WHITE, "PIKA_ADD_MASK_WHITE", "white" },
    { PIKA_ADD_MASK_BLACK, "PIKA_ADD_MASK_BLACK", "black" },
    { PIKA_ADD_MASK_ALPHA, "PIKA_ADD_MASK_ALPHA", "alpha" },
    { PIKA_ADD_MASK_ALPHA_TRANSFER, "PIKA_ADD_MASK_ALPHA_TRANSFER", "alpha-transfer" },
    { PIKA_ADD_MASK_SELECTION, "PIKA_ADD_MASK_SELECTION", "selection" },
    { PIKA_ADD_MASK_COPY, "PIKA_ADD_MASK_COPY", "copy" },
    { PIKA_ADD_MASK_CHANNEL, "PIKA_ADD_MASK_CHANNEL", "channel" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ADD_MASK_WHITE, NC_("add-mask-type", "_White (full opacity)"), NULL },
    { PIKA_ADD_MASK_BLACK, NC_("add-mask-type", "_Black (full transparency)"), NULL },
    { PIKA_ADD_MASK_ALPHA, NC_("add-mask-type", "Layer's _alpha channel"), NULL },
    { PIKA_ADD_MASK_ALPHA_TRANSFER, NC_("add-mask-type", "_Transfer layer's alpha channel"), NULL },
    { PIKA_ADD_MASK_SELECTION, NC_("add-mask-type", "_Selection"), NULL },
    { PIKA_ADD_MASK_COPY, NC_("add-mask-type", "_Grayscale copy of layer"), NULL },
    { PIKA_ADD_MASK_CHANNEL, NC_("add-mask-type", "C_hannel"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaAddMaskType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "add-mask-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_brush_generated_shape_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_BRUSH_GENERATED_CIRCLE, "PIKA_BRUSH_GENERATED_CIRCLE", "circle" },
    { PIKA_BRUSH_GENERATED_SQUARE, "PIKA_BRUSH_GENERATED_SQUARE", "square" },
    { PIKA_BRUSH_GENERATED_DIAMOND, "PIKA_BRUSH_GENERATED_DIAMOND", "diamond" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_BRUSH_GENERATED_CIRCLE, NC_("brush-generated-shape", "Circle"), NULL },
    { PIKA_BRUSH_GENERATED_SQUARE, NC_("brush-generated-shape", "Square"), NULL },
    { PIKA_BRUSH_GENERATED_DIAMOND, NC_("brush-generated-shape", "Diamond"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaBrushGeneratedShape", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "brush-generated-shape");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_cap_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CAP_BUTT, "PIKA_CAP_BUTT", "butt" },
    { PIKA_CAP_ROUND, "PIKA_CAP_ROUND", "round" },
    { PIKA_CAP_SQUARE, "PIKA_CAP_SQUARE", "square" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CAP_BUTT, NC_("cap-style", "Butt"), NULL },
    { PIKA_CAP_ROUND, NC_("cap-style", "Round"), NULL },
    { PIKA_CAP_SQUARE, NC_("cap-style", "Square"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCapStyle", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "cap-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_channel_ops_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CHANNEL_OP_ADD, "PIKA_CHANNEL_OP_ADD", "add" },
    { PIKA_CHANNEL_OP_SUBTRACT, "PIKA_CHANNEL_OP_SUBTRACT", "subtract" },
    { PIKA_CHANNEL_OP_REPLACE, "PIKA_CHANNEL_OP_REPLACE", "replace" },
    { PIKA_CHANNEL_OP_INTERSECT, "PIKA_CHANNEL_OP_INTERSECT", "intersect" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CHANNEL_OP_ADD, NC_("channel-ops", "Add to the current selection"), NULL },
    { PIKA_CHANNEL_OP_SUBTRACT, NC_("channel-ops", "Subtract from the current selection"), NULL },
    { PIKA_CHANNEL_OP_REPLACE, NC_("channel-ops", "Replace the current selection"), NULL },
    { PIKA_CHANNEL_OP_INTERSECT, NC_("channel-ops", "Intersect with the current selection"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaChannelOps", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "channel-ops");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_channel_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CHANNEL_RED, "PIKA_CHANNEL_RED", "red" },
    { PIKA_CHANNEL_GREEN, "PIKA_CHANNEL_GREEN", "green" },
    { PIKA_CHANNEL_BLUE, "PIKA_CHANNEL_BLUE", "blue" },
    { PIKA_CHANNEL_GRAY, "PIKA_CHANNEL_GRAY", "gray" },
    { PIKA_CHANNEL_INDEXED, "PIKA_CHANNEL_INDEXED", "indexed" },
    { PIKA_CHANNEL_ALPHA, "PIKA_CHANNEL_ALPHA", "alpha" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CHANNEL_RED, NC_("channel-type", "Red"), NULL },
    { PIKA_CHANNEL_GREEN, NC_("channel-type", "Green"), NULL },
    { PIKA_CHANNEL_BLUE, NC_("channel-type", "Blue"), NULL },
    { PIKA_CHANNEL_GRAY, NC_("channel-type", "Gray"), NULL },
    { PIKA_CHANNEL_INDEXED, NC_("channel-type", "Indexed"), NULL },
    { PIKA_CHANNEL_ALPHA, NC_("channel-type", "Alpha"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaChannelType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "channel-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_check_size_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CHECK_SIZE_SMALL_CHECKS, "PIKA_CHECK_SIZE_SMALL_CHECKS", "small-checks" },
    { PIKA_CHECK_SIZE_MEDIUM_CHECKS, "PIKA_CHECK_SIZE_MEDIUM_CHECKS", "medium-checks" },
    { PIKA_CHECK_SIZE_LARGE_CHECKS, "PIKA_CHECK_SIZE_LARGE_CHECKS", "large-checks" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CHECK_SIZE_SMALL_CHECKS, NC_("check-size", "Small"), NULL },
    { PIKA_CHECK_SIZE_MEDIUM_CHECKS, NC_("check-size", "Medium"), NULL },
    { PIKA_CHECK_SIZE_LARGE_CHECKS, NC_("check-size", "Large"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCheckSize", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "check-size");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_check_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CHECK_TYPE_LIGHT_CHECKS, "PIKA_CHECK_TYPE_LIGHT_CHECKS", "light-checks" },
    { PIKA_CHECK_TYPE_GRAY_CHECKS, "PIKA_CHECK_TYPE_GRAY_CHECKS", "gray-checks" },
    { PIKA_CHECK_TYPE_DARK_CHECKS, "PIKA_CHECK_TYPE_DARK_CHECKS", "dark-checks" },
    { PIKA_CHECK_TYPE_WHITE_ONLY, "PIKA_CHECK_TYPE_WHITE_ONLY", "white-only" },
    { PIKA_CHECK_TYPE_GRAY_ONLY, "PIKA_CHECK_TYPE_GRAY_ONLY", "gray-only" },
    { PIKA_CHECK_TYPE_BLACK_ONLY, "PIKA_CHECK_TYPE_BLACK_ONLY", "black-only" },
    { PIKA_CHECK_TYPE_CUSTOM_CHECKS, "PIKA_CHECK_TYPE_CUSTOM_CHECKS", "custom-checks" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CHECK_TYPE_LIGHT_CHECKS, NC_("check-type", "Light checks"), NULL },
    { PIKA_CHECK_TYPE_GRAY_CHECKS, NC_("check-type", "Mid-tone checks"), NULL },
    { PIKA_CHECK_TYPE_DARK_CHECKS, NC_("check-type", "Dark checks"), NULL },
    { PIKA_CHECK_TYPE_WHITE_ONLY, NC_("check-type", "White only"), NULL },
    { PIKA_CHECK_TYPE_GRAY_ONLY, NC_("check-type", "Gray only"), NULL },
    { PIKA_CHECK_TYPE_BLACK_ONLY, NC_("check-type", "Black only"), NULL },
    { PIKA_CHECK_TYPE_CUSTOM_CHECKS, NC_("check-type", "Custom checks"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCheckType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "check-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_clone_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CLONE_IMAGE, "PIKA_CLONE_IMAGE", "image" },
    { PIKA_CLONE_PATTERN, "PIKA_CLONE_PATTERN", "pattern" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CLONE_IMAGE, NC_("clone-type", "Image"), NULL },
    { PIKA_CLONE_PATTERN, NC_("clone-type", "Pattern"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaCloneType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "clone-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_color_tag_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_COLOR_TAG_NONE, "PIKA_COLOR_TAG_NONE", "none" },
    { PIKA_COLOR_TAG_BLUE, "PIKA_COLOR_TAG_BLUE", "blue" },
    { PIKA_COLOR_TAG_GREEN, "PIKA_COLOR_TAG_GREEN", "green" },
    { PIKA_COLOR_TAG_YELLOW, "PIKA_COLOR_TAG_YELLOW", "yellow" },
    { PIKA_COLOR_TAG_ORANGE, "PIKA_COLOR_TAG_ORANGE", "orange" },
    { PIKA_COLOR_TAG_BROWN, "PIKA_COLOR_TAG_BROWN", "brown" },
    { PIKA_COLOR_TAG_RED, "PIKA_COLOR_TAG_RED", "red" },
    { PIKA_COLOR_TAG_VIOLET, "PIKA_COLOR_TAG_VIOLET", "violet" },
    { PIKA_COLOR_TAG_GRAY, "PIKA_COLOR_TAG_GRAY", "gray" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_COLOR_TAG_NONE, NC_("color-tag", "None"), NULL },
    { PIKA_COLOR_TAG_BLUE, NC_("color-tag", "Blue"), NULL },
    { PIKA_COLOR_TAG_GREEN, NC_("color-tag", "Green"), NULL },
    { PIKA_COLOR_TAG_YELLOW, NC_("color-tag", "Yellow"), NULL },
    { PIKA_COLOR_TAG_ORANGE, NC_("color-tag", "Orange"), NULL },
    { PIKA_COLOR_TAG_BROWN, NC_("color-tag", "Brown"), NULL },
    { PIKA_COLOR_TAG_RED, NC_("color-tag", "Red"), NULL },
    { PIKA_COLOR_TAG_VIOLET, NC_("color-tag", "Violet"), NULL },
    { PIKA_COLOR_TAG_GRAY, NC_("color-tag", "Gray"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaColorTag", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "color-tag");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_component_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_COMPONENT_TYPE_U8, "PIKA_COMPONENT_TYPE_U8", "u8" },
    { PIKA_COMPONENT_TYPE_U16, "PIKA_COMPONENT_TYPE_U16", "u16" },
    { PIKA_COMPONENT_TYPE_U32, "PIKA_COMPONENT_TYPE_U32", "u32" },
    { PIKA_COMPONENT_TYPE_HALF, "PIKA_COMPONENT_TYPE_HALF", "half" },
    { PIKA_COMPONENT_TYPE_FLOAT, "PIKA_COMPONENT_TYPE_FLOAT", "float" },
    { PIKA_COMPONENT_TYPE_DOUBLE, "PIKA_COMPONENT_TYPE_DOUBLE", "double" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_COMPONENT_TYPE_U8, NC_("component-type", "8-bit integer"), NULL },
    { PIKA_COMPONENT_TYPE_U16, NC_("component-type", "16-bit integer"), NULL },
    { PIKA_COMPONENT_TYPE_U32, NC_("component-type", "32-bit integer"), NULL },
    { PIKA_COMPONENT_TYPE_HALF, NC_("component-type", "16-bit floating point"), NULL },
    { PIKA_COMPONENT_TYPE_FLOAT, NC_("component-type", "32-bit floating point"), NULL },
    { PIKA_COMPONENT_TYPE_DOUBLE, NC_("component-type", "64-bit floating point"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaComponentType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "component-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_convert_palette_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CONVERT_PALETTE_GENERATE, "PIKA_CONVERT_PALETTE_GENERATE", "generate" },
    { PIKA_CONVERT_PALETTE_WEB, "PIKA_CONVERT_PALETTE_WEB", "web" },
    { PIKA_CONVERT_PALETTE_MONO, "PIKA_CONVERT_PALETTE_MONO", "mono" },
    { PIKA_CONVERT_PALETTE_CUSTOM, "PIKA_CONVERT_PALETTE_CUSTOM", "custom" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CONVERT_PALETTE_GENERATE, NC_("convert-palette-type", "Generate optimum palette"), NULL },
    { PIKA_CONVERT_PALETTE_WEB, NC_("convert-palette-type", "Use web-optimized palette"), NULL },
    { PIKA_CONVERT_PALETTE_MONO, NC_("convert-palette-type", "Use black and white (1-bit) palette"), NULL },
    { PIKA_CONVERT_PALETTE_CUSTOM, NC_("convert-palette-type", "Use custom palette"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaConvertPaletteType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "convert-palette-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_convolve_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_CONVOLVE_BLUR, "PIKA_CONVOLVE_BLUR", "blur" },
    { PIKA_CONVOLVE_SHARPEN, "PIKA_CONVOLVE_SHARPEN", "sharpen" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_CONVOLVE_BLUR, NC_("convolve-type", "Blur"), NULL },
    { PIKA_CONVOLVE_SHARPEN, NC_("convolve-type", "Sharpen"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaConvolveType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "convolve-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_desaturate_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_DESATURATE_LIGHTNESS, "PIKA_DESATURATE_LIGHTNESS", "lightness" },
    { PIKA_DESATURATE_LUMA, "PIKA_DESATURATE_LUMA", "luma" },
    { PIKA_DESATURATE_AVERAGE, "PIKA_DESATURATE_AVERAGE", "average" },
    { PIKA_DESATURATE_LUMINANCE, "PIKA_DESATURATE_LUMINANCE", "luminance" },
    { PIKA_DESATURATE_VALUE, "PIKA_DESATURATE_VALUE", "value" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_DESATURATE_LIGHTNESS, NC_("desaturate-mode", "Lightness (HSL)"), NULL },
    { PIKA_DESATURATE_LUMA, NC_("desaturate-mode", "Luma"), NULL },
    { PIKA_DESATURATE_AVERAGE, NC_("desaturate-mode", "Average (HSI Intensity)"), NULL },
    { PIKA_DESATURATE_LUMINANCE, NC_("desaturate-mode", "Luminance"), NULL },
    { PIKA_DESATURATE_VALUE, NC_("desaturate-mode", "Value (HSV)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaDesaturateMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "desaturate-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_dodge_burn_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_DODGE_BURN_TYPE_DODGE, "PIKA_DODGE_BURN_TYPE_DODGE", "dodge" },
    { PIKA_DODGE_BURN_TYPE_BURN, "PIKA_DODGE_BURN_TYPE_BURN", "burn" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_DODGE_BURN_TYPE_DODGE, NC_("dodge-burn-type", "Dodge"), NULL },
    { PIKA_DODGE_BURN_TYPE_BURN, NC_("dodge-burn-type", "Burn"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaDodgeBurnType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "dodge-burn-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_fill_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_FILL_FOREGROUND, "PIKA_FILL_FOREGROUND", "foreground" },
    { PIKA_FILL_BACKGROUND, "PIKA_FILL_BACKGROUND", "background" },
    { PIKA_FILL_CIELAB_MIDDLE_GRAY, "PIKA_FILL_CIELAB_MIDDLE_GRAY", "cielab-middle-gray" },
    { PIKA_FILL_WHITE, "PIKA_FILL_WHITE", "white" },
    { PIKA_FILL_TRANSPARENT, "PIKA_FILL_TRANSPARENT", "transparent" },
    { PIKA_FILL_PATTERN, "PIKA_FILL_PATTERN", "pattern" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_FILL_FOREGROUND, NC_("fill-type", "Foreground color"), NULL },
    { PIKA_FILL_BACKGROUND, NC_("fill-type", "Background color"), NULL },
    { PIKA_FILL_CIELAB_MIDDLE_GRAY, NC_("fill-type", "Middle Gray (CIELAB)"), NULL },
    { PIKA_FILL_WHITE, NC_("fill-type", "White"), NULL },
    { PIKA_FILL_TRANSPARENT, NC_("fill-type", "Transparency"), NULL },
    { PIKA_FILL_PATTERN, NC_("fill-type", "Pattern"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaFillType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "fill-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_foreground_extract_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_FOREGROUND_EXTRACT_MATTING, "PIKA_FOREGROUND_EXTRACT_MATTING", "matting" },
    { 0, NULL, NULL }
  };

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

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaForegroundExtractMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "foreground-extract-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_gradient_blend_color_space_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRADIENT_BLEND_RGB_PERCEPTUAL, "PIKA_GRADIENT_BLEND_RGB_PERCEPTUAL", "rgb-perceptual" },
    { PIKA_GRADIENT_BLEND_RGB_LINEAR, "PIKA_GRADIENT_BLEND_RGB_LINEAR", "rgb-linear" },
    { PIKA_GRADIENT_BLEND_CIE_LAB, "PIKA_GRADIENT_BLEND_CIE_LAB", "cie-lab" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRADIENT_BLEND_RGB_PERCEPTUAL, NC_("gradient-blend-color-space", "Perceptual RGB"), NULL },
    { PIKA_GRADIENT_BLEND_RGB_LINEAR, NC_("gradient-blend-color-space", "Linear RGB"), NULL },
    { PIKA_GRADIENT_BLEND_CIE_LAB, NC_("gradient-blend-color-space", "CIE Lab"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGradientBlendColorSpace", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "gradient-blend-color-space");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_gradient_segment_color_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRADIENT_SEGMENT_RGB, "PIKA_GRADIENT_SEGMENT_RGB", "rgb" },
    { PIKA_GRADIENT_SEGMENT_HSV_CCW, "PIKA_GRADIENT_SEGMENT_HSV_CCW", "hsv-ccw" },
    { PIKA_GRADIENT_SEGMENT_HSV_CW, "PIKA_GRADIENT_SEGMENT_HSV_CW", "hsv-cw" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRADIENT_SEGMENT_RGB, NC_("gradient-segment-color", "RGB"), NULL },
    { PIKA_GRADIENT_SEGMENT_HSV_CCW, NC_("gradient-segment-color", "HSV (counter-clockwise hue)"), NULL },
    /* Translators: this is an abbreviated version of "HSV (counter-clockwise hue)".
       Keep it short. */
    { PIKA_GRADIENT_SEGMENT_HSV_CCW, NC_("gradient-segment-color", "HSV (ccw)"), NULL },
    { PIKA_GRADIENT_SEGMENT_HSV_CW, NC_("gradient-segment-color", "HSV (clockwise hue)"), NULL },
    /* Translators: this is an abbreviated version of "HSV (clockwise hue)".
       Keep it short. */
    { PIKA_GRADIENT_SEGMENT_HSV_CW, NC_("gradient-segment-color", "HSV (cw)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGradientSegmentColor", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "gradient-segment-color");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_gradient_segment_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRADIENT_SEGMENT_LINEAR, "PIKA_GRADIENT_SEGMENT_LINEAR", "linear" },
    { PIKA_GRADIENT_SEGMENT_CURVED, "PIKA_GRADIENT_SEGMENT_CURVED", "curved" },
    { PIKA_GRADIENT_SEGMENT_SINE, "PIKA_GRADIENT_SEGMENT_SINE", "sine" },
    { PIKA_GRADIENT_SEGMENT_SPHERE_INCREASING, "PIKA_GRADIENT_SEGMENT_SPHERE_INCREASING", "sphere-increasing" },
    { PIKA_GRADIENT_SEGMENT_SPHERE_DECREASING, "PIKA_GRADIENT_SEGMENT_SPHERE_DECREASING", "sphere-decreasing" },
    { PIKA_GRADIENT_SEGMENT_STEP, "PIKA_GRADIENT_SEGMENT_STEP", "step" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRADIENT_SEGMENT_LINEAR, NC_("gradient-segment-type", "Linear"), NULL },
    { PIKA_GRADIENT_SEGMENT_CURVED, NC_("gradient-segment-type", "Curved"), NULL },
    { PIKA_GRADIENT_SEGMENT_SINE, NC_("gradient-segment-type", "Sinusoidal"), NULL },
    { PIKA_GRADIENT_SEGMENT_SPHERE_INCREASING, NC_("gradient-segment-type", "Spherical (increasing)"), NULL },
    /* Translators: this is an abbreviated version of "Spherical (increasing)".
       Keep it short. */
    { PIKA_GRADIENT_SEGMENT_SPHERE_INCREASING, NC_("gradient-segment-type", "Spherical (inc)"), NULL },
    { PIKA_GRADIENT_SEGMENT_SPHERE_DECREASING, NC_("gradient-segment-type", "Spherical (decreasing)"), NULL },
    /* Translators: this is an abbreviated version of "Spherical (decreasing)".
       Keep it short. */
    { PIKA_GRADIENT_SEGMENT_SPHERE_DECREASING, NC_("gradient-segment-type", "Spherical (dec)"), NULL },
    { PIKA_GRADIENT_SEGMENT_STEP, NC_("gradient-segment-type", "Step"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGradientSegmentType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "gradient-segment-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_gradient_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRADIENT_LINEAR, "PIKA_GRADIENT_LINEAR", "linear" },
    { PIKA_GRADIENT_BILINEAR, "PIKA_GRADIENT_BILINEAR", "bilinear" },
    { PIKA_GRADIENT_RADIAL, "PIKA_GRADIENT_RADIAL", "radial" },
    { PIKA_GRADIENT_SQUARE, "PIKA_GRADIENT_SQUARE", "square" },
    { PIKA_GRADIENT_CONICAL_SYMMETRIC, "PIKA_GRADIENT_CONICAL_SYMMETRIC", "conical-symmetric" },
    { PIKA_GRADIENT_CONICAL_ASYMMETRIC, "PIKA_GRADIENT_CONICAL_ASYMMETRIC", "conical-asymmetric" },
    { PIKA_GRADIENT_SHAPEBURST_ANGULAR, "PIKA_GRADIENT_SHAPEBURST_ANGULAR", "shapeburst-angular" },
    { PIKA_GRADIENT_SHAPEBURST_SPHERICAL, "PIKA_GRADIENT_SHAPEBURST_SPHERICAL", "shapeburst-spherical" },
    { PIKA_GRADIENT_SHAPEBURST_DIMPLED, "PIKA_GRADIENT_SHAPEBURST_DIMPLED", "shapeburst-dimpled" },
    { PIKA_GRADIENT_SPIRAL_CLOCKWISE, "PIKA_GRADIENT_SPIRAL_CLOCKWISE", "spiral-clockwise" },
    { PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE, "PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE", "spiral-anticlockwise" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRADIENT_LINEAR, NC_("gradient-type", "Linear"), NULL },
    { PIKA_GRADIENT_BILINEAR, NC_("gradient-type", "Bi-linear"), NULL },
    { PIKA_GRADIENT_RADIAL, NC_("gradient-type", "Radial"), NULL },
    { PIKA_GRADIENT_SQUARE, NC_("gradient-type", "Square"), NULL },
    { PIKA_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (symmetric)"), NULL },
    /* Translators: this is an abbreviated version of "Conical (symmetric)".
       Keep it short. */
    { PIKA_GRADIENT_CONICAL_SYMMETRIC, NC_("gradient-type", "Conical (sym)"), NULL },
    { PIKA_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asymmetric)"), NULL },
    /* Translators: this is an abbreviated version of "Conical (asymmetric)".
       Keep it short. */
    { PIKA_GRADIENT_CONICAL_ASYMMETRIC, NC_("gradient-type", "Conical (asym)"), NULL },
    { PIKA_GRADIENT_SHAPEBURST_ANGULAR, NC_("gradient-type", "Shaped (angular)"), NULL },
    { PIKA_GRADIENT_SHAPEBURST_SPHERICAL, NC_("gradient-type", "Shaped (spherical)"), NULL },
    { PIKA_GRADIENT_SHAPEBURST_DIMPLED, NC_("gradient-type", "Shaped (dimpled)"), NULL },
    { PIKA_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (clockwise)"), NULL },
    /* Translators: this is an abbreviated version of "Spiral (clockwise)".
       Keep it short. */
    { PIKA_GRADIENT_SPIRAL_CLOCKWISE, NC_("gradient-type", "Spiral (cw)"), NULL },
    { PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (counter-clockwise)"), NULL },
    /* Translators: this is an abbreviated version of "Spiral (counter-clockwise)".
       Keep it short. */
    { PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE, NC_("gradient-type", "Spiral (ccw)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGradientType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "gradient-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_grid_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_GRID_DOTS, "PIKA_GRID_DOTS", "dots" },
    { PIKA_GRID_INTERSECTIONS, "PIKA_GRID_INTERSECTIONS", "intersections" },
    { PIKA_GRID_ON_OFF_DASH, "PIKA_GRID_ON_OFF_DASH", "on-off-dash" },
    { PIKA_GRID_DOUBLE_DASH, "PIKA_GRID_DOUBLE_DASH", "double-dash" },
    { PIKA_GRID_SOLID, "PIKA_GRID_SOLID", "solid" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_GRID_DOTS, NC_("grid-style", "Intersections (dots)"), NULL },
    { PIKA_GRID_INTERSECTIONS, NC_("grid-style", "Intersections (crosshairs)"), NULL },
    { PIKA_GRID_ON_OFF_DASH, NC_("grid-style", "Dashed"), NULL },
    { PIKA_GRID_DOUBLE_DASH, NC_("grid-style", "Double dashed"), NULL },
    { PIKA_GRID_SOLID, NC_("grid-style", "Solid"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaGridStyle", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "grid-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_hue_range_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_HUE_RANGE_ALL, "PIKA_HUE_RANGE_ALL", "all" },
    { PIKA_HUE_RANGE_RED, "PIKA_HUE_RANGE_RED", "red" },
    { PIKA_HUE_RANGE_YELLOW, "PIKA_HUE_RANGE_YELLOW", "yellow" },
    { PIKA_HUE_RANGE_GREEN, "PIKA_HUE_RANGE_GREEN", "green" },
    { PIKA_HUE_RANGE_CYAN, "PIKA_HUE_RANGE_CYAN", "cyan" },
    { PIKA_HUE_RANGE_BLUE, "PIKA_HUE_RANGE_BLUE", "blue" },
    { PIKA_HUE_RANGE_MAGENTA, "PIKA_HUE_RANGE_MAGENTA", "magenta" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_HUE_RANGE_ALL, "PIKA_HUE_RANGE_ALL", NULL },
    { PIKA_HUE_RANGE_RED, "PIKA_HUE_RANGE_RED", NULL },
    { PIKA_HUE_RANGE_YELLOW, "PIKA_HUE_RANGE_YELLOW", NULL },
    { PIKA_HUE_RANGE_GREEN, "PIKA_HUE_RANGE_GREEN", NULL },
    { PIKA_HUE_RANGE_CYAN, "PIKA_HUE_RANGE_CYAN", NULL },
    { PIKA_HUE_RANGE_BLUE, "PIKA_HUE_RANGE_BLUE", NULL },
    { PIKA_HUE_RANGE_MAGENTA, "PIKA_HUE_RANGE_MAGENTA", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaHueRange", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "hue-range");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_icon_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ICON_TYPE_ICON_NAME, "PIKA_ICON_TYPE_ICON_NAME", "icon-name" },
    { PIKA_ICON_TYPE_PIXBUF, "PIKA_ICON_TYPE_PIXBUF", "pixbuf" },
    { PIKA_ICON_TYPE_IMAGE_FILE, "PIKA_ICON_TYPE_IMAGE_FILE", "image-file" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ICON_TYPE_ICON_NAME, NC_("icon-type", "Icon name"), NULL },
    { PIKA_ICON_TYPE_PIXBUF, NC_("icon-type", "Pixbuf"), NULL },
    { PIKA_ICON_TYPE_IMAGE_FILE, NC_("icon-type", "Image file"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaIconType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "icon-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_image_base_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_RGB, "PIKA_RGB", "rgb" },
    { PIKA_GRAY, "PIKA_GRAY", "gray" },
    { PIKA_INDEXED, "PIKA_INDEXED", "indexed" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_RGB, NC_("image-base-type", "RGB color"), NULL },
    { PIKA_GRAY, NC_("image-base-type", "Grayscale"), NULL },
    { PIKA_INDEXED, NC_("image-base-type", "Indexed color"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaImageBaseType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "image-base-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_image_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_RGB_IMAGE, "PIKA_RGB_IMAGE", "rgb-image" },
    { PIKA_RGBA_IMAGE, "PIKA_RGBA_IMAGE", "rgba-image" },
    { PIKA_GRAY_IMAGE, "PIKA_GRAY_IMAGE", "gray-image" },
    { PIKA_GRAYA_IMAGE, "PIKA_GRAYA_IMAGE", "graya-image" },
    { PIKA_INDEXED_IMAGE, "PIKA_INDEXED_IMAGE", "indexed-image" },
    { PIKA_INDEXEDA_IMAGE, "PIKA_INDEXEDA_IMAGE", "indexeda-image" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_RGB_IMAGE, NC_("image-type", "RGB"), NULL },
    { PIKA_RGBA_IMAGE, NC_("image-type", "RGB-alpha"), NULL },
    { PIKA_GRAY_IMAGE, NC_("image-type", "Grayscale"), NULL },
    { PIKA_GRAYA_IMAGE, NC_("image-type", "Grayscale-alpha"), NULL },
    { PIKA_INDEXED_IMAGE, NC_("image-type", "Indexed"), NULL },
    { PIKA_INDEXEDA_IMAGE, NC_("image-type", "Indexed-alpha"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaImageType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "image-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_ink_blob_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_INK_BLOB_TYPE_CIRCLE, "PIKA_INK_BLOB_TYPE_CIRCLE", "circle" },
    { PIKA_INK_BLOB_TYPE_SQUARE, "PIKA_INK_BLOB_TYPE_SQUARE", "square" },
    { PIKA_INK_BLOB_TYPE_DIAMOND, "PIKA_INK_BLOB_TYPE_DIAMOND", "diamond" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_INK_BLOB_TYPE_CIRCLE, NC_("ink-blob-type", "Circle"), NULL },
    { PIKA_INK_BLOB_TYPE_SQUARE, NC_("ink-blob-type", "Square"), NULL },
    { PIKA_INK_BLOB_TYPE_DIAMOND, NC_("ink-blob-type", "Diamond"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaInkBlobType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "ink-blob-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_interpolation_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_INTERPOLATION_NONE, "PIKA_INTERPOLATION_NONE", "none" },
    { PIKA_INTERPOLATION_LINEAR, "PIKA_INTERPOLATION_LINEAR", "linear" },
    { PIKA_INTERPOLATION_CUBIC, "PIKA_INTERPOLATION_CUBIC", "cubic" },
    { PIKA_INTERPOLATION_NOHALO, "PIKA_INTERPOLATION_NOHALO", "nohalo" },
    { PIKA_INTERPOLATION_LOHALO, "PIKA_INTERPOLATION_LOHALO", "lohalo" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_INTERPOLATION_NONE, NC_("interpolation-type", "None"), NULL },
    { PIKA_INTERPOLATION_LINEAR, NC_("interpolation-type", "Linear"), NULL },
    { PIKA_INTERPOLATION_CUBIC, NC_("interpolation-type", "Cubic"), NULL },
    { PIKA_INTERPOLATION_NOHALO, NC_("interpolation-type", "NoHalo"), NULL },
    { PIKA_INTERPOLATION_LOHALO, NC_("interpolation-type", "LoHalo"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaInterpolationType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "interpolation-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_join_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_JOIN_MITER, "PIKA_JOIN_MITER", "miter" },
    { PIKA_JOIN_ROUND, "PIKA_JOIN_ROUND", "round" },
    { PIKA_JOIN_BEVEL, "PIKA_JOIN_BEVEL", "bevel" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_JOIN_MITER, NC_("join-style", "Miter"), NULL },
    { PIKA_JOIN_ROUND, NC_("join-style", "Round"), NULL },
    { PIKA_JOIN_BEVEL, NC_("join-style", "Bevel"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaJoinStyle", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "join-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_mask_apply_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_MASK_APPLY, "PIKA_MASK_APPLY", "apply" },
    { PIKA_MASK_DISCARD, "PIKA_MASK_DISCARD", "discard" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_MASK_APPLY, "PIKA_MASK_APPLY", NULL },
    { PIKA_MASK_DISCARD, "PIKA_MASK_DISCARD", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaMaskApplyMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "mask-apply-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_merge_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_EXPAND_AS_NECESSARY, "PIKA_EXPAND_AS_NECESSARY", "expand-as-necessary" },
    { PIKA_CLIP_TO_IMAGE, "PIKA_CLIP_TO_IMAGE", "clip-to-image" },
    { PIKA_CLIP_TO_BOTTOM_LAYER, "PIKA_CLIP_TO_BOTTOM_LAYER", "clip-to-bottom-layer" },
    { PIKA_FLATTEN_IMAGE, "PIKA_FLATTEN_IMAGE", "flatten-image" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_EXPAND_AS_NECESSARY, NC_("merge-type", "Expanded as necessary"), NULL },
    { PIKA_CLIP_TO_IMAGE, NC_("merge-type", "Clipped to image"), NULL },
    { PIKA_CLIP_TO_BOTTOM_LAYER, NC_("merge-type", "Clipped to bottom layer"), NULL },
    { PIKA_FLATTEN_IMAGE, NC_("merge-type", "Flatten"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaMergeType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "merge-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_message_handler_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_MESSAGE_BOX, "PIKA_MESSAGE_BOX", "message-box" },
    { PIKA_CONSOLE, "PIKA_CONSOLE", "console" },
    { PIKA_ERROR_CONSOLE, "PIKA_ERROR_CONSOLE", "error-console" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_MESSAGE_BOX, "PIKA_MESSAGE_BOX", NULL },
    { PIKA_CONSOLE, "PIKA_CONSOLE", NULL },
    { PIKA_ERROR_CONSOLE, "PIKA_ERROR_CONSOLE", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaMessageHandlerType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "message-handler-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_offset_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_OFFSET_BACKGROUND, "PIKA_OFFSET_BACKGROUND", "background" },
    { PIKA_OFFSET_TRANSPARENT, "PIKA_OFFSET_TRANSPARENT", "transparent" },
    { PIKA_OFFSET_WRAP_AROUND, "PIKA_OFFSET_WRAP_AROUND", "wrap-around" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_OFFSET_BACKGROUND, "PIKA_OFFSET_BACKGROUND", NULL },
    { PIKA_OFFSET_TRANSPARENT, "PIKA_OFFSET_TRANSPARENT", NULL },
    { PIKA_OFFSET_WRAP_AROUND, "PIKA_OFFSET_WRAP_AROUND", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaOffsetType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "offset-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_orientation_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ORIENTATION_HORIZONTAL, "PIKA_ORIENTATION_HORIZONTAL", "horizontal" },
    { PIKA_ORIENTATION_VERTICAL, "PIKA_ORIENTATION_VERTICAL", "vertical" },
    { PIKA_ORIENTATION_UNKNOWN, "PIKA_ORIENTATION_UNKNOWN", "unknown" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ORIENTATION_HORIZONTAL, NC_("orientation-type", "Horizontal"), NULL },
    { PIKA_ORIENTATION_VERTICAL, NC_("orientation-type", "Vertical"), NULL },
    { PIKA_ORIENTATION_UNKNOWN, NC_("orientation-type", "Unknown"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaOrientationType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "orientation-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_paint_application_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PAINT_CONSTANT, "PIKA_PAINT_CONSTANT", "constant" },
    { PIKA_PAINT_INCREMENTAL, "PIKA_PAINT_INCREMENTAL", "incremental" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PAINT_CONSTANT, NC_("paint-application-mode", "Constant"), NULL },
    { PIKA_PAINT_INCREMENTAL, NC_("paint-application-mode", "Incremental"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaPaintApplicationMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "paint-application-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_pdb_error_handler_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PDB_ERROR_HANDLER_INTERNAL, "PIKA_PDB_ERROR_HANDLER_INTERNAL", "internal" },
    { PIKA_PDB_ERROR_HANDLER_PLUGIN, "PIKA_PDB_ERROR_HANDLER_PLUGIN", "plugin" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PDB_ERROR_HANDLER_INTERNAL, "PIKA_PDB_ERROR_HANDLER_INTERNAL", NULL },
    { PIKA_PDB_ERROR_HANDLER_PLUGIN, "PIKA_PDB_ERROR_HANDLER_PLUGIN", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaPDBErrorHandler", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "pdb-error-handler");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_pdb_proc_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PDB_PROC_TYPE_INTERNAL, "PIKA_PDB_PROC_TYPE_INTERNAL", "internal" },
    { PIKA_PDB_PROC_TYPE_PLUGIN, "PIKA_PDB_PROC_TYPE_PLUGIN", "plugin" },
    { PIKA_PDB_PROC_TYPE_EXTENSION, "PIKA_PDB_PROC_TYPE_EXTENSION", "extension" },
    { PIKA_PDB_PROC_TYPE_TEMPORARY, "PIKA_PDB_PROC_TYPE_TEMPORARY", "temporary" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PDB_PROC_TYPE_INTERNAL, NC_("pdb-proc-type", "Internal PIKA procedure"), NULL },
    { PIKA_PDB_PROC_TYPE_PLUGIN, NC_("pdb-proc-type", "PIKA Plug-In"), NULL },
    { PIKA_PDB_PROC_TYPE_EXTENSION, NC_("pdb-proc-type", "PIKA Extension"), NULL },
    { PIKA_PDB_PROC_TYPE_TEMPORARY, NC_("pdb-proc-type", "Temporary Procedure"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaPDBProcType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "pdb-proc-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_pdb_status_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PDB_EXECUTION_ERROR, "PIKA_PDB_EXECUTION_ERROR", "execution-error" },
    { PIKA_PDB_CALLING_ERROR, "PIKA_PDB_CALLING_ERROR", "calling-error" },
    { PIKA_PDB_PASS_THROUGH, "PIKA_PDB_PASS_THROUGH", "pass-through" },
    { PIKA_PDB_SUCCESS, "PIKA_PDB_SUCCESS", "success" },
    { PIKA_PDB_CANCEL, "PIKA_PDB_CANCEL", "cancel" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PDB_EXECUTION_ERROR, "PIKA_PDB_EXECUTION_ERROR", NULL },
    { PIKA_PDB_CALLING_ERROR, "PIKA_PDB_CALLING_ERROR", NULL },
    { PIKA_PDB_PASS_THROUGH, "PIKA_PDB_PASS_THROUGH", NULL },
    { PIKA_PDB_SUCCESS, "PIKA_PDB_SUCCESS", NULL },
    { PIKA_PDB_CANCEL, "PIKA_PDB_CANCEL", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaPDBStatusType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "pdb-status-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_precision_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PRECISION_U8_LINEAR, "PIKA_PRECISION_U8_LINEAR", "u8-linear" },
    { PIKA_PRECISION_U8_NON_LINEAR, "PIKA_PRECISION_U8_NON_LINEAR", "u8-non-linear" },
    { PIKA_PRECISION_U8_PERCEPTUAL, "PIKA_PRECISION_U8_PERCEPTUAL", "u8-perceptual" },
    { PIKA_PRECISION_U16_LINEAR, "PIKA_PRECISION_U16_LINEAR", "u16-linear" },
    { PIKA_PRECISION_U16_NON_LINEAR, "PIKA_PRECISION_U16_NON_LINEAR", "u16-non-linear" },
    { PIKA_PRECISION_U16_PERCEPTUAL, "PIKA_PRECISION_U16_PERCEPTUAL", "u16-perceptual" },
    { PIKA_PRECISION_U32_LINEAR, "PIKA_PRECISION_U32_LINEAR", "u32-linear" },
    { PIKA_PRECISION_U32_NON_LINEAR, "PIKA_PRECISION_U32_NON_LINEAR", "u32-non-linear" },
    { PIKA_PRECISION_U32_PERCEPTUAL, "PIKA_PRECISION_U32_PERCEPTUAL", "u32-perceptual" },
    { PIKA_PRECISION_HALF_LINEAR, "PIKA_PRECISION_HALF_LINEAR", "half-linear" },
    { PIKA_PRECISION_HALF_NON_LINEAR, "PIKA_PRECISION_HALF_NON_LINEAR", "half-non-linear" },
    { PIKA_PRECISION_HALF_PERCEPTUAL, "PIKA_PRECISION_HALF_PERCEPTUAL", "half-perceptual" },
    { PIKA_PRECISION_FLOAT_LINEAR, "PIKA_PRECISION_FLOAT_LINEAR", "float-linear" },
    { PIKA_PRECISION_FLOAT_NON_LINEAR, "PIKA_PRECISION_FLOAT_NON_LINEAR", "float-non-linear" },
    { PIKA_PRECISION_FLOAT_PERCEPTUAL, "PIKA_PRECISION_FLOAT_PERCEPTUAL", "float-perceptual" },
    { PIKA_PRECISION_DOUBLE_LINEAR, "PIKA_PRECISION_DOUBLE_LINEAR", "double-linear" },
    { PIKA_PRECISION_DOUBLE_NON_LINEAR, "PIKA_PRECISION_DOUBLE_NON_LINEAR", "double-non-linear" },
    { PIKA_PRECISION_DOUBLE_PERCEPTUAL, "PIKA_PRECISION_DOUBLE_PERCEPTUAL", "double-perceptual" },
    { PIKA_PRECISION_U8_GAMMA, "PIKA_PRECISION_U8_GAMMA", "u8-gamma" },
    { PIKA_PRECISION_U16_GAMMA, "PIKA_PRECISION_U16_GAMMA", "u16-gamma" },
    { PIKA_PRECISION_U32_GAMMA, "PIKA_PRECISION_U32_GAMMA", "u32-gamma" },
    { PIKA_PRECISION_HALF_GAMMA, "PIKA_PRECISION_HALF_GAMMA", "half-gamma" },
    { PIKA_PRECISION_FLOAT_GAMMA, "PIKA_PRECISION_FLOAT_GAMMA", "float-gamma" },
    { PIKA_PRECISION_DOUBLE_GAMMA, "PIKA_PRECISION_DOUBLE_GAMMA", "double-gamma" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PRECISION_U8_LINEAR, NC_("precision", "8-bit linear integer"), NULL },
    { PIKA_PRECISION_U8_NON_LINEAR, NC_("precision", "8-bit non-linear integer"), NULL },
    { PIKA_PRECISION_U8_PERCEPTUAL, NC_("precision", "8-bit perceptual integer"), NULL },
    { PIKA_PRECISION_U16_LINEAR, NC_("precision", "16-bit linear integer"), NULL },
    { PIKA_PRECISION_U16_NON_LINEAR, NC_("precision", "16-bit non-linear integer"), NULL },
    { PIKA_PRECISION_U16_PERCEPTUAL, NC_("precision", "16-bit perceptual integer"), NULL },
    { PIKA_PRECISION_U32_LINEAR, NC_("precision", "32-bit linear integer"), NULL },
    { PIKA_PRECISION_U32_NON_LINEAR, NC_("precision", "32-bit non-linear integer"), NULL },
    { PIKA_PRECISION_U32_PERCEPTUAL, NC_("precision", "32-bit perceptual integer"), NULL },
    { PIKA_PRECISION_HALF_LINEAR, NC_("precision", "16-bit linear floating point"), NULL },
    { PIKA_PRECISION_HALF_NON_LINEAR, NC_("precision", "16-bit non-linear floating point"), NULL },
    { PIKA_PRECISION_HALF_PERCEPTUAL, NC_("precision", "16-bit perceptual floating point"), NULL },
    { PIKA_PRECISION_FLOAT_LINEAR, NC_("precision", "32-bit linear floating point"), NULL },
    { PIKA_PRECISION_FLOAT_NON_LINEAR, NC_("precision", "32-bit non-linear floating point"), NULL },
    { PIKA_PRECISION_FLOAT_PERCEPTUAL, NC_("precision", "32-bit perceptual floating point"), NULL },
    { PIKA_PRECISION_DOUBLE_LINEAR, NC_("precision", "64-bit linear floating point"), NULL },
    { PIKA_PRECISION_DOUBLE_NON_LINEAR, NC_("precision", "64-bit non-linear floating point"), NULL },
    { PIKA_PRECISION_DOUBLE_PERCEPTUAL, NC_("precision", "64-bit perceptual floating point"), NULL },
    { PIKA_PRECISION_U8_GAMMA, "PIKA_PRECISION_U8_GAMMA", NULL },
    { PIKA_PRECISION_U16_GAMMA, "PIKA_PRECISION_U16_GAMMA", NULL },
    { PIKA_PRECISION_U32_GAMMA, "PIKA_PRECISION_U32_GAMMA", NULL },
    { PIKA_PRECISION_HALF_GAMMA, "PIKA_PRECISION_HALF_GAMMA", NULL },
    { PIKA_PRECISION_FLOAT_GAMMA, "PIKA_PRECISION_FLOAT_GAMMA", NULL },
    { PIKA_PRECISION_DOUBLE_GAMMA, "PIKA_PRECISION_DOUBLE_GAMMA", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaPrecision", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "precision");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_procedure_sensitivity_mask_get_type (void)
{
  static const GFlagsValue values[] =
  {
    { PIKA_PROCEDURE_SENSITIVE_DRAWABLE, "PIKA_PROCEDURE_SENSITIVE_DRAWABLE", "drawable" },
    { PIKA_PROCEDURE_SENSITIVE_DRAWABLES, "PIKA_PROCEDURE_SENSITIVE_DRAWABLES", "drawables" },
    { PIKA_PROCEDURE_SENSITIVE_NO_DRAWABLES, "PIKA_PROCEDURE_SENSITIVE_NO_DRAWABLES", "no-drawables" },
    { PIKA_PROCEDURE_SENSITIVE_NO_IMAGE, "PIKA_PROCEDURE_SENSITIVE_NO_IMAGE", "no-image" },
    { PIKA_PROCEDURE_SENSITIVE_ALWAYS, "PIKA_PROCEDURE_SENSITIVE_ALWAYS", "always" },
    { 0, NULL, NULL }
  };

  static const PikaFlagsDesc descs[] =
  {
    { PIKA_PROCEDURE_SENSITIVE_DRAWABLE, "PIKA_PROCEDURE_SENSITIVE_DRAWABLE", NULL },
    { PIKA_PROCEDURE_SENSITIVE_DRAWABLES, "PIKA_PROCEDURE_SENSITIVE_DRAWABLES", NULL },
    { PIKA_PROCEDURE_SENSITIVE_NO_DRAWABLES, "PIKA_PROCEDURE_SENSITIVE_NO_DRAWABLES", NULL },
    { PIKA_PROCEDURE_SENSITIVE_NO_IMAGE, "PIKA_PROCEDURE_SENSITIVE_NO_IMAGE", NULL },
    { PIKA_PROCEDURE_SENSITIVE_ALWAYS, "PIKA_PROCEDURE_SENSITIVE_ALWAYS", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_flags_register_static ("PikaProcedureSensitivityMask", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "procedure-sensitivity-mask");
      pika_flags_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_progress_command_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PROGRESS_COMMAND_START, "PIKA_PROGRESS_COMMAND_START", "start" },
    { PIKA_PROGRESS_COMMAND_END, "PIKA_PROGRESS_COMMAND_END", "end" },
    { PIKA_PROGRESS_COMMAND_SET_TEXT, "PIKA_PROGRESS_COMMAND_SET_TEXT", "set-text" },
    { PIKA_PROGRESS_COMMAND_SET_VALUE, "PIKA_PROGRESS_COMMAND_SET_VALUE", "set-value" },
    { PIKA_PROGRESS_COMMAND_PULSE, "PIKA_PROGRESS_COMMAND_PULSE", "pulse" },
    { PIKA_PROGRESS_COMMAND_GET_WINDOW, "PIKA_PROGRESS_COMMAND_GET_WINDOW", "get-window" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PROGRESS_COMMAND_START, "PIKA_PROGRESS_COMMAND_START", NULL },
    { PIKA_PROGRESS_COMMAND_END, "PIKA_PROGRESS_COMMAND_END", NULL },
    { PIKA_PROGRESS_COMMAND_SET_TEXT, "PIKA_PROGRESS_COMMAND_SET_TEXT", NULL },
    { PIKA_PROGRESS_COMMAND_SET_VALUE, "PIKA_PROGRESS_COMMAND_SET_VALUE", NULL },
    { PIKA_PROGRESS_COMMAND_PULSE, "PIKA_PROGRESS_COMMAND_PULSE", NULL },
    { PIKA_PROGRESS_COMMAND_GET_WINDOW, "PIKA_PROGRESS_COMMAND_GET_WINDOW", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaProgressCommand", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "progress-command");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_repeat_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_REPEAT_NONE, "PIKA_REPEAT_NONE", "none" },
    { PIKA_REPEAT_SAWTOOTH, "PIKA_REPEAT_SAWTOOTH", "sawtooth" },
    { PIKA_REPEAT_TRIANGULAR, "PIKA_REPEAT_TRIANGULAR", "triangular" },
    { PIKA_REPEAT_TRUNCATE, "PIKA_REPEAT_TRUNCATE", "truncate" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_REPEAT_NONE, NC_("repeat-mode", "None (extend)"), NULL },
    { PIKA_REPEAT_SAWTOOTH, NC_("repeat-mode", "Sawtooth wave"), NULL },
    { PIKA_REPEAT_TRIANGULAR, NC_("repeat-mode", "Triangular wave"), NULL },
    { PIKA_REPEAT_TRUNCATE, NC_("repeat-mode", "Truncate"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaRepeatMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "repeat-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_rotation_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_ROTATE_90, "PIKA_ROTATE_90", "90" },
    { PIKA_ROTATE_180, "PIKA_ROTATE_180", "180" },
    { PIKA_ROTATE_270, "PIKA_ROTATE_270", "270" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_ROTATE_90, "PIKA_ROTATE_90", NULL },
    { PIKA_ROTATE_180, "PIKA_ROTATE_180", NULL },
    { PIKA_ROTATE_270, "PIKA_ROTATE_270", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaRotationType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "rotation-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_run_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_RUN_INTERACTIVE, "PIKA_RUN_INTERACTIVE", "interactive" },
    { PIKA_RUN_NONINTERACTIVE, "PIKA_RUN_NONINTERACTIVE", "noninteractive" },
    { PIKA_RUN_WITH_LAST_VALS, "PIKA_RUN_WITH_LAST_VALS", "with-last-vals" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_RUN_INTERACTIVE, NC_("run-mode", "Run interactively"), NULL },
    { PIKA_RUN_NONINTERACTIVE, NC_("run-mode", "Run non-interactively"), NULL },
    { PIKA_RUN_WITH_LAST_VALS, NC_("run-mode", "Run with last used values"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaRunMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "run-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_select_criterion_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_SELECT_CRITERION_COMPOSITE, "PIKA_SELECT_CRITERION_COMPOSITE", "composite" },
    { PIKA_SELECT_CRITERION_RGB_RED, "PIKA_SELECT_CRITERION_RGB_RED", "rgb-red" },
    { PIKA_SELECT_CRITERION_RGB_GREEN, "PIKA_SELECT_CRITERION_RGB_GREEN", "rgb-green" },
    { PIKA_SELECT_CRITERION_RGB_BLUE, "PIKA_SELECT_CRITERION_RGB_BLUE", "rgb-blue" },
    { PIKA_SELECT_CRITERION_HSV_HUE, "PIKA_SELECT_CRITERION_HSV_HUE", "hsv-hue" },
    { PIKA_SELECT_CRITERION_HSV_SATURATION, "PIKA_SELECT_CRITERION_HSV_SATURATION", "hsv-saturation" },
    { PIKA_SELECT_CRITERION_HSV_VALUE, "PIKA_SELECT_CRITERION_HSV_VALUE", "hsv-value" },
    { PIKA_SELECT_CRITERION_LCH_LIGHTNESS, "PIKA_SELECT_CRITERION_LCH_LIGHTNESS", "lch-lightness" },
    { PIKA_SELECT_CRITERION_LCH_CHROMA, "PIKA_SELECT_CRITERION_LCH_CHROMA", "lch-chroma" },
    { PIKA_SELECT_CRITERION_LCH_HUE, "PIKA_SELECT_CRITERION_LCH_HUE", "lch-hue" },
    { PIKA_SELECT_CRITERION_ALPHA, "PIKA_SELECT_CRITERION_ALPHA", "alpha" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_SELECT_CRITERION_COMPOSITE, NC_("select-criterion", "Composite"), NULL },
    { PIKA_SELECT_CRITERION_RGB_RED, NC_("select-criterion", "Red"), NULL },
    { PIKA_SELECT_CRITERION_RGB_GREEN, NC_("select-criterion", "Green"), NULL },
    { PIKA_SELECT_CRITERION_RGB_BLUE, NC_("select-criterion", "Blue"), NULL },
    { PIKA_SELECT_CRITERION_HSV_HUE, NC_("select-criterion", "HSV Hue"), NULL },
    { PIKA_SELECT_CRITERION_HSV_SATURATION, NC_("select-criterion", "HSV Saturation"), NULL },
    { PIKA_SELECT_CRITERION_HSV_VALUE, NC_("select-criterion", "HSV Value"), NULL },
    { PIKA_SELECT_CRITERION_LCH_LIGHTNESS, NC_("select-criterion", "LCh Lightness"), NULL },
    { PIKA_SELECT_CRITERION_LCH_CHROMA, NC_("select-criterion", "LCh Chroma"), NULL },
    { PIKA_SELECT_CRITERION_LCH_HUE, NC_("select-criterion", "LCh Hue"), NULL },
    { PIKA_SELECT_CRITERION_ALPHA, NC_("select-criterion", "Alpha"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaSelectCriterion", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "select-criterion");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_size_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_PIXELS, "PIKA_PIXELS", "pixels" },
    { PIKA_POINTS, "PIKA_POINTS", "points" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_PIXELS, NC_("size-type", "Pixels"), NULL },
    { PIKA_POINTS, NC_("size-type", "Points"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaSizeType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "size-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_stack_trace_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_STACK_TRACE_NEVER, "PIKA_STACK_TRACE_NEVER", "never" },
    { PIKA_STACK_TRACE_QUERY, "PIKA_STACK_TRACE_QUERY", "query" },
    { PIKA_STACK_TRACE_ALWAYS, "PIKA_STACK_TRACE_ALWAYS", "always" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_STACK_TRACE_NEVER, "PIKA_STACK_TRACE_NEVER", NULL },
    { PIKA_STACK_TRACE_QUERY, "PIKA_STACK_TRACE_QUERY", NULL },
    { PIKA_STACK_TRACE_ALWAYS, "PIKA_STACK_TRACE_ALWAYS", NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaStackTraceMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "stack-trace-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_stroke_method_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_STROKE_LINE, "PIKA_STROKE_LINE", "line" },
    { PIKA_STROKE_PAINT_METHOD, "PIKA_STROKE_PAINT_METHOD", "paint-method" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_STROKE_LINE, NC_("stroke-method", "Stroke line"), NULL },
    { PIKA_STROKE_PAINT_METHOD, NC_("stroke-method", "Stroke with a paint tool"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaStrokeMethod", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "stroke-method");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_text_direction_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TEXT_DIRECTION_LTR, "PIKA_TEXT_DIRECTION_LTR", "ltr" },
    { PIKA_TEXT_DIRECTION_RTL, "PIKA_TEXT_DIRECTION_RTL", "rtl" },
    { PIKA_TEXT_DIRECTION_TTB_RTL, "PIKA_TEXT_DIRECTION_TTB_RTL", "ttb-rtl" },
    { PIKA_TEXT_DIRECTION_TTB_RTL_UPRIGHT, "PIKA_TEXT_DIRECTION_TTB_RTL_UPRIGHT", "ttb-rtl-upright" },
    { PIKA_TEXT_DIRECTION_TTB_LTR, "PIKA_TEXT_DIRECTION_TTB_LTR", "ttb-ltr" },
    { PIKA_TEXT_DIRECTION_TTB_LTR_UPRIGHT, "PIKA_TEXT_DIRECTION_TTB_LTR_UPRIGHT", "ttb-ltr-upright" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TEXT_DIRECTION_LTR, NC_("text-direction", "From left to right"), NULL },
    { PIKA_TEXT_DIRECTION_RTL, NC_("text-direction", "From right to left"), NULL },
    { PIKA_TEXT_DIRECTION_TTB_RTL, NC_("text-direction", "Vertical, right to left (mixed orientation)"), NULL },
    { PIKA_TEXT_DIRECTION_TTB_RTL_UPRIGHT, NC_("text-direction", "Vertical, right to left (upright orientation)"), NULL },
    { PIKA_TEXT_DIRECTION_TTB_LTR, NC_("text-direction", "Vertical, left to right (mixed orientation)"), NULL },
    { PIKA_TEXT_DIRECTION_TTB_LTR_UPRIGHT, NC_("text-direction", "Vertical, left to right (upright orientation)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTextDirection", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "text-direction");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_text_hint_style_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TEXT_HINT_STYLE_NONE, "PIKA_TEXT_HINT_STYLE_NONE", "none" },
    { PIKA_TEXT_HINT_STYLE_SLIGHT, "PIKA_TEXT_HINT_STYLE_SLIGHT", "slight" },
    { PIKA_TEXT_HINT_STYLE_MEDIUM, "PIKA_TEXT_HINT_STYLE_MEDIUM", "medium" },
    { PIKA_TEXT_HINT_STYLE_FULL, "PIKA_TEXT_HINT_STYLE_FULL", "full" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TEXT_HINT_STYLE_NONE, NC_("text-hint-style", "None"), NULL },
    { PIKA_TEXT_HINT_STYLE_SLIGHT, NC_("text-hint-style", "Slight"), NULL },
    { PIKA_TEXT_HINT_STYLE_MEDIUM, NC_("text-hint-style", "Medium"), NULL },
    { PIKA_TEXT_HINT_STYLE_FULL, NC_("text-hint-style", "Full"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTextHintStyle", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "text-hint-style");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_text_justification_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TEXT_JUSTIFY_LEFT, "PIKA_TEXT_JUSTIFY_LEFT", "left" },
    { PIKA_TEXT_JUSTIFY_RIGHT, "PIKA_TEXT_JUSTIFY_RIGHT", "right" },
    { PIKA_TEXT_JUSTIFY_CENTER, "PIKA_TEXT_JUSTIFY_CENTER", "center" },
    { PIKA_TEXT_JUSTIFY_FILL, "PIKA_TEXT_JUSTIFY_FILL", "fill" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TEXT_JUSTIFY_LEFT, NC_("text-justification", "Left justified"), NULL },
    { PIKA_TEXT_JUSTIFY_RIGHT, NC_("text-justification", "Right justified"), NULL },
    { PIKA_TEXT_JUSTIFY_CENTER, NC_("text-justification", "Centered"), NULL },
    { PIKA_TEXT_JUSTIFY_FILL, NC_("text-justification", "Filled"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTextJustification", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "text-justification");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_transfer_mode_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TRANSFER_SHADOWS, "PIKA_TRANSFER_SHADOWS", "shadows" },
    { PIKA_TRANSFER_MIDTONES, "PIKA_TRANSFER_MIDTONES", "midtones" },
    { PIKA_TRANSFER_HIGHLIGHTS, "PIKA_TRANSFER_HIGHLIGHTS", "highlights" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TRANSFER_SHADOWS, NC_("transfer-mode", "Shadows"), NULL },
    { PIKA_TRANSFER_MIDTONES, NC_("transfer-mode", "Midtones"), NULL },
    { PIKA_TRANSFER_HIGHLIGHTS, NC_("transfer-mode", "Highlights"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTransferMode", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "transfer-mode");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_transform_direction_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TRANSFORM_FORWARD, "PIKA_TRANSFORM_FORWARD", "forward" },
    { PIKA_TRANSFORM_BACKWARD, "PIKA_TRANSFORM_BACKWARD", "backward" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TRANSFORM_FORWARD, NC_("transform-direction", "Normal (Forward)"), NULL },
    { PIKA_TRANSFORM_BACKWARD, NC_("transform-direction", "Corrective (Backward)"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTransformDirection", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "transform-direction");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_transform_resize_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_TRANSFORM_RESIZE_ADJUST, "PIKA_TRANSFORM_RESIZE_ADJUST", "adjust" },
    { PIKA_TRANSFORM_RESIZE_CLIP, "PIKA_TRANSFORM_RESIZE_CLIP", "clip" },
    { PIKA_TRANSFORM_RESIZE_CROP, "PIKA_TRANSFORM_RESIZE_CROP", "crop" },
    { PIKA_TRANSFORM_RESIZE_CROP_WITH_ASPECT, "PIKA_TRANSFORM_RESIZE_CROP_WITH_ASPECT", "crop-with-aspect" },
    { 0, NULL, NULL }
  };

  static const PikaEnumDesc descs[] =
  {
    { PIKA_TRANSFORM_RESIZE_ADJUST, NC_("transform-resize", "Adjust"), NULL },
    { PIKA_TRANSFORM_RESIZE_CLIP, NC_("transform-resize", "Clip"), NULL },
    { PIKA_TRANSFORM_RESIZE_CROP, NC_("transform-resize", "Crop to result"), NULL },
    { PIKA_TRANSFORM_RESIZE_CROP_WITH_ASPECT, NC_("transform-resize", "Crop with aspect"), NULL },
    { 0, NULL, NULL }
  };

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaTransformResize", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "transform-resize");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}

GType
pika_vectors_stroke_type_get_type (void)
{
  static const GEnumValue values[] =
  {
    { PIKA_VECTORS_STROKE_TYPE_BEZIER, "PIKA_VECTORS_STROKE_TYPE_BEZIER", "bezier" },
    { 0, NULL, NULL }
  };

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

  static GType type = 0;

  if (G_UNLIKELY (! type))
    {
      type = g_enum_register_static ("PikaVectorsStrokeType", values);
      pika_type_set_translation_domain (type, GETTEXT_PACKAGE "-libpika");
      pika_type_set_translation_context (type, "vectors-stroke-type");
      pika_enum_set_value_descriptions (type, descs);
    }

  return type;
}


/* Generated data ends here */