gimpparamspecs

gimpparamspecs

Synopsis

#define             GIMP_PARAM_NO_VALIDATE
#define             GIMP_TYPE_INT32
#define             GIMP_VALUE_HOLDS_INT32              (value)
#define             GIMP_TYPE_PARAM_INT32
struct              GimpParamSpecInt32;
GType               gimp_param_int32_get_type           (void);
GParamSpec *        gimp_param_spec_int32               (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint minimum,
                                                         gint maximum,
                                                         gint default_value,
                                                         GParamFlags flags);
#define             GIMP_TYPE_INT16
#define             GIMP_VALUE_HOLDS_INT16              (value)
GType               gimp_int16_get_type                 (void);
#define             GIMP_TYPE_PARAM_INT16
#define             GIMP_PARAM_SPEC_INT16               (pspec)
#define             GIMP_IS_PARAM_SPEC_INT16            (pspec)
struct              GimpParamSpecInt16;
GType               gimp_param_int16_get_type           (void);
GParamSpec *        gimp_param_spec_int16               (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint minimum,
                                                         gint maximum,
                                                         gint default_value,
                                                         GParamFlags flags);
#define             GIMP_TYPE_INT8
#define             GIMP_VALUE_HOLDS_INT8               (value)
GType               gimp_int8_get_type                  (void);
#define             GIMP_TYPE_PARAM_INT8
#define             GIMP_PARAM_SPEC_INT8                (pspec)
#define             GIMP_IS_PARAM_SPEC_INT8             (pspec)
struct              GimpParamSpecInt8;
GType               gimp_param_int8_get_type            (void);
GParamSpec *        gimp_param_spec_int8                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint minimum,
                                                         guint maximum,
                                                         guint default_value,
                                                         GParamFlags flags);
#define             GIMP_TYPE_PARAM_STRING
#define             GIMP_PARAM_SPEC_STRING              (pspec)
#define             GIMP_IS_PARAM_SPEC_STRING           (pspec)
struct              GimpParamSpecString;
GType               gimp_param_string_get_type          (void);
GParamSpec *        gimp_param_spec_string              (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gboolean allow_non_utf8,
                                                         gboolean null_ok,
                                                         gboolean non_empty,
                                                         const gchar *default_value,
                                                         GParamFlags flags);
#define             GIMP_TYPE_PARAM_ENUM
#define             GIMP_PARAM_SPEC_ENUM                (pspec)
#define             GIMP_IS_PARAM_SPEC_ENUM             (pspec)
struct              GimpParamSpecEnum;
GType               gimp_param_enum_get_type            (void);
GParamSpec *        gimp_param_spec_enum                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType enum_type,
                                                         gint default_value,
                                                         GParamFlags flags);
void                gimp_param_spec_enum_exclude_value  (GimpParamSpecEnum *espec,
                                                         gint value);
