/* LIBPIKA - The PIKA Library
 * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
 *
 * This library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <https://www.gnu.org/licenses/>.
 */

#ifndef __PIKA_BASE_ENUMS_H__
#define __PIKA_BASE_ENUMS_H__


/**
 * SECTION: pikabaseenums
 * @title: pikabaseenums
 * @short_description: Basic PIKA enumeration data types.
 *
 * Basic PIKA enumeration data types.
 **/


G_BEGIN_DECLS

/* For information look into the C source or the html documentation */


/**
 * PikaAddMaskType:
 * @PIKA_ADD_MASK_WHITE:          White (full opacity)
 * @PIKA_ADD_MASK_BLACK:          Black (full transparency)
 * @PIKA_ADD_MASK_ALPHA:          Layer's alpha channel
 * @PIKA_ADD_MASK_ALPHA_TRANSFER: Transfer layer's alpha channel
 * @PIKA_ADD_MASK_SELECTION:      Selection
 * @PIKA_ADD_MASK_COPY:           Grayscale copy of layer
 * @PIKA_ADD_MASK_CHANNEL:        Channel
 *
 * Modes of initialising a layer mask.
 **/
#define PIKA_TYPE_ADD_MASK_TYPE (pika_add_mask_type_get_type ())

GType pika_add_mask_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_ADD_MASK_WHITE,          /*< desc="_White (full opacity)"           >*/
  PIKA_ADD_MASK_BLACK,          /*< desc="_Black (full transparency)"      >*/
  PIKA_ADD_MASK_ALPHA,          /*< desc="Layer's _alpha channel"          >*/
  PIKA_ADD_MASK_ALPHA_TRANSFER, /*< desc="_Transfer layer's alpha channel" >*/
  PIKA_ADD_MASK_SELECTION,      /*< desc="_Selection"                      >*/
  PIKA_ADD_MASK_COPY,           /*< desc="_Grayscale copy of layer"        >*/
  PIKA_ADD_MASK_CHANNEL         /*< desc="C_hannel"                        >*/
} PikaAddMaskType;


/**
 * PikaBrushGeneratedShape:
 * @PIKA_BRUSH_GENERATED_CIRCLE:  Circle
 * @PIKA_BRUSH_GENERATED_SQUARE:  Square
 * @PIKA_BRUSH_GENERATED_DIAMOND: Diamond
 *
 * Shapes of generated brushes.
 **/
#define PIKA_TYPE_BRUSH_GENERATED_SHAPE (pika_brush_generated_shape_get_type ())

GType pika_brush_generated_shape_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_BRUSH_GENERATED_CIRCLE,  /*< desc="Circle"  >*/
  PIKA_BRUSH_GENERATED_SQUARE,  /*< desc="Square"  >*/
  PIKA_BRUSH_GENERATED_DIAMOND  /*< desc="Diamond" >*/
} PikaBrushGeneratedShape;


/**
 * PikaCapStyle:
 * @PIKA_CAP_BUTT:   Butt
 * @PIKA_CAP_ROUND:  Round
 * @PIKA_CAP_SQUARE: Square
 *
 * Style of line endings.
 **/
#define PIKA_TYPE_CAP_STYLE (pika_cap_style_get_type ())

GType pika_cap_style_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_CAP_BUTT,   /*< desc="Butt"   >*/
  PIKA_CAP_ROUND,  /*< desc="Round"  >*/
  PIKA_CAP_SQUARE  /*< desc="Square" >*/
} PikaCapStyle;


/**
 * PikaChannelOps:
 * @PIKA_CHANNEL_OP_ADD:       Add to the current selection
 * @PIKA_CHANNEL_OP_SUBTRACT:  Subtract from the current selection
 * @PIKA_CHANNEL_OP_REPLACE:   Replace the current selection
 * @PIKA_CHANNEL_OP_INTERSECT: Intersect with the current selection
 *
 * Operations to combine channels and selections.
 **/
#define PIKA_TYPE_CHANNEL_OPS (pika_channel_ops_get_type ())

GType pika_channel_ops_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_CHANNEL_OP_ADD,       /*< desc="Add to the current selection"         >*/
  PIKA_CHANNEL_OP_SUBTRACT,  /*< desc="Subtract from the current selection"  >*/
  PIKA_CHANNEL_OP_REPLACE,   /*< desc="Replace the current selection"        >*/
  PIKA_CHANNEL_OP_INTERSECT  /*< desc="Intersect with the current selection" >*/
} PikaChannelOps;


/**
 * PikaChannelType:
 * @PIKA_CHANNEL_RED:     Red
 * @PIKA_CHANNEL_GREEN:   Green
 * @PIKA_CHANNEL_BLUE:    Blue
 * @PIKA_CHANNEL_GRAY:    Gray
 * @PIKA_CHANNEL_INDEXED: Indexed
 * @PIKA_CHANNEL_ALPHA:   Alpha
 *
 * Channels (as in color components).
 **/
#define PIKA_TYPE_CHANNEL_TYPE (pika_channel_type_get_type ())

GType pika_channel_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_CHANNEL_RED,      /*< desc="Red"     >*/
  PIKA_CHANNEL_GREEN,    /*< desc="Green"   >*/
  PIKA_CHANNEL_BLUE,     /*< desc="Blue"    >*/
  PIKA_CHANNEL_GRAY,     /*< desc="Gray"    >*/
  PIKA_CHANNEL_INDEXED,  /*< desc="Indexed" >*/
  PIKA_CHANNEL_ALPHA     /*< desc="Alpha"   >*/
} PikaChannelType;


/**
 * PikaCheckSize:
 * @PIKA_CHECK_SIZE_SMALL_CHECKS:  Small
 * @PIKA_CHECK_SIZE_MEDIUM_CHECKS: Medium
 * @PIKA_CHECK_SIZE_LARGE_CHECKS:  Large
 *
 * Size of the checkerboard indicating transparency.
 **/
#define PIKA_TYPE_CHECK_SIZE (pika_check_size_get_type ())

GType pika_check_size_get_type (void) G_GNUC_CONST;

typedef enum  /*< pdb-skip >*/
{
  PIKA_CHECK_SIZE_SMALL_CHECKS  = 0,  /*< desc="Small"  >*/
  PIKA_CHECK_SIZE_MEDIUM_CHECKS = 1,  /*< desc="Medium" >*/
  PIKA_CHECK_SIZE_LARGE_CHECKS  = 2   /*< desc="Large"  >*/
} PikaCheckSize;


/**
 * PikaCheckType:
 * @PIKA_CHECK_TYPE_LIGHT_CHECKS: Light checks
 * @PIKA_CHECK_TYPE_GRAY_CHECKS:  Mid-tone checks
 * @PIKA_CHECK_TYPE_DARK_CHECKS:  Dark checks
 * @PIKA_CHECK_TYPE_WHITE_ONLY:   White only
 * @PIKA_CHECK_TYPE_GRAY_ONLY:    Gray only
 * @PIKA_CHECK_TYPE_BLACK_ONLY:   Black only
 * @PIKA_CHECK_TYPE_CUSTOM_CHECKS: Custom checks
 *
 * Color/Brightness of the checkerboard indicating transparency.
 **/
#define PIKA_TYPE_CHECK_TYPE (pika_check_type_get_type ())

