eUgEntOptIc44/gimp
1
1
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-10-06 01:12:40 +02:00
Code Issues Releases Activity

app, libgimp*, pdb, plug-ins: rename various public API name s/float/double/.

Browse Source 
Several types functions were using the wording "float" historically to
mean double-precision, e.g. the float array type (which was in fact a
double array). Or the scanner function gimp_scanner_parse_float() was in
fact returning a double value. What if we wanted someday to actually add
float (usually this naming means in C the single-precision IEEE 754
floating point representation) support? How would we name this?

Now technically it's not entirely wrong (a double is still a floating
point). So I've been wondering if that is because maybe we never planned
to have float and double precision may be good enough for all usage in a
plug-in API (which doesn't have to be as generic so the higher precision
is enough)? But how can we be sure? Also we already had some functions
using the wording double (e.g. gimp_procedure_add_double_argument()), so
let's just go the safe route and use the accurate wording.

The additional change in PDB is internal, but there too, I was also
finding very confusing that we were naming double-precision float as
'float' type. So I took the opportunity to update this. It doesn't
change any signature.

In fact the whole commit doesn't change any type or code logic, only
naming, except for one bug fix in the middle which I encountered while
renaming: in gimp_scanner_parse_deprecated_color(), I discovered a
hidden bug in scanning (color-hsv*) values, which was mistakenly using a
double type for an array of float.
This commit is contained in:
Jehan
2024-11-02 14:03:37 +01:00
parent cec189bd40
commit dc3e815ff0
65 changed files with 892 additions and 894 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/core/gimp-memsize.c
View File

