From dc3e815ff018a82cd721855bed78fb21b48cd258 Mon Sep 17 00:00:00 2001 From: Jehan Date: Sat, 2 Nov 2024 14:03:37 +0100 Subject: [PATCH] app, libgimp*, pdb, plug-ins: rename various public API name s/float/double/. 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. --- app/core/gimp-memsize.c | 2 +- app/core/gimp-units.c | 2 +- app/pdb/brush-cmds.c | 4 +- app/pdb/context-cmds.c | 20 +- app/pdb/drawable-color-cmds.c | 20 +- app/pdb/gimppdb.c | 2 +- app/pdb/gradient-cmds.c | 31 +- app/pdb/image-select-cmds.c | 10 +- app/pdb/paint-tools-cmds.c | 170 +++++------ app/pdb/path-cmds.c | 32 +- app/pdb/plug-in-compat-cmds.c | 10 +- app/pdb/text-layer-cmds.c | 2 +- app/plug-in/plug-in-rc.c | 24 +- app/widgets/gimpgradientselect.c | 6 +- libgimp/gimp.c | 2 +- libgimp/gimp.def | 6 +- libgimp/gimpbrush_pdb.c | 4 +- libgimp/gimpcontext_pdb.c | 6 +- libgimp/gimpdrawablecolor_pdb.c | 8 +- libgimp/gimpgpparams-body.c | 34 +-- libgimp/gimpgradient_pdb.c | 8 +- libgimp/gimpimageselect_pdb.c | 4 +- libgimp/gimppainttools_pdb.c | 68 ++--- libgimp/gimppath_pdb.c | 17 +- libgimp/gimpprocedure-params.c | 60 ++-- libgimp/gimpprocedure-params.h | 24 +- libgimp/gimpresourceselect.c | 8 +- libgimp/gimptextlayer_pdb.c | 2 +- libgimpbase/gimpbase.def | 20 +- libgimpbase/gimpparamspecs.c | 132 ++++---- libgimpbase/gimpparamspecs.h | 62 ++-- libgimpbase/gimpprotocol.c | 28 +- libgimpbase/gimpprotocol.h | 12 +- libgimpconfig/gimpconfig-deserialize.c | 12 +- libgimpconfig/gimpconfig-params.c | 5 +- libgimpconfig/gimpconfig-serialize.c | 4 +- libgimpconfig/gimpconfig.def | 2 +- libgimpconfig/gimpscanner.c | 20 +- libgimpconfig/gimpscanner.h | 2 +- pdb/app.pl | 12 +- pdb/groups/brush.pdb | 28 +- pdb/groups/channel.pdb | 6 +- pdb/groups/context.pdb | 84 ++--- pdb/groups/debug.pdb | 2 +- pdb/groups/drawable_color.pdb | 72 ++--- pdb/groups/drawable_edit.pdb | 16 +- pdb/groups/gimprc.pdb | 4 +- pdb/groups/gradient.pdb | 29 +- pdb/groups/image.pdb | 14 +- pdb/groups/image_grid.pdb | 16 +- pdb/groups/image_select.pdb | 34 +-- pdb/groups/item_transform.pdb | 82 ++--- pdb/groups/layer.pdb | 6 +- pdb/groups/paint_tools.pdb | 22 +- pdb/groups/path.pdb | 86 +++--- pdb/groups/plug_in_compat.pdb | 286 +++++++++--------- pdb/groups/progress.pdb | 2 +- pdb/groups/selection.pdb | 2 +- pdb/groups/text_layer.pdb | 24 +- pdb/groups/text_tool.pdb | 8 +- pdb/groups/unit.pdb | 4 +- pdb/pdb.pl | 14 +- plug-ins/common/curve-bend.c | 40 +-- .../libscriptfu/scheme-marshal-return.c | 4 +- .../script-fu/libscriptfu/scheme-wrapper.c | 4 +- 65 files changed, 892 insertions(+), 894 deletions(-) diff --git a/app/core/gimp-memsize.c b/app/core/gimp-memsize.c index 01a25c5b6a..8e81fd2e8a 100644 --- a/app/core/gimp-memsize.c +++ b/app/core/gimp-memsize.c @@ -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); diff --git a/app/core/gimp-units.c b/app/core/gimp-units.c index cb7c2d2df9..ec1a0e86e0 100644 --- a/app/core/gimp-units.c +++ b/app/core/gimp-units.c @@ -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; diff --git a/app/pdb/brush-cmds.c b/app/pdb/brush-cmds.c index 5ecea34d1a..ba2010d409 100644 --- a/app/pdb/brush-cmds.c +++ b/app/pdb/brush-cmds.c @@ -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 ", @@ -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 ", diff --git a/app/pdb/context-cmds.c b/app/pdb/context-cmds.c index cfb85acfec..9d144205fb 100644 --- a/app/pdb/context-cmds.c +++ b/app/pdb/context-cmds.c @@ -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); diff --git a/app/pdb/drawable-color-cmds.c b/app/pdb/drawable-color-cmds.c index d81c1a467d..604964a805 100644 --- a/app/pdb/drawable-color-cmds.c +++ b/app/pdb/drawable-color-cmds.c @@ -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); diff --git a/app/pdb/gimppdb.c b/app/pdb/gimppdb.c index 43e23eb5ef..05fc1d561d 100644 --- a/app/pdb/gimppdb.c +++ b/app/pdb/gimppdb.c @@ -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)); diff --git a/app/pdb/gradient-cmds.c b/app/pdb/gradient-cmds.c index a7309ccf1d..36e657f55c 100644 --- a/app/pdb/gradient-cmds.c +++ b/app/pdb/gradient-cmds.c @@ -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); diff --git a/app/pdb/image-select-cmds.c b/app/pdb/image-select-cmds.c index 0e3e55c731..7dd9225655 100644 --- a/app/pdb/image-select-cmds.c +++ b/app/pdb/image-select-cmds.c @@ -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); diff --git a/app/pdb/paint-tools-cmds.c b/app/pdb/paint-tools-cmds.c index b24c463d6f..68768d4c29 100644 --- a/app/pdb/paint-tools-cmds.c +++ b/app/pdb/paint-tools-cmds.c @@ -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); } diff --git a/app/pdb/path-cmds.c b/app/pdb/path-cmds.c index a569748563..04cb9f2b77 100644 --- a/app/pdb/path-cmds.c +++ b/app/pdb/path-cmds.c @@ -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", diff --git a/app/pdb/plug-in-compat-cmds.c b/app/pdb/plug-in-compat-cmds.c index 676047d827..b933cc294e 100644 --- a/app/pdb/plug-in-compat-cmds.c +++ b/app/pdb/plug-in-compat-cmds.c @@ -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", diff --git a/app/pdb/text-layer-cmds.c b/app/pdb/text-layer-cmds.c index 73edeee49d..4d0437ac02 100644 --- a/app/pdb/text-layer-cmds.c +++ b/app/pdb/text-layer-cmds.c @@ -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 ", diff --git a/app/plug-in/plug-in-rc.c b/app/plug-in/plug-in-rc.c index dcfddcdd45..f4550da692 100644 --- a/app/plug-in/plug-in-rc.c +++ b/app/plug-in/plug-in-rc.c @@ -892,13 +892,13 @@ plug_in_proc_arg_deserialize (GScanner *scanner, } break; - case GP_PARAM_DEF_TYPE_FLOAT: - if (! gimp_scanner_parse_float (scanner, - ¶m_def.meta.m_float.min_val) || - ! gimp_scanner_parse_float (scanner, - ¶m_def.meta.m_float.max_val) || - ! gimp_scanner_parse_float (scanner, - ¶m_def.meta.m_float.default_val)) + case GP_PARAM_DEF_TYPE_DOUBLE: + if (! gimp_scanner_parse_double (scanner, + ¶m_def.meta.m_double.min_val) || + ! gimp_scanner_parse_double (scanner, + ¶m_def.meta.m_double.max_val) || + ! gimp_scanner_parse_double (scanner, + ¶m_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; diff --git a/app/widgets/gimpgradientselect.c b/app/widgets/gimpgradientselect.c index 7702fa29e8..0782bea11d 100644 --- a/app/widgets/gimpgradientselect.c +++ b/app/widgets/gimpgradientselect.c @@ -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); diff --git a/libgimp/gimp.c b/libgimp/gimp.c index 9bd94a0789..d0780353aa 100644 --- a/libgimp/gimp.c +++ b/libgimp/gimp.c @@ -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, diff --git a/libgimp/gimp.def b/libgimp/gimp.def index a32e17d719..bc2ce4eb01 100644 --- a/libgimp/gimp.def +++ b/libgimp/gimp.def @@ -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 diff --git a/libgimp/gimpbrush_pdb.c b/libgimp/gimpbrush_pdb.c index e0cc33577d..29584f44fc 100644 --- a/libgimp/gimpbrush_pdb.c +++ b/libgimp/gimpbrush_pdb.c @@ -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. diff --git a/libgimp/gimpcontext_pdb.c b/libgimp/gimpcontext_pdb.c index 51f26f877e..66beb27cbd 100644 --- a/libgimp/gimpcontext_pdb.c +++ b/libgimp/gimpcontext_pdb.c @@ -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", diff --git a/libgimp/gimpdrawablecolor_pdb.c b/libgimp/gimpdrawablecolor_pdb.c index 8171bd1a26..a096a9068f 100644 --- a/libgimp/gimpdrawablecolor_pdb.c +++ b/libgimp/gimpdrawablecolor_pdb.c @@ -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", diff --git a/libgimp/gimpgpparams-body.c b/libgimp/gimpgpparams-body.c index e48790be17..832dde960c 100644 --- a/libgimp/gimpgpparams-body.c +++ b/libgimp/gimpgpparams-body.c @@ -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: diff --git a/libgimp/gimpgradient_pdb.c b/libgimp/gimpgradient_pdb.c index 9502572fec..39e4087aea 100644 --- a/libgimp/gimpgradient_pdb.c +++ b/libgimp/gimpgradient_pdb.c @@ -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); diff --git a/libgimp/gimpimageselect_pdb.c b/libgimp/gimpimageselect_pdb.c index 203e1788da..8932cc5941 100644 --- a/libgimp/gimpimageselect_pdb.c +++ b/libgimp/gimpimageselect_pdb.c @@ -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", diff --git a/libgimp/gimppainttools_pdb.c b/libgimp/gimppainttools_pdb.c index d4366be4c6..748be66167 100644 --- a/libgimp/gimppainttools_pdb.c +++ b/libgimp/gimppainttools_pdb.c @@ -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", diff --git a/libgimp/gimppath_pdb.c b/libgimp/gimppath_pdb.c index bbc1f5871f..e958256894 100644 --- a/libgimp/gimppath_pdb.c +++ b/libgimp/gimppath_pdb.c @@ -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); } diff --git a/libgimp/gimpprocedure-params.c b/libgimp/gimpprocedure-params.c index ab5eb065c0..4c7c6884b1 100644 --- a/libgimp/gimpprocedure-params.c +++ b/libgimp/gimpprocedure-params.c @@ -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)); } /** diff --git a/libgimp/gimpprocedure-params.h b/libgimp/gimpprocedure-params.h index edbd077210..4f060d1179 100644 --- a/libgimp/gimpprocedure-params.h +++ b/libgimp/gimpprocedure-params.h @@ -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, diff --git a/libgimp/gimpresourceselect.c b/libgimp/gimpresourceselect.c index 0073c5cdfb..c45862aa91 100644 --- a/libgimp/gimpresourceselect.c +++ b/libgimp/gimpresourceselect.c @@ -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)) { diff --git a/libgimp/gimptextlayer_pdb.c b/libgimp/gimptextlayer_pdb.c index 6594a700f3..9bd1e581c3 100644 --- a/libgimp/gimptextlayer_pdb.c +++ b/libgimp/gimptextlayer_pdb.c @@ -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. diff --git a/libgimpbase/gimpbase.def b/libgimpbase/gimpbase.def index d2092a2811..71e7668098 100644 --- a/libgimpbase/gimpbase.def +++ b/libgimpbase/gimpbase.def @@ -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 diff --git a/libgimpbase/gimpparamspecs.c b/libgimpbase/gimpparamspecs.c index 2bc0822d42..51a95f550c 100644 --- a/libgimpbase/gimpparamspecs.c +++ b/libgimpbase/gimpparamspecs.c @@ -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)); diff --git a/libgimpbase/gimpparamspecs.h b/libgimpbase/gimpparamspecs.h index 7957066c30..ecd258eaf6 100644 --- a/libgimpbase/gimpparamspecs.h +++ b/libgimpbase/gimpparamspecs.h @@ -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); /* diff --git a/libgimpbase/gimpprotocol.c b/libgimpbase/gimpprotocol.c index e526205a8a..884647f1c8 100644 --- a/libgimpbase/gimpprotocol.c +++ b/libgimpbase/gimpprotocol.c @@ -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, - ¶m_def->meta.m_float.min_val, 1, + ¶m_def->meta.m_double.min_val, 1, user_data) || ! _gimp_wire_read_double (channel, - ¶m_def->meta.m_float.max_val, 1, + ¶m_def->meta.m_double.max_val, 1, user_data) || ! _gimp_wire_read_double (channel, - ¶m_def->meta.m_float.default_val, 1, + ¶m_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, - ¶m_def->meta.m_float.min_val, 1, + ¶m_def->meta.m_double.min_val, 1, user_data) || ! _gimp_wire_write_double (channel, - ¶m_def->meta.m_float.max_val, 1, + ¶m_def->meta.m_double.max_val, 1, user_data) || ! _gimp_wire_write_double (channel, - ¶m_def->meta.m_float.default_val, 1, + ¶m_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 *) ¶ms[i].data.d_float, 1, + (const gdouble *) ¶ms[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: diff --git a/libgimpbase/gimpprotocol.h b/libgimpbase/gimpprotocol.h index 4ee24ceda4..213acc90bf 100644 --- a/libgimpbase/gimpprotocol.h +++ b/libgimpbase/gimpprotocol.h @@ -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; diff --git a/libgimpconfig/gimpconfig-deserialize.c b/libgimpconfig/gimpconfig-deserialize.c index cee869cf21..b892c2a79b 100644 --- a/libgimpconfig/gimpconfig-deserialize.c +++ b/libgimpconfig/gimpconfig-deserialize.c @@ -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 { diff --git a/libgimpconfig/gimpconfig-params.c b/libgimpconfig/gimpconfig-params.c index eb41297d24..fc4f4b5869 100644 --- a/libgimpconfig/gimpconfig-params.c +++ b/libgimpconfig/gimpconfig-params.c @@ -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)) diff --git a/libgimpconfig/gimpconfig-serialize.c b/libgimpconfig/gimpconfig-serialize.c index 7cc7d011f3..4da6c4ec2f 100644 --- a/libgimpconfig/gimpconfig-serialize.c +++ b/libgimpconfig/gimpconfig-serialize.c @@ -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); diff --git a/libgimpconfig/gimpconfig.def b/libgimpconfig/gimpconfig.def index dedc32de94..a23ddf04a6 100644 --- a/libgimpconfig/gimpconfig.def +++ b/libgimpconfig/gimpconfig.def @@ -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 diff --git a/libgimpconfig/gimpscanner.c b/libgimpconfig/gimpscanner.c index 7c93f0a5e3..94d053acab 100644 --- a/libgimpconfig/gimpscanner.c +++ b/libgimpconfig/gimpscanner.c @@ -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]; diff --git a/libgimpconfig/gimpscanner.h b/libgimpconfig/gimpscanner.h index 2aec159ffe..e690c9be2e 100644 --- a/libgimpconfig/gimpscanner.h +++ b/libgimpconfig/gimpscanner.h @@ -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); diff --git a/pdb/app.pl b/pdb/app.pl index ed1e38eec7..0e13e27d16 100644 --- a/pdb/app.pl +++ b/pdb/app.pl @@ -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 = < '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' } ); diff --git a/pdb/groups/channel.pdb b/pdb/groups/channel.pdb index 616a9f24d1..90a37716a8 100644 --- a/pdb/groups/channel.pdb +++ b/pdb/groups/channel.pdb @@ -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' } ); diff --git a/pdb/groups/context.pdb b/pdb/groups/context.pdb index 8cf5484c87..587cd405c1 100644 --- a/pdb/groups/context.pdb +++ b/pdb/groups/context.pdb @@ -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" } ); diff --git a/pdb/groups/debug.pdb b/pdb/groups/debug.pdb index da1111085f..cad02bb77a 100644 --- a/pdb/groups/debug.pdb +++ b/pdb/groups/debug.pdb @@ -58,7 +58,7 @@ HELP &std_pdb_debug(); @outargs = ( - { name => 'elapsed', type => 'float', + { name => 'elapsed', type => 'double', desc => 'The elapsed time, in seconds' } ); diff --git a/pdb/groups/drawable_color.pdb b/pdb/groups/drawable_color.pdb index 5c626292fe..6653ebfac3 100644 --- a/pdb/groups/drawable_color.pdb +++ b/pdb/groups/drawable_color.pdb @@ -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' } ); diff --git a/pdb/groups/drawable_edit.pdb b/pdb/groups/drawable_edit.pdb index 59a43815b4..c4d46d9f10 100644 --- a/pdb/groups/drawable_edit.pdb +++ b/pdb/groups/drawable_edit.pdb @@ -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" } ); diff --git a/pdb/groups/gimprc.pdb b/pdb/groups/gimprc.pdb index c3175b9674..fc69e61b37 100644 --- a/pdb/groups/gimprc.pdb +++ b/pdb/groups/gimprc.pdb @@ -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' }, ); diff --git a/pdb/groups/gradient.pdb b/pdb/groups/gradient.pdb index 22f589bec0..64983d250f 100644 --- a/pdb/groups/gradient.pdb +++ b/pdb/groups/gradient.pdb @@ -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' } ); diff --git a/pdb/groups/image.pdb b/pdb/groups/image.pdb index 537f29fa00..72b88f561b 100644 --- a/pdb/groups/image.pdb +++ b/pdb/groups/image.pdb @@ -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' } ); diff --git a/pdb/groups/image_grid.pdb b/pdb/groups/image_grid.pdb index 4c42d0807a..d554f63da6 100644 --- a/pdb/groups/image_grid.pdb +++ b/pdb/groups/image_grid.pdb @@ -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" } ); diff --git a/pdb/groups/image_select.pdb b/pdb/groups/image_select.pdb index 9e4f4c1267..cd23ba42da 100644 --- a/pdb/groups/image_select.pdb +++ b/pdb/groups/image_select.pdb @@ -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', diff --git a/pdb/groups/item_transform.pdb b/pdb/groups/item_transform.pdb index de388c7d50..5758378c30 100644 --- a/pdb/groups/item_transform.pdb +++ b/pdb/groups/item_transform.pdb @@ -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' } ); diff --git a/pdb/groups/layer.pdb b/pdb/groups/layer.pdb index 1a7d6278cc..66afa406cc 100644 --- a/pdb/groups/layer.pdb +++ b/pdb/groups/layer.pdb @@ -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' } ); diff --git a/pdb/groups/paint_tools.pdb b/pdb/groups/paint_tools.pdb index 8c4331063c..7eb96ef588 100644 --- a/pdb/groups/paint_tools.pdb +++ b/pdb/groups/paint_tools.pdb @@ -17,7 +17,7 @@ # "Perlized" from C source by Manish Singh 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' }, diff --git a/pdb/groups/path.pdb b/pdb/groups/path.pdb index fc29ff00b3..ff731d7f99 100644 --- a/pdb/groups/path.pdb +++ b/pdb/groups/path.pdb @@ -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)' } ); diff --git a/pdb/groups/plug_in_compat.pdb b/pdb/groups/plug_in_compat.pdb index e6ee987f56..612c9da2c3 100644 --- a/pdb/groups/plug_in_compat.pdb +++ b/pdb/groups/plug_in_compat.pdb @@ -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)' } ); diff --git a/pdb/groups/progress.pdb b/pdb/groups/progress.pdb index f274e45921..d25f978274 100644 --- a/pdb/groups/progress.pdb +++ b/pdb/groups/progress.pdb @@ -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' } ); diff --git a/pdb/groups/selection.pdb b/pdb/groups/selection.pdb index 86dd16f62e..9db82c824d 100644 --- a/pdb/groups/selection.pdb +++ b/pdb/groups/selection.pdb @@ -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)' } ); diff --git a/pdb/groups/text_layer.pdb b/pdb/groups/text_layer.pdb index 5394a7309f..0183162852 100644 --- a/pdb/groups/text_layer.pdb +++ b/pdb/groups/text_layer.pdb @@ -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' }, ); diff --git a/pdb/groups/text_tool.pdb b/pdb/groups/text_tool.pdb index 95e8a8a342..b6f137efd9 100644 --- a/pdb/groups/text_tool.pdb +++ b/pdb/groups/text_tool.pdb @@ -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' } diff --git a/pdb/groups/unit.pdb b/pdb/groups/unit.pdb index 9e2e2f940a..43ace81139 100644 --- a/pdb/groups/unit.pdb +++ b/pdb/groups/unit.pdb @@ -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" }, diff --git a/pdb/pdb.pl b/pdb/pdb.pl index 5e7239a94c..b1fd533947 100644 --- a/pdb/pdb.pl +++ b/pdb/pdb.pl @@ -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', diff --git a/plug-ins/common/curve-bend.c b/plug-ins/common/curve-bend.c index d89c238b9f..86d19fb6b7 100644 --- a/plug-ins/common/curve-bend.c +++ b/plug-ins/common/curve-bend.c @@ -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"), diff --git a/plug-ins/script-fu/libscriptfu/scheme-marshal-return.c b/plug-ins/script-fu/libscriptfu/scheme-marshal-return.c index 654fd990f4..9ebd061e7b 100644 --- a/plug-ins/script-fu/libscriptfu/scheme-marshal-return.c +++ b/plug-ins/script-fu/libscriptfu/scheme-marshal-return.c @@ -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++) diff --git a/plug-ins/script-fu/libscriptfu/scheme-wrapper.c b/plug-ins/script-fu/libscriptfu/scheme-wrapper.c index 2a0471e662..9fc7e6a332 100644 --- a/plug-ins/script-fu/libscriptfu/scheme-wrapper.c +++ b/plug-ins/script-fu/libscriptfu/scheme-wrapper.c @@ -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"); }