GType pika_check_type_get_type (void) G_GNUC_CONST;

typedef enum  /*< pdb-skip >*/
{
  PIKA_CHECK_TYPE_LIGHT_CHECKS = 0,  /*< desc="Light checks"    >*/
  PIKA_CHECK_TYPE_GRAY_CHECKS  = 1,  /*< desc="Mid-tone checks" >*/
  PIKA_CHECK_TYPE_DARK_CHECKS  = 2,  /*< desc="Dark checks"     >*/
  PIKA_CHECK_TYPE_WHITE_ONLY   = 3,  /*< desc="White only"      >*/
  PIKA_CHECK_TYPE_GRAY_ONLY    = 4,  /*< desc="Gray only"       >*/
  PIKA_CHECK_TYPE_BLACK_ONLY   = 5,  /*< desc="Black only"      >*/
  PIKA_CHECK_TYPE_CUSTOM_CHECKS = 6  /*< desc="Custom checks"   >*/
} PikaCheckType;


/**
 * PikaCloneType:
 * @PIKA_CLONE_IMAGE:   Clone from an image/drawable source
 * @PIKA_CLONE_PATTERN: Clone from a pattern source
 *
 * Clone sources.
 **/
#define PIKA_TYPE_CLONE_TYPE (pika_clone_type_get_type ())

GType pika_clone_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_CLONE_IMAGE,    /*< desc="Image"   >*/
  PIKA_CLONE_PATTERN   /*< desc="Pattern" >*/
} PikaCloneType;


/**
 * PikaColorTag:
 * @PIKA_COLOR_TAG_NONE:   None
 * @PIKA_COLOR_TAG_BLUE:   Blue
 * @PIKA_COLOR_TAG_GREEN:  Green
 * @PIKA_COLOR_TAG_YELLOW: Yellow
 * @PIKA_COLOR_TAG_ORANGE: Orange
 * @PIKA_COLOR_TAG_BROWN:  Brown
 * @PIKA_COLOR_TAG_RED:    Red
 * @PIKA_COLOR_TAG_VIOLET: Violet
 * @PIKA_COLOR_TAG_GRAY:   Gray
 *
 * Possible tag colors.
 *
 * Since: 2.10
 **/
#define PIKA_TYPE_COLOR_TAG (pika_color_tag_get_type ())

GType pika_color_tag_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_COLOR_TAG_NONE,   /*< desc="None"   >*/
  PIKA_COLOR_TAG_BLUE,   /*< desc="Blue"   >*/
  PIKA_COLOR_TAG_GREEN,  /*< desc="Green"  >*/
  PIKA_COLOR_TAG_YELLOW, /*< desc="Yellow" >*/
  PIKA_COLOR_TAG_ORANGE, /*< desc="Orange" >*/
  PIKA_COLOR_TAG_BROWN,  /*< desc="Brown"  >*/
  PIKA_COLOR_TAG_RED,    /*< desc="Red"    >*/
  PIKA_COLOR_TAG_VIOLET, /*< desc="Violet" >*/
  PIKA_COLOR_TAG_GRAY    /*< desc="Gray"   >*/
} PikaColorTag;


/**
 * PikaComponentType:
 * @PIKA_COMPONENT_TYPE_U8:     8-bit integer
 * @PIKA_COMPONENT_TYPE_U16:    16-bit integer
 * @PIKA_COMPONENT_TYPE_U32:    32-bit integer
 * @PIKA_COMPONENT_TYPE_HALF:   16-bit floating point
 * @PIKA_COMPONENT_TYPE_FLOAT:  32-bit floating point
 * @PIKA_COMPONENT_TYPE_DOUBLE: 64-bit floating point
 *
 * Encoding types of image components.
 *
 * Since: 2.10
 **/
#define PIKA_TYPE_COMPONENT_TYPE (pika_component_type_get_type ())

GType pika_component_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_COMPONENT_TYPE_U8     = 100, /*< desc="8-bit integer"         >*/
  PIKA_COMPONENT_TYPE_U16    = 200, /*< desc="16-bit integer"        >*/
  PIKA_COMPONENT_TYPE_U32    = 300, /*< desc="32-bit integer"        >*/
  PIKA_COMPONENT_TYPE_HALF   = 500, /*< desc="16-bit floating point" >*/
  PIKA_COMPONENT_TYPE_FLOAT  = 600, /*< desc="32-bit floating point" >*/
  PIKA_COMPONENT_TYPE_DOUBLE = 700  /*< desc="64-bit floating point" >*/
} PikaComponentType;


/**
 * PikaConvertPaletteType:
 * @PIKA_CONVERT_PALETTE_GENERATE: Generate optimum palette
 * @PIKA_CONVERT_PALETTE_WEB:      Use web-optimized palette
 * @PIKA_CONVERT_PALETTE_MONO:     Use black and white (1-bit) palette
 * @PIKA_CONVERT_PALETTE_CUSTOM:   Use custom palette
 *
 * Types of palettes for indexed conversion.
 **/
#define PIKA_TYPE_CONVERT_PALETTE_TYPE (pika_convert_palette_type_get_type ())

GType pika_convert_palette_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_CONVERT_PALETTE_GENERATE, /*< desc="Generate optimum palette"          >*/
  PIKA_CONVERT_PALETTE_WEB,      /*< desc="Use web-optimized palette"         >*/
  PIKA_CONVERT_PALETTE_MONO,     /*< desc="Use black and white (1-bit) palette" >*/
  PIKA_CONVERT_PALETTE_CUSTOM    /*< desc="Use custom palette"                >*/
} PikaConvertPaletteType;


/**
 * PikaConvolveType:
 * @PIKA_CONVOLVE_BLUR:    Blur
 * @PIKA_CONVOLVE_SHARPEN: Sharpen
 *
 * Types of convolutions.
 **/
#define PIKA_TYPE_CONVOLVE_TYPE (pika_convolve_type_get_type ())

GType pika_convolve_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_CONVOLVE_BLUR,    /*< desc="Blur"    >*/
  PIKA_CONVOLVE_SHARPEN  /*< desc="Sharpen" >*/
} PikaConvolveType;


/**
 * PikaDesaturateMode:
 * @PIKA_DESATURATE_LIGHTNESS:  Lightness (HSL)
 * @PIKA_DESATURATE_LUMA:       Luma
 * @PIKA_DESATURATE_AVERAGE:    Average (HSI Intensity)
 * @PIKA_DESATURATE_LUMINANCE:  Luminance
 * @PIKA_DESATURATE_VALUE:      Value (HSV)
 *
 * Grayscale conversion methods.
 **/
#define PIKA_TYPE_DESATURATE_MODE (pika_desaturate_mode_get_type ())

GType pika_desaturate_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_DESATURATE_LIGHTNESS,   /*< desc="Lightness (HSL)"          >*/
  PIKA_DESATURATE_LUMA,        /*< desc="Luma"                     >*/
  PIKA_DESATURATE_AVERAGE,     /*< desc="Average (HSI Intensity)"  >*/
  PIKA_DESATURATE_LUMINANCE,   /*< desc="Luminance"                >*/
  PIKA_DESATURATE_VALUE        /*< desc="Value (HSV)"              >*/
} PikaDesaturateMode;