@@ -217,7 +217,7 @@ gimp_g_value_get_memsize (GValue *value)
} }
else if (GIMP_VALUE_HOLDS_ARRAY (value) || else if (GIMP_VALUE_HOLDS_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT32_ARRAY (value) || GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)) GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{ {
GimpArray *array = g_value_get_boxed (value); GimpArray *array = g_value_get_boxed (value);

2
app/core/gimp-units.c
View File

@@ -307,7 +307,7 @@ gimp_unitrc_unit_info_deserialize (GScanner *scanner,
{ {
case UNIT_FACTOR: case UNIT_FACTOR:
token = G_TOKEN_FLOAT; token = G_TOKEN_FLOAT;
if (! gimp_scanner_parse_float (scanner, &factor)) if (! gimp_scanner_parse_double (scanner, &factor))
goto cleanup; goto cleanup;
break; break;

4
app/pdb/brush-cmds.c
View File

@@ -1249,7 +1249,7 @@ register_brush_procs (GimpPDB *pdb)
"gimp-brush-get-hardness"); "gimp-brush-get-hardness");
gimp_procedure_set_static_help (procedure, gimp_procedure_set_static_help (procedure,
"Gets the hardness of a generated brush.", "Gets the hardness of a generated brush.",
"Gets the hardness of a generated brush. The hardness of a brush is the amount its intensity fades at the outside edge, as a float between 0.0 and 1.0. Returns an error when called for a non-parametric brush.", "Gets the hardness of a generated brush. The hardness of a brush is the amount its intensity fades at the outside edge, as a double between 0.0 and 1.0. Returns an error when called for a non-parametric brush.",
NULL); NULL);
gimp_procedure_set_static_attribution (procedure, gimp_procedure_set_static_attribution (procedure,
"Bill Skaggs <weskaggs@primate.ucdavis.edu>", "Bill Skaggs <weskaggs@primate.ucdavis.edu>",
@@ -1317,7 +1317,7 @@ register_brush_procs (GimpPDB *pdb)
"gimp-brush-get-aspect-ratio"); "gimp-brush-get-aspect-ratio");
gimp_procedure_set_static_help (procedure, gimp_procedure_set_static_help (procedure,
"Gets the aspect ratio of a generated brush.", "Gets the aspect ratio of a generated brush.",
"Gets the aspect ratio of a generated brush. Returns an error when called for a non-parametric brush. The aspect ratio is a float between 0.0 and 1000.0.", "Gets the aspect ratio of a generated brush. Returns an error when called for a non-parametric brush. The aspect ratio is a double between 0.0 and 1000.0.",
NULL); NULL);
gimp_procedure_set_static_attribution (procedure, gimp_procedure_set_static_attribution (procedure,
"Bill Skaggs <weskaggs@primate.ucdavis.edu>", "Bill Skaggs <weskaggs@primate.ucdavis.edu>",

20
app/pdb/context-cmds.c
View File

@@ -764,7 +764,7 @@ context_get_line_dash_pattern_invoker (GimpProcedure *procedure,
dashes = gimp_dash_pattern_to_double_array (pattern, &num_dashes); dashes = gimp_dash_pattern_to_double_array (pattern, &num_dashes);
return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL); return_vals = gimp_procedure_get_return_values (procedure, TRUE, NULL);
gimp_value_take_float_array (gimp_value_array_index (return_vals, 1), dashes, num_dashes); gimp_value_take_double_array (gimp_value_array_index (return_vals, 1), dashes, num_dashes);
return return_vals; return return_vals;
} }
@@ -781,7 +781,7 @@ context_set_line_dash_pattern_invoker (GimpProcedure *procedure,
gsize num_dashes; gsize num_dashes;
const gdouble *dashes; const gdouble *dashes;
dashes = gimp_value_get_float_array (gimp_value_array_index (args, 0), &num_dashes); dashes = gimp_value_get_double_array (gimp_value_array_index (args, 0), &num_dashes);
if (success) if (success)
{ {
@@ -3827,10 +3827,10 @@ register_context_procs (GimpPDB *pdb)
"Michael Natterer", "Michael Natterer",
"2015"); "2015");
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("dashes", gimp_param_spec_double_array ("dashes",
"dashes", "dashes",
"The line dash pattern setting", "The line dash pattern setting",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -3853,10 +3853,10 @@ register_context_procs (GimpPDB *pdb)
"Michael Natterer", "Michael Natterer",
"2015"); "2015");
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("dashes", gimp_param_spec_double_array ("dashes",
"dashes", "dashes",
"The line dash pattern setting", "The line dash pattern setting",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);

20
app/pdb/drawable-color-cmds.c
View File

@@ -212,7 +212,7 @@ drawable_curves_explicit_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
channel = g_value_get_enum (gimp_value_array_index (args, 1)); channel = g_value_get_enum (gimp_value_array_index (args, 1));
values = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_values); values = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_values);
if (success) if (success)
{ {
@@ -260,7 +260,7 @@ drawable_curves_spline_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
channel = g_value_get_enum (gimp_value_array_index (args, 1)); channel = g_value_get_enum (gimp_value_array_index (args, 1));
points = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_points); points = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_points);
if (success) if (success)
{ {
@@ -993,10 +993,10 @@ register_drawable_color_procs (GimpPDB *pdb)
GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_VALUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("values", gimp_param_spec_double_array ("values",
"values", "values",
"The explicit curve", "The explicit curve",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1028,10 +1028,10 @@ register_drawable_color_procs (GimpPDB *pdb)
GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_VALUE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("points", gimp_param_spec_double_array ("points",
"points", "points",
"The spline control points: { cp1.x, cp1.y, cp2.x, cp2.y, ... }", "The spline control points: { cp1.x, cp1.y, cp2.x, cp2.y, ... }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);

2
app/pdb/gimppdb.c
View File

@@ -444,7 +444,7 @@ gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
} }
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) || if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) || GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value) ||
GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value)) GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value))
{ {
g_value_set_boxed (value, va_arg (va_args, gpointer)); g_value_set_boxed (value, va_arg (va_args, gpointer));

31
app/pdb/gradient-cmds.c
View File

@@ -188,7 +188,6 @@ gradient_get_uniform_samples_invoker (GimpProcedure *procedure,
pos, reverse, pos, reverse,
GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
&color); &color);
/* XXX "float" in PDB are in fact double. */
if (color) if (color)
gegl_color_get_pixel (color, babl_format ("R'G'B'A double"), sample); gegl_color_get_pixel (color, babl_format ("R'G'B'A double"), sample);
/* TODO: should we really return a list of floats? What about a list /* TODO: should we really return a list of floats? What about a list
@@ -209,7 +208,7 @@ gradient_get_uniform_samples_invoker (GimpProcedure *procedure,
error ? *error : NULL); error ? *error : NULL);
if (success) if (success)
gimp_value_take_float_array (gimp_value_array_index (return_vals, 1), color_samples, num_color_samples); gimp_value_take_double_array (gimp_value_array_index (return_vals, 1), color_samples, num_color_samples);
return return_vals; return return_vals;
} }
@@ -232,7 +231,7 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure,
gdouble *color_samples = NULL; gdouble *color_samples = NULL;
gradient = g_value_get_object (gimp_value_array_index (args, 0)); gradient = g_value_get_object (gimp_value_array_index (args, 0));
positions = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_samples); positions = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_samples);
reverse = g_value_get_boolean (gimp_value_array_index (args, 2)); reverse = g_value_get_boolean (gimp_value_array_index (args, 2));
if (success) if (success)
@@ -273,7 +272,7 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure,
error ? *error : NULL); error ? *error : NULL);
if (success) if (success)
gimp_value_take_float_array (gimp_value_array_index (return_vals, 1), color_samples, num_color_samples); gimp_value_take_double_array (gimp_value_array_index (return_vals, 1), color_samples, num_color_samples);
return return_vals; return return_vals;
} }
@@ -1381,10 +1380,10 @@ register_gradient_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples", gimp_param_spec_double_array ("color-samples",
"color samples", "color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }", "Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1411,10 +1410,10 @@ register_gradient_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("positions", gimp_param_spec_double_array ("positions",
"positions", "positions",
"The list of positions to sample along the gradient", "The list of positions to sample along the gradient",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("reverse", g_param_spec_boolean ("reverse",
"reverse", "reverse",
@@ -1422,10 +1421,10 @@ register_gradient_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples", gimp_param_spec_double_array ("color-samples",
"color samples", "color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }", "Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);

10
app/pdb/image-select-cmds.c
View File

@@ -295,7 +295,7 @@ image_select_polygon_invoker (GimpProcedure *procedure,
image = g_value_get_object (gimp_value_array_index (args, 0)); image = g_value_get_object (gimp_value_array_index (args, 0));
operation = g_value_get_enum (gimp_value_array_index (args, 1)); operation = g_value_get_enum (gimp_value_array_index (args, 1));
segs = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_segs); segs = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_segs);
if (success) if (success)
{ {
@@ -668,10 +668,10 @@ register_image_select_procs (GimpPDB *pdb)
GIMP_CHANNEL_OP_ADD, GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("segs", gimp_param_spec_double_array ("segs",
"segs", "segs",
"Array of points: { p1.x, p1.y, p2.x, p2.y, ..., pn.x, pn.y}", "Array of points: { p1.x, p1.y, p2.x, p2.y, ..., pn.x, pn.y}",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);

170
app/pdb/paint-tools-cmds.c
View File

@@ -118,7 +118,7 @@ airbrush_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
pressure = g_value_get_double (gimp_value_array_index (args, 1)); pressure = g_value_get_double (gimp_value_array_index (args, 1));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_strokes);
if (success) if (success)
{ {
@@ -164,7 +164,7 @@ airbrush_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -214,7 +214,7 @@ clone_invoker (GimpProcedure *procedure,
clone_type = g_value_get_enum (gimp_value_array_index (args, 2)); clone_type = g_value_get_enum (gimp_value_array_index (args, 2));
src_x = g_value_get_double (gimp_value_array_index (args, 3)); src_x = g_value_get_double (gimp_value_array_index (args, 3));
src_y = g_value_get_double (gimp_value_array_index (args, 4)); src_y = g_value_get_double (gimp_value_array_index (args, 4));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 5), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 5), &num_strokes);
if (success) if (success)
{ {
@@ -267,7 +267,7 @@ clone_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -313,7 +313,7 @@ convolve_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
pressure = g_value_get_double (gimp_value_array_index (args, 1)); pressure = g_value_get_double (gimp_value_array_index (args, 1));
convolve_type = g_value_get_enum (gimp_value_array_index (args, 2)); convolve_type = g_value_get_enum (gimp_value_array_index (args, 2));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 3), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 3), &num_strokes);
if (success) if (success)
{ {
@@ -360,7 +360,7 @@ convolve_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -408,7 +408,7 @@ dodgeburn_invoker (GimpProcedure *procedure,
exposure = g_value_get_double (gimp_value_array_index (args, 1)); exposure = g_value_get_double (gimp_value_array_index (args, 1));
dodgeburn_type = g_value_get_enum (gimp_value_array_index (args, 2)); dodgeburn_type = g_value_get_enum (gimp_value_array_index (args, 2));
dodgeburn_mode = g_value_get_enum (gimp_value_array_index (args, 3)); dodgeburn_mode = g_value_get_enum (gimp_value_array_index (args, 3));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 4), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 4), &num_strokes);
if (success) if (success)
{ {
@@ -456,7 +456,7 @@ dodgeburn_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -500,7 +500,7 @@ eraser_invoker (GimpProcedure *procedure,
gint method; gint method;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
hardness = g_value_get_enum (gimp_value_array_index (args, 2)); hardness = g_value_get_enum (gimp_value_array_index (args, 2));
method = g_value_get_enum (gimp_value_array_index (args, 3)); method = g_value_get_enum (gimp_value_array_index (args, 3));
@@ -549,7 +549,7 @@ eraser_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -597,7 +597,7 @@ heal_invoker (GimpProcedure *procedure,
src_drawable = g_value_get_object (gimp_value_array_index (args, 1)); src_drawable = g_value_get_object (gimp_value_array_index (args, 1));
src_x = g_value_get_double (gimp_value_array_index (args, 2)); src_x = g_value_get_double (gimp_value_array_index (args, 2));
src_y = g_value_get_double (gimp_value_array_index (args, 3)); src_y = g_value_get_double (gimp_value_array_index (args, 3));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 4), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 4), &num_strokes);
if (success) if (success)
{ {
@@ -649,7 +649,7 @@ heal_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -695,7 +695,7 @@ paintbrush_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
fade_out = g_value_get_double (gimp_value_array_index (args, 1)); fade_out = g_value_get_double (gimp_value_array_index (args, 1));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_strokes);
method = g_value_get_enum (gimp_value_array_index (args, 3)); method = g_value_get_enum (gimp_value_array_index (args, 3));
gradient_length = g_value_get_double (gimp_value_array_index (args, 4)); gradient_length = g_value_get_double (gimp_value_array_index (args, 4));
@@ -775,7 +775,7 @@ paintbrush_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -817,7 +817,7 @@ pencil_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -861,7 +861,7 @@ smudge_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
pressure = g_value_get_double (gimp_value_array_index (args, 1)); pressure = g_value_get_double (gimp_value_array_index (args, 1));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_strokes);
if (success) if (success)
{ {
@@ -907,7 +907,7 @@ smudge_default_invoker (GimpProcedure *procedure,
const gdouble *strokes; const gdouble *strokes;
drawable = g_value_get_object (gimp_value_array_index (args, 0)); drawable = g_value_get_object (gimp_value_array_index (args, 0));
strokes = gimp_value_get_float_array (gimp_value_array_index (args, 1), &num_strokes); strokes = gimp_value_get_double_array (gimp_value_array_index (args, 1), &num_strokes);
if (success) if (success)
{ {
@@ -967,10 +967,10 @@ register_paint_tools_procs (GimpPDB *pdb)
0, 100, 0, 0, 100, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -995,10 +995,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1048,10 +1048,10 @@ register_paint_tools_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1076,10 +1076,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1117,10 +1117,10 @@ register_paint_tools_procs (GimpPDB *pdb)
GIMP_CONVOLVE_BLUR, GIMP_CONVOLVE_BLUR,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1145,10 +1145,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1193,10 +1193,10 @@ register_paint_tools_procs (GimpPDB *pdb)
GIMP_TRANSFER_SHADOWS, GIMP_TRANSFER_SHADOWS,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1221,10 +1221,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1249,10 +1249,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("hardness", g_param_spec_enum ("hardness",
"hardness", "hardness",
@@ -1291,10 +1291,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1337,10 +1337,10 @@ register_paint_tools_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1365,10 +1365,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1399,10 +1399,10 @@ register_paint_tools_procs (GimpPDB *pdb)
0, G_MAXDOUBLE, 0, 0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_enum ("method", g_param_spec_enum ("method",
"method", "method",
@@ -1440,10 +1440,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1468,10 +1468,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1502,10 +1502,10 @@ register_paint_tools_procs (GimpPDB *pdb)
0, 100, 0, 0, 100, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
@@ -1530,10 +1530,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes", gimp_param_spec_double_array ("strokes",
"strokes", "strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }", "Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure); gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure); g_object_unref (procedure);
} }

32
app/pdb/path-cmds.c
View File

@@ -704,7 +704,7 @@ path_stroke_get_points_invoker (GimpProcedure *procedure,
if (success) if (success)
{ {
g_value_set_enum (gimp_value_array_index (return_vals, 1), type); g_value_set_enum (gimp_value_array_index (return_vals, 1), type);
gimp_value_take_float_array (gimp_value_array_index (return_vals, 2), controlpoints, num_points); gimp_value_take_double_array (gimp_value_array_index (return_vals, 2), controlpoints, num_points);
g_value_set_boolean (gimp_value_array_index (return_vals, 3), closed); g_value_set_boolean (gimp_value_array_index (return_vals, 3), closed);
} }
@@ -730,7 +730,7 @@ path_stroke_new_from_points_invoker (GimpProcedure *procedure,
path = g_value_get_object (gimp_value_array_index (args, 0)); path = g_value_get_object (gimp_value_array_index (args, 0));
type = g_value_get_enum (gimp_value_array_index (args, 1)); type = g_value_get_enum (gimp_value_array_index (args, 1));
controlpoints = gimp_value_get_float_array (gimp_value_array_index (args, 2), &num_points); controlpoints = gimp_value_get_double_array (gimp_value_array_index (args, 2), &num_points);
closed = g_value_get_boolean (gimp_value_array_index (args, 3)); closed = g_value_get_boolean (gimp_value_array_index (args, 3));
if (success) if (success)
@@ -839,7 +839,7 @@ path_stroke_interpolate_invoker (GimpProcedure *procedure,
if (success) if (success)
{ {
gimp_value_take_float_array (gimp_value_array_index (return_vals, 1), coords, num_coords); gimp_value_take_double_array (gimp_value_array_index (return_vals, 1), coords, num_coords);
g_value_set_boolean (gimp_value_array_index (return_vals, 2), closed); g_value_set_boolean (gimp_value_array_index (return_vals, 2), closed);
} }
@@ -1718,10 +1718,10 @@ register_path_procs (GimpPDB *pdb)
GIMP_PATH_STROKE_TYPE_BEZIER, GIMP_PATH_STROKE_TYPE_BEZIER,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("controlpoints", gimp_param_spec_double_array ("controlpoints",
"controlpoints", "controlpoints",
"List of the control points for the stroke (x0, y0, x1, y1, ...).", "List of the control points for the stroke (x0, y0, x1, y1, ...).",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("closed", g_param_spec_boolean ("closed",
"closed", "closed",
@@ -1739,7 +1739,7 @@ register_path_procs (GimpPDB *pdb)
"gimp-path-stroke-new-from-points"); "gimp-path-stroke-new-from-points");
gimp_procedure_set_static_help (procedure, gimp_procedure_set_static_help (procedure,
"Adds a stroke of a given type to the path object.", "Adds a stroke of a given type to the path object.",
"Adds a stroke of a given type to the path object. The coordinates of the control points can be specified. For now only strokes of the type GIMP_PATH_STROKE_TYPE_BEZIER are supported. The control points are specified as a pair of float values for the x- and y-coordinate. The Bezier stroke type needs a multiple of three control points. Each Bezier segment endpoint (anchor, A) has two additional control points (C) associated. They are specified in the order CACCACCAC...", "Adds a stroke of a given type to the path object. The coordinates of the control points can be specified. For now only strokes of the type GIMP_PATH_STROKE_TYPE_BEZIER are supported. The control points are specified as a pair of double values for the x- and y-coordinate. The Bezier stroke type needs a multiple of three control points. Each Bezier segment endpoint (anchor, A) has two additional control points (C) associated. They are specified in the order CACCACCAC...",
NULL); NULL);
gimp_procedure_set_static_attribution (procedure, gimp_procedure_set_static_attribution (procedure,
"Simon Budig", "Simon Budig",
@@ -1759,10 +1759,10 @@ register_path_procs (GimpPDB *pdb)
GIMP_PATH_STROKE_TYPE_BEZIER, GIMP_PATH_STROKE_TYPE_BEZIER,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("controlpoints", gimp_param_spec_double_array ("controlpoints",
"controlpoints", "controlpoints",
"List of the x- and y-coordinates of the control points.", "List of the x- and y-coordinates of the control points.",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("closed", g_param_spec_boolean ("closed",
"closed", "closed",
@@ -1811,10 +1811,10 @@ register_path_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0, -G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("coords", gimp_param_spec_double_array ("coords",
"coords", "coords",
"List of the coords along the path (x0, y0, x1, y1, ...).", "List of the coords along the path (x0, y0, x1, y1, ...).",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure, gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("closed", g_param_spec_boolean ("closed",
"closed", "closed",

10
app/pdb/plug-in-compat-cmds.c
View File

@@ -1138,7 +1138,7 @@ plug_in_convmatrix_invoker (GimpProcedure *procedure,
gint bmode; gint bmode;
drawable = g_value_get_object (gimp_value_array_index (args, 2)); drawable = g_value_get_object (gimp_value_array_index (args, 2));
matrix = gimp_value_get_float_array (gimp_value_array_index (args, 3), &argc_matrix); matrix = gimp_value_get_double_array (gimp_value_array_index (args, 3), &argc_matrix);
alpha_alg = g_value_get_boolean (gimp_value_array_index (args, 4)); alpha_alg = g_value_get_boolean (gimp_value_array_index (args, 4));
divisor = g_value_get_double (gimp_value_array_index (args, 5)); divisor = g_value_get_double (gimp_value_array_index (args, 5));
offset = g_value_get_double (gimp_value_array_index (args, 6)); offset = g_value_get_double (gimp_value_array_index (args, 6));
@@ -5518,10 +5518,10 @@ register_plug_in_compat_procs (GimpPDB *pdb)
FALSE, FALSE,
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("matrix", gimp_param_spec_double_array ("matrix",
"matrix", "matrix",
"The 5x5 convolution matrix", "The 5x5 convolution matrix",
GIMP_PARAM_READWRITE)); GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure, gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("alpha-alg", g_param_spec_boolean ("alpha-alg",
"alpha alg", "alpha alg",

2
app/pdb/text-layer-cmds.c
View File

@@ -1245,7 +1245,7 @@ register_text_layer_procs (GimpPDB *pdb)
"gimp-text-layer-get-font-size"); "gimp-text-layer-get-font-size");
gimp_procedure_set_static_help (procedure, gimp_procedure_set_static_help (procedure,
"Get the font size from a text layer.", "Get the font size from a text layer.",
"This procedure returns the size of the font which is used in a text layer. You will receive the size as a float 'font-size' in 'unit' units.", "This procedure returns the size of the font which is used in a text layer. You will receive the size as a double 'font-size' in 'unit' units.",
NULL); NULL);
gimp_procedure_set_static_attribution (procedure, gimp_procedure_set_static_attribution (procedure,
"Marcus Heese <heese@cip.ifi.lmu.de>", "Marcus Heese <heese@cip.ifi.lmu.de>",

24
app/plug-in/plug-in-rc.c
View File

@@ -892,13 +892,13 @@ plug_in_proc_arg_deserialize (GScanner *scanner,
} }
break; break;
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
if (! gimp_scanner_parse_float (scanner, if (! gimp_scanner_parse_double (scanner,
&param_def.meta.m_float.min_val) || &param_def.meta.m_double.min_val) ||
! gimp_scanner_parse_float (scanner, ! gimp_scanner_parse_double (scanner,
&param_def.meta.m_float.max_val) || &param_def.meta.m_double.max_val) ||
! gimp_scanner_parse_float (scanner, ! gimp_scanner_parse_double (scanner,
&param_def.meta.m_float.default_val)) &param_def.meta.m_double.default_val))
{ {
token = G_TOKEN_FLOAT; token = G_TOKEN_FLOAT;
goto error; goto error;
@@ -1049,7 +1049,7 @@ plug_in_proc_arg_deserialize (GScanner *scanner,
break; break;
case GP_PARAM_DEF_TYPE_BOOLEAN: case GP_PARAM_DEF_TYPE_BOOLEAN:
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
break; break;
case GP_PARAM_DEF_TYPE_STRING: case GP_PARAM_DEF_TYPE_STRING:
@@ -1203,13 +1203,13 @@ plug_in_rc_write_proc_arg (GimpConfigWriter *writer,
param_def.meta.m_boolean.default_val); param_def.meta.m_boolean.default_val);
break; break;
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
g_ascii_dtostr (buf[0], sizeof (buf[0]), g_ascii_dtostr (buf[0], sizeof (buf[0]),
param_def.meta.m_float.min_val); param_def.meta.m_double.min_val);
g_ascii_dtostr (buf[1], sizeof (buf[1]), g_ascii_dtostr (buf[1], sizeof (buf[1]),
param_def.meta.m_float.max_val), param_def.meta.m_double.max_val),
g_ascii_dtostr (buf[2], sizeof (buf[2]), g_ascii_dtostr (buf[2], sizeof (buf[2]),
param_def.meta.m_float.default_val); param_def.meta.m_double.default_val);
gimp_config_writer_printf (writer, "%s %s %s", gimp_config_writer_printf (writer, "%s %s %s",
buf[0], buf[1], buf[2]); buf[0], buf[1], buf[2]);
break; break;

6
app/widgets/gimpgradientselect.c
View File

@@ -184,9 +184,9 @@ gimp_gradient_select_run_callback (GimpPdbDialog *dialog,
dialog->caller_context, dialog->caller_context,
NULL, error, NULL, error,
dialog->callback_name, dialog->callback_name,
GIMP_TYPE_RESOURCE, object, GIMP_TYPE_RESOURCE, object,
GIMP_TYPE_FLOAT_ARRAY, array, GIMP_TYPE_DOUBLE_ARRAY, array,
G_TYPE_BOOLEAN, closing, G_TYPE_BOOLEAN, closing,
G_TYPE_NONE); G_TYPE_NONE);
gimp_array_free (array); gimp_array_free (array);

2
libgimp/gimp.c
View File

@@ -431,7 +431,7 @@ gimp_main (GType plug_in_type,
GIMP_TYPE_ARRAY, GIMP_TYPE_PARAM_ARRAY, GIMP_TYPE_ARRAY, GIMP_TYPE_PARAM_ARRAY,
GIMP_TYPE_INT32_ARRAY, GIMP_TYPE_PARAM_INT32_ARRAY, GIMP_TYPE_INT32_ARRAY, GIMP_TYPE_PARAM_INT32_ARRAY,
GIMP_TYPE_FLOAT_ARRAY, GIMP_TYPE_PARAM_FLOAT_ARRAY, GIMP_TYPE_DOUBLE_ARRAY, GIMP_TYPE_PARAM_DOUBLE_ARRAY,
GIMP_TYPE_CORE_OBJECT_ARRAY, GIMP_TYPE_PARAM_CORE_OBJECT_ARRAY, GIMP_TYPE_CORE_OBJECT_ARRAY, GIMP_TYPE_PARAM_CORE_OBJECT_ARRAY,
GIMP_TYPE_DISPLAY, GIMP_TYPE_PARAM_DISPLAY, GIMP_TYPE_DISPLAY, GIMP_TYPE_PARAM_DISPLAY,

6
libgimp/gimp.def
View File

@@ -798,6 +798,9 @@ EXPORTS
gimp_procedure_add_display_aux_argument gimp_procedure_add_display_aux_argument
gimp_procedure_add_display_return_value gimp_procedure_add_display_return_value
gimp_procedure_add_double_argument gimp_procedure_add_double_argument
gimp_procedure_add_double_array_argument
gimp_procedure_add_double_array_aux_argument
gimp_procedure_add_double_array_return_value
gimp_procedure_add_double_aux_argument gimp_procedure_add_double_aux_argument
gimp_procedure_add_double_return_value gimp_procedure_add_double_return_value
gimp_procedure_add_drawable_argument gimp_procedure_add_drawable_argument
@@ -809,9 +812,6 @@ EXPORTS
gimp_procedure_add_file_argument gimp_procedure_add_file_argument
gimp_procedure_add_file_aux_argument gimp_procedure_add_file_aux_argument
gimp_procedure_add_file_return_value gimp_procedure_add_file_return_value
gimp_procedure_add_float_array_argument
gimp_procedure_add_float_array_aux_argument
gimp_procedure_add_float_array_return_value
gimp_procedure_add_font_argument gimp_procedure_add_font_argument
gimp_procedure_add_font_aux_argument gimp_procedure_add_font_aux_argument
gimp_procedure_add_font_return_value gimp_procedure_add_font_return_value

4
libgimp/gimpbrush_pdb.c
View File

@@ -631,7 +631,7 @@ gimp_brush_set_spikes (GimpBrush *brush,
* Gets the hardness of a generated brush. * Gets the hardness of a generated brush.
* *
* Gets the hardness of a generated brush. The hardness of a brush is * Gets the hardness of a generated brush. The hardness of a brush is
* the amount its intensity fades at the outside edge, as a float * the amount its intensity fades at the outside edge, as a double
* between 0.0 and 1.0. Returns an error when called for a * between 0.0 and 1.0. Returns an error when called for a
* non-parametric brush. * non-parametric brush.
* *
@@ -723,7 +723,7 @@ gimp_brush_set_hardness (GimpBrush *brush,
* Gets the aspect ratio of a generated brush. * Gets the aspect ratio of a generated brush.
* *
* Gets the aspect ratio of a generated brush. Returns an error when * Gets the aspect ratio of a generated brush. Returns an error when
* called for a non-parametric brush. The aspect ratio is a float * called for a non-parametric brush. The aspect ratio is a double
* between 0.0 and 1000.0. * between 0.0 and 1000.0.
* *
* Returns: TRUE on success. * Returns: TRUE on success.

6
libgimp/gimpcontext_pdb.c
View File

@@ -1159,7 +1159,7 @@ gimp_context_get_line_dash_pattern (gsize *num_dashes,
if (success) if (success)
{ {
*dashes = GIMP_VALUES_DUP_FLOAT_ARRAY (return_vals, 1, num_dashes); *dashes = GIMP_VALUES_DUP_DOUBLE_ARRAY (return_vals, 1, num_dashes);
} }
gimp_value_array_unref (return_vals); gimp_value_array_unref (return_vals);
@@ -1197,9 +1197,9 @@ gimp_context_set_line_dash_pattern (gsize num_dashes,
gboolean success = TRUE; gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 0), dashes, num_dashes); gimp_value_set_double_array (gimp_value_array_index (args, 0), dashes, num_dashes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-context-set-line-dash-pattern", "gimp-context-set-line-dash-pattern",

8
libgimp/gimpdrawablecolor_pdb.c
View File

@@ -220,9 +220,9 @@ gimp_drawable_curves_explicit (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_HISTOGRAM_CHANNEL, channel, GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), values, num_values); gimp_value_set_double_array (gimp_value_array_index (args, 2), values, num_values);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-curves-explicit", "gimp-drawable-curves-explicit",
@@ -273,9 +273,9 @@ gimp_drawable_curves_spline (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_HISTOGRAM_CHANNEL, channel, GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), points, num_points); gimp_value_set_double_array (gimp_value_array_index (args, 2), points, num_points);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-drawable-curves-spline", "gimp-drawable-curves-spline",

34
libgimp/gimpgpparams-body.c
View File

@@ -53,8 +53,8 @@ _gimp_gp_param_def_to_param_spec (const GPParamDef *param_def)
if (! strcmp (param_def->type_name, "GimpParamInt32Array")) if (! strcmp (param_def->type_name, "GimpParamInt32Array"))
return gimp_param_spec_int32_array (name, nick, blurb, flags); return gimp_param_spec_int32_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamFloatArray")) if (! strcmp (param_def->type_name, "GimpParamDoubleArray"))
return gimp_param_spec_float_array (name, nick, blurb, flags); return gimp_param_spec_double_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamParasite")) if (! strcmp (param_def->type_name, "GimpParamParasite"))
return gimp_param_spec_parasite (name, nick, blurb, flags); return gimp_param_spec_parasite (name, nick, blurb, flags);
@@ -151,12 +151,12 @@ _gimp_gp_param_def_to_param_spec (const GPParamDef *param_def)
flags); flags);
break; break;
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
if (! strcmp (param_def->type_name, "GParamDouble")) if (! strcmp (param_def->type_name, "GParamDouble"))
return g_param_spec_double (name, nick, blurb, return g_param_spec_double (name, nick, blurb,
param_def->meta.m_float.min_val, param_def->meta.m_double.min_val,
param_def->meta.m_float.max_val, param_def->meta.m_double.max_val,
param_def->meta.m_float.default_val, param_def->meta.m_double.default_val,
flags); flags);
break; break;
@@ -388,11 +388,11 @@ _gimp_param_spec_to_gp_param_def (GParamSpec *pspec,
{ {
GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec); GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
param_def->param_def_type = GP_PARAM_DEF_TYPE_FLOAT; param_def->param_def_type = GP_PARAM_DEF_TYPE_DOUBLE;
param_def->meta.m_float.min_val = dspec->minimum; param_def->meta.m_double.min_val = dspec->minimum;
param_def->meta.m_float.max_val = dspec->maximum; param_def->meta.m_double.max_val = dspec->maximum;
param_def->meta.m_float.default_val = dspec->default_value; param_def->meta.m_double.default_val = dspec->default_value;
} }
/* Must be before G_IS_PARAM_SPEC_STRING() because it's a parent. */ /* Must be before G_IS_PARAM_SPEC_STRING() because it's a parent. */
else if (pspec_type == GIMP_TYPE_PARAM_CHOICE) else if (pspec_type == GIMP_TYPE_PARAM_CHOICE)
@@ -732,7 +732,7 @@ gimp_gp_param_to_value (gpointer gimp,
} }
else if (G_VALUE_HOLDS_DOUBLE (value)) else if (G_VALUE_HOLDS_DOUBLE (value))
{ {
g_value_set_double (value, param->data.d_float); g_value_set_double (value, param->data.d_double);
} }
else if (G_VALUE_HOLDS_STRING (value)) else if (G_VALUE_HOLDS_STRING (value))
{ {
@@ -839,9 +839,9 @@ gimp_gp_param_to_value (gpointer gimp,
param->data.d_array.size / param->data.d_array.size /
sizeof (gint32)); sizeof (gint32));
} }
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)) else if (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{ {
gimp_value_set_float_array (value, gimp_value_set_double_array (value,
(const gdouble *) (const gdouble *)
param->data.d_array.data, param->data.d_array.data,
param->data.d_array.size / param->data.d_array.size /
@@ -1135,9 +1135,9 @@ gimp_value_to_gp_param (const GValue *value,
} }
else if (G_VALUE_HOLDS_DOUBLE (value)) else if (G_VALUE_HOLDS_DOUBLE (value))
{ {
param->param_type = GP_PARAM_TYPE_FLOAT; param->param_type = GP_PARAM_TYPE_DOUBLE;
param->data.d_float = g_value_get_double (value); param->data.d_double = g_value_get_double (value);
} }
else if (G_VALUE_HOLDS_STRING (value)) else if (G_VALUE_HOLDS_STRING (value))
{ {
@@ -1272,7 +1272,7 @@ gimp_value_to_gp_param (const GValue *value,
} }
} }
else if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) || else if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)) GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{ {
GimpArray *array = g_value_get_boxed (value); GimpArray *array = g_value_get_boxed (value);
@@ -1550,7 +1550,7 @@ _gimp_gp_params_free (GPParam *params,
switch (params[i].param_type) switch (params[i].param_type)
{ {
case GP_PARAM_TYPE_INT: case GP_PARAM_TYPE_INT:
case GP_PARAM_TYPE_FLOAT: case GP_PARAM_TYPE_DOUBLE:
break; break;
case GP_PARAM_TYPE_STRING: case GP_PARAM_TYPE_STRING:

8
libgimp/gimpgradient_pdb.c
View File

@@ -195,7 +195,7 @@ gimp_gradient_get_uniform_samples (GimpGradient *gradient,
if (success) if (success)
{ {
*color_samples = GIMP_VALUES_DUP_FLOAT_ARRAY (return_vals, 1, num_color_samples); *color_samples = GIMP_VALUES_DUP_DOUBLE_ARRAY (return_vals, 1, num_color_samples);
} }
gimp_value_array_unref (return_vals); gimp_value_array_unref (return_vals);
@@ -239,10 +239,10 @@ gimp_gradient_get_custom_samples (GimpGradient *gradient,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_GRADIENT, gradient, GIMP_TYPE_GRADIENT, gradient,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_BOOLEAN, reverse, G_TYPE_BOOLEAN, reverse,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), positions, num_samples); gimp_value_set_double_array (gimp_value_array_index (args, 1), positions, num_samples);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-gradient-get-custom-samples", "gimp-gradient-get-custom-samples",
@@ -256,7 +256,7 @@ gimp_gradient_get_custom_samples (GimpGradient *gradient,
if (success) if (success)
{ {
*color_samples = GIMP_VALUES_DUP_FLOAT_ARRAY (return_vals, 1, num_color_samples); *color_samples = GIMP_VALUES_DUP_DOUBLE_ARRAY (return_vals, 1, num_color_samples);
} }
gimp_value_array_unref (return_vals); gimp_value_array_unref (return_vals);

4
libgimp/gimpimageselect_pdb.c
View File

@@ -384,9 +384,9 @@ gimp_image_select_polygon (GimpImage *image,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_IMAGE, image, GIMP_TYPE_IMAGE, image,
GIMP_TYPE_CHANNEL_OPS, operation, GIMP_TYPE_CHANNEL_OPS, operation,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), segs, num_segs); gimp_value_set_double_array (gimp_value_array_index (args, 2), segs, num_segs);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-image-select-polygon", "gimp-image-select-polygon",

68
libgimp/gimppainttools_pdb.c
View File

@@ -68,9 +68,9 @@ gimp_airbrush (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, pressure, G_TYPE_DOUBLE, pressure,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 2), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-airbrush", "gimp-airbrush",
@@ -113,9 +113,9 @@ gimp_airbrush_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-airbrush-default", "gimp-airbrush-default",
@@ -177,9 +177,9 @@ gimp_clone (GimpDrawable *drawable,
GIMP_TYPE_CLONE_TYPE, clone_type, GIMP_TYPE_CLONE_TYPE, clone_type,
G_TYPE_DOUBLE, src_x, G_TYPE_DOUBLE, src_x,
G_TYPE_DOUBLE, src_y, G_TYPE_DOUBLE, src_y,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 5), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 5), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-clone", "gimp-clone",
@@ -223,9 +223,9 @@ gimp_clone_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-clone-default", "gimp-clone-default",
@@ -273,9 +273,9 @@ gimp_convolve (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, pressure, G_TYPE_DOUBLE, pressure,
GIMP_TYPE_CONVOLVE_TYPE, convolve_type, GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 3), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 3), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-convolve", "gimp-convolve",
@@ -318,9 +318,9 @@ gimp_convolve_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-convolve-default", "gimp-convolve-default",
@@ -368,9 +368,9 @@ gimp_dodgeburn (GimpDrawable *drawable,
G_TYPE_DOUBLE, exposure, G_TYPE_DOUBLE, exposure,
GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type, GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode, GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 4), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-dodgeburn", "gimp-dodgeburn",
@@ -412,9 +412,9 @@ gimp_dodgeburn_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-dodgeburn-default", "gimp-dodgeburn-default",
@@ -461,11 +461,11 @@ gimp_eraser (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness, GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
GIMP_TYPE_PAINT_APPLICATION_MODE, method, GIMP_TYPE_PAINT_APPLICATION_MODE, method,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-eraser", "gimp-eraser",
@@ -508,9 +508,9 @@ gimp_eraser_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-eraser-default", "gimp-eraser-default",
@@ -565,9 +565,9 @@ gimp_heal (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, src_drawable, GIMP_TYPE_DRAWABLE, src_drawable,
G_TYPE_DOUBLE, src_x, G_TYPE_DOUBLE, src_x,
G_TYPE_DOUBLE, src_y, G_TYPE_DOUBLE, src_y,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 4), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 4), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-heal", "gimp-heal",
@@ -613,9 +613,9 @@ gimp_heal_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-heal-default", "gimp-heal-default",
@@ -670,11 +670,11 @@ gimp_paintbrush (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, fade_out, G_TYPE_DOUBLE, fade_out,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
GIMP_TYPE_PAINT_APPLICATION_MODE, method, GIMP_TYPE_PAINT_APPLICATION_MODE, method,
G_TYPE_DOUBLE, gradient_length, G_TYPE_DOUBLE, gradient_length,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 2), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-paintbrush", "gimp-paintbrush",
@@ -726,9 +726,9 @@ gimp_paintbrush_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-paintbrush-default", "gimp-paintbrush-default",
@@ -772,9 +772,9 @@ gimp_pencil (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-pencil", "gimp-pencil",
@@ -818,9 +818,9 @@ gimp_smudge (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, pressure, G_TYPE_DOUBLE, pressure,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 2), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-smudge", "gimp-smudge",
@@ -862,9 +862,9 @@ gimp_smudge_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable, GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 1), strokes, num_strokes); gimp_value_set_double_array (gimp_value_array_index (args, 1), strokes, num_strokes);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-smudge-default", "gimp-smudge-default",

17
libgimp/gimppath_pdb.c
View File

@@ -701,7 +701,7 @@ gimp_path_stroke_get_points (GimpPath *path,
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{ {
type = GIMP_VALUES_GET_ENUM (return_vals, 1); type = GIMP_VALUES_GET_ENUM (return_vals, 1);
*controlpoints = GIMP_VALUES_DUP_FLOAT_ARRAY (return_vals, 2, num_points); *controlpoints = GIMP_VALUES_DUP_DOUBLE_ARRAY (return_vals, 2, num_points);
*closed = GIMP_VALUES_GET_BOOLEAN (return_vals, 3); *closed = GIMP_VALUES_GET_BOOLEAN (return_vals, 3);
} }
@@ -723,10 +723,11 @@ gimp_path_stroke_get_points (GimpPath *path,
* Adds a stroke of a given type to the path object. The coordinates of * Adds a stroke of a given type to the path object. The coordinates of
* the control points can be specified. For now only strokes of the * the control points can be specified. For now only strokes of the
* type GIMP_PATH_STROKE_TYPE_BEZIER are supported. The control points * type GIMP_PATH_STROKE_TYPE_BEZIER are supported. The control points
* are specified as a pair of float values for the x- and y-coordinate. * are specified as a pair of double values for the x- and
* The Bezier stroke type needs a multiple of three control points. * y-coordinate. The Bezier stroke type needs a multiple of three
* Each Bezier segment endpoint (anchor, A) has two additional control * control points. Each Bezier segment endpoint (anchor, A) has two
* points (C) associated. They are specified in the order CACCACCAC... * additional control points (C) associated. They are specified in the
* order CACCACCAC...
* *
* Returns: The stroke ID of the newly created stroke. * Returns: The stroke ID of the newly created stroke.
* *
@@ -746,10 +747,10 @@ gimp_path_stroke_new_from_points (GimpPath *path,
args = gimp_value_array_new_from_types (NULL, args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_PATH, path, GIMP_TYPE_PATH, path,
GIMP_TYPE_PATH_STROKE_TYPE, type, GIMP_TYPE_PATH_STROKE_TYPE, type,
GIMP_TYPE_FLOAT_ARRAY, NULL, GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_BOOLEAN, closed, G_TYPE_BOOLEAN, closed,
G_TYPE_NONE); G_TYPE_NONE);
gimp_value_set_float_array (gimp_value_array_index (args, 2), controlpoints, num_points); gimp_value_set_double_array (gimp_value_array_index (args, 2), controlpoints, num_points);
return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (), return_vals = _gimp_pdb_run_procedure_array (gimp_get_pdb (),
"gimp-path-stroke-new-from-points", "gimp-path-stroke-new-from-points",
@@ -808,7 +809,7 @@ gimp_path_stroke_interpolate (GimpPath *path,
if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS) if (GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS)
{ {
coords = GIMP_VALUES_DUP_FLOAT_ARRAY (return_vals, 1, num_coords); coords = GIMP_VALUES_DUP_DOUBLE_ARRAY (return_vals, 1, num_coords);
*closed = GIMP_VALUES_GET_BOOLEAN (return_vals, 2); *closed = GIMP_VALUES_GET_BOOLEAN (return_vals, 2);
} }

60
libgimp/gimpprocedure-params.c
View File

@@ -398,7 +398,7 @@ gimp_procedure_add_unit_return_value (GimpProcedure *procedure,
* @value: the default value. * @value: the default value.
* @flags: argument flags. * @flags: argument flags.
* *
* Add a new double argument to @procedure. * Add a new floating-point in double precision argument to @procedure.
* *
* Since: 3.0 * Since: 3.0
**/ **/
@@ -429,7 +429,7 @@ gimp_procedure_add_double_argument (GimpProcedure *procedure,
* @value: the default value. * @value: the default value.
* @flags: argument flags. * @flags: argument flags.
* *
* Add a new double auxiliary argument to @procedure. * Add a new floating-point in double precision auxiliary argument to @procedure.
* *
* Since: 3.0 * Since: 3.0
**/ **/
@@ -460,7 +460,7 @@ gimp_procedure_add_double_aux_argument (GimpProcedure *procedure,
* @value: the default value. * @value: the default value.
* @flags: argument flags. * @flags: argument flags.
* *
* Add a new double return value to @procedure. * Add a new floating-point in double precision return value to @procedure.
* *
* Since: 3.0 * Since: 3.0
**/ **/
@@ -1195,75 +1195,75 @@ gimp_procedure_add_int32_array_return_value (GimpProcedure *procedure,
} }
/** /**
* gimp_procedure_add_float_array_argument: * gimp_procedure_add_double_array_argument:
* @procedure: the #GimpProcedure. * @procedure: the #GimpProcedure.
* @name: the name of the argument to be created. * @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog. * @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description. * @blurb: a more detailed help description.
* @flags: argument flags. * @flags: argument flags.
* *
* Add a new float array argument to @procedure. * Add a new double array argument to @procedure.
* *
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_procedure_add_float_array_argument (GimpProcedure *procedure, gimp_procedure_add_double_array_argument (GimpProcedure *procedure,
const gchar *name, const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags) GParamFlags flags)
{ {
_gimp_procedure_add_argument (procedure, _gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array (name, nick, blurb, gimp_param_spec_double_array (name, nick, blurb,
flags)); flags));
} }
/** /**
* gimp_procedure_add_float_array_aux_argument: * gimp_procedure_add_double_array_aux_argument:
* @procedure: the #GimpProcedure. * @procedure: the #GimpProcedure.
* @name: the name of the argument to be created. * @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog. * @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description. * @blurb: a more detailed help description.
* @flags: argument flags. * @flags: argument flags.
* *
* Add a new float array auxiliary argument to @procedure. * Add a new double array auxiliary argument to @procedure.
* *
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_procedure_add_float_array_aux_argument (GimpProcedure *procedure, gimp_procedure_add_double_array_aux_argument (GimpProcedure *procedure,
const gchar *name, const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags) GParamFlags flags)
{ {
_gimp_procedure_add_aux_argument (procedure, _gimp_procedure_add_aux_argument (procedure,
gimp_param_spec_float_array (name, nick, blurb, gimp_param_spec_double_array (name, nick, blurb,
flags)); flags));
} }
/** /**
* gimp_procedure_add_float_array_return_value: * gimp_procedure_add_double_array_return_value:
* @procedure: the #GimpProcedure. * @procedure: the #GimpProcedure.
* @name: the name of the argument to be created. * @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog. * @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description. * @blurb: a more detailed help description.
* @flags: argument flags. * @flags: argument flags.
* *
* Add a new float array return value to @procedure. * Add a new double array return value to @procedure.
* *
* Since: 3.0 * Since: 3.0
**/ **/
void void
gimp_procedure_add_float_array_return_value (GimpProcedure *procedure, gimp_procedure_add_double_array_return_value (GimpProcedure *procedure,
const gchar *name, const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags) GParamFlags flags)
{ {
_gimp_procedure_add_return_value (procedure, _gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array (name, nick, blurb, gimp_param_spec_double_array (name, nick, blurb,
flags)); flags));
} }
/** /**

24
libgimp/gimpprocedure-params.h
View File

@@ -196,19 +196,19 @@ G_BEGIN_DECLS
gimp_value_take_int32_array (gimp_value_array_index (args, n), value, length) gimp_value_take_int32_array (gimp_value_array_index (args, n), value, length)
/* float array */ /* double array */
#define GIMP_VALUES_GET_FLOAT_ARRAY(args, n, length) \ #define GIMP_VALUES_GET_DOUBLE_ARRAY(args, n, length) \
gimp_value_get_float_array (gimp_value_array_index (args, n), length) gimp_value_get_double_array (gimp_value_array_index (args, n), length)
#define GIMP_VALUES_DUP_FLOAT_ARRAY(args, n, length) \ #define GIMP_VALUES_DUP_DOUBLE_ARRAY(args, n, length) \
gimp_value_dup_float_array (gimp_value_array_index (args, n), length) gimp_value_dup_double_array (gimp_value_array_index (args, n), length)
#define GIMP_VALUES_SET_FLOAT_ARRAY(args, n, value, length) \ #define GIMP_VALUES_SET_DOUBLE_ARRAY(args, n, value, length) \
gimp_value_set_float_array (gimp_value_array_index (args, n), value, length) gimp_value_set_double_array (gimp_value_array_index (args, n), value, length)
#define GIMP_VALUES_TAKE_FLOAT_ARRAY(args, n, value, length) \ #define GIMP_VALUES_TAKE_DOUBLE_ARRAY(args, n, value, length) \
gimp_value_take_float_array (gimp_value_array_index (args, n), value, length) gimp_value_take_double_array (gimp_value_array_index (args, n), value, length)
/* string array (strv) */ /* string array (strv) */
@@ -722,17 +722,17 @@ void gimp_procedure_add_int32_array_return_value (GimpProcedure *procedure
const gchar *blurb, const gchar *blurb,
GParamFlags flags); GParamFlags flags);
void gimp_procedure_add_float_array_argument (GimpProcedure *procedure, void gimp_procedure_add_double_array_argument (GimpProcedure *procedure,
const gchar *name, const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags); GParamFlags flags);
void gimp_procedure_add_float_array_aux_argument (GimpProcedure *procedure, void gimp_procedure_add_double_array_aux_argument (GimpProcedure *procedure,
const gchar *name, const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags); GParamFlags flags);
void gimp_procedure_add_float_array_return_value (GimpProcedure *procedure, void gimp_procedure_add_double_array_return_value (GimpProcedure *procedure,
const gchar *name, const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,

8
libgimp/gimpresourceselect.c
View File

@@ -127,10 +127,10 @@ create_callback_PDB_procedure_params (GimpProcedure *procedure,
} }
else if (g_type_is_a (resource_type, GIMP_TYPE_GRADIENT)) else if (g_type_is_a (resource_type, GIMP_TYPE_GRADIENT))
{ {
gimp_procedure_add_float_array_argument (procedure, "gradient-data", gimp_procedure_add_double_array_argument (procedure, "gradient-data",
"Gradient data", "Gradient data",
"The gradient data", "The gradient data",
G_PARAM_READWRITE); G_PARAM_READWRITE);
} }
else if (g_type_is_a (resource_type, GIMP_TYPE_BRUSH)) else if (g_type_is_a (resource_type, GIMP_TYPE_BRUSH))
{ {

2
libgimp/gimptextlayer_pdb.c
View File

@@ -331,7 +331,7 @@ gimp_text_layer_set_font (GimpTextLayer *layer,
* Get the font size from a text layer. * Get the font size from a text layer.
* *
* This procedure returns the size of the font which is used in a text * This procedure returns the size of the font which is used in a text
* layer. You will receive the size as a float 'font-size' in 'unit' * layer. You will receive the size as a double 'font-size' in 'unit'
* units. * units.
* *
* Returns: The font size. * Returns: The font size.

20
libgimpbase/gimpbase.def
View File

@@ -48,6 +48,9 @@ EXPORTS
gimp_directory gimp_directory
gimp_directory_file gimp_directory_file
gimp_dodge_burn_type_get_type gimp_dodge_burn_type_get_type
gimp_double_array_get_type
gimp_double_array_get_values
gimp_double_array_set_values
gimp_enum_get_desc gimp_enum_get_desc
gimp_enum_get_value gimp_enum_get_value
gimp_enum_get_value_descriptions gimp_enum_get_value_descriptions
@@ -71,9 +74,6 @@ EXPORTS
gimp_flags_value_get_abbrev gimp_flags_value_get_abbrev
gimp_flags_value_get_desc gimp_flags_value_get_desc
gimp_flags_value_get_help gimp_flags_value_get_help
gimp_float_array_get_type
gimp_float_array_get_values
gimp_float_array_set_values
gimp_foreground_extract_mode_get_type gimp_foreground_extract_mode_get_type
gimp_gradient_blend_color_space_get_type gimp_gradient_blend_color_space_get_type
gimp_gradient_segment_color_get_type gimp_gradient_segment_color_get_type
@@ -129,8 +129,8 @@ EXPORTS
gimp_param_array_get_type gimp_param_array_get_type
gimp_param_choice_get_type gimp_param_choice_get_type
gimp_param_core_object_array_get_type gimp_param_core_object_array_get_type
gimp_param_double_array_get_type
gimp_param_export_options_get_type gimp_param_export_options_get_type
gimp_param_float_array_get_type
gimp_param_int32_array_get_type gimp_param_int32_array_get_type
gimp_param_memsize_get_type gimp_param_memsize_get_type
gimp_param_object_get_type gimp_param_object_get_type
@@ -138,8 +138,8 @@ EXPORTS
gimp_param_spec_array gimp_param_spec_array
gimp_param_spec_choice gimp_param_spec_choice
gimp_param_spec_core_object_array gimp_param_spec_core_object_array
gimp_param_spec_double_array
gimp_param_spec_export_options gimp_param_spec_export_options
gimp_param_spec_float_array
gimp_param_spec_int32_array gimp_param_spec_int32_array
gimp_param_spec_memsize gimp_param_spec_memsize
gimp_param_spec_object_duplicate gimp_param_spec_object_duplicate
@@ -249,15 +249,15 @@ EXPORTS
gimp_value_array_remove gimp_value_array_remove
gimp_value_array_truncate gimp_value_array_truncate
gimp_value_array_unref gimp_value_array_unref
gimp_value_dup_float_array gimp_value_dup_double_array
gimp_value_dup_int32_array gimp_value_dup_int32_array
gimp_value_get_float_array gimp_value_get_double_array
gimp_value_get_int32_array gimp_value_get_int32_array
gimp_value_set_float_array gimp_value_set_double_array
gimp_value_set_int32_array gimp_value_set_int32_array
gimp_value_set_static_float_array gimp_value_set_static_double_array
gimp_value_set_static_int32_array gimp_value_set_static_int32_array
gimp_value_take_float_array gimp_value_take_double_array
gimp_value_take_int32_array gimp_value_take_int32_array
gimp_wire_clear_error gimp_wire_clear_error
gimp_wire_destroy gimp_wire_destroy

132
libgimpbase/gimpparamspecs.c
View File

@@ -681,22 +681,22 @@ gimp_value_take_int32_array (GValue *value,
/* /*
* GIMP_TYPE_FLOAT_ARRAY * GIMP_TYPE_DOUBLE_ARRAY
*/ */
typedef GimpArray GimpFloatArray; typedef GimpArray GimpDoubleArray;
G_DEFINE_BOXED_TYPE (GimpFloatArray, gimp_float_array, gimp_array_copy, gimp_array_free) G_DEFINE_BOXED_TYPE (GimpDoubleArray, gimp_double_array, gimp_array_copy, gimp_array_free)
/** /**
* gimp_float_array_get_values: * gimp_double_array_get_values:
* @array: the #GimpArray representing #float values. * @array: the #GimpArray representing #double values.
* @length: the number of #float values in the returned array. * @length: the number of #double values in the returned array.
* *
* Returns: (array length=length) (transfer none): a C-array of #gdouble. * Returns: (array length=length) (transfer none): a C-array of #gdouble.
*/ */
const gdouble * const gdouble *
gimp_float_array_get_values (GimpArray *array, gimp_double_array_get_values (GimpArray *array,
gsize *length) gsize *length)
{ {
g_return_val_if_fail (array->length % sizeof (gdouble) == 0, NULL); g_return_val_if_fail (array->length % sizeof (gdouble) == 0, NULL);
@@ -707,17 +707,17 @@ gimp_float_array_get_values (GimpArray *array,
} }
/** /**
* gimp_float_array_set_values: * gimp_double_array_set_values:
* @array: the array to modify. * @array: the array to modify.
* @values: (array length=length): the C-array. * @values: (array length=length): the C-array.
* @length: the number of #float values in @data. * @length: the number of #double values in @data.
* @static_data: whether @data is a static rather than allocated array. * @static_data: whether @data is a static rather than allocated array.
*/ */
void void
gimp_float_array_set_values (GimpArray *array, gimp_double_array_set_values (GimpArray *array,
const gdouble *values, const gdouble *values,
gsize length, gsize length,
gboolean static_data) gboolean static_data)
{ {
g_return_if_fail ((values == NULL && length == 0) || (values != NULL && length > 0)); g_return_if_fail ((values == NULL && length == 0) || (values != NULL && length > 0));
@@ -731,14 +731,14 @@ gimp_float_array_set_values (GimpArray *array,
/* /*
* GIMP_TYPE_PARAM_FLOAT_ARRAY * GIMP_TYPE_PARAM_DOUBLE_ARRAY
*/ */
static void gimp_param_float_array_class_init (GParamSpecClass *klass); static void gimp_param_double_array_class_init (GParamSpecClass *klass);
static void gimp_param_float_array_init (GParamSpec *pspec); static void gimp_param_double_array_init (GParamSpec *pspec);
GType GType
gimp_param_float_array_get_type (void) gimp_param_double_array_get_type (void)
{ {
static GType type = 0; static GType type = 0;
@@ -748,77 +748,77 @@ gimp_param_float_array_get_type (void)
{ {
sizeof (GParamSpecClass), sizeof (GParamSpecClass),
NULL, NULL, NULL, NULL,
(GClassInitFunc) gimp_param_float_array_class_init, (GClassInitFunc) gimp_param_double_array_class_init,
NULL, NULL, NULL, NULL,
sizeof (GParamSpecBoxed), sizeof (GParamSpecBoxed),
0, 0,
(GInstanceInitFunc) gimp_param_float_array_init (GInstanceInitFunc) gimp_param_double_array_init
}; };
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY, type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
"GimpParamFloatArray", &info, 0); "GimpParamDoubleArray", &info, 0);
} }
return type; return type;
} }
static void static void
gimp_param_float_array_class_init (GParamSpecClass *klass) gimp_param_double_array_class_init (GParamSpecClass *klass)
{ {
klass->value_type = GIMP_TYPE_FLOAT_ARRAY; klass->value_type = GIMP_TYPE_DOUBLE_ARRAY;
} }
static void static void
gimp_param_float_array_init (GParamSpec *pspec) gimp_param_double_array_init (GParamSpec *pspec)
{ {
} }
/** /**
* gimp_param_spec_float_array: * gimp_param_spec_double_array:
* @name: Canonical name of the property specified. * @name: Canonical name of the property specified.
* @nick: Nick name of the property specified. * @nick: Nick name of the property specified.
* @blurb: Description of the property specified. * @blurb: Description of the property specified.
* @flags: Flags for the property specified. * @flags: Flags for the property specified.
* *
* Creates a new #GimpParamSpecFloatArray specifying a * Creates a new #GimpParamSpecDoubleArray specifying a
* %GIMP_TYPE_FLOAT_ARRAY property. * %GIMP_TYPE_DOUBLE_ARRAY property.
* *
* See g_param_spec_internal() for details on property names. * See g_param_spec_internal() for details on property names.
* *
* Returns: (transfer floating): The newly created #GimpParamSpecFloatArray. * Returns: (transfer floating): The newly created #GimpParamSpecDoubleArray.
* *
* Since: 3.0 * Since: 3.0
**/ **/
GParamSpec * GParamSpec *
gimp_param_spec_float_array (const gchar *name, gimp_param_spec_double_array (const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags) GParamFlags flags)
{ {
GParamSpec *array_spec; GParamSpec *array_spec;
array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_FLOAT_ARRAY, array_spec = g_param_spec_internal (GIMP_TYPE_PARAM_DOUBLE_ARRAY,
name, nick, blurb, flags); name, nick, blurb, flags);
return array_spec; return array_spec;
} }
/** /**
* gimp_value_get_float_array: * gimp_value_get_double_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY * @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @length: the number of returned #double elements. * @length: the number of returned #double elements.
* *
* Gets the contents of a %GIMP_TYPE_FLOAT_ARRAY #GValue * Gets the contents of a %GIMP_TYPE_DOUBLE_ARRAY #GValue
* *
* Returns: (transfer none) (array length=length): The contents of @value * Returns: (transfer none) (array length=length): The contents of @value
*/ */
const gdouble * const gdouble *
gimp_value_get_float_array (const GValue *value, gimp_value_get_double_array (const GValue *value,
gsize *length) gsize *length)
{ {
GimpArray *array; GimpArray *array;
g_return_val_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), NULL); g_return_val_if_fail (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value), NULL);
array = value->data[0].v_pointer; array = value->data[0].v_pointer;
@@ -831,21 +831,21 @@ gimp_value_get_float_array (const GValue *value,
} }
/** /**
* gimp_value_dup_float_array: * gimp_value_dup_double_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY * @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @length: the number of returned #double elements. * @length: the number of returned #double elements.
* *
* Gets the contents of a %GIMP_TYPE_FLOAT_ARRAY #GValue * Gets the contents of a %GIMP_TYPE_DOUBLE_ARRAY #GValue
* *
* Returns: (transfer full) (array length=length): The contents of @value * Returns: (transfer full) (array length=length): The contents of @value
*/ */
gdouble * gdouble *
gimp_value_dup_float_array (const GValue *value, gimp_value_dup_double_array (const GValue *value,
gsize *length) gsize *length)
{ {
GimpArray *array; GimpArray *array;
g_return_val_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), NULL); g_return_val_if_fail (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value), NULL);
array = value->data[0].v_pointer; array = value->data[0].v_pointer;
@@ -858,57 +858,57 @@ gimp_value_dup_float_array (const GValue *value,
} }
/** /**
* gimp_value_set_float_array: * gimp_value_set_double_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY * @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @data: (array length=length): A #gfloat array * @data: (array length=length): A #gdouble array
* @length: The number of elements in @data * @length: The number of elements in @data
* *
* Sets the contents of @value to @data. * Sets the contents of @value to @data.
*/ */
void void
gimp_value_set_float_array (GValue *value, gimp_value_set_double_array (GValue *value,
const gdouble *data, const gdouble *data,
gsize length) gsize length)
{ {
g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)); g_return_if_fail (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value));
gimp_value_set_array (value, (const guint8 *) data, gimp_value_set_array (value, (const guint8 *) data,
length * sizeof (gdouble)); length * sizeof (gdouble));
} }
/** /**
* gimp_value_set_static_float_array: * gimp_value_set_static_double_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY * @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @data: (array length=length): A #gfloat array * @data: (array length=length): A #gdouble array
* @length: The number of elements in @data * @length: The number of elements in @data
* *
* Sets the contents of @value to @data, without copying the data. * Sets the contents of @value to @data, without copying the data.
*/ */
void void
gimp_value_set_static_float_array (GValue *value, gimp_value_set_static_double_array (GValue *value,
const gdouble *data, const gdouble *data,
gsize length) gsize length)
{ {
g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)); g_return_if_fail (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value));
gimp_value_set_static_array (value, (const guint8 *) data, gimp_value_set_static_array (value, (const guint8 *) data,
length * sizeof (gdouble)); length * sizeof (gdouble));
} }
/** /**
* gimp_value_take_float_array: * gimp_value_take_double_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY * @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @data: (transfer full) (array length=length): A #gfloat array * @data: (transfer full) (array length=length): A #gdouble array
* @length: The number of elements in @data * @length: The number of elements in @data
* *
* Sets the contents of @value to @data, and takes ownership of @data. * Sets the contents of @value to @data, and takes ownership of @data.
*/ */
void void
gimp_value_take_float_array (GValue *value, gimp_value_take_double_array (GValue *value,
gdouble *data, gdouble *data,
gsize length) gsize length)
{ {
g_return_if_fail (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)); g_return_if_fail (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value));
gimp_value_take_array (value, (guint8 *) data, gimp_value_take_array (value, (guint8 *) data,
length * sizeof (gdouble)); length * sizeof (gdouble));

