From 5c7134f3a5dd50c6044188688be369f5e6834f15 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Fri, 26 Jul 2019 12:56:28 +0200 Subject: [PATCH] app, pdb: rename GIMP_TYPE_COLOR_ARRAY to GIMP_TYPE_RGB_ARRAY and rename its GParamSpec too. Also, always say "foo_array" not "fooarray". --- app/core/gimpparamspecs.c | 180 ++++++++++++------------ app/core/gimpparamspecs.h | 212 ++++++++++++++--------------- app/pdb/brush-cmds.c | 4 +- app/pdb/brushes-cmds.c | 2 +- app/pdb/buffer-cmds.c | 2 +- app/pdb/context-cmds.c | 6 +- app/pdb/drawable-cmds.c | 8 +- app/pdb/drawable-color-cmds.c | 4 +- app/pdb/dynamics-cmds.c | 2 +- app/pdb/fileops-cmds.c | 4 +- app/pdb/fonts-cmds.c | 2 +- app/pdb/gimp-cmds.c | 2 +- app/pdb/gimp-pdb-compat.c | 8 +- app/pdb/gradient-cmds.c | 6 +- app/pdb/gradients-cmds.c | 2 +- app/pdb/image-cmds.c | 16 +-- app/pdb/image-color-profile-cmds.c | 8 +- app/pdb/image-convert-cmds.c | 2 +- app/pdb/image-select-cmds.c | 2 +- app/pdb/item-cmds.c | 4 +- app/pdb/paint-tools-cmds.c | 34 ++--- app/pdb/palette-cmds.c | 10 +- app/pdb/palettes-cmds.c | 2 +- app/pdb/pattern-cmds.c | 2 +- app/pdb/patterns-cmds.c | 2 +- app/pdb/plug-in-cmds.c | 14 +- app/pdb/plug-in-compat-cmds.c | 4 +- app/pdb/procedural-db-cmds.c | 6 +- app/pdb/vectors-cmds.c | 12 +- app/plug-in/plug-in-params.c | 84 ++++++------ app/widgets/gimphelp.c | 36 ++--- pdb/app.pl | 8 +- pdb/pdb.pl | 24 ++-- 33 files changed, 357 insertions(+), 357 deletions(-) diff --git a/app/core/gimpparamspecs.c b/app/core/gimpparamspecs.c index cc66b8595e..8570c185b6 100644 --- a/app/core/gimpparamspecs.c +++ b/app/core/gimpparamspecs.c @@ -2157,7 +2157,7 @@ gimp_param_spec_int8_array (const gchar *name, } const guint8 * -gimp_value_get_int8array (const GValue *value) +gimp_value_get_int8_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value), NULL); @@ -2165,7 +2165,7 @@ gimp_value_get_int8array (const GValue *value) } guint8 * -gimp_value_dup_int8array (const GValue *value) +gimp_value_dup_int8_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value), NULL); @@ -2173,9 +2173,9 @@ gimp_value_dup_int8array (const GValue *value) } void -gimp_value_set_int8array (GValue *value, - const guint8 *data, - gsize length) +gimp_value_set_int8_array (GValue *value, + const guint8 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value)); @@ -2183,9 +2183,9 @@ gimp_value_set_int8array (GValue *value, } void -gimp_value_set_static_int8array (GValue *value, - const guint8 *data, - gsize length) +gimp_value_set_static_int8_array (GValue *value, + const guint8 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value)); @@ -2193,9 +2193,9 @@ gimp_value_set_static_int8array (GValue *value, } void -gimp_value_take_int8array (GValue *value, - guint8 *data, - gsize length) +gimp_value_take_int8_array (GValue *value, + guint8 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT8_ARRAY (value)); @@ -2279,7 +2279,7 @@ gimp_param_spec_int16_array (const gchar *name, } const gint16 * -gimp_value_get_int16array (const GValue *value) +gimp_value_get_int16_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value), NULL); @@ -2287,7 +2287,7 @@ gimp_value_get_int16array (const GValue *value) } gint16 * -gimp_value_dup_int16array (const GValue *value) +gimp_value_dup_int16_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value), NULL); @@ -2295,9 +2295,9 @@ gimp_value_dup_int16array (const GValue *value) } void -gimp_value_set_int16array (GValue *value, - const gint16 *data, - gsize length) +gimp_value_set_int16_array (GValue *value, + const gint16 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value)); @@ -2306,9 +2306,9 @@ gimp_value_set_int16array (GValue *value, } void -gimp_value_set_static_int16array (GValue *value, - const gint16 *data, - gsize length) +gimp_value_set_static_int16_array (GValue *value, + const gint16 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value)); @@ -2317,9 +2317,9 @@ gimp_value_set_static_int16array (GValue *value, } void -gimp_value_take_int16array (GValue *value, - gint16 *data, - gsize length) +gimp_value_take_int16_array (GValue *value, + gint16 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT16_ARRAY (value)); @@ -2404,7 +2404,7 @@ gimp_param_spec_int32_array (const gchar *name, } const gint32 * -gimp_value_get_int32array (const GValue *value) +gimp_value_get_int32_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value), NULL); @@ -2412,7 +2412,7 @@ gimp_value_get_int32array (const GValue *value) } gint32 * -gimp_value_dup_int32array (const GValue *value) +gimp_value_dup_int32_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value), NULL); @@ -2420,9 +2420,9 @@ gimp_value_dup_int32array (const GValue *value) } void -gimp_value_set_int32array (GValue *value, - const gint32 *data, - gsize length) +gimp_value_set_int32_array (GValue *value, + const gint32 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value)); @@ -2431,9 +2431,9 @@ gimp_value_set_int32array (GValue *value, } void -gimp_value_set_static_int32array (GValue *value, - const gint32 *data, - gsize length) +gimp_value_set_static_int32_array (GValue *value, + const gint32 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value)); @@ -2442,9 +2442,9 @@ gimp_value_set_static_int32array (GValue *value, } void -gimp_value_take_int32array (GValue *value, - gint32 *data, - gsize length) +gimp_value_take_int32_array (GValue *value, + gint32 *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value)); @@ -2529,7 +2529,7 @@ gimp_param_spec_float_array (const gchar *name, } const gdouble * -gimp_value_get_floatarray (const GValue *value) +gimp_value_get_float_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), NULL); @@ -2537,7 +2537,7 @@ gimp_value_get_floatarray (const GValue *value) } gdouble * -gimp_value_dup_floatarray (const GValue *value) +gimp_value_dup_float_array (const GValue *value) { g_return_val_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), NULL); @@ -2545,9 +2545,9 @@ gimp_value_dup_floatarray (const GValue *value) } void -gimp_value_set_floatarray (GValue *value, - const gdouble *data, - gsize length) +gimp_value_set_float_array (GValue *value, + const gdouble *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)); @@ -2556,9 +2556,9 @@ gimp_value_set_floatarray (GValue *value, } void -gimp_value_set_static_floatarray (GValue *value, - const gdouble *data, - gsize length) +gimp_value_set_static_float_array (GValue *value, + const gdouble *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)); @@ -2567,9 +2567,9 @@ gimp_value_set_static_floatarray (GValue *value, } void -gimp_value_take_floatarray (GValue *value, - gdouble *data, - gsize length) +gimp_value_take_float_array (GValue *value, + gdouble *data, + gsize length) { g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)); @@ -2765,7 +2765,7 @@ gimp_param_spec_string_array (const gchar *name, } const gchar ** -gimp_value_get_stringarray (const GValue *value) +gimp_value_get_string_array (const GValue *value) { GimpArray *array; @@ -2780,7 +2780,7 @@ gimp_value_get_stringarray (const GValue *value) } gchar ** -gimp_value_dup_stringarray (const GValue *value) +gimp_value_dup_string_array (const GValue *value) { GimpArray *array; @@ -2803,9 +2803,9 @@ gimp_value_dup_stringarray (const GValue *value) } void -gimp_value_set_stringarray (GValue *value, - const gchar **data, - gsize length) +gimp_value_set_string_array (GValue *value, + const gchar **data, + gsize length) { GimpArray *array; @@ -2817,9 +2817,9 @@ gimp_value_set_stringarray (GValue *value, } void -gimp_value_set_static_stringarray (GValue *value, - const gchar **data, - gsize length) +gimp_value_set_static_string_array (GValue *value, + const gchar **data, + gsize length) { GimpArray *array; @@ -2831,9 +2831,9 @@ gimp_value_set_static_stringarray (GValue *value, } void -gimp_value_take_stringarray (GValue *value, - gchar **data, - gsize length) +gimp_value_take_string_array (GValue *value, + gchar **data, + gsize length) { GimpArray *array; @@ -2847,16 +2847,16 @@ gimp_value_take_stringarray (GValue *value, /* - * GIMP_TYPE_COLOR_ARRAY + * GIMP_TYPE_RGB_ARRAY */ GType -gimp_color_array_get_type (void) +gimp_rgb_array_get_type (void) { static GType type = 0; if (! type) - type = g_boxed_type_register_static ("GimpColorArray", + type = g_boxed_type_register_static ("GimpRgbArray", (GBoxedCopyFunc) gimp_array_copy, (GBoxedFreeFunc) gimp_array_free); @@ -2865,14 +2865,14 @@ gimp_color_array_get_type (void) /* - * GIMP_TYPE_PARAM_COLOR_ARRAY + * GIMP_TYPE_PARAM_RGB_ARRAY */ -static void gimp_param_color_array_class_init (GParamSpecClass *klass); -static void gimp_param_color_array_init (GParamSpec *pspec); +static void gimp_param_rgb_array_class_init (GParamSpecClass *klass); +static void gimp_param_rgb_array_init (GParamSpec *pspec); GType -gimp_param_color_array_get_type (void) +gimp_param_rgb_array_get_type (void) { static GType type = 0; @@ -2882,89 +2882,89 @@ gimp_param_color_array_get_type (void) { sizeof (GParamSpecClass), NULL, NULL, - (GClassInitFunc) gimp_param_color_array_class_init, + (GClassInitFunc) gimp_param_rgb_array_class_init, NULL, NULL, sizeof (GimpParamSpecArray), 0, - (GInstanceInitFunc) gimp_param_color_array_init + (GInstanceInitFunc) gimp_param_rgb_array_init }; type = g_type_register_static (G_TYPE_PARAM_BOXED, - "GimpParamColorArray", &info, 0); + "GimpParamRGBArray", &info, 0); } return type; } static void -gimp_param_color_array_class_init (GParamSpecClass *klass) +gimp_param_rgb_array_class_init (GParamSpecClass *klass) { - klass->value_type = GIMP_TYPE_COLOR_ARRAY; + klass->value_type = GIMP_TYPE_RGB_ARRAY; } static void -gimp_param_color_array_init (GParamSpec *pspec) +gimp_param_rgb_array_init (GParamSpec *pspec) { } GParamSpec * -gimp_param_spec_color_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags) +gimp_param_spec_rgb_array (const gchar *name, + const gchar *nick, + const gchar *blurb, + GParamFlags flags) { - GimpParamSpecColorArray *array_spec; + GimpParamSpecRGBArray *array_spec; - array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_COLOR_ARRAY, + array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_RGB_ARRAY, name, nick, blurb, flags); return G_PARAM_SPEC (array_spec); } const GimpRGB * -gimp_value_get_colorarray (const GValue *value) +gimp_value_get_rgb_array (const GValue *value) { - g_return_val_if_fail (GIMP_VALUE_HOLDS_COLOR_ARRAY (value), NULL); + g_return_val_if_fail (GIMP_VALUE_HOLDS_RGB_ARRAY (value), NULL); return (const GimpRGB *) gimp_value_get_array (value); } GimpRGB * -gimp_value_dup_colorarray (const GValue *value) +gimp_value_dup_rgb_array (const GValue *value) { - g_return_val_if_fail (GIMP_VALUE_HOLDS_COLOR_ARRAY (value), NULL); + g_return_val_if_fail (GIMP_VALUE_HOLDS_RGB_ARRAY (value), NULL); return (GimpRGB *) gimp_value_dup_array (value); } void -gimp_value_set_colorarray (GValue *value, - const GimpRGB *data, - gsize length) +gimp_value_set_rgb_array (GValue *value, + const GimpRGB *data, + gsize length) { - g_return_if_fail (GIMP_VALUE_HOLDS_COLOR_ARRAY (value)); + g_return_if_fail (GIMP_VALUE_HOLDS_RGB_ARRAY (value)); gimp_value_set_array (value, (const guint8 *) data, length * sizeof (GimpRGB)); } void -gimp_value_set_static_colorarray (GValue *value, - const GimpRGB *data, - gsize length) +gimp_value_set_static_rgb_array (GValue *value, + const GimpRGB *data, + gsize length) { - g_return_if_fail (GIMP_VALUE_HOLDS_COLOR_ARRAY (value)); + g_return_if_fail (GIMP_VALUE_HOLDS_RGB_ARRAY (value)); gimp_value_set_static_array (value, (const guint8 *) data, length * sizeof (GimpRGB)); } void -gimp_value_take_colorarray (GValue *value, - GimpRGB *data, - gsize length) +gimp_value_take_rgb_array (GValue *value, + GimpRGB *data, + gsize length) { - g_return_if_fail (GIMP_VALUE_HOLDS_COLOR_ARRAY (value)); + g_return_if_fail (GIMP_VALUE_HOLDS_RGB_ARRAY (value)); gimp_value_take_array (value, (guint8 *) data, length * sizeof (GimpRGB)); diff --git a/app/core/gimpparamspecs.h b/app/core/gimpparamspecs.h index abfb56f4ae..51e7968d52 100644 --- a/app/core/gimpparamspecs.h +++ b/app/core/gimpparamspecs.h @@ -650,24 +650,24 @@ struct _GimpParamSpecInt8Array GimpParamSpecArray parent_instance; }; -GType gimp_param_int8_array_get_type (void) G_GNUC_CONST; +GType gimp_param_int8_array_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_int8_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags); +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); +const guint8 * gimp_value_get_int8_array (const GValue *value); +guint8 * gimp_value_dup_int8_array (const GValue *value); +void gimp_value_set_int8_array (GValue *value, + const guint8 *array, + gsize length); +void gimp_value_set_static_int8_array (GValue *value, + const guint8 *array, + gsize length); +void gimp_value_take_int8_array (GValue *value, + guint8 *array, + gsize length); /* @@ -695,24 +695,24 @@ struct _GimpParamSpecInt16Array GimpParamSpecArray parent_instance; }; -GType gimp_param_int16_array_get_type (void) G_GNUC_CONST; +GType gimp_param_int16_array_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_int16_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags); +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); +const gint16 * gimp_value_get_int16_array (const GValue *value); +gint16 * gimp_value_dup_int16_array (const GValue *value); +void gimp_value_set_int16_array (GValue *value, + const gint16 *array, + gsize length); +void gimp_value_set_static_int16_array (GValue *value, + const gint16 *array, + gsize length); +void gimp_value_take_int16_array (GValue *value, + gint16 *array, + gsize length); /* @@ -740,24 +740,24 @@ struct _GimpParamSpecInt32Array GimpParamSpecArray parent_instance; }; -GType gimp_param_int32_array_get_type (void) G_GNUC_CONST; +GType gimp_param_int32_array_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_int32_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags); +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); +const gint32 * gimp_value_get_int32_array (const GValue *value); +gint32 * gimp_value_dup_int32_array (const GValue *value); +void gimp_value_set_int32_array (GValue *value, + const gint32 *array, + gsize length); +void gimp_value_set_static_int32_array (GValue *value, + const gint32 *array, + gsize length); +void gimp_value_take_int32_array (GValue *value, + gint32 *array, + gsize length); /* @@ -785,24 +785,24 @@ struct _GimpParamSpecFloatArray GimpParamSpecArray parent_instance; }; -GType gimp_param_float_array_get_type (void) G_GNUC_CONST; +GType gimp_param_float_array_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_float_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags); +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); +const gdouble * gimp_value_get_float_array (const GValue *value); +gdouble * gimp_value_dup_float_array (const GValue *value); +void gimp_value_set_float_array (GValue *value, + const gdouble *array, + gsize length); +void gimp_value_set_static_float_array (GValue *value, + const gdouble *array, + gsize length); +void gimp_value_take_float_array (GValue *value, + gdouble *array, + gsize length); /* @@ -836,69 +836,69 @@ struct _GimpParamSpecStringArray GParamSpecBoxed parent_instance; }; -GType gimp_param_string_array_get_type (void) G_GNUC_CONST; +GType gimp_param_string_array_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_string_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags); +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); +const gchar ** gimp_value_get_string_array (const GValue *value); +gchar ** gimp_value_dup_string_array (const GValue *value); +void gimp_value_set_string_array (GValue *value, + const gchar **array, + gsize length); +void gimp_value_set_static_string_array (GValue *value, + const gchar **array, + gsize length); +void gimp_value_take_string_array (GValue *value, + gchar **array, + gsize length); /* - * GIMP_TYPE_COLOR_ARRAY + * GIMP_TYPE_RGB_ARRAY */ -#define GIMP_TYPE_COLOR_ARRAY (gimp_color_array_get_type ()) -#define GIMP_VALUE_HOLDS_COLOR_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_COLOR_ARRAY)) +#define GIMP_TYPE_RGB_ARRAY (gimp_rgb_array_get_type ()) +#define GIMP_VALUE_HOLDS_RGB_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_RGB_ARRAY)) -GType gimp_color_array_get_type (void) G_GNUC_CONST; +GType gimp_rgb_array_get_type (void) G_GNUC_CONST; /* - * GIMP_TYPE_PARAM_COLOR_ARRAY + * GIMP_TYPE_PARAM_RGB_ARRAY */ -#define GIMP_TYPE_PARAM_COLOR_ARRAY (gimp_param_color_array_get_type ()) -#define GIMP_PARAM_SPEC_COLOR_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_COLOR_ARRAY, GimpParamSpecColorArray)) -#define GIMP_IS_PARAM_SPEC_COLOR_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_COLOR_ARRAY)) +#define GIMP_TYPE_PARAM_RGB_ARRAY (gimp_param_rgb_array_get_type ()) +#define GIMP_PARAM_SPEC_RGB_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), GIMP_TYPE_PARAM_RGB_ARRAY, GimpParamSpecRGBArray)) +#define GIMP_IS_PARAM_SPEC_RGB_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_RGB_ARRAY)) -typedef struct _GimpParamSpecColorArray GimpParamSpecColorArray; +typedef struct _GimpParamSpecRGBArray GimpParamSpecRGBArray; -struct _GimpParamSpecColorArray +struct _GimpParamSpecRGBArray { GParamSpecBoxed parent_instance; }; -GType gimp_param_color_array_get_type (void) G_GNUC_CONST; +GType gimp_param_rgb_array_get_type (void) G_GNUC_CONST; -GParamSpec * gimp_param_spec_color_array (const gchar *name, - const gchar *nick, - const gchar *blurb, - GParamFlags flags); +GParamSpec * gimp_param_spec_rgb_array (const gchar *name, + const gchar *nick, + const gchar *blurb, + GParamFlags flags); -const GimpRGB * gimp_value_get_colorarray (const GValue *value); -GimpRGB * gimp_value_dup_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); +const GimpRGB * gimp_value_get_rgb_array (const GValue *value); +GimpRGB * gimp_value_dup_rgb_array (const GValue *value); +void gimp_value_set_rgb_array (GValue *value, + const GimpRGB *array, + gsize length); +void gimp_value_set_static_rgb_array (GValue *value, + const GimpRGB *array, + gsize length); +void gimp_value_take_rgb_array (GValue *value, + GimpRGB *array, + gsize length); #endif /* __GIMP_PARAM_SPECS_H__ */ diff --git a/app/pdb/brush-cmds.c b/app/pdb/brush-cmds.c index 2415d63318..60cde6f961 100644 --- a/app/pdb/brush-cmds.c +++ b/app/pdb/brush-cmds.c @@ -393,10 +393,10 @@ brush_get_pixels_invoker (GimpProcedure *procedure, g_value_set_int (gimp_value_array_index (return_vals, 2), height); g_value_set_int (gimp_value_array_index (return_vals, 3), mask_bpp); g_value_set_int (gimp_value_array_index (return_vals, 4), num_mask_bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 5), mask_bytes, num_mask_bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 5), mask_bytes, num_mask_bytes); g_value_set_int (gimp_value_array_index (return_vals, 6), color_bpp); g_value_set_int (gimp_value_array_index (return_vals, 7), num_color_bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 8), color_bytes, num_color_bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 8), color_bytes, num_color_bytes); } return return_vals; diff --git a/app/pdb/brushes-cmds.c b/app/pdb/brushes-cmds.c index 4ae49d3e00..73bccadbe4 100644 --- a/app/pdb/brushes-cmds.c +++ b/app/pdb/brushes-cmds.c @@ -84,7 +84,7 @@ brushes_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_brushes); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), brush_list, num_brushes); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), brush_list, num_brushes); } return return_vals; diff --git a/app/pdb/buffer-cmds.c b/app/pdb/buffer-cmds.c index 23f5a8f777..b849bd40fc 100644 --- a/app/pdb/buffer-cmds.c +++ b/app/pdb/buffer-cmds.c @@ -70,7 +70,7 @@ buffers_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_buffers); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), buffer_list, num_buffers); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), buffer_list, num_buffers); } return return_vals; diff --git a/app/pdb/context-cmds.c b/app/pdb/context-cmds.c index 9d139ae274..277b8069e2 100644 --- a/app/pdb/context-cmds.c +++ b/app/pdb/context-cmds.c @@ -123,7 +123,7 @@ context_list_paint_methods_invoker (GimpProcedure *procedure, return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL); g_value_set_int (gimp_value_array_index (return_vals, 1), num_paint_methods); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), paint_methods, num_paint_methods); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), paint_methods, num_paint_methods); return return_vals; } @@ -759,7 +759,7 @@ context_get_line_dash_pattern_invoker (GimpProcedure *procedure, return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL); g_value_set_int (gimp_value_array_index (return_vals, 1), num_dashes); - gimp_value_take_floatarray (gimp_value_array_index (return_vals, 2), dashes, num_dashes); + gimp_value_take_float_array (gimp_value_array_index (return_vals, 2), dashes, num_dashes); return return_vals; } @@ -777,7 +777,7 @@ context_set_line_dash_pattern_invoker (GimpProcedure *procedure, const gdouble *dashes; num_dashes = g_value_get_int (gimp_value_array_index (args, 0)); - dashes = gimp_value_get_floatarray (gimp_value_array_index (args, 1)); + dashes = gimp_value_get_float_array (gimp_value_array_index (args, 1)); if (success) { diff --git a/app/pdb/drawable-cmds.c b/app/pdb/drawable-cmds.c index e608ad93ee..60b00274af 100644 --- a/app/pdb/drawable-cmds.c +++ b/app/pdb/drawable-cmds.c @@ -636,7 +636,7 @@ drawable_get_pixel_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_channels); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), pixel, num_channels); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 2), pixel, num_channels); } return return_vals; @@ -661,7 +661,7 @@ drawable_set_pixel_invoker (GimpProcedure *procedure, x_coord = g_value_get_int (gimp_value_array_index (args, 1)); y_coord = g_value_get_int (gimp_value_array_index (args, 2)); num_channels = g_value_get_int (gimp_value_array_index (args, 3)); - pixel = gimp_value_get_int8array (gimp_value_array_index (args, 4)); + pixel = gimp_value_get_int8_array (gimp_value_array_index (args, 4)); if (success) { @@ -825,7 +825,7 @@ drawable_thumbnail_invoker (GimpProcedure *procedure, g_value_set_int (gimp_value_array_index (return_vals, 2), actual_height); g_value_set_int (gimp_value_array_index (return_vals, 3), bpp); g_value_set_int (gimp_value_array_index (return_vals, 4), thumbnail_data_count); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count); } return return_vals; @@ -907,7 +907,7 @@ drawable_sub_thumbnail_invoker (GimpProcedure *procedure, g_value_set_int (gimp_value_array_index (return_vals, 2), height); g_value_set_int (gimp_value_array_index (return_vals, 3), bpp); g_value_set_int (gimp_value_array_index (return_vals, 4), thumbnail_data_count); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count); } return return_vals; diff --git a/app/pdb/drawable-color-cmds.c b/app/pdb/drawable-color-cmds.c index d0fd7404a3..b921d81b9a 100644 --- a/app/pdb/drawable-color-cmds.c +++ b/app/pdb/drawable-color-cmds.c @@ -211,7 +211,7 @@ drawable_curves_explicit_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); channel = g_value_get_enum (gimp_value_array_index (args, 1)); num_values = g_value_get_int (gimp_value_array_index (args, 2)); - values = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + values = gimp_value_get_float_array (gimp_value_array_index (args, 3)); if (success) { @@ -260,7 +260,7 @@ drawable_curves_spline_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); channel = g_value_get_enum (gimp_value_array_index (args, 1)); num_points = g_value_get_int (gimp_value_array_index (args, 2)); - points = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + points = gimp_value_get_float_array (gimp_value_array_index (args, 3)); if (success) { diff --git a/app/pdb/dynamics-cmds.c b/app/pdb/dynamics-cmds.c index e071afa0bb..34390f6c2d 100644 --- a/app/pdb/dynamics-cmds.c +++ b/app/pdb/dynamics-cmds.c @@ -79,7 +79,7 @@ dynamics_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_dynamics); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), dynamics_list, num_dynamics); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), dynamics_list, num_dynamics); } return return_vals; diff --git a/app/pdb/fileops-cmds.c b/app/pdb/fileops-cmds.c index f50d34563b..2f606bdb51 100644 --- a/app/pdb/fileops-cmds.c +++ b/app/pdb/fileops-cmds.c @@ -249,7 +249,7 @@ file_load_layers_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_layers); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), layer_ids, num_layers); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), layer_ids, num_layers); } return return_vals; @@ -377,7 +377,7 @@ file_load_thumbnail_invoker (GimpProcedure *procedure, g_value_set_int (gimp_value_array_index (return_vals, 1), width); g_value_set_int (gimp_value_array_index (return_vals, 2), height); g_value_set_int (gimp_value_array_index (return_vals, 3), thumb_data_count); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 4), thumb_data, thumb_data_count); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 4), thumb_data, thumb_data_count); } return return_vals; diff --git a/app/pdb/fonts-cmds.c b/app/pdb/fonts-cmds.c index 09d25d0e56..bc28d0287e 100644 --- a/app/pdb/fonts-cmds.c +++ b/app/pdb/fonts-cmds.c @@ -86,7 +86,7 @@ fonts_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_fonts); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), font_list, num_fonts); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), font_list, num_fonts); } return return_vals; diff --git a/app/pdb/gimp-cmds.c b/app/pdb/gimp-cmds.c index a05be45c43..66c20ee811 100644 --- a/app/pdb/gimp-cmds.c +++ b/app/pdb/gimp-cmds.c @@ -195,7 +195,7 @@ get_parasite_list_invoker (GimpProcedure *procedure, return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL); g_value_set_int (gimp_value_array_index (return_vals, 1), num_parasites); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), parasites, num_parasites); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), parasites, num_parasites); return return_vals; } diff --git a/app/pdb/gimp-pdb-compat.c b/app/pdb/gimp-pdb-compat.c index 48266bb6d2..c220c22afe 100644 --- a/app/pdb/gimp-pdb-compat.c +++ b/app/pdb/gimp-pdb-compat.c @@ -153,8 +153,8 @@ gimp_pdb_compat_param_spec (Gimp *gimp, break; case GIMP_PDB_COLORARRAY: - pspec = gimp_param_spec_color_array (name, name, desc, - G_PARAM_READWRITE); + pspec = gimp_param_spec_rgb_array (name, name, desc, + G_PARAM_READWRITE); break; case GIMP_PDB_VECTORS: @@ -247,7 +247,7 @@ gimp_pdb_compat_arg_type_to_gtype (GimpPDBArgType type) return GIMP_TYPE_SELECTION_ID; case GIMP_PDB_COLORARRAY: - return GIMP_TYPE_COLOR_ARRAY; + return GIMP_TYPE_RGB_ARRAY; case GIMP_PDB_VECTORS: return GIMP_TYPE_VECTORS_ID; @@ -302,7 +302,7 @@ gimp_pdb_compat_arg_type_from_gtype (GType type) { GIMP_TYPE_INT8_ARRAY, GIMP_PDB_INT8ARRAY }, { GIMP_TYPE_FLOAT_ARRAY, GIMP_PDB_FLOATARRAY }, { GIMP_TYPE_STRING_ARRAY, GIMP_PDB_STRINGARRAY }, - { GIMP_TYPE_COLOR_ARRAY, GIMP_PDB_COLORARRAY }, + { GIMP_TYPE_RGB_ARRAY, GIMP_PDB_COLORARRAY }, { GIMP_TYPE_ITEM_ID, GIMP_PDB_ITEM }, { GIMP_TYPE_DISPLAY_ID, GIMP_PDB_DISPLAY }, diff --git a/app/pdb/gradient-cmds.c b/app/pdb/gradient-cmds.c index 27434b3b73..589ce33863 100644 --- a/app/pdb/gradient-cmds.c +++ b/app/pdb/gradient-cmds.c @@ -377,7 +377,7 @@ gradient_get_uniform_samples_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_color_samples); - gimp_value_take_floatarray (gimp_value_array_index (return_vals, 2), color_samples, num_color_samples); + gimp_value_take_float_array (gimp_value_array_index (return_vals, 2), color_samples, num_color_samples); } return return_vals; @@ -402,7 +402,7 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure, name = g_value_get_string (gimp_value_array_index (args, 0)); num_samples = g_value_get_int (gimp_value_array_index (args, 1)); - positions = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + positions = gimp_value_get_float_array (gimp_value_array_index (args, 2)); reverse = g_value_get_boolean (gimp_value_array_index (args, 3)); if (success) @@ -448,7 +448,7 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_color_samples); - gimp_value_take_floatarray (gimp_value_array_index (return_vals, 2), color_samples, num_color_samples); + gimp_value_take_float_array (gimp_value_array_index (return_vals, 2), color_samples, num_color_samples); } return return_vals; diff --git a/app/pdb/gradients-cmds.c b/app/pdb/gradients-cmds.c index 273f640549..e46d117818 100644 --- a/app/pdb/gradients-cmds.c +++ b/app/pdb/gradients-cmds.c @@ -83,7 +83,7 @@ gradients_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_gradients); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), gradient_list, num_gradients); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), gradient_list, num_gradients); } return return_vals; diff --git a/app/pdb/image-cmds.c b/app/pdb/image-cmds.c index bed0106da8..283f5ac89e 100644 --- a/app/pdb/image-cmds.c +++ b/app/pdb/image-cmds.c @@ -129,7 +129,7 @@ image_list_invoker (GimpProcedure *procedure, return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL); g_value_set_int (gimp_value_array_index (return_vals, 1), num_images); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), image_ids, num_images); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), image_ids, num_images); return return_vals; } @@ -455,7 +455,7 @@ image_get_layers_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_layers); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), layer_ids, num_layers); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), layer_ids, num_layers); } return return_vals; @@ -500,7 +500,7 @@ image_get_channels_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_channels); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), channel_ids, num_channels); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), channel_ids, num_channels); } return return_vals; @@ -545,7 +545,7 @@ image_get_vectors_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_vectors); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), vector_ids, num_vectors); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), vector_ids, num_vectors); } return return_vals; @@ -1481,7 +1481,7 @@ image_get_colormap_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), colormap, num_bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 2), colormap, num_bytes); } return return_vals; @@ -1502,7 +1502,7 @@ image_set_colormap_invoker (GimpProcedure *procedure, image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); num_bytes = g_value_get_int (gimp_value_array_index (args, 1)); - colormap = gimp_value_get_int8array (gimp_value_array_index (args, 2)); + colormap = gimp_value_get_int8_array (gimp_value_array_index (args, 2)); if (success) { @@ -1693,7 +1693,7 @@ image_thumbnail_invoker (GimpProcedure *procedure, g_value_set_int (gimp_value_array_index (return_vals, 2), actual_height); g_value_set_int (gimp_value_array_index (return_vals, 3), bpp); g_value_set_int (gimp_value_array_index (return_vals, 4), thumbnail_data_count); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 5), thumbnail_data, thumbnail_data_count); } return return_vals; @@ -2752,7 +2752,7 @@ image_get_parasite_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_parasites); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), parasites, num_parasites); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), parasites, num_parasites); } return return_vals; diff --git a/app/pdb/image-color-profile-cmds.c b/app/pdb/image-color-profile-cmds.c index db2a1f48a4..8820625d48 100644 --- a/app/pdb/image-color-profile-cmds.c +++ b/app/pdb/image-color-profile-cmds.c @@ -82,7 +82,7 @@ image_get_color_profile_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes); } return return_vals; @@ -128,7 +128,7 @@ image_get_effective_color_profile_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 2), profile_data, num_bytes); } return return_vals; @@ -149,7 +149,7 @@ image_set_color_profile_invoker (GimpProcedure *procedure, image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); num_bytes = g_value_get_int (gimp_value_array_index (args, 1)); - color_profile = gimp_value_get_int8array (gimp_value_array_index (args, 2)); + color_profile = gimp_value_get_int8_array (gimp_value_array_index (args, 2)); if (success) { @@ -244,7 +244,7 @@ image_convert_color_profile_invoker (GimpProcedure *procedure, image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); num_bytes = g_value_get_int (gimp_value_array_index (args, 1)); - color_profile = gimp_value_get_int8array (gimp_value_array_index (args, 2)); + color_profile = gimp_value_get_int8_array (gimp_value_array_index (args, 2)); intent = g_value_get_enum (gimp_value_array_index (args, 3)); bpc = g_value_get_boolean (gimp_value_array_index (args, 4)); diff --git a/app/pdb/image-convert-cmds.c b/app/pdb/image-convert-cmds.c index 0e52668997..0374032a1c 100644 --- a/app/pdb/image-convert-cmds.c +++ b/app/pdb/image-convert-cmds.c @@ -202,7 +202,7 @@ image_convert_set_dither_matrix_invoker (GimpProcedure *procedure, width = g_value_get_int (gimp_value_array_index (args, 0)); height = g_value_get_int (gimp_value_array_index (args, 1)); matrix_length = g_value_get_int (gimp_value_array_index (args, 2)); - matrix = gimp_value_get_int8array (gimp_value_array_index (args, 3)); + matrix = gimp_value_get_int8_array (gimp_value_array_index (args, 3)); if (success) { diff --git a/app/pdb/image-select-cmds.c b/app/pdb/image-select-cmds.c index 3980aea61f..fc5af260df 100644 --- a/app/pdb/image-select-cmds.c +++ b/app/pdb/image-select-cmds.c @@ -292,7 +292,7 @@ image_select_polygon_invoker (GimpProcedure *procedure, image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); operation = g_value_get_enum (gimp_value_array_index (args, 1)); num_segs = g_value_get_int (gimp_value_array_index (args, 2)); - segs = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + segs = gimp_value_get_float_array (gimp_value_array_index (args, 3)); if (success) { diff --git a/app/pdb/item-cmds.c b/app/pdb/item-cmds.c index 894e596810..f5acfa3901 100644 --- a/app/pdb/item-cmds.c +++ b/app/pdb/item-cmds.c @@ -438,7 +438,7 @@ item_get_children_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_children); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), child_ids, num_children); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), child_ids, num_children); } return return_vals; @@ -986,7 +986,7 @@ item_get_parasite_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_parasites); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), parasites, num_parasites); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), parasites, num_parasites); } return return_vals; diff --git a/app/pdb/paint-tools-cmds.c b/app/pdb/paint-tools-cmds.c index b4a0b0ffc4..763cd1411c 100644 --- a/app/pdb/paint-tools-cmds.c +++ b/app/pdb/paint-tools-cmds.c @@ -117,7 +117,7 @@ airbrush_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); pressure = g_value_get_double (gimp_value_array_index (args, 1)); num_strokes = g_value_get_int (gimp_value_array_index (args, 2)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 3)); if (success) { @@ -164,7 +164,7 @@ airbrush_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -215,7 +215,7 @@ clone_invoker (GimpProcedure *procedure, src_x = g_value_get_double (gimp_value_array_index (args, 3)); src_y = g_value_get_double (gimp_value_array_index (args, 4)); num_strokes = g_value_get_int (gimp_value_array_index (args, 5)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 6)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 6)); if (success) { @@ -265,7 +265,7 @@ clone_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -312,7 +312,7 @@ convolve_invoker (GimpProcedure *procedure, pressure = g_value_get_double (gimp_value_array_index (args, 1)); convolve_type = g_value_get_enum (gimp_value_array_index (args, 2)); num_strokes = g_value_get_int (gimp_value_array_index (args, 3)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 4)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 4)); if (success) { @@ -360,7 +360,7 @@ convolve_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -409,7 +409,7 @@ dodgeburn_invoker (GimpProcedure *procedure, dodgeburn_type = g_value_get_enum (gimp_value_array_index (args, 2)); dodgeburn_mode = g_value_get_enum (gimp_value_array_index (args, 3)); num_strokes = g_value_get_int (gimp_value_array_index (args, 4)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 5)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 5)); if (success) { @@ -458,7 +458,7 @@ dodgeburn_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -503,7 +503,7 @@ eraser_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); hardness = g_value_get_enum (gimp_value_array_index (args, 3)); method = g_value_get_enum (gimp_value_array_index (args, 4)); @@ -553,7 +553,7 @@ eraser_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -602,7 +602,7 @@ heal_invoker (GimpProcedure *procedure, src_x = g_value_get_double (gimp_value_array_index (args, 2)); src_y = g_value_get_double (gimp_value_array_index (args, 3)); num_strokes = g_value_get_int (gimp_value_array_index (args, 4)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 5)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 5)); if (success) { @@ -648,7 +648,7 @@ heal_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -695,7 +695,7 @@ paintbrush_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); fade_out = g_value_get_double (gimp_value_array_index (args, 1)); num_strokes = g_value_get_int (gimp_value_array_index (args, 2)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 3)); method = g_value_get_enum (gimp_value_array_index (args, 4)); gradient_length = g_value_get_double (gimp_value_array_index (args, 5)); @@ -776,7 +776,7 @@ paintbrush_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -819,7 +819,7 @@ pencil_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { @@ -864,7 +864,7 @@ smudge_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); pressure = g_value_get_double (gimp_value_array_index (args, 1)); num_strokes = g_value_get_int (gimp_value_array_index (args, 2)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 3)); if (success) { @@ -911,7 +911,7 @@ smudge_default_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 0), gimp); num_strokes = g_value_get_int (gimp_value_array_index (args, 1)); - strokes = gimp_value_get_floatarray (gimp_value_array_index (args, 2)); + strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2)); if (success) { diff --git a/app/pdb/palette-cmds.c b/app/pdb/palette-cmds.c index df78136a49..ae1a31f11f 100644 --- a/app/pdb/palette-cmds.c +++ b/app/pdb/palette-cmds.c @@ -303,7 +303,7 @@ palette_get_colors_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_colors); - gimp_value_take_colorarray (gimp_value_array_index (return_vals, 2), colors, num_colors); + gimp_value_take_rgb_array (gimp_value_array_index (return_vals, 2), colors, num_colors); } return return_vals; @@ -816,10 +816,10 @@ register_palette_procs (GimpPDB *pdb) 0, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, - gimp_param_spec_color_array ("colors", - "colors", - "The colors in the palette", - GIMP_PARAM_READWRITE)); + gimp_param_spec_rgb_array ("colors", + "colors", + "The colors in the palette", + GIMP_PARAM_READWRITE)); gimp_pdb_register_procedure (pdb, procedure); g_object_unref (procedure); diff --git a/app/pdb/palettes-cmds.c b/app/pdb/palettes-cmds.c index 1f112e2cf6..4c2b5b6ba9 100644 --- a/app/pdb/palettes-cmds.c +++ b/app/pdb/palettes-cmds.c @@ -83,7 +83,7 @@ palettes_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_palettes); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), palette_list, num_palettes); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), palette_list, num_palettes); } return return_vals; diff --git a/app/pdb/pattern-cmds.c b/app/pdb/pattern-cmds.c index e9a67d9b3c..ee1c804049 100644 --- a/app/pdb/pattern-cmds.c +++ b/app/pdb/pattern-cmds.c @@ -144,7 +144,7 @@ pattern_get_pixels_invoker (GimpProcedure *procedure, g_value_set_int (gimp_value_array_index (return_vals, 2), height); g_value_set_int (gimp_value_array_index (return_vals, 3), bpp); g_value_set_int (gimp_value_array_index (return_vals, 4), num_color_bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 5), color_bytes, num_color_bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 5), color_bytes, num_color_bytes); } return return_vals; diff --git a/app/pdb/patterns-cmds.c b/app/pdb/patterns-cmds.c index a5fdf6af10..0831381769 100644 --- a/app/pdb/patterns-cmds.c +++ b/app/pdb/patterns-cmds.c @@ -84,7 +84,7 @@ patterns_get_list_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_patterns); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), pattern_list, num_patterns); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), pattern_list, num_patterns); } return return_vals; diff --git a/app/pdb/plug-in-cmds.c b/app/pdb/plug-in-cmds.c index 9551ab0d01..2fa928f14a 100644 --- a/app/pdb/plug-in-cmds.c +++ b/app/pdb/plug-in-cmds.c @@ -78,17 +78,17 @@ plugins_query_invoker (GimpProcedure *procedure, return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL); g_value_set_int (gimp_value_array_index (return_vals, 1), num_plugins); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), menu_path, num_plugins); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), menu_path, num_plugins); g_value_set_int (gimp_value_array_index (return_vals, 3), num_plugins); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 4), plugin_accelerator, num_plugins); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 4), plugin_accelerator, num_plugins); g_value_set_int (gimp_value_array_index (return_vals, 5), num_plugins); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 6), plugin_location, num_plugins); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 6), plugin_location, num_plugins); g_value_set_int (gimp_value_array_index (return_vals, 7), num_plugins); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 8), plugin_image_type, num_plugins); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 8), plugin_image_type, num_plugins); g_value_set_int (gimp_value_array_index (return_vals, 9), num_plugins); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 10), plugin_install_time, num_plugins); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 10), plugin_install_time, num_plugins); g_value_set_int (gimp_value_array_index (return_vals, 11), num_plugins); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 12), plugin_real_name, num_plugins); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 12), plugin_real_name, num_plugins); return return_vals; } @@ -247,7 +247,7 @@ plugin_icon_register_invoker (GimpProcedure *procedure, procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); icon_type = g_value_get_enum (gimp_value_array_index (args, 1)); icon_data_length = g_value_get_int (gimp_value_array_index (args, 2)); - icon_data = gimp_value_get_int8array (gimp_value_array_index (args, 3)); + icon_data = gimp_value_get_int8_array (gimp_value_array_index (args, 3)); if (success) { diff --git a/app/pdb/plug-in-compat-cmds.c b/app/pdb/plug-in-compat-cmds.c index 937d3ca486..50b21cc29c 100644 --- a/app/pdb/plug-in-compat-cmds.c +++ b/app/pdb/plug-in-compat-cmds.c @@ -1098,12 +1098,12 @@ plug_in_convmatrix_invoker (GimpProcedure *procedure, drawable = gimp_value_get_drawable (gimp_value_array_index (args, 2), gimp); argc_matrix = g_value_get_int (gimp_value_array_index (args, 3)); - matrix = gimp_value_get_floatarray (gimp_value_array_index (args, 4)); + matrix = gimp_value_get_float_array (gimp_value_array_index (args, 4)); alpha_alg = g_value_get_boolean (gimp_value_array_index (args, 5)); divisor = g_value_get_double (gimp_value_array_index (args, 6)); offset = g_value_get_double (gimp_value_array_index (args, 7)); argc_channels = g_value_get_int (gimp_value_array_index (args, 8)); - channels = gimp_value_get_int32array (gimp_value_array_index (args, 9)); + channels = gimp_value_get_int32_array (gimp_value_array_index (args, 9)); bmode = g_value_get_int (gimp_value_array_index (args, 10)); if (success) diff --git a/app/pdb/procedural-db-cmds.c b/app/pdb/procedural-db-cmds.c index bb8896e226..ef3eb53e23 100644 --- a/app/pdb/procedural-db-cmds.c +++ b/app/pdb/procedural-db-cmds.c @@ -131,7 +131,7 @@ procedural_db_query_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_matches); - gimp_value_take_stringarray (gimp_value_array_index (return_vals, 2), procedure_names, num_matches); + gimp_value_take_string_array (gimp_value_array_index (return_vals, 2), procedure_names, num_matches); } return return_vals; @@ -408,7 +408,7 @@ procedural_db_get_data_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), bytes); - gimp_value_take_int8array (gimp_value_array_index (return_vals, 2), data, bytes); + gimp_value_take_int8_array (gimp_value_array_index (return_vals, 2), data, bytes); } return return_vals; @@ -464,7 +464,7 @@ procedural_db_set_data_invoker (GimpProcedure *procedure, identifier = g_value_get_string (gimp_value_array_index (args, 0)); bytes = g_value_get_int (gimp_value_array_index (args, 1)); - data = gimp_value_get_int8array (gimp_value_array_index (args, 2)); + data = gimp_value_get_int8_array (gimp_value_array_index (args, 2)); if (success) { diff --git a/app/pdb/vectors-cmds.c b/app/pdb/vectors-cmds.c index f749869007..32a40742af 100644 --- a/app/pdb/vectors-cmds.c +++ b/app/pdb/vectors-cmds.c @@ -202,7 +202,7 @@ vectors_get_strokes_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_strokes); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), stroke_ids, num_strokes); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), stroke_ids, num_strokes); } return return_vals; @@ -669,7 +669,7 @@ vectors_stroke_get_points_invoker (GimpProcedure *procedure, { g_value_set_enum (gimp_value_array_index (return_vals, 1), type); g_value_set_int (gimp_value_array_index (return_vals, 2), num_points); - gimp_value_take_floatarray (gimp_value_array_index (return_vals, 3), controlpoints, num_points); + gimp_value_take_float_array (gimp_value_array_index (return_vals, 3), controlpoints, num_points); g_value_set_boolean (gimp_value_array_index (return_vals, 4), closed); } @@ -696,7 +696,7 @@ vectors_stroke_new_from_points_invoker (GimpProcedure *procedure, vectors = gimp_value_get_vectors (gimp_value_array_index (args, 0), gimp); type = g_value_get_enum (gimp_value_array_index (args, 1)); num_points = g_value_get_int (gimp_value_array_index (args, 2)); - controlpoints = gimp_value_get_floatarray (gimp_value_array_index (args, 3)); + controlpoints = gimp_value_get_float_array (gimp_value_array_index (args, 3)); closed = g_value_get_boolean (gimp_value_array_index (args, 4)); if (success) @@ -806,7 +806,7 @@ vectors_stroke_interpolate_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_coords); - gimp_value_take_floatarray (gimp_value_array_index (return_vals, 2), coords, num_coords); + gimp_value_take_float_array (gimp_value_array_index (return_vals, 2), coords, num_coords); g_value_set_boolean (gimp_value_array_index (return_vals, 3), closed); } @@ -1159,7 +1159,7 @@ vectors_import_from_file_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_vectors); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), vectors_ids, num_vectors); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), vectors_ids, num_vectors); } return return_vals; @@ -1223,7 +1223,7 @@ vectors_import_from_string_invoker (GimpProcedure *procedure, if (success) { g_value_set_int (gimp_value_array_index (return_vals, 1), num_vectors); - gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), vectors_ids, num_vectors); + gimp_value_take_int32_array (gimp_value_array_index (return_vals, 2), vectors_ids, num_vectors); } return return_vals; diff --git a/app/plug-in/plug-in-params.c b/app/plug-in/plug-in-params.c index 3f781b22ef..1614189cbc 100644 --- a/app/plug-in/plug-in-params.c +++ b/app/plug-in/plug-in-params.c @@ -132,61 +132,61 @@ plug_in_params_to_args (GParamSpec **pspecs, case GIMP_PDB_INT32ARRAY: count = g_value_get_int (gimp_value_array_index (args, i - 1)); if (full_copy) - gimp_value_set_int32array (&value, - params[i].data.d_int32array, - count); + gimp_value_set_int32_array (&value, + params[i].data.d_int32array, + count); else - gimp_value_set_static_int32array (&value, - params[i].data.d_int32array, - count); + gimp_value_set_static_int32_array (&value, + params[i].data.d_int32array, + count); break; case GIMP_PDB_INT16ARRAY: count = g_value_get_int (gimp_value_array_index (args, i - 1)); if (full_copy) - gimp_value_set_int16array (&value, - params[i].data.d_int16array, - count); + gimp_value_set_int16_array (&value, + params[i].data.d_int16array, + count); else - gimp_value_set_static_int16array (&value, - params[i].data.d_int16array, - count); + gimp_value_set_static_int16_array (&value, + params[i].data.d_int16array, + count); break; case GIMP_PDB_INT8ARRAY: count = g_value_get_int (gimp_value_array_index (args, i - 1)); if (full_copy) - gimp_value_set_int8array (&value, - params[i].data.d_int8array, - count); + gimp_value_set_int8_array (&value, + params[i].data.d_int8array, + count); else - gimp_value_set_static_int8array (&value, - params[i].data.d_int8array, - count); + gimp_value_set_static_int8_array (&value, + params[i].data.d_int8array, + count); break; case GIMP_PDB_FLOATARRAY: count = g_value_get_int (gimp_value_array_index (args, i - 1)); if (full_copy) - gimp_value_set_floatarray (&value, - params[i].data.d_floatarray, - count); + gimp_value_set_float_array (&value, + params[i].data.d_floatarray, + count); else - gimp_value_set_static_floatarray (&value, - params[i].data.d_floatarray, - count); + gimp_value_set_static_float_array (&value, + params[i].data.d_floatarray, + count); break; case GIMP_PDB_STRINGARRAY: count = g_value_get_int (gimp_value_array_index (args, i - 1)); if (full_copy) - gimp_value_set_stringarray (&value, + gimp_value_set_string_array (&value, (const gchar **) params[i].data.d_stringarray, count); else - gimp_value_set_static_stringarray (&value, - (const gchar **) params[i].data.d_stringarray, - count); + gimp_value_set_static_string_array (&value, + (const gchar **) params[i].data.d_stringarray, + count); break; case GIMP_PDB_COLOR: @@ -224,11 +224,11 @@ plug_in_params_to_args (GParamSpec **pspecs, case GIMP_PDB_COLORARRAY: count = g_value_get_int (gimp_value_array_index (args, i - 1)); if (full_copy) - gimp_value_set_colorarray (&value, + gimp_value_set_rgb_array (&value, params[i].data.d_colorarray, count); else - gimp_value_set_static_colorarray (&value, + gimp_value_set_static_rgb_array (&value, params[i].data.d_colorarray, count); break; @@ -320,37 +320,37 @@ plug_in_args_to_params (GimpValueArray *args, case GIMP_PDB_INT32ARRAY: if (full_copy) - params[i].data.d_int32array = gimp_value_dup_int32array (value); + params[i].data.d_int32array = gimp_value_dup_int32_array (value); else - params[i].data.d_int32array = (gint32 *) gimp_value_get_int32array (value); + params[i].data.d_int32array = (gint32 *) gimp_value_get_int32_array (value); break; case GIMP_PDB_INT16ARRAY: if (full_copy) - params[i].data.d_int16array = gimp_value_dup_int16array (value); + params[i].data.d_int16array = gimp_value_dup_int16_array (value); else - params[i].data.d_int16array = (gint16 *) gimp_value_get_int16array (value); + params[i].data.d_int16array = (gint16 *) gimp_value_get_int16_array (value); break; case GIMP_PDB_INT8ARRAY: if (full_copy) - params[i].data.d_int8array = gimp_value_dup_int8array (value); + params[i].data.d_int8array = gimp_value_dup_int8_array (value); else - params[i].data.d_int8array = (guint8 *) gimp_value_get_int8array (value); + params[i].data.d_int8array = (guint8 *) gimp_value_get_int8_array (value); break; case GIMP_PDB_FLOATARRAY: if (full_copy) - params[i].data.d_floatarray = gimp_value_dup_floatarray (value); + params[i].data.d_floatarray = gimp_value_dup_float_array (value); else - params[i].data.d_floatarray = (gdouble *) gimp_value_get_floatarray (value); + params[i].data.d_floatarray = (gdouble *) gimp_value_get_float_array (value); break; case GIMP_PDB_STRINGARRAY: if (full_copy) - params[i].data.d_stringarray = gimp_value_dup_stringarray (value); + params[i].data.d_stringarray = gimp_value_dup_string_array (value); else - params[i].data.d_stringarray = (gchar **) gimp_value_get_stringarray (value); + params[i].data.d_stringarray = (gchar **) gimp_value_get_string_array (value); break; case GIMP_PDB_COLOR: @@ -387,9 +387,9 @@ plug_in_args_to_params (GimpValueArray *args, case GIMP_PDB_COLORARRAY: if (full_copy) - params[i].data.d_colorarray = gimp_value_dup_colorarray (value); + params[i].data.d_colorarray = gimp_value_dup_rgb_array (value); else - params[i].data.d_colorarray = (GimpRGB *) gimp_value_get_colorarray (value); + params[i].data.d_colorarray = (GimpRGB *) gimp_value_get_rgb_array (value); break; case GIMP_PDB_VECTORS: diff --git a/app/widgets/gimphelp.c b/app/widgets/gimphelp.c index ee07178874..4d96201528 100644 --- a/app/widgets/gimphelp.c +++ b/app/widgets/gimphelp.c @@ -384,16 +384,16 @@ gimp_help_browser (Gimp *gimp, args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 5); - g_value_set_int (gimp_value_array_index (args, 0), - GIMP_RUN_INTERACTIVE); - g_value_set_int (gimp_value_array_index (args, 1), - n_domains); - gimp_value_take_stringarray (gimp_value_array_index (args, 2), - help_domains, n_domains); - g_value_set_int (gimp_value_array_index (args, 3), - n_domains); - gimp_value_take_stringarray (gimp_value_array_index (args, 4), - help_uris, n_domains); + g_value_set_int (gimp_value_array_index (args, 0), + GIMP_RUN_INTERACTIVE); + g_value_set_int (gimp_value_array_index (args, 1), + n_domains); + gimp_value_take_string_array (gimp_value_array_index (args, 2), + help_domains, n_domains); + g_value_set_int (gimp_value_array_index (args, 3), + n_domains); + gimp_value_take_string_array (gimp_value_array_index (args, 4), + help_uris, n_domains); gimp_procedure_execute_async (procedure, gimp, gimp_get_user_context (gimp), @@ -541,14 +541,14 @@ gimp_help_call (Gimp *gimp, args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 4); - g_value_set_int (gimp_value_array_index (args, 0), - n_domains); - gimp_value_take_stringarray (gimp_value_array_index (args, 1), - help_domains, n_domains); - g_value_set_int (gimp_value_array_index (args, 2), - n_domains); - gimp_value_take_stringarray (gimp_value_array_index (args, 3), - help_uris, n_domains); + g_value_set_int (gimp_value_array_index (args, 0), + n_domains); + gimp_value_take_string_array (gimp_value_array_index (args, 1), + help_domains, n_domains); + g_value_set_int (gimp_value_array_index (args, 2), + n_domains); + gimp_value_take_string_array (gimp_value_array_index (args, 3), + help_uris, n_domains); gimp_procedure_execute_async (procedure, gimp, gimp_get_user_context (gimp), progress, diff --git a/pdb/app.pl b/pdb/app.pl index 83d00e344b..7b650fcc7e 100644 --- a/pdb/app.pl +++ b/pdb/app.pl @@ -552,10 +552,10 @@ CODE } elsif ($pdbtype eq 'colorarray') { $pspec = < 'const gint32 *', array => 1, init_value => 'NULL', - get_value_func => '$var = gimp_value_get_int32array ($value)', - set_value_func => 'gimp_value_take_int32array ($value, $var, $var_len)' }, + get_value_func => '$var = gimp_value_get_int32_array ($value)', + set_value_func => 'gimp_value_take_int32_array ($value, $var, $var_len)' }, int16array => { name => 'INT16ARRAY', type => 'gint16 *', const_type => 'const gint16 *', array => 1, init_value => 'NULL', - get_value_func => '$var = gimp_value_get_int16array ($value)', - set_value_func => 'gimp_value_take_int16array ($value, $var, $var_len)' }, + get_value_func => '$var = gimp_value_get_int16_array ($value)', + set_value_func => 'gimp_value_take_int16_array ($value, $var, $var_len)' }, int8array => { name => 'INT8ARRAY', type => 'guint8 *', const_type => 'const guint8 *', array => 1, init_value => 'NULL', - get_value_func => '$var = gimp_value_get_int8array ($value)', - set_value_func => 'gimp_value_take_int8array ($value, $var, $var_len)' }, + get_value_func => '$var = gimp_value_get_int8_array ($value)', + set_value_func => 'gimp_value_take_int8_array ($value, $var, $var_len)' }, floatarray => { name => 'FLOATARRAY', type => 'gdouble *', const_type => 'const gdouble *', array => 1, init_value => 'NULL', - get_value_func => '$var = gimp_value_get_floatarray ($value)', - set_value_func => 'gimp_value_take_floatarray ($value, $var, $var_len)' }, + get_value_func => '$var = gimp_value_get_float_array ($value)', + set_value_func => 'gimp_value_take_float_array ($value, $var, $var_len)' }, stringarray => { name => 'STRINGARRAY', type => 'gchar **', const_type => 'const gchar **', array => 1, init_value => 'NULL', - get_value_func => '$var = gimp_value_get_stringarray ($value)', - set_value_func => 'gimp_value_take_stringarray ($value, $var, $var_len)' }, + get_value_func => '$var = gimp_value_get_string_array ($value)', + set_value_func => 'gimp_value_take_string_array ($value, $var, $var_len)' }, colorarray => { name => 'COLORARRAY', type => 'GimpRGB *', const_type => 'const GimpRGB *', array => 1, init_value => 'NULL', - get_value_func => '$var = gimp_value_get_colorarray ($value)', - set_value_func => 'gimp_value_take_colorarray ($value, $var, $var_len)' }, + get_value_func => '$var = gimp_value_get_rgb_array ($value)', + set_value_func => 'gimp_value_take_rgb_array ($value, $var, $var_len)' }, color => { name => 'COLOR' , type => 'GimpRGB ',