/**
 * PikaDodgeBurnType:
 * @PIKA_DODGE_BURN_TYPE_DODGE: Dodge
 * @PIKA_DODGE_BURN_TYPE_BURN:  Burn
 *
 * Methods for the dodge/burn operation.
 **/
#define PIKA_TYPE_DODGE_BURN_TYPE (pika_dodge_burn_type_get_type ())

GType pika_dodge_burn_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_DODGE_BURN_TYPE_DODGE,  /*< desc="Dodge" >*/
  PIKA_DODGE_BURN_TYPE_BURN    /*< desc="Burn"  >*/
} PikaDodgeBurnType;


/**
 * PikaFillType:
 * @PIKA_FILL_FOREGROUND:         Foreground color
 * @PIKA_FILL_BACKGROUND:         Background color
 * @PIKA_FILL_CIELAB_MIDDLE_GRAY: Middle Gray (CIELAB)
 * @PIKA_FILL_WHITE:              White
 * @PIKA_FILL_TRANSPARENT:        Transparency
 * @PIKA_FILL_PATTERN:            Pattern
 *
 * Types of filling.
 **/
#define PIKA_TYPE_FILL_TYPE (pika_fill_type_get_type ())

GType pika_fill_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_FILL_FOREGROUND,         /*< desc="Foreground color" >*/
  PIKA_FILL_BACKGROUND,         /*< desc="Background color" >*/
  PIKA_FILL_CIELAB_MIDDLE_GRAY, /*< desc="Middle Gray (CIELAB)" >*/
  PIKA_FILL_WHITE,              /*< desc="White"            >*/
  PIKA_FILL_TRANSPARENT,        /*< desc="Transparency"     >*/
  PIKA_FILL_PATTERN             /*< desc="Pattern"          >*/
} PikaFillType;


/**
 * PikaForegroundExtractMode:
 * @PIKA_FOREGROUND_EXTRACT_MATTING: Matting (Since 2.10)
 *
 * Foreground extract engines.
 **/
#define PIKA_TYPE_FOREGROUND_EXTRACT_MODE (pika_foreground_extract_mode_get_type ())

GType pika_foreground_extract_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_FOREGROUND_EXTRACT_MATTING
} PikaForegroundExtractMode;


/**
 * PikaGradientBlendColorSpace:
 * @PIKA_GRADIENT_BLEND_RGB_PERCEPTUAL: Perceptual RGB
 * @PIKA_GRADIENT_BLEND_RGB_LINEAR:     Linear RGB
 * @PIKA_GRADIENT_BLEND_CIE_LAB:        CIE Lab
 *
 * Color space for blending gradients.
 *
 * Since: 2.10
 */
#define PIKA_TYPE_GRADIENT_BLEND_COLOR_SPACE (pika_gradient_blend_color_space_get_type ())

GType pika_gradient_blend_color_space_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_GRADIENT_BLEND_RGB_PERCEPTUAL,  /*< desc="Perceptual RGB", nick=rgb-perceptual >*/
  PIKA_GRADIENT_BLEND_RGB_LINEAR,      /*< desc="Linear RGB",     nick=rgb-linear     >*/
  PIKA_GRADIENT_BLEND_CIE_LAB          /*< desc="CIE Lab",        nick=cie-lab        >*/
} PikaGradientBlendColorSpace;


/**
 * PikaGradientSegmentColor:
 * @PIKA_GRADIENT_SEGMENT_RGB:     RGB
 * @PIKA_GRADIENT_SEGMENT_HSV_CCW: HSV (counter-clockwise hue)
 * @PIKA_GRADIENT_SEGMENT_HSV_CW:  HSV (clockwise hue)
 *
 * Coloring types for gradient segments.
 **/
#define PIKA_TYPE_GRADIENT_SEGMENT_COLOR (pika_gradient_segment_color_get_type ())

GType pika_gradient_segment_color_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_GRADIENT_SEGMENT_RGB,      /*< desc="RGB"                                             >*/
  PIKA_GRADIENT_SEGMENT_HSV_CCW,  /*< desc="HSV (counter-clockwise hue)", abbrev="HSV (ccw)" >*/
  PIKA_GRADIENT_SEGMENT_HSV_CW    /*< desc="HSV (clockwise hue)",         abbrev="HSV (cw)"  >*/
} PikaGradientSegmentColor;


/**
 * PikaGradientSegmentType:
 * @PIKA_GRADIENT_SEGMENT_LINEAR:            Linear
 * @PIKA_GRADIENT_SEGMENT_CURVED:            Curved
 * @PIKA_GRADIENT_SEGMENT_SINE:              Sinusoidal
 * @PIKA_GRADIENT_SEGMENT_SPHERE_INCREASING: Spherical (increasing)
 * @PIKA_GRADIENT_SEGMENT_SPHERE_DECREASING: Spherical (decreasing)
 * @PIKA_GRADIENT_SEGMENT_STEP:              Step
 *
 * Transition functions for gradient segments.
 **/
#define PIKA_TYPE_GRADIENT_SEGMENT_TYPE (pika_gradient_segment_type_get_type ())

GType pika_gradient_segment_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_GRADIENT_SEGMENT_LINEAR,             /*< desc="Linear"                                           >*/
  PIKA_GRADIENT_SEGMENT_CURVED,             /*< desc="Curved"                                           >*/
  PIKA_GRADIENT_SEGMENT_SINE,               /*< desc="Sinusoidal"                                       >*/
  PIKA_GRADIENT_SEGMENT_SPHERE_INCREASING,  /*< desc="Spherical (increasing)", abbrev="Spherical (inc)" >*/
  PIKA_GRADIENT_SEGMENT_SPHERE_DECREASING,  /*< desc="Spherical (decreasing)", abbrev="Spherical (dec)" >*/
  PIKA_GRADIENT_SEGMENT_STEP                /*< desc="Step"                                             >*/
} PikaGradientSegmentType;


/**
 * PikaGradientType:
 * @PIKA_GRADIENT_LINEAR:               Linear
 * @PIKA_GRADIENT_BILINEAR:             Bi-linear
 * @PIKA_GRADIENT_RADIAL:               Radial
 * @PIKA_GRADIENT_SQUARE:               Square
 * @PIKA_GRADIENT_CONICAL_SYMMETRIC:    Conical (symmetric)
 * @PIKA_GRADIENT_CONICAL_ASYMMETRIC:   Conical (asymmetric)
 * @PIKA_GRADIENT_SHAPEBURST_ANGULAR:   Shaped (angular)
 * @PIKA_GRADIENT_SHAPEBURST_SPHERICAL: Shaped (spherical)
 * @PIKA_GRADIENT_SHAPEBURST_DIMPLED:   Shaped (dimpled)
 * @PIKA_GRADIENT_SPIRAL_CLOCKWISE:     Spiral (clockwise)
 * @PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE: Spiral (counter-clockwise)
 *
 * Gradient shapes.
 **/
#define PIKA_TYPE_GRADIENT_TYPE (pika_gradient_type_get_type ())

