[gimp] plug-ins: various plug-ins ported to new GimpScaleEntry.



commit f342b566c89e726d6a9041eaa8303be5aaf9f7b0
Author: Jehan <jehan girinstud io>
Date:   Fri Oct 30 23:28:57 2020 +0100

    plug-ins: various plug-ins ported to new GimpScaleEntry.

 plug-ins/common/align-layers.c           |  34 ++-
 plug-ins/common/blinds.c                 |  62 ++---
 plug-ins/common/film.c                   | 165 ++++++------
 plug-ins/common/jigsaw.c                 |  99 +++----
 plug-ins/common/sparkle.c                | 183 +++++++------
 plug-ins/common/wavelet-decompose.c      |  44 ++--
 plug-ins/gradient-flare/gradient-flare.c | 425 +++++++++++++++----------------
 plug-ins/lighting/lighting-ui.c          |  30 +--
 plug-ins/pagecurl/pagecurl.c             |  44 ++--
 9 files changed, 529 insertions(+), 557 deletions(-)
---
diff --git a/plug-ins/common/align-layers.c b/plug-ins/common/align-layers.c
index 20d321ad42..6391be66ba 100644
--- a/plug-ins/common/align-layers.c
+++ b/plug-ins/common/align-layers.c
@@ -28,7 +28,6 @@
 #define PLUG_IN_PROC   "plug-in-align-layers"
 #define PLUG_IN_BINARY "align-layers"
 #define PLUG_IN_ROLE   "gimp-align-layers"
-#define SCALE_WIDTH    150
 
 enum
 {
@@ -124,6 +123,8 @@ static void             align_layers_get_align_offsets      (GimpDrawable
                                                              gint                 *x,
                                                              gint                 *y);
 static gint             align_layers_dialog                 (void);
+static void             align_layers_scale_entry_update_int (GimpScaleEntry       *entry,
+                                                             gint                 *value);
 
 
 G_DEFINE_TYPE (AlignLayers, align_layers, GIMP_TYPE_PLUG_IN)
@@ -647,12 +648,12 @@ align_layers_get_align_offsets (GimpDrawable *drawable,
 static int
 align_layers_dialog (void)
 {
-  GtkWidget     *dialog;
-  GtkWidget     *grid;
-  GtkWidget     *combo;
-  GtkWidget     *toggle;
-  GtkAdjustment *adj;
-  gboolean       run;
+  GtkWidget *dialog;
+  GtkWidget *grid;
+  GtkWidget *combo;
+  GtkWidget *toggle;
+  GtkWidget *scale;
+  gboolean   run;
 
   gimp_ui_init (PLUG_IN_BINARY);
 
@@ -741,14 +742,12 @@ align_layers_dialog (void)
                             _("Ver_tical base:"), 0.0, 0.5,
                             combo, 2);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 4,
-                              _("_Grid size:"), SCALE_WIDTH, 0,
-                              VALS.grid_size, 1, 200, 1, 10, 0,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Grid size:"), VALS.grid_size, 1, 200, 0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (align_layers_scale_entry_update_int),
                     &VALS.grid_size);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 4, 3, 1);
+  gtk_widget_show (scale);
 
   toggle = gtk_check_button_new_with_mnemonic
     (_("_Ignore the bottom layer even if visible"));
@@ -779,3 +778,10 @@ align_layers_dialog (void)
 
   return run;
 }
+
+static void
+align_layers_scale_entry_update_int (GimpScaleEntry *entry,
+                                     gint           *value)
+{
+  *value = (gint) gimp_scale_entry_get_value (entry);
+}
diff --git a/plug-ins/common/blinds.c b/plug-ins/common/blinds.c
index f6b859782a..a98ed502d0 100644
--- a/plug-ins/common/blinds.c
+++ b/plug-ins/common/blinds.c
@@ -44,8 +44,6 @@
 #define PLUG_IN_BINARY "blinds"
 #define PLUG_IN_ROLE   "gimp-blinds"
 
-#define SCALE_WIDTH    150
-
 #define MAX_FANS       100
 
 /* Variables set in dialog box */
@@ -89,6 +87,8 @@ static GimpValueArray * blinds_run              (GimpProcedure        *procedure
                                                  gpointer              run_data);
 
 static gboolean         blinds_dialog           (GimpDrawable         *drawable);
+static void       blinds_scale_entry_update_int (GimpScaleEntry       *entry,
+                                                 gint                 *value);
 
 static void             dialog_update_preview   (GimpDrawable         *drawable,
                                                  GimpPreview          *preview);
@@ -256,17 +256,17 @@ blinds_run (GimpProcedure        *procedure,
 static gboolean
 blinds_dialog (GimpDrawable *drawable)
 {
-  GtkWidget     *dialog;
-  GtkWidget     *main_vbox;
-  GtkWidget     *preview;
-  GtkWidget     *hbox;
-  GtkWidget     *frame;
-  GtkWidget     *grid;
-  GtkAdjustment *size_data;
-  GtkWidget     *toggle;
-  GtkWidget     *horizontal;
-  GtkWidget     *vertical;
-  gboolean       run;
+  GtkWidget *dialog;
+  GtkWidget *main_vbox;
+  GtkWidget *preview;
+  GtkWidget *hbox;
+  GtkWidget *frame;
+  GtkWidget *grid;
+  GtkWidget *scale;
+  GtkWidget *toggle;
+  GtkWidget *horizontal;
+  GtkWidget *vertical;
+  gboolean   run;
 
   gimp_ui_init (PLUG_IN_BINARY);
 
@@ -355,29 +355,26 @@ blinds_dialog (GimpDrawable *drawable)
   gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
   gtk_widget_show (grid);
 
-  size_data = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                                    _("_Displacement:"), SCALE_WIDTH, 0,
-                                    bvals.angledsp, 1, 90, 1, 15, 0,
-                                    TRUE, 0, 0,
-                                    NULL, NULL);
-  g_signal_connect (size_data, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Displacement:"), bvals.angledsp, 1, 90, 0);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (blinds_scale_entry_update_int),
                     &bvals.angledsp);
-  g_signal_connect_swapped (size_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 2);
+  gtk_widget_show (scale);
 
-  size_data = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
-                                    _("_Number of segments:"), SCALE_WIDTH, 0,
-                                    bvals.numsegs, 1, MAX_FANS, 1, 2, 0,
-                                    TRUE, 0, 0,
-                                    NULL, NULL);
-  g_signal_connect (size_data, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Number of segments:"), bvals.numsegs, 1, MAX_FANS, 0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (blinds_scale_entry_update_int),
                     &bvals.numsegs);
