app, libgimpwidgets: move gimp_prop_spin_scale_new() and…

… gimp_prop_widget_set_factor() to libgimpwidgets.

Now that GimpSpinScale is in libgimpwidgets, it's time to move the
associated prop too, to make it a prop widget with such a widget easily
creatable by plug-ins.

While doing so, I update both these functions logic, binding properties
together with the g_object_bind_property*() APIs (as we do already in
some other recent prop functions) rather than connecting to signals
ourselves. It makes for much simpler code.

app/propgui/gimppropgui-color-balance.c

@@ -54,10 +54,9 @@ create_levels_scale (GObject     *config,
   gtk_grid_attach (GTK_GRID (grid), label, 0, col, 1, 1);
   gtk_widget_show (label);
 
-  scale = gimp_prop_spin_scale_new (config, property_name,
+  scale = gimp_prop_spin_scale_new (config, property_name, 0.01, 0.1, 0);
-                                    NULL, 0.01, 0.1, 0);
   gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), NULL);
-  gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+  gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
   gtk_widget_set_hexpand (scale, TRUE);
   gtk_grid_attach (GTK_GRID (grid), scale, 1, col, 1, 1);
 

app/propgui/gimppropgui-color-rotate.c

@@ -105,12 +105,12 @@ gimp_prop_angle_range_box_new (GObject     *config,
   gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0);
   gtk_widget_show (vbox);
 
-  scale = gimp_prop_spin_scale_new (config, alpha_property_name, NULL,
+  scale = gimp_prop_spin_scale_new (config, alpha_property_name,
                                     1.0, 15.0, 2);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (scale), TRUE);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, beta_property_name, NULL,
+  scale = gimp_prop_spin_scale_new (config, beta_property_name,
                                     1.0, 15.0, 2);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (scale), TRUE);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@@ -167,12 +167,12 @@ gimp_prop_polar_box_new (GObject     *config,
   gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0);
   gtk_widget_show (vbox);
 
-  scale = gimp_prop_spin_scale_new (config, angle_property_name, NULL,
+  scale = gimp_prop_spin_scale_new (config, angle_property_name,
                                     1.0, 15.0, 2);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (scale), TRUE);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, radius_property_name, NULL,
+  scale = gimp_prop_spin_scale_new (config, radius_property_name,
                                     1.0, 15.0, 2);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/propgui/gimppropgui-hue-saturation.c

@@ -222,9 +222,9 @@ _gimp_prop_gui_new_hue_saturation (GObject                  *config,
   gtk_widget_show (grid);
 
   /* Create the 'Overlap' option slider */
-  scale = gimp_prop_spin_scale_new (config, "overlap",
+  scale = gimp_prop_spin_scale_new (config, "overlap", 0.01, 0.1, 0);
-                                    _("_Overlap"), 0.01, 0.1, 0);
+  gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
-  gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+  gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), _("_Overlap"));
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   frame = gimp_frame_new (_("Adjust Selected Color"));
@@ -237,20 +237,21 @@ _gimp_prop_gui_new_hue_saturation (GObject                  *config,
 
   /*  Create the hue scale widget  */
   scale = gimp_prop_spin_scale_new (config, "hue",
-                                    _("_Hue"), 1.0 / 180.0, 15.0 / 180.0, 0);
+                                    1.0 / 180.0, 15.0 / 180.0, 0);
-  gimp_prop_widget_set_factor (scale, 180.0, 0.0, 0.0, 1);
+  gimp_prop_widget_set_factor (scale, 180.0, 1.0, 15.0, 1);
+  gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), _("_Hue"));
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   /*  Create the lightness scale widget  */
-  scale = gimp_prop_spin_scale_new (config, "lightness",
+  scale = gimp_prop_spin_scale_new (config, "lightness", 0.01, 0.1, 0);
-                                    _("_Lightness"), 0.01, 0.1, 0);
+  gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
-  gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+  gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), _("_Lightness"));
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   /*  Create the saturation scale widget  */
-  scale = gimp_prop_spin_scale_new (config, "saturation",
+  scale = gimp_prop_spin_scale_new (config, "saturation", 0.01, 0.1, 0);
-                                    _("_Saturation"), 0.01, 0.1, 0);
+  gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
-  gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+  gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), _("_Saturation"));
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

app/propgui/gimppropgui.c

@@ -199,7 +199,7 @@ gimp_prop_widget_new_from_pspec (GObject                  *config,
             }
         }
 
-      widget = gimp_prop_spin_scale_new (config, pspec->name, NULL,
+      widget = gimp_prop_spin_scale_new (config, pspec->name,
                                          step, page, digits);
 
       if (HAS_KEY (pspec, "unit", "degree") &&

app/tools/gimpairbrushtool.c

@@ -135,11 +135,11 @@ gimp_airbrush_options_gui (GimpToolOptions *tool_options)
   button = gimp_prop_check_button_new (config, "motion-only", NULL);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "rate", NULL,
+  scale = gimp_prop_spin_scale_new (config, "rate",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "flow", NULL,
+  scale = gimp_prop_spin_scale_new (config, "flow",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimpbrightnesscontrasttool.c

@@ -279,14 +279,16 @@ gimp_brightness_contrast_tool_dialog (GimpFilterTool *filter_tool)
 
   /*  Create the brightness scale widget  */
   scale = gimp_prop_spin_scale_new (filter_tool->config, "brightness",
-                                    _("_Brightness"), 0.01, 0.1, 3);
+                                    0.01, 0.1, 3);
+  gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), _("_Brightness"));
   gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 0);
 
   bc_tool->brightness_scale = scale;
 
   /*  Create the contrast scale widget  */
   scale = gimp_prop_spin_scale_new (filter_tool->config, "contrast",
-                                    _("_Contrast"), 0.01, 0.1, 3);
+                                    0.01, 0.1, 3);
+  gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), _("_Contrast"));
   gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 0);
 
   bc_tool->contrast_scale = scale;