GType pika_gradient_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_GRADIENT_LINEAR,                /*< desc="Linear"                                              >*/
  PIKA_GRADIENT_BILINEAR,              /*< desc="Bi-linear"                                           >*/
  PIKA_GRADIENT_RADIAL,                /*< desc="Radial"                                              >*/
  PIKA_GRADIENT_SQUARE,                /*< desc="Square"                                              >*/
  PIKA_GRADIENT_CONICAL_SYMMETRIC,     /*< desc="Conical (symmetric)",        abbrev="Conical (sym)"  >*/
  PIKA_GRADIENT_CONICAL_ASYMMETRIC,    /*< desc="Conical (asymmetric)",       abbrev="Conical (asym)" >*/
  PIKA_GRADIENT_SHAPEBURST_ANGULAR,    /*< desc="Shaped (angular)"                                    >*/
  PIKA_GRADIENT_SHAPEBURST_SPHERICAL,  /*< desc="Shaped (spherical)"                                  >*/
  PIKA_GRADIENT_SHAPEBURST_DIMPLED,    /*< desc="Shaped (dimpled)"                                    >*/
  PIKA_GRADIENT_SPIRAL_CLOCKWISE,      /*< desc="Spiral (clockwise)",         abbrev="Spiral (cw)"    >*/
  PIKA_GRADIENT_SPIRAL_ANTICLOCKWISE   /*< desc="Spiral (counter-clockwise)", abbrev="Spiral (ccw)"   >*/
} PikaGradientType;


/**
 * PikaGridStyle:
 * @PIKA_GRID_DOTS:          Intersections (dots)
 * @PIKA_GRID_INTERSECTIONS: Intersections (crosshairs)
 * @PIKA_GRID_ON_OFF_DASH:   Dashed
 * @PIKA_GRID_DOUBLE_DASH:   Double dashed
 * @PIKA_GRID_SOLID:         Solid
 *
 * Rendering types for the display grid.
 **/
#define PIKA_TYPE_GRID_STYLE (pika_grid_style_get_type ())

GType pika_grid_style_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_GRID_DOTS,           /*< desc="Intersections (dots)"       >*/
  PIKA_GRID_INTERSECTIONS,  /*< desc="Intersections (crosshairs)" >*/
  PIKA_GRID_ON_OFF_DASH,    /*< desc="Dashed"                     >*/
  PIKA_GRID_DOUBLE_DASH,    /*< desc="Double dashed"              >*/
  PIKA_GRID_SOLID           /*< desc="Solid"                      >*/
} PikaGridStyle;


/**
 * PikaHueRange:
 * @PIKA_HUE_RANGE_ALL:     All hues
 * @PIKA_HUE_RANGE_RED:     Red hues
 * @PIKA_HUE_RANGE_YELLOW:  Yellow hues
 * @PIKA_HUE_RANGE_GREEN:   Green hues
 * @PIKA_HUE_RANGE_CYAN:    Cyan hues
 * @PIKA_HUE_RANGE_BLUE:    Blue hues
 * @PIKA_HUE_RANGE_MAGENTA: Magenta hues
 *
 * Hue ranges.
 **/
#define PIKA_TYPE_HUE_RANGE (pika_hue_range_get_type ())

GType pika_hue_range_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_HUE_RANGE_ALL,
  PIKA_HUE_RANGE_RED,
  PIKA_HUE_RANGE_YELLOW,
  PIKA_HUE_RANGE_GREEN,
  PIKA_HUE_RANGE_CYAN,
  PIKA_HUE_RANGE_BLUE,
  PIKA_HUE_RANGE_MAGENTA
} PikaHueRange;


/**
 * PikaIconType:
 * @PIKA_ICON_TYPE_ICON_NAME:  Icon name
 * @PIKA_ICON_TYPE_PIXBUF:     Inline pixbuf
 * @PIKA_ICON_TYPE_IMAGE_FILE: Image file
 *
 * Icon types for plug-ins to register.
 **/
#define PIKA_TYPE_ICON_TYPE (pika_icon_type_get_type ())

GType pika_icon_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_ICON_TYPE_ICON_NAME,  /*< desc="Icon name"  >*/
  PIKA_ICON_TYPE_PIXBUF,     /*< desc="Pixbuf"     >*/
  PIKA_ICON_TYPE_IMAGE_FILE  /*< desc="Image file" >*/
} PikaIconType;


/**
 * PikaImageBaseType:
 * @PIKA_RGB:     RGB color
 * @PIKA_GRAY:    Grayscale
 * @PIKA_INDEXED: Indexed color
 *
 * Image color models.
 **/
#define PIKA_TYPE_IMAGE_BASE_TYPE (pika_image_base_type_get_type ())

GType pika_image_base_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_RGB,     /*< desc="RGB color"     >*/
  PIKA_GRAY,    /*< desc="Grayscale"     >*/
  PIKA_INDEXED  /*< desc="Indexed color" >*/
} PikaImageBaseType;


/**
 * PikaImageType:
 * @PIKA_RGB_IMAGE:      RGB
 * @PIKA_RGBA_IMAGE:     RGB-alpha
 * @PIKA_GRAY_IMAGE:     Grayscale
 * @PIKA_GRAYA_IMAGE:    Grayscale-alpha
 * @PIKA_INDEXED_IMAGE:  Indexed
 * @PIKA_INDEXEDA_IMAGE: Indexed-alpha
 *
 * Possible drawable types.
 **/
#define PIKA_TYPE_IMAGE_TYPE (pika_image_type_get_type ())

GType pika_image_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_RGB_IMAGE,      /*< desc="RGB"             >*/
  PIKA_RGBA_IMAGE,     /*< desc="RGB-alpha"       >*/
  PIKA_GRAY_IMAGE,     /*< desc="Grayscale"       >*/
  PIKA_GRAYA_IMAGE,    /*< desc="Grayscale-alpha" >*/
  PIKA_INDEXED_IMAGE,  /*< desc="Indexed"         >*/
  PIKA_INDEXEDA_IMAGE  /*< desc="Indexed-alpha"   >*/
} PikaImageType;


/**
 * PikaInkBlobType:
 * @PIKA_INK_BLOB_TYPE_CIRCLE:  Circle
 * @PIKA_INK_BLOB_TYPE_SQUARE:  Square
 * @PIKA_INK_BLOB_TYPE_DIAMOND: Diamond
 *
 * Ink tool tips.
 **/
#define PIKA_TYPE_INK_BLOB_TYPE (pika_ink_blob_type_get_type ())

GType pika_ink_blob_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_INK_BLOB_TYPE_CIRCLE,  /*< desc="Circle"  >*/
  PIKA_INK_BLOB_TYPE_SQUARE,  /*< desc="Square"  >*/
  PIKA_INK_BLOB_TYPE_DIAMOND  /*< desc="Diamond" >*/
} PikaInkBlobType;


/**
 * PikaInterpolationType:
 * @PIKA_INTERPOLATION_NONE:   None
 * @PIKA_INTERPOLATION_LINEAR: Linear
 * @PIKA_INTERPOLATION_CUBIC:  Cubic
 * @PIKA_INTERPOLATION_NOHALO: NoHalo
 * @PIKA_INTERPOLATION_LOHALO: LoHalo
 *
 * Interpolation types.
 **/
#define PIKA_TYPE_INTERPOLATION_TYPE (pika_interpolation_type_get_type ())

GType pika_interpolation_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_INTERPOLATION_NONE,   /*< desc="None"   >*/
  PIKA_INTERPOLATION_LINEAR, /*< desc="Linear" >*/
  PIKA_INTERPOLATION_CUBIC,  /*< desc="Cubic"  >*/
  PIKA_INTERPOLATION_NOHALO, /*< desc="NoHalo" >*/
  PIKA_INTERPOLATION_LOHALO  /*< desc="LoHalo" >*/
} PikaInterpolationType;