-  g_signal_connect_swapped (size_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 2);
+  gtk_widget_show (scale);
 
   gtk_widget_show (dialog);
 
@@ -388,6 +385,13 @@ blinds_dialog (GimpDrawable *drawable)
   return run;
 }
 
+static void
+blinds_scale_entry_update_int (GimpScaleEntry *entry,
+                               gint           *value)
+{
+  *value = (gint) gimp_scale_entry_get_value (entry);
+}
+
 static void
 blindsapply (guchar *srow,
              guchar *drow,
diff --git a/plug-ins/common/film.c b/plug-ins/common/film.c
index d14f26263a..724dd4425b 100644
--- a/plug-ins/common/film.c
+++ b/plug-ins/common/film.c
@@ -67,7 +67,7 @@ typedef struct
 /* Data to use for the dialog */
 typedef struct
 {
-  GtkAdjustment *advanced_adj[7];
+  GtkWidget     *scales[7];
   GtkTreeModel  *image_list_all;
   GtkTreeModel  *image_list_film;
 } FilmInterface;
@@ -145,6 +145,8 @@ static void         film_font_select_callback (GimpFontSelectButton *button,
                                                gboolean              closing,
                                                gpointer              data);
 
+static void    film_scale_entry_update_double (GimpScaleEntry       *entry,
+                                               gdouble              *value);
 
 G_DEFINE_TYPE (Film, film, GIMP_TYPE_PLUG_IN)
 
@@ -1181,13 +1183,13 @@ create_selection_tab (GtkWidget *notebook,
 static void
 create_advanced_tab (GtkWidget *notebook)
 {
-  GtkWidget     *vbox;
-  GtkWidget     *hbox;
-  GtkWidget     *grid;
-  GtkWidget     *frame;
-  GtkAdjustment *adj;
-  GtkWidget     *button;
-  gint           row;
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *grid;
+  GtkWidget *frame;
+  GtkWidget *scale;
+  GtkWidget *button;
+  gint       row;
 
   frame = gimp_frame_new (_("All Values are Fractions of the Strip Height"));
   gtk_container_set_border_width (GTK_CONTAINER (frame), 12);
@@ -1207,88 +1209,74 @@ create_advanced_tab (GtkWidget *notebook)
 
   row = 0;
 
-  filmint.advanced_adj[0] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("Image _height:"), 0, 0,
-                          filmvals.picture_height,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  filmint.scales[0] = scale =
+    gimp_scale_entry_new2 (_("Image _height:"), filmvals.picture_height, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.picture_height);
-
-  filmint.advanced_adj[1] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("Image spac_ing:"), 0, 0,
-                          filmvals.picture_space,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 0, 1), 6);
-  gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 1, 1), 6);
-  gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 2, 1), 6);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
+
+  filmint.scales[1] = scale =
+    gimp_scale_entry_new2 (_("Image spac_ing:"), filmvals.picture_space, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.picture_space);
-
-  filmint.advanced_adj[2] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("_Hole offset:"), 0, 0,
-                          filmvals.hole_offset,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6);
+  gtk_widget_set_margin_bottom (gimp_scale_entry_get_scale (GIMP_SCALE_ENTRY (scale)), 6);
+  gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)), 6);
+  gtk_widget_show (scale);
+
+  filmint.scales[2] = scale =
+    gimp_scale_entry_new2 (_("_Hole offset:"), filmvals.hole_offset, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.hole_offset);
-
-  filmint.advanced_adj[3] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("Ho_le width:"), 0, 0,
-                          filmvals.hole_width,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
+
+  filmint.scales[3] = scale =
+    gimp_scale_entry_new2 (_("Ho_le width:"), filmvals.hole_width, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.hole_width);
-
-  filmint.advanced_adj[4] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("Hol_e height:"), 0, 0,
-                          filmvals.hole_height,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
+
+  filmint.scales[4] = scale =
+    gimp_scale_entry_new2 (_("Hol_e height:"), filmvals.hole_height, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.hole_height);
-
-  filmint.advanced_adj[5] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("Hole sp_acing:"), 0, 0,
-                          filmvals.hole_space,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 0, 5), 6);
-  gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 1, 5), 6);
-  gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 2, 5), 6);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
+
+  filmint.scales[5] = scale =
+    gimp_scale_entry_new2 (_("Hole sp_acing:"), filmvals.hole_space, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.hole_space);
-
-  filmint.advanced_adj[6] = adj =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                          _("_Number height:"), 0, 0,
-                          filmvals.number_height,
-                          0.0, 1.0, 0.001, 0.01, 3,
-                          TRUE, 0, 0,
-                          NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6);
+  gtk_widget_set_margin_bottom (gimp_scale_entry_get_scale (GIMP_SCALE_ENTRY (scale)), 6);
+  gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)), 6);
+  gtk_widget_show (scale);
+
+  filmint.scales[6] = scale =
+    gimp_scale_entry_new2 (_("_Number height:"), filmvals.number_height, 0.0, 1.0, 3);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (film_scale_entry_update_double),
                     &filmvals.number_height);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
@@ -1387,8 +1375,8 @@ film_reset_callback (GtkWidget *widget,
   gint i;
 
   for (i = 0; i < G_N_ELEMENTS (advanced_defaults) ; i++)
-    gtk_adjustment_set_value (filmint.advanced_adj[i],
-                              advanced_defaults[i]);
+    gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (filmint.scales[i]),
+                                advanced_defaults[i]);
 }
 
 static void