62
libgimpbase/gimpparamspecs.h
View File

@@ -246,49 +246,49 @@ void gimp_value_take_int32_array (GValue *value,
/* /*
* GIMP_TYPE_FLOAT_ARRAY * GIMP_TYPE_DOUBLE_ARRAY
*/ */
#define GIMP_TYPE_FLOAT_ARRAY (gimp_float_array_get_type ()) #define GIMP_TYPE_DOUBLE_ARRAY (gimp_double_array_get_type ())
#define GIMP_VALUE_HOLDS_FLOAT_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_FLOAT_ARRAY)) #define GIMP_VALUE_HOLDS_DOUBLE_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_DOUBLE_ARRAY))
GType gimp_float_array_get_type (void) G_GNUC_CONST; GType gimp_double_array_get_type (void) G_GNUC_CONST;
const gdouble * gimp_float_array_get_values (GimpArray *array, const gdouble * gimp_double_array_get_values (GimpArray *array,
gsize *length); gsize *length);
void gimp_float_array_set_values (GimpArray *array, void gimp_double_array_set_values (GimpArray *array,
const gdouble *values, const gdouble *values,
gsize length, gsize length,
gboolean static_data); gboolean static_data);
/* /*
* GIMP_TYPE_PARAM_FLOAT_ARRAY * GIMP_TYPE_PARAM_DOUBLE_ARRAY
*/ */
#define GIMP_TYPE_PARAM_FLOAT_ARRAY (gimp_param_float_array_get_type ()) #define GIMP_TYPE_PARAM_DOUBLE_ARRAY (gimp_param_double_array_get_type ())
#define GIMP_IS_PARAM_SPEC_FLOAT_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_FLOAT_ARRAY)) #define GIMP_IS_PARAM_SPEC_DOUBLE_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_DOUBLE_ARRAY))
GType gimp_param_float_array_get_type (void) G_GNUC_CONST; GType gimp_param_double_array_get_type (void) G_GNUC_CONST;
GParamSpec * gimp_param_spec_float_array (const gchar *name, GParamSpec * gimp_param_spec_double_array (const gchar *name,
const gchar *nick, const gchar *nick,
const gchar *blurb, const gchar *blurb,
GParamFlags flags); GParamFlags flags);
const gdouble * gimp_value_get_float_array (const GValue *value, const gdouble * gimp_value_get_double_array (const GValue *value,
gsize *length); gsize *length);
gdouble * gimp_value_dup_float_array (const GValue *value, gdouble * gimp_value_dup_double_array (const GValue *value,
gsize *length); gsize *length);
void gimp_value_set_float_array (GValue *value, void gimp_value_set_double_array (GValue *value,
const gdouble *data, const gdouble *data,
gsize length); gsize length);
void gimp_value_set_static_float_array (GValue *value, void gimp_value_set_static_double_array (GValue *value,
const gdouble *data, const gdouble *data,
gsize length); gsize length);
void gimp_value_take_float_array (GValue *value, void gimp_value_take_double_array (GValue *value,
gdouble *data, gdouble *data,
gsize length); gsize length);
/* /*

28
libgimpbase/gimpprotocol.c
View File

@@ -1197,15 +1197,15 @@ _gp_param_def_read (GIOChannel *channel,
return FALSE; return FALSE;
break; break;
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
if (! _gimp_wire_read_double (channel, if (! _gimp_wire_read_double (channel,
&param_def->meta.m_float.min_val, 1, &param_def->meta.m_double.min_val, 1,
user_data) || user_data) ||
! _gimp_wire_read_double (channel, ! _gimp_wire_read_double (channel,
&param_def->meta.m_float.max_val, 1, &param_def->meta.m_double.max_val, 1,
user_data) || user_data) ||
! _gimp_wire_read_double (channel, ! _gimp_wire_read_double (channel,
&param_def->meta.m_float.default_val, 1, &param_def->meta.m_double.default_val, 1,
user_data)) user_data))
return FALSE; return FALSE;
break; break;
@@ -1316,7 +1316,7 @@ _gp_param_def_destroy (GPParamDef *param_def)
break; break;
case GP_PARAM_DEF_TYPE_BOOLEAN: case GP_PARAM_DEF_TYPE_BOOLEAN:
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
break; break;
case GP_PARAM_DEF_TYPE_CHOICE: case GP_PARAM_DEF_TYPE_CHOICE:
@@ -1557,15 +1557,15 @@ _gp_param_def_write (GIOChannel *channel,
return FALSE; return FALSE;
break; break;
case GP_PARAM_DEF_TYPE_FLOAT: case GP_PARAM_DEF_TYPE_DOUBLE:
if (! _gimp_wire_write_double (channel, if (! _gimp_wire_write_double (channel,
&param_def->meta.m_float.min_val, 1, &param_def->meta.m_double.min_val, 1,
user_data) || user_data) ||
! _gimp_wire_write_double (channel, ! _gimp_wire_write_double (channel,
&param_def->meta.m_float.max_val, 1, &param_def->meta.m_double.max_val, 1,
user_data) || user_data) ||
! _gimp_wire_write_double (channel, ! _gimp_wire_write_double (channel,
&param_def->meta.m_float.default_val, 1, &param_def->meta.m_double.default_val, 1,
user_data)) user_data))
return FALSE; return FALSE;
break; break;
@@ -1825,9 +1825,9 @@ _gp_params_read (GIOChannel *channel,
goto cleanup; goto cleanup;
break; break;
case GP_PARAM_TYPE_FLOAT: case GP_PARAM_TYPE_DOUBLE:
if (! _gimp_wire_read_double (channel, if (! _gimp_wire_read_double (channel,
&(*params)[i].data.d_float, 1, &(*params)[i].data.d_double, 1,
user_data)) user_data))
goto cleanup; goto cleanup;
break; break;
@@ -2178,9 +2178,9 @@ _gp_params_write (GIOChannel *channel,
return; return;
break; break;
case GP_PARAM_TYPE_FLOAT: case GP_PARAM_TYPE_DOUBLE:
if (! _gimp_wire_write_double (channel, if (! _gimp_wire_write_double (channel,
(const gdouble *) &params[i].data.d_float, 1, (const gdouble *) &params[i].data.d_double, 1,
user_data)) user_data))
return; return;
break; break;
@@ -2374,7 +2374,7 @@ _gp_params_destroy (GPParam *params,
switch (params[i].param_type) switch (params[i].param_type)
{ {
case GP_PARAM_TYPE_INT: case GP_PARAM_TYPE_INT:
case GP_PARAM_TYPE_FLOAT: case GP_PARAM_TYPE_DOUBLE:
break; break;
case GP_PARAM_TYPE_STRING: case GP_PARAM_TYPE_STRING:

12
libgimpbase/gimpprotocol.h
View File

@@ -54,7 +54,7 @@ typedef enum
GP_PARAM_DEF_TYPE_ENUM, GP_PARAM_DEF_TYPE_ENUM,
GP_PARAM_DEF_TYPE_CHOICE, GP_PARAM_DEF_TYPE_CHOICE,
GP_PARAM_DEF_TYPE_BOOLEAN, GP_PARAM_DEF_TYPE_BOOLEAN,
GP_PARAM_DEF_TYPE_FLOAT, GP_PARAM_DEF_TYPE_DOUBLE,
GP_PARAM_DEF_TYPE_STRING, GP_PARAM_DEF_TYPE_STRING,
GP_PARAM_DEF_TYPE_GEGL_COLOR, GP_PARAM_DEF_TYPE_GEGL_COLOR,
GP_PARAM_DEF_TYPE_ID, GP_PARAM_DEF_TYPE_ID,
@@ -66,7 +66,7 @@ typedef enum
typedef enum typedef enum
{ {
GP_PARAM_TYPE_INT, GP_PARAM_TYPE_INT,
GP_PARAM_TYPE_FLOAT, GP_PARAM_TYPE_DOUBLE,
GP_PARAM_TYPE_STRING, GP_PARAM_TYPE_STRING,
GP_PARAM_TYPE_STRV, GP_PARAM_TYPE_STRV,
GP_PARAM_TYPE_BYTES, GP_PARAM_TYPE_BYTES,
@@ -91,7 +91,7 @@ typedef struct _GPParamDefInt GPParamDefInt;
typedef struct _GPParamDefUnit GPParamDefUnit; typedef struct _GPParamDefUnit GPParamDefUnit;
typedef struct _GPParamDefEnum GPParamDefEnum; typedef struct _GPParamDefEnum GPParamDefEnum;
typedef struct _GPParamDefBoolean GPParamDefBoolean; typedef struct _GPParamDefBoolean GPParamDefBoolean;
typedef struct _GPParamDefFloat GPParamDefFloat; typedef struct _GPParamDefDouble GPParamDefDouble;
typedef struct _GPParamDefString GPParamDefString; typedef struct _GPParamDefString GPParamDefString;
typedef struct _GPParamDefChoice GPParamDefChoice; typedef struct _GPParamDefChoice GPParamDefChoice;
typedef struct _GPParamStrv GPParamStrv; typedef struct _GPParamStrv GPParamStrv;
@@ -196,7 +196,7 @@ struct _GPParamDefBoolean
gint32 default_val; gint32 default_val;
}; };
struct _GPParamDefFloat struct _GPParamDefDouble
{ {
gdouble min_val; gdouble min_val;
gdouble max_val; gdouble max_val;
@@ -253,7 +253,7 @@ struct _GPParamDef
GPParamDefUnit m_unit; GPParamDefUnit m_unit;
GPParamDefEnum m_enum; GPParamDefEnum m_enum;
GPParamDefBoolean m_boolean; GPParamDefBoolean m_boolean;
GPParamDefFloat m_float; GPParamDefDouble m_double;
GPParamDefString m_string; GPParamDefString m_string;
GPParamDefGeglColor m_gegl_color; GPParamDefGeglColor m_gegl_color;
GPParamDefID m_id; GPParamDefID m_id;
@@ -314,7 +314,7 @@ struct _GPParam
union union
{ {
gint32 d_int; gint32 d_int;
gdouble d_float; gdouble d_double;
gchar *d_string; gchar *d_string;
gchar **d_strv; gchar **d_strv;
GBytes *d_bytes; GBytes *d_bytes;

12
libgimpconfig/gimpconfig-deserialize.c
View File

@@ -385,7 +385,7 @@ gimp_config_deserialize_value (GValue *value,
return gimp_config_deserialize_strv (value, scanner); return gimp_config_deserialize_strv (value, scanner);
} }
else if (prop_spec->value_type == GIMP_TYPE_INT32_ARRAY || else if (prop_spec->value_type == GIMP_TYPE_INT32_ARRAY ||
prop_spec->value_type == GIMP_TYPE_FLOAT_ARRAY) prop_spec->value_type == GIMP_TYPE_DOUBLE_ARRAY)
{ {
return gimp_config_deserialize_array (value, scanner); return gimp_config_deserialize_array (value, scanner);
} }
@@ -538,8 +538,8 @@ gimp_config_deserialize_fundamental (GValue *value,
case G_TYPE_FLOAT: case G_TYPE_FLOAT:
if (next_token == G_TOKEN_FLOAT) if (next_token == G_TOKEN_FLOAT)
g_value_set_float (value, negate ? g_value_set_float (value, negate ?
- scanner->value.v_float : - (gfloat) scanner->value.v_float :
scanner->value.v_float); (gfloat) scanner->value.v_float);
else else
g_value_set_float (value, negate ? g_value_set_float (value, negate ?
- (gfloat) scanner->value.v_int : - (gfloat) scanner->value.v_int :
@@ -946,7 +946,7 @@ gimp_config_deserialize_array (GValue *value,
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value)) if (GIMP_VALUE_HOLDS_INT32_ARRAY (value))
values = g_new0 (gint32, n_values); values = g_new0 (gint32, n_values);
else /* GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) */ else /* GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value) */
values = (gint32 *) g_new0 (gdouble, n_values); values = (gint32 *) g_new0 (gdouble, n_values);
for (gint i = 0; i < n_values; i++) for (gint i = 0; i < n_values; i++)
@@ -967,7 +967,7 @@ gimp_config_deserialize_array (GValue *value,
{ {
gdouble value; gdouble value;
if (! gimp_scanner_parse_float (scanner, &value)) if (! gimp_scanner_parse_double (scanner, &value))
{ {
result_token = G_TOKEN_FLOAT; result_token = G_TOKEN_FLOAT;
break; break;
@@ -982,7 +982,7 @@ gimp_config_deserialize_array (GValue *value,
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value)) if (GIMP_VALUE_HOLDS_INT32_ARRAY (value))
gimp_value_take_int32_array (value, values, n_values); gimp_value_take_int32_array (value, values, n_values);
else else
gimp_value_take_float_array (value, (gdouble *) values, n_values); gimp_value_take_double_array (value, (gdouble *) values, n_values);
} }
else else
{ {

5
libgimpconfig/gimpconfig-params.c
View File

@@ -288,10 +288,9 @@ gimp_config_param_spec_duplicate (GParamSpec *pspec)
copy = gimp_param_spec_int32_array (name, nick, blurb, copy = gimp_param_spec_int32_array (name, nick, blurb,
flags); flags);
} }
else if (GIMP_IS_PARAM_SPEC_FLOAT_ARRAY (pspec)) else if (GIMP_IS_PARAM_SPEC_DOUBLE_ARRAY (pspec))
{ {
copy = gimp_param_spec_float_array (name, nick, blurb, copy = gimp_param_spec_double_array (name, nick, blurb, flags);
flags);
} }
} }
else if (GIMP_IS_PARAM_SPEC_CORE_OBJECT_ARRAY (pspec)) else if (GIMP_IS_PARAM_SPEC_CORE_OBJECT_ARRAY (pspec))

4
libgimpconfig/gimpconfig-serialize.c
View File

@@ -515,7 +515,7 @@ gimp_config_serialize_value (const GValue *value,
} }
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) || if (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)) GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{ {
return gimp_config_serialize_array (value, str); return gimp_config_serialize_array (value, str);
} }
@@ -745,7 +745,7 @@ gimp_config_serialize_array (const GValue *value,
GimpArray *array; GimpArray *array;
g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value) || g_return_val_if_fail (GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value), FALSE); GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value), FALSE);
array = g_value_get_boxed (value); array = g_value_get_boxed (value);

2
libgimpconfig/gimpconfig.def
View File