/**
 * PikaJoinStyle:
 * @PIKA_JOIN_MITER: Miter
 * @PIKA_JOIN_ROUND: Round
 * @PIKA_JOIN_BEVEL: Bevel
 *
 * Line join styles.
 **/
#define PIKA_TYPE_JOIN_STYLE (pika_join_style_get_type ())

GType pika_join_style_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_JOIN_MITER,  /*< desc="Miter" >*/
  PIKA_JOIN_ROUND,  /*< desc="Round" >*/
  PIKA_JOIN_BEVEL   /*< desc="Bevel" >*/
} PikaJoinStyle;


/**
 * PikaMaskApplyMode:
 * @PIKA_MASK_APPLY:   Apply the mask
 * @PIKA_MASK_DISCARD: Discard the mask
 *
 * Layer mask apply modes.
 **/
#define PIKA_TYPE_MASK_APPLY_MODE (pika_mask_apply_mode_get_type ())

GType pika_mask_apply_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_MASK_APPLY,
  PIKA_MASK_DISCARD
} PikaMaskApplyMode;


/**
 * PikaMergeType:
 * @PIKA_EXPAND_AS_NECESSARY:  Expanded as necessary
 * @PIKA_CLIP_TO_IMAGE:        Clipped to image
 * @PIKA_CLIP_TO_BOTTOM_LAYER: Clipped to bottom layer
 * @PIKA_FLATTEN_IMAGE:        Flatten
 *
 * Types of merging layers.
 **/
#define PIKA_TYPE_MERGE_TYPE (pika_merge_type_get_type ())

GType pika_merge_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_EXPAND_AS_NECESSARY,  /*< desc="Expanded as necessary"  >*/
  PIKA_CLIP_TO_IMAGE,        /*< desc="Clipped to image"        >*/
  PIKA_CLIP_TO_BOTTOM_LAYER, /*< desc="Clipped to bottom layer" >*/
  PIKA_FLATTEN_IMAGE         /*< desc="Flatten"                 >*/
} PikaMergeType;


/**
 * PikaMessageHandlerType:
 * @PIKA_MESSAGE_BOX:   A popup dialog
 * @PIKA_CONSOLE:       The terminal
 * @PIKA_ERROR_CONSOLE: The error console dockable
 *
 * How to present messages.
 **/
#define PIKA_TYPE_MESSAGE_HANDLER_TYPE (pika_message_handler_type_get_type ())

GType pika_message_handler_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_MESSAGE_BOX,
  PIKA_CONSOLE,
  PIKA_ERROR_CONSOLE
} PikaMessageHandlerType;


/**
 * PikaOffsetType:
 * @PIKA_OFFSET_BACKGROUND:  Background
 * @PIKA_OFFSET_TRANSPARENT: Transparent
 * @PIKA_OFFSET_WRAP_AROUND: Wrap image around
 *
 * Background fill types for the offset operation.
 **/
#define PIKA_TYPE_OFFSET_TYPE (pika_offset_type_get_type ())

GType pika_offset_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_OFFSET_BACKGROUND,
  PIKA_OFFSET_TRANSPARENT,
  PIKA_OFFSET_WRAP_AROUND
} PikaOffsetType;


/**
 * PikaOrientationType:
 * @PIKA_ORIENTATION_HORIZONTAL: Horizontal
 * @PIKA_ORIENTATION_VERTICAL:   Vertical
 * @PIKA_ORIENTATION_UNKNOWN:    Unknown
 *
 * Orientations for various purposes.
 **/
#define PIKA_TYPE_ORIENTATION_TYPE (pika_orientation_type_get_type ())

GType pika_orientation_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_ORIENTATION_HORIZONTAL, /*< desc="Horizontal" >*/
  PIKA_ORIENTATION_VERTICAL,   /*< desc="Vertical"   >*/
  PIKA_ORIENTATION_UNKNOWN     /*< desc="Unknown"    >*/
} PikaOrientationType;


/**
 * PikaPaintApplicationMode:
 * @PIKA_PAINT_CONSTANT:    Constant
 * @PIKA_PAINT_INCREMENTAL: Incremental
 *
 * Paint application modes.
 **/
#define PIKA_TYPE_PAINT_APPLICATION_MODE (pika_paint_application_mode_get_type ())

GType pika_paint_application_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PAINT_CONSTANT,    /*< desc="Constant"    >*/
  PIKA_PAINT_INCREMENTAL  /*< desc="Incremental" >*/
} PikaPaintApplicationMode;


/**
 * PikaPDBErrorHandler:
 * @PIKA_PDB_ERROR_HANDLER_INTERNAL: Internal
 * @PIKA_PDB_ERROR_HANDLER_PLUGIN:   Plug-In
 *
 * PDB error handlers.
 **/
#define PIKA_TYPE_PDB_ERROR_HANDLER (pika_pdb_error_handler_get_type ())

GType pika_pdb_error_handler_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PDB_ERROR_HANDLER_INTERNAL,
  PIKA_PDB_ERROR_HANDLER_PLUGIN
} PikaPDBErrorHandler;


/**
 * PikaPDBProcType:
 * @PIKA_PDB_PROC_TYPE_INTERNAL:  Internal PIKA procedure
 * @PIKA_PDB_PROC_TYPE_PLUGIN:    PIKA Plug-In
 * @PIKA_PDB_PROC_TYPE_EXTENSION: PIKA Extension
 * @PIKA_PDB_PROC_TYPE_TEMPORARY: Temporary Procedure
 *
 * Types of PDB procedures.
 **/
#define PIKA_TYPE_PDB_PROC_TYPE (pika_pdb_proc_type_get_type ())

GType pika_pdb_proc_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PDB_PROC_TYPE_INTERNAL,   /*< desc="Internal PIKA procedure" >*/
  PIKA_PDB_PROC_TYPE_PLUGIN,     /*< desc="PIKA Plug-In" >*/
  PIKA_PDB_PROC_TYPE_EXTENSION,  /*< desc="PIKA Extension" >*/
  PIKA_PDB_PROC_TYPE_TEMPORARY   /*< desc="Temporary Procedure" >*/
} PikaPDBProcType;


/**
 * PikaPDBStatusType:
 * @PIKA_PDB_EXECUTION_ERROR: Execution error
 * @PIKA_PDB_CALLING_ERROR:   Calling error
 * @PIKA_PDB_PASS_THROUGH:    Pass through
 * @PIKA_PDB_SUCCESS:         Success
 * @PIKA_PDB_CANCEL:          User cancel
 *
 * Return status of PDB calls.
 **/
#define PIKA_TYPE_PDB_STATUS_TYPE (pika_pdb_status_type_get_type ())

GType pika_pdb_status_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PDB_EXECUTION_ERROR,
  PIKA_PDB_CALLING_ERROR,
  PIKA_PDB_PASS_THROUGH,
  PIKA_PDB_SUCCESS,
  PIKA_PDB_CANCEL
} PikaPDBStatusType;