@@ -1401,3 +1389,10 @@ film_font_select_callback (GimpFontSelectButton *button,
 
   g_strlcpy (vals->number_font, name, FONT_LEN);
 }
+
+static void
+film_scale_entry_update_double (GimpScaleEntry *entry,
+                                gdouble       *value)
+{
+  *value = gimp_scale_entry_get_value (entry);
+}
diff --git a/plug-ins/common/jigsaw.c b/plug-ins/common/jigsaw.c
index 44187b4f4e..305b0ab53a 100644
--- a/plug-ins/common/jigsaw.c
+++ b/plug-ins/common/jigsaw.c
@@ -108,8 +108,6 @@ typedef enum
 #define MIN_BLEND_AMOUNT 0
 #define MAX_BLEND_AMOUNT 1.0
 
-#define SCALE_WIDTH 200
-
 #define DRAW_POINT(buffer, bufsize, index)         \
   do                                               \
     {                                              \
@@ -221,7 +219,11 @@ static void     jigsaw             (GimpDrawable *drawable,
 static void     jigsaw_preview     (GimpDrawable *drawable,
                                     GimpPreview  *preview);
 
-static gboolean jigsaw_dialog      (GimpDrawable *drawable);
+static gboolean jigsaw_dialog                    (GimpDrawable        *drawable);
+static void     jigsaw_scale_entry_update_double (GimpScaleEntry      *entry,
+                                                  gdouble             *value);
+static void     jigsaw_scale_entry_update_int    (GimpScaleEntry      *entry,
+                                                  gint                *value);
 
 static void     draw_jigsaw        (guchar    *buffer,
                                     gint       bufsize,
@@ -2460,7 +2462,7 @@ jigsaw_dialog (GimpDrawable *drawable)
   GtkWidget     *rbutton1;
   GtkWidget     *rbutton2;
   GtkWidget     *grid;
-  GtkAdjustment *adj;
+  GtkWidget     *scale;
   gboolean       run;
 
   gimp_ui_init (PLUG_IN_BINARY);
@@ -2506,35 +2508,33 @@ jigsaw_dialog (GimpDrawable *drawable)
   group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 
   /* xtiles */
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("_Horizontal:"), SCALE_WIDTH, 0,
-                              config.x, MIN_XTILES, MAX_XTILES, 1.0, 4.0, 0,
-                              TRUE, 0, 0,
-                              _("Number of pieces going across"), NULL);
+  scale = gimp_scale_entry_new2 (_("_Horizontal:"), config.x, MIN_XTILES, MAX_XTILES, 0);
+  gimp_help_set_help_data (scale, _("Number of pieces going across"), NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
-  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (scale));
   g_object_unref (group);
 
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (jigsaw_scale_entry_update_int),
                     &config.x);
-  g_signal_connect_swapped (adj, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
 
   /* ytiles */
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
-                              _("_Vertical:"), SCALE_WIDTH, 0,
-                              config.y, MIN_YTILES, MAX_YTILES, 1.0, 4.0, 0,
-                              TRUE, 0, 0,
-                              _("Number of pieces going down"), NULL);
+  scale = gimp_scale_entry_new2 (_("_Vertical:"), config.y, MIN_YTILES, MAX_YTILES, 0);
+  gimp_help_set_help_data (scale, _("Number of pieces going down"), NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1);
+  gtk_widget_show (scale);
 
-  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+  gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)));
 
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (jigsaw_scale_entry_update_int),
                     &config.y);
-  g_signal_connect_swapped (adj, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
 
@@ -2550,37 +2550,32 @@ jigsaw_dialog (GimpDrawable *drawable)
   gtk_container_add (GTK_CONTAINER (frame), grid);
 
   /* number of blending lines */
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("_Bevel width:"), SCALE_WIDTH, 4,
-                              config.blend_lines,
-                              MIN_BLEND_LINES, MAX_BLEND_LINES, 1.0, 2.0, 0,
-                              TRUE, 0, 0,
-                              _("Degree of slope of each piece's edge"), NULL);
+  scale = gimp_scale_entry_new2 (_("_Bevel width:"), config.blend_lines, MIN_BLEND_LINES, MAX_BLEND_LINES, 
0);
+  gimp_help_set_help_data (scale, _("Degree of slope of each piece's edge"), NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
-  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
+  gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)));
 
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (jigsaw_scale_entry_update_int),
                     &config.blend_lines);
-  g_signal_connect_swapped (adj, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
 
   /* blending amount */
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
-                              _("H_ighlight:"), SCALE_WIDTH, 4,
-                              config.blend_amount,
-                              MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 0.05, 0.1, 2,
-                              TRUE, 0, 0,
-                              _("The amount of highlighting on the edges "
-                                "of each piece"), NULL);
-
-  gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
-
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("H_ighlight:"), config.blend_amount, MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 
2);
+  gimp_help_set_help_data (scale, _("The amount of highlighting on the edges of each piece"), NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1);
+  gtk_widget_show (scale);
+
+  gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)));
+
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (jigsaw_scale_entry_update_double),
                     &config.blend_amount);
-  g_signal_connect_swapped (adj, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
 
@@ -2618,3 +2613,17 @@ jigsaw_dialog (GimpDrawable *drawable)
 
   return run;
 }
+
+static void
+jigsaw_scale_entry_update_double (GimpScaleEntry *entry,
+                                  gdouble        *value)
+{
+  *value = gimp_scale_entry_get_value (entry);
+}
+
+static void
+jigsaw_scale_entry_update_int (GimpScaleEntry *entry,
+                               gint           *value)
+{
+  *value = (gint) gimp_scale_entry_get_value (entry);
+}
diff --git a/plug-ins/common/sparkle.c b/plug-ins/common/sparkle.c
index dcb1ae56e3..1f4cc012c7 100644
--- a/plug-ins/common/sparkle.c
+++ b/plug-ins/common/sparkle.c
@@ -42,8 +42,6 @@
 #define PLUG_IN_BINARY "sparkle"
 #define PLUG_IN_ROLE   "gimp-sparkle"
 
