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