/**
 * PikaPrecision:
 * @PIKA_PRECISION_U8_LINEAR:         8-bit linear integer
 * @PIKA_PRECISION_U8_NON_LINEAR:     8-bit non-linear integer
 * @PIKA_PRECISION_U8_PERCEPTUAL:     8-bit perceptual integer
 * @PIKA_PRECISION_U16_LINEAR:        16-bit linear integer
 * @PIKA_PRECISION_U16_NON_LINEAR:    16-bit non-linear integer
 * @PIKA_PRECISION_U16_PERCEPTUAL:    16-bit perceptual integer
 * @PIKA_PRECISION_U32_LINEAR:        32-bit linear integer
 * @PIKA_PRECISION_U32_NON_LINEAR:    32-bit non-linear integer
 * @PIKA_PRECISION_U32_PERCEPTUAL:    32-bit perceptual integer
 * @PIKA_PRECISION_HALF_LINEAR:       16-bit linear floating point
 * @PIKA_PRECISION_HALF_NON_LINEAR:   16-bit non-linear floating point
 * @PIKA_PRECISION_HALF_PERCEPTUAL:   16-bit perceptual floating point
 * @PIKA_PRECISION_FLOAT_LINEAR:      32-bit linear floating point
 * @PIKA_PRECISION_FLOAT_NON_LINEAR:  32-bit non-linear floating point
 * @PIKA_PRECISION_FLOAT_PERCEPTUAL:  32-bit perceptual floating point
 * @PIKA_PRECISION_DOUBLE_LINEAR:     64-bit linear floating point
 * @PIKA_PRECISION_DOUBLE_NON_LINEAR: 64-bit non-linear floating point
 * @PIKA_PRECISION_DOUBLE_PERCEPTUAL: 64-bit perceptual floating point
 * @PIKA_PRECISION_U8_GAMMA:      deprecated alias for
 *                                @PIKA_PRECISION_U8_NON_LINEAR
 * @PIKA_PRECISION_U16_GAMMA:     deprecated alias for
 *                                @PIKA_PRECISION_U16_NON_LINEAR
 * @PIKA_PRECISION_U32_GAMMA:     deprecated alias for
 *                                @PIKA_PRECISION_U32_NON_LINEAR
 * @PIKA_PRECISION_HALF_GAMMA:    deprecated alias for
 *                                @PIKA_PRECISION_HALF_NON_LINEAR
 * @PIKA_PRECISION_FLOAT_GAMMA:   deprecated alias for
 *                                @PIKA_PRECISION_FLOAT_NON_LINEAR
 * @PIKA_PRECISION_DOUBLE_GAMMA:  deprecated alias for
 *                                @PIKA_PRECISION_DOUBLE_NON_LINEAR
 *
 * Precisions for pixel encoding.
 *
 * Since: 2.10
 **/
#define PIKA_TYPE_PRECISION (pika_precision_get_type ())

GType pika_precision_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PRECISION_U8_LINEAR         = 100, /*< desc="8-bit linear integer"         >*/
  PIKA_PRECISION_U8_NON_LINEAR     = 150, /*< desc="8-bit non-linear integer"          >*/
  PIKA_PRECISION_U8_PERCEPTUAL     = 175, /*< desc="8-bit perceptual integer"          >*/
  PIKA_PRECISION_U16_LINEAR        = 200, /*< desc="16-bit linear integer"        >*/
  PIKA_PRECISION_U16_NON_LINEAR    = 250, /*< desc="16-bit non-linear integer"         >*/
  PIKA_PRECISION_U16_PERCEPTUAL    = 275, /*< desc="16-bit perceptual integer"         >*/
  PIKA_PRECISION_U32_LINEAR        = 300, /*< desc="32-bit linear integer"        >*/
  PIKA_PRECISION_U32_NON_LINEAR    = 350, /*< desc="32-bit non-linear integer"         >*/
  PIKA_PRECISION_U32_PERCEPTUAL    = 375, /*< desc="32-bit perceptual integer"         >*/
  PIKA_PRECISION_HALF_LINEAR       = 500, /*< desc="16-bit linear floating point" >*/
  PIKA_PRECISION_HALF_NON_LINEAR   = 550, /*< desc="16-bit non-linear floating point"  >*/
  PIKA_PRECISION_HALF_PERCEPTUAL   = 575, /*< desc="16-bit perceptual floating point"  >*/
  PIKA_PRECISION_FLOAT_LINEAR      = 600, /*< desc="32-bit linear floating point" >*/
  PIKA_PRECISION_FLOAT_NON_LINEAR  = 650, /*< desc="32-bit non-linear floating point"  >*/
  PIKA_PRECISION_FLOAT_PERCEPTUAL  = 675, /*< desc="32-bit perceptual floating point"  >*/
  PIKA_PRECISION_DOUBLE_LINEAR     = 700, /*< desc="64-bit linear floating point" >*/
  PIKA_PRECISION_DOUBLE_NON_LINEAR = 750, /*< desc="64-bit non-linear floating point"  >*/
  PIKA_PRECISION_DOUBLE_PERCEPTUAL = 775, /*< desc="64-bit perceptual floating point"  >*/

#ifndef PIKA_DISABLE_DEPRECATED
  PIKA_PRECISION_U8_GAMMA      = PIKA_PRECISION_U8_NON_LINEAR,
  PIKA_PRECISION_U16_GAMMA     = PIKA_PRECISION_U16_NON_LINEAR,
  PIKA_PRECISION_U32_GAMMA     = PIKA_PRECISION_U32_NON_LINEAR,
  PIKA_PRECISION_HALF_GAMMA    = PIKA_PRECISION_HALF_NON_LINEAR,
  PIKA_PRECISION_FLOAT_GAMMA   = PIKA_PRECISION_FLOAT_NON_LINEAR,
  PIKA_PRECISION_DOUBLE_GAMMA  = PIKA_PRECISION_DOUBLE_NON_LINEAR
#endif
} PikaPrecision;


/**
 * PikaProcedureSensitivityMask:
 * @PIKA_PROCEDURE_SENSITIVE_DRAWABLE:     Handles image with one selected drawable.
 * @PIKA_PROCEDURE_SENSITIVE_DRAWABLES:    Handles image with several selected drawables.
 * @PIKA_PROCEDURE_SENSITIVE_NO_DRAWABLES: Handles image with no selected drawables.
 * @PIKA_PROCEDURE_SENSITIVE_NO_IMAGE:     Handles no image.
 *
 * The cases when a #PikaProcedure should be shown as sensitive.
 **/
#define PIKA_TYPE_PROCEDURE_SENSITIVITY_MASK (pika_procedure_sensitivity_mask_get_type ())

GType pika_procedure_sensitivity_mask_get_type (void) G_GNUC_CONST;
typedef enum  /*< pdb-skip >*/
{
  PIKA_PROCEDURE_SENSITIVE_DRAWABLE      = 1 << 0,
  PIKA_PROCEDURE_SENSITIVE_DRAWABLES     = 1 << 2,
  PIKA_PROCEDURE_SENSITIVE_NO_DRAWABLES  = 1 << 3,
  PIKA_PROCEDURE_SENSITIVE_NO_IMAGE      = 1 << 4,
  PIKA_PROCEDURE_SENSITIVE_ALWAYS        = G_MAXINT
} PikaProcedureSensitivityMask;