@@ -88,7 +88,7 @@ EXPORTS
gimp_scanner_parse_boolean gimp_scanner_parse_boolean
gimp_scanner_parse_color gimp_scanner_parse_color
gimp_scanner_parse_data gimp_scanner_parse_data
gimp_scanner_parse_float gimp_scanner_parse_double
gimp_scanner_parse_identifier gimp_scanner_parse_identifier
gimp_scanner_parse_int gimp_scanner_parse_int
gimp_scanner_parse_int64 gimp_scanner_parse_int64

20
libgimpconfig/gimpscanner.c
View File

@@ -562,18 +562,18 @@ gimp_scanner_parse_int64 (GimpScanner *scanner,
} }
/** /**
* gimp_scanner_parse_float: * gimp_scanner_parse_double:
* @scanner: A #GimpScanner created by gimp_scanner_new_file() or * @scanner: A #GimpScanner created by gimp_scanner_new_file() or
* gimp_scanner_new_string() * gimp_scanner_new_string()
* @dest: (out): Return location for the parsed float * @dest: (out): Return location for the parsed double
* *
* Returns: %TRUE on success * Returns: %TRUE on success
* *
* Since: 2.4 * Since: 2.4
**/ **/
gboolean gboolean
gimp_scanner_parse_float (GimpScanner *scanner, gimp_scanner_parse_double (GimpScanner *scanner,
gdouble *dest) gdouble *dest)
{ {
gboolean negate = FALSE; gboolean negate = FALSE;
@@ -933,13 +933,13 @@ gimp_scanner_parse_matrix2 (GimpScanner *scanner,
{ {
token = G_TOKEN_FLOAT; token = G_TOKEN_FLOAT;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[0][0])) if (! gimp_scanner_parse_double (scanner, &matrix.coeff[0][0]))
goto finish; goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[0][1])) if (! gimp_scanner_parse_double (scanner, &matrix.coeff[0][1]))
goto finish; goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[1][0])) if (! gimp_scanner_parse_double (scanner, &matrix.coeff[1][0]))
goto finish; goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[1][1])) if (! gimp_scanner_parse_double (scanner, &matrix.coeff[1][1]))
goto finish; goto finish;
token = G_TOKEN_RIGHT_PAREN; token = G_TOKEN_RIGHT_PAREN;
@@ -1030,7 +1030,7 @@ gimp_scanner_parse_deprecated_color (GimpScanner *scanner,
case G_TOKEN_SYMBOL: case G_TOKEN_SYMBOL:
{ {
gdouble col[4] = { 0.0, 0.0, 0.0, 1.0 }; gdouble col[4] = { 0.0, 0.0, 0.0, 1.0 };
gdouble col_f[4] = { 0.0, 0.0, 0.0, 1.0 }; gfloat col_f[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
gint n_channels = 4; gint n_channels = 4;
gboolean is_hsv = FALSE; gboolean is_hsv = FALSE;
gint i; gint i;
@@ -1055,7 +1055,7 @@ gimp_scanner_parse_deprecated_color (GimpScanner *scanner,
for (i = 0; i < n_channels; i++) for (i = 0; i < n_channels; i++)
{ {
if (! gimp_scanner_parse_float (scanner, &col[i])) if (! gimp_scanner_parse_double (scanner, &col[i]))
goto finish; goto finish;
col_f[i] = (gfloat) col[i]; col_f[i] = (gfloat) col[i];

2
libgimpconfig/gimpscanner.h
View File

@@ -67,7 +67,7 @@ gboolean gimp_scanner_parse_int (GimpScanner *scanner,
gint *dest); gint *dest);
gboolean gimp_scanner_parse_int64 (GimpScanner *scanner, gboolean gimp_scanner_parse_int64 (GimpScanner *scanner,
gint64 *dest); gint64 *dest);
gboolean gimp_scanner_parse_float (GimpScanner *scanner, gboolean gimp_scanner_parse_double (GimpScanner *scanner,
gdouble *dest); gdouble *dest);
gboolean gimp_scanner_parse_boolean (GimpScanner *scanner, gboolean gimp_scanner_parse_boolean (GimpScanner *scanner,
gboolean *dest); gboolean *dest);

12
pdb/app.pl
View File

@@ -487,7 +487,7 @@ gimp_param_spec_export_options ("$name",
$flags) $flags)
CODE CODE
} }
elsif ($pdbtype eq 'float') { elsif ($pdbtype eq 'double') {
$min = defined $typeinfo[0] ? $typeinfo[0] : -G_MAXDOUBLE; $min = defined $typeinfo[0] ? $typeinfo[0] : -G_MAXDOUBLE;
$max = defined $typeinfo[2] ? $typeinfo[2] : G_MAXDOUBLE; $max = defined $typeinfo[2] ? $typeinfo[2] : G_MAXDOUBLE;
$default = exists $arg->{default} ? $arg->{default} : defined $typeinfo[0] ? $typeinfo[0] : 0.0; $default = exists $arg->{default} ? $arg->{default} : defined $typeinfo[0] ? $typeinfo[0] : 0.0;
@@ -686,12 +686,12 @@ gimp_param_spec_int32_array ("$name",
$flags) $flags)
CODE CODE
} }
elsif ($pdbtype eq 'floatarray') { elsif ($pdbtype eq 'doublearray') {
$pspec = <<CODE; $pspec = <<CODE;
gimp_param_spec_float_array ("$name", gimp_param_spec_double_array ("$name",
"$nick", "$nick",
"$blurb", "$blurb",
$flags) $flags)
CODE CODE
} }
elsif ($pdbtype eq 'bytes') { elsif ($pdbtype eq 'bytes') {

28
pdb/groups/brush.pdb
View File

@@ -314,7 +314,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'radius', type => 'float', { name => 'radius', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The radius of the brush in pixels' } desc => 'The radius of the brush in pixels' }
); );
@@ -369,7 +369,7 @@ sub brush_get_hardness {
$help = <<'HELP'; $help = <<'HELP';
Gets the hardness of a generated brush. Gets the hardness of a generated brush.
The hardness of a brush is the amount its intensity fades at the The hardness of a brush is the amount its intensity fades at the
outside edge, as a float between 0.0 and 1.0. outside edge, as a double between 0.0 and 1.0.
Returns an error when called for a non-parametric brush. Returns an error when called for a non-parametric brush.
HELP HELP
@@ -380,7 +380,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'hardness', type => 'float', { name => 'hardness', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The hardness of the brush.' } desc => 'The hardness of the brush.' }
); );
@@ -403,7 +403,7 @@ sub brush_get_aspect_ratio {
$help = <<'HELP'; $help = <<'HELP';
Gets the aspect ratio of a generated brush. Gets the aspect ratio of a generated brush.
Returns an error when called for a non-parametric brush. Returns an error when called for a non-parametric brush.
The aspect ratio is a float between 0.0 and 1000.0. The aspect ratio is a double between 0.0 and 1000.0.
HELP HELP
&bill_pdb_misc('2004', '2.4'); &bill_pdb_misc('2004', '2.4');
@@ -413,7 +413,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'aspect_ratio', type => 'float', { name => 'aspect_ratio', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The aspect ratio of the brush.' } desc => 'The aspect ratio of the brush.' }
); );
@@ -445,7 +445,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'angle', type => 'float', { name => 'angle', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The rotation angle of the brush in degree.' } desc => 'The rotation angle of the brush in degree.' }
); );
@@ -551,12 +551,12 @@ HELP
@inargs = ( @inargs = (
${brush_arg_spec}, ${brush_arg_spec},
{ name => 'radius_in', type => 'float', { name => 'radius_in', type => 'double',
desc => 'The desired brush radius in pixel' } desc => 'The desired brush radius in pixel' }
); );
@outargs = ( @outargs = (
{ name => 'radius_out', type => 'float', { name => 'radius_out', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The brush radius actually assigned' } desc => 'The brush radius actually assigned' }
); );
@@ -637,12 +637,12 @@ HELP
@inargs = ( @inargs = (
${brush_arg_spec}, ${brush_arg_spec},
{ name => 'hardness_in', type => 'float', { name => 'hardness_in', type => 'double',
desc => 'The desired brush hardness' } desc => 'The desired brush hardness' }
); );
@outargs = ( @outargs = (
{ name => 'hardness_out', type => 'float', { name => 'hardness_out', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The brush hardness actually assigned' } desc => 'The brush hardness actually assigned' }
); );
@@ -680,12 +680,12 @@ HELP
@inargs = ( @inargs = (
${brush_arg_spec}, ${brush_arg_spec},
{ name => 'aspect_ratio_in', type => 'float', { name => 'aspect_ratio_in', type => 'double',
desc => 'The desired brush aspect ratio' } desc => 'The desired brush aspect ratio' }
); );
@outargs = ( @outargs = (
{ name => 'aspect_ratio_out', type => 'float', { name => 'aspect_ratio_out', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The brush aspect ratio actually assigned' } desc => 'The brush aspect ratio actually assigned' }
); );
@@ -723,12 +723,12 @@ HELP
@inargs = ( @inargs = (
${brush_arg_spec}, ${brush_arg_spec},
{ name => 'angle_in', type => 'float', { name => 'angle_in', type => 'double',
desc => 'The desired brush rotation angle in degrees' } desc => 'The desired brush rotation angle in degrees' }
); );
@outargs = ( @outargs = (
{ name => 'angle_out', type => 'float', { name => 'angle_out', type => 'double',
void_ret => 1, void_ret => 1,
desc => 'The brush rotation angle actually assigned' } desc => 'The brush rotation angle actually assigned' }
); );

6
pdb/groups/channel.pdb
View File

@@ -46,7 +46,7 @@ HELP
desc => 'The channel width' }, desc => 'The channel width' },
{ name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE', { name => 'height', type => '1 <= int32 <= GIMP_MAX_IMAGE_SIZE',
desc => 'The channel height' }, desc => 'The channel height' },
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The channel opacity' }, desc => 'The channel opacity' },
{ name => 'color', type => 'geglcolor', { name => 'color', type => 'geglcolor',
desc => 'The channel compositing color' desc => 'The channel compositing color'
@@ -270,7 +270,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The channel opacity' } desc => 'The channel opacity' }
); );
@@ -295,7 +295,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'channel', type => 'channel', { name => 'channel', type => 'channel',
desc => 'The channel' }, desc => 'The channel' },
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The new channel opacity' } desc => 'The new channel opacity' }
); );

84
pdb/groups/context.pdb
View File

@@ -392,7 +392,7 @@ HELP
&pdb_misc; &pdb_misc;
@outargs = ( @outargs = (
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The opacity' } desc => 'The opacity' }
); );
@@ -416,7 +416,7 @@ HELP
&pdb_misc; &pdb_misc;
@inargs = ( @inargs = (
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The opacity' } desc => 'The opacity' }
); );
@@ -492,7 +492,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@outargs = ( @outargs = (
{ name => 'line_width', type => '0.0 <= float <= 2000.0', { name => 'line_width', type => '0.0 <= double <= 2000.0',
desc => 'The line width setting' } desc => 'The line width setting' }
); );
@@ -524,7 +524,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@inargs = ( @inargs = (
{ name => 'line_width', type => '0.0 <= float <= 2000.0', { name => 'line_width', type => '0.0 <= double <= 2000.0',
desc => 'The line width setting' } desc => 'The line width setting' }
); );
@@ -731,7 +731,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@outargs = ( @outargs = (
{ name => 'miter_limit', type => '0.0 <= float <= 100.0', { name => 'miter_limit', type => '0.0 <= double <= 100.0',
desc => 'The line miter limit setting' } desc => 'The line miter limit setting' }
); );
@@ -767,7 +767,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@inargs = ( @inargs = (
{ name => 'miter_limit', type => '0.0 <= float <= 100.0', { name => 'miter_limit', type => '0.0 <= double <= 100.0',
desc => 'The line miter limit setting' } desc => 'The line miter limit setting' }
); );
@@ -795,7 +795,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@outargs = ( @outargs = (
{ name => 'dash_offset', type => '0.0 <= float <= 2000.0', { name => 'dash_offset', type => '0.0 <= double <= 2000.0',
desc => 'The line dash offset setting' } desc => 'The line dash offset setting' }
); );
@@ -827,7 +827,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@inargs = ( @inargs = (
{ name => 'dash_offset', type => '0.0 <= float <= 100.0', { name => 'dash_offset', type => '0.0 <= double <= 100.0',
desc => 'The line dash offset setting' } desc => 'The line dash offset setting' }
); );
@@ -855,7 +855,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@outargs = ( @outargs = (
{ name => 'dashes', type => 'floatarray', void_ret => 1, { name => 'dashes', type => 'doublearray', void_ret => 1,
desc => 'The line dash pattern setting', desc => 'The line dash pattern setting',
array => { desc => 'The number of dashes in the dash_pattern array' } } array => { desc => 'The number of dashes in the dash_pattern array' } }
); );
@@ -893,7 +893,7 @@ HELP
&mitch_pdb_misc('2015', '2.10'); &mitch_pdb_misc('2015', '2.10');
@inargs = ( @inargs = (
{ name => 'dashes', type => 'floatarray', { name => 'dashes', type => 'doublearray',
desc => 'The line dash pattern setting', desc => 'The line dash pattern setting',
array => { desc => 'The number of dashes in the dash_pattern array' } } array => { desc => 'The number of dashes in the dash_pattern array' } }
); );
@@ -980,7 +980,7 @@ sub context_get_brush_size {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "size", type => "0 < float", { name => "size", type => "0 < double",
desc => "Brush size in pixels" } desc => "Brush size in pixels" }
); );
@@ -1010,7 +1010,7 @@ sub context_set_brush_size {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "size", type => "1 <= float <= 10000", { name => "size", type => "1 <= double <= 10000",
desc => "Brush size in pixels" } desc => "Brush size in pixels" }
); );
@@ -1075,7 +1075,7 @@ sub context_set_brush_aspect_ratio {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "aspect", type => "-20 <= float <= 20", { name => "aspect", type => "-20 <= double <= 20",
desc => "Aspect ratio" } desc => "Aspect ratio" }
); );
@@ -1105,7 +1105,7 @@ sub context_get_brush_aspect_ratio {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "aspect", type => "-20 <= float <= 20", { name => "aspect", type => "-20 <= double <= 20",
desc => "Aspect ratio" } desc => "Aspect ratio" }
); );
@@ -1135,7 +1135,7 @@ sub context_set_brush_angle {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "angle", type => "-180 <= float <= 180", { name => "angle", type => "-180 <= double <= 180",
desc => "Angle in degrees" } desc => "Angle in degrees" }
); );
@@ -1165,7 +1165,7 @@ sub context_get_brush_angle {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "angle", type => "-180 <= float <= 180", { name => "angle", type => "-180 <= double <= 180",
desc => "Angle in degrees" } desc => "Angle in degrees" }
); );
@@ -1195,7 +1195,7 @@ sub context_get_brush_spacing {
&adeath_pdb_misc('2014', '2.10'); &adeath_pdb_misc('2014', '2.10');
@outargs = ( @outargs = (
{ name => "spacing", type => "0.01 <= float <= 50.0", { name => "spacing", type => "0.01 <= double <= 50.0",
desc => "Brush spacing as fraction of size" } desc => "Brush spacing as fraction of size" }
); );
@@ -1225,7 +1225,7 @@ sub context_set_brush_spacing {
&adeath_pdb_misc('2014', '2.10'); &adeath_pdb_misc('2014', '2.10');
@inargs = ( @inargs = (
{ name => "spacing", type => "0.01 <= float <= 50.0", { name => "spacing", type => "0.01 <= double <= 50.0",
desc => "Brush spacing as fraction of size" } desc => "Brush spacing as fraction of size" }
); );
@@ -1290,7 +1290,7 @@ sub context_get_brush_hardness {
&adeath_pdb_misc('2014', '2.10'); &adeath_pdb_misc('2014', '2.10');
@outargs = ( @outargs = (
{ name => "hardness", type => "0.0 <= float <= 1.0", { name => "hardness", type => "0.0 <= double <= 1.0",
desc => "Brush hardness" } desc => "Brush hardness" }
); );
@@ -1320,7 +1320,7 @@ sub context_set_brush_hardness {
&adeath_pdb_misc('2014', '2.10'); &adeath_pdb_misc('2014', '2.10');
@inargs = ( @inargs = (
{ name => "hardness", type => "0.0 <= float <= 1.0", { name => "hardness", type => "0.0 <= double <= 1.0",
desc => "Brush hardness" } desc => "Brush hardness" }
); );
@@ -1385,7 +1385,7 @@ sub context_get_brush_force {
&adeath_pdb_misc('2014', '2.10'); &adeath_pdb_misc('2014', '2.10');
@outargs = ( @outargs = (
{ name => "force", type => "0.0 <= float <= 1.0", { name => "force", type => "0.0 <= double <= 1.0",
desc => "Brush application force" } desc => "Brush application force" }
); );
@@ -1415,7 +1415,7 @@ sub context_set_brush_force {
&adeath_pdb_misc('2014', '2.10'); &adeath_pdb_misc('2014', '2.10');
@inargs = ( @inargs = (
{ name => "force", type => "0.0 <= float <= 1.0", { name => "force", type => "0.0 <= double <= 1.0",
desc => "Brush application force" } desc => "Brush application force" }
); );
@@ -2293,9 +2293,9 @@ HELP
&mitch_pdb_misc('2010', '2.8'); &mitch_pdb_misc('2010', '2.8');
@outargs = ( @outargs = (
{ name => 'feather_radius_x', type => '0 <= float <= 1000', void_ret => 1, { name => 'feather_radius_x', type => '0 <= double <= 1000', void_ret => 1,
desc => 'The horizontal feather radius' }, desc => 'The horizontal feather radius' },
{ name => 'feather_radius_y', type => '0 <= float <= 1000', { name => 'feather_radius_y', type => '0 <= double <= 1000',
desc => 'The vertical feather radius' } desc => 'The vertical feather radius' }
); );
@@ -2325,9 +2325,9 @@ HELP
&mitch_pdb_misc('2010', '2.8'); &mitch_pdb_misc('2010', '2.8');
@inargs = ( @inargs = (
{ name => 'feather_radius_x', type => '0 <= float <= 1000', { name => 'feather_radius_x', type => '0 <= double <= 1000',
desc => 'The horizontal feather radius' }, desc => 'The horizontal feather radius' },
{ name => 'feather_radius_y', type => '0 <= float <= 1000', { name => 'feather_radius_y', type => '0 <= double <= 1000',
desc => 'The vertical feather radius' } desc => 'The vertical feather radius' }
); );
@@ -2471,7 +2471,7 @@ HELP
&mitch_pdb_misc('2011', '2.8'); &mitch_pdb_misc('2011', '2.8');
@outargs = ( @outargs = (
{ name => 'sample_threshold', type => '0.0 <= float <= 1.0', { name => 'sample_threshold', type => '0.0 <= double <= 1.0',
desc => 'The sample threshold setting' } desc => 'The sample threshold setting' }
); );
@@ -2505,7 +2505,7 @@ HELP
&mitch_pdb_misc('2011', '2.8'); &mitch_pdb_misc('2011', '2.8');
@inargs = ( @inargs = (
{ name => 'sample_threshold', type => '0.0 <= float <= 1.0', { name => 'sample_threshold', type => '0.0 <= double <= 1.0',
desc => 'The sample threshold setting' } desc => 'The sample threshold setting' }
); );
@@ -2948,7 +2948,7 @@ sub context_get_ink_size {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "size", type => "0 <= float <= 200", { name => "size", type => "0 <= double <= 200",
desc => "ink blob size in pixels" } desc => "ink blob size in pixels" }
); );
@@ -2978,7 +2978,7 @@ sub context_set_ink_size {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "size", type => "0 <= float <= 200", { name => "size", type => "0 <= double <= 200",
desc => "ink blob size in pixels" } desc => "ink blob size in pixels" }
); );
@@ -3008,7 +3008,7 @@ sub context_get_ink_angle {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "angle", type => "-90 <= float <= 90", { name => "angle", type => "-90 <= double <= 90",
desc => "ink angle in degrees" } desc => "ink angle in degrees" }
); );
@@ -3038,7 +3038,7 @@ sub context_set_ink_angle {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "angle", type => "-90 <= float <= 90", { name => "angle", type => "-90 <= double <= 90",
desc => "ink angle in degrees" } desc => "ink angle in degrees" }
); );
@@ -3068,7 +3068,7 @@ sub context_get_ink_size_sensitivity {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "size", type => "0 <= float <= 1", { name => "size", type => "0 <= double <= 1",
desc => "ink size sensitivity" } desc => "ink size sensitivity" }
); );
@@ -3098,7 +3098,7 @@ sub context_set_ink_size_sensitivity {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "size", type => "0 <= float <= 1", { name => "size", type => "0 <= double <= 1",
desc => "ink size sensitivity" } desc => "ink size sensitivity" }
); );
@@ -3128,7 +3128,7 @@ sub context_get_ink_tilt_sensitivity {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "tilt", type => "0 <= float <= 1", { name => "tilt", type => "0 <= double <= 1",
desc => "ink tilt sensitivity" } desc => "ink tilt sensitivity" }
); );
@@ -3158,7 +3158,7 @@ sub context_set_ink_tilt_sensitivity {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "tilt", type => "0 <= float <= 1", { name => "tilt", type => "0 <= double <= 1",
desc => "ink tilt sensitivity" } desc => "ink tilt sensitivity" }
); );
@@ -3188,7 +3188,7 @@ sub context_get_ink_speed_sensitivity {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "speed", type => "0 <= float <= 1", { name => "speed", type => "0 <= double <= 1",
desc => "ink speed sensitivity" } desc => "ink speed sensitivity" }
); );
@@ -3218,7 +3218,7 @@ sub context_set_ink_speed_sensitivity {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "speed", type => "0 <= float <= 1", { name => "speed", type => "0 <= double <= 1",
desc => "ink speed sensitivity" } desc => "ink speed sensitivity" }
); );
@@ -3308,7 +3308,7 @@ sub context_get_ink_blob_aspect_ratio {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "aspect", type => "1 <= float <= 10", { name => "aspect", type => "1 <= double <= 10",
desc => "ink blob aspect ratio" } desc => "ink blob aspect ratio" }
); );
@@ -3338,7 +3338,7 @@ sub context_set_ink_blob_aspect_ratio {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "aspect", type => "1 <= float <= 10", { name => "aspect", type => "1 <= double <= 10",
desc => "ink blob aspect ratio" } desc => "ink blob aspect ratio" }
); );
@@ -3368,7 +3368,7 @@ sub context_get_ink_blob_angle {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@outargs = ( @outargs = (
{ name => "angle", type => "-180 <= float <= 180", { name => "angle", type => "-180 <= double <= 180",
desc => "ink blob angle in degrees" } desc => "ink blob angle in degrees" }
); );
@@ -3401,7 +3401,7 @@ sub context_set_ink_blob_angle {
&ejs_pdb_misc('2012', '2.8'); &ejs_pdb_misc('2012', '2.8');
@inargs = ( @inargs = (
{ name => "angle", type => "-180 <= float <= 180", { name => "angle", type => "-180 <= double <= 180",
desc => "ink blob angle in degrees" } desc => "ink blob angle in degrees" }
); );

2
pdb/groups/debug.pdb
View File

@@ -58,7 +58,7 @@ HELP
&std_pdb_debug(); &std_pdb_debug();
@outargs = ( @outargs = (
{ name => 'elapsed', type => 'float', { name => 'elapsed', type => 'double',
desc => 'The elapsed time, in seconds' } desc => 'The elapsed time, in seconds' }
); );

72
pdb/groups/drawable_color.pdb
View File

@@ -32,9 +32,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'brightness', type => '-1.0 <= float <= 1.0', { name => 'brightness', type => '-1.0 <= double <= 1.0',
desc => 'Brightness adjustment' }, desc => 'Brightness adjustment' },
{ name => 'contrast', type => '-1.0 <= float <= 1.0', { name => 'contrast', type => '-1.0 <= double <= 1.0',
desc => 'Contrast adjustment' } desc => 'Contrast adjustment' }
); );
@@ -88,11 +88,11 @@ HELP
desc => 'Transfer mode' }, desc => 'Transfer mode' },
{ name => 'preserve_lum', type => 'boolean', { name => 'preserve_lum', type => 'boolean',
desc => 'Preserve luminosity values at each pixel' }, desc => 'Preserve luminosity values at each pixel' },
{ name => 'cyan_red', type => '-100 <= float <= 100', { name => 'cyan_red', type => '-100 <= double <= 100',
desc => 'Cyan-Red color balance' }, desc => 'Cyan-Red color balance' },
{ name => 'magenta_green', type => '-100 <= float <= 100', { name => 'magenta_green', type => '-100 <= double <= 100',
desc => 'Magenta-Green color balance' }, desc => 'Magenta-Green color balance' },
{ name => 'yellow_blue', type => '-100 <= float <= 100', { name => 'yellow_blue', type => '-100 <= double <= 100',
desc => 'Yellow-Blue color balance' } desc => 'Yellow-Blue color balance' }
); );
@@ -141,11 +141,11 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'hue', type => '0 <= float <= 360', { name => 'hue', type => '0 <= double <= 360',
desc => 'Hue in degrees' }, desc => 'Hue in degrees' },
{ name => 'saturation', type => '0 <= float <= 100', { name => 'saturation', type => '0 <= double <= 100',
desc => 'Saturation in percent' }, desc => 'Saturation in percent' },
{ name => 'lightness', type => '-100 <= float <= 100', { name => 'lightness', type => '-100 <= double <= 100',
desc => 'Lightness in percent' } desc => 'Lightness in percent' }
); );
@@ -197,7 +197,7 @@ HELP
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel', { name => 'channel', type => 'enum GimpHistogramChannel',
desc => 'The channel to modify' }, desc => 'The channel to modify' },
{ name => 'values', type => 'floatarray', { name => 'values', type => 'doublearray',
desc => 'The explicit curve', desc => 'The explicit curve',
array => { name => 'num_values', type => '256 <= size <= 2096', array => { name => 'num_values', type => '256 <= size <= 2096',
desc => 'The number of values in the new curve' } } desc => 'The number of values in the new curve' } }
@@ -254,7 +254,7 @@ HELP
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel', { name => 'channel', type => 'enum GimpHistogramChannel',
desc => 'The channel to modify' }, desc => 'The channel to modify' },
{ name => 'points', type => 'floatarray', { name => 'points', type => 'doublearray',
desc => 'The spline control points: { cp1.x, cp1.y, cp2.x, cp2.y, desc => 'The spline control points: { cp1.x, cp1.y, cp2.x, cp2.y,
... }', ... }',
array => { name => 'num_points', type => '4 <= size <= 2048', array => { name => 'num_points', type => '4 <= size <= 2048',
@@ -462,24 +462,24 @@ HELP
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel', { name => 'channel', type => 'enum GimpHistogramChannel',
desc => 'The channel to query' }, desc => 'The channel to query' },
{ name => 'start_range', type => '0.0 <= float <= 1.0', { name => 'start_range', type => '0.0 <= double <= 1.0',
desc => 'Start of the intensity measurement range' }, desc => 'Start of the intensity measurement range' },
{ name => 'end_range', type => '0.0 <= float <= 1.0', { name => 'end_range', type => '0.0 <= double <= 1.0',
desc => 'End of the intensity measurement range' } desc => 'End of the intensity measurement range' }
); );
@outargs = ( @outargs = (
{ name => 'mean', type => 'float', void_ret => 1, { name => 'mean', type => 'double', void_ret => 1,
desc => 'Mean intensity value' }, desc => 'Mean intensity value' },
{ name => 'std_dev', type => 'float', { name => 'std_dev', type => 'double',
desc => 'Standard deviation of intensity values' }, desc => 'Standard deviation of intensity values' },
{ name => 'median', type => 'float', { name => 'median', type => 'double',
desc => 'Median intensity value' }, desc => 'Median intensity value' },
{ name => 'pixels', type => 'float', { name => 'pixels', type => 'double',
desc => 'Alpha-weighted pixel count for entire image' }, desc => 'Alpha-weighted pixel count for entire image' },
{ name => 'count', type => 'float', { name => 'count', type => 'double',
desc => 'Alpha-weighted pixel count for range' }, desc => 'Alpha-weighted pixel count for range' },
{ name => 'percentile', type => 'float', { name => 'percentile', type => 'double',
desc => 'Percentile that range falls under' } desc => 'Percentile that range falls under' }
); );
@@ -558,13 +558,13 @@ HELP
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'hue_range', type => 'enum GimpHueRange', { name => 'hue_range', type => 'enum GimpHueRange',
desc => 'Range of affected hues' }, desc => 'Range of affected hues' },
{ name => 'hue_offset', type => '-180 <= float <= 180', { name => 'hue_offset', type => '-180 <= double <= 180',
desc => 'Hue offset in degrees' }, desc => 'Hue offset in degrees' },
{ name => 'lightness', type => '-100 <= float <= 100', { name => 'lightness', type => '-100 <= double <= 100',
desc => 'Lightness modification' }, desc => 'Lightness modification' },
{ name => 'saturation', type => '-100 <= float <= 100', { name => 'saturation', type => '-100 <= double <= 100',
desc => 'Saturation modification' }, desc => 'Saturation modification' },
{ name => 'overlap', type => '0 <= float <= 100', { name => 'overlap', type => '0 <= double <= 100',
desc => 'Overlap other hue channels' } desc => 'Overlap other hue channels' }
); );
@@ -665,17 +665,17 @@ HELP
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel', { name => 'channel', type => 'enum GimpHistogramChannel',
desc => 'The channel to modify' }, desc => 'The channel to modify' },
{ name => 'low_input', type => '0.0 <= float <= 1.0', { name => 'low_input', type => '0.0 <= double <= 1.0',
desc => "Intensity of lowest input" }, desc => "Intensity of lowest input" },
{ name => 'high_input', type => '0.0 <= float <= 1.0', { name => 'high_input', type => '0.0 <= double <= 1.0',
desc => "Intensity of highest input" }, desc => "Intensity of highest input" },
{ name => 'clamp_input', type => 'boolean', { name => 'clamp_input', type => 'boolean',
desc => 'Clamp input values before applying output levels' }, desc => 'Clamp input values before applying output levels' },
{ name => 'gamma', type => '0.1 <= float <= 10', { name => 'gamma', type => '0.1 <= double <= 10',
desc => 'Gamma adjustment factor' }, desc => 'Gamma adjustment factor' },
{ name => 'low_output', type => '0.0 <= float <= 1.0', { name => 'low_output', type => '0.0 <= double <= 1.0',
desc => "Intensity of lowest output" }, desc => "Intensity of lowest output" },
{ name => 'high_output', type => '0.0 <= float <= 1.0', { name => 'high_output', type => '0.0 <= double <= 1.0',
desc => "Intensity of highest output" }, desc => "Intensity of highest output" },
{ name => 'clamp_output', type => 'boolean', { name => 'clamp_output', type => 'boolean',
desc => 'Clamp final output values' }, desc => 'Clamp final output values' },
@@ -771,19 +771,19 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'shadows', type => '-100 <= float <= 100', { name => 'shadows', type => '-100 <= double <= 100',
desc => 'Adjust exposure of shadows' }, desc => 'Adjust exposure of shadows' },
{ name => 'highlights', type => '-100 <= float <= 100', { name => 'highlights', type => '-100 <= double <= 100',
desc => 'Adjust exposure of highlights' }, desc => 'Adjust exposure of highlights' },
{ name => 'whitepoint', type => '-10 <= float <= 10', { name => 'whitepoint', type => '-10 <= double <= 10',
desc => 'Shift white point' }, desc => 'Shift white point' },
{ name => 'radius', type => '0.1 <= float <= 1500', { name => 'radius', type => '0.1 <= double <= 1500',
desc => 'Spatial extent' }, desc => 'Spatial extent' },
{ name => 'compress', type => '0 <= float <= 100', { name => 'compress', type => '0 <= double <= 100',
desc => 'Compress the effect on shadows/highlights and preserve midtones' }, desc => 'Compress the effect on shadows/highlights and preserve midtones' },
{ name => 'shadows_ccorrect', type => '0 <= float <= 100', { name => 'shadows_ccorrect', type => '0 <= double <= 100',
desc => 'Adjust saturation of shadows' }, desc => 'Adjust saturation of shadows' },
{ name => 'highlights_ccorrect', type => '0 <= float <= 100', { name => 'highlights_ccorrect', type => '0 <= double <= 100',
desc => 'Adjust saturation of highlights' }, desc => 'Adjust saturation of highlights' },
); );
@@ -881,9 +881,9 @@ HELP
desc => 'The drawable' }, desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel', { name => 'channel', type => 'enum GimpHistogramChannel',
desc => 'The channel to base the threshold on' }, desc => 'The channel to base the threshold on' },
{ name => 'low_threshold', type => '0.0 <= float <= 1.0', { name => 'low_threshold', type => '0.0 <= double <= 1.0',
desc => 'The low threshold value' }, desc => 'The low threshold value' },
{ name => 'high_threshold', type => '0.0 <= float <= 1.0', { name => 'high_threshold', type => '0.0 <= double <= 1.0',
desc => 'The high threshold value' } desc => 'The high threshold value' }
); );