-#define SCALE_WIDTH    175
-#define ENTRY_WIDTH      7
 #define MAX_CHANNELS     4
 #define PSV              2  /* point spread value */
 
@@ -101,6 +99,9 @@ static GimpValueArray * sparkle_run              (GimpProcedure        *procedur
                                                   gpointer              run_data);
 
 static gboolean         sparkle_dialog           (GimpDrawable         *drawable);
+static void    sparkle_scale_entry_update_double (GimpScaleEntry       *entry,
+                                                  gdouble              *value);
+
 
 static gint             compute_luminosity       (const guchar         *pixel,
                                                   gboolean              gray,
@@ -382,16 +383,16 @@ sparkle_run (GimpProcedure        *procedure,
 static gboolean
 sparkle_dialog (GimpDrawable *drawable)
 {
-  GtkWidget     *dialog;
-  GtkWidget     *main_vbox;
-  GtkWidget     *preview;
-  GtkWidget     *vbox;
-  GtkWidget     *hbox;
-  GtkWidget     *grid;
-  GtkWidget     *toggle;
-  GtkWidget     *r1, *r2, *r3;
-  GtkAdjustment *scale_data;
-  gboolean       run;
+  GtkWidget *dialog;
+  GtkWidget *main_vbox;
+  GtkWidget *preview;
+  GtkWidget *vbox;
+  GtkWidget *hbox;
+  GtkWidget *grid;
+  GtkWidget *toggle;
+  GtkWidget *r1, *r2, *r3;
+  GtkWidget *scale;
+  gboolean   run;
 
   gimp_ui_init (PLUG_IN_BINARY);
 
@@ -430,124 +431,106 @@ sparkle_dialog (GimpDrawable *drawable)
   gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
   gtk_widget_show (grid);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-              _("Luminosity _threshold:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.lum_threshold, 0.0, 0.1, 0.001, 0.01, 3,
-              TRUE, 0, 0,
-              _("Adjust the luminosity threshold"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Luminosity _threshold:"), svals.lum_threshold, 0.0, 0.1, 3);
+  gimp_help_set_help_data (scale, _("Adjust the luminosity threshold"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.lum_threshold);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
-              _("F_lare intensity:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.flare_inten, 0.0, 1.0, 0.01, 0.1, 2,
-              TRUE, 0, 0,
-              _("Adjust the flare intensity"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("F_lare intensity:"), svals.flare_inten, 0.0, 1.0, 2);
+  gimp_help_set_help_data (scale, _("Adjust the flare intensity"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.flare_inten);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 2,
-              _("_Spike length:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.spike_len, 1, 100, 1, 10, 0,
-              TRUE, 0, 0,
-              _("Adjust the spike length"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Spike length:"), svals.spike_len, 1, 100, 0);
+  gimp_help_set_help_data (scale, _("Adjust the spike length"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.spike_len);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 2, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 3,
-              _("Sp_ike points:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.spike_pts, 0, 16, 1, 4, 0,
-              TRUE, 0, 0,
-              _("Adjust the number of spikes"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Sp_ike points:"), svals.spike_pts, 0, 16, 0);
+  gimp_help_set_help_data (scale, _("Adjust the number of spikes"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.spike_pts);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
-
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 4,
-              _("Spi_ke angle (-1: random):"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.spike_angle, -1, 360, 1, 15, 0,
-              TRUE, 0, 0,
-              _("Adjust the spike angle "
-                "(-1 causes a random angle to be chosen)"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 3, 3, 1);
+  gtk_widget_show (scale);
+
+  scale = gimp_scale_entry_new2 (_("Spi_ke angle (-1: random):"), svals.spike_angle, -1, 360, 0);
+  gimp_help_set_help_data (scale, _("Adjust the spike angle "
+                                    "(-1 causes a random angle to be chosen)"), NULL);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.spike_angle);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 4, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 5,
-              _("Spik_e density:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.density, 0.0, 1.0, 0.01, 0.1, 2,
-              TRUE, 0, 0,
-              _("Adjust the spike density"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Spik_e density:"), svals.density, 0.0, 1.0, 2);
+  gimp_help_set_help_data (scale, _("Adjust the spike density"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.density);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 5, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 6,
-              _("Tr_ansparency:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.transparency, 0.0, 1.0, 0.01, 0.1, 2,
-              TRUE, 0, 0,
-              _("Adjust the opacity of the spikes"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Tr_ansparency:"), svals.transparency, 0.0, 1.0, 2);
+  gimp_help_set_help_data (scale, _("Adjust the opacity of the spikes"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.transparency);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 6, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 7,
-              _("_Random hue:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.random_hue, 0.0, 1.0, 0.01, 0.1, 2,
-              TRUE, 0, 0,
-              _("Adjust how much the hue should be changed randomly"), NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Random hue:"), svals.random_hue, 0.0, 1.0, 2);
+  gimp_help_set_help_data (scale, _("Adjust how much the hue should be changed randomly"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.random_hue);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 7, 3, 1);
+  gtk_widget_show (scale);
 
-  scale_data =
-    gimp_scale_entry_new (GTK_GRID (grid), 0, 8,
-              _("Rando_m saturation:"), SCALE_WIDTH, ENTRY_WIDTH,
-              svals.random_saturation, 0.0, 1.0, 0.01, 0.1, 2,
-              TRUE, 0, 0,
-              _("Adjust how much the saturation should be changed randomly"),
-              NULL);
-  g_signal_connect (scale_data, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Rando_m saturation:"), svals.random_saturation, 0.0, 1.0, 2);
+  gimp_help_set_help_data (scale, _("Adjust how much the saturation should be changed randomly"), NULL);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (sparkle_scale_entry_update_double),
                     &svals.random_saturation);
-  g_signal_connect_swapped (scale_data, "value-changed",
+  g_signal_connect_swapped (scale, "value-changed",
                             G_CALLBACK (gimp_preview_invalidate),
                             preview);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 8, 3, 1);
+  gtk_widget_show (scale);
 
   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
   gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
@@ -639,6 +622,14 @@ sparkle_dialog (GimpDrawable *drawable)
   return run;
 }
 
+static void
+sparkle_scale_entry_update_double (GimpScaleEntry *entry,
+                                   gdouble        *value)
+{
+  *value = gimp_scale_entry_get_value (entry);
+}
+
+
 static gint
 compute_luminosity (const guchar *pixel,
                     gboolean      gray,
diff --git a/plug-ins/common/wavelet-decompose.c b/plug-ins/common/wavelet-decompose.c
index 954cf8e562..88d5e6fd11 100644
--- a/plug-ins/common/wavelet-decompose.c
+++ b/plug-ins/common/wavelet-decompose.c
@@ -29,9 +29,6 @@
 #define PLUG_IN_ROLE   "gimp-wavelet-decompose"
 #define PLUG_IN_BINARY "wavelet-decompose"
 
-#define SCALE_WIDTH   120
-#define ENTRY_WIDTH     5
-
 
 typedef struct
 {
@@ -72,9 +69,11 @@ static GimpValueArray * wavelet_run              (GimpProcedure        *procedur
                                                   gpointer              run_data);
 
 static void             wavelet_blur             (GimpDrawable         *drawable,
-                                                  gint              radius);
+                                                  gint                  radius);
 
 static gboolean         wavelet_decompose_dialog (void);
+static void       wavelet_scale_entry_update_int (GimpScaleEntry       *entry,
+                                                  gint                 *value);
 
 
 G_DEFINE_TYPE (Wavelet, wavelet, GIMP_TYPE_PLUG_IN)
@@ -372,12 +371,11 @@ wavelet_blur (GimpDrawable *drawable,
 static gboolean
 wavelet_decompose_dialog (void)
 {
-  GtkWidget     *dialog;
-  GtkWidget     *main_vbox;
-  GtkWidget     *grid;
-  GtkWidget     *button;
-  GtkAdjustment *adj;
-  gboolean       run;
+  GtkWidget *dialog;
+  GtkWidget *main_vbox;
+  GtkWidget *button;
+  GtkWidget *scale;
+  gboolean   run;
 
   gimp_ui_init (PLUG_IN_BINARY);
 
@@ -403,23 +401,14 @@ wavelet_decompose_dialog (void)
                       main_vbox, TRUE, TRUE, 0);
   gtk_widget_show (main_vbox);
 
-  grid = gtk_grid_new ();
-  gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
-  gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
-  gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
-  gtk_widget_show (grid);
-
   /* scales */
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("Scales:"), SCALE_WIDTH, ENTRY_WIDTH,
-                              wavelet_params.scales,
-                              1.0, 7.0, 1.0, 1.0, 0,
-                              TRUE, 0, 0,
-                              NULL, NULL);
+  scale = gimp_scale_entry_new2 (_("Scales:"), wavelet_params.scales, 1.0, 7.0, 0);
+  gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 6);
+  gtk_widget_show (scale);
 
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (wavelet_scale_entry_update_int),
                     &wavelet_params.scales);
 
   /* create group layer */
@@ -454,3 +443,10 @@ wavelet_decompose_dialog (void)
 
   return run;
 }
+
+static void
+wavelet_scale_entry_update_int (GimpScaleEntry *entry,
+                                gint           *value)
+{
+  *value = (int) gimp_scale_entry_get_value (entry);
+}
diff --git a/plug-ins/gradient-flare/gradient-flare.c b/plug-ins/gradient-flare/gradient-flare.c
index 12f82a6fac..ecfce0563d 100644
--- a/plug-ins/gradient-flare/gradient-flare.c
+++ b/plug-ins/gradient-flare/gradient-flare.c
@@ -85,8 +85,6 @@
 #define GM_PREVIEW_WIDTH    80
 #define GM_PREVIEW_HEIGHT   16
 
-#define SCALE_WIDTH         80
-
 #ifndef OPAQUE
 #define OPAQUE              255
 #endif
@@ -664,6 +662,10 @@ static void gradient_get_values_real_external   (const gchar *gradient_name,
 static GradientCacheItem *gradient_cache_lookup (const gchar *name,
                                                  gboolean    *found);
 static void gradient_cache_zorch                (void);
+static void gradient_scale_entry_update_double  (GimpScaleEntry *entry,
+                                                 gdouble        *value);
+static void gradient_scale_entry_update_int     (GimpScaleEntry *entry,
+                                                 gint           *value);
 
 
 G_DEFINE_TYPE (Gflare, gflare, GIMP_TYPE_PLUG_IN)
@@ -2838,16 +2840,16 @@ static void
 dlg_make_page_settings (GFlareDialog *dlg,
                         GtkWidget    *notebook)
 {
-  GtkWidget     *main_vbox;
-  GtkWidget     *frame;
-  GtkWidget     *center;
-  GtkWidget     *chain;
-  GtkWidget     *grid;
-  GtkWidget     *button;
-  GtkWidget     *asup_grid;
-  GtkAdjustment *adj;
-  gdouble        xres, yres;
-  gint           row;
+  GtkWidget *main_vbox;
+  GtkWidget *frame;
+  GtkWidget *center;
+  GtkWidget *chain;
+  GtkWidget *grid;
+  GtkWidget *button;
+  GtkWidget *asup_grid;
+  GtkWidget *scale;
+  gdouble    xres, yres;
+  gint       row;
 
   main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
@@ -2896,67 +2898,60 @@ dlg_make_page_settings (GFlareDialog *dlg,
 
   row = 0;
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("_Radius:"), SCALE_WIDTH, 6,
-                              pvals.radius, 0.0,
-                              gimp_drawable_width (drawable) / 2,
-                              1.0, 10.0, 1,
-                              FALSE, 0.0, GIMP_MAX_IMAGE_SIZE,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Radius:"), pvals.radius, 0.0, GIMP_MAX_IMAGE_SIZE, 1);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 0.0, gimp_drawable_width (drawable) / 2, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &pvals.radius);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (dlg_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Ro_tation:"), SCALE_WIDTH, 6,
-                              pvals.rotation, -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Ro_tation:"), pvals.rotation, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &pvals.rotation);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (dlg_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("_Hue rotation:"), SCALE_WIDTH, 6,
-                              pvals.hue, -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Hue rotation:"), pvals.hue, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &pvals.hue);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (dlg_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Vector _angle:"), SCALE_WIDTH, 6,
-                              pvals.vangle, 0.0, 359.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Vector _angle:"), pvals.vangle, 0.0, 359.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &pvals.vangle);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (dlg_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Vector _length:"), SCALE_WIDTH, 6,
-                              pvals.vlength, 1, 1000, 1.0, 10.0, 1,
-                              FALSE, 1, GIMP_MAX_IMAGE_SIZE,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Vector _length:"), pvals.vlength, 1, GIMP_MAX_IMAGE_SIZE, 1);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1, 1000, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &pvals.vlength);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (dlg_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
   /**
   ***   Asupsample settings
@@ -2988,25 +2983,20 @@ dlg_make_page_settings (GFlareDialog *dlg,
                           asup_grid, "sensitive",
                           G_BINDING_SYNC_CREATE);
 
-  adj = gimp_scale_entry_new (GTK_GRID (asup_grid), 0, 0,
-                              _("_Max depth:"), -1, 4,
-                              pvals.asupsample_max_depth,
-                              1.0, 10.0, 1.0, 1.0, 0,
-                              TRUE, 0.0, 0.0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Max depth:"), pvals.asupsample_max_depth, 1.0, 10.0, 0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_int),
                     &pvals.asupsample_max_depth);
+  gtk_grid_attach (GTK_GRID (asup_grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (asup_grid), 0, 1,
-                              _("_Threshold"), -1, 4,
-                              pvals.asupsample_threshold,
-                              0.0, 4.0, 0.01, 0.01, 2,
-                              TRUE, 0.0, 0.0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("_Threshold"), pvals.asupsample_threshold, 0.0, 4.0, 2);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &pvals.asupsample_threshold);
+  gtk_grid_attach (GTK_GRID (asup_grid), scale, 0, 1, 3, 1);
+  gtk_widget_show (scale);
 
   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox,
                             gtk_label_new_with_mnemonic (_("_Settings")));
@@ -3574,12 +3564,12 @@ static void
 ed_make_page_general (GFlareEditor *ed,
                       GtkWidget    *notebook)
 {
-  GFlare        *gflare = ed->gflare;
-  GtkWidget     *vbox;
-  GtkWidget     *frame;
-  GtkWidget     *grid;
-  GtkWidget     *combo;
-  GtkAdjustment *adj;
+  GFlare    *gflare = ed->gflare;
+  GtkWidget *vbox;
+  GtkWidget *frame;
+  GtkWidget *grid;
+  GtkWidget *combo;
+  GtkWidget *scale;
 
   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@@ -3596,17 +3586,15 @@ ed_make_page_general (GFlareEditor *ed,
   gtk_container_add (GTK_CONTAINER (frame), grid);
   gtk_widget_show (grid);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("Opacity:"), SCALE_WIDTH, 6,
-                              gflare->glow_opacity, 0.0, 100.0, 1.0, 10.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Opacity:"), gflare->glow_opacity, 0.0, 100.0, 1);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->glow_opacity);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
   combo = ed_mode_menu_new (&gflare->glow_mode);
   gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1,
@@ -3624,17 +3612,15 @@ ed_make_page_general (GFlareEditor *ed,
   gtk_container_add (GTK_CONTAINER (frame), grid);
   gtk_widget_show (grid);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("Opacity:"), SCALE_WIDTH, 6,
-                              gflare->rays_opacity, 0.0, 100.0, 1.0, 10.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Opacity:"), gflare->rays_opacity, 0.0, 100.0, 1);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->rays_opacity);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
   combo = ed_mode_menu_new (&gflare->rays_mode);
   gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1,
@@ -3652,17 +3638,15 @@ ed_make_page_general (GFlareEditor *ed,
   gtk_container_add (GTK_CONTAINER (frame), grid);
   gtk_widget_show (grid);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("Opacity:"), SCALE_WIDTH, 6,
-                              gflare->sflare_opacity, 0.0, 100.0, 1.0, 10.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Opacity:"), gflare->sflare_opacity, 0.0, 100.0, 1);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->sflare_opacity);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
+  gtk_widget_show (scale);
 
   combo = ed_mode_menu_new (&gflare->sflare_mode);
   gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1,
@@ -3680,13 +3664,13 @@ static void
 ed_make_page_glow (GFlareEditor *ed,
                    GtkWidget    *notebook)
 {
-  GFlare        *gflare = ed->gflare;
-  GradientMenu  *gm;
-  GtkWidget     *vbox;
-  GtkWidget     *frame;
-  GtkWidget     *grid;
-  GtkAdjustment *adj;
-  gint           row;
+  GFlare       *gflare = ed->gflare;
+  GradientMenu *gm;
+  GtkWidget    *vbox;
+  GtkWidget    *frame;
+  GtkWidget    *grid;
+  GtkWidget    *scale;
+  gint          row;
 
   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@@ -3733,41 +3717,38 @@ ed_make_page_glow (GFlareEditor *ed,
 
   row = 0;
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Size (%):"), SCALE_WIDTH, 6,
-                              gflare->glow_size, 0.0, 200.0, 1.0, 10.0, 1,
-                              FALSE, 0, G_MAXINT,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Size (%):"), gflare->glow_size, 0.0, G_MAXINT, 1);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 0.0, 200.0, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->glow_size);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Rotation:"), SCALE_WIDTH, 6,
-                              gflare->glow_rotation, -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Rotation:"), gflare->glow_rotation, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->glow_rotation);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Hue rotation:"), SCALE_WIDTH, 6,
-                              gflare->glow_hue, -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Hue rotation:"), gflare->glow_hue, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->glow_hue);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
   gtk_widget_show (grid);
 
@@ -3783,13 +3764,13 @@ static void
 ed_make_page_rays (GFlareEditor *ed,
                    GtkWidget    *notebook)
 {
-  GFlare        *gflare = ed->gflare;
-  GradientMenu  *gm;
-  GtkWidget     *vbox;
-  GtkWidget     *frame;
-  GtkWidget     *grid;
-  GtkAdjustment *adj;
-  gint           row;
+  GFlare       *gflare = ed->gflare;
+  GradientMenu *gm;
+  GtkWidget    *vbox;
+  GtkWidget    *frame;
+  GtkWidget    *grid;
+  GtkWidget    *scale;
+  gint          row;
 
   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@@ -3838,66 +3819,60 @@ ed_make_page_rays (GFlareEditor *ed,
 
   row = 0;
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Size (%):"), SCALE_WIDTH, 6,
-                              gflare->rays_size, 0.0, 200.0, 1.0, 10.0, 1,
-                              FALSE, 0, G_MAXINT,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Size (%):"), gflare->rays_size, 0.0, G_MAXINT, 1);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 0.0, 200.0, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->rays_size);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Rotation:"), SCALE_WIDTH, 6,
-                              gflare->rays_rotation,
-                              -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Rotation:"), gflare->rays_rotation, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->rays_rotation);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Hue rotation:"), SCALE_WIDTH, 6,
-                              gflare->rays_hue, -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Hue rotation:"), gflare->rays_hue, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->rays_hue);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("# of Spikes:"), SCALE_WIDTH, 6,
-                              gflare->rays_nspikes, 1, 300, 1.0, 10.0, 0,
-                              FALSE, 0, G_MAXINT,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_int_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("# of Spikes:"), gflare->rays_nspikes, 1, G_MAXINT, 0);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1.0, 300.0, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_int),
                     &gflare->rays_nspikes);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Spike thickness:"), SCALE_WIDTH, 6,
-                              gflare->rays_thickness, 1.0, 100.0, 1.0, 10.0, 1,
-                              FALSE, 0, GIMP_MAX_IMAGE_SIZE,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Spike thickness:"), gflare->rays_thickness, 1.0, GIMP_MAX_IMAGE_SIZE, 1);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1.0, 100.0, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->rays_thickness);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
   gtk_widget_show (grid);
 
@@ -3913,22 +3888,22 @@ static void
 ed_make_page_sflare (GFlareEditor *ed,
                      GtkWidget    *notebook)
 {
-  GFlare        *gflare = ed->gflare;
-  GradientMenu  *gm;
-  GtkWidget     *vbox;
-  GtkWidget     *grid;
-  GtkWidget     *frame;
-  GtkWidget     *shape_vbox;
-  GSList        *shape_group = NULL;
-  GtkWidget     *polygon_hbox;
-  GtkWidget     *seed_hbox;
-  GtkWidget     *toggle;
-  GtkWidget     *label;
-  GtkWidget     *seed;
-  GtkWidget     *entry;
-  GtkAdjustment *adj;
-  gchar          buf[256];
-  gint           row;
+  GFlare       *gflare = ed->gflare;
+  GradientMenu *gm;
+  GtkWidget    *vbox;
+  GtkWidget    *grid;
+  GtkWidget    *frame;
+  GtkWidget    *shape_vbox;
+  GSList       *shape_group = NULL;
+  GtkWidget    *polygon_hbox;
+  GtkWidget    *seed_hbox;
+  GtkWidget    *toggle;
+  GtkWidget    *label;
+  GtkWidget    *seed;
+  GtkWidget    *entry;
+  GtkWidget    *scale;
+  gchar         buf[256];
+  gint          row;
 
   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@@ -3975,42 +3950,38 @@ ed_make_page_sflare (GFlareEditor *ed,
 
   row = 0;
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Size (%):"), SCALE_WIDTH, 6,
-                              gflare->sflare_size, 0.0, 200.0, 1.0, 10.0, 1,
-                              FALSE, 0, G_MAXINT,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Size (%):"), gflare->sflare_size, 0.0, G_MAXINT, 1);
+  gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1.0, 200.0, TRUE);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->sflare_size);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Rotation:"), SCALE_WIDTH, 6,
-                              gflare->sflare_rotation,
-                              -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Rotation:"), gflare->sflare_rotation, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->sflare_rotation);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
-                              _("Hue rotation:"), SCALE_WIDTH, 6,
-                              gflare->sflare_hue, -180.0, 180.0, 1.0, 15.0, 1,
-                              TRUE, 0, 0,
-                              NULL, NULL);
-  g_signal_connect (adj, "value-changed",
-                    G_CALLBACK (gimp_double_adjustment_update),
+  scale = gimp_scale_entry_new2 (_("Hue rotation:"), gflare->sflare_hue, -180.0, 180.0, 1);
+  gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
+  g_signal_connect (scale, "value-changed",
+                    G_CALLBACK (gradient_scale_entry_update_double),
                     &gflare->sflare_hue);
-  g_signal_connect (adj, "value-changed",
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (ed_preview_update),
                     NULL);
+  gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
+  gtk_widget_show (scale);
 
   gtk_widget_show (grid);
 
@@ -5164,6 +5135,20 @@ gradient_cache_zorch (void)
     }
 }
 
+static void
+gradient_scale_entry_update_double (GimpScaleEntry *entry,
+                                    gdouble        *value)
+{
+  *value = gimp_scale_entry_get_value (entry);
+}
+
+static void
+gradient_scale_entry_update_int (GimpScaleEntry *entry,
+                                 gint           *value)
+{
+  *value = (gint) gimp_scale_entry_get_value (entry);
+}
+
 #ifdef DEBUG
 void
 gradient_report (void)
diff --git a/plug-ins/lighting/lighting-ui.c b/plug-ins/lighting/lighting-ui.c
index 18f581f222..f4be962d74 100644
--- a/plug-ins/lighting/lighting-ui.c
+++ b/plug-ins/lighting/lighting-ui.c
@@ -62,7 +62,7 @@ static void create_main_notebook      (GtkWidget       *container);
 static void toggle_update             (GtkWidget       *widget,
                                        gpointer         data);
 
-static void     distance_update       (GtkAdjustment   *adj,
+static void     distance_update       (GimpScaleEntry       *scale,
                                        gpointer         data);
 
 static gboolean  bumpmap_constrain    (GimpImage       *image,
@@ -116,10 +116,10 @@ toggle_update (GtkWidget *widget,
 
 
 static void
-distance_update (GtkAdjustment *adj,
-                 gpointer   data)
+distance_update (GimpScaleEntry *scale,
+                 gpointer        data)
 {
-  mapvals.viewpoint.z = gtk_adjustment_get_value (adj);
+  mapvals.viewpoint.z = gimp_scale_entry_get_value (scale);
 
   preview_compute ();
   gtk_widget_queue_draw (previewarea);
@@ -301,8 +301,7 @@ create_options_page (void)
   GtkWidget     *frame;
   GtkWidget     *vbox;
   GtkWidget     *toggle;
-  GtkWidget     *grid;
-  GtkAdjustment *adj;
+  GtkWidget     *scale;
 
   page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   gtk_container_set_border_width (GTK_CONTAINER (page), 12);
@@ -354,20 +353,15 @@ create_options_page (void)
   gimp_help_set_help_data (toggle,
                            _("Enable/disable high quality preview"), NULL);
 
-  grid = gtk_grid_new ();
-  gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 12);
-  gtk_widget_show (grid);
-
-  adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                              _("Distance:"), 100, 6,
-                              mapvals.viewpoint.z,
-                              0.0, 2.0, 0.01, 0.05,
-                              3, TRUE, 0.0, 0.0,
-                              "Distance of observer from surface",
-                              "plug-in-lighting");
-  g_signal_connect (adj, "value-changed",
+  scale = gimp_scale_entry_new2 (_("Distance:"), mapvals.viewpoint.z, 0.0, 2.0, 3);
+  gimp_help_set_help_data (scale,
+                           "Distance of observer from surface",
+                           "plug-in-lighting");
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (distance_update),
                     NULL);
+  gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 12);
+  gtk_widget_show (scale);
 
   gtk_widget_show (page);
 
diff --git a/plug-ins/pagecurl/pagecurl.c b/plug-ins/pagecurl/pagecurl.c
index 2f43ca7f06..742e8445ec 100644
--- a/plug-ins/pagecurl/pagecurl.c
+++ b/plug-ins/pagecurl/pagecurl.c
@@ -133,8 +133,8 @@ static GimpValueArray * pagecurl_run              (GimpProcedure        *procedu
                                                    const GimpValueArray *args,
                                                    gpointer              run_data);
 
-static void             dialog_scale_update       (GtkAdjustment    *adjustment,
-                                                   gdouble          *value);
+static void             dialog_scale_update       (GimpScaleEntry       *adjustment,
+                                                   gdouble              *value);
 
 static gboolean         dialog                    (void);
 
@@ -414,10 +414,10 @@ inside_circle (gdouble x,
 /********************************************************************/
 
 static void
-dialog_scale_update (GtkAdjustment *adjustment,
-                     gdouble       *value)
+dialog_scale_update (GimpScaleEntry *scale,
+                     gdouble        *value)
 {
-  *value = ((gdouble) gtk_adjustment_get_value (adjustment)) / 100.0;
+  *value = ((gdouble) gimp_scale_entry_get_value (scale)) / 100.0;
 }
 
 static void
@@ -454,15 +454,15 @@ dialog (void)
   /* Missing options: Color-dialogs? / own curl layer ? / transparency
      to original drawable / Warp-curl (unsupported yet) */
 
-  GtkWidget     *dialog;
-  GtkWidget     *hbox;
-  GtkWidget     *vbox;
-  GtkWidget     *grid;
-  GtkWidget     *frame;
-  GtkWidget     *button;
-  GtkWidget     *combo;
-  GtkAdjustment *adjustment;
-  gboolean       run;
+  GtkWidget *dialog;
+  GtkWidget *hbox;
+  GtkWidget *vbox;
+  GtkWidget *grid;
+  GtkWidget *frame;
+  GtkWidget *button;
+  GtkWidget *combo;
+  GtkWidget *scale;
+  gboolean   run;
 
   gimp_ui_init (PLUG_IN_BINARY);
 
@@ -662,20 +662,12 @@ dialog (void)
                               G_CALLBACK (gimp_int_combo_box_get_active),
                               &curl.colors, NULL);
 
-  grid = gtk_grid_new ();
-  gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
-  gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
-  gtk_widget_show (grid);
-
-  adjustment = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
-                                     _("_Opacity:"), 100, 0,
-                                     curl.opacity * 100.0, 0.0, 100.0,
-                                     1.0, 1.0, 0.0,
-                                     TRUE, 0, 0,
-                                     NULL, NULL);
-  g_signal_connect (adjustment, "value-changed",
+  scale = gimp_scale_entry_new2 (_("_Opacity:"), curl.opacity * 100.0, 0.0, 100.0, 0.0);
+  g_signal_connect (scale, "value-changed",
                     G_CALLBACK (dialog_scale_update),
                     &curl.opacity);
+  gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 6);
+  gtk_widget_show (scale);
 
   gtk_widget_show (dialog);
 


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]