/**
 * PikaProgressCommand:
 * @PIKA_PROGRESS_COMMAND_START:      Start a progress
 * @PIKA_PROGRESS_COMMAND_END:        End the progress
 * @PIKA_PROGRESS_COMMAND_SET_TEXT:   Set the text
 * @PIKA_PROGRESS_COMMAND_SET_VALUE:  Set the percentage
 * @PIKA_PROGRESS_COMMAND_PULSE:      Pulse the progress
 * @PIKA_PROGRESS_COMMAND_GET_WINDOW: Get the window where the progress is shown
 *
 * Commands for the progress API.
 **/
#define PIKA_TYPE_PROGRESS_COMMAND (pika_progress_command_get_type ())

GType pika_progress_command_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PROGRESS_COMMAND_START,
  PIKA_PROGRESS_COMMAND_END,
  PIKA_PROGRESS_COMMAND_SET_TEXT,
  PIKA_PROGRESS_COMMAND_SET_VALUE,
  PIKA_PROGRESS_COMMAND_PULSE,
  PIKA_PROGRESS_COMMAND_GET_WINDOW
} PikaProgressCommand;


/**
 * PikaRepeatMode:
 * @PIKA_REPEAT_NONE:       None (extend)
 * @PIKA_REPEAT_SAWTOOTH:   Sawtooth wave
 * @PIKA_REPEAT_TRIANGULAR: Triangular wave
 * @PIKA_REPEAT_TRUNCATE:   Truncate
 *
 * Repeat modes for example for gradients.
 **/
#define PIKA_TYPE_REPEAT_MODE (pika_repeat_mode_get_type ())

GType pika_repeat_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_REPEAT_NONE,       /*< desc="None (extend)"   >*/
  PIKA_REPEAT_SAWTOOTH,   /*< desc="Sawtooth wave"   >*/
  PIKA_REPEAT_TRIANGULAR, /*< desc="Triangular wave" >*/
  PIKA_REPEAT_TRUNCATE    /*< desc="Truncate"        >*/
} PikaRepeatMode;


/**
 * PikaRotationType:
 * @PIKA_ROTATE_90:  90 degrees
 * @PIKA_ROTATE_180: 180 degrees
 * @PIKA_ROTATE_270: 270 degrees
 *
 * Types of simple rotations.
 **/
#define PIKA_TYPE_ROTATION_TYPE (pika_rotation_type_get_type ())

GType pika_rotation_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_ROTATE_90,
  PIKA_ROTATE_180,
  PIKA_ROTATE_270
} PikaRotationType;


/**
 * PikaRunMode:
 * @PIKA_RUN_INTERACTIVE:    Run interactively
 * @PIKA_RUN_NONINTERACTIVE: Run non-interactively
 * @PIKA_RUN_WITH_LAST_VALS: Run with last used values
 *
 * Run modes for plug-ins.
 **/
#define PIKA_TYPE_RUN_MODE (pika_run_mode_get_type ())

GType pika_run_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_RUN_INTERACTIVE,     /*< desc="Run interactively"         >*/
  PIKA_RUN_NONINTERACTIVE,  /*< desc="Run non-interactively"     >*/
  PIKA_RUN_WITH_LAST_VALS   /*< desc="Run with last used values" >*/
} PikaRunMode;


/**
 * PikaSelectCriterion:
 * @PIKA_SELECT_CRITERION_COMPOSITE:      Composite
 * @PIKA_SELECT_CRITERION_RGB_RED:        Red
 * @PIKA_SELECT_CRITERION_RGB_GREEN:      Green
 * @PIKA_SELECT_CRITERION_RGB_BLUE:       Blue
 * @PIKA_SELECT_CRITERION_HSV_HUE:        HSV Hue
 * @PIKA_SELECT_CRITERION_HSV_SATURATION: HSV Saturation
 * @PIKA_SELECT_CRITERION_HSV_VALUE:      HSV Value
 * @PIKA_SELECT_CRITERION_LCH_LIGHTNESS:  LCh Lightness
 * @PIKA_SELECT_CRITERION_LCH_CHROMA:     LCh Chroma
 * @PIKA_SELECT_CRITERION_LCH_HUE:        LCh Hue
 * @PIKA_SELECT_CRITERION_ALPHA:          Alpha
 *
 * Criterions for color similarity.
 **/
#define PIKA_TYPE_SELECT_CRITERION (pika_select_criterion_get_type ())

GType pika_select_criterion_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_SELECT_CRITERION_COMPOSITE,      /*< desc="Composite"      >*/
  PIKA_SELECT_CRITERION_RGB_RED,        /*< desc="Red"            >*/
  PIKA_SELECT_CRITERION_RGB_GREEN,      /*< desc="Green"          >*/
  PIKA_SELECT_CRITERION_RGB_BLUE,       /*< desc="Blue"           >*/
  PIKA_SELECT_CRITERION_HSV_HUE,        /*< desc="HSV Hue"        >*/
  PIKA_SELECT_CRITERION_HSV_SATURATION, /*< desc="HSV Saturation" >*/
  PIKA_SELECT_CRITERION_HSV_VALUE,      /*< desc="HSV Value"      >*/
  PIKA_SELECT_CRITERION_LCH_LIGHTNESS,  /*< desc="LCh Lightness"  >*/
  PIKA_SELECT_CRITERION_LCH_CHROMA,     /*< desc="LCh Chroma"     >*/
  PIKA_SELECT_CRITERION_LCH_HUE,        /*< desc="LCh Hue"        >*/
  PIKA_SELECT_CRITERION_ALPHA,          /*< desc="Alpha"          >*/
} PikaSelectCriterion;


/**
 * PikaSizeType:
 * @PIKA_PIXELS: Pixels
 * @PIKA_POINTS: Points
 *
 * Size types for the old-style text API.
 **/
#define PIKA_TYPE_SIZE_TYPE (pika_size_type_get_type ())

GType pika_size_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_PIXELS,  /*< desc="Pixels" >*/
  PIKA_POINTS   /*< desc="Points" >*/
} PikaSizeType;


/**
 * PikaStackTraceMode:
 * @PIKA_STACK_TRACE_NEVER:  Never
 * @PIKA_STACK_TRACE_QUERY:  Ask each time
 * @PIKA_STACK_TRACE_ALWAYS: Always
 *
 * When to generate stack traces in case of an error.
 **/
#define PIKA_TYPE_STACK_TRACE_MODE (pika_stack_trace_mode_get_type ())

GType pika_stack_trace_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_STACK_TRACE_NEVER,
  PIKA_STACK_TRACE_QUERY,
  PIKA_STACK_TRACE_ALWAYS
} PikaStackTraceMode;


/**
 * PikaStrokeMethod:
 * @PIKA_STROKE_LINE:         Stroke line
 * @PIKA_STROKE_PAINT_METHOD: Stroke with a paint tool
 *
 * Methods of stroking selections and paths.
 **/
#define PIKA_TYPE_STROKE_METHOD (pika_stroke_method_get_type ())

GType pika_stroke_method_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_STROKE_LINE,         /*< desc="Stroke line"              >*/
  PIKA_STROKE_PAINT_METHOD  /*< desc="Stroke with a paint tool" >*/
} PikaStrokeMethod;