16
pdb/groups/drawable_edit.pdb
View File

@@ -142,9 +142,9 @@ HELP
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'fill_type', type => 'enum GimpFillType', { name => 'fill_type', type => 'enum GimpFillType',
desc => 'The type of fill' }, desc => 'The type of fill' },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => "The x coordinate of this bucket fill's application." }, desc => "The x coordinate of this bucket fill's application." },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => "The y coordinate of this bucket fill's application." } desc => "The y coordinate of this bucket fill's application." }
); );
@@ -217,7 +217,7 @@ HELP
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'gradient_type', type => 'enum GimpGradientType', { name => 'gradient_type', type => 'enum GimpGradientType',
desc => 'The type of gradient' }, desc => 'The type of gradient' },
{ name => 'offset', type => '0 <= float', { name => 'offset', type => '0 <= double',
desc => 'Offset relates to the starting and ending coordinates desc => 'Offset relates to the starting and ending coordinates
specified for the blend. This parameter is mode dependent.' }, specified for the blend. This parameter is mode dependent.' },
{ name => 'supersample', type => 'boolean', { name => 'supersample', type => 'boolean',
@@ -225,18 +225,18 @@ HELP
{ name => 'supersample_max_depth', type => '1 <= int32 <= 9', { name => 'supersample_max_depth', type => '1 <= int32 <= 9',
no_validate => 1, no_validate => 1,
desc => 'Maximum recursion levels for supersampling' }, desc => 'Maximum recursion levels for supersampling' },
{ name => 'supersample_threshold', type => '0 <= float <= 4', { name => 'supersample_threshold', type => '0 <= double <= 4',
no_validate => 1, no_validate => 1,
desc => 'Supersampling threshold' }, desc => 'Supersampling threshold' },
{ name => 'dither', type => 'boolean', { name => 'dither', type => 'boolean',
desc => 'Use dithering to reduce banding' }, desc => 'Use dithering to reduce banding' },
{ name => 'x1', type => 'float', { name => 'x1', type => 'double',
desc => "The x coordinate of this gradient's starting point" }, desc => "The x coordinate of this gradient's starting point" },
{ name => 'y1', type => 'float', { name => 'y1', type => 'double',
desc => "The y coordinate of this gradient's starting point" }, desc => "The y coordinate of this gradient's starting point" },
{ name => 'x2', type => 'float', { name => 'x2', type => 'double',
desc => "The x coordinate of this gradient's ending point" }, desc => "The x coordinate of this gradient's ending point" },
{ name => 'y2', type => 'float', { name => 'y2', type => 'double',
desc => "The y coordinate of this gradient's ending point" } desc => "The y coordinate of this gradient's ending point" }
); );

4
pdb/groups/gimprc.pdb
View File

@@ -110,9 +110,9 @@ HELP
&std_pdb_misc; &std_pdb_misc;
@outargs = ( @outargs = (
{ name => 'xres', type => 'float', void_ret => 1, { name => 'xres', type => 'double', void_ret => 1,
desc => 'X resolution' }, desc => 'X resolution' },
{ name => 'yres', type => 'float', { name => 'yres', type => 'double',
desc => 'Y resolution' }, desc => 'Y resolution' },
); );

29
pdb/groups/gradient.pdb
View File

@@ -155,7 +155,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'color_samples', type => 'floatarray', void_ret => 1, { name => 'color_samples', type => 'doublearray', void_ret => 1,
desc => 'Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }', desc => 'Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }',
array => { desc => 'Length of the color_samples array (4 * array => { desc => 'Length of the color_samples array (4 *
num_samples)' } } num_samples)' } }
@@ -183,7 +183,6 @@ HELP
pos, reverse, pos, reverse,
GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
&color); &color);
/* XXX "float" in PDB are in fact double. */
if (color) if (color)
gegl_color_get_pixel (color, babl_format ("R'G'B'A double"), sample); gegl_color_get_pixel (color, babl_format ("R'G'B'A double"), sample);
/* TODO: should we really return a list of floats? What about a list /* TODO: should we really return a list of floats? What about a list
@@ -217,7 +216,7 @@ HELP
@inargs = ( @inargs = (
${gradient_arg_spec}, ${gradient_arg_spec},
{ name => 'positions', type => 'floatarray', { name => 'positions', type => 'doublearray',
desc => 'The list of positions to sample along the gradient', desc => 'The list of positions to sample along the gradient',
array => { name => 'num_samples', type => '1 <= size', array => { name => 'num_samples', type => '1 <= size',
desc => 'The number of samples to take' } }, desc => 'The number of samples to take' } },
@@ -226,7 +225,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'color_samples', type => 'floatarray', void_ret => 1, { name => 'color_samples', type => 'doublearray', void_ret => 1,
desc => 'Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }', desc => 'Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }',
array => { desc => 'Length of the color_samples array (4 * array => { desc => 'Length of the color_samples array (4 *
num_samples)' } } num_samples)' } }
@@ -436,7 +435,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'pos', type => 'float', void_ret => 1, { name => 'pos', type => 'double', void_ret => 1,
desc => 'The return position' } desc => 'The return position' }
); );
@@ -470,7 +469,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'pos', type => 'float', void_ret => 1, { name => 'pos', type => 'double', void_ret => 1,
desc => 'The return position' } desc => 'The return position' }
); );
@@ -504,7 +503,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'pos', type => 'float', void_ret => 1, { name => 'pos', type => 'double', void_ret => 1,
desc => 'The return position' } desc => 'The return position' }
); );
@@ -538,12 +537,12 @@ HELP
@inargs = ( @inargs = (
${gradient_arg_spec}, ${gradient_arg_spec},
${gradient_seg_arg_spec}, ${gradient_seg_arg_spec},
{ name => 'pos', type => '0.0 <= float <= 1.0', { name => 'pos', type => '0.0 <= double <= 1.0',
desc => 'The position to set the guidepoint to' } desc => 'The position to set the guidepoint to' }
); );
@outargs = ( @outargs = (
{ name => 'final_pos', type => 'float', void_ret => 1, { name => 'final_pos', type => 'double', void_ret => 1,
desc => 'The return position' } desc => 'The return position' }
); );
@@ -585,12 +584,12 @@ HELP
@inargs = ( @inargs = (
${gradient_arg_spec}, ${gradient_arg_spec},
${gradient_seg_arg_spec}, ${gradient_seg_arg_spec},
{ name => 'pos', type => '0.0 <= float <= 1.0', { name => 'pos', type => '0.0 <= double <= 1.0',
desc => 'The position to set the right endpoint to' } desc => 'The position to set the right endpoint to' }
); );
@outargs = ( @outargs = (
{ name => 'final_pos', type => 'float', void_ret => 1, { name => 'final_pos', type => 'double', void_ret => 1,
desc => 'The return position' } desc => 'The return position' }
); );
@@ -631,12 +630,12 @@ HELP
@inargs = ( @inargs = (
${gradient_arg_spec}, ${gradient_arg_spec},
${gradient_seg_arg_spec}, ${gradient_seg_arg_spec},
{ name => 'pos', type => '0.0 <= float <= 1.0', { name => 'pos', type => '0.0 <= double <= 1.0',
desc => 'The position to set the guidepoint to' } desc => 'The position to set the guidepoint to' }
); );
@outargs = ( @outargs = (
{ name => 'final_pos', type => 'float', void_ret => 1, { name => 'final_pos', type => 'double', void_ret => 1,
desc => 'The return position' } desc => 'The return position' }
); );
@@ -1197,14 +1196,14 @@ HELP
${gradient_arg_spec}, ${gradient_arg_spec},
${gradient_start_segment_arg_spec}, ${gradient_start_segment_arg_spec},
${gradient_end_segment_arg_spec}, ${gradient_end_segment_arg_spec},
{ name => 'delta', type => '-1.0 <= float <= 1.0', { name => 'delta', type => '-1.0 <= double <= 1.0',
desc => 'The delta to move the segment range' }, desc => 'The delta to move the segment range' },
{ name => 'control_compress', type => 'boolean', { name => 'control_compress', type => 'boolean',
desc => 'Whether or not to compress the neighboring segments' } desc => 'Whether or not to compress the neighboring segments' }
); );
@outargs = ( @outargs = (
{ name => 'final_delta', type => 'float', { name => 'final_delta', type => 'double',
desc => 'The final delta by which the range moved' } desc => 'The final delta by which the range moved' }
); );

14
pdb/groups/image.pdb
View File

@@ -408,16 +408,16 @@ HELP
desc => 'The image' }, desc => 'The image' },
{ name => 'drawables', type => 'drawablearray', { name => 'drawables', type => 'drawablearray',
desc => 'The drawables to pick from' }, desc => 'The drawables to pick from' },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => 'x coordinate of upper-left corner of rectangle' }, desc => 'x coordinate of upper-left corner of rectangle' },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => 'y coordinate of upper-left corner of rectangle' }, desc => 'y coordinate of upper-left corner of rectangle' },
{ name => 'sample_merged', type => 'boolean', { name => 'sample_merged', type => 'boolean',
desc => 'Use the composite image, not the drawables' }, desc => 'Use the composite image, not the drawables' },
{ name => 'sample_average', type => 'boolean', { name => 'sample_average', type => 'boolean',
desc => 'Average the color of all the pixels in a specified desc => 'Average the color of all the pixels in a specified
radius' }, radius' },
{ name => 'average_radius', type => '0 < float', no_validate => 1, { name => 'average_radius', type => '0 < double', no_validate => 1,
desc => 'The radius of pixels to average' } desc => 'The radius of pixels to average' }
); );
@@ -2608,9 +2608,9 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'xresolution', type => 'float', void_ret => 1, { name => 'xresolution', type => 'double', void_ret => 1,
desc => 'The resolution in the x-axis, in dots per inch' }, desc => 'The resolution in the x-axis, in dots per inch' },
{ name => 'yresolution', type => 'float', { name => 'yresolution', type => 'double',
desc => 'The resolution in the y-axis, in dots per inch' } desc => 'The resolution in the y-axis, in dots per inch' }
); );
@@ -2637,9 +2637,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'image', type => 'image', { name => 'image', type => 'image',
desc => 'The image' }, desc => 'The image' },
{ name => 'xresolution', type => 'float', { name => 'xresolution', type => 'double',
desc => 'The new image resolution in the x-axis, in dots per inch' }, desc => 'The new image resolution in the x-axis, in dots per inch' },
{ name => 'yresolution', type => 'float', { name => 'yresolution', type => 'double',
desc => 'The new image resolution in the y-axis, in dots per inch' } desc => 'The new image resolution in the y-axis, in dots per inch' }
); );

16
pdb/groups/image_grid.pdb
View File

@@ -30,9 +30,9 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'xspacing', type => 'float', void_ret => 1, { name => 'xspacing', type => 'double', void_ret => 1,
desc => "The image's grid horizontal spacing" }, desc => "The image's grid horizontal spacing" },
{ name => 'yspacing', type => 'float', void_ret => 1, { name => 'yspacing', type => 'double', void_ret => 1,
desc => "The image's grid vertical spacing" } desc => "The image's grid vertical spacing" }
); );
@@ -65,9 +65,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'image', type => 'image', { name => 'image', type => 'image',
desc => 'The image' }, desc => 'The image' },
{ name => 'xspacing', type => 'float', { name => 'xspacing', type => 'double',
desc => "The image's grid horizontal spacing" }, desc => "The image's grid horizontal spacing" },
{ name => 'yspacing', type => 'float', { name => 'yspacing', type => 'double',
desc => "The image's grid vertical spacing" } desc => "The image's grid vertical spacing" }
); );
@@ -104,9 +104,9 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'xoffset', type => 'float', void_ret => 1, { name => 'xoffset', type => 'double', void_ret => 1,
desc => "The image's grid horizontal offset" }, desc => "The image's grid horizontal offset" },
{ name => 'yoffset', type => 'float', void_ret => 1, { name => 'yoffset', type => 'double', void_ret => 1,
desc => "The image's grid vertical offset" } desc => "The image's grid vertical offset" }
); );
@@ -139,9 +139,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'image', type => 'image', { name => 'image', type => 'image',
desc => 'The image' }, desc => 'The image' },
{ name => 'xoffset', type => 'float', { name => 'xoffset', type => 'double',
desc => "The image's grid horizontal offset" }, desc => "The image's grid horizontal offset" },
{ name => 'yoffset', type => 'float', { name => 'yoffset', type => 'double',
desc => "The image's grid vertical offset" } desc => "The image's grid vertical offset" }
); );

34
pdb/groups/image_select.pdb
View File

@@ -125,10 +125,10 @@ HELP
desc => 'The selection operation' }, desc => 'The selection operation' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => 'x coordinate of initial seed fill point: (image desc => 'x coordinate of initial seed fill point: (image
coordinates)' }, coordinates)' },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => 'y coordinate of initial seed fill point: (image desc => 'y coordinate of initial seed fill point: (image
coordinates)' } coordinates)' }
); );
@@ -184,13 +184,13 @@ HELP
desc => 'The image' }, desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps', { name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' }, desc => 'The selection operation' },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => 'x coordinate of upper-left corner of rectangle' }, desc => 'x coordinate of upper-left corner of rectangle' },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => 'y coordinate of upper-left corner of rectangle' }, desc => 'y coordinate of upper-left corner of rectangle' },
{ name => 'width', type => '0 < float', { name => 'width', type => '0 < double',
desc => 'The width of the rectangle' }, desc => 'The width of the rectangle' },
{ name => 'height', type => '0 < float', { name => 'height', type => '0 < double',
desc => 'The height of the rectangle' } desc => 'The height of the rectangle' }
); );
@@ -235,17 +235,17 @@ HELP
desc => 'The image' }, desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps', { name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' }, desc => 'The selection operation' },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => 'x coordinate of upper-left corner of rectangle' }, desc => 'x coordinate of upper-left corner of rectangle' },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => 'y coordinate of upper-left corner of rectangle' }, desc => 'y coordinate of upper-left corner of rectangle' },
{ name => 'width', type => '0 < float', { name => 'width', type => '0 < double',
desc => 'The width of the rectangle' }, desc => 'The width of the rectangle' },
{ name => 'height', type => '0 < float', { name => 'height', type => '0 < double',
desc => 'The height of the rectangle' }, desc => 'The height of the rectangle' },
{ name => 'corner_radius_x', type => '0 < float < GIMP_MAX_IMAGE_SIZE', { name => 'corner_radius_x', type => '0 < double < GIMP_MAX_IMAGE_SIZE',
desc => 'The corner radius in X direction' }, desc => 'The corner radius in X direction' },
{ name => 'corner_radius_y', type => '0 < float < GIMP_MAX_IMAGE_SIZE', { name => 'corner_radius_y', type => '0 < double < GIMP_MAX_IMAGE_SIZE',
desc => 'The corner radius in Y direction' } desc => 'The corner radius in Y direction' }
); );
@@ -292,13 +292,13 @@ HELP
desc => 'The image' }, desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps', { name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' }, desc => 'The selection operation' },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => 'x coordinate of upper-left corner of ellipse bounding box' }, desc => 'x coordinate of upper-left corner of ellipse bounding box' },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => 'y coordinate of upper-left corner of ellipse bounding box' }, desc => 'y coordinate of upper-left corner of ellipse bounding box' },
{ name => 'width', type => '0 < float', { name => 'width', type => '0 < double',
desc => 'The width of the ellipse' }, desc => 'The width of the ellipse' },
{ name => 'height', type => '0 < float', { name => 'height', type => '0 < double',
desc => 'The height of the ellipse' } desc => 'The height of the ellipse' }
); );
@@ -348,7 +348,7 @@ HELP
desc => 'The image' }, desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps', { name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' }, desc => 'The selection operation' },
{ name => 'segs', type => 'floatarray', { name => 'segs', type => 'doublearray',
desc => 'Array of points: { p1.x, p1.y, p2.x, p2.y, ..., desc => 'Array of points: { p1.x, p1.y, p2.x, p2.y, ...,
pn.x, pn.y}', pn.x, pn.y}',
array => { type => '2 <= size', array => { type => '2 <= size',

82
pdb/groups/item_transform.pdb
View File

@@ -117,9 +117,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The item' }, desc => 'The item' },
{ name => 'off_x', type => 'float', { name => 'off_x', type => 'double',
desc => "Offset in x direction" }, desc => "Offset in x direction" },
{ name => 'off_y', type => 'float', { name => 'off_y', type => 'double',
desc => "Offset in y direction" } desc => "Offset in y direction" }
); );
@@ -178,7 +178,7 @@ HELP
desc => 'Type of flip' }, desc => 'Type of flip' },
{ name => 'auto_center', type => 'boolean', { name => 'auto_center', type => 'boolean',
desc => 'Whether to automatically position the axis in the selection center' }, desc => 'Whether to automatically position the axis in the selection center' },
{ name => 'axis', type => 'float', { name => 'axis', type => 'double',
desc => 'coord. of flip axis' } desc => 'coord. of flip axis' }
); );
@@ -272,13 +272,13 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The affected item' }, desc => 'The affected item' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'horz. coord. of one end of axis' }, desc => 'horz. coord. of one end of axis' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'vert. coord. of one end of axis' }, desc => 'vert. coord. of one end of axis' },
{ name => 'x1', type => 'float', { name => 'x1', type => 'double',
desc => 'horz. coord. of other end of axis' }, desc => 'horz. coord. of other end of axis' },
{ name => 'y1', type => 'float', { name => 'y1', type => 'double',
desc => 'vert. coord. of other end of axis' } desc => 'vert. coord. of other end of axis' }
); );
@@ -335,28 +335,28 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The affected item' }, desc => 'The affected item' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The new x coordinate of upper-left corner of original desc => 'The new x coordinate of upper-left corner of original
bounding box' }, bounding box' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The new y coordinate of upper-left corner of original desc => 'The new y coordinate of upper-left corner of original
bounding box' }, bounding box' },
{ name => 'x1', type => 'float', { name => 'x1', type => 'double',
desc => 'The new x coordinate of upper-right corner of original desc => 'The new x coordinate of upper-right corner of original
bounding box' }, bounding box' },
{ name => 'y1', type => 'float', { name => 'y1', type => 'double',
desc => 'The new y coordinate of upper-right corner of original desc => 'The new y coordinate of upper-right corner of original
bounding box' }, bounding box' },
{ name => 'x2', type => 'float', { name => 'x2', type => 'double',
desc => 'The new x coordinate of lower-left corner of original desc => 'The new x coordinate of lower-left corner of original
bounding box' }, bounding box' },
{ name => 'y2', type => 'float', { name => 'y2', type => 'double',
desc => 'The new y coordinate of lower-left corner of original desc => 'The new y coordinate of lower-left corner of original
bounding box' }, bounding box' },
{ name => 'x3', type => 'float', { name => 'x3', type => 'double',
desc => 'The new x coordinate of lower-right corner of original desc => 'The new x coordinate of lower-right corner of original
bounding box' }, bounding box' },
{ name => 'y3', type => 'float', { name => 'y3', type => 'double',
desc => 'The new y coordinate of lower-right corner of original desc => 'The new y coordinate of lower-right corner of original
bounding box' } bounding box' }
); );
@@ -414,9 +414,9 @@ HELP
desc => 'Type of rotation' }, desc => 'Type of rotation' },
{ name => 'auto_center', type => 'boolean', { name => 'auto_center', type => 'boolean',
desc => 'Whether to automatically rotate around the selection center' }, desc => 'Whether to automatically rotate around the selection center' },
{ name => 'center_x', type => 'float', { name => 'center_x', type => 'double',
desc => 'The hor. coordinate of the center of rotation' }, desc => 'The hor. coordinate of the center of rotation' },
{ name => 'center_y', type => 'float', { name => 'center_y', type => 'double',
desc => 'The vert. coordinate of the center of rotation' } desc => 'The vert. coordinate of the center of rotation' }
); );
@@ -518,13 +518,13 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The affected item' }, desc => 'The affected item' },
{ name => 'angle', type => 'float', { name => 'angle', type => 'double',
desc => 'The angle of rotation (radians)' }, desc => 'The angle of rotation (radians)' },
{ name => 'auto_center', type => 'boolean', { name => 'auto_center', type => 'boolean',
desc => 'Whether to automatically rotate around the selection center' }, desc => 'Whether to automatically rotate around the selection center' },
{ name => 'center_x', type => 'float', { name => 'center_x', type => 'double',
desc => 'The hor. coordinate of the center of rotation' }, desc => 'The hor. coordinate of the center of rotation' },
{ name => 'center_y', type => 'float', { name => 'center_y', type => 'double',
desc => 'The vert. coordinate of the center of rotation' } desc => 'The vert. coordinate of the center of rotation' }
); );
@@ -578,16 +578,16 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The affected item' }, desc => 'The affected item' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The new x coordinate of the upper-left corner of the desc => 'The new x coordinate of the upper-left corner of the
scaled region' }, scaled region' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The new y coordinate of the upper-left corner of the desc => 'The new y coordinate of the upper-left corner of the
scaled region' }, scaled region' },
{ name => 'x1', type => 'float', { name => 'x1', type => 'double',
desc => 'The new x coordinate of the lower-right corner of the desc => 'The new x coordinate of the lower-right corner of the
scaled region' }, scaled region' },
{ name => 'y1', type => 'float', { name => 'y1', type => 'double',
desc => 'The new y coordinate of the lower-right corner of the desc => 'The new y coordinate of the lower-right corner of the
scaled region' } scaled region' }
); );
@@ -645,7 +645,7 @@ HELP
{ name => 'shear_type', { name => 'shear_type',
type => 'enum GimpOrientationType (no GIMP_ORIENTATION_UNKNOWN)', type => 'enum GimpOrientationType (no GIMP_ORIENTATION_UNKNOWN)',
desc => 'Type of shear' }, desc => 'Type of shear' },
{ name => 'magnitude', type => 'float', { name => 'magnitude', type => 'double',
desc => 'The magnitude of the shear' } desc => 'The magnitude of the shear' }
); );
@@ -698,19 +698,19 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The affected item' }, desc => 'The affected item' },
{ name => 'source_x', type => 'float', { name => 'source_x', type => 'double',
desc => 'X coordinate of the transformation center' }, desc => 'X coordinate of the transformation center' },
{ name => 'source_y', type => 'float', { name => 'source_y', type => 'double',
desc => 'Y coordinate of the transformation center' }, desc => 'Y coordinate of the transformation center' },
{ name => 'scale_x', type => 'float', { name => 'scale_x', type => 'double',
desc => 'Amount to scale in x direction' }, desc => 'Amount to scale in x direction' },
{ name => 'scale_y', type => 'float', { name => 'scale_y', type => 'double',
desc => 'Amount to scale in y direction' }, desc => 'Amount to scale in y direction' },
{ name => 'angle', type => 'float', { name => 'angle', type => 'double',
desc => 'The angle of rotation (radians)' }, desc => 'The angle of rotation (radians)' },
{ name => 'dest_x', type => 'float', { name => 'dest_x', type => 'double',
desc => 'X coordinate of where the center goes' }, desc => 'X coordinate of where the center goes' },
{ name => 'dest_y', type => 'float', { name => 'dest_y', type => 'double',
desc => 'Y coordinate of where the center goes' } desc => 'Y coordinate of where the center goes' }
); );
@@ -762,23 +762,23 @@ HELP
@inargs = ( @inargs = (
{ name => 'item', type => 'item', { name => 'item', type => 'item',
desc => 'The affected item' }, desc => 'The affected item' },
{ name => 'coeff_0_0', type => 'float', { name => 'coeff_0_0', type => 'double',
desc => 'coefficient (0,0) of the transformation matrix' }, desc => 'coefficient (0,0) of the transformation matrix' },
{ name => 'coeff_0_1', type => 'float', { name => 'coeff_0_1', type => 'double',
desc => 'coefficient (0,1) of the transformation matrix' }, desc => 'coefficient (0,1) of the transformation matrix' },
{ name => 'coeff_0_2', type => 'float', { name => 'coeff_0_2', type => 'double',
desc => 'coefficient (0,2) of the transformation matrix' }, desc => 'coefficient (0,2) of the transformation matrix' },
{ name => 'coeff_1_0', type => 'float', { name => 'coeff_1_0', type => 'double',
desc => 'coefficient (1,0) of the transformation matrix' }, desc => 'coefficient (1,0) of the transformation matrix' },
{ name => 'coeff_1_1', type => 'float', { name => 'coeff_1_1', type => 'double',
desc => 'coefficient (1,1) of the transformation matrix' }, desc => 'coefficient (1,1) of the transformation matrix' },
{ name => 'coeff_1_2', type => 'float', { name => 'coeff_1_2', type => 'double',
desc => 'coefficient (1,2) of the transformation matrix' }, desc => 'coefficient (1,2) of the transformation matrix' },
{ name => 'coeff_2_0', type => 'float', { name => 'coeff_2_0', type => 'double',
desc => 'coefficient (2,0) of the transformation matrix' }, desc => 'coefficient (2,0) of the transformation matrix' },
{ name => 'coeff_2_1', type => 'float', { name => 'coeff_2_1', type => 'double',
desc => 'coefficient (2,1) of the transformation matrix' }, desc => 'coefficient (2,1) of the transformation matrix' },
{ name => 'coeff_2_2', type => 'float', { name => 'coeff_2_2', type => 'double',
desc => 'coefficient (2,2) of the transformation matrix' } desc => 'coefficient (2,2) of the transformation matrix' }
); );

6
pdb/groups/layer.pdb
View File

@@ -44,7 +44,7 @@ HELP
desc => 'The layer type' }, desc => 'The layer type' },
{ name => 'name', type => 'string', { name => 'name', type => 'string',
desc => 'The layer name', null_ok => 0 }, desc => 'The layer name', null_ok => 0 },
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The layer opacity' }, desc => 'The layer opacity' },
{ name => 'mode', type => 'enum GimpLayerMode', { name => 'mode', type => 'enum GimpLayerMode',
default => 'GIMP_LAYER_MODE_NORMAL', default => 'GIMP_LAYER_MODE_NORMAL',
@@ -1003,7 +1003,7 @@ sub layer_get_opacity {
); );
@outargs = ( @outargs = (
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The layer opacity' } desc => 'The layer opacity' }
); );
@@ -1025,7 +1025,7 @@ sub layer_set_opacity {
@inargs = ( @inargs = (
{ name => 'layer', type => 'layer', { name => 'layer', type => 'layer',
desc => 'The layer' }, desc => 'The layer' },
{ name => 'opacity', type => '0 <= float <= 100', { name => 'opacity', type => '0 <= double <= 100',
desc => 'The new layer opacity' } desc => 'The new layer opacity' }
); );

22
pdb/groups/paint_tools.pdb
View File

@@ -17,7 +17,7 @@
# "Perlized" from C source by Manish Singh <yosh@gimp.org> # "Perlized" from C source by Manish Singh <yosh@gimp.org>
sub stroke_arg () { sub stroke_arg () {
{ name => 'strokes', type => 'floatarray', { name => 'strokes', type => 'doublearray',
desc => 'Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., desc => 'Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ...,
sn.x, sn.y }', sn.x, sn.y }',
array => { type => '2 <= size', array => { type => '2 <= size',
@@ -44,7 +44,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'pressure', type => '0 <= float <= 100', { name => 'pressure', type => '0 <= double <= 100',
desc => 'The pressure of the airbrush strokes' }, desc => 'The pressure of the airbrush strokes' },
&stroke_arg &stroke_arg
); );
@@ -153,9 +153,9 @@ HELP
desc => 'The source drawable' }, desc => 'The source drawable' },
{ name => 'clone_type', type => 'enum GimpCloneType', { name => 'clone_type', type => 'enum GimpCloneType',
desc => 'The type of clone' }, desc => 'The type of clone' },
{ name => 'src_x', type => 'float', { name => 'src_x', type => 'double',
desc => 'The x coordinate in the source image' }, desc => 'The x coordinate in the source image' },
{ name => 'src_y', type => 'float', { name => 'src_y', type => 'double',
desc => 'The y coordinate in the source image' }, desc => 'The y coordinate in the source image' },
&stroke_arg &stroke_arg
); );
@@ -305,7 +305,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'pressure', type => '0 <= float <= 100', { name => 'pressure', type => '0 <= double <= 100',
desc => 'The pressure' }, desc => 'The pressure' },
{ name => 'convolve_type', type => 'enum GimpConvolveType', { name => 'convolve_type', type => 'enum GimpConvolveType',
desc => 'Convolve type' }, desc => 'Convolve type' },
@@ -516,9 +516,9 @@ HELP
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'src_drawable', type => 'drawable', { name => 'src_drawable', type => 'drawable',
desc => 'The source drawable' }, desc => 'The source drawable' },
{ name => 'src_x', type => 'float', { name => 'src_x', type => 'double',
desc => 'The x coordinate in the source image' }, desc => 'The x coordinate in the source image' },
{ name => 'src_y', type => 'float', { name => 'src_y', type => 'double',
desc => 'The y coordinate in the source image' }, desc => 'The y coordinate in the source image' },
&stroke_arg &stroke_arg
); );
@@ -628,12 +628,12 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'fade_out', type => '0 <= float', { name => 'fade_out', type => '0 <= double',
desc => 'Fade out parameter' }, desc => 'Fade out parameter' },
&stroke_arg, &stroke_arg,
{ name => 'method', type => 'enum GimpPaintApplicationMode', { name => 'method', type => 'enum GimpPaintApplicationMode',
desc => 'The paint method to use' }, desc => 'The paint method to use' },
{ name => 'gradient_length', type => '0 <= float', { name => 'gradient_length', type => '0 <= double',
desc => 'Length of gradient to draw' } desc => 'Length of gradient to draw' }
); );
@@ -811,7 +811,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'pressure', type => '0 <= float <= 100', { name => 'pressure', type => '0 <= double <= 100',
desc => 'The pressure of the smudge strokes' }, desc => 'The pressure of the smudge strokes' },
&stroke_arg &stroke_arg
); );
@@ -906,7 +906,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable' }, desc => 'The affected drawable' },
{ name => 'exposure', type => '0 <= float <= 100', { name => 'exposure', type => '0 <= double <= 100',
desc => 'The exposure of the strokes' }, desc => 'The exposure of the strokes' },
{ name => 'dodgeburn_type', type => 'enum GimpDodgeBurnType', { name => 'dodgeburn_type', type => 'enum GimpDodgeBurnType',
desc => 'The type either dodge or burn' }, desc => 'The type either dodge or burn' },

86
pdb/groups/path.pdb
View File

@@ -179,12 +179,12 @@ sub path_stroke_get_length {
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => 'precision', type => '0.0 <= float', default => 0.1, { name => 'precision', type => '0.0 <= double', default => 0.1,
desc => 'The precision used for approximating straight portions of the stroke' } desc => 'The precision used for approximating straight portions of the stroke' }
); );
@outargs = ( @outargs = (
{ name => 'length', type => 'float', { name => 'length', type => 'double',
desc => 'The length (in pixels) of the given stroke.' } desc => 'The length (in pixels) of the given stroke.' }
); );
@@ -220,18 +220,18 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => 'dist', type => 'float', { name => 'dist', type => 'double',
desc => 'The given distance.' }, desc => 'The given distance.' },
{ name => 'precision', type => 'float', { name => 'precision', type => 'double',
desc => 'The precision used for the approximation' } desc => 'The precision used for the approximation' }
); );
@outargs = ( @outargs = (
{ name => 'x_point', type => 'float', void_ret => 1, { name => 'x_point', type => 'double', void_ret => 1,
desc => 'The x position of the point.' }, desc => 'The x position of the point.' },
{ name => 'y_point', type => 'float', { name => 'y_point', type => 'double',
desc => 'The y position of the point.' }, desc => 'The y position of the point.' },
{ name => 'slope', type => 'float', { name => 'slope', type => 'double',
desc => 'The slope (dy / dx) at the specified point.' }, desc => 'The slope (dy / dx) at the specified point.' },
{ name => 'valid', type => 'boolean', { name => 'valid', type => 'boolean',
desc => 'Indicator for the validity of the returned data.' } desc => 'Indicator for the validity of the returned data.' }
@@ -392,9 +392,9 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => "off_x", type => 'float', { name => "off_x", type => 'double',
desc => "Offset in x direction" }, desc => "Offset in x direction" },
{ name => "off_y", type => 'float', { name => "off_y", type => 'double',
desc => "Offset in y direction" } desc => "Offset in y direction" }
); );
@@ -438,9 +438,9 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => "scale_x", type => 'float', { name => "scale_x", type => 'double',
desc => "Scale factor in x direction" }, desc => "Scale factor in x direction" },
{ name => "scale_y", type => 'float', { name => "scale_y", type => 'double',
desc => "Scale factor in y direction" } desc => "Scale factor in y direction" }
); );
@@ -483,11 +483,11 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => "center_x", type => 'float', { name => "center_x", type => 'double',
desc => "X coordinate of the rotation center" }, desc => "X coordinate of the rotation center" },
{ name => "center_y", type => 'float', { name => "center_y", type => 'double',
desc => "Y coordinate of the rotation center" }, desc => "Y coordinate of the rotation center" },
{ name => "angle", type => 'float', { name => "angle", type => 'double',
desc => "angle to rotate about" } desc => "angle to rotate about" }
); );
@@ -533,7 +533,7 @@ HELP
{ name => "flip_type", { name => "flip_type",
type => 'enum GimpOrientationType (no GIMP_ORIENTATION_UNKNOWN)', type => 'enum GimpOrientationType (no GIMP_ORIENTATION_UNKNOWN)',
desc => "Flip orientation, either vertical or horizontal" }, desc => "Flip orientation, either vertical or horizontal" },
{ name => "axis", type => 'float', { name => "axis", type => 'double',
desc => "axis coordinate about which to flip, in pixels" } desc => "axis coordinate about which to flip, in pixels" }
); );
@@ -577,13 +577,13 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => "x1", type => 'float', { name => "x1", type => 'double',
desc => "X coordinate of the first point of the flipping axis" }, desc => "X coordinate of the first point of the flipping axis" },
{ name => "y1", type => 'float', { name => "y1", type => 'double',
desc => "Y coordinate of the first point of the flipping axis" }, desc => "Y coordinate of the first point of the flipping axis" },
{ name => "x2", type => 'float', { name => "x2", type => 'double',
desc => "X coordinate of the second point of the flipping axis" }, desc => "X coordinate of the second point of the flipping axis" },
{ name => "y2", type => 'float', { name => "y2", type => 'double',
desc => "Y coordinate of the second point of the flipping axis" }, desc => "Y coordinate of the second point of the flipping axis" },
); );
@@ -635,7 +635,7 @@ HELP
@outargs = ( @outargs = (
{ name => 'type', type => 'enum GimpPathStrokeType', { name => 'type', type => 'enum GimpPathStrokeType',
desc => 'type of the stroke (always GIMP_PATH_STROKE_TYPE_BEZIER for now).' }, desc => 'type of the stroke (always GIMP_PATH_STROKE_TYPE_BEZIER for now).' },
{ name => 'controlpoints', type => 'floatarray', { name => 'controlpoints', type => 'doublearray',
desc => 'List of the control points for the stroke (x0, y0, x1, y1, ...).', desc => 'List of the control points for the stroke (x0, y0, x1, y1, ...).',
array => { name => 'num_points', array => { name => 'num_points',
desc => 'The number of floats returned.' } }, desc => 'The number of floats returned.' } },
@@ -696,12 +696,12 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => 'precision', type => 'float', { name => 'precision', type => 'double',
desc => 'The precision used for the approximation' } desc => 'The precision used for the approximation' }
); );
@outargs = ( @outargs = (
{ name => 'coords', type => 'floatarray', { name => 'coords', type => 'doublearray',
desc => 'List of the coords along the path (x0, y0, x1, y1, ...).', desc => 'List of the coords along the path (x0, y0, x1, y1, ...).',
array => { name => 'num_coords', array => { name => 'num_coords',
desc => 'The number of floats returned.' } }, desc => 'The number of floats returned.' } },
@@ -752,7 +752,7 @@ sub path_stroke_new_from_points {
Adds a stroke of a given type to the path object. The coordinates of the Adds a stroke of a given type to the path object. The coordinates of the
control points can be specified. control points can be specified.
For now only strokes of the type GIMP_PATH_STROKE_TYPE_BEZIER are supported. For now only strokes of the type GIMP_PATH_STROKE_TYPE_BEZIER are supported.
The control points are specified as a pair of float values for the x- and The control points are specified as a pair of double values for the x- and
y-coordinate. y-coordinate.
The Bezier stroke type needs a multiple of three control points. Each Bezier The Bezier stroke type needs a multiple of three control points. Each Bezier
segment endpoint (anchor, A) has two additional control points (C) associated. segment endpoint (anchor, A) has two additional control points (C) associated.
@@ -766,7 +766,7 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'type', type => 'enum GimpPathStrokeType', { name => 'type', type => 'enum GimpPathStrokeType',
desc => 'type of the stroke (always GIMP_PATH_STROKE_TYPE_BEZIER for now).' }, desc => 'type of the stroke (always GIMP_PATH_STROKE_TYPE_BEZIER for now).' },
{ name => 'controlpoints', type => 'floatarray', { name => 'controlpoints', type => 'doublearray',
desc => 'List of the x- and y-coordinates of the control points.', desc => 'List of the x- and y-coordinates of the control points.',
array => { name => 'num_points', array => { name => 'num_points',
desc => 'The number of elements in the array, i.e. the desc => 'The number of elements in the array, i.e. the
@@ -837,9 +837,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'path', type => 'path', { name => 'path', type => 'path',
desc => 'The path object' }, desc => 'The path object' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The x-coordinate of the moveto' }, desc => 'The x-coordinate of the moveto' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The y-coordinate of the moveto' } desc => 'The y-coordinate of the moveto' }
); );
@@ -894,9 +894,9 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The x-coordinate of the lineto' }, desc => 'The x-coordinate of the lineto' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The y-coordinate of the lineto' } desc => 'The y-coordinate of the lineto' }
); );
@@ -945,13 +945,13 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The x-coordinate of the control point' }, desc => 'The x-coordinate of the control point' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The y-coordinate of the control point' }, desc => 'The y-coordinate of the control point' },
{ name => 'x1', type => 'float', { name => 'x1', type => 'double',
desc => 'The x-coordinate of the end point' }, desc => 'The x-coordinate of the end point' },
{ name => 'y1', type => 'float', { name => 'y1', type => 'double',
desc => 'The y-coordinate of the end point' } desc => 'The y-coordinate of the end point' }
); );
@@ -1002,17 +1002,17 @@ HELP
desc => 'The path object' }, desc => 'The path object' },
{ name => 'stroke_id', type => 'int32', { name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' }, desc => 'The stroke ID' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The x-coordinate of the first control point' }, desc => 'The x-coordinate of the first control point' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The y-coordinate of the first control point' }, desc => 'The y-coordinate of the first control point' },
{ name => 'x1', type => 'float', { name => 'x1', type => 'double',
desc => 'The x-coordinate of the second control point' }, desc => 'The x-coordinate of the second control point' },
{ name => 'y1', type => 'float', { name => 'y1', type => 'double',
desc => 'The y-coordinate of the second control point' }, desc => 'The y-coordinate of the second control point' },
{ name => 'x2', type => 'float', { name => 'x2', type => 'double',
desc => 'The x-coordinate of the end point' }, desc => 'The x-coordinate of the end point' },
{ name => 'y2', type => 'float', { name => 'y2', type => 'double',
desc => 'The y-coordinate of the end point' } desc => 'The y-coordinate of the end point' }
); );
@@ -1065,15 +1065,15 @@ HELP
@inargs = ( @inargs = (
{ name => 'path', type => 'path', { name => 'path', type => 'path',
desc => 'The path object' }, desc => 'The path object' },
{ name => 'x0', type => 'float', { name => 'x0', type => 'double',
desc => 'The x-coordinate of the center' }, desc => 'The x-coordinate of the center' },
{ name => 'y0', type => 'float', { name => 'y0', type => 'double',
desc => 'The y-coordinate of the center' }, desc => 'The y-coordinate of the center' },
{ name => 'radius_x', type => 'float', { name => 'radius_x', type => 'double',
desc => 'The radius in x direction' }, desc => 'The radius in x direction' },
{ name => 'radius_y', type => 'float', { name => 'radius_y', type => 'double',
desc => 'The radius in y direction' }, desc => 'The radius in y direction' },
{ name => 'angle', type => 'float', { name => 'angle', type => 'double',
desc => 'The angle the x-axis of the ellipse desc => 'The angle the x-axis of the ellipse
(radians, counterclockwise)' } (radians, counterclockwise)' }
); );

286
pdb/groups/plug_in_compat.pdb
View File

@@ -39,17 +39,17 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'redfrequency', type => '0 <= float <= 20', { name => 'redfrequency', type => '0 <= double <= 20',
desc => 'Red/hue component frequency factor' }, desc => 'Red/hue component frequency factor' },
{ name => 'redangle', type => '0 <= float <= 360', { name => 'redangle', type => '0 <= double <= 360',
desc => 'Red/hue component angle factor (0-360)' }, desc => 'Red/hue component angle factor (0-360)' },
{ name => 'greenfrequency', type => '0 <= float <= 20', { name => 'greenfrequency', type => '0 <= double <= 20',
desc => 'Green/saturation component frequency factor' }, desc => 'Green/saturation component frequency factor' },
{ name => 'greenangle', type => '0 <= float <= 360', { name => 'greenangle', type => '0 <= double <= 360',
desc => 'Green/saturation component angle factor (0-360)' }, desc => 'Green/saturation component angle factor (0-360)' },
{ name => 'bluefrequency', type => '0 <= float <= 20', { name => 'bluefrequency', type => '0 <= double <= 20',
desc => 'Blue/luminance component frequency factor' }, desc => 'Blue/luminance component frequency factor' },
{ name => 'blueangle', type => '0 <= float <= 360', { name => 'blueangle', type => '0 <= double <= 360',
desc => 'Blue/luminance component angle factor (0-360)' }, desc => 'Blue/luminance component angle factor (0-360)' },
{ name => 'colormodel', type => '0 <= int32 <= 1', { name => 'colormodel', type => '0 <= int32 <= 1',
desc => 'Color model { RGB-MODEL (0), HSL-MODEL (1) }' }, desc => 'Color model { RGB-MODEL (0), HSL-MODEL (1) }' },
@@ -204,7 +204,7 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'refraction', type => '1.0 <= float <= 100.0', { name => 'refraction', type => '1.0 <= double <= 100.0',
desc => 'Lens refraction index' }, desc => 'Lens refraction index' },
{ name => 'keep_surroundings', type => 'boolean', { name => 'keep_surroundings', type => 'boolean',
desc => 'Keep lens surroundings' }, desc => 'Keep lens surroundings' },
@@ -463,9 +463,9 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'bumpmap', type => 'drawable', { name => 'bumpmap', type => 'drawable',
desc => 'Bump map drawable' }, desc => 'Bump map drawable' },
{ name => 'azimuth', type => '0.0 <= float <= 360.0', { name => 'azimuth', type => '0.0 <= double <= 360.0',
desc => 'Azimuth' }, desc => 'Azimuth' },
{ name => 'elevation', type => '0.5 <= float <= 90.0', { name => 'elevation', type => '0.5 <= double <= 90.0',
desc => 'Elevation' }, desc => 'Elevation' },
{ name => 'depth', type => '1 <= int32 <= 65', { name => 'depth', type => '1 <= int32 <= 65',
desc => 'Depth' }, desc => 'Depth' },
@@ -473,9 +473,9 @@ HELP
desc => 'X offset' }, desc => 'X offset' },
{ name => 'yofs', type => 'int32', { name => 'yofs', type => 'int32',
desc => 'Y offset' }, desc => 'Y offset' },
{ name => 'waterlevel', type => '0.0 <= float <= 1.0', { name => 'waterlevel', type => '0.0 <= double <= 1.0',
desc => 'Level that full transparency should represent' }, desc => 'Level that full transparency should represent' },
{ name => 'ambient', type => '0.0 <= float <= 1.0', { name => 'ambient', type => '0.0 <= double <= 1.0',
desc => 'Ambient lighting factor' }, desc => 'Ambient lighting factor' },
{ name => 'compensate', type => 'boolean', { name => 'compensate', type => 'boolean',
desc => 'Compensate for darkening' }, desc => 'Compensate for darkening' },
@@ -531,9 +531,9 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'bumpmap', type => 'drawable', { name => 'bumpmap', type => 'drawable',
desc => 'Bump map drawable' }, desc => 'Bump map drawable' },
{ name => 'azimuth', type => '0.0 <= float <= 360.0', { name => 'azimuth', type => '0.0 <= double <= 360.0',
desc => 'Azimuth' }, desc => 'Azimuth' },
{ name => 'elevation', type => '0.5 <= float <= 90.0', { name => 'elevation', type => '0.5 <= double <= 90.0',
desc => 'Elevation' }, desc => 'Elevation' },
{ name => 'depth', type => '1 <= int32 <= 65', { name => 'depth', type => '1 <= int32 <= 65',
desc => 'Depth' }, desc => 'Depth' },
@@ -541,9 +541,9 @@ HELP
desc => 'X offset' }, desc => 'X offset' },
{ name => 'yofs', type => 'int32', { name => 'yofs', type => 'int32',
desc => 'Y offset' }, desc => 'Y offset' },
{ name => 'waterlevel', type => '0.0 <= float <= 1.0', { name => 'waterlevel', type => '0.0 <= double <= 1.0',
desc => 'Level that full transparency should represent' }, desc => 'Level that full transparency should represent' },
{ name => 'ambient', type => '0.0 <= float <= 1.0', { name => 'ambient', type => '0.0 <= double <= 1.0',
desc => 'Ambient lighting factor' }, desc => 'Ambient lighting factor' },
{ name => 'compensate', type => 'boolean', { name => 'compensate', type => 'boolean',
desc => 'Compensate for darkening' }, desc => 'Compensate for darkening' },
@@ -658,9 +658,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'mask_radius', type => '1.0 <= float <= 50.0', { name => 'mask_radius', type => '1.0 <= double <= 50.0',
desc => 'Cartoon mask radius (radius of pixel neighborhood)' }, desc => 'Cartoon mask radius (radius of pixel neighborhood)' },
{ name => 'pct_black', type => '0.0 <= float <= 1.0', { name => 'pct_black', type => '0.0 <= double <= 1.0',
desc => 'Percentage of darkened pixels to set to black' }, desc => 'Percentage of darkened pixels to set to black' },
); );
@@ -709,23 +709,23 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'monochrome', type => '0 <= int32 <= 1', { name => 'monochrome', type => '0 <= int32 <= 1',
desc => 'Monochrome { TRUE, FALSE }' }, desc => 'Monochrome { TRUE, FALSE }' },
{ name => 'rr_gain', type => '-2 <= float <= 2', { name => 'rr_gain', type => '-2 <= double <= 2',
desc => 'Set the red gain for the red channel' }, desc => 'Set the red gain for the red channel' },
{ name => 'rg_gain', type => '-2 <= float <= 2', { name => 'rg_gain', type => '-2 <= double <= 2',
desc => 'Set the green gain for the red channel' }, desc => 'Set the green gain for the red channel' },
{ name => 'rb_gain', type => '-2 <= float <= 2', { name => 'rb_gain', type => '-2 <= double <= 2',
desc => 'Set the blue gain for the red channel' }, desc => 'Set the blue gain for the red channel' },
{ name => 'gr_gain', type => '-2 <= float <= 2', { name => 'gr_gain', type => '-2 <= double <= 2',
desc => 'Set the red gain for the green channel' }, desc => 'Set the red gain for the green channel' },
{ name => 'gg_gain', type => '-2 <= float <= 2', { name => 'gg_gain', type => '-2 <= double <= 2',
desc => 'Set the green gain for the green channel' }, desc => 'Set the green gain for the green channel' },
{ name => 'gb_gain', type => '-2 <= float <= 2', { name => 'gb_gain', type => '-2 <= double <= 2',
desc => 'Set the blue gain for the green channel' }, desc => 'Set the blue gain for the green channel' },
{ name => 'br_gain', type => '-2 <= float <= 2', { name => 'br_gain', type => '-2 <= double <= 2',
desc => 'Set the red gain for the blue channel' }, desc => 'Set the red gain for the blue channel' },
{ name => 'bg_gain', type => '-2 <= float <= 2', { name => 'bg_gain', type => '-2 <= double <= 2',
desc => 'Set the green gain for the blue channel' }, desc => 'Set the green gain for the blue channel' },
{ name => 'bb_gain', type => '-2 <= float <= 2', { name => 'bb_gain', type => '-2 <= double <= 2',
desc => 'Set the blue gain for the blue channel' }, desc => 'Set the blue gain for the blue channel' },
); );
@@ -841,15 +841,15 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'matrix', type => 'floatarray', { name => 'matrix', type => 'doublearray',
desc => 'The 5x5 convolution matrix', desc => 'The 5x5 convolution matrix',
array => { name => 'argc_matrix', array => { name => 'argc_matrix',
desc => 'The number of elements in the following array, must always be 25' } }, desc => 'The number of elements in the following array, must always be 25' } },
{ name => 'alpha_alg', type => 'boolean', { name => 'alpha_alg', type => 'boolean',
desc => 'Enable weighting by alpha channel' }, desc => 'Enable weighting by alpha channel' },
{ name => 'divisor', type => 'float', { name => 'divisor', type => 'double',
desc => 'Divisor' }, desc => 'Divisor' },
{ name => 'offset', type => 'float', { name => 'offset', type => 'double',
desc => 'Offset' }, desc => 'Offset' },
{ name => 'channels', type => 'int32array', { name => 'channels', type => 'int32array',
desc => 'Mask of the channels to be filtered', desc => 'Mask of the channels to be filtered',
@@ -979,9 +979,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'tile_size', type => '0.0 <= float <= 100.0', { name => 'tile_size', type => '0.0 <= double <= 100.0',
desc => 'Average diameter of each tile (in pixels)' }, desc => 'Average diameter of each tile (in pixels)' },
{ name => 'tile_saturation', type => '0.0 <= float <= 10.0', { name => 'tile_saturation', type => '0.0 <= double <= 10.0',
desc => 'Expand tiles by this amount' }, desc => 'Expand tiles by this amount' },
{ name => 'bg_color', type => '0 <= int32 <= 1', { name => 'bg_color', type => '0 <= int32 <= 1',
desc => 'Background color { BLACK (0), BG (1) }' } desc => 'Background color { BLACK (0), BG (1) }' }
@@ -1098,29 +1098,29 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'lam_r', type => '0.0 <= float <= 20.0', { name => 'lam_r', type => '0.0 <= double <= 20.0',
desc => 'Light frequency (red)' }, desc => 'Light frequency (red)' },
{ name => 'lam_g', type => '0.0 <= float <= 20.0', { name => 'lam_g', type => '0.0 <= double <= 20.0',
desc => 'Light frequency (green)' }, desc => 'Light frequency (green)' },
{ name => 'lam_b', type => '0.0 <= float <= 20.0', { name => 'lam_b', type => '0.0 <= double <= 20.0',
desc => 'Light frequency (blue)' }, desc => 'Light frequency (blue)' },
{ name => 'contour_r', type => '0.0 <= float <= 10.0', { name => 'contour_r', type => '0.0 <= double <= 10.0',
desc => 'Number of contours (red)' }, desc => 'Number of contours (red)' },
{ name => 'contour_g', type => '0.0 <= float <= 10.0', { name => 'contour_g', type => '0.0 <= double <= 10.0',
desc => 'Number of contours (green)' }, desc => 'Number of contours (green)' },
{ name => 'contour_b', type => '0.0 <= float <= 10.0', { name => 'contour_b', type => '0.0 <= double <= 10.0',
desc => 'Number of contours (blue)' }, desc => 'Number of contours (blue)' },
{ name => 'edges_r', type => '0.0 <= float <= 1.0', { name => 'edges_r', type => '0.0 <= double <= 1.0',
desc => 'Number of sharp edges (red)' }, desc => 'Number of sharp edges (red)' },
{ name => 'edges_g', type => '0.0 <= float <= 1.0', { name => 'edges_g', type => '0.0 <= double <= 1.0',
desc => 'Number of sharp edges (green)' }, desc => 'Number of sharp edges (green)' },
{ name => 'edges_b', type => '0.0 <= float <= 1.0', { name => 'edges_b', type => '0.0 <= double <= 1.0',
desc => 'Number of sharp edges (blue)' }, desc => 'Number of sharp edges (blue)' },
{ name => 'brightness', type => '0.0 <= float <= 1.0', { name => 'brightness', type => '0.0 <= double <= 1.0',
desc => 'Brightness and shifting/fattening of contours' }, desc => 'Brightness and shifting/fattening of contours' },
{ name => 'scattering', type => '0.0 <= float <= 100.0', { name => 'scattering', type => '0.0 <= double <= 100.0',
desc => 'Scattering (Speed vs. quality)' }, desc => 'Scattering (Speed vs. quality)' },
{ name => 'polarization', type => '-1.0 <= float <= 1.0', { name => 'polarization', type => '-1.0 <= double <= 1.0',
desc => 'Polarization' } desc => 'Polarization' }
); );
@@ -1185,9 +1185,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'amount_x', type => '-500.0 <= float <= 500.0', { name => 'amount_x', type => '-500.0 <= double <= 500.0',
desc => 'Displace multiplier for x direction' }, desc => 'Displace multiplier for x direction' },
{ name => 'amount_y', type => '-500.0 <= float <= 500.0', { name => 'amount_y', type => '-500.0 <= double <= 500.0',
desc => 'Displace multiplier for y direction' }, desc => 'Displace multiplier for y direction' },
{ name => 'do_x', type => 'boolean', { name => 'do_x', type => 'boolean',
desc => 'Displace in x direction ?' }, desc => 'Displace in x direction ?' },
@@ -1238,9 +1238,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'amount_x', type => '-500.0 <= float <= 500.0', { name => 'amount_x', type => '-500.0 <= double <= 500.0',
desc => 'Displace multiplier for radial direction' }, desc => 'Displace multiplier for radial direction' },
{ name => 'amount_y', type => '-500.0 <= float <= 500.0', { name => 'amount_y', type => '-500.0 <= double <= 500.0',
desc => 'Displace multiplier for tangent direction' }, desc => 'Displace multiplier for tangent direction' },
{ name => 'do_x', type => 'boolean', { name => 'do_x', type => 'boolean',
desc => 'Displace in radial direction ?' }, desc => 'Displace in radial direction ?' },
@@ -1291,9 +1291,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'inner', type => '0.0 <= float <= 10.0', { name => 'inner', type => '0.0 <= double <= 10.0',
desc => 'Radius of inner gaussian blur in pixels' }, desc => 'Radius of inner gaussian blur in pixels' },
{ name => 'outer', type => '0.0 <= float <= 10.0', { name => 'outer', type => '0.0 <= double <= 10.0',
desc => 'Radius of outer gaussian blur in pixels' }, desc => 'Radius of outer gaussian blur in pixels' },
{ name => 'normalize', type => 'boolean', { name => 'normalize', type => 'boolean',
desc => 'Normalize' }, desc => 'Normalize' },
@@ -1377,7 +1377,7 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'amount', type => '1.0 <= float <= 10.0', { name => 'amount', type => '1.0 <= double <= 10.0',
desc => 'Edge detection amount' }, desc => 'Edge detection amount' },
{ name => 'warpmode', type => '0 <= int32 <= 3', { name => 'warpmode', type => '0 <= int32 <= 3',
desc => 'Edge detection behavior { NONE (0), WRAP (1), SMEAR (2), BLACK (3) }' }, desc => 'Edge detection behavior { NONE (0), WRAP (1), SMEAR (2), BLACK (3) }' },
@@ -1451,9 +1451,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'azimuth', type => '0.0 <= float <= 360.0', { name => 'azimuth', type => '0.0 <= double <= 360.0',
desc => 'The Light Angle (degrees)' }, desc => 'The Light Angle (degrees)' },
{ name => 'elevation', type => '0.0 <= float <= 180', { name => 'elevation', type => '0.0 <= double <= 180',
desc => 'The Elevation Angle (degrees)' }, desc => 'The Elevation Angle (degrees)' },
{ name => 'depth', type => '0 < int32 < 100', { name => 'depth', type => '0 < int32 < 100',
default => 1, desc => 'The Filter Width' }, default => 1, desc => 'The Filter Width' },
@@ -1560,23 +1560,23 @@ HELP
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'from_red', type => '0.0 <= float <= 1.0', { name => 'from_red', type => '0.0 <= double <= 1.0',
desc => 'Red value (from)' }, desc => 'Red value (from)' },
{ name => 'from_green', type => '0.0 <= float <= 1.0', { name => 'from_green', type => '0.0 <= double <= 1.0',
desc => 'Green value (from)' }, desc => 'Green value (from)' },
{ name => 'from_blue', type => '0.0 <= float <= 1.0', { name => 'from_blue', type => '0.0 <= double <= 1.0',
desc => 'Blue value (from)' }, desc => 'Blue value (from)' },
{ name => 'to_red', type => '0.0 <= float <= 1.0', { name => 'to_red', type => '0.0 <= double <= 1.0',
desc => 'Red value (to)' }, desc => 'Red value (to)' },
{ name => 'to_green', type => '0.0 <= float <= 1.0', { name => 'to_green', type => '0.0 <= double <= 1.0',
desc => 'Green value (to)' }, desc => 'Green value (to)' },
{ name => 'to_blue', type => '0.0 <= float <= 1.0', { name => 'to_blue', type => '0.0 <= double <= 1.0',
desc => 'Blue value (to)' }, desc => 'Blue value (to)' },
{ name => 'red_threshold', type => '0.0 <= float <= 1.0', { name => 'red_threshold', type => '0.0 <= double <= 1.0',
desc => 'Red threshold' }, desc => 'Red threshold' },
{ name => 'green_threshold', type => '0.0 <= float <= 1.0', { name => 'green_threshold', type => '0.0 <= double <= 1.0',
desc => 'Green threshold' }, desc => 'Green threshold' },
{ name => 'blue_threshold', type => '0.0 <= float <= 1.0', { name => 'blue_threshold', type => '0.0 <= double <= 1.0',
desc => 'Blue threshold' } desc => 'Blue threshold' }
); );
@@ -1692,13 +1692,13 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'xmin', type => '-50.0 <= float <= 50.0', { name => 'xmin', type => '-50.0 <= double <= 50.0',
desc => 'xmin fractal image delimiter' }, desc => 'xmin fractal image delimiter' },
{ name => 'xmax', type => '-50.0 <= float <= 50.0', { name => 'xmax', type => '-50.0 <= double <= 50.0',
desc => 'xmax fractal image delimiter' }, desc => 'xmax fractal image delimiter' },
{ name => 'ymin', type => '-50.0 <= float <= 50.0', { name => 'ymin', type => '-50.0 <= double <= 50.0',
desc => 'ymin fractal image delimiter' }, desc => 'ymin fractal image delimiter' },
{ name => 'ymax', type => '-50.0 <= float <= 50.0', { name => 'ymax', type => '-50.0 <= double <= 50.0',
desc => 'ymax fractal image delimiter' }, desc => 'ymax fractal image delimiter' },
{ name => 'depth', type => '1 <= int32 <= 65536', { name => 'depth', type => '1 <= int32 <= 65536',
desc => 'Trace depth' }, desc => 'Trace depth' },
@@ -1767,9 +1767,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'horizontal', type => '0.0 <= float <= 1500.0', { name => 'horizontal', type => '0.0 <= double <= 1500.0',
desc => 'Horizontal radius of gaussian blur (in pixels)' }, desc => 'Horizontal radius of gaussian blur (in pixels)' },
{ name => 'vertical', type => '0.0 <= float <= 1500.0', { name => 'vertical', type => '0.0 <= double <= 1500.0',
desc => 'Vertical radius of gaussian blur (in pixels)' }, desc => 'Vertical radius of gaussian blur (in pixels)' },
{ name => 'method', type => '0 <= int32 <= 1', { name => 'method', type => '0 <= int32 <= 1',
desc => 'Blur method { AUTO (0), FIR (1), IIR (2) }' } desc => 'Blur method { AUTO (0), FIR (1), IIR (2) }' }
@@ -2010,17 +2010,17 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'offset_x', type => '-100 <= float <= 100', { name => 'offset_x', type => '-100 <= double <= 100',
desc => 'Effect centre offset in X' }, desc => 'Effect centre offset in X' },
{ name => 'offset_y', type => '-100 <= float <= 100', { name => 'offset_y', type => '-100 <= double <= 100',
desc => 'Effect centre offset in Y' }, desc => 'Effect centre offset in Y' },
{ name => 'main_adjust', type => '-100 <= float <= 100', { name => 'main_adjust', type => '-100 <= double <= 100',
desc => 'Amount of second-order distortion' }, desc => 'Amount of second-order distortion' },
{ name => 'edge_adjust', type => '-100 <= float <= 100', { name => 'edge_adjust', type => '-100 <= double <= 100',
desc => 'Amount of fourth-order distortion' }, desc => 'Amount of fourth-order distortion' },
{ name => 'rescale', type => '-100 <= float <= 100', { name => 'rescale', type => '-100 <= double <= 100',
desc => 'Rescale overall image size' }, desc => 'Rescale overall image size' },
{ name => 'brighten', type => '-100 <= float <= 100', { name => 'brighten', type => '-100 <= double <= 100',
desc => 'Adjust brightness in corners' } desc => 'Adjust brightness in corners' }
); );
@@ -2206,13 +2206,13 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'type', type => '0 <= int32 <= 2', { name => 'type', type => '0 <= int32 <= 2',
desc => 'Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }' }, desc => 'Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }' },
{ name => 'length', type => 'float', { name => 'length', type => 'double',
desc => 'Length' }, desc => 'Length' },
{ name => 'angle', type => '0 <= float <= 360', { name => 'angle', type => '0 <= double <= 360',
desc => 'Angle' }, desc => 'Angle' },
{ name => 'center_x', type => 'float', { name => 'center_x', type => 'double',
desc => 'Center X' }, desc => 'Center X' },
{ name => 'center_y', type => 'float', { name => 'center_y', type => 'double',
desc => 'Center Y' } desc => 'Center Y' }
); );
@@ -2300,13 +2300,13 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'type', type => '0 <= int32 <= 2', { name => 'type', type => '0 <= int32 <= 2',
desc => 'Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }' }, desc => 'Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }' },
{ name => 'length', type => 'float', { name => 'length', type => 'double',
desc => 'Length' }, desc => 'Length' },
{ name => 'angle', type => '0 <= float <= 360', { name => 'angle', type => '0 <= double <= 360',
desc => 'Angle' }, desc => 'Angle' },
{ name => 'center_x', type => 'float', { name => 'center_x', type => 'double',
desc => 'Center X' }, desc => 'Center X' },
{ name => 'center_y', type => 'float', { name => 'center_y', type => 'double',
desc => 'Center Y' } desc => 'Center Y' }
); );
@@ -2391,7 +2391,7 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'radius', type => '-400 <= int32 <= 400', { name => 'radius', type => '-400 <= int32 <= 400',
desc => 'Neighborhood radius, a negative value will calculate with inverted percentiles' }, desc => 'Neighborhood radius, a negative value will calculate with inverted percentiles' },
{ name => 'percentile', type => '0 <= float <= 100', { name => 'percentile', type => '0 <= double <= 100',
desc => 'Neighborhood color percentile' } desc => 'Neighborhood color percentile' }
); );
@@ -2440,19 +2440,19 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'tile_size', type => '1 <= float <= 1000', { name => 'tile_size', type => '1 <= double <= 1000',
desc => 'Average diameter of each tile (in pixels)' }, desc => 'Average diameter of each tile (in pixels)' },
{ name => 'tile_height', type => '1 <= float <= 1000', { name => 'tile_height', type => '1 <= double <= 1000',
desc => 'Apparent height of each tile (in pixels)' }, desc => 'Apparent height of each tile (in pixels)' },
{ name => 'tile_spacing', type => '0.1 <= float <= 1000', { name => 'tile_spacing', type => '0.1 <= double <= 1000',
desc => 'Inter_tile spacing (in pixels)' }, desc => 'Inter_tile spacing (in pixels)' },
{ name => 'tile_neatness', type => '0 <= float <= 1.0', { name => 'tile_neatness', type => '0 <= double <= 1.0',
desc => 'Deviation from perfectly formed tiles' }, desc => 'Deviation from perfectly formed tiles' },
{ name => 'tile_allow_split', type => '0 <= int32 <= 1', { name => 'tile_allow_split', type => '0 <= int32 <= 1',
desc => 'Allows splitting tiles at hard edges' }, desc => 'Allows splitting tiles at hard edges' },
{ name => 'light_dir', type => '0 <= float <= 360', { name => 'light_dir', type => '0 <= double <= 360',
desc => 'Direction of light_source (in degrees)' }, desc => 'Direction of light_source (in degrees)' },
{ name => 'color_variation', type => '0.0 <= float <= 1.0', { name => 'color_variation', type => '0.0 <= double <= 1.0',
desc => 'Magnitude of random color variations' }, desc => 'Magnitude of random color variations' },
{ name => 'antialiasing', type => '0 <= int32 <= 1', { name => 'antialiasing', type => '0 <= int32 <= 1',
desc => 'Enables smoother tile output at the cost of speed' }, desc => 'Enables smoother tile output at the cost of speed' },
@@ -2542,9 +2542,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'radius', type => '0.0 <= float <= 1500.0', { name => 'radius', type => '0.0 <= double <= 1500.0',
desc => 'Radius of neon effect (in pixels)' }, desc => 'Radius of neon effect (in pixels)' },
{ name => 'amount', type => '0.0 <= float <= 100.0', { name => 'amount', type => '0.0 <= double <= 100.0',
desc => 'Effect enhancement variable' } desc => 'Effect enhancement variable' }
); );
@@ -2596,19 +2596,19 @@ sub plug_in_newsprint {
desc => 'Separate to { GRAYSCALE (0), RGB (1), CMYK (2), LUMINANCE (3) }' }, desc => 'Separate to { GRAYSCALE (0), RGB (1), CMYK (2), LUMINANCE (3) }' },
{ name => 'k_pullout', type => '0 <= int32 <= 100', { name => 'k_pullout', type => '0 <= int32 <= 100',
desc => 'Percentage of black to pullout (CMYK only)' }, desc => 'Percentage of black to pullout (CMYK only)' },
{ name => 'gry_ang', type => '0.0 <= float <= 360.0', { name => 'gry_ang', type => '0.0 <= double <= 360.0',
desc => 'Grey/black screen angle (degrees)' }, desc => 'Grey/black screen angle (degrees)' },
{ name => 'gry_spotfn', type => '0 <= int32 <= 4', { name => 'gry_spotfn', type => '0 <= int32 <= 4',
desc => 'Grey/black spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' }, desc => 'Grey/black spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' },
{ name => 'red_ang', type => '0.0 <= float <= 360.0', { name => 'red_ang', type => '0.0 <= double <= 360.0',
desc => 'Red/cyan screen angle (degrees)' }, desc => 'Red/cyan screen angle (degrees)' },
{ name => 'red_spotfn', type => '0 <= int32 <= 4', { name => 'red_spotfn', type => '0 <= int32 <= 4',
desc => 'Red/cyan spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' }, desc => 'Red/cyan spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' },
{ name => 'grn_ang', type => '0.0 <= float <= 360.0', { name => 'grn_ang', type => '0.0 <= double <= 360.0',
desc => 'Green/magenta screen angle (degrees)' }, desc => 'Green/magenta screen angle (degrees)' },
{ name => 'grn_spotfn', type => '0 <= int32 <= 4', { name => 'grn_spotfn', type => '0 <= int32 <= 4',
desc => 'Green/magenta spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' }, desc => 'Green/magenta spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' },
{ name => 'blu_ang', type => '0.0 <= float <= 360.0', { name => 'blu_ang', type => '0.0 <= double <= 360.0',
desc => 'Blue/yellow screen angle (degrees)' }, desc => 'Blue/yellow screen angle (degrees)' },
{ name => 'blu_spotfn', type => '0 <= int32 <= 4', { name => 'blu_spotfn', type => '0 <= int32 <= 4',
desc => 'Blue/yellow spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' }, desc => 'Blue/yellow spot function { DOTS (0), LINES (1), DIAMONDS (2), EUCLIDIAN-DOT (3), PS-DIAMONDS (4) }' },
@@ -2937,7 +2937,7 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'tile_size', type => '1 <= int32', { name => 'tile_size', type => '1 <= int32',
desc => 'Tile size (pixels)' }, desc => 'Tile size (pixels)' },
{ name => 'move_max', type => '1.0 <= float <= 100.0', { name => 'move_max', type => '1.0 <= double <= 100.0',
desc => 'Max move rate (%)' }, desc => 'Max move rate (%)' },
{ name => 'fractional_type', type => '0 <= int32 <= 2', { name => 'fractional_type', type => '0 <= int32 <= 2',
desc => 'Fractional type { BACKGROUND (0), IGNORE (1), FORCE (2) }' }, desc => 'Fractional type { BACKGROUND (0), IGNORE (1), FORCE (2) }' },
@@ -3052,13 +3052,13 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'mask_radius', type => '3.0 <= float <= 50.0', { name => 'mask_radius', type => '3.0 <= double <= 50.0',
desc => 'Photocopy mask radius (radius of pixel neighborhood)' }, desc => 'Photocopy mask radius (radius of pixel neighborhood)' },
{ name => 'sharpness', type => '0.0 <= float <= 1.0', { name => 'sharpness', type => '0.0 <= double <= 1.0',
desc => 'Sharpness (detail level)' }, desc => 'Sharpness (detail level)' },
{ name => 'pct_black', type => '0.0 <= float <= 1.0', { name => 'pct_black', type => '0.0 <= double <= 1.0',
desc => 'Percentage of darkened pixels to set to black' }, desc => 'Percentage of darkened pixels to set to black' },
{ name => 'pct_white', type => '0.0 <= float <= 1.0', { name => 'pct_white', type => '0.0 <= double <= 1.0',
desc => 'Percentage of non-darkened pixels left white' }, desc => 'Percentage of non-darkened pixels left white' },
); );
@@ -3159,7 +3159,7 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'seed', type => '-1 <= int32 <= G_MAXINT', { name => 'seed', type => '-1 <= int32 <= G_MAXINT',
desc => 'Random seed' }, desc => 'Random seed' },
{ name => 'turbulence', type => '0.0 <= float <= 7.0', { name => 'turbulence', type => '0.0 <= double <= 7.0',
desc => 'The value of the turbulence' } desc => 'The value of the turbulence' }
); );
@@ -3219,9 +3219,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'circle', type => '0.0 <= float <= 100.0', { name => 'circle', type => '0.0 <= double <= 100.0',
desc => 'Circle depth in %' }, desc => 'Circle depth in %' },
{ name => 'angle', type => '0.0 <= float < 360.0', { name => 'angle', type => '0.0 <= double < 360.0',
desc => 'Offset angle' }, desc => 'Offset angle' },
{ name => 'backwards', type => 'boolean', { name => 'backwards', type => 'boolean',
desc => 'Map backwards' }, desc => 'Map backwards' },
@@ -3281,9 +3281,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'rndm_pct', type => '0.0 <= float <= 100.0', { name => 'rndm_pct', type => '0.0 <= double <= 100.0',
desc => 'Randomization percentage' }, desc => 'Randomization percentage' },
{ name => 'rndm_rcount', type => '1.0 <= float <= 100.0', { name => 'rndm_rcount', type => '1.0 <= double <= 100.0',
desc => 'Repeat count' }, desc => 'Repeat count' },
{ name => 'randomize', type => 'boolean', { name => 'randomize', type => 'boolean',
desc => 'Use random seed' }, desc => 'Use random seed' },
@@ -3342,9 +3342,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'rndm_pct', type => '1.0 <= float <= 100.0', { name => 'rndm_pct', type => '1.0 <= double <= 100.0',
desc => 'Randomization percentage' }, desc => 'Randomization percentage' },
{ name => 'rndm_rcount', type => '1.0 <= float <= 100.0', { name => 'rndm_rcount', type => '1.0 <= double <= 100.0',
desc => 'Repeat count' }, desc => 'Repeat count' },
{ name => 'randomize', type => 'boolean', { name => 'randomize', type => 'boolean',
desc => 'Use random seed' }, desc => 'Use random seed' },
@@ -3403,9 +3403,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'rndm_pct', type => '1.0 <= float <= 100.0', { name => 'rndm_pct', type => '1.0 <= double <= 100.0',
desc => 'Randomization percentage' }, desc => 'Randomization percentage' },
{ name => 'rndm_rcount', type => '1.0 <= float <= 100.0', { name => 'rndm_rcount', type => '1.0 <= double <= 100.0',
desc => 'Repeat count' }, desc => 'Repeat count' },
{ name => 'randomize', type => 'boolean', { name => 'randomize', type => 'boolean',
desc => 'Use random seed' }, desc => 'Use random seed' },
@@ -3518,13 +3518,13 @@ HELP
desc => 'Noise in channels independent' }, desc => 'Noise in channels independent' },
{ name => 'correlated', type => 'boolean', { name => 'correlated', type => 'boolean',
desc => 'Noise correlated (i.e. multiplicative not additive)' }, desc => 'Noise correlated (i.e. multiplicative not additive)' },
{ name => 'noise_1', type => '0.0 <= float <= 1.0', { name => 'noise_1', type => '0.0 <= double <= 1.0',
desc => 'Noise in the first channel (red, gray)' }, desc => 'Noise in the first channel (red, gray)' },
{ name => 'noise_2', type => '0.0 <= float <= 1.0', { name => 'noise_2', type => '0.0 <= double <= 1.0',
desc => 'Noise in the second channel (green, gray_alpha)' }, desc => 'Noise in the second channel (green, gray_alpha)' },
{ name => 'noise_3', type => '0.0 <= float <= 1.0', { name => 'noise_3', type => '0.0 <= double <= 1.0',
desc => 'Noise in the third channel (blue)' }, desc => 'Noise in the third channel (blue)' },
{ name => 'noise_4', type => '0.0 <= float <= 1.0', { name => 'noise_4', type => '0.0 <= double <= 1.0',
desc => 'Noise in the fourth channel (alpha)' } desc => 'Noise in the fourth channel (alpha)' }
); );
@@ -3597,9 +3597,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'period', type => ' 0.0 < float < 1000.0', { name => 'period', type => ' 0.0 < double < 1000.0',
default => 200.0, desc => 'Period: number of pixels for one wave to complete' }, default => 200.0, desc => 'Period: number of pixels for one wave to complete' },
{ name => 'amplitude', type => ' 0.0 < float < 1000.0', { name => 'amplitude', type => ' 0.0 < double < 1000.0',
default => 25.0, desc => 'Amplitude: maximum displacement of wave' }, default => 25.0, desc => 'Amplitude: maximum displacement of wave' },
{ name => 'orientation', type => '0 <= int32 <= 1', { name => 'orientation', type => '0 <= int32 <= 1',
desc => 'Orientation { ORIENTATION-HORIZONTAL (0), ORIENTATION-VERTICAL (1) }' }, desc => 'Orientation { ORIENTATION-HORIZONTAL (0), ORIENTATION-VERTICAL (1) }' },
@@ -3734,13 +3734,13 @@ HELP
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'independent', type => 'boolean', { name => 'independent', type => 'boolean',
desc => 'Noise in channels independent' }, desc => 'Noise in channels independent' },
{ name => 'noise_1', type => '0.0 <= float <= 1.0', { name => 'noise_1', type => '0.0 <= double <= 1.0',
desc => 'Noise in the first channel (red, gray)' }, desc => 'Noise in the first channel (red, gray)' },
{ name => 'noise_2', type => '0.0 <= float <= 1.0', { name => 'noise_2', type => '0.0 <= double <= 1.0',
desc => 'Noise in the second channel (green, gray_alpha)' }, desc => 'Noise in the second channel (green, gray_alpha)' },
{ name => 'noise_3', type => '0.0 <= float <= 1.0', { name => 'noise_3', type => '0.0 <= double <= 1.0',
desc => 'Noise in the third channel (blue)' }, desc => 'Noise in the third channel (blue)' },
{ name => 'noise_4', type => '0.0 <= float <= 1.0', { name => 'noise_4', type => '0.0 <= double <= 1.0',
desc => 'Noise in the fourth channel (alpha)' } desc => 'Noise in the fourth channel (alpha)' }
); );
@@ -3815,7 +3815,7 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'radius', type => '1.0 <= float <= 1000.0', { name => 'radius', type => '1.0 <= double <= 1000.0',
desc => 'Radius of gaussian blur (in pixels)' }, desc => 'Radius of gaussian blur (in pixels)' },
{ name => 'max_delta', type => '0 <= int32 <= 255', { name => 'max_delta', type => '0 <= int32 <= 255',
desc => 'Maximum delta' } desc => 'Maximum delta' }
@@ -3963,11 +3963,11 @@ sub plug_in_sinus {
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'xscale', type => '0.0001 <= float <= 100.0', { name => 'xscale', type => '0.0001 <= double <= 100.0',
desc => 'Scale value for x axis' }, desc => 'Scale value for x axis' },
{ name => 'yscale', type => '0.0001 <= float <= 100.0', { name => 'yscale', type => '0.0001 <= double <= 100.0',
desc => 'Scale value for y axis' }, desc => 'Scale value for y axis' },
{ name => 'complex', type => '0 <= float', { name => 'complex', type => '0 <= double',
desc => 'Complexity factor' }, desc => 'Complexity factor' },
{ name => 'seed', type => '0 <= int32', { name => 'seed', type => '0 <= int32',
desc => 'Seed value for random number generator' }, desc => 'Seed value for random number generator' },
@@ -3981,13 +3981,13 @@ sub plug_in_sinus {
desc => 'fist color (sometimes unused)' }, desc => 'fist color (sometimes unused)' },
{ name => 'col2', type => 'geglcolor', { name => 'col2', type => 'geglcolor',
desc => 'second color (sometimes unused)' }, desc => 'second color (sometimes unused)' },
{ name => 'alpha1', type => '0 <= float <= 1', { name => 'alpha1', type => '0 <= double <= 1',
desc => 'alpha for the first color (used if the drawable has an alpha channel)' }, desc => 'alpha for the first color (used if the drawable has an alpha channel)' },
{ name => 'alpha2', type => '0 <= float <= 1', { name => 'alpha2', type => '0 <= double <= 1',
desc => 'alpha for the second color (used if the drawable has an alpha channel)' }, desc => 'alpha for the second color (used if the drawable has an alpha channel)' },
{ name => 'blend', type => '0 <= int32 <= 2', { name => 'blend', type => '0 <= int32 <= 2',
desc => '0=linear, 1=bilinear, 2=sinusoidal' }, desc => '0=linear, 1=bilinear, 2=sinusoidal' },
{ name => 'blend_power', type => 'float', { name => 'blend_power', type => 'double',
desc => 'Power used to stretch the blend' } desc => 'Power used to stretch the blend' }
); );
@@ -4143,11 +4143,11 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'glow_radius', type => '1.0 <= float <= 50.0', { name => 'glow_radius', type => '1.0 <= double <= 50.0',
desc => 'Glow radius in pixels' }, desc => 'Glow radius in pixels' },
{ name => 'brightness', type => '0.0 <= float <= 1.0', { name => 'brightness', type => '0.0 <= double <= 1.0',
desc => 'Glow brightness' }, desc => 'Glow brightness' },
{ name => 'sharpness', type => '0.0 <= float <= 1.0', { name => 'sharpness', type => '0.0 <= double <= 1.0',
desc => 'Glow sharpness' } desc => 'Glow sharpness' }
); );
@@ -4205,9 +4205,9 @@ HELP
desc => 'Random seed' }, desc => 'Random seed' },
{ name => 'detail', type => '0 <= int32 <= 15', { name => 'detail', type => '0 <= int32 <= 15',
desc => 'Detail level' }, desc => 'Detail level' },
{ name => 'xsize', type => '0.1 <= float <= 16.0', { name => 'xsize', type => '0.1 <= double <= 16.0',
desc => 'Horizontal texture size' }, desc => 'Horizontal texture size' },
{ name => 'ysize', type => '0.1 <= float <= 16.0', { name => 'ysize', type => '0.1 <= double <= 16.0',
desc => 'Vertical texture size' } desc => 'Vertical texture size' }
); );
@@ -4266,9 +4266,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'spread_amount_x', type => '0 <= float <= 512', { name => 'spread_amount_x', type => '0 <= double <= 512',
desc => 'Horizontal spread amount' }, desc => 'Horizontal spread amount' },
{ name => 'spread_amount_y', type => '0 <= float <= 512', { name => 'spread_amount_y', type => '0 <= double <= 512',
desc => 'Vertical spread amount' } desc => 'Vertical spread amount' }
); );
@@ -4366,9 +4366,9 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'radius', type => '0.0 <= float <= 300.0', { name => 'radius', type => '0.0 <= double <= 300.0',
desc => 'Radius of gaussian blur' }, desc => 'Radius of gaussian blur' },
{ name => 'amount', type => '0.0 <= float <= 300.0', { name => 'amount', type => '0.0 <= double <= 300.0',
desc => 'Strength of effect' }, desc => 'Strength of effect' },
{ name => 'threshold', type => '0 <= int32 <= 255', { name => 'threshold', type => '0 <= int32 <= 255',
desc => 'Threshold' } desc => 'Threshold' }
@@ -4522,7 +4522,7 @@ HELP
desc => 'Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }' }, desc => 'Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }' },
{ name => 'propagating_channel', type => 'int32', { name => 'propagating_channel', type => 'int32',
desc => 'Channels which values are propagated' }, desc => 'Channels which values are propagated' },
{ name => 'propagating_rate', type => '0.0 <= float <= 1.0', { name => 'propagating_rate', type => '0.0 <= double <= 1.0',
desc => 'Propagating rate' }, desc => 'Propagating rate' },
{ name => 'direction_mask', type => '0 <= int32 <= 15', { name => 'direction_mask', type => '0 <= int32 <= 15',
desc => 'Direction mask' }, desc => 'Direction mask' },
@@ -4629,7 +4629,7 @@ HELP
desc => 'Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }' }, desc => 'Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }' },
{ name => 'propagating_channel', type => 'int32', dead => 1, { name => 'propagating_channel', type => 'int32', dead => 1,
desc => 'Channels which values are propagated' }, desc => 'Channels which values are propagated' },
{ name => 'propagating_rate', type => '0.0 <= float <= 1.0', dead => 1, { name => 'propagating_rate', type => '0.0 <= double <= 1.0', dead => 1,
desc => 'Propagating rate' }, desc => 'Propagating rate' },
{ name => 'direction_mask', type => '0 <= int32 <= 15', dead => 1, { name => 'direction_mask', type => '0 <= int32 <= 15', dead => 1,
desc => 'Direction mask' }, desc => 'Direction mask' },
@@ -4694,7 +4694,7 @@ HELP
desc => 'Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }' }, desc => 'Propagate mode { 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent }' },
{ name => 'propagating_channel', type => 'int32', dead => 1, { name => 'propagating_channel', type => 'int32', dead => 1,
desc => 'Channels which values are propagated' }, desc => 'Channels which values are propagated' },
{ name => 'propagating_rate', type => '0.0 <= float <= 1.0', dead => 1, { name => 'propagating_rate', type => '0.0 <= double <= 1.0', dead => 1,
desc => 'Propagating rate' }, desc => 'Propagating rate' },
{ name => 'direction_mask', type => '0 <= int32 <= 15', dead => 1, { name => 'direction_mask', type => '0 <= int32 <= 15', dead => 1,
desc => 'Direction mask' }, desc => 'Direction mask' },
@@ -4755,11 +4755,11 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'amplitude', type => '0 <= float <= 101', { name => 'amplitude', type => '0 <= double <= 101',
desc => 'The Amplitude of the Waves' }, desc => 'The Amplitude of the Waves' },
{ name => 'phase', type => '-360 <= float <= 360', { name => 'phase', type => '-360 <= double <= 360',
desc => 'The Phase of the Waves' }, desc => 'The Phase of the Waves' },
{ name => 'wavelength', type => '0.1 <= float <= 100', { name => 'wavelength', type => '0.1 <= double <= 100',
desc => 'The Wavelength of the Waves' }, desc => 'The Wavelength of the Waves' },
{ name => 'type', type => 'boolean', { name => 'type', type => 'boolean',
desc => 'Type of waves: { 0 = smeared, 1 = black }' }, desc => 'Type of waves: { 0 = smeared, 1 = black }' },
@@ -4830,11 +4830,11 @@ HELP
desc => 'Input image (unused)' }, desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'Input drawable' }, desc => 'Input drawable' },
{ name => 'whirl', type => '-720 <= float <= 720', { name => 'whirl', type => '-720 <= double <= 720',
desc => 'Whirl angle (degrees)' }, desc => 'Whirl angle (degrees)' },
{ name => 'pinch', type => '-1 <= float <= 1', { name => 'pinch', type => '-1 <= double <= 1',
desc => 'Pinch amount' }, desc => 'Pinch amount' },
{ name => 'radius', type => '0 <= float <= 2', { name => 'radius', type => '0 <= double <= 2',
desc => 'Radius (1.0 is the largest circle that fits in the image, and 2.0 goes all the way to the corners)' } desc => 'Radius (1.0 is the largest circle that fits in the image, and 2.0 goes all the way to the corners)' }
); );

2
pdb/groups/progress.pdb
View File

@@ -66,7 +66,7 @@ HELP
$lib_private = 1; $lib_private = 1;
@inargs = ( @inargs = (
{ name => 'percentage', type => 'float', { name => 'percentage', type => 'double',
desc => 'Percentage of progress completed which must desc => 'Percentage of progress completed which must
be between 0.0 and 1.0' } be between 0.0 and 1.0' }
); );

2
pdb/groups/selection.pdb
View File

@@ -353,7 +353,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'image', type => 'image', { name => 'image', type => 'image',
desc => 'The image' }, desc => 'The image' },
{ name => 'radius', type => '0 <= float', { name => 'radius', type => '0 <= double',
desc => 'Radius of feather (in pixels)' } desc => 'Radius of feather (in pixels)' }
); );

24
pdb/groups/text_layer.pdb
View File

@@ -40,7 +40,7 @@ HELP
desc => 'The text to generate (in UTF-8 encoding)' }, desc => 'The text to generate (in UTF-8 encoding)' },
{ name => 'font', type => 'font', { name => 'font', type => 'font',
desc => 'The font to write the text with' }, desc => 'The font to write the text with' },
{ name => 'size', type => '0.0 <= float <= 8192.0', { name => 'size', type => '0.0 <= double <= 8192.0',
desc => 'The size of text in either pixels or points' }, desc => 'The size of text in either pixels or points' },
{ name => 'unit', type => 'unit', allow_pixel => 1, { name => 'unit', type => 'unit', allow_pixel => 1,
desc => 'The units of specified size' } desc => 'The units of specified size' }
@@ -294,7 +294,7 @@ sub text_layer_get_font_size {
$help = <<'HELP'; $help = <<'HELP';
This procedure returns the size of the font which is used in a text This procedure returns the size of the font which is used in a text
layer. You will receive the size as a float 'font-size' in 'unit' layer. You will receive the size as a double 'font-size' in 'unit'
units. units.
HELP HELP
@@ -306,7 +306,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'font_size', type => 'float', { name => 'font_size', type => 'double',
desc => 'The font size' }, desc => 'The font size' },
{ name => 'unit', type => 'unit', { name => 'unit', type => 'unit',
desc => 'The unit used for the font size' } desc => 'The unit used for the font size' }
@@ -337,7 +337,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'layer', type => 'text_layer', { name => 'layer', type => 'text_layer',
desc => 'The text layer' }, desc => 'The text layer' },
{ name => 'font_size', type => '0.0 <= float <= 8192.0', { name => 'font_size', type => '0.0 <= double <= 8192.0',
desc => 'The font size' }, desc => 'The font size' },
{ name => 'unit', type => 'unit', { name => 'unit', type => 'unit',
desc => 'The unit to use for the font size' } desc => 'The unit to use for the font size' }
@@ -785,7 +785,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'indent', type => 'float', { name => 'indent', type => 'double',
desc => 'The indentation value of the first line.' } desc => 'The indentation value of the first line.' }
); );
@@ -812,7 +812,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'layer', type => 'text_layer', { name => 'layer', type => 'text_layer',
desc => 'The text layer' }, desc => 'The text layer' },
{ name => 'indent', type => '-8192.0 <= float <= 8192.0', { name => 'indent', type => '-8192.0 <= double <= 8192.0',
desc => 'The indentation for the first line.' } desc => 'The indentation for the first line.' }
); );
@@ -843,7 +843,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'line_spacing', type => 'float', { name => 'line_spacing', type => 'double',
desc => 'The line-spacing value.' } desc => 'The line-spacing value.' }
); );
@@ -870,7 +870,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'layer', type => 'text_layer', { name => 'layer', type => 'text_layer',
desc => 'The text layer' }, desc => 'The text layer' },
{ name => 'line_spacing', type => '-8192.0 <= float <= 8192.0', { name => 'line_spacing', type => '-8192.0 <= double <= 8192.0',
desc => 'The additional line spacing to use.' } desc => 'The additional line spacing to use.' }
); );
@@ -902,7 +902,7 @@ HELP
); );
@outargs = ( @outargs = (
{ name => 'letter_spacing', type => 'float', { name => 'letter_spacing', type => 'double',
desc => 'The letter-spacing value.' } desc => 'The letter-spacing value.' }
); );
@@ -930,7 +930,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'layer', type => 'text_layer', { name => 'layer', type => 'text_layer',
desc => 'The text layer' }, desc => 'The text layer' },
{ name => 'letter_spacing', type => '-8192.0 <= float <= 8192.0', { name => 'letter_spacing', type => '-8192.0 <= double <= 8192.0',
desc => 'The additional letter spacing to use.' } desc => 'The additional letter spacing to use.' }
); );
@@ -960,9 +960,9 @@ HELP
@inargs = ( @inargs = (
{ name => 'layer', type => 'text_layer', { name => 'layer', type => 'text_layer',
desc => 'The text layer' }, desc => 'The text layer' },
{ name => 'width', type => '0.0 <= float <= GIMP_MAX_IMAGE_SIZE', { name => 'width', type => '0.0 <= double <= GIMP_MAX_IMAGE_SIZE',
desc => 'The new box width in pixels' }, desc => 'The new box width in pixels' },
{ name => 'height', type => '0.0 <= float <= GIMP_MAX_IMAGE_SIZE', { name => 'height', type => '0.0 <= double <= GIMP_MAX_IMAGE_SIZE',
desc => 'The new box height in pixels' }, desc => 'The new box height in pixels' },
); );

8
pdb/groups/text_tool.pdb
View File

@@ -43,9 +43,9 @@ HELP
{ name => 'drawable', type => 'drawable', { name => 'drawable', type => 'drawable',
desc => 'The affected drawable: (%NULL for a new text layer)', desc => 'The affected drawable: (%NULL for a new text layer)',
none_ok => 1 }, none_ok => 1 },
{ name => 'x', type => 'float', { name => 'x', type => 'double',
desc => 'The x coordinate for the left of the text bounding box' }, desc => 'The x coordinate for the left of the text bounding box' },
{ name => 'y', type => 'float', { name => 'y', type => 'double',
desc => 'The y coordinate for the top of the text bounding box' }, desc => 'The y coordinate for the top of the text bounding box' },
{ name => 'text', type => 'string', { name => 'text', type => 'string',
desc => 'The text to generate (in UTF-8 encoding)' }, desc => 'The text to generate (in UTF-8 encoding)' },
@@ -53,7 +53,7 @@ HELP
desc => 'The size of the border' }, desc => 'The size of the border' },
{ name => 'antialias', type => 'boolean', { name => 'antialias', type => 'boolean',
desc => 'Antialiasing' }, desc => 'Antialiasing' },
{ name => 'size', type => '0 < float', { name => 'size', type => '0 < double',
desc => 'The size of text in pixels' }, desc => 'The size of text in pixels' },
{ name => 'font', type => 'font', { name => 'font', type => 'font',
desc => 'The font' } desc => 'The font' }
@@ -107,7 +107,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'text', type => 'string', { name => 'text', type => 'string',
desc => 'The text to generate (in UTF-8 encoding)' }, desc => 'The text to generate (in UTF-8 encoding)' },
{ name => 'size', type => '0 < float', { name => 'size', type => '0 < double',
desc => 'The size of text in either pixels or points' }, desc => 'The size of text in either pixels or points' },
{ name => 'font', type => 'font', { name => 'font', type => 'font',
desc => 'The name of the font' } desc => 'The name of the font' }

4
pdb/groups/unit.pdb
View File

@@ -37,7 +37,7 @@ HELP
@outargs = ( @outargs = (
{ name => 'name', type => 'string', { name => 'name', type => 'string',
desc => "The unit's name" }, desc => "The unit's name" },
{ name => 'factor', type => 'float', { name => 'factor', type => 'double',
desc => "The unit's factor" }, desc => "The unit's factor" },
{ name => 'digits', type => 'int32', { name => 'digits', type => 'int32',
desc => "The unit's number of digits" }, desc => "The unit's number of digits" },
@@ -82,7 +82,7 @@ HELP
@inargs = ( @inargs = (
{ name => 'name', type => 'string', non_empty => 1, { name => 'name', type => 'string', non_empty => 1,
desc => "The new unit's name" }, desc => "The new unit's name" },
{ name => 'factor', type => 'float', { name => 'factor', type => 'double',
desc => "The new unit's factor" }, desc => "The new unit's factor" },
{ name => 'digits', type => 'int32', { name => 'digits', type => 'int32',
desc => "The new unit's digits" }, desc => "The new unit's digits" },

14
pdb/pdb.pl
View File

@@ -37,7 +37,7 @@ package Gimp::CodeGen::pdb;
set_value_func => 'g_value_set_int ($value, $var)', set_value_func => 'g_value_set_int ($value, $var)',
take_value_func => 'g_value_set_int ($value, $var)' }, take_value_func => 'g_value_set_int ($value, $var)' },
float => { name => 'FLOAT', double => { name => 'DOUBLE',
gtype => 'G_TYPE_DOUBLE', gtype => 'G_TYPE_DOUBLE',
type => 'gdouble ', type => 'gdouble ',
const_type => 'gdouble ', const_type => 'gdouble ',
@@ -94,18 +94,18 @@ package Gimp::CodeGen::pdb;
set_value_func => 'gimp_value_set_int32_array ($value, $var, $var_len)', set_value_func => 'gimp_value_set_int32_array ($value, $var, $var_len)',
take_value_func => 'gimp_value_take_int32_array ($value, $var, $var_len)' }, take_value_func => 'gimp_value_take_int32_array ($value, $var, $var_len)' },
floatarray => { name => 'FLOATARRAY', doublearray => { name => 'DOUBLEARRAY',
gtype => 'GIMP_TYPE_FLOAT_ARRAY', gtype => 'GIMP_TYPE_DOUBLE_ARRAY',
type => 'gdouble *', type => 'gdouble *',
const_type => 'const gdouble *', const_type => 'const gdouble *',
array => 1, array => 1,
init_value => 'NULL', init_value => 'NULL',
in_annotate => '(element-type gdouble)', in_annotate => '(element-type gdouble)',
out_annotate => '(element-type gdouble) (transfer full)', out_annotate => '(element-type gdouble) (transfer full)',
get_value_func => '$var = gimp_value_get_float_array ($value, &$var_len)', get_value_func => '$var = gimp_value_get_double_array ($value, &$var_len)',
dup_value_func => '$var = GIMP_VALUES_DUP_FLOAT_ARRAY ($value, $var_len)', dup_value_func => '$var = GIMP_VALUES_DUP_DOUBLE_ARRAY ($value, $var_len)',
set_value_func => 'gimp_value_set_float_array ($value, $var, $var_len)', set_value_func => 'gimp_value_set_double_array ($value, $var, $var_len)',
take_value_func => 'gimp_value_take_float_array ($value, $var, $var_len)' }, take_value_func => 'gimp_value_take_double_array ($value, $var, $var_len)' },
colorarray => { name => 'COLOR_ARRAY', colorarray => { name => 'COLOR_ARRAY',
gtype => 'GIMP_TYPE_COLOR_ARRAY', gtype => 'GIMP_TYPE_COLOR_ARRAY',

40
plug-ins/common/curve-bend.c
View File

@@ -465,29 +465,29 @@ bender_create_procedure (GimpPlugIn *plug_in,
"upper", "upper",
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "upper-point-x", gimp_procedure_add_double_array_argument (procedure, "upper-point-x",
_("Upper point X"), _("Upper point X"),
_("Array of 17 x point coords " _("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"), "{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "upper-point-y", gimp_procedure_add_double_array_argument (procedure, "upper-point-y",
_("Upper point Y"), _("Upper point Y"),
_("Array of 17 y point coords " _("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"), "{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "lower-point-x", gimp_procedure_add_double_array_argument (procedure, "lower-point-x",
_("Lower point X"), _("Lower point X"),
_("Array of 17 x point coords " _("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"), "{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "lower-point-y", gimp_procedure_add_double_array_argument (procedure, "lower-point-y",
_("Lower point Y"), _("Lower point Y"),
_("Array of 17 y point coords " _("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"), "{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE); G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "upper-val-y", gimp_procedure_add_bytes_argument (procedure, "upper-val-y",
_("Upper val Y"), _("Upper val Y"),

4
plug-ins/script-fu/libscriptfu/scheme-marshal-return.c
View File

@@ -479,10 +479,10 @@ marshal_returned_PDB_value (scheme *sc,
result = vector; result = vector;
} }
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value)) else if (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{ {
guint array_length; guint array_length;
const gdouble *v = gimp_value_get_float_array (value, (gsize *) &array_length); const gdouble *v = gimp_value_get_double_array (value, (gsize *) &array_length);
pointer vector = sc->vptr->mk_vector (sc, array_length); pointer vector = sc->vptr->mk_vector (sc, array_length);
for (j = 0; j < array_length; j++) for (j = 0; j < array_length; j++)

4
plug-ins/script-fu/libscriptfu/scheme-wrapper.c
View File

@@ -1163,7 +1163,7 @@ script_fu_marshal_procedure_call (scheme *sc,
debug_vector (sc, vector, "%ld"); debug_vector (sc, vector, "%ld");
} }
} }
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (&value)) else if (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (&value))
{ {
vector = sc->vptr->pair_car (a); vector = sc->vptr->pair_car (a);
if (! sc->vptr->is_vector (vector)) if (! sc->vptr->is_vector (vector))
@@ -1188,7 +1188,7 @@ script_fu_marshal_procedure_call (scheme *sc,
array[j] = (gdouble) sc->vptr->rvalue (v_element); array[j] = (gdouble) sc->vptr->rvalue (v_element);
} }
gimp_value_take_float_array (&value, array, n_elements); gimp_value_take_double_array (&value, array, n_elements);
debug_vector (sc, vector, "%f"); debug_vector (sc, vector, "%f");
} }