procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-02 00:51:14 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

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) ||
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);

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

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

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

@ -1249,7 +1249,7 @@ register_brush_procs (GimpPDB *pdb)
"gimp-brush-get-hardness");
gimp_procedure_set_static_help (procedure,
"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);
gimp_procedure_set_static_attribution (procedure,
"Bill Skaggs <weskaggs@primate.ucdavis.edu>",
@ -1317,7 +1317,7 @@ register_brush_procs (GimpPDB *pdb)
"gimp-brush-get-aspect-ratio");
gimp_procedure_set_static_help (procedure,
"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);
gimp_procedure_set_static_attribution (procedure,
"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);
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;
}
@ -781,7 +781,7 @@ context_set_line_dash_pattern_invoker (GimpProcedure *procedure,
gsize num_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)
{
@ -3827,10 +3827,10 @@ register_context_procs (GimpPDB *pdb)
"Michael Natterer",
"2015");
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("dashes",
"dashes",
"The line dash pattern setting",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("dashes",
"dashes",
"The line dash pattern setting",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -3853,10 +3853,10 @@ register_context_procs (GimpPDB *pdb)
"Michael Natterer",
"2015");
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("dashes",
"dashes",
"The line dash pattern setting",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("dashes",
"dashes",
"The line dash pattern setting",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, 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));
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)
{
@ -260,7 +260,7 @@ drawable_curves_spline_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0));
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)
{
@ -993,10 +993,10 @@ register_drawable_color_procs (GimpPDB *pdb)
GIMP_HISTOGRAM_VALUE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("values",
"values",
"The explicit curve",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("values",
"values",
"The explicit curve",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1028,10 +1028,10 @@ register_drawable_color_procs (GimpPDB *pdb)
GIMP_HISTOGRAM_VALUE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("points",
"points",
"The spline control points: { cp1.x, cp1.y, cp2.x, cp2.y, ... }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("points",
"points",
"The spline control points: { cp1.x, cp1.y, cp2.x, cp2.y, ... }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, 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) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value) ||
GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value) ||
GIMP_VALUE_HOLDS_CORE_OBJECT_ARRAY (value))
{
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,
GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
&color);
/* XXX "float" in PDB are in fact double. */
if (color)
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
@ -209,7 +208,7 @@ gradient_get_uniform_samples_invoker (GimpProcedure *procedure,
error ? *error : NULL);
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;
}
@ -232,7 +231,7 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure,
gdouble *color_samples = NULL;
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));
if (success)
@ -273,7 +272,7 @@ gradient_get_custom_samples_invoker (GimpProcedure *procedure,
error ? *error : NULL);
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;
}
@ -1381,10 +1380,10 @@ register_gradient_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples",
"color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("color-samples",
"color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1411,10 +1410,10 @@ register_gradient_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("positions",
"positions",
"The list of positions to sample along the gradient",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("positions",
"positions",
"The list of positions to sample along the gradient",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("reverse",
"reverse",
@ -1422,10 +1421,10 @@ register_gradient_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("color-samples",
"color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("color-samples",
"color samples",
"Color samples: { R1, G1, B1, A1, ..., Rn, Gn, Bn, An }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, 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));
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)
{
@ -668,10 +668,10 @@ register_image_select_procs (GimpPDB *pdb)
GIMP_CHANNEL_OP_ADD,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("segs",
"segs",
"Array of points: { p1.x, p1.y, p2.x, p2.y, ..., pn.x, pn.y}",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("segs",
"segs",
"Array of points: { p1.x, p1.y, p2.x, p2.y, ..., pn.x, pn.y}",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, 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));
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)
{
@ -164,7 +164,7 @@ airbrush_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -214,7 +214,7 @@ clone_invoker (GimpProcedure *procedure,
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_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)
{
@ -267,7 +267,7 @@ clone_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -313,7 +313,7 @@ convolve_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0));
pressure = g_value_get_double (gimp_value_array_index (args, 1));
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)
{
@ -360,7 +360,7 @@ convolve_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -408,7 +408,7 @@ dodgeburn_invoker (GimpProcedure *procedure,
exposure = g_value_get_double (gimp_value_array_index (args, 1));
dodgeburn_type = g_value_get_enum (gimp_value_array_index (args, 2));
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)
{
@ -456,7 +456,7 @@ dodgeburn_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -500,7 +500,7 @@ eraser_invoker (GimpProcedure *procedure,
gint method;
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));
method = g_value_get_enum (gimp_value_array_index (args, 3));
@ -549,7 +549,7 @@ eraser_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -597,7 +597,7 @@ heal_invoker (GimpProcedure *procedure,
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_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)
{
@ -649,7 +649,7 @@ heal_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -695,7 +695,7 @@ paintbrush_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0));
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));
gradient_length = g_value_get_double (gimp_value_array_index (args, 4));
@ -775,7 +775,7 @@ paintbrush_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -817,7 +817,7 @@ pencil_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -861,7 +861,7 @@ smudge_invoker (GimpProcedure *procedure,
drawable = g_value_get_object (gimp_value_array_index (args, 0));
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)
{
@ -907,7 +907,7 @@ smudge_default_invoker (GimpProcedure *procedure,
const gdouble *strokes;
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)
{
@ -967,10 +967,10 @@ register_paint_tools_procs (GimpPDB *pdb)
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -995,10 +995,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1048,10 +1048,10 @@ register_paint_tools_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1076,10 +1076,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1117,10 +1117,10 @@ register_paint_tools_procs (GimpPDB *pdb)
GIMP_CONVOLVE_BLUR,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1145,10 +1145,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1193,10 +1193,10 @@ register_paint_tools_procs (GimpPDB *pdb)
GIMP_TRANSFER_SHADOWS,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1221,10 +1221,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1249,10 +1249,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("hardness",
"hardness",
@ -1291,10 +1291,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1337,10 +1337,10 @@ register_paint_tools_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1365,10 +1365,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1399,10 +1399,10 @@ register_paint_tools_procs (GimpPDB *pdb)
0, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_enum ("method",
"method",
@ -1440,10 +1440,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1468,10 +1468,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1502,10 +1502,10 @@ register_paint_tools_procs (GimpPDB *pdb)
0, 100, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
@ -1530,10 +1530,10 @@ register_paint_tools_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("strokes",
"strokes",
"Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ..., sn.x, sn.y }",
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, 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)
{
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);
}
@ -730,7 +730,7 @@ path_stroke_new_from_points_invoker (GimpProcedure *procedure,
path = g_value_get_object (gimp_value_array_index (args, 0));
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));
if (success)
@ -839,7 +839,7 @@ path_stroke_interpolate_invoker (GimpProcedure *procedure,
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);
}
@ -1718,10 +1718,10 @@ register_path_procs (GimpPDB *pdb)
GIMP_PATH_STROKE_TYPE_BEZIER,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("controlpoints",
"controlpoints",
"List of the control points for the stroke (x0, y0, x1, y1, ...).",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("controlpoints",
"controlpoints",
"List of the control points for the stroke (x0, y0, x1, y1, ...).",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("closed",
"closed",
@ -1739,7 +1739,7 @@ register_path_procs (GimpPDB *pdb)
"gimp-path-stroke-new-from-points");
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. 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);
gimp_procedure_set_static_attribution (procedure,
"Simon Budig",
@ -1759,10 +1759,10 @@ register_path_procs (GimpPDB *pdb)
GIMP_PATH_STROKE_TYPE_BEZIER,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("controlpoints",
"controlpoints",
"List of the x- and y-coordinates of the control points.",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("controlpoints",
"controlpoints",
"List of the x- and y-coordinates of the control points.",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("closed",
"closed",
@ -1811,10 +1811,10 @@ register_path_procs (GimpPDB *pdb)
-G_MAXDOUBLE, G_MAXDOUBLE, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array ("coords",
"coords",
"List of the coords along the path (x0, y0, x1, y1, ...).",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("coords",
"coords",
"List of the coords along the path (x0, y0, x1, y1, ...).",
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
g_param_spec_boolean ("closed",
"closed",

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

@ -1138,7 +1138,7 @@ plug_in_convmatrix_invoker (GimpProcedure *procedure,
gint bmode;
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));
divisor = g_value_get_double (gimp_value_array_index (args, 5));
offset = g_value_get_double (gimp_value_array_index (args, 6));
@ -5518,10 +5518,10 @@ register_plug_in_compat_procs (GimpPDB *pdb)
FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array ("matrix",
"matrix",
"The 5x5 convolution matrix",
GIMP_PARAM_READWRITE));
gimp_param_spec_double_array ("matrix",
"matrix",
"The 5x5 convolution matrix",
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
g_param_spec_boolean ("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_procedure_set_static_help (procedure,
"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);
gimp_procedure_set_static_attribution (procedure,
"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;
case GP_PARAM_DEF_TYPE_FLOAT:
if (! gimp_scanner_parse_float (scanner,
&param_def.meta.m_float.min_val) ||
! gimp_scanner_parse_float (scanner,
&param_def.meta.m_float.max_val) ||
! gimp_scanner_parse_float (scanner,
&param_def.meta.m_float.default_val))
case GP_PARAM_DEF_TYPE_DOUBLE:
if (! gimp_scanner_parse_double (scanner,
&param_def.meta.m_double.min_val) ||
! gimp_scanner_parse_double (scanner,
&param_def.meta.m_double.max_val) ||
! gimp_scanner_parse_double (scanner,
&param_def.meta.m_double.default_val))
{
token = G_TOKEN_FLOAT;
goto error;
@ -1049,7 +1049,7 @@ plug_in_proc_arg_deserialize (GScanner *scanner,
break;
case GP_PARAM_DEF_TYPE_BOOLEAN:
case GP_PARAM_DEF_TYPE_FLOAT:
case GP_PARAM_DEF_TYPE_DOUBLE:
break;
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);
break;
case GP_PARAM_DEF_TYPE_FLOAT:
case GP_PARAM_DEF_TYPE_DOUBLE:
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]),
param_def.meta.m_float.max_val),
param_def.meta.m_double.max_val),
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",
buf[0], buf[1], buf[2]);
break;

6
app/widgets/gimpgradientselect.c
View file

@ -184,9 +184,9 @@ gimp_gradient_select_run_callback (GimpPdbDialog *dialog,
dialog->caller_context,
NULL, error,
dialog->callback_name,
GIMP_TYPE_RESOURCE, object,
GIMP_TYPE_FLOAT_ARRAY, array,
G_TYPE_BOOLEAN, closing,
GIMP_TYPE_RESOURCE, object,
GIMP_TYPE_DOUBLE_ARRAY, array,
G_TYPE_BOOLEAN, closing,
G_TYPE_NONE);
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_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_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_return_value
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_return_value
gimp_procedure_add_drawable_argument
@ -809,9 +812,6 @@ EXPORTS
gimp_procedure_add_file_argument
gimp_procedure_add_file_aux_argument
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_aux_argument
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. 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
* 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. 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.
*
* 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)
{
*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);
@ -1197,9 +1197,9 @@ gimp_context_set_line_dash_pattern (gsize num_dashes,
gboolean success = TRUE;
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"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,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-drawable-curves-explicit",
@ -273,9 +273,9 @@ gimp_drawable_curves_spline (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_HISTOGRAM_CHANNEL, channel,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"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"))
return gimp_param_spec_int32_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamFloatArray"))
return gimp_param_spec_float_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamDoubleArray"))
return gimp_param_spec_double_array (name, nick, blurb, flags);
if (! strcmp (param_def->type_name, "GimpParamParasite"))
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);
break;
case GP_PARAM_DEF_TYPE_FLOAT:
case GP_PARAM_DEF_TYPE_DOUBLE:
if (! strcmp (param_def->type_name, "GParamDouble"))
return g_param_spec_double (name, nick, blurb,
param_def->meta.m_float.min_val,
param_def->meta.m_float.max_val,
param_def->meta.m_float.default_val,
param_def->meta.m_double.min_val,
param_def->meta.m_double.max_val,
param_def->meta.m_double.default_val,
flags);
break;
@ -388,11 +388,11 @@ _gimp_param_spec_to_gp_param_def (GParamSpec *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_float.max_val = dspec->maximum;
param_def->meta.m_float.default_val = dspec->default_value;
param_def->meta.m_double.min_val = dspec->minimum;
param_def->meta.m_double.max_val = dspec->maximum;
param_def->meta.m_double.default_val = dspec->default_value;
}
/* Must be before G_IS_PARAM_SPEC_STRING() because it's a parent. */
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))
{
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))
{
@ -839,9 +839,9 @@ gimp_gp_param_to_value (gpointer gimp,
param->data.d_array.size /
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 *)
param->data.d_array.data,
param->data.d_array.size /
@ -1135,9 +1135,9 @@ gimp_value_to_gp_param (const GValue *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))
{
@ -1272,7 +1272,7 @@ gimp_value_to_gp_param (const GValue *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);
@ -1550,7 +1550,7 @@ _gimp_gp_params_free (GPParam *params,
switch (params[i].param_type)
{
case GP_PARAM_TYPE_INT:
case GP_PARAM_TYPE_FLOAT:
case GP_PARAM_TYPE_DOUBLE:
break;
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)
{
*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);
@ -239,10 +239,10 @@ gimp_gradient_get_custom_samples (GimpGradient *gradient,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_GRADIENT, gradient,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_BOOLEAN, reverse,
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 (),
"gimp-gradient-get-custom-samples",
@ -256,7 +256,7 @@ gimp_gradient_get_custom_samples (GimpGradient *gradient,
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);

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,
GIMP_TYPE_IMAGE, image,
GIMP_TYPE_CHANNEL_OPS, operation,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"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,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, pressure,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-airbrush",
@ -113,9 +113,9 @@ gimp_airbrush_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-airbrush-default",
@ -177,9 +177,9 @@ gimp_clone (GimpDrawable *drawable,
GIMP_TYPE_CLONE_TYPE, clone_type,
G_TYPE_DOUBLE, src_x,
G_TYPE_DOUBLE, src_y,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-clone",
@ -223,9 +223,9 @@ gimp_clone_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-clone-default",
@ -273,9 +273,9 @@ gimp_convolve (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, pressure,
GIMP_TYPE_CONVOLVE_TYPE, convolve_type,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-convolve",
@ -318,9 +318,9 @@ gimp_convolve_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-convolve-default",
@ -368,9 +368,9 @@ gimp_dodgeburn (GimpDrawable *drawable,
G_TYPE_DOUBLE, exposure,
GIMP_TYPE_DODGE_BURN_TYPE, dodgeburn_type,
GIMP_TYPE_TRANSFER_MODE, dodgeburn_mode,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-dodgeburn",
@ -412,9 +412,9 @@ gimp_dodgeburn_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-dodgeburn-default",
@ -461,11 +461,11 @@ gimp_eraser (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
GIMP_TYPE_BRUSH_APPLICATION_MODE, hardness,
GIMP_TYPE_PAINT_APPLICATION_MODE, method,
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 (),
"gimp-eraser",
@ -508,9 +508,9 @@ gimp_eraser_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-eraser-default",
@ -565,9 +565,9 @@ gimp_heal (GimpDrawable *drawable,
GIMP_TYPE_DRAWABLE, src_drawable,
G_TYPE_DOUBLE, src_x,
G_TYPE_DOUBLE, src_y,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-heal",
@ -613,9 +613,9 @@ gimp_heal_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-heal-default",
@ -670,11 +670,11 @@ gimp_paintbrush (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, fade_out,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
GIMP_TYPE_PAINT_APPLICATION_MODE, method,
G_TYPE_DOUBLE, gradient_length,
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 (),
"gimp-paintbrush",
@ -726,9 +726,9 @@ gimp_paintbrush_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-paintbrush-default",
@ -772,9 +772,9 @@ gimp_pencil (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-pencil",
@ -818,9 +818,9 @@ gimp_smudge (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
G_TYPE_DOUBLE, pressure,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"gimp-smudge",
@ -862,9 +862,9 @@ gimp_smudge_default (GimpDrawable *drawable,
args = gimp_value_array_new_from_types (NULL,
GIMP_TYPE_DRAWABLE, drawable,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
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 (),
"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)
{
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);
}
@ -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
* 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...
* 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...
*
* 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,
GIMP_TYPE_PATH, path,
GIMP_TYPE_PATH_STROKE_TYPE, type,
GIMP_TYPE_FLOAT_ARRAY, NULL,
GIMP_TYPE_DOUBLE_ARRAY, NULL,
G_TYPE_BOOLEAN, closed,
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 (),
"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)
{
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);
}

60
libgimp/gimpprocedure-params.c
View file

@ -398,7 +398,7 @@ gimp_procedure_add_unit_return_value (GimpProcedure *procedure,
* @value: the default value.
* @flags: argument flags.
*
* Add a new double argument to @procedure.
* Add a new floating-point in double precision argument to @procedure.
*
* Since: 3.0
**/
@ -429,7 +429,7 @@ gimp_procedure_add_double_argument (GimpProcedure *procedure,
* @value: the default value.
* @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
**/
@ -460,7 +460,7 @@ gimp_procedure_add_double_aux_argument (GimpProcedure *procedure,
* @value: the default value.
* @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
**/
@ -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.
* @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description.
* @flags: argument flags.
*
* Add a new float array argument to @procedure.
* Add a new double array argument to @procedure.
*
* Since: 3.0
**/
void
gimp_procedure_add_float_array_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
gimp_procedure_add_double_array_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
{
_gimp_procedure_add_argument (procedure,
gimp_param_spec_float_array (name, nick, blurb,
flags));
gimp_param_spec_double_array (name, nick, blurb,
flags));
}
/**
* gimp_procedure_add_float_array_aux_argument:
* gimp_procedure_add_double_array_aux_argument:
* @procedure: the #GimpProcedure.
* @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description.
* @flags: argument flags.
*
* Add a new float array auxiliary argument to @procedure.
* Add a new double array auxiliary argument to @procedure.
*
* Since: 3.0
**/
void
gimp_procedure_add_float_array_aux_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
gimp_procedure_add_double_array_aux_argument (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
{
_gimp_procedure_add_aux_argument (procedure,
gimp_param_spec_float_array (name, nick, blurb,
flags));
gimp_param_spec_double_array (name, nick, blurb,
flags));
}
/**
* gimp_procedure_add_float_array_return_value:
* gimp_procedure_add_double_array_return_value:
* @procedure: the #GimpProcedure.
* @name: the name of the argument to be created.
* @nick: the label used in #GimpProcedureDialog.
* @blurb: a more detailed help description.
* @flags: argument flags.
*
* Add a new float array return value to @procedure.
* Add a new double array return value to @procedure.
*
* Since: 3.0
**/
void
gimp_procedure_add_float_array_return_value (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
gimp_procedure_add_double_array_return_value (GimpProcedure *procedure,
const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
{
_gimp_procedure_add_return_value (procedure,
gimp_param_spec_float_array (name, nick, blurb,
flags));
gimp_param_spec_double_array (name, nick, blurb,
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)
/* float array */
/* double array */
#define GIMP_VALUES_GET_FLOAT_ARRAY(args, n, length) \
gimp_value_get_float_array (gimp_value_array_index (args, n), length)
#define GIMP_VALUES_GET_DOUBLE_ARRAY(args, n, length) \
gimp_value_get_double_array (gimp_value_array_index (args, n), length)
#define GIMP_VALUES_DUP_FLOAT_ARRAY(args, n, length) \
gimp_value_dup_float_array (gimp_value_array_index (args, n), length)
#define GIMP_VALUES_DUP_DOUBLE_ARRAY(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) \
gimp_value_set_float_array (gimp_value_array_index (args, n), value, length)
#define GIMP_VALUES_SET_DOUBLE_ARRAY(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) \
gimp_value_take_float_array (gimp_value_array_index (args, n), value, length)
#define GIMP_VALUES_TAKE_DOUBLE_ARRAY(args, n, value, length) \
gimp_value_take_double_array (gimp_value_array_index (args, n), value, length)
/* string array (strv) */
@ -722,17 +722,17 @@ void gimp_procedure_add_int32_array_return_value (GimpProcedure *procedure
const gchar *blurb,
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 *nick,
const gchar *blurb,
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 *nick,
const gchar *blurb,
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 *nick,
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))
{
gimp_procedure_add_float_array_argument (procedure, "gradient-data",
"Gradient data",
"The gradient data",
G_PARAM_READWRITE);
gimp_procedure_add_double_array_argument (procedure, "gradient-data",
"Gradient data",
"The gradient data",
G_PARAM_READWRITE);
}
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.
*
* 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.
*
* Returns: The font size.

20
libgimpbase/gimpbase.def
View file

@ -48,6 +48,9 @@ EXPORTS
gimp_directory
gimp_directory_file
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_value
gimp_enum_get_value_descriptions
@ -71,9 +74,6 @@ EXPORTS
gimp_flags_value_get_abbrev
gimp_flags_value_get_desc
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_gradient_blend_color_space_get_type
gimp_gradient_segment_color_get_type
@ -129,8 +129,8 @@ EXPORTS
gimp_param_array_get_type
gimp_param_choice_get_type
gimp_param_core_object_array_get_type
gimp_param_double_array_get_type
gimp_param_export_options_get_type
gimp_param_float_array_get_type
gimp_param_int32_array_get_type
gimp_param_memsize_get_type
gimp_param_object_get_type
@ -138,8 +138,8 @@ EXPORTS
gimp_param_spec_array
gimp_param_spec_choice
gimp_param_spec_core_object_array
gimp_param_spec_double_array
gimp_param_spec_export_options
gimp_param_spec_float_array
gimp_param_spec_int32_array
gimp_param_spec_memsize
gimp_param_spec_object_duplicate
@ -249,15 +249,15 @@ EXPORTS
gimp_value_array_remove
gimp_value_array_truncate
gimp_value_array_unref
gimp_value_dup_float_array
gimp_value_dup_double_array
gimp_value_dup_int32_array
gimp_value_get_float_array
gimp_value_get_double_array
gimp_value_get_int32_array
gimp_value_set_float_array
gimp_value_set_double_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_take_float_array
gimp_value_take_double_array
gimp_value_take_int32_array
gimp_wire_clear_error
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;
G_DEFINE_BOXED_TYPE (GimpFloatArray, gimp_float_array, gimp_array_copy, gimp_array_free)
typedef GimpArray GimpDoubleArray;
G_DEFINE_BOXED_TYPE (GimpDoubleArray, gimp_double_array, gimp_array_copy, gimp_array_free)
/**
* gimp_float_array_get_values:
* @array: the #GimpArray representing #float values.
* @length: the number of #float values in the returned array.
* gimp_double_array_get_values:
* @array: the #GimpArray representing #double values.
* @length: the number of #double values in the returned array.
*
* Returns: (array length=length) (transfer none): a C-array of #gdouble.
*/
const gdouble *
gimp_float_array_get_values (GimpArray *array,
gsize *length)
gimp_double_array_get_values (GimpArray *array,
gsize *length)
{
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.
* @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.
*/
void
gimp_float_array_set_values (GimpArray *array,
const gdouble *values,
gsize length,
gboolean static_data)
gimp_double_array_set_values (GimpArray *array,
const gdouble *values,
gsize length,
gboolean static_data)
{
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_float_array_init (GParamSpec *pspec);
static void gimp_param_double_array_class_init (GParamSpecClass *klass);
static void gimp_param_double_array_init (GParamSpec *pspec);
GType
gimp_param_float_array_get_type (void)
gimp_param_double_array_get_type (void)
{
static GType type = 0;
@ -748,77 +748,77 @@ gimp_param_float_array_get_type (void)
{
sizeof (GParamSpecClass),
NULL, NULL,
(GClassInitFunc) gimp_param_float_array_class_init,
(GClassInitFunc) gimp_param_double_array_class_init,
NULL, NULL,
sizeof (GParamSpecBoxed),
0,
(GInstanceInitFunc) gimp_param_float_array_init
(GInstanceInitFunc) gimp_param_double_array_init
};
type = g_type_register_static (GIMP_TYPE_PARAM_ARRAY,
"GimpParamFloatArray", &info, 0);
"GimpParamDoubleArray", &info, 0);
}
return type;
}
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
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.
* @nick: Nick name of the property specified.
* @blurb: Description of the property specified.
* @flags: Flags for the property specified.
*
* Creates a new #GimpParamSpecFloatArray specifying a
* %GIMP_TYPE_FLOAT_ARRAY property.
* Creates a new #GimpParamSpecDoubleArray specifying a
* %GIMP_TYPE_DOUBLE_ARRAY property.
*
* 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
**/
GParamSpec *
gimp_param_spec_float_array (const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
gimp_param_spec_double_array (const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags)
{
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);
return array_spec;
}
/**
* gimp_value_get_float_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY
* gimp_value_get_double_array:
* @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @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
*/
const gdouble *
gimp_value_get_float_array (const GValue *value,
gsize *length)
gimp_value_get_double_array (const GValue *value,
gsize *length)
{
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;
@ -831,21 +831,21 @@ gimp_value_get_float_array (const GValue *value,
}
/**
* gimp_value_dup_float_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY
* gimp_value_dup_double_array:
* @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @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
*/
gdouble *
gimp_value_dup_float_array (const GValue *value,
gsize *length)
gimp_value_dup_double_array (const GValue *value,
gsize *length)
{
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;
@ -858,57 +858,57 @@ gimp_value_dup_float_array (const GValue *value,
}
/**
* gimp_value_set_float_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY
* @data: (array length=length): A #gfloat array
* gimp_value_set_double_array:
* @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @data: (array length=length): A #gdouble array
* @length: The number of elements in @data
*
* Sets the contents of @value to @data.
*/
void
gimp_value_set_float_array (GValue *value,
const gdouble *data,
gsize length)
gimp_value_set_double_array (GValue *value,
const gdouble *data,
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,
length * sizeof (gdouble));
}
/**
* gimp_value_set_static_float_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY
* @data: (array length=length): A #gfloat array
* gimp_value_set_static_double_array:
* @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @data: (array length=length): A #gdouble array
* @length: The number of elements in @data
*
* Sets the contents of @value to @data, without copying the data.
*/
void
gimp_value_set_static_float_array (GValue *value,
const gdouble *data,
gsize length)
gimp_value_set_static_double_array (GValue *value,
const gdouble *data,
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,
length * sizeof (gdouble));
}
/**
* gimp_value_take_float_array:
* @value: A valid value of type %GIMP_TYPE_FLOAT_ARRAY
* @data: (transfer full) (array length=length): A #gfloat array
* gimp_value_take_double_array:
* @value: A valid value of type %GIMP_TYPE_DOUBLE_ARRAY
* @data: (transfer full) (array length=length): A #gdouble array
* @length: The number of elements in @data
*
* Sets the contents of @value to @data, and takes ownership of @data.
*/
void
gimp_value_take_float_array (GValue *value,
gdouble *data,
gsize length)
gimp_value_take_double_array (GValue *value,
gdouble *data,
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,
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_VALUE_HOLDS_FLOAT_ARRAY(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_FLOAT_ARRAY))
#define GIMP_TYPE_DOUBLE_ARRAY (gimp_double_array_get_type ())
#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,
gsize *length);
void gimp_float_array_set_values (GimpArray *array,
const gdouble *values,
gsize length,
gboolean static_data);
const gdouble * gimp_double_array_get_values (GimpArray *array,
gsize *length);
void gimp_double_array_set_values (GimpArray *array,
const gdouble *values,
gsize length,
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_IS_PARAM_SPEC_FLOAT_ARRAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_FLOAT_ARRAY))
#define GIMP_TYPE_PARAM_DOUBLE_ARRAY (gimp_param_double_array_get_type ())
#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,
const gchar *nick,
const gchar *blurb,
GParamFlags flags);
GParamSpec * gimp_param_spec_double_array (const gchar *name,
const gchar *nick,
const gchar *blurb,
GParamFlags flags);
const gdouble * gimp_value_get_float_array (const GValue *value,
gsize *length);
gdouble * gimp_value_dup_float_array (const GValue *value,
gsize *length);
void gimp_value_set_float_array (GValue *value,
const gdouble *data,
gsize length);
void gimp_value_set_static_float_array (GValue *value,
const gdouble *data,
gsize length);
void gimp_value_take_float_array (GValue *value,
gdouble *data,
gsize length);
const gdouble * gimp_value_get_double_array (const GValue *value,
gsize *length);
gdouble * gimp_value_dup_double_array (const GValue *value,
gsize *length);
void gimp_value_set_double_array (GValue *value,
const gdouble *data,
gsize length);
void gimp_value_set_static_double_array (GValue *value,
const gdouble *data,
gsize length);
void gimp_value_take_double_array (GValue *value,
gdouble *data,
gsize length);
/*

28
libgimpbase/gimpprotocol.c
View file

@ -1197,15 +1197,15 @@ _gp_param_def_read (GIOChannel *channel,
return FALSE;
break;
case GP_PARAM_DEF_TYPE_FLOAT:
case GP_PARAM_DEF_TYPE_DOUBLE:
if (! _gimp_wire_read_double (channel,
&param_def->meta.m_float.min_val, 1,
&param_def->meta.m_double.min_val, 1,
user_data) ||
! _gimp_wire_read_double (channel,
&param_def->meta.m_float.max_val, 1,
&param_def->meta.m_double.max_val, 1,
user_data) ||
! _gimp_wire_read_double (channel,
&param_def->meta.m_float.default_val, 1,
&param_def->meta.m_double.default_val, 1,
user_data))
return FALSE;
break;
@ -1316,7 +1316,7 @@ _gp_param_def_destroy (GPParamDef *param_def)
break;
case GP_PARAM_DEF_TYPE_BOOLEAN:
case GP_PARAM_DEF_TYPE_FLOAT:
case GP_PARAM_DEF_TYPE_DOUBLE:
break;
case GP_PARAM_DEF_TYPE_CHOICE:
@ -1557,15 +1557,15 @@ _gp_param_def_write (GIOChannel *channel,
return FALSE;
break;
case GP_PARAM_DEF_TYPE_FLOAT:
case GP_PARAM_DEF_TYPE_DOUBLE:
if (! _gimp_wire_write_double (channel,
&param_def->meta.m_float.min_val, 1,
&param_def->meta.m_double.min_val, 1,
user_data) ||
! _gimp_wire_write_double (channel,
&param_def->meta.m_float.max_val, 1,
&param_def->meta.m_double.max_val, 1,
user_data) ||
! _gimp_wire_write_double (channel,
&param_def->meta.m_float.default_val, 1,
&param_def->meta.m_double.default_val, 1,
user_data))
return FALSE;
break;
@ -1825,9 +1825,9 @@ _gp_params_read (GIOChannel *channel,
goto cleanup;
break;
case GP_PARAM_TYPE_FLOAT:
case GP_PARAM_TYPE_DOUBLE:
if (! _gimp_wire_read_double (channel,
&(*params)[i].data.d_float, 1,
&(*params)[i].data.d_double, 1,
user_data))
goto cleanup;
break;
@ -2178,9 +2178,9 @@ _gp_params_write (GIOChannel *channel,
return;
break;
case GP_PARAM_TYPE_FLOAT:
case GP_PARAM_TYPE_DOUBLE:
if (! _gimp_wire_write_double (channel,
(const gdouble *) &params[i].data.d_float, 1,
(const gdouble *) &params[i].data.d_double, 1,
user_data))
return;
break;
@ -2374,7 +2374,7 @@ _gp_params_destroy (GPParam *params,
switch (params[i].param_type)
{
case GP_PARAM_TYPE_INT:
case GP_PARAM_TYPE_FLOAT:
case GP_PARAM_TYPE_DOUBLE:
break;
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_CHOICE,
GP_PARAM_DEF_TYPE_BOOLEAN,
GP_PARAM_DEF_TYPE_FLOAT,
GP_PARAM_DEF_TYPE_DOUBLE,
GP_PARAM_DEF_TYPE_STRING,
GP_PARAM_DEF_TYPE_GEGL_COLOR,
GP_PARAM_DEF_TYPE_ID,
@ -66,7 +66,7 @@ typedef enum
typedef enum
{
GP_PARAM_TYPE_INT,
GP_PARAM_TYPE_FLOAT,
GP_PARAM_TYPE_DOUBLE,
GP_PARAM_TYPE_STRING,
GP_PARAM_TYPE_STRV,
GP_PARAM_TYPE_BYTES,
@ -91,7 +91,7 @@ typedef struct _GPParamDefInt GPParamDefInt;
typedef struct _GPParamDefUnit GPParamDefUnit;
typedef struct _GPParamDefEnum GPParamDefEnum;
typedef struct _GPParamDefBoolean GPParamDefBoolean;
typedef struct _GPParamDefFloat GPParamDefFloat;
typedef struct _GPParamDefDouble GPParamDefDouble;
typedef struct _GPParamDefString GPParamDefString;
typedef struct _GPParamDefChoice GPParamDefChoice;
typedef struct _GPParamStrv GPParamStrv;
@ -196,7 +196,7 @@ struct _GPParamDefBoolean
gint32 default_val;
};
struct _GPParamDefFloat
struct _GPParamDefDouble
{
gdouble min_val;
gdouble max_val;
@ -253,7 +253,7 @@ struct _GPParamDef
GPParamDefUnit m_unit;
GPParamDefEnum m_enum;
GPParamDefBoolean m_boolean;
GPParamDefFloat m_float;
GPParamDefDouble m_double;
GPParamDefString m_string;
GPParamDefGeglColor m_gegl_color;
GPParamDefID m_id;
@ -314,7 +314,7 @@ struct _GPParam
union
{
gint32 d_int;
gdouble d_float;
gdouble d_double;
gchar *d_string;
gchar **d_strv;
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);
}
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);
}
@ -538,8 +538,8 @@ gimp_config_deserialize_fundamental (GValue *value,
case G_TYPE_FLOAT:
if (next_token == G_TOKEN_FLOAT)
g_value_set_float (value, negate ?
- scanner->value.v_float :
scanner->value.v_float);
- (gfloat) scanner->value.v_float :
(gfloat) scanner->value.v_float);
else
g_value_set_float (value, negate ?
- (gfloat) scanner->value.v_int :
@ -946,7 +946,7 @@ gimp_config_deserialize_array (GValue *value,
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value))
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);
for (gint i = 0; i < n_values; i++)
@ -967,7 +967,7 @@ gimp_config_deserialize_array (GValue *value,
{
gdouble value;
if (! gimp_scanner_parse_float (scanner, &value))
if (! gimp_scanner_parse_double (scanner, &value))
{
result_token = G_TOKEN_FLOAT;
break;
@ -982,7 +982,7 @@ gimp_config_deserialize_array (GValue *value,
if (GIMP_VALUE_HOLDS_INT32_ARRAY (value))
gimp_value_take_int32_array (value, values, n_values);
else
gimp_value_take_float_array (value, (gdouble *) values, n_values);
gimp_value_take_double_array (value, (gdouble *) values, n_values);
}
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,
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,
flags);
copy = gimp_param_spec_double_array (name, nick, blurb, flags);
}
}
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) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{
return gimp_config_serialize_array (value, str);
}
@ -745,7 +745,7 @@ gimp_config_serialize_array (const GValue *value,
GimpArray *array;
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);

2
libgimpconfig/gimpconfig.def
View file

@ -88,7 +88,7 @@ EXPORTS
gimp_scanner_parse_boolean
gimp_scanner_parse_color
gimp_scanner_parse_data
gimp_scanner_parse_float
gimp_scanner_parse_double
gimp_scanner_parse_identifier
gimp_scanner_parse_int
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
* gimp_scanner_new_string()
* @dest: (out): Return location for the parsed float
* @dest: (out): Return location for the parsed double
*
* Returns: %TRUE on success
*
* Since: 2.4
**/
gboolean
gimp_scanner_parse_float (GimpScanner *scanner,
gdouble *dest)
gimp_scanner_parse_double (GimpScanner *scanner,
gdouble *dest)
{
gboolean negate = FALSE;
@ -933,13 +933,13 @@ gimp_scanner_parse_matrix2 (GimpScanner *scanner,
{
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;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[0][1]))
if (! gimp_scanner_parse_double (scanner, &matrix.coeff[0][1]))
goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[1][0]))
if (! gimp_scanner_parse_double (scanner, &matrix.coeff[1][0]))
goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[1][1]))
if (! gimp_scanner_parse_double (scanner, &matrix.coeff[1][1]))
goto finish;
token = G_TOKEN_RIGHT_PAREN;
@ -1030,7 +1030,7 @@ gimp_scanner_parse_deprecated_color (GimpScanner *scanner,
case G_TOKEN_SYMBOL:
{
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;
gboolean is_hsv = FALSE;
gint i;
@ -1055,7 +1055,7 @@ gimp_scanner_parse_deprecated_color (GimpScanner *scanner,
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;
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);
gboolean gimp_scanner_parse_int64 (GimpScanner *scanner,
gint64 *dest);
gboolean gimp_scanner_parse_float (GimpScanner *scanner,
gboolean gimp_scanner_parse_double (GimpScanner *scanner,
gdouble *dest);
gboolean gimp_scanner_parse_boolean (GimpScanner *scanner,
gboolean *dest);

12
pdb/app.pl
View file

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

28
pdb/groups/brush.pdb
View file

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

6
pdb/groups/channel.pdb
View file

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

84
pdb/groups/context.pdb
View file

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

2
pdb/groups/debug.pdb
View file

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

72
pdb/groups/drawable_color.pdb
View file

@ -32,9 +32,9 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The drawable' },
{ name => 'brightness', type => '-1.0 <= float <= 1.0',
{ name => 'brightness', type => '-1.0 <= double <= 1.0',
desc => 'Brightness adjustment' },
{ name => 'contrast', type => '-1.0 <= float <= 1.0',
{ name => 'contrast', type => '-1.0 <= double <= 1.0',
desc => 'Contrast adjustment' }
);
@ -88,11 +88,11 @@ HELP
desc => 'Transfer mode' },
{ name => 'preserve_lum', type => 'boolean',
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' },
{ name => 'magenta_green', type => '-100 <= float <= 100',
{ name => 'magenta_green', type => '-100 <= double <= 100',
desc => 'Magenta-Green color balance' },
{ name => 'yellow_blue', type => '-100 <= float <= 100',
{ name => 'yellow_blue', type => '-100 <= double <= 100',
desc => 'Yellow-Blue color balance' }
);
@ -141,11 +141,11 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The drawable' },
{ name => 'hue', type => '0 <= float <= 360',
{ name => 'hue', type => '0 <= double <= 360',
desc => 'Hue in degrees' },
{ name => 'saturation', type => '0 <= float <= 100',
{ name => 'saturation', type => '0 <= double <= 100',
desc => 'Saturation in percent' },
{ name => 'lightness', type => '-100 <= float <= 100',
{ name => 'lightness', type => '-100 <= double <= 100',
desc => 'Lightness in percent' }
);
@ -197,7 +197,7 @@ HELP
desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel',
desc => 'The channel to modify' },
{ name => 'values', type => 'floatarray',
{ name => 'values', type => 'doublearray',
desc => 'The explicit curve',
array => { name => 'num_values', type => '256 <= size <= 2096',
desc => 'The number of values in the new curve' } }
@ -254,7 +254,7 @@ HELP
desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel',
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,
... }',
array => { name => 'num_points', type => '4 <= size <= 2048',
@ -462,24 +462,24 @@ HELP
desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel',
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' },
{ 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' }
);
@outargs = (
{ name => 'mean', type => 'float', void_ret => 1,
{ name => 'mean', type => 'double', void_ret => 1,
desc => 'Mean intensity value' },
{ name => 'std_dev', type => 'float',
{ name => 'std_dev', type => 'double',
desc => 'Standard deviation of intensity values' },
{ name => 'median', type => 'float',
{ name => 'median', type => 'double',
desc => 'Median intensity value' },
{ name => 'pixels', type => 'float',
{ name => 'pixels', type => 'double',
desc => 'Alpha-weighted pixel count for entire image' },
{ name => 'count', type => 'float',
{ name => 'count', type => 'double',
desc => 'Alpha-weighted pixel count for range' },
{ name => 'percentile', type => 'float',
{ name => 'percentile', type => 'double',
desc => 'Percentile that range falls under' }
);
@ -558,13 +558,13 @@ HELP
desc => 'The drawable' },
{ name => 'hue_range', type => 'enum GimpHueRange',
desc => 'Range of affected hues' },
{ name => 'hue_offset', type => '-180 <= float <= 180',
{ name => 'hue_offset', type => '-180 <= double <= 180',
desc => 'Hue offset in degrees' },
{ name => 'lightness', type => '-100 <= float <= 100',
{ name => 'lightness', type => '-100 <= double <= 100',
desc => 'Lightness modification' },
{ name => 'saturation', type => '-100 <= float <= 100',
{ name => 'saturation', type => '-100 <= double <= 100',
desc => 'Saturation modification' },
{ name => 'overlap', type => '0 <= float <= 100',
{ name => 'overlap', type => '0 <= double <= 100',
desc => 'Overlap other hue channels' }
);
@ -665,17 +665,17 @@ HELP
desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel',
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" },
{ name => 'high_input', type => '0.0 <= float <= 1.0',
{ name => 'high_input', type => '0.0 <= double <= 1.0',
desc => "Intensity of highest input" },
{ name => 'clamp_input', type => 'boolean',
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' },
{ name => 'low_output', type => '0.0 <= float <= 1.0',
{ name => 'low_output', type => '0.0 <= double <= 1.0',
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" },
{ name => 'clamp_output', type => 'boolean',
desc => 'Clamp final output values' },
@ -771,19 +771,19 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The drawable' },
{ name => 'shadows', type => '-100 <= float <= 100',
{ name => 'shadows', type => '-100 <= double <= 100',
desc => 'Adjust exposure of shadows' },
{ name => 'highlights', type => '-100 <= float <= 100',
{ name => 'highlights', type => '-100 <= double <= 100',
desc => 'Adjust exposure of highlights' },
{ name => 'whitepoint', type => '-10 <= float <= 10',
{ name => 'whitepoint', type => '-10 <= double <= 10',
desc => 'Shift white point' },
{ name => 'radius', type => '0.1 <= float <= 1500',
{ name => 'radius', type => '0.1 <= double <= 1500',
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' },
{ name => 'shadows_ccorrect', type => '0 <= float <= 100',
{ name => 'shadows_ccorrect', type => '0 <= double <= 100',
desc => 'Adjust saturation of shadows' },
{ name => 'highlights_ccorrect', type => '0 <= float <= 100',
{ name => 'highlights_ccorrect', type => '0 <= double <= 100',
desc => 'Adjust saturation of highlights' },
);
@ -881,9 +881,9 @@ HELP
desc => 'The drawable' },
{ name => 'channel', type => 'enum GimpHistogramChannel',
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' },
{ name => 'high_threshold', type => '0.0 <= float <= 1.0',
{ name => 'high_threshold', type => '0.0 <= double <= 1.0',
desc => 'The high threshold value' }
);

16
pdb/groups/drawable_edit.pdb
View file

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

4
pdb/groups/gimprc.pdb
View file

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

29
pdb/groups/gradient.pdb
View file

@ -155,7 +155,7 @@ HELP
);
@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 }',
array => { desc => 'Length of the color_samples array (4 *
num_samples)' } }
@ -183,7 +183,6 @@ HELP
pos, reverse,
GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL,
&color);
/* XXX "float" in PDB are in fact double. */
if (color)
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
@ -217,7 +216,7 @@ HELP
@inargs = (
${gradient_arg_spec},
{ name => 'positions', type => 'floatarray',
{ name => 'positions', type => 'doublearray',
desc => 'The list of positions to sample along the gradient',
array => { name => 'num_samples', type => '1 <= size',
desc => 'The number of samples to take' } },
@ -226,7 +225,7 @@ HELP
);
@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 }',
array => { desc => 'Length of the color_samples array (4 *
num_samples)' } }
@ -436,7 +435,7 @@ HELP
);
@outargs = (
{ name => 'pos', type => 'float', void_ret => 1,
{ name => 'pos', type => 'double', void_ret => 1,
desc => 'The return position' }
);
@ -470,7 +469,7 @@ HELP
);
@outargs = (
{ name => 'pos', type => 'float', void_ret => 1,
{ name => 'pos', type => 'double', void_ret => 1,
desc => 'The return position' }
);
@ -504,7 +503,7 @@ HELP
);
@outargs = (
{ name => 'pos', type => 'float', void_ret => 1,
{ name => 'pos', type => 'double', void_ret => 1,
desc => 'The return position' }
);
@ -538,12 +537,12 @@ HELP
@inargs = (
${gradient_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' }
);
@outargs = (
{ name => 'final_pos', type => 'float', void_ret => 1,
{ name => 'final_pos', type => 'double', void_ret => 1,
desc => 'The return position' }
);
@ -585,12 +584,12 @@ HELP
@inargs = (
${gradient_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' }
);
@outargs = (
{ name => 'final_pos', type => 'float', void_ret => 1,
{ name => 'final_pos', type => 'double', void_ret => 1,
desc => 'The return position' }
);
@ -631,12 +630,12 @@ HELP
@inargs = (
${gradient_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' }
);
@outargs = (
{ name => 'final_pos', type => 'float', void_ret => 1,
{ name => 'final_pos', type => 'double', void_ret => 1,
desc => 'The return position' }
);
@ -1197,14 +1196,14 @@ HELP
${gradient_arg_spec},
${gradient_start_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' },
{ name => 'control_compress', type => 'boolean',
desc => 'Whether or not to compress the neighboring segments' }
);
@outargs = (
{ name => 'final_delta', type => 'float',
{ name => 'final_delta', type => 'double',
desc => 'The final delta by which the range moved' }
);

14
pdb/groups/image.pdb
View file

@ -408,16 +408,16 @@ HELP
desc => 'The image' },
{ name => 'drawables', type => 'drawablearray',
desc => 'The drawables to pick from' },
{ name => 'x', type => 'float',
{ name => 'x', type => 'double',
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' },
{ name => 'sample_merged', type => 'boolean',
desc => 'Use the composite image, not the drawables' },
{ name => 'sample_average', type => 'boolean',
desc => 'Average the color of all the pixels in a specified
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' }
);
@ -2608,9 +2608,9 @@ HELP
);
@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' },
{ name => 'yresolution', type => 'float',
{ name => 'yresolution', type => 'double',
desc => 'The resolution in the y-axis, in dots per inch' }
);
@ -2637,9 +2637,9 @@ HELP
@inargs = (
{ name => 'image', type => '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' },
{ name => 'yresolution', type => 'float',
{ name => 'yresolution', type => 'double',
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 = (
{ name => 'xspacing', type => 'float', void_ret => 1,
{ name => 'xspacing', type => 'double', void_ret => 1,
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" }
);
@ -65,9 +65,9 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'xspacing', type => 'float',
{ name => 'xspacing', type => 'double',
desc => "The image's grid horizontal spacing" },
{ name => 'yspacing', type => 'float',
{ name => 'yspacing', type => 'double',
desc => "The image's grid vertical spacing" }
);
@ -104,9 +104,9 @@ HELP
);
@outargs = (
{ name => 'xoffset', type => 'float', void_ret => 1,
{ name => 'xoffset', type => 'double', void_ret => 1,
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" }
);
@ -139,9 +139,9 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'xoffset', type => 'float',
{ name => 'xoffset', type => 'double',
desc => "The image's grid horizontal offset" },
{ name => 'yoffset', type => 'float',
{ name => 'yoffset', type => 'double',
desc => "The image's grid vertical offset" }
);

34
pdb/groups/image_select.pdb
View file

@ -125,10 +125,10 @@ HELP
desc => 'The selection operation' },
{ name => 'drawable', type => 'drawable',
desc => 'The affected drawable' },
{ name => 'x', type => 'float',
{ name => 'x', type => 'double',
desc => 'x coordinate of initial seed fill point: (image
coordinates)' },
{ name => 'y', type => 'float',
{ name => 'y', type => 'double',
desc => 'y coordinate of initial seed fill point: (image
coordinates)' }
);
@ -184,13 +184,13 @@ HELP
desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' },
{ name => 'x', type => 'float',
{ name => 'x', type => 'double',
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' },
{ name => 'width', type => '0 < float',
{ name => 'width', type => '0 < double',
desc => 'The width of the rectangle' },
{ name => 'height', type => '0 < float',
{ name => 'height', type => '0 < double',
desc => 'The height of the rectangle' }
);
@ -235,17 +235,17 @@ HELP
desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' },
{ name => 'x', type => 'float',
{ name => 'x', type => 'double',
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' },
{ name => 'width', type => '0 < float',
{ name => 'width', type => '0 < double',
desc => 'The width of the rectangle' },
{ name => 'height', type => '0 < float',
{ name => 'height', type => '0 < double',
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' },
{ 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' }
);
@ -292,13 +292,13 @@ HELP
desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' },
{ name => 'x', type => 'float',
{ name => 'x', type => 'double',
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' },
{ name => 'width', type => '0 < float',
{ name => 'width', type => '0 < double',
desc => 'The width of the ellipse' },
{ name => 'height', type => '0 < float',
{ name => 'height', type => '0 < double',
desc => 'The height of the ellipse' }
);
@ -348,7 +348,7 @@ HELP
desc => 'The image' },
{ name => 'operation', type => 'enum GimpChannelOps',
desc => 'The selection operation' },
{ name => 'segs', type => 'floatarray',
{ name => 'segs', type => 'doublearray',
desc => 'Array of points: { p1.x, p1.y, p2.x, p2.y, ...,
pn.x, pn.y}',
array => { type => '2 <= size',

82
pdb/groups/item_transform.pdb
View file

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

6
pdb/groups/layer.pdb
View file

@ -44,7 +44,7 @@ HELP
desc => 'The layer type' },
{ name => 'name', type => 'string',
desc => 'The layer name', null_ok => 0 },
{ name => 'opacity', type => '0 <= float <= 100',
{ name => 'opacity', type => '0 <= double <= 100',
desc => 'The layer opacity' },
{ name => 'mode', type => 'enum GimpLayerMode',
default => 'GIMP_LAYER_MODE_NORMAL',
@ -1003,7 +1003,7 @@ sub layer_get_opacity {
);
@outargs = (
{ name => 'opacity', type => '0 <= float <= 100',
{ name => 'opacity', type => '0 <= double <= 100',
desc => 'The layer opacity' }
);
@ -1025,7 +1025,7 @@ sub layer_set_opacity {
@inargs = (
{ name => 'layer', type => 'layer',
desc => 'The layer' },
{ name => 'opacity', type => '0 <= float <= 100',
{ name => 'opacity', type => '0 <= double <= 100',
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>
sub stroke_arg () {
{ name => 'strokes', type => 'floatarray',
{ name => 'strokes', type => 'doublearray',
desc => 'Array of stroke coordinates: { s1.x, s1.y, s2.x, s2.y, ...,
sn.x, sn.y }',
array => { type => '2 <= size',
@ -44,7 +44,7 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The affected drawable' },
{ name => 'pressure', type => '0 <= float <= 100',
{ name => 'pressure', type => '0 <= double <= 100',
desc => 'The pressure of the airbrush strokes' },
&stroke_arg
);
@ -153,9 +153,9 @@ HELP
desc => 'The source drawable' },
{ name => 'clone_type', type => 'enum GimpCloneType',
desc => 'The type of clone' },
{ name => 'src_x', type => 'float',
{ name => 'src_x', type => 'double',
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' },
&stroke_arg
);
@ -305,7 +305,7 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The affected drawable' },
{ name => 'pressure', type => '0 <= float <= 100',
{ name => 'pressure', type => '0 <= double <= 100',
desc => 'The pressure' },
{ name => 'convolve_type', type => 'enum GimpConvolveType',
desc => 'Convolve type' },
@ -516,9 +516,9 @@ HELP
desc => 'The affected drawable' },
{ name => 'src_drawable', type => 'drawable',
desc => 'The source drawable' },
{ name => 'src_x', type => 'float',
{ name => 'src_x', type => 'double',
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' },
&stroke_arg
);
@ -628,12 +628,12 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The affected drawable' },
{ name => 'fade_out', type => '0 <= float',
{ name => 'fade_out', type => '0 <= double',
desc => 'Fade out parameter' },
&stroke_arg,
{ name => 'method', type => 'enum GimpPaintApplicationMode',
desc => 'The paint method to use' },
{ name => 'gradient_length', type => '0 <= float',
{ name => 'gradient_length', type => '0 <= double',
desc => 'Length of gradient to draw' }
);
@ -811,7 +811,7 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The affected drawable' },
{ name => 'pressure', type => '0 <= float <= 100',
{ name => 'pressure', type => '0 <= double <= 100',
desc => 'The pressure of the smudge strokes' },
&stroke_arg
);
@ -906,7 +906,7 @@ HELP
@inargs = (
{ name => 'drawable', type => 'drawable',
desc => 'The affected drawable' },
{ name => 'exposure', type => '0 <= float <= 100',
{ name => 'exposure', type => '0 <= double <= 100',
desc => 'The exposure of the strokes' },
{ name => 'dodgeburn_type', type => 'enum GimpDodgeBurnType',
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' },
{ name => 'stroke_id', type => 'int32',
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' }
);
@outargs = (
{ name => 'length', type => 'float',
{ name => 'length', type => 'double',
desc => 'The length (in pixels) of the given stroke.' }
);
@ -220,18 +220,18 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => 'dist', type => 'float',
{ name => 'dist', type => 'double',
desc => 'The given distance.' },
{ name => 'precision', type => 'float',
{ name => 'precision', type => 'double',
desc => 'The precision used for the approximation' }
);
@outargs = (
{ name => 'x_point', type => 'float', void_ret => 1,
{ name => 'x_point', type => 'double', void_ret => 1,
desc => 'The x position of the point.' },
{ name => 'y_point', type => 'float',
{ name => 'y_point', type => 'double',
desc => 'The y position of the point.' },
{ name => 'slope', type => 'float',
{ name => 'slope', type => 'double',
desc => 'The slope (dy / dx) at the specified point.' },
{ name => 'valid', type => 'boolean',
desc => 'Indicator for the validity of the returned data.' }
@ -392,9 +392,9 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => "off_x", type => 'float',
{ name => "off_x", type => 'double',
desc => "Offset in x direction" },
{ name => "off_y", type => 'float',
{ name => "off_y", type => 'double',
desc => "Offset in y direction" }
);
@ -438,9 +438,9 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => "scale_x", type => 'float',
{ name => "scale_x", type => 'double',
desc => "Scale factor in x direction" },
{ name => "scale_y", type => 'float',
{ name => "scale_y", type => 'double',
desc => "Scale factor in y direction" }
);
@ -483,11 +483,11 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => "center_x", type => 'float',
{ name => "center_x", type => 'double',
desc => "X coordinate of the rotation center" },
{ name => "center_y", type => 'float',
{ name => "center_y", type => 'double',
desc => "Y coordinate of the rotation center" },
{ name => "angle", type => 'float',
{ name => "angle", type => 'double',
desc => "angle to rotate about" }
);
@ -533,7 +533,7 @@ HELP
{ name => "flip_type",
type => 'enum GimpOrientationType (no GIMP_ORIENTATION_UNKNOWN)',
desc => "Flip orientation, either vertical or horizontal" },
{ name => "axis", type => 'float',
{ name => "axis", type => 'double',
desc => "axis coordinate about which to flip, in pixels" }
);
@ -577,13 +577,13 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => "x1", type => 'float',
{ name => "x1", type => 'double',
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" },
{ name => "x2", type => 'float',
{ name => "x2", type => 'double',
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" },
);
@ -635,7 +635,7 @@ HELP
@outargs = (
{ name => 'type', type => 'enum GimpPathStrokeType',
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, ...).',
array => { name => 'num_points',
desc => 'The number of floats returned.' } },
@ -696,12 +696,12 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => 'precision', type => 'float',
{ name => 'precision', type => 'double',
desc => 'The precision used for the approximation' }
);
@outargs = (
{ name => 'coords', type => 'floatarray',
{ name => 'coords', type => 'doublearray',
desc => 'List of the coords along the path (x0, y0, x1, y1, ...).',
array => { name => 'num_coords',
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
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
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.
@ -766,7 +766,7 @@ HELP
desc => 'The path object' },
{ name => 'type', type => 'enum GimpPathStrokeType',
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.',
array => { name => 'num_points',
desc => 'The number of elements in the array, i.e. the
@ -837,9 +837,9 @@ HELP
@inargs = (
{ name => 'path', type => 'path',
desc => 'The path object' },
{ name => 'x0', type => 'float',
{ name => 'x0', type => 'double',
desc => 'The x-coordinate of the moveto' },
{ name => 'y0', type => 'float',
{ name => 'y0', type => 'double',
desc => 'The y-coordinate of the moveto' }
);
@ -894,9 +894,9 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => 'x0', type => 'float',
{ name => 'x0', type => 'double',
desc => 'The x-coordinate of the lineto' },
{ name => 'y0', type => 'float',
{ name => 'y0', type => 'double',
desc => 'The y-coordinate of the lineto' }
);
@ -945,13 +945,13 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => 'x0', type => 'float',
{ name => 'x0', type => 'double',
desc => 'The x-coordinate of the control point' },
{ name => 'y0', type => 'float',
{ name => 'y0', type => 'double',
desc => 'The y-coordinate of the control point' },
{ name => 'x1', type => 'float',
{ name => 'x1', type => 'double',
desc => 'The x-coordinate of the end point' },
{ name => 'y1', type => 'float',
{ name => 'y1', type => 'double',
desc => 'The y-coordinate of the end point' }
);
@ -1002,17 +1002,17 @@ HELP
desc => 'The path object' },
{ name => 'stroke_id', type => 'int32',
desc => 'The stroke ID' },
{ name => 'x0', type => 'float',
{ name => 'x0', type => 'double',
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' },
{ name => 'x1', type => 'float',
{ name => 'x1', type => 'double',
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' },
{ name => 'x2', type => 'float',
{ name => 'x2', type => 'double',
desc => 'The x-coordinate of the end point' },
{ name => 'y2', type => 'float',
{ name => 'y2', type => 'double',
desc => 'The y-coordinate of the end point' }
);
@ -1065,15 +1065,15 @@ HELP
@inargs = (
{ name => 'path', type => 'path',
desc => 'The path object' },
{ name => 'x0', type => 'float',
{ name => 'x0', type => 'double',
desc => 'The x-coordinate of the center' },
{ name => 'y0', type => 'float',
{ name => 'y0', type => 'double',
desc => 'The y-coordinate of the center' },
{ name => 'radius_x', type => 'float',
{ name => 'radius_x', type => 'double',
desc => 'The radius in x direction' },
{ name => 'radius_y', type => 'float',
{ name => 'radius_y', type => 'double',
desc => 'The radius in y direction' },
{ name => 'angle', type => 'float',
{ name => 'angle', type => 'double',
desc => 'The angle the x-axis of the ellipse
(radians, counterclockwise)' }
);

286
pdb/groups/plug_in_compat.pdb
View file

@ -39,17 +39,17 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'redfrequency', type => '0 <= float <= 20',
{ name => 'redfrequency', type => '0 <= double <= 20',
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)' },
{ name => 'greenfrequency', type => '0 <= float <= 20',
{ name => 'greenfrequency', type => '0 <= double <= 20',
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)' },
{ name => 'bluefrequency', type => '0 <= float <= 20',
{ name => 'bluefrequency', type => '0 <= double <= 20',
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)' },
{ name => 'colormodel', type => '0 <= int32 <= 1',
desc => 'Color model { RGB-MODEL (0), HSL-MODEL (1) }' },
@ -204,7 +204,7 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'refraction', type => '1.0 <= float <= 100.0',
{ name => 'refraction', type => '1.0 <= double <= 100.0',
desc => 'Lens refraction index' },
{ name => 'keep_surroundings', type => 'boolean',
desc => 'Keep lens surroundings' },
@ -463,9 +463,9 @@ HELP
desc => 'Input drawable' },
{ name => 'bumpmap', type => 'drawable',
desc => 'Bump map drawable' },
{ name => 'azimuth', type => '0.0 <= float <= 360.0',
{ name => 'azimuth', type => '0.0 <= double <= 360.0',
desc => 'Azimuth' },
{ name => 'elevation', type => '0.5 <= float <= 90.0',
{ name => 'elevation', type => '0.5 <= double <= 90.0',
desc => 'Elevation' },
{ name => 'depth', type => '1 <= int32 <= 65',
desc => 'Depth' },
@ -473,9 +473,9 @@ HELP
desc => 'X offset' },
{ name => 'yofs', type => 'int32',
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' },
{ name => 'ambient', type => '0.0 <= float <= 1.0',
{ name => 'ambient', type => '0.0 <= double <= 1.0',
desc => 'Ambient lighting factor' },
{ name => 'compensate', type => 'boolean',
desc => 'Compensate for darkening' },
@ -531,9 +531,9 @@ HELP
desc => 'Input drawable' },
{ name => 'bumpmap', type => 'drawable',
desc => 'Bump map drawable' },
{ name => 'azimuth', type => '0.0 <= float <= 360.0',
{ name => 'azimuth', type => '0.0 <= double <= 360.0',
desc => 'Azimuth' },
{ name => 'elevation', type => '0.5 <= float <= 90.0',
{ name => 'elevation', type => '0.5 <= double <= 90.0',
desc => 'Elevation' },
{ name => 'depth', type => '1 <= int32 <= 65',
desc => 'Depth' },
@ -541,9 +541,9 @@ HELP
desc => 'X offset' },
{ name => 'yofs', type => 'int32',
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' },
{ name => 'ambient', type => '0.0 <= float <= 1.0',
{ name => 'ambient', type => '0.0 <= double <= 1.0',
desc => 'Ambient lighting factor' },
{ name => 'compensate', type => 'boolean',
desc => 'Compensate for darkening' },
@ -658,9 +658,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ 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' },
);
@ -709,23 +709,23 @@ HELP
desc => 'Input drawable' },
{ name => 'monochrome', type => '0 <= int32 <= 1',
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' },
{ name => 'rg_gain', type => '-2 <= float <= 2',
{ name => 'rg_gain', type => '-2 <= double <= 2',
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' },
{ name => 'gr_gain', type => '-2 <= float <= 2',
{ name => 'gr_gain', type => '-2 <= double <= 2',
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' },
{ name => 'gb_gain', type => '-2 <= float <= 2',
{ name => 'gb_gain', type => '-2 <= double <= 2',
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' },
{ name => 'bg_gain', type => '-2 <= float <= 2',
{ name => 'bg_gain', type => '-2 <= double <= 2',
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' },
);
@ -841,15 +841,15 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'matrix', type => 'floatarray',
{ name => 'matrix', type => 'doublearray',
desc => 'The 5x5 convolution matrix',
array => { name => 'argc_matrix',
desc => 'The number of elements in the following array, must always be 25' } },
{ name => 'alpha_alg', type => 'boolean',
desc => 'Enable weighting by alpha channel' },
{ name => 'divisor', type => 'float',
{ name => 'divisor', type => 'double',
desc => 'Divisor' },
{ name => 'offset', type => 'float',
{ name => 'offset', type => 'double',
desc => 'Offset' },
{ name => 'channels', type => 'int32array',
desc => 'Mask of the channels to be filtered',
@ -979,9 +979,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'tile_saturation', type => '0.0 <= float <= 10.0',
{ name => 'tile_saturation', type => '0.0 <= double <= 10.0',
desc => 'Expand tiles by this amount' },
{ name => 'bg_color', type => '0 <= int32 <= 1',
desc => 'Background color { BLACK (0), BG (1) }' }
@ -1098,29 +1098,29 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'lam_g', type => '0.0 <= float <= 20.0',
{ name => 'lam_g', type => '0.0 <= double <= 20.0',
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)' },
{ name => 'contour_r', type => '0.0 <= float <= 10.0',
{ name => 'contour_r', type => '0.0 <= double <= 10.0',
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)' },
{ name => 'contour_b', type => '0.0 <= float <= 10.0',
{ name => 'contour_b', type => '0.0 <= double <= 10.0',
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)' },
{ name => 'edges_g', type => '0.0 <= float <= 1.0',
{ name => 'edges_g', type => '0.0 <= double <= 1.0',
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)' },
{ name => 'brightness', type => '0.0 <= float <= 1.0',
{ name => 'brightness', type => '0.0 <= double <= 1.0',
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)' },
{ name => 'polarization', type => '-1.0 <= float <= 1.0',
{ name => 'polarization', type => '-1.0 <= double <= 1.0',
desc => 'Polarization' }
);
@ -1185,9 +1185,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'amount_y', type => '-500.0 <= float <= 500.0',
{ name => 'amount_y', type => '-500.0 <= double <= 500.0',
desc => 'Displace multiplier for y direction' },
{ name => 'do_x', type => 'boolean',
desc => 'Displace in x direction ?' },
@ -1238,9 +1238,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'amount_y', type => '-500.0 <= float <= 500.0',
{ name => 'amount_y', type => '-500.0 <= double <= 500.0',
desc => 'Displace multiplier for tangent direction' },
{ name => 'do_x', type => 'boolean',
desc => 'Displace in radial direction ?' },
@ -1291,9 +1291,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'outer', type => '0.0 <= float <= 10.0',
{ name => 'outer', type => '0.0 <= double <= 10.0',
desc => 'Radius of outer gaussian blur in pixels' },
{ name => 'normalize', type => 'boolean',
desc => 'Normalize' },
@ -1377,7 +1377,7 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'amount', type => '1.0 <= float <= 10.0',
{ name => 'amount', type => '1.0 <= double <= 10.0',
desc => 'Edge detection amount' },
{ name => 'warpmode', type => '0 <= int32 <= 3',
desc => 'Edge detection behavior { NONE (0), WRAP (1), SMEAR (2), BLACK (3) }' },
@ -1451,9 +1451,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'elevation', type => '0.0 <= float <= 180',
{ name => 'elevation', type => '0.0 <= double <= 180',
desc => 'The Elevation Angle (degrees)' },
{ name => 'depth', type => '0 < int32 < 100',
default => 1, desc => 'The Filter Width' },
@ -1560,23 +1560,23 @@ HELP
{ name => 'drawable', type => '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)' },
{ name => 'from_green', type => '0.0 <= float <= 1.0',
{ name => 'from_green', type => '0.0 <= double <= 1.0',
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)' },
{ name => 'to_red', type => '0.0 <= float <= 1.0',
{ name => 'to_red', type => '0.0 <= double <= 1.0',
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)' },
{ name => 'to_blue', type => '0.0 <= float <= 1.0',
{ name => 'to_blue', type => '0.0 <= double <= 1.0',
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' },
{ name => 'green_threshold', type => '0.0 <= float <= 1.0',
{ name => 'green_threshold', type => '0.0 <= double <= 1.0',
desc => 'Green threshold' },
{ name => 'blue_threshold', type => '0.0 <= float <= 1.0',
{ name => 'blue_threshold', type => '0.0 <= double <= 1.0',
desc => 'Blue threshold' }
);
@ -1692,13 +1692,13 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'xmax', type => '-50.0 <= float <= 50.0',
{ name => 'xmax', type => '-50.0 <= double <= 50.0',
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' },
{ name => 'ymax', type => '-50.0 <= float <= 50.0',
{ name => 'ymax', type => '-50.0 <= double <= 50.0',
desc => 'ymax fractal image delimiter' },
{ name => 'depth', type => '1 <= int32 <= 65536',
desc => 'Trace depth' },
@ -1767,9 +1767,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'vertical', type => '0.0 <= float <= 1500.0',
{ name => 'vertical', type => '0.0 <= double <= 1500.0',
desc => 'Vertical radius of gaussian blur (in pixels)' },
{ name => 'method', type => '0 <= int32 <= 1',
desc => 'Blur method { AUTO (0), FIR (1), IIR (2) }' }
@ -2010,17 +2010,17 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'offset_x', type => '-100 <= float <= 100',
{ name => 'offset_x', type => '-100 <= double <= 100',
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' },
{ name => 'main_adjust', type => '-100 <= float <= 100',
{ name => 'main_adjust', type => '-100 <= double <= 100',
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' },
{ name => 'rescale', type => '-100 <= float <= 100',
{ name => 'rescale', type => '-100 <= double <= 100',
desc => 'Rescale overall image size' },
{ name => 'brighten', type => '-100 <= float <= 100',
{ name => 'brighten', type => '-100 <= double <= 100',
desc => 'Adjust brightness in corners' }
);
@ -2206,13 +2206,13 @@ HELP
desc => 'Input drawable' },
{ name => 'type', type => '0 <= int32 <= 2',
desc => 'Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }' },
{ name => 'length', type => 'float',
{ name => 'length', type => 'double',
desc => 'Length' },
{ name => 'angle', type => '0 <= float <= 360',
{ name => 'angle', type => '0 <= double <= 360',
desc => 'Angle' },
{ name => 'center_x', type => 'float',
{ name => 'center_x', type => 'double',
desc => 'Center X' },
{ name => 'center_y', type => 'float',
{ name => 'center_y', type => 'double',
desc => 'Center Y' }
);
@ -2300,13 +2300,13 @@ HELP
desc => 'Input drawable' },
{ name => 'type', type => '0 <= int32 <= 2',
desc => 'Type of motion blur { LINEAR (0), RADIAL (1), ZOOM (2) }' },
{ name => 'length', type => 'float',
{ name => 'length', type => 'double',
desc => 'Length' },
{ name => 'angle', type => '0 <= float <= 360',
{ name => 'angle', type => '0 <= double <= 360',
desc => 'Angle' },
{ name => 'center_x', type => 'float',
{ name => 'center_x', type => 'double',
desc => 'Center X' },
{ name => 'center_y', type => 'float',
{ name => 'center_y', type => 'double',
desc => 'Center Y' }
);
@ -2391,7 +2391,7 @@ HELP
desc => 'Input drawable' },
{ name => 'radius', type => '-400 <= int32 <= 400',
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' }
);
@ -2440,19 +2440,19 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'tile_height', type => '1 <= float <= 1000',
{ name => 'tile_height', type => '1 <= double <= 1000',
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)' },
{ name => 'tile_neatness', type => '0 <= float <= 1.0',
{ name => 'tile_neatness', type => '0 <= double <= 1.0',
desc => 'Deviation from perfectly formed tiles' },
{ name => 'tile_allow_split', type => '0 <= int32 <= 1',
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)' },
{ name => 'color_variation', type => '0.0 <= float <= 1.0',
{ name => 'color_variation', type => '0.0 <= double <= 1.0',
desc => 'Magnitude of random color variations' },
{ name => 'antialiasing', type => '0 <= int32 <= 1',
desc => 'Enables smoother tile output at the cost of speed' },
@ -2542,9 +2542,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'amount', type => '0.0 <= float <= 100.0',
{ name => 'amount', type => '0.0 <= double <= 100.0',
desc => 'Effect enhancement variable' }
);
@ -2596,19 +2596,19 @@ sub plug_in_newsprint {
desc => 'Separate to { GRAYSCALE (0), RGB (1), CMYK (2), LUMINANCE (3) }' },
{ name => 'k_pullout', type => '0 <= int32 <= 100',
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)' },
{ name => 'gry_spotfn', type => '0 <= int32 <= 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)' },
{ name => 'red_spotfn', type => '0 <= int32 <= 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)' },
{ name => 'grn_spotfn', type => '0 <= int32 <= 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)' },
{ name => 'blu_spotfn', type => '0 <= int32 <= 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' },
{ name => 'tile_size', type => '1 <= int32',
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 (%)' },
{ name => 'fractional_type', type => '0 <= int32 <= 2',
desc => 'Fractional type { BACKGROUND (0), IGNORE (1), FORCE (2) }' },
@ -3052,13 +3052,13 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'sharpness', type => '0.0 <= float <= 1.0',
{ name => 'sharpness', type => '0.0 <= double <= 1.0',
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' },
{ 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' },
);
@ -3159,7 +3159,7 @@ HELP
desc => 'Input drawable' },
{ name => 'seed', type => '-1 <= int32 <= G_MAXINT',
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' }
);
@ -3219,9 +3219,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'circle', type => '0.0 <= float <= 100.0',
{ name => 'circle', type => '0.0 <= double <= 100.0',
desc => 'Circle depth in %' },
{ name => 'angle', type => '0.0 <= float < 360.0',
{ name => 'angle', type => '0.0 <= double < 360.0',
desc => 'Offset angle' },
{ name => 'backwards', type => 'boolean',
desc => 'Map backwards' },
@ -3281,9 +3281,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'rndm_rcount', type => '1.0 <= float <= 100.0',
{ name => 'rndm_rcount', type => '1.0 <= double <= 100.0',
desc => 'Repeat count' },
{ name => 'randomize', type => 'boolean',
desc => 'Use random seed' },
@ -3342,9 +3342,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'rndm_rcount', type => '1.0 <= float <= 100.0',
{ name => 'rndm_rcount', type => '1.0 <= double <= 100.0',
desc => 'Repeat count' },
{ name => 'randomize', type => 'boolean',
desc => 'Use random seed' },
@ -3403,9 +3403,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'rndm_rcount', type => '1.0 <= float <= 100.0',
{ name => 'rndm_rcount', type => '1.0 <= double <= 100.0',
desc => 'Repeat count' },
{ name => 'randomize', type => 'boolean',
desc => 'Use random seed' },
@ -3518,13 +3518,13 @@ HELP
desc => 'Noise in channels independent' },
{ name => 'correlated', type => 'boolean',
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)' },
{ 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)' },
{ 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)' },
{ 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)' }
);
@ -3597,9 +3597,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ 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' },
{ name => 'orientation', type => '0 <= int32 <= 1',
desc => 'Orientation { ORIENTATION-HORIZONTAL (0), ORIENTATION-VERTICAL (1) }' },
@ -3734,13 +3734,13 @@ HELP
desc => 'Input drawable' },
{ name => 'independent', type => 'boolean',
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)' },
{ 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)' },
{ 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)' },
{ 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)' }
);
@ -3815,7 +3815,7 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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)' },
{ name => 'max_delta', type => '0 <= int32 <= 255',
desc => 'Maximum delta' }
@ -3963,11 +3963,11 @@ sub plug_in_sinus {
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'yscale', type => '0.0001 <= float <= 100.0',
{ name => 'yscale', type => '0.0001 <= double <= 100.0',
desc => 'Scale value for y axis' },
{ name => 'complex', type => '0 <= float',
{ name => 'complex', type => '0 <= double',
desc => 'Complexity factor' },
{ name => 'seed', type => '0 <= int32',
desc => 'Seed value for random number generator' },
@ -3981,13 +3981,13 @@ sub plug_in_sinus {
desc => 'fist color (sometimes unused)' },
{ name => 'col2', type => 'geglcolor',
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)' },
{ 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)' },
{ name => 'blend', type => '0 <= int32 <= 2',
desc => '0=linear, 1=bilinear, 2=sinusoidal' },
{ name => 'blend_power', type => 'float',
{ name => 'blend_power', type => 'double',
desc => 'Power used to stretch the blend' }
);
@ -4143,11 +4143,11 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'brightness', type => '0.0 <= float <= 1.0',
{ name => 'brightness', type => '0.0 <= double <= 1.0',
desc => 'Glow brightness' },
{ name => 'sharpness', type => '0.0 <= float <= 1.0',
{ name => 'sharpness', type => '0.0 <= double <= 1.0',
desc => 'Glow sharpness' }
);
@ -4205,9 +4205,9 @@ HELP
desc => 'Random seed' },
{ name => 'detail', type => '0 <= int32 <= 15',
desc => 'Detail level' },
{ name => 'xsize', type => '0.1 <= float <= 16.0',
{ name => 'xsize', type => '0.1 <= double <= 16.0',
desc => 'Horizontal texture size' },
{ name => 'ysize', type => '0.1 <= float <= 16.0',
{ name => 'ysize', type => '0.1 <= double <= 16.0',
desc => 'Vertical texture size' }
);
@ -4266,9 +4266,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'spread_amount_x', type => '0 <= float <= 512',
{ name => 'spread_amount_x', type => '0 <= double <= 512',
desc => 'Horizontal spread amount' },
{ name => 'spread_amount_y', type => '0 <= float <= 512',
{ name => 'spread_amount_y', type => '0 <= double <= 512',
desc => 'Vertical spread amount' }
);
@ -4366,9 +4366,9 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => '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' },
{ name => 'amount', type => '0.0 <= float <= 300.0',
{ name => 'amount', type => '0.0 <= double <= 300.0',
desc => 'Strength of effect' },
{ name => 'threshold', type => '0 <= int32 <= 255',
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 }' },
{ name => 'propagating_channel', type => 'int32',
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' },
{ name => 'direction_mask', type => '0 <= int32 <= 15',
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 }' },
{ name => 'propagating_channel', type => 'int32', dead => 1,
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' },
{ name => 'direction_mask', type => '0 <= int32 <= 15', dead => 1,
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 }' },
{ name => 'propagating_channel', type => 'int32', dead => 1,
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' },
{ name => 'direction_mask', type => '0 <= int32 <= 15', dead => 1,
desc => 'Direction mask' },
@ -4755,11 +4755,11 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'amplitude', type => '0 <= float <= 101',
{ name => 'amplitude', type => '0 <= double <= 101',
desc => 'The Amplitude of the Waves' },
{ name => 'phase', type => '-360 <= float <= 360',
{ name => 'phase', type => '-360 <= double <= 360',
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' },
{ name => 'type', type => 'boolean',
desc => 'Type of waves: { 0 = smeared, 1 = black }' },
@ -4830,11 +4830,11 @@ HELP
desc => 'Input image (unused)' },
{ name => 'drawable', type => 'drawable',
desc => 'Input drawable' },
{ name => 'whirl', type => '-720 <= float <= 720',
{ name => 'whirl', type => '-720 <= double <= 720',
desc => 'Whirl angle (degrees)' },
{ name => 'pinch', type => '-1 <= float <= 1',
{ name => 'pinch', type => '-1 <= double <= 1',
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)' }
);

2
pdb/groups/progress.pdb
View file

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

2
pdb/groups/selection.pdb
View file

@ -353,7 +353,7 @@ HELP
@inargs = (
{ name => 'image', type => 'image',
desc => 'The image' },
{ name => 'radius', type => '0 <= float',
{ name => 'radius', type => '0 <= double',
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)' },
{ name => 'font', type => 'font',
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' },
{ name => 'unit', type => 'unit', allow_pixel => 1,
desc => 'The units of specified size' }
@ -294,7 +294,7 @@ sub text_layer_get_font_size {
$help = <<'HELP';
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.
HELP
@ -306,7 +306,7 @@ HELP
);
@outargs = (
{ name => 'font_size', type => 'float',
{ name => 'font_size', type => 'double',
desc => 'The font size' },
{ name => 'unit', type => 'unit',
desc => 'The unit used for the font size' }
@ -337,7 +337,7 @@ HELP
@inargs = (
{ name => 'layer', type => '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' },
{ name => 'unit', type => 'unit',
desc => 'The unit to use for the font size' }
@ -785,7 +785,7 @@ HELP
);
@outargs = (
{ name => 'indent', type => 'float',
{ name => 'indent', type => 'double',
desc => 'The indentation value of the first line.' }
);
@ -812,7 +812,7 @@ HELP
@inargs = (
{ name => 'layer', type => '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.' }
);
@ -843,7 +843,7 @@ HELP
);
@outargs = (
{ name => 'line_spacing', type => 'float',
{ name => 'line_spacing', type => 'double',
desc => 'The line-spacing value.' }
);
@ -870,7 +870,7 @@ HELP
@inargs = (
{ name => 'layer', type => '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.' }
);
@ -902,7 +902,7 @@ HELP
);
@outargs = (
{ name => 'letter_spacing', type => 'float',
{ name => 'letter_spacing', type => 'double',
desc => 'The letter-spacing value.' }
);
@ -930,7 +930,7 @@ HELP
@inargs = (
{ name => 'layer', type => '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.' }
);
@ -960,9 +960,9 @@ HELP
@inargs = (
{ name => 'layer', type => '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' },
{ 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' },
);

8
pdb/groups/text_tool.pdb
View file

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

4
pdb/groups/unit.pdb
View file

@ -37,7 +37,7 @@ HELP
@outargs = (
{ name => 'name', type => 'string',
desc => "The unit's name" },
{ name => 'factor', type => 'float',
{ name => 'factor', type => 'double',
desc => "The unit's factor" },
{ name => 'digits', type => 'int32',
desc => "The unit's number of digits" },
@ -82,7 +82,7 @@ HELP
@inargs = (
{ name => 'name', type => 'string', non_empty => 1,
desc => "The new unit's name" },
{ name => 'factor', type => 'float',
{ name => 'factor', type => 'double',
desc => "The new unit's factor" },
{ name => 'digits', type => 'int32',
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)',
take_value_func => 'g_value_set_int ($value, $var)' },
float => { name => 'FLOAT',
double => { name => 'DOUBLE',
gtype => 'G_TYPE_DOUBLE',
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)',
take_value_func => 'gimp_value_take_int32_array ($value, $var, $var_len)' },
floatarray => { name => 'FLOATARRAY',
gtype => 'GIMP_TYPE_FLOAT_ARRAY',
doublearray => { name => 'DOUBLEARRAY',
gtype => 'GIMP_TYPE_DOUBLE_ARRAY',
type => 'gdouble *',
const_type => 'const gdouble *',
array => 1,
init_value => 'NULL',
in_annotate => '(element-type gdouble)',
out_annotate => '(element-type gdouble) (transfer full)',
get_value_func => '$var = gimp_value_get_float_array ($value, &$var_len)',
dup_value_func => '$var = GIMP_VALUES_DUP_FLOAT_ARRAY ($value, $var_len)',
set_value_func => 'gimp_value_set_float_array ($value, $var, $var_len)',
take_value_func => 'gimp_value_take_float_array ($value, $var, $var_len)' },
get_value_func => '$var = gimp_value_get_double_array ($value, &$var_len)',
dup_value_func => '$var = GIMP_VALUES_DUP_DOUBLE_ARRAY ($value, $var_len)',
set_value_func => 'gimp_value_set_double_array ($value, $var, $var_len)',
take_value_func => 'gimp_value_take_double_array ($value, $var, $var_len)' },
colorarray => { name => '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",
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "upper-point-x",
_("Upper point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_double_array_argument (procedure, "upper-point-x",
_("Upper point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "upper-point-y",
_("Upper point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_double_array_argument (procedure, "upper-point-y",
_("Upper point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "lower-point-x",
_("Lower point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_double_array_argument (procedure, "lower-point-x",
_("Lower point X"),
_("Array of 17 x point coords "
"{ 0.0 <= x <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_float_array_argument (procedure, "lower-point-y",
_("Lower point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_double_array_argument (procedure, "lower-point-y",
_("Lower point Y"),
_("Array of 17 y point coords "
"{ 0.0 <= y <= 1.0 or -1 for unused point }"),
G_PARAM_READWRITE);
gimp_procedure_add_bytes_argument (procedure, "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;
}
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
else if (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (value))
{
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);
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");
}
}
else if (GIMP_VALUE_HOLDS_FLOAT_ARRAY (&value))
else if (GIMP_VALUE_HOLDS_DOUBLE_ARRAY (&value))
{
vector = sc->vptr->pair_car (a);
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);
}
gimp_value_take_float_array (&value, array, n_elements);
gimp_value_take_double_array (&value, array, n_elements);
debug_vector (sc, vector, "%f");
}