/**
 * PikaTextDirection:
 * @PIKA_TEXT_DIRECTION_LTR: From left to right
 * @PIKA_TEXT_DIRECTION_RTL: From right to left
 * @PIKA_TEXT_DIRECTION_TTB_RTL: Characters are from top to bottom, Lines are from right to left
 * @PIKA_TEXT_DIRECTION_TTB_RTL_UPRIGHT: Upright characters are from top to bottom, Lines are from right to left
 * @PIKA_TEXT_DIRECTION_TTB_LTR: Characters are from top to bottom, Lines are from left to right
 * @PIKA_TEXT_DIRECTION_TTB_LTR_UPRIGHT: Upright characters are from top to bottom, Lines are from left to right
 *
 * Text directions.
 **/
#define PIKA_TYPE_TEXT_DIRECTION (pika_text_direction_get_type ())

GType pika_text_direction_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_TEXT_DIRECTION_LTR,              /*< desc="From left to right"                                     >*/
  PIKA_TEXT_DIRECTION_RTL,              /*< desc="From right to left"                                     >*/
  PIKA_TEXT_DIRECTION_TTB_RTL,          /*< desc="Vertical, right to left (mixed orientation)"  >*/
  PIKA_TEXT_DIRECTION_TTB_RTL_UPRIGHT,  /*< desc="Vertical, right to left (upright orientation)" >*/
  PIKA_TEXT_DIRECTION_TTB_LTR,          /*< desc="Vertical, left to right (mixed orientation)"  >*/
  PIKA_TEXT_DIRECTION_TTB_LTR_UPRIGHT   /*< desc="Vertical, left to right (upright orientation)" >*/
} PikaTextDirection;


/**
 * PikaTextHintStyle:
 * @PIKA_TEXT_HINT_STYLE_NONE:   None
 * @PIKA_TEXT_HINT_STYLE_SLIGHT: Slight
 * @PIKA_TEXT_HINT_STYLE_MEDIUM: Medium
 * @PIKA_TEXT_HINT_STYLE_FULL:   Full
 *
 * Text hint strengths.
 **/
#define PIKA_TYPE_TEXT_HINT_STYLE (pika_text_hint_style_get_type ())

GType pika_text_hint_style_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_TEXT_HINT_STYLE_NONE,     /*< desc="None"   >*/
  PIKA_TEXT_HINT_STYLE_SLIGHT,   /*< desc="Slight" >*/
  PIKA_TEXT_HINT_STYLE_MEDIUM,   /*< desc="Medium" >*/
  PIKA_TEXT_HINT_STYLE_FULL      /*< desc="Full"   >*/
} PikaTextHintStyle;


/**
 * PikaTextJustification:
 * @PIKA_TEXT_JUSTIFY_LEFT:   Left justified
 * @PIKA_TEXT_JUSTIFY_RIGHT:  Right justified
 * @PIKA_TEXT_JUSTIFY_CENTER: Centered
 * @PIKA_TEXT_JUSTIFY_FILL:   Filled
 *
 * Text justifications.
 **/
#define PIKA_TYPE_TEXT_JUSTIFICATION (pika_text_justification_get_type ())

GType pika_text_justification_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_TEXT_JUSTIFY_LEFT,    /*< desc="Left justified"  >*/
  PIKA_TEXT_JUSTIFY_RIGHT,   /*< desc="Right justified" >*/
  PIKA_TEXT_JUSTIFY_CENTER,  /*< desc="Centered"        >*/
  PIKA_TEXT_JUSTIFY_FILL     /*< desc="Filled"          >*/
} PikaTextJustification;


/**
 * PikaTransferMode:
 * @PIKA_TRANSFER_SHADOWS:    Shadows
 * @PIKA_TRANSFER_MIDTONES:   Midtones
 * @PIKA_TRANSFER_HIGHLIGHTS: Highlights
 *
 * For choosing which brightness ranges to transform.
 **/
#define PIKA_TYPE_TRANSFER_MODE (pika_transfer_mode_get_type ())

GType pika_transfer_mode_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_TRANSFER_SHADOWS,     /*< desc="Shadows"    >*/
  PIKA_TRANSFER_MIDTONES,    /*< desc="Midtones"   >*/
  PIKA_TRANSFER_HIGHLIGHTS   /*< desc="Highlights" >*/
} PikaTransferMode;


/**
 * PikaTransformDirection:
 * @PIKA_TRANSFORM_FORWARD:  Normal (Forward)
 * @PIKA_TRANSFORM_BACKWARD: Corrective (Backward)
 *
 * Transform directions.
 **/
#define PIKA_TYPE_TRANSFORM_DIRECTION (pika_transform_direction_get_type ())

GType pika_transform_direction_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_TRANSFORM_FORWARD,   /*< desc="Normal (Forward)" >*/
  PIKA_TRANSFORM_BACKWARD   /*< desc="Corrective (Backward)" >*/
} PikaTransformDirection;


/**
 * PikaTransformResize:
 * @PIKA_TRANSFORM_RESIZE_ADJUST:           Adjust
 * @PIKA_TRANSFORM_RESIZE_CLIP:             Clip
 * @PIKA_TRANSFORM_RESIZE_CROP:             Crop to result
 * @PIKA_TRANSFORM_RESIZE_CROP_WITH_ASPECT: Crop with aspect
 *
 * Ways of clipping the result when transforming drawables.
 **/
#define PIKA_TYPE_TRANSFORM_RESIZE (pika_transform_resize_get_type ())

GType pika_transform_resize_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_TRANSFORM_RESIZE_ADJUST,           /*< desc="Adjust"           >*/
  PIKA_TRANSFORM_RESIZE_CLIP,             /*< desc="Clip"             >*/
  PIKA_TRANSFORM_RESIZE_CROP,             /*< desc="Crop to result"   >*/
  PIKA_TRANSFORM_RESIZE_CROP_WITH_ASPECT  /*< desc="Crop with aspect" >*/
} PikaTransformResize;


/**
 * PikaUnit:
 * @PIKA_UNIT_PIXEL:   Pixels
 * @PIKA_UNIT_INCH:    Inches
 * @PIKA_UNIT_MM:      Millimeters
 * @PIKA_UNIT_POINT:   Points
 * @PIKA_UNIT_PICA:    Picas
 * @PIKA_UNIT_END:     Marker for end-of-builtin-units
 * @PIKA_UNIT_PERCENT: Pseudo-unit percent
 *
 * Units used for dimensions in images.
 **/
typedef enum /*< skip >*/
{
  PIKA_UNIT_PIXEL   = 0,

  PIKA_UNIT_INCH    = 1,
  PIKA_UNIT_MM      = 2,
  PIKA_UNIT_POINT   = 3,
  PIKA_UNIT_PICA    = 4,

  PIKA_UNIT_END     = 5,

  PIKA_UNIT_PERCENT = 65536 /*< pdb-skip >*/
} PikaUnit;


/**
 * PikaVectorsStrokeType:
 * @PIKA_VECTORS_STROKE_TYPE_BEZIER: A bezier stroke
 *
 * Possible type of strokes in vectors objects.
 **/
#define PIKA_TYPE_VECTORS_STROKE_TYPE (pika_vectors_stroke_type_get_type ())

GType pika_vectors_stroke_type_get_type (void) G_GNUC_CONST;

typedef enum
{
  PIKA_VECTORS_STROKE_TYPE_BEZIER
} PikaVectorsStrokeType;

G_END_DECLS

#endif  /* __PIKA_BASE_ENUMS_H__ */