app/tools/gimpbucketfilloptions.c

@@ -490,7 +490,7 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (box2), widget, FALSE, FALSE, 0);
 
   /*  the threshold scale  */
-  scale = gimp_prop_spin_scale_new (config, "threshold", NULL,
+  scale = gimp_prop_spin_scale_new (config, "threshold",
                                     1.0, 16.0, 1);
   gtk_box_pack_start (GTK_BOX (box2), scale, FALSE, FALSE, 0);
   options->priv->threshold_scale = scale;
@@ -535,7 +535,7 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (box2), combo, FALSE, FALSE, 0);
 
   /*  Line Art: fill as line art  */
-  scale = gimp_prop_spin_scale_new (config, "fill-color-as-line-art-threshold", NULL,
+  scale = gimp_prop_spin_scale_new (config, "fill-color-as-line-art-threshold",
                                     1.0, 16.0, 1);
 
   frame = gimp_prop_expanding_frame_new (config, "fill-color-as-line-art", NULL,
@@ -548,7 +548,7 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (box2), widget, FALSE, FALSE, 0);
 
   /*  Line Art: feather radius scale  */
-  scale = gimp_prop_spin_scale_new (config, "feather-radius", NULL,
+  scale = gimp_prop_spin_scale_new (config, "feather-radius",
                                     1.0, 10.0, 1);
 
   frame = gimp_prop_expanding_frame_new (config, "feather", NULL,
@@ -556,17 +556,17 @@ gimp_bucket_fill_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (box2), frame, FALSE, FALSE, 0);
 
   /*  Line Art: max growing size */
-  scale = gimp_prop_spin_scale_new (config, "line-art-max-grow", NULL,
+  scale = gimp_prop_spin_scale_new (config, "line-art-max-grow",
                                     1, 5, 0);
   gtk_box_pack_start (GTK_BOX (box2), scale, FALSE, FALSE, 0);
 
   /*  Line Art: stroke threshold */
-  scale = gimp_prop_spin_scale_new (config, "line-art-threshold", NULL,
+  scale = gimp_prop_spin_scale_new (config, "line-art-threshold",
                                     0.05, 0.1, 2);
   gtk_box_pack_start (GTK_BOX (box2), scale, FALSE, FALSE, 0);
 
   /*  Line Art: max gap length */
-  scale = gimp_prop_spin_scale_new (config, "line-art-max-gap-length", NULL,
+  scale = gimp_prop_spin_scale_new (config, "line-art-max-gap-length",
                                     1, 5, 0);
   gtk_box_pack_start (GTK_BOX (box2), scale, FALSE, FALSE, 0);
 

app/tools/gimpcoloroptions.c

@@ -154,7 +154,7 @@ gimp_color_options_gui (GimpToolOptions *tool_options)
   GtkWidget *scale;
 
   /*  the sample average options  */
-  scale = gimp_prop_spin_scale_new (config, "average-radius", NULL,
+  scale = gimp_prop_spin_scale_new (config, "average-radius",
                                     1.0, 10.0, 0);
 
   frame = gimp_prop_expanding_frame_new (config, "sample-average", NULL,

app/tools/gimpconvolvetool.c

@@ -220,7 +220,7 @@ gimp_convolve_options_gui (GimpToolOptions *tool_options)
   g_free (str);
 
   /*  the rate scale  */
-  scale = gimp_prop_spin_scale_new (config, "rate", NULL,
+  scale = gimp_prop_spin_scale_new (config, "rate",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimpdodgeburntool.c

@@ -230,7 +230,7 @@ gimp_dodge_burn_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
   /*  the exposure scale  */
-  scale = gimp_prop_spin_scale_new (config, "exposure", NULL,
+  scale = gimp_prop_spin_scale_new (config, "exposure",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimpfiltertool.c

@@ -1142,7 +1142,6 @@ gimp_filter_tool_update_dialog_operation_settings (GimpFilterTool *filter_tool)
           /*  The opacity scale  */
           scale = gimp_prop_spin_scale_new (filter_tool->config,
                                             "gimp-opacity",
-                                            NULL,
                                             1.0, 10.0, 1);
           gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
           gtk_box_pack_start (GTK_BOX (vbox2), scale,

app/tools/gimpforegroundselectoptions.c

@@ -298,7 +298,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
   gtk_widget_show (hbox);
 
   /* stroke width */
-  scale = gimp_prop_spin_scale_new (config, "stroke-width", NULL,
+  scale = gimp_prop_spin_scale_new (config, "stroke-width",
                                     1.0, 10.0, 2);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
   gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7);
@@ -351,7 +351,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
   gtk_widget_show (inner_vbox);
 
   /*  engine parameters  */
-  scale = gimp_prop_spin_scale_new (config, "levels", NULL,
+  scale = gimp_prop_spin_scale_new (config, "levels",
                                     1.0, 1.0, 0);
   gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0);
 
@@ -363,7 +363,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
                                GINT_TO_POINTER (GIMP_MATTING_ENGINE_LEVIN),
                                NULL);
 
-  scale = gimp_prop_spin_scale_new (config, "active-levels", NULL,
+  scale = gimp_prop_spin_scale_new (config, "active-levels",
                                     1.0, 1.0, 0);
   gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0);
 
@@ -375,7 +375,7 @@ gimp_foreground_select_options_gui (GimpToolOptions *tool_options)
                                GINT_TO_POINTER (GIMP_MATTING_ENGINE_LEVIN),
                                NULL);
 
-  scale = gimp_prop_spin_scale_new (config, "iterations", NULL,
+  scale = gimp_prop_spin_scale_new (config, "iterations",
                                     1.0, 1.0, 0);
   gtk_box_pack_start (GTK_BOX (inner_vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimpgradientoptions.c

@@ -314,7 +314,7 @@ gimp_gradient_options_gui (GimpToolOptions *tool_options)
   gradient_options_repeat_gradient_type_notify (options, NULL, combo);
 
   /*  the offset scale  */
-  scale = gimp_prop_spin_scale_new (config, "offset", NULL,
+  scale = gimp_prop_spin_scale_new (config, "offset",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
@@ -329,12 +329,12 @@ gimp_gradient_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
   /*  max depth scale  */
-  scale = gimp_prop_spin_scale_new (config, "supersample-depth", NULL,
+  scale = gimp_prop_spin_scale_new (config, "supersample-depth",
                                     1.0, 1.0, 0);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 
   /*  threshold scale  */
-  scale = gimp_prop_spin_scale_new (config, "supersample-threshold", NULL,
+  scale = gimp_prop_spin_scale_new (config, "supersample-threshold",
                                     0.01, 0.1, 2);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 

app/tools/gimpinkoptions-gui.c

@@ -61,12 +61,12 @@ gimp_ink_options_gui (GimpToolOptions *tool_options)
   gtk_widget_show (vbox2);
 
   /*  size slider  */
-  scale = gimp_prop_spin_scale_new (config, "size", NULL,
+  scale = gimp_prop_spin_scale_new (config, "size",
                                     1.0, 2.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 
   /* angle adjust slider */
-  scale = gimp_prop_spin_scale_new (config, "tilt-angle", NULL,
+  scale = gimp_prop_spin_scale_new (config, "tilt-angle",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 
@@ -80,17 +80,17 @@ gimp_ink_options_gui (GimpToolOptions *tool_options)
   gtk_widget_show (vbox2);
 
   /* size sens slider */
-  scale = gimp_prop_spin_scale_new (config, "size-sensitivity", NULL,
+  scale = gimp_prop_spin_scale_new (config, "size-sensitivity",
                                     0.01, 0.1, 2);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 
   /* tilt sens slider */
-  scale = gimp_prop_spin_scale_new (config, "tilt-sensitivity", NULL,
+  scale = gimp_prop_spin_scale_new (config, "tilt-sensitivity",
                                     0.01, 0.1, 2);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 
   /* velocity sens slider */
-  scale = gimp_prop_spin_scale_new (config, "vel-sensitivity", NULL,
+  scale = gimp_prop_spin_scale_new (config, "vel-sensitivity",
                                     0.01, 0.1, 2);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
 

app/tools/gimpmybrushoptions-gui.c

@@ -64,17 +64,17 @@ gimp_mybrush_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   /* radius */
-  scale = gimp_prop_spin_scale_new (config, "radius", NULL,
+  scale = gimp_prop_spin_scale_new (config, "radius",
                                     0.1, 1.0, 2);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   /* opaque */
-  scale = gimp_prop_spin_scale_new (config, "opaque", NULL,
+  scale = gimp_prop_spin_scale_new (config, "opaque",
                                     0.1, 1.0, 2);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   /* hardness */
-  scale = gimp_prop_spin_scale_new (config, "hardness", NULL,
+  scale = gimp_prop_spin_scale_new (config, "hardness",
                                     0.1, 1.0, 2);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimpnpointdeformationoptions.c

@@ -209,14 +209,14 @@ gimp_n_point_deformation_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
   gtk_widget_set_can_focus (widget, FALSE);
 
-  widget = gimp_prop_spin_scale_new (config, "square-size", NULL,
+  widget = gimp_prop_spin_scale_new (config, "square-size",
                                      1.0, 10.0, 0);
   npd_options->scale_square_size = widget;
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 10.0, 100.0);
   gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
   gtk_widget_set_can_focus (widget, FALSE);
 
-  widget = gimp_prop_spin_scale_new (config, "rigidity", NULL,
+  widget = gimp_prop_spin_scale_new (config, "rigidity",
                                      1.0, 10.0, 0);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 1.0, 2000.0);
   gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
@@ -233,7 +233,7 @@ gimp_n_point_deformation_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
   gtk_widget_set_can_focus (widget, FALSE);
 
-  widget = gimp_prop_spin_scale_new (config, "mls-weights-alpha", NULL,
+  widget = gimp_prop_spin_scale_new (config, "mls-weights-alpha",
                                      0.1, 0.1, 1);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (widget), 0.1, 2.0);
   gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);

app/tools/gimppaintoptions-gui.c

@@ -126,10 +126,9 @@ gimp_paint_options_gui (GimpToolOptions *tool_options)
     }
 
   /*  the opacity scale  */
-  scale = gimp_prop_spin_scale_new (config, "opacity", NULL,
+  scale = gimp_prop_spin_scale_new (config, "opacity", 0.01, 0.1, 0);
-                                    0.01, 0.1, 0);
   gimp_spin_scale_set_constrain_drag (GIMP_SPIN_SCALE (scale), TRUE);
-  gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+  gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
   /*  temp debug foo, disabled in stable  */
@@ -327,7 +326,7 @@ dynamics_options_gui (GimpPaintOptions *paint_options,
   gtk_box_pack_start (GTK_BOX (inner_vbox), hbox, FALSE, FALSE, 0);
   gtk_widget_show (hbox);
 
-  scale = gimp_prop_spin_scale_new (config, "fade-length", NULL,
+  scale = gimp_prop_spin_scale_new (config, "fade-length",
                                     1.0, 50.0, 0);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
   gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
@@ -392,7 +391,7 @@ jitter_options_gui (GimpPaintOptions *paint_options,
   GtkWidget *frame;
   GtkWidget *scale;
 
-  scale = gimp_prop_spin_scale_new (config, "jitter-amount", NULL,
+  scale = gimp_prop_spin_scale_new (config, "jitter-amount",
                                     0.01, 1.0, 2);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 5.0);
 
@@ -416,11 +415,11 @@ smoothing_options_gui (GimpPaintOptions *paint_options,
   frame = gimp_prop_expanding_frame_new (config, "use-smoothing", NULL,
                                          vbox, NULL);
 
-  scale = gimp_prop_spin_scale_new (config, "smoothing-quality", NULL,
+  scale = gimp_prop_spin_scale_new (config, "smoothing-quality",
                                     1, 10, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "smoothing-factor", NULL,
+  scale = gimp_prop_spin_scale_new (config, "smoothing-factor",
                                     1, 10, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
@@ -507,7 +506,7 @@ gimp_paint_options_gui_scale_with_buttons (GObject      *config,
 
   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 
-  scale = gimp_prop_spin_scale_new (config, prop_name, NULL,
+  scale = gimp_prop_spin_scale_new (config, prop_name,
                                     step_increment, page_increment, digits);
   gimp_spin_scale_set_constrain_drag (GIMP_SPIN_SCALE (scale), TRUE);
 

app/tools/gimppaintselectoptions.c

@@ -179,7 +179,7 @@ gimp_paint_select_options_gui (GimpToolOptions *tool_options)
   gtk_widget_show (hbox);
 
   /* stroke width */
-  scale = gimp_prop_spin_scale_new (config, "stroke-width", NULL,
+  scale = gimp_prop_spin_scale_new (config, "stroke-width",
                                     1.0, 10.0, 2);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
   gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), 1.7);

app/tools/gimprectangleoptions.c

@@ -1019,9 +1019,9 @@ gimp_rectangle_options_gui (GimpToolOptions *tool_options)
   {
     GtkWidget *scale;
 
-    scale = gimp_prop_spin_scale_new (config, "highlight-opacity", NULL,
+    scale = gimp_prop_spin_scale_new (config, "highlight-opacity",
                                       0.01, 0.1, 0);
-    gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+    gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
 
     frame = gimp_prop_expanding_frame_new (config, "highlight", NULL,
                                            scale, NULL);

app/tools/gimprectangleselectoptions.c

@@ -172,7 +172,7 @@ gimp_rectangle_select_options_gui (GimpToolOptions *tool_options)
       GtkWidget *scale;
       GtkWidget *toggle;
 
-      scale = gimp_prop_spin_scale_new (config, "corner-radius", NULL,
+      scale = gimp_prop_spin_scale_new (config, "corner-radius",
                                         1.0, 10.0, 1);
       gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale),
                                         0.0, 1000.0);

app/tools/gimpregionselectoptions.c

@@ -268,7 +268,7 @@ gimp_region_select_options_gui (GimpToolOptions *tool_options)
     }
 
   /*  the threshold scale  */
-  scale = gimp_prop_spin_scale_new (config, "threshold", NULL,
+  scale = gimp_prop_spin_scale_new (config, "threshold",
                                     1.0, 16.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimpseamlesscloneoptions.c

@@ -128,7 +128,7 @@ gimp_seamless_clone_options_gui (GimpToolOptions *tool_options)
   GtkWidget *vbox   = gimp_tool_options_gui (tool_options);
   GtkWidget *scale;
 
-  scale = gimp_prop_spin_scale_new (config, "max-refine-scale", NULL,
+  scale = gimp_prop_spin_scale_new (config, "max-refine-scale",
                                     1.0, 10.0, 0);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 50.0);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);

app/tools/gimpselectionoptions.c

@@ -278,7 +278,7 @@ gimp_selection_options_gui (GimpToolOptions *tool_options)
     GtkWidget *scale;
 
     /*  the feather radius scale  */
-    scale = gimp_prop_spin_scale_new (config, "feather-radius", NULL,
+    scale = gimp_prop_spin_scale_new (config, "feather-radius",
                                       1.0, 10.0, 1);
 
     frame = gimp_prop_expanding_frame_new (config, "feather", NULL,

app/tools/gimpsmudgetool.c

@@ -99,11 +99,11 @@ gimp_smudge_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
   /*  the rate scale  */
-  scale = gimp_prop_spin_scale_new (config, "rate", NULL,
+  scale = gimp_prop_spin_scale_new (config, "rate",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "flow", NULL,
+  scale = gimp_prop_spin_scale_new (config, "flow",
                                     1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 

app/tools/gimptransformgridoptions.c

@@ -443,9 +443,9 @@ gimp_transform_grid_options_gui (GimpToolOptions *tool_options)
   gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 0);
   gtk_widget_show (frame);
 
-  scale = gimp_prop_spin_scale_new (config, "preview-opacity", NULL,
+  scale = gimp_prop_spin_scale_new (config, "preview-opacity",
                                     0.01, 0.1, 0);
-  gimp_prop_widget_set_factor (scale, 100.0, 0.0, 0.0, 1);
+  gimp_prop_widget_set_factor (scale, 100.0, 1.0, 10.0, 1);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);
   gtk_widget_show (scale);
 
@@ -470,7 +470,7 @@ gimp_transform_grid_options_gui (GimpToolOptions *tool_options)
   gtk_frame_set_label_widget (GTK_FRAME (frame), combo);
 
   /*  the grid density scale  */
-  scale = gimp_prop_spin_scale_new (config, "grid-size", NULL,
+  scale = gimp_prop_spin_scale_new (config, "grid-size",
                                     1.8, 8.0, 0);
   gimp_spin_scale_set_label (GIMP_SPIN_SCALE (scale), NULL);
   gtk_container_add (GTK_CONTAINER (frame), scale);

app/tools/gimpwarpoptions.c

@@ -309,22 +309,22 @@ gimp_warp_options_gui (GimpToolOptions *tool_options)
 
   options->behavior_combo = combo;
 
-  scale = gimp_prop_spin_scale_new (config, "effect-size", NULL,
+  scale = gimp_prop_spin_scale_new (config, "effect-size",
                                     0.01, 1.0, 2);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 1000.0);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "effect-hardness", NULL,
+  scale = gimp_prop_spin_scale_new (config, "effect-hardness",
                                     1, 10, 1);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 100.0);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "effect-strength", NULL,
+  scale = gimp_prop_spin_scale_new (config, "effect-strength",
                                     1, 10, 1);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 100.0);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "stroke-spacing", NULL,
+  scale = gimp_prop_spin_scale_new (config, "stroke-spacing",
                                     1, 10, 1);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 1.0, 100.0);
   gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 0);
@@ -360,7 +360,7 @@ gimp_warp_options_gui (GimpToolOptions *tool_options)
   button = gimp_prop_check_button_new (config, "stroke-during-motion", NULL);
   gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
 
-  scale = gimp_prop_spin_scale_new (config, "stroke-periodically-rate", NULL,
+  scale = gimp_prop_spin_scale_new (config, "stroke-periodically-rate",
                                     1, 10, 1);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 0.0, 100.0);
 
@@ -377,7 +377,7 @@ gimp_warp_options_gui (GimpToolOptions *tool_options)
   gtk_container_add (GTK_CONTAINER (frame), vbox2);
   gtk_widget_show (vbox2);
 
-  scale = gimp_prop_spin_scale_new (config, "n-animation-frames", NULL,
+  scale = gimp_prop_spin_scale_new (config, "n-animation-frames",
                                     1.0, 10.0, 0);
   gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale), 3.0, 100.0);
   gtk_box_pack_start (GTK_BOX (vbox2), scale, FALSE, FALSE, 0);

app/widgets/gimppropwidgets.c

@@ -450,336 +450,6 @@ gimp_prop_color_button_notify (GObject    *config,
 }
 
 
-/*****************/
-/*  adjustments  */
-/*****************/
-
-static void   gimp_prop_adjustment_callback (GtkAdjustment *adjustment,
-                                             GObject       *config);
-static void   gimp_prop_adjustment_notify   (GObject       *config,
-                                             GParamSpec    *param_spec,
-                                             GtkAdjustment *adjustment);
-
-/**
- * gimp_prop_spin_scale_new:
- * @config:        #GimpConfig object to which property is attached.
- * @property_name: Name of gdouble property
- * @label:         Label of the created #GimpSpinScale.
- * @step_increment:
- * @page_increment:
- * @digits:
- *
- * Creates a #GimpSpinScale to set and display the value of a
- * gdouble property in a very space-efficient way.
- * If @label is %NULL, the @property_name's nick will be used as label
- * of the returned widget.
- * The property's lower and upper values will be used as min/max of the
- * #GimpSpinScale.
- *
- * Returns:  A new #GimpSpinScale widget.
- *
- * Since GIMP 2.8
- */
-GtkWidget *
-gimp_prop_spin_scale_new (GObject     *config,
-                          const gchar *property_name,
-                          const gchar *label,
-                          gdouble      step_increment,
-                          gdouble      page_increment,
-                          gint         digits)
-{
-  GParamSpec    *param_spec;
-  GtkAdjustment *adjustment;
-  GtkWidget     *scale;
-  gdouble        value;
-  gdouble        lower;
-  gdouble        upper;
-
-  param_spec = find_param_spec (config, property_name, G_STRFUNC);
-  if (! param_spec)
-    return NULL;
-
-  /* The generic min and max for the property. */
-  if (! _gimp_prop_widgets_get_numeric_values (config, param_spec,
-                                               &value, &lower, &upper,
-                                               G_STRFUNC))
-    return NULL;
-
-  /* Get label. */
-  if (! label)
-    label = g_param_spec_get_nick (param_spec);
-
-  /* Also usable on int properties. */
-  if (! G_IS_PARAM_SPEC_DOUBLE (param_spec))
-    digits = 0;
-
-  adjustment = gtk_adjustment_new (value, lower, upper,
-                                   step_increment, page_increment, 0.0);
-
-  scale = gimp_spin_scale_new (adjustment, label, digits);
-
-  set_param_spec (G_OBJECT (adjustment), scale, param_spec);
-
-  if (GEGL_IS_PARAM_SPEC_DOUBLE (param_spec))
-    {
-      GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (param_spec);
-
-      gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale),
-                                        gspec->ui_minimum, gspec->ui_maximum);
-      gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), gspec->ui_gamma);
-    }
-  else if (GEGL_IS_PARAM_SPEC_INT (param_spec))
-    {
-      GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (param_spec);
-
-      gimp_spin_scale_set_scale_limits (GIMP_SPIN_SCALE (scale),
-                                        gspec->ui_minimum, gspec->ui_maximum);
-      gimp_spin_scale_set_gamma (GIMP_SPIN_SCALE (scale), gspec->ui_gamma);
-    }
-
-  g_signal_connect (adjustment, "value-changed",
-                    G_CALLBACK (gimp_prop_adjustment_callback),
-                    config);
-
-  connect_notify (config, property_name,
-                  G_CALLBACK (gimp_prop_adjustment_notify),
-                  adjustment);
-
-  gtk_widget_show (scale);
-
-  return scale;
-}
-
-void
-gimp_prop_widget_set_factor (GtkWidget *widget,
-                             gdouble    factor,
-                             gdouble    step_increment,
-                             gdouble    page_increment,
-                             gint       digits)
-{
-  GtkAdjustment *adjustment;
-  gdouble       *factor_store;
-  gdouble        old_factor = 1.0;
-  gdouble        f;
-
-  g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
-  g_return_if_fail (factor != 0.0);
-  g_return_if_fail (digits >= 0);
-
-  adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
-
-  g_return_if_fail (get_param_spec (G_OBJECT (adjustment)) != NULL);
-
-  factor_store = g_object_get_data (G_OBJECT (adjustment),
-                                    "gimp-prop-adjustment-factor");
-  if (factor_store)
-    {
-      old_factor = *factor_store;
-    }
-  else
-    {
-      factor_store = g_new (gdouble, 1);
-      g_object_set_data_full (G_OBJECT (adjustment),
-                              "gimp-prop-adjustment-factor",
-                              factor_store, (GDestroyNotify) g_free);
-    }
-
-  *factor_store = factor;
-
-  f = factor / old_factor;
-
-  if (step_increment <= 0)
-    step_increment = f * gtk_adjustment_get_step_increment (adjustment);
-
-  if (page_increment <= 0)
-    page_increment = f * gtk_adjustment_get_page_increment (adjustment);
-
-  gtk_adjustment_configure (adjustment,
-                            f * gtk_adjustment_get_value (adjustment),
-                            f * gtk_adjustment_get_lower (adjustment),
-                            f * gtk_adjustment_get_upper (adjustment),
-                            step_increment,
-                            page_increment,
-                            f * gtk_adjustment_get_page_size (adjustment));
-
-  gtk_spin_button_set_digits (GTK_SPIN_BUTTON (widget), digits);
-}
-
-static void
-gimp_prop_adjustment_callback (GtkAdjustment *adjustment,
-                               GObject       *config)
-{
-  GParamSpec *param_spec;
-  gdouble     value;
-  gdouble    *factor;
-
-  param_spec = get_param_spec (G_OBJECT (adjustment));
-  if (! param_spec)
-    return;
-
-  value = gtk_adjustment_get_value (adjustment);
-
-  factor = g_object_get_data (G_OBJECT (adjustment),
-                              "gimp-prop-adjustment-factor");
-  if (factor)
-    value /= *factor;
-
-  if (G_IS_PARAM_SPEC_INT (param_spec))
-    {
-      gint v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != (gint) value)
-        g_object_set (config, param_spec->name, (gint) value, NULL);
-    }
-  else if (G_IS_PARAM_SPEC_UINT (param_spec))
-    {
-      guint v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != (guint) value)
-        g_object_set (config, param_spec->name, (guint) value, NULL);
-    }
-  else if (G_IS_PARAM_SPEC_LONG (param_spec))
-    {
-      glong v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != (glong) value)
-        g_object_set (config, param_spec->name, (glong) value, NULL);
-    }
-  else if (G_IS_PARAM_SPEC_ULONG (param_spec))
-    {
-      gulong v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != (gulong) value)
-        g_object_set (config, param_spec->name, (gulong) value, NULL);
-    }
-  else if (G_IS_PARAM_SPEC_INT64 (param_spec))
-    {
-      gint64 v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != (gint64) value)
-        g_object_set (config, param_spec->name, (gint64) value, NULL);
-    }
-  else if (G_IS_PARAM_SPEC_UINT64 (param_spec))
-    {
-      guint64 v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != (guint64) value)
-        g_object_set (config, param_spec->name, (guint64) value, NULL);
-    }
-  else if (G_IS_PARAM_SPEC_DOUBLE (param_spec))
-    {
-      gdouble v;
-
-      g_object_get (config, param_spec->name, &v, NULL);
-
-      if (v != value)
-        g_object_set (config, param_spec->name, value, NULL);
-    }
-}
-
-static void
-gimp_prop_adjustment_notify (GObject       *config,
-                             GParamSpec    *param_spec,
-                             GtkAdjustment *adjustment)
-{
-  gdouble  value;
-  gdouble *factor;
-
-  if (G_IS_PARAM_SPEC_INT (param_spec))
-    {
-      gint int_value;
-
-      g_object_get (config, param_spec->name, &int_value, NULL);
-
-      value = int_value;
-    }
-  else if (G_IS_PARAM_SPEC_UINT (param_spec))
-    {
-      guint uint_value;
-
-      g_object_get (config, param_spec->name, &uint_value, NULL);
-
-      value = uint_value;
-    }
-  else if (G_IS_PARAM_SPEC_LONG (param_spec))
-    {
-      glong long_value;
-
-      g_object_get (config, param_spec->name, &long_value, NULL);
-
-      value = long_value;
-    }
-  else if (G_IS_PARAM_SPEC_ULONG (param_spec))
-    {
-      gulong ulong_value;
-
-      g_object_get (config, param_spec->name, &ulong_value, NULL);
-
-      value = ulong_value;
-    }
-  else if (G_IS_PARAM_SPEC_INT64 (param_spec))
-    {
-      gint64 int64_value;
-
-      g_object_get (config, param_spec->name, &int64_value, NULL);
-
-      value = int64_value;
-    }
-  else if (G_IS_PARAM_SPEC_UINT64 (param_spec))
-    {
-      guint64 uint64_value;
-
-      g_object_get (config, param_spec->name, &uint64_value, NULL);
-
-#if defined _MSC_VER && (_MSC_VER < 1300)
-      value = (gint64) uint64_value;
-#else
-      value = uint64_value;
-#endif
-    }
-  else if (G_IS_PARAM_SPEC_DOUBLE (param_spec))
-    {
-      g_object_get (config, param_spec->name, &value, NULL);
-    }
-  else
-    {
-      g_warning ("%s: unhandled param spec of type %s",
-                 G_STRFUNC, G_PARAM_SPEC_TYPE_NAME (param_spec));
-      return;
-    }
-
-  factor = g_object_get_data (G_OBJECT (adjustment),
-                              "gimp-prop-adjustment-factor");
-  if (factor)
-    value *= *factor;
-
-  if (gtk_adjustment_get_value (adjustment) != value)
-    {
-      g_signal_handlers_block_by_func (adjustment,
-                                       gimp_prop_adjustment_callback,
-                                       config);
-
-      gtk_adjustment_set_value (adjustment, value);
-
-      g_signal_handlers_unblock_by_func (adjustment,
-                                         gimp_prop_adjustment_callback,
-                                         config);
-    }
-}
-
-
 /************/
 /*  angles  */
 /************/

app/widgets/gimppropwidgets.h

@@ -57,19 +57,6 @@ GtkWidget * gimp_prop_color_button_new      (GObject       *config,
 
 /*  GParamDouble  */
 
-GtkWidget * gimp_prop_spin_scale_new        (GObject       *config,
-                                             const gchar   *property_name,
-                                             const gchar   *label,
-                                             gdouble        step_increment,
-                                             gdouble        page_increment,
-                                             gint           digits);
-
-void        gimp_prop_widget_set_factor     (GtkWidget     *widget,
-                                             gdouble        factor,
-                                             gdouble        step_increment,
-                                             gdouble        page_increment,
-                                             gint           digits);
-
 GtkWidget * gimp_prop_angle_dial_new        (GObject       *config,
                                              const gchar   *property_name);
 GtkWidget * gimp_prop_angle_range_dial_new  (GObject       *config,

libgimpwidgets/gimppropwidgets.c

@@ -1355,6 +1355,9 @@ static void   gimp_prop_adjustment_notify   (GObject       *config,
  * Creates a spin button to set and display the value of the
  * specified double property.
  *
+ * If you wish to change the widget's range relatively to the
+ * @property_name's range, use gimp_prop_widget_set_factor().
+ *
  * Returns: (transfer full): A new #libgimpwidgets-gimpspinbutton.
  *
  * Since: 2.4
@@ -1369,6 +1372,7 @@ gimp_prop_spin_button_new (GObject     *config,
   GParamSpec    *param_spec;
   GtkWidget     *spinbutton;
   GtkAdjustment *adjustment;
+  GBinding      *binding;
   gdouble        value;
   gdouble        lower;
   gdouble        upper;
@@ -1392,13 +1396,12 @@ gimp_prop_spin_button_new (GObject     *config,
 
   set_param_spec (G_OBJECT (adjustment), spinbutton, param_spec);
 
-  g_signal_connect (adjustment, "value-changed",
+  binding = g_object_bind_property (config,     property_name,
-                    G_CALLBACK (gimp_prop_adjustment_callback),
+                                    spinbutton, "value",
-                    config);
+                                    G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
-
+  g_object_set_data (G_OBJECT (adjustment),
-  connect_notify (config, property_name,
+                     "gimp-prop-adjustment-binding",
-                  G_CALLBACK (gimp_prop_adjustment_notify),
+                     binding);
-                  adjustment);
 
   gtk_widget_show (spinbutton);
 
@@ -1450,6 +1453,215 @@ gimp_prop_label_spin_new (GObject     *config,
   return widget;
 }
 
+/**
+ * gimp_prop_spin_scale_new:
+ * @config:         Object to which property is attached.
+ * @property_name:  Name of double or int property controlled by the
+ *                  spin button.
+ * @step_increment: Step size.
+ * @page_increment: Page size.
+ * @digits:         Number of digits after decimal point to display.
+ *                  This is only used for double properties. In case of
+ *                  int properties, `digits = 0` is implied.
+ *
+ * Creates a spin scale to set and display the value of the specified
+ * int or double property.
+ *
+ * By default, the @property_name's nick will be used as label of the
+ * returned widget. Use gimp_spin_scale_set_label() to change this.
+ *
+ * If you wish to change the widget's range relatively to the
+ * @property_name's range, use gimp_prop_widget_set_factor().
+ *
+ * Returns: (transfer full): A new #libgimpwidgets-gimpspinbutton.
+ *
+ * Since: 3.0
+ */
+GtkWidget *
+gimp_prop_spin_scale_new (GObject     *config,
+                          const gchar *property_name,
+                          gdouble      step_increment,
+                          gdouble      page_increment,
+                          gint         digits)
+{
+  GParamSpec    *param_spec;
+  GtkWidget     *spinscale;
+  GtkAdjustment *adjustment;
+  const gchar   *label;
+  const gchar   *tooltip;
+  GBinding      *binding;
+  gdouble        value;
+  gdouble        lower;
+  gdouble        upper;
+
+  param_spec = find_param_spec (config, property_name, G_STRFUNC);
+  if (! param_spec)
+    return NULL;
+
+  if (! get_numeric_values (config,
+                            param_spec, &value, &lower, &upper, G_STRFUNC))
+    return NULL;
+
+  if (! G_IS_PARAM_SPEC_DOUBLE (param_spec))
+    digits = 0;
+
+  adjustment = gtk_adjustment_new (value, lower, upper,
+                                   step_increment, page_increment, 0);
+  label = g_param_spec_get_nick (param_spec);
+
+  spinscale = gimp_spin_scale_new (adjustment, label, digits);
+
+  set_param_spec (G_OBJECT (adjustment), spinscale, param_spec);
+
+  tooltip = g_param_spec_get_blurb (param_spec);
+  gimp_help_set_help_data (spinscale, tooltip, NULL);
+
+  binding = g_object_bind_property (config, property_name,
+                                    spinscale, "value",
+                                    G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
+
+  g_object_set_data (G_OBJECT (adjustment),
+                     "gimp-prop-adjustment-binding",
+                     binding);
+
+  gtk_widget_show (spinscale);
+
+  return spinscale;
+}
+
+/**
+ * gimp_prop_widget_set_factor:
+ * @widget:         Property widget.
+ * @factor:         Multiplier to convert the @widget's range and
+ *                  map appropriately to the property's range it is
+ *                  associated to.
+ * @step_increment: Step size.
+ * @page_increment: Page size.
+ * @digits:         Number of digits after decimal point to display.
+ *
+ * Change the display factor of the property @widget relatively to the
+ * property it was bound to. Currently the only types of widget accepted
+ * as input are those created by gimp_prop_spin_scale_new() and
+ * gimp_prop_spin_button_new().
+ *
+ * If @factor is 1.0, then the config property and the widget display
+ * map exactly.
+ *
+ * If @factor is not 1.0, the widget's range will be computed based of
+ * @property_name's range multiplied by @factor. A typical usage would
+ * be to display a [0.0, 1.0] range as [0.0, 100.0] by setting 100.0 as
+ * @factor. This function can only be used with double properties.
+ *
+ * The @step_increment and @page_increment can be set to new increments
+ * you want to get for this new range. If you set them to 0.0 or
+ * negative values, new increments will be computed based on the new
+ * @factor and previous factor.
+ *
+ * Since: 3.0
+ */
+void
+gimp_prop_widget_set_factor (GtkWidget *widget,
+                             gdouble    factor,
+                             gdouble    step_increment,
+                             gdouble    page_increment,
+                             gint       digits)
+{
+  GtkAdjustment *adjustment;
+  GParamSpec    *param_spec;
+  GBinding      *binding;
+  GObject       *config;
+  gchar         *property_name;
+  gdouble       *factor_store;
+  gdouble        old_factor = 1.0;
+  gdouble        f;
+
+  g_return_if_fail (GTK_IS_SPIN_BUTTON (widget));
+  g_return_if_fail (factor != 0.0);
+  g_return_if_fail (digits >= 0);
+
+  adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
+
+  param_spec = get_param_spec (G_OBJECT (adjustment));
+  g_return_if_fail (param_spec != NULL && G_IS_PARAM_SPEC_DOUBLE (param_spec));
+
+  /* Get the old factor and recompute new values. */
+  factor_store = g_object_get_data (G_OBJECT (adjustment),
+                                    "gimp-prop-adjustment-factor");
+  if (factor_store)
+    {
+      old_factor = *factor_store;
+    }
+  else
+    {
+      factor_store = g_new (gdouble, 1);
+      g_object_set_data_full (G_OBJECT (adjustment),
+                              "gimp-prop-adjustment-factor",
+                              factor_store, (GDestroyNotify) g_free);
+    }
+
+  *factor_store = factor;
+
+  f = factor / old_factor;
+
+  if (step_increment <= 0)
+    step_increment = f * gtk_adjustment_get_step_increment (adjustment);
+
+  if (page_increment <= 0)
+    page_increment = f * gtk_adjustment_get_page_increment (adjustment);
+
+  /* Remove the old binding. */
+  binding = g_object_get_data (G_OBJECT (adjustment),
+                               "gimp-prop-adjustment-binding");
+  g_return_if_fail (binding != NULL);
+  config = g_binding_dup_source (binding);
+
+  /* This binding should not have outlived the config object. */
+  g_return_if_fail (config != NULL);
+
+  property_name = g_strdup (g_binding_get_source_property (binding));
+  g_binding_unbind (binding);
+
+  /* Reconfigure the scale object. */
+  gtk_adjustment_configure (adjustment,
+                            f * gtk_adjustment_get_value (adjustment),
+                            f * gtk_adjustment_get_lower (adjustment),
+                            f * gtk_adjustment_get_upper (adjustment),
+                            step_increment,
+                            page_increment,
+                            f * gtk_adjustment_get_page_size (adjustment));
+
+  gtk_spin_button_set_digits (GTK_SPIN_BUTTON (widget), digits);
+
+  /* Finally create a new binding. */
+  if (factor != 1.0)
+    {
+      gdouble *user_data;
+
+      user_data = g_new0 (gdouble, 1);
+      *user_data = factor;
+      /* With @factor == 1.0, this is equivalent to a
+       * g_object_bind_property().
+       */
+      binding = g_object_bind_property_full (config, property_name,
+                                             widget, "value",
+                                             G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE,
+                                             gimp_prop_widget_double_to_factor,
+                                             gimp_prop_widget_double_from_factor,
+                                             user_data, (GDestroyNotify) g_free);
+    }
+  else
+    {
+      binding = g_object_bind_property (config, property_name,
+                                        widget, "value",
+                                        G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
+    }
+  g_object_set_data (G_OBJECT (adjustment),
+                     "gimp-prop-adjustment-binding",
+                     binding);
+  g_object_unref (config);
+  g_free (property_name);
+}
+
 /**
  * gimp_prop_hscale_new:
  * @config:         Object to which property is attached.

libgimpwidgets/gimppropwidgets.h

@@ -118,6 +118,17 @@ GtkWidget     * gimp_prop_label_spin_new          (GObject      *config,
                                                    const gchar  *property_name,
                                                    gint          digits);
 
+GtkWidget     * gimp_prop_spin_scale_new          (GObject      *config,
+                                                   const gchar  *property_name,
+                                                   gdouble       step_increment,
+                                                   gdouble       page_increment,
+                                                   gint          digits);
+
+void            gimp_prop_widget_set_factor       (GtkWidget    *widget,
+                                                   gdouble       factor,
+                                                   gdouble       step_increment,
+                                                   gdouble       page_increment,
+                                                   gint          digits);
 
 GtkWidget     * gimp_prop_hscale_new              (GObject      *config,
                                                    const gchar  *property_name,

libgimpwidgets/gimpwidgets.def

@@ -374,10 +374,12 @@ EXPORTS
 	gimp_prop_scale_entry_new
 	gimp_prop_size_entry_new
 	gimp_prop_spin_button_new
+	gimp_prop_spin_scale_new
 	gimp_prop_string_combo_box_new
 	gimp_prop_switch_new
 	gimp_prop_text_buffer_new
 	gimp_prop_unit_combo_box_new
+	gimp_prop_widget_set_factor
 	gimp_query_boolean_box
 	gimp_query_double_box
 	gimp_query_int_box