#define             GIMP_TYPE_IMAGE_ID
#define             GIMP_VALUE_HOLDS_IMAGE_ID           (value)
GType               gimp_image_id_get_type              (void);
#define             GIMP_TYPE_PARAM_IMAGE_ID
#define             GIMP_PARAM_SPEC_IMAGE_ID            (pspec)
#define             GIMP_IS_PARAM_SPEC_IMAGE_ID         (pspec)
struct              GimpParamSpecImageID;
GType               gimp_param_image_id_get_type        (void);
GParamSpec *        gimp_param_spec_image_id            (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpImage *         gimp_value_get_image                (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_image                (GValue *value,
                                                         GimpImage *image);
#define             GIMP_TYPE_ITEM_ID
#define             GIMP_VALUE_HOLDS_ITEM_ID            (value)
GType               gimp_item_id_get_type               (void);
#define             GIMP_TYPE_PARAM_ITEM_ID
#define             GIMP_PARAM_SPEC_ITEM_ID             (pspec)
#define             GIMP_IS_PARAM_SPEC_ITEM_ID          (pspec)
struct              GimpParamSpecItemID;
GType               gimp_param_item_id_get_type         (void);
GParamSpec *        gimp_param_spec_item_id             (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpItem *          gimp_value_get_item                 (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_item                 (GValue *value,
                                                         GimpItem *item);
#define             GIMP_TYPE_DRAWABLE_ID
#define             GIMP_VALUE_HOLDS_DRAWABLE_ID        (value)
GType               gimp_drawable_id_get_type           (void);
#define             GIMP_TYPE_PARAM_DRAWABLE_ID
#define             GIMP_PARAM_SPEC_DRAWABLE_ID         (pspec)
#define             GIMP_IS_PARAM_SPEC_DRAWABLE_ID      (pspec)
struct              GimpParamSpecDrawableID;
GType               gimp_param_drawable_id_get_type     (void);
GParamSpec *        gimp_param_spec_drawable_id         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpDrawable *      gimp_value_get_drawable             (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_drawable             (GValue *value,
                                                         GimpDrawable *drawable);
#define             GIMP_TYPE_LAYER_ID
#define             GIMP_VALUE_HOLDS_LAYER_ID           (value)
GType               gimp_layer_id_get_type              (void);
#define             GIMP_TYPE_PARAM_LAYER_ID
#define             GIMP_PARAM_SPEC_LAYER_ID            (pspec)
#define             GIMP_IS_PARAM_SPEC_LAYER_ID         (pspec)
struct              GimpParamSpecLayerID;
GType               gimp_param_layer_id_get_type        (void);
GParamSpec *        gimp_param_spec_layer_id            (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpLayer *         gimp_value_get_layer                (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_layer                (GValue *value,
                                                         GimpLayer *layer);
#define             GIMP_TYPE_CHANNEL_ID
#define             GIMP_VALUE_HOLDS_CHANNEL_ID         (value)
GType               gimp_channel_id_get_type            (void);
#define             GIMP_TYPE_PARAM_CHANNEL_ID
#define             GIMP_PARAM_SPEC_CHANNEL_ID          (pspec)
#define             GIMP_IS_PARAM_SPEC_CHANNEL_ID       (pspec)
struct              GimpParamSpecChannelID;
GType               gimp_param_channel_id_get_type      (void);
GParamSpec *        gimp_param_spec_channel_id          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpChannel *       gimp_value_get_channel              (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_channel              (GValue *value,
                                                         GimpChannel *channel);
#define             GIMP_TYPE_LAYER_MASK_ID
#define             GIMP_VALUE_HOLDS_LAYER_MASK_ID      (value)
GType               gimp_layer_mask_id_get_type         (void);
#define             GIMP_TYPE_PARAM_LAYER_MASK_ID
#define             GIMP_PARAM_SPEC_LAYER_MASK_ID       (pspec)
#define             GIMP_IS_PARAM_SPEC_LAYER_MASK_ID    (pspec)
struct              GimpParamSpecLayerMaskID;
GType               gimp_param_layer_mask_id_get_type   (void);
GParamSpec *        gimp_param_spec_layer_mask_id       (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpLayerMask *     gimp_value_get_layer_mask           (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_layer_mask           (GValue *value,
                                                         GimpLayerMask *layer_mask);
#define             GIMP_TYPE_SELECTION_ID
#define             GIMP_VALUE_HOLDS_SELECTION_ID       (value)
GType               gimp_selection_id_get_type          (void);
#define             GIMP_TYPE_PARAM_SELECTION_ID
#define             GIMP_PARAM_SPEC_SELECTION_ID        (pspec)
#define             GIMP_IS_PARAM_SPEC_SELECTION_ID     (pspec)
struct              GimpParamSpecSelectionID;
GType               gimp_param_selection_id_get_type    (void);
GParamSpec *        gimp_param_spec_selection_id        (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpSelection *     gimp_value_get_selection            (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_selection            (GValue *value,
                                                         GimpSelection *selection);
#define             GIMP_TYPE_VECTORS_ID
#define             GIMP_VALUE_HOLDS_VECTORS_ID         (value)
GType               gimp_vectors_id_get_type            (void);
#define             GIMP_TYPE_PARAM_VECTORS_ID
#define             GIMP_PARAM_SPEC_VECTORS_ID          (pspec)
#define             GIMP_IS_PARAM_SPEC_VECTORS_ID       (pspec)
struct              GimpParamSpecVectorsID;
GType               gimp_param_vectors_id_get_type      (void);
GParamSpec *        gimp_param_spec_vectors_id          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpVectors *       gimp_value_get_vectors              (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_vectors              (GValue *value,
                                                         GimpVectors *vectors);
#define             GIMP_TYPE_DISPLAY_ID
#define             GIMP_VALUE_HOLDS_DISPLAY_ID         (value)
GType               gimp_display_id_get_type            (void);
#define             GIMP_TYPE_PARAM_DISPLAY_ID
#define             GIMP_PARAM_SPEC_DISPLAY_ID          (pspec)
#define             GIMP_IS_PARAM_SPEC_DISPLAY_ID       (pspec)
struct              GimpParamSpecDisplayID;
GType               gimp_param_display_id_get_type      (void);
GParamSpec *        gimp_param_spec_display_id          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);
GimpObject *        gimp_value_get_display              (const GValue *value,
                                                         Gimp *gimp);
void                gimp_value_set_display              (GValue *value,
                                                         GimpObject *display);
struct              GimpArray;
GimpArray *         gimp_array_new                      (const guint8 *data,
                                                         gsize length,
                                                         gboolean static_data);
GimpArray *         gimp_array_copy                     (const GimpArray *array);
void                gimp_array_free                     (GimpArray *array);
#define             GIMP_TYPE_ARRAY
#define             GIMP_VALUE_HOLDS_ARRAY              (value)
GType               gimp_array_get_type                 (void);
#define             GIMP_TYPE_PARAM_ARRAY
#define             GIMP_PARAM_SPEC_ARRAY               (pspec)
#define             GIMP_IS_PARAM_SPEC_ARRAY            (pspec)
struct              GimpParamSpecArray;
GType               gimp_param_array_get_type           (void);
GParamSpec *        gimp_param_spec_array               (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
#define             GIMP_TYPE_INT8_ARRAY
#define             GIMP_VALUE_HOLDS_INT8_ARRAY         (value)
GType               gimp_int8_array_get_type            (void);
#define             GIMP_TYPE_PARAM_INT8_ARRAY
#define             GIMP_PARAM_SPEC_INT8_ARRAY          (pspec)
#define             GIMP_IS_PARAM_SPEC_INT8_ARRAY       (pspec)
struct              GimpParamSpecInt8Array;
GType               gimp_param_int8_array_get_type      (void);
GParamSpec *        gimp_param_spec_int8_array          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
const guint8 *      gimp_value_get_int8array            (const GValue *value);
guint8 *            gimp_value_dup_int8array            (const GValue *value);
void                gimp_value_set_int8array            (GValue *value,
                                                         const guint8 *array,
                                                         gsize length);
void                gimp_value_set_static_int8array     (GValue *value,
                                                         const guint8 *array,
                                                         gsize length);
void                gimp_value_take_int8array           (GValue *value,
                                                         guint8 *array,
                                                         gsize length);
#define             GIMP_TYPE_INT16_ARRAY
#define             GIMP_VALUE_HOLDS_INT16_ARRAY        (value)
GType               gimp_int16_array_get_type           (void);
#define             GIMP_TYPE_PARAM_INT16_ARRAY
#define             GIMP_PARAM_SPEC_INT16_ARRAY         (pspec)
#define             GIMP_IS_PARAM_SPEC_INT16_ARRAY      (pspec)
struct              GimpParamSpecInt16Array;
GType               gimp_param_int16_array_get_type     (void);
GParamSpec *        gimp_param_spec_int16_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
const gint16 *      gimp_value_get_int16array           (const GValue *value);
gint16 *            gimp_value_dup_int16array           (const GValue *value);
void                gimp_value_set_int16array           (GValue *value,
                                                         const gint16 *array,
                                                         gsize length);
void                gimp_value_set_static_int16array    (GValue *value,
                                                         const gint16 *array,
                                                         gsize length);
void                gimp_value_take_int16array          (GValue *value,
                                                         gint16 *array,
                                                         gsize length);
#define             GIMP_TYPE_INT32_ARRAY
#define             GIMP_VALUE_HOLDS_INT32_ARRAY        (value)
GType               gimp_int32_array_get_type           (void);
#define             GIMP_TYPE_PARAM_INT32_ARRAY
#define             GIMP_PARAM_SPEC_INT32_ARRAY         (pspec)
#define             GIMP_IS_PARAM_SPEC_INT32_ARRAY      (pspec)
struct              GimpParamSpecInt32Array;
GType               gimp_param_int32_array_get_type     (void);
GParamSpec *        gimp_param_spec_int32_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
const gint32 *      gimp_value_get_int32array           (const GValue *value);
gint32 *            gimp_value_dup_int32array           (const GValue *value);
void                gimp_value_set_int32array           (GValue *value,
                                                         const gint32 *array,
                                                         gsize length);
void                gimp_value_set_static_int32array    (GValue *value,
                                                         const gint32 *array,
                                                         gsize length);
void                gimp_value_take_int32array          (GValue *value,
                                                         gint32 *array,
                                                         gsize length);
#define             GIMP_TYPE_FLOAT_ARRAY
#define             GIMP_VALUE_HOLDS_FLOAT_ARRAY        (value)
GType               gimp_float_array_get_type           (void);
#define             GIMP_TYPE_PARAM_FLOAT_ARRAY
#define             GIMP_PARAM_SPEC_FLOAT_ARRAY         (pspec)
#define             GIMP_IS_PARAM_SPEC_FLOAT_ARRAY      (pspec)
struct              GimpParamSpecFloatArray;
GType               gimp_param_float_array_get_type     (void);
GParamSpec *        gimp_param_spec_float_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
const gdouble *     gimp_value_get_floatarray           (const GValue *value);
gdouble *           gimp_value_dup_floatarray           (const GValue *value);
void                gimp_value_set_floatarray           (GValue *value,
                                                         const gdouble *array,
                                                         gsize length);
void                gimp_value_set_static_floatarray    (GValue *value,
                                                         const gdouble *array,
                                                         gsize length);
void                gimp_value_take_floatarray          (GValue *value,
                                                         gdouble *array,
                                                         gsize length);
GimpArray *         gimp_string_array_new               (const gchar **data,
                                                         gsize length,
                                                         gboolean static_data);
GimpArray *         gimp_string_array_copy              (const GimpArray *array);
void                gimp_string_array_free              (GimpArray *array);
#define             GIMP_TYPE_STRING_ARRAY
#define             GIMP_VALUE_HOLDS_STRING_ARRAY       (value)
GType               gimp_string_array_get_type          (void);
#define             GIMP_TYPE_PARAM_STRING_ARRAY
#define             GIMP_PARAM_SPEC_STRING_ARRAY        (pspec)
#define             GIMP_IS_PARAM_SPEC_STRING_ARRAY     (pspec)
struct              GimpParamSpecStringArray;
GType               gimp_param_string_array_get_type    (void);
GParamSpec *        gimp_param_spec_string_array        (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
const gchar **      gimp_value_get_stringarray          (const GValue *value);
gchar **            gimp_value_dup_stringarray          (const GValue *value);
void                gimp_value_set_stringarray          (GValue *value,
                                                         const gchar **array,
                                                         gsize length);
void                gimp_value_set_static_stringarray   (GValue *value,
                                                         const gchar **array,
                                                         gsize length);
void                gimp_value_take_stringarray         (GValue *value,
                                                         gchar **array,
                                                         gsize length);
#define             GIMP_TYPE_COLOR_ARRAY
#define             GIMP_VALUE_HOLDS_COLOR_ARRAY        (value)
GType               gimp_color_array_get_type           (void);
GType               gimp_param_color_array_get_type     (void);
#define             GIMP_TYPE_PARAM_COLOR_ARRAY
#define             GIMP_PARAM_SPEC_COLOR_ARRAY         (pspec)
#define             GIMP_IS_PARAM_SPEC_COLOR_ARRAY      (pspec)
struct              GimpParamSpecColorArray;
GParamSpec *        gimp_param_spec_color_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);
GimpRGB *           gimp_value_dup_colorarray           (const GValue *value);
const GimpRGB *     gimp_value_get_colorarray           (const GValue *value);
void                gimp_value_set_colorarray           (GValue *value,
                                                         const GimpRGB *array,
                                                         gsize length);
void                gimp_value_set_static_colorarray    (GValue *value,
                                                         const GimpRGB *array,
                                                         gsize length);
void                gimp_value_take_colorarray          (GValue *value,
                                                         GimpRGB *array,
                                                         gsize length);

Object Hierarchy

  GBoxed
   +----GimpArray

Description

Details

GIMP_PARAM_NO_VALIDATE

#define GIMP_PARAM_NO_VALIDATE (1 << (6 + G_PARAM_USER_SHIFT))


GIMP_TYPE_INT32

#define GIMP_TYPE_INT32               (gimp_int32_get_type ())


GIMP_VALUE_HOLDS_INT32()

#define             GIMP_VALUE_HOLDS_INT32(value)


GIMP_TYPE_PARAM_INT32

#define GIMP_TYPE_PARAM_INT32           (gimp_param_int32_get_type ())


struct GimpParamSpecInt32

struct GimpParamSpecInt32 {
  GParamSpecInt parent_instance;
};


gimp_param_int32_get_type ()

GType               gimp_param_int32_get_type           (void);


gimp_param_spec_int32 ()

GParamSpec *        gimp_param_spec_int32               (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint minimum,
                                                         gint maximum,
                                                         gint default_value,
                                                         GParamFlags flags);


GIMP_TYPE_INT16

#define GIMP_TYPE_INT16               (gimp_int16_get_type ())


GIMP_VALUE_HOLDS_INT16()

#define             GIMP_VALUE_HOLDS_INT16(value)


gimp_int16_get_type ()

GType               gimp_int16_get_type                 (void);


GIMP_TYPE_PARAM_INT16

#define GIMP_TYPE_PARAM_INT16           (gimp_param_int16_get_type ())


GIMP_PARAM_SPEC_INT16()

#define GIMP_PARAM_SPEC_INT16(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT16, GimpParamSpecInt16))


GIMP_IS_PARAM_SPEC_INT16()

#define GIMP_IS_PARAM_SPEC_INT16(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT16))


struct GimpParamSpecInt16

struct GimpParamSpecInt16 {
  GParamSpecInt parent_instance;
};


gimp_param_int16_get_type ()

GType               gimp_param_int16_get_type           (void);


gimp_param_spec_int16 ()

GParamSpec *        gimp_param_spec_int16               (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gint minimum,
                                                         gint maximum,
                                                         gint default_value,
                                                         GParamFlags flags);


GIMP_TYPE_INT8

#define GIMP_TYPE_INT8               (gimp_int8_get_type ())


GIMP_VALUE_HOLDS_INT8()

#define             GIMP_VALUE_HOLDS_INT8(value)


gimp_int8_get_type ()

GType               gimp_int8_get_type                  (void);


GIMP_TYPE_PARAM_INT8

#define GIMP_TYPE_PARAM_INT8           (gimp_param_int8_get_type ())


GIMP_PARAM_SPEC_INT8()

#define GIMP_PARAM_SPEC_INT8(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT8, GimpParamSpecInt8))


GIMP_IS_PARAM_SPEC_INT8()

#define GIMP_IS_PARAM_SPEC_INT8(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT8))


struct GimpParamSpecInt8

struct GimpParamSpecInt8 {
  GParamSpecUInt parent_instance;
};


gimp_param_int8_get_type ()

GType               gimp_param_int8_get_type            (void);


gimp_param_spec_int8 ()

GParamSpec *        gimp_param_spec_int8                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         guint minimum,
                                                         guint maximum,
                                                         guint default_value,
                                                         GParamFlags flags);


GIMP_TYPE_PARAM_STRING

#define GIMP_TYPE_PARAM_STRING           (gimp_param_string_get_type ())


GIMP_PARAM_SPEC_STRING()

#define GIMP_PARAM_SPEC_STRING(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_STRING, GimpParamSpecString))


GIMP_IS_PARAM_SPEC_STRING()

#define GIMP_IS_PARAM_SPEC_STRING(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_STRING))


struct GimpParamSpecString

struct GimpParamSpecString {
  GParamSpecString parent_instance;

  guint            allow_non_utf8 : 1;
  guint            non_empty      : 1;
};


gimp_param_string_get_type ()

GType               gimp_param_string_get_type          (void);


gimp_param_spec_string ()

GParamSpec *        gimp_param_spec_string              (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         gboolean allow_non_utf8,
                                                         gboolean null_ok,
                                                         gboolean non_empty,
                                                         const gchar *default_value,
                                                         GParamFlags flags);


GIMP_TYPE_PARAM_ENUM

#define GIMP_TYPE_PARAM_ENUM           (gimp_param_enum_get_type ())


GIMP_PARAM_SPEC_ENUM()

#define GIMP_PARAM_SPEC_ENUM(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_ENUM, GimpParamSpecEnum))


GIMP_IS_PARAM_SPEC_ENUM()

#define GIMP_IS_PARAM_SPEC_ENUM(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_ENUM))


struct GimpParamSpecEnum

struct GimpParamSpecEnum {
  GParamSpecEnum  parent_instance;

  GSList         *excluded_values;
};


gimp_param_enum_get_type ()

GType               gimp_param_enum_get_type            (void);


gimp_param_spec_enum ()

GParamSpec *        gimp_param_spec_enum                (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType enum_type,
                                                         gint default_value,
                                                         GParamFlags flags);


gimp_param_spec_enum_exclude_value ()

void                gimp_param_spec_enum_exclude_value  (GimpParamSpecEnum *espec,
                                                         gint value);


GIMP_TYPE_IMAGE_ID

#define GIMP_TYPE_IMAGE_ID               (gimp_image_id_get_type ())


GIMP_VALUE_HOLDS_IMAGE_ID()

#define             GIMP_VALUE_HOLDS_IMAGE_ID(value)


gimp_image_id_get_type ()

GType               gimp_image_id_get_type              (void);


GIMP_TYPE_PARAM_IMAGE_ID

#define GIMP_TYPE_PARAM_IMAGE_ID           (gimp_param_image_id_get_type ())


GIMP_PARAM_SPEC_IMAGE_ID()

#define GIMP_PARAM_SPEC_IMAGE_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_IMAGE_ID, GimpParamSpecImageID))


GIMP_IS_PARAM_SPEC_IMAGE_ID()

#define GIMP_IS_PARAM_SPEC_IMAGE_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_IMAGE_ID))


struct GimpParamSpecImageID

struct GimpParamSpecImageID {
  GParamSpecInt  parent_instance;

  Gimp          *gimp;
  gboolean       none_ok;
};


gimp_param_image_id_get_type ()

GType               gimp_param_image_id_get_type        (void);


gimp_param_spec_image_id ()

GParamSpec *        gimp_param_spec_image_id            (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_image ()

GimpImage *         gimp_value_get_image                (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_image ()

void                gimp_value_set_image                (GValue *value,
                                                         GimpImage *image);


GIMP_TYPE_ITEM_ID

#define GIMP_TYPE_ITEM_ID               (gimp_item_id_get_type ())


GIMP_VALUE_HOLDS_ITEM_ID()

#define             GIMP_VALUE_HOLDS_ITEM_ID(value)


gimp_item_id_get_type ()

GType               gimp_item_id_get_type               (void);


GIMP_TYPE_PARAM_ITEM_ID

#define GIMP_TYPE_PARAM_ITEM_ID           (gimp_param_item_id_get_type ())


GIMP_PARAM_SPEC_ITEM_ID()

#define GIMP_PARAM_SPEC_ITEM_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_ITEM_ID, GimpParamSpecItemID))


GIMP_IS_PARAM_SPEC_ITEM_ID()

#define GIMP_IS_PARAM_SPEC_ITEM_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_ITEM_ID))


struct GimpParamSpecItemID

struct GimpParamSpecItemID {
  GParamSpecInt  parent_instance;

  Gimp          *gimp;
  GType          item_type;
  gboolean       none_ok;
};


gimp_param_item_id_get_type ()

GType               gimp_param_item_id_get_type         (void);


gimp_param_spec_item_id ()

GParamSpec *        gimp_param_spec_item_id             (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_item ()

GimpItem *          gimp_value_get_item                 (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_item ()

void                gimp_value_set_item                 (GValue *value,
                                                         GimpItem *item);


GIMP_TYPE_DRAWABLE_ID

#define GIMP_TYPE_DRAWABLE_ID               (gimp_drawable_id_get_type ())


GIMP_VALUE_HOLDS_DRAWABLE_ID()

#define             GIMP_VALUE_HOLDS_DRAWABLE_ID(value)


gimp_drawable_id_get_type ()

GType               gimp_drawable_id_get_type           (void);


GIMP_TYPE_PARAM_DRAWABLE_ID

#define GIMP_TYPE_PARAM_DRAWABLE_ID           (gimp_param_drawable_id_get_type ())


GIMP_PARAM_SPEC_DRAWABLE_ID()

#define GIMP_PARAM_SPEC_DRAWABLE_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_DRAWABLE_ID, GimpParamSpecDrawableID))


GIMP_IS_PARAM_SPEC_DRAWABLE_ID()

#define GIMP_IS_PARAM_SPEC_DRAWABLE_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_DRAWABLE_ID))


struct GimpParamSpecDrawableID

struct GimpParamSpecDrawableID {
  GimpParamSpecItemID parent_instance;
};


gimp_param_drawable_id_get_type ()

GType               gimp_param_drawable_id_get_type     (void);


gimp_param_spec_drawable_id ()

GParamSpec *        gimp_param_spec_drawable_id         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_drawable ()

GimpDrawable *      gimp_value_get_drawable             (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_drawable ()

void                gimp_value_set_drawable             (GValue *value,
                                                         GimpDrawable *drawable);


GIMP_TYPE_LAYER_ID

#define GIMP_TYPE_LAYER_ID               (gimp_layer_id_get_type ())


GIMP_VALUE_HOLDS_LAYER_ID()

#define             GIMP_VALUE_HOLDS_LAYER_ID(value)


gimp_layer_id_get_type ()

GType               gimp_layer_id_get_type              (void);


GIMP_TYPE_PARAM_LAYER_ID

#define GIMP_TYPE_PARAM_LAYER_ID           (gimp_param_layer_id_get_type ())


GIMP_PARAM_SPEC_LAYER_ID()

#define GIMP_PARAM_SPEC_LAYER_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_LAYER_ID, GimpParamSpecLayerID))


GIMP_IS_PARAM_SPEC_LAYER_ID()

#define GIMP_IS_PARAM_SPEC_LAYER_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_LAYER_ID))


struct GimpParamSpecLayerID

struct GimpParamSpecLayerID {
  GimpParamSpecDrawableID parent_instance;
};


gimp_param_layer_id_get_type ()

GType               gimp_param_layer_id_get_type        (void);


gimp_param_spec_layer_id ()

GParamSpec *        gimp_param_spec_layer_id            (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_layer ()

GimpLayer *         gimp_value_get_layer                (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_layer ()

void                gimp_value_set_layer                (GValue *value,
                                                         GimpLayer *layer);


GIMP_TYPE_CHANNEL_ID

#define GIMP_TYPE_CHANNEL_ID               (gimp_channel_id_get_type ())


GIMP_VALUE_HOLDS_CHANNEL_ID()

#define             GIMP_VALUE_HOLDS_CHANNEL_ID(value)


gimp_channel_id_get_type ()

GType               gimp_channel_id_get_type            (void);


GIMP_TYPE_PARAM_CHANNEL_ID

#define GIMP_TYPE_PARAM_CHANNEL_ID           (gimp_param_channel_id_get_type ())


GIMP_PARAM_SPEC_CHANNEL_ID()

#define GIMP_PARAM_SPEC_CHANNEL_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_CHANNEL_ID, GimpParamSpecChannelID))


GIMP_IS_PARAM_SPEC_CHANNEL_ID()

#define GIMP_IS_PARAM_SPEC_CHANNEL_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_CHANNEL_ID))


struct GimpParamSpecChannelID

struct GimpParamSpecChannelID {
  GimpParamSpecDrawableID parent_instance;
};


gimp_param_channel_id_get_type ()

GType               gimp_param_channel_id_get_type      (void);


gimp_param_spec_channel_id ()

GParamSpec *        gimp_param_spec_channel_id          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_channel ()

GimpChannel *       gimp_value_get_channel              (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_channel ()

void                gimp_value_set_channel              (GValue *value,
                                                         GimpChannel *channel);


GIMP_TYPE_LAYER_MASK_ID

#define GIMP_TYPE_LAYER_MASK_ID               (gimp_layer_mask_id_get_type ())


GIMP_VALUE_HOLDS_LAYER_MASK_ID()

#define             GIMP_VALUE_HOLDS_LAYER_MASK_ID(value)


gimp_layer_mask_id_get_type ()

GType               gimp_layer_mask_id_get_type         (void);


GIMP_TYPE_PARAM_LAYER_MASK_ID

#define GIMP_TYPE_PARAM_LAYER_MASK_ID           (gimp_param_layer_mask_id_get_type ())


GIMP_PARAM_SPEC_LAYER_MASK_ID()

#define GIMP_PARAM_SPEC_LAYER_MASK_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_LAYER_MASK_ID, GimpParamSpecLayerMaskID))


GIMP_IS_PARAM_SPEC_LAYER_MASK_ID()

#define GIMP_IS_PARAM_SPEC_LAYER_MASK_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_LAYER_MASK_ID))


struct GimpParamSpecLayerMaskID

struct GimpParamSpecLayerMaskID {
  GimpParamSpecChannelID parent_instance;
};


gimp_param_layer_mask_id_get_type ()

GType               gimp_param_layer_mask_id_get_type   (void);


gimp_param_spec_layer_mask_id ()

GParamSpec *        gimp_param_spec_layer_mask_id       (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_layer_mask ()

GimpLayerMask *     gimp_value_get_layer_mask           (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_layer_mask ()

void                gimp_value_set_layer_mask           (GValue *value,
                                                         GimpLayerMask *layer_mask);


GIMP_TYPE_SELECTION_ID

#define GIMP_TYPE_SELECTION_ID               (gimp_selection_id_get_type ())


GIMP_VALUE_HOLDS_SELECTION_ID()

#define             GIMP_VALUE_HOLDS_SELECTION_ID(value)


gimp_selection_id_get_type ()

GType               gimp_selection_id_get_type          (void);


GIMP_TYPE_PARAM_SELECTION_ID

#define GIMP_TYPE_PARAM_SELECTION_ID           (gimp_param_selection_id_get_type ())


GIMP_PARAM_SPEC_SELECTION_ID()

#define GIMP_PARAM_SPEC_SELECTION_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_SELECTION_ID, GimpParamSpecSelectionID))


GIMP_IS_PARAM_SPEC_SELECTION_ID()

#define GIMP_IS_PARAM_SPEC_SELECTION_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_SELECTION_ID))


struct GimpParamSpecSelectionID

struct GimpParamSpecSelectionID {
  GimpParamSpecChannelID parent_instance;
};


gimp_param_selection_id_get_type ()

GType               gimp_param_selection_id_get_type    (void);


gimp_param_spec_selection_id ()

GParamSpec *        gimp_param_spec_selection_id        (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_selection ()

GimpSelection *     gimp_value_get_selection            (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_selection ()

void                gimp_value_set_selection            (GValue *value,
                                                         GimpSelection *selection);


GIMP_TYPE_VECTORS_ID

#define GIMP_TYPE_VECTORS_ID               (gimp_vectors_id_get_type ())


GIMP_VALUE_HOLDS_VECTORS_ID()

#define             GIMP_VALUE_HOLDS_VECTORS_ID(value)


gimp_vectors_id_get_type ()

GType               gimp_vectors_id_get_type            (void);


GIMP_TYPE_PARAM_VECTORS_ID

#define GIMP_TYPE_PARAM_VECTORS_ID           (gimp_param_vectors_id_get_type ())


GIMP_PARAM_SPEC_VECTORS_ID()

#define GIMP_PARAM_SPEC_VECTORS_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_VECTORS_ID, GimpParamSpecVectorsID))


GIMP_IS_PARAM_SPEC_VECTORS_ID()

#define GIMP_IS_PARAM_SPEC_VECTORS_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_VECTORS_ID))


struct GimpParamSpecVectorsID

struct GimpParamSpecVectorsID {
  GimpParamSpecItemID parent_instance;
};


gimp_param_vectors_id_get_type ()

GType               gimp_param_vectors_id_get_type      (void);


gimp_param_spec_vectors_id ()

GParamSpec *        gimp_param_spec_vectors_id          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_vectors ()

GimpVectors *       gimp_value_get_vectors              (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_vectors ()

void                gimp_value_set_vectors              (GValue *value,
                                                         GimpVectors *vectors);


GIMP_TYPE_DISPLAY_ID

#define GIMP_TYPE_DISPLAY_ID               (gimp_display_id_get_type ())


GIMP_VALUE_HOLDS_DISPLAY_ID()

#define             GIMP_VALUE_HOLDS_DISPLAY_ID(value)


gimp_display_id_get_type ()

GType               gimp_display_id_get_type            (void);


GIMP_TYPE_PARAM_DISPLAY_ID

#define GIMP_TYPE_PARAM_DISPLAY_ID           (gimp_param_display_id_get_type ())


GIMP_PARAM_SPEC_DISPLAY_ID()

#define GIMP_PARAM_SPEC_DISPLAY_ID(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_DISPLAY_ID, GimpParamSpecDisplayID))


GIMP_IS_PARAM_SPEC_DISPLAY_ID()

#define GIMP_IS_PARAM_SPEC_DISPLAY_ID(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_DISPLAY_ID))


struct GimpParamSpecDisplayID

struct GimpParamSpecDisplayID {
  GParamSpecInt  parent_instance;

  Gimp          *gimp;
  gboolean       none_ok;
};


gimp_param_display_id_get_type ()

GType               gimp_param_display_id_get_type      (void);


gimp_param_spec_display_id ()

GParamSpec *        gimp_param_spec_display_id          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         Gimp *gimp,
                                                         gboolean none_ok,
                                                         GParamFlags flags);


gimp_value_get_display ()

GimpObject *        gimp_value_get_display              (const GValue *value,
                                                         Gimp *gimp);


gimp_value_set_display ()

void                gimp_value_set_display              (GValue *value,
                                                         GimpObject *display);


struct GimpArray

struct GimpArray {
  guint8   *data;
  gsize     length;
  gboolean  static_data;
};


gimp_array_new ()

GimpArray *         gimp_array_new                      (const guint8 *data,
                                                         gsize length,
                                                         gboolean static_data);


gimp_array_copy ()

GimpArray *         gimp_array_copy                     (const GimpArray *array);


gimp_array_free ()

void                gimp_array_free                     (GimpArray *array);


GIMP_TYPE_ARRAY

#define GIMP_TYPE_ARRAY               (gimp_array_get_type ())


GIMP_VALUE_HOLDS_ARRAY()

#define GIMP_VALUE_HOLDS_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_ARRAY))


gimp_array_get_type ()

GType               gimp_array_get_type                 (void);


GIMP_TYPE_PARAM_ARRAY

#define GIMP_TYPE_PARAM_ARRAY           (gimp_param_array_get_type ())


GIMP_PARAM_SPEC_ARRAY()

#define GIMP_PARAM_SPEC_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_ARRAY, GimpParamSpecArray))


GIMP_IS_PARAM_SPEC_ARRAY()

#define GIMP_IS_PARAM_SPEC_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_ARRAY))


struct GimpParamSpecArray

struct GimpParamSpecArray {
  GParamSpecBoxed parent_instance;
};


gimp_param_array_get_type ()

GType               gimp_param_array_get_type           (void);


gimp_param_spec_array ()

GParamSpec *        gimp_param_spec_array               (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


GIMP_TYPE_INT8_ARRAY

#define GIMP_TYPE_INT8_ARRAY               (gimp_int8_array_get_type ())


GIMP_VALUE_HOLDS_INT8_ARRAY()

#define GIMP_VALUE_HOLDS_INT8_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT8_ARRAY))


gimp_int8_array_get_type ()

GType               gimp_int8_array_get_type            (void);


GIMP_TYPE_PARAM_INT8_ARRAY

#define GIMP_TYPE_PARAM_INT8_ARRAY           (gimp_param_int8_array_get_type ())


GIMP_PARAM_SPEC_INT8_ARRAY()

#define GIMP_PARAM_SPEC_INT8_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT8_ARRAY, GimpParamSpecInt8Array))


GIMP_IS_PARAM_SPEC_INT8_ARRAY()

#define GIMP_IS_PARAM_SPEC_INT8_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT8_ARRAY))


struct GimpParamSpecInt8Array

struct GimpParamSpecInt8Array {
  GimpParamSpecArray parent_instance;
};


gimp_param_int8_array_get_type ()

GType               gimp_param_int8_array_get_type      (void);


gimp_param_spec_int8_array ()

GParamSpec *        gimp_param_spec_int8_array          (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


gimp_value_get_int8array ()

const guint8 *      gimp_value_get_int8array            (const GValue *value);


gimp_value_dup_int8array ()

guint8 *            gimp_value_dup_int8array            (const GValue *value);


gimp_value_set_int8array ()

void                gimp_value_set_int8array            (GValue *value,
                                                         const guint8 *array,
                                                         gsize length);


gimp_value_set_static_int8array ()

void                gimp_value_set_static_int8array     (GValue *value,
                                                         const guint8 *array,
                                                         gsize length);


gimp_value_take_int8array ()

void                gimp_value_take_int8array           (GValue *value,
                                                         guint8 *array,
                                                         gsize length);


GIMP_TYPE_INT16_ARRAY

#define GIMP_TYPE_INT16_ARRAY               (gimp_int16_array_get_type ())


GIMP_VALUE_HOLDS_INT16_ARRAY()

#define GIMP_VALUE_HOLDS_INT16_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT16_ARRAY))


gimp_int16_array_get_type ()

GType               gimp_int16_array_get_type           (void);


GIMP_TYPE_PARAM_INT16_ARRAY

#define GIMP_TYPE_PARAM_INT16_ARRAY           (gimp_param_int16_array_get_type ())


GIMP_PARAM_SPEC_INT16_ARRAY()

#define GIMP_PARAM_SPEC_INT16_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT16_ARRAY, GimpParamSpecInt16Array))


GIMP_IS_PARAM_SPEC_INT16_ARRAY()

#define GIMP_IS_PARAM_SPEC_INT16_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT16_ARRAY))


struct GimpParamSpecInt16Array

struct GimpParamSpecInt16Array {
  GimpParamSpecArray parent_instance;
};


gimp_param_int16_array_get_type ()

GType               gimp_param_int16_array_get_type     (void);


gimp_param_spec_int16_array ()

GParamSpec *        gimp_param_spec_int16_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


gimp_value_get_int16array ()

const gint16 *      gimp_value_get_int16array           (const GValue *value);


gimp_value_dup_int16array ()

gint16 *            gimp_value_dup_int16array           (const GValue *value);


gimp_value_set_int16array ()

void                gimp_value_set_int16array           (GValue *value,
                                                         const gint16 *array,
                                                         gsize length);


gimp_value_set_static_int16array ()

void                gimp_value_set_static_int16array    (GValue *value,
                                                         const gint16 *array,
                                                         gsize length);


gimp_value_take_int16array ()

void                gimp_value_take_int16array          (GValue *value,
                                                         gint16 *array,
                                                         gsize length);


GIMP_TYPE_INT32_ARRAY

#define GIMP_TYPE_INT32_ARRAY               (gimp_int32_array_get_type ())


GIMP_VALUE_HOLDS_INT32_ARRAY()

#define GIMP_VALUE_HOLDS_INT32_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_INT32_ARRAY))


gimp_int32_array_get_type ()

GType               gimp_int32_array_get_type           (void);


GIMP_TYPE_PARAM_INT32_ARRAY

#define GIMP_TYPE_PARAM_INT32_ARRAY           (gimp_param_int32_array_get_type ())


GIMP_PARAM_SPEC_INT32_ARRAY()

#define GIMP_PARAM_SPEC_INT32_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_INT32_ARRAY, GimpParamSpecInt32Array))


GIMP_IS_PARAM_SPEC_INT32_ARRAY()

#define GIMP_IS_PARAM_SPEC_INT32_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_INT32_ARRAY))


struct GimpParamSpecInt32Array

struct GimpParamSpecInt32Array {
  GimpParamSpecArray parent_instance;
};


gimp_param_int32_array_get_type ()

GType               gimp_param_int32_array_get_type     (void);


gimp_param_spec_int32_array ()

GParamSpec *        gimp_param_spec_int32_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


gimp_value_get_int32array ()

const gint32 *      gimp_value_get_int32array           (const GValue *value);


gimp_value_dup_int32array ()

gint32 *            gimp_value_dup_int32array           (const GValue *value);


gimp_value_set_int32array ()

void                gimp_value_set_int32array           (GValue *value,
                                                         const gint32 *array,
                                                         gsize length);


gimp_value_set_static_int32array ()

void                gimp_value_set_static_int32array    (GValue *value,
                                                         const gint32 *array,
                                                         gsize length);


gimp_value_take_int32array ()

void                gimp_value_take_int32array          (GValue *value,
                                                         gint32 *array,
                                                         gsize length);


GIMP_TYPE_FLOAT_ARRAY

#define GIMP_TYPE_FLOAT_ARRAY               (gimp_float_array_get_type ())


GIMP_VALUE_HOLDS_FLOAT_ARRAY()

#define GIMP_VALUE_HOLDS_FLOAT_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_FLOAT_ARRAY))


gimp_float_array_get_type ()

GType               gimp_float_array_get_type           (void);


GIMP_TYPE_PARAM_FLOAT_ARRAY

#define GIMP_TYPE_PARAM_FLOAT_ARRAY           (gimp_param_float_array_get_type ())


GIMP_PARAM_SPEC_FLOAT_ARRAY()

#define GIMP_PARAM_SPEC_FLOAT_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_FLOAT_ARRAY, GimpParamSpecFloatArray))


GIMP_IS_PARAM_SPEC_FLOAT_ARRAY()

#define GIMP_IS_PARAM_SPEC_FLOAT_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_FLOAT_ARRAY))


struct GimpParamSpecFloatArray

struct GimpParamSpecFloatArray {
  GimpParamSpecArray parent_instance;
};


gimp_param_float_array_get_type ()

GType               gimp_param_float_array_get_type     (void);


gimp_param_spec_float_array ()

GParamSpec *        gimp_param_spec_float_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


gimp_value_get_floatarray ()

const gdouble *     gimp_value_get_floatarray           (const GValue *value);


gimp_value_dup_floatarray ()

gdouble *           gimp_value_dup_floatarray           (const GValue *value);


gimp_value_set_floatarray ()

void                gimp_value_set_floatarray           (GValue *value,
                                                         const gdouble *array,
                                                         gsize length);


gimp_value_set_static_floatarray ()

void                gimp_value_set_static_floatarray    (GValue *value,
                                                         const gdouble *array,
                                                         gsize length);


gimp_value_take_floatarray ()

void                gimp_value_take_floatarray          (GValue *value,
                                                         gdouble *array,
                                                         gsize length);


gimp_string_array_new ()

GimpArray *         gimp_string_array_new               (const gchar **data,
                                                         gsize length,
                                                         gboolean static_data);


gimp_string_array_copy ()

GimpArray *         gimp_string_array_copy              (const GimpArray *array);


gimp_string_array_free ()

void                gimp_string_array_free              (GimpArray *array);


GIMP_TYPE_STRING_ARRAY

#define GIMP_TYPE_STRING_ARRAY               (gimp_string_array_get_type ())


GIMP_VALUE_HOLDS_STRING_ARRAY()

#define GIMP_VALUE_HOLDS_STRING_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_STRING_ARRAY))


gimp_string_array_get_type ()

GType               gimp_string_array_get_type          (void);


GIMP_TYPE_PARAM_STRING_ARRAY

#define GIMP_TYPE_PARAM_STRING_ARRAY           (gimp_param_string_array_get_type ())


GIMP_PARAM_SPEC_STRING_ARRAY()

#define GIMP_PARAM_SPEC_STRING_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_STRING_ARRAY, GimpParamSpecStringArray))


GIMP_IS_PARAM_SPEC_STRING_ARRAY()

#define GIMP_IS_PARAM_SPEC_STRING_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_STRING_ARRAY))


struct GimpParamSpecStringArray

struct GimpParamSpecStringArray {
  GParamSpecBoxed parent_instance;
};


gimp_param_string_array_get_type ()

GType               gimp_param_string_array_get_type    (void);


gimp_param_spec_string_array ()

GParamSpec *        gimp_param_spec_string_array        (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


gimp_value_get_stringarray ()

const gchar **      gimp_value_get_stringarray          (const GValue *value);


gimp_value_dup_stringarray ()

gchar **            gimp_value_dup_stringarray          (const GValue *value);


gimp_value_set_stringarray ()

void                gimp_value_set_stringarray          (GValue *value,
                                                         const gchar **array,
                                                         gsize length);


gimp_value_set_static_stringarray ()

void                gimp_value_set_static_stringarray   (GValue *value,
                                                         const gchar **array,
                                                         gsize length);


gimp_value_take_stringarray ()

void                gimp_value_take_stringarray         (GValue *value,
                                                         gchar **array,
                                                         gsize length);


GIMP_TYPE_COLOR_ARRAY

#define GIMP_TYPE_COLOR_ARRAY               (gimp_color_array_get_type ())


GIMP_VALUE_HOLDS_COLOR_ARRAY()

#define GIMP_VALUE_HOLDS_COLOR_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_COLOR_ARRAY))


gimp_color_array_get_type ()

GType               gimp_color_array_get_type           (void);


gimp_param_color_array_get_type ()

GType               gimp_param_color_array_get_type     (void);


GIMP_TYPE_PARAM_COLOR_ARRAY

#define GIMP_TYPE_PARAM_COLOR_ARRAY           (gimp_param_color_array_get_type ())


GIMP_PARAM_SPEC_COLOR_ARRAY()

#define GIMP_PARAM_SPEC_COLOR_ARRAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_COLOR_ARRAY, GimpParamSpecColorArray))


GIMP_IS_PARAM_SPEC_COLOR_ARRAY()

#define GIMP_IS_PARAM_SPEC_COLOR_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_COLOR_ARRAY))


struct GimpParamSpecColorArray

struct GimpParamSpecColorArray {
  GParamSpecBoxed parent_instance;
};


gimp_param_spec_color_array ()

GParamSpec *        gimp_param_spec_color_array         (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GParamFlags flags);


gimp_value_dup_colorarray ()

GimpRGB *           gimp_value_dup_colorarray           (const GValue *value);


gimp_value_get_colorarray ()

const GimpRGB *     gimp_value_get_colorarray           (const GValue *value);


gimp_value_set_colorarray ()

void                gimp_value_set_colorarray           (GValue *value,
                                                         const GimpRGB *array,
                                                         gsize length);


gimp_value_set_static_colorarray ()

void                gimp_value_set_static_colorarray    (GValue *value,
                                                         const GimpRGB *array,
                                                         gsize length);


gimp_value_take_colorarray ()

void                gimp_value_take_colorarray          (GValue *value,
                                                         GimpRGB *array,
                                                         gsize length);