From d95f417719cea4f704fa612d8e3173ff3194730b Mon Sep 17 00:00:00 2001 From: Jehan Date: Thu, 5 Nov 2020 17:37:15 +0100 Subject: [PATCH] =?UTF-8?q?app,=20libgimpwidgets,=20modules,=20plug-ins:?= =?UTF-8?q?=20code=20changes=20after=20GimpScaleEntry=E2=80=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit … reclassing as GimpLabelSpin subclass. --- app/dialogs/palette-import-dialog.c | 14 ++-- app/widgets/gimpstrokeeditor.c | 2 +- libgimpwidgets/gimpcolorscales.c | 10 +-- libgimpwidgets/gimppropwidgets.c | 2 +- modules/color-selector-cmyk.c | 12 +-- plug-ins/common/align-layers.c | 8 +- plug-ins/common/blinds.c | 10 +-- plug-ins/common/cml-explorer.c | 30 ++++---- plug-ins/common/compose.c | 10 +-- plug-ins/common/contrast-retinex.c | 20 ++--- plug-ins/common/depth-merge.c | 16 ++-- plug-ins/common/destripe.c | 8 +- plug-ins/common/file-gbr.c | 2 +- plug-ins/common/file-heif.c | 2 +- plug-ins/common/file-png.c | 2 +- plug-ins/common/file-raw-data.c | 12 +-- plug-ins/common/film.c | 32 ++++---- plug-ins/common/jigsaw.c | 24 +++--- plug-ins/common/nl-filter.c | 8 +- plug-ins/common/sparkle.c | 10 +-- plug-ins/common/sphere-designer.c | 76 +++++++++---------- plug-ins/common/tile-small.c | 8 +- plug-ins/common/van-gogh-lic.c | 12 +-- plug-ins/common/wavelet-decompose.c | 8 +- plug-ins/file-jpeg/jpeg-save.c | 18 ++--- plug-ins/flame/flame.c | 42 +++++----- .../fractal-explorer-dialogs.c | 38 +++++----- plug-ins/gfig/gfig-dialog.c | 28 +++---- plug-ins/gimpressionist/brush.c | 18 ++--- plug-ins/gimpressionist/color.c | 4 +- plug-ins/gimpressionist/general.c | 32 ++++---- plug-ins/gimpressionist/gimpressionist.h | 8 +- plug-ins/gimpressionist/orientation.c | 12 +-- plug-ins/gimpressionist/orientmap.c | 28 +++---- plug-ins/gimpressionist/paper.c | 4 +- plug-ins/gimpressionist/placement.c | 4 +- plug-ins/gimpressionist/size.c | 12 +-- plug-ins/gimpressionist/sizemap.c | 16 ++-- plug-ins/gimpressionist/utils.c | 12 +-- plug-ins/gradient-flare/gradient-flare.c | 36 ++++----- plug-ins/lighting/lighting-ui.c | 8 +- plug-ins/map-object/map-object-ui.c | 44 +++++------ plug-ins/pagecurl/pagecurl.c | 8 +- plug-ins/script-fu/script-fu-interface.c | 8 +- .../selection-to-path-dialog.c | 14 ++-- 45 files changed, 366 insertions(+), 366 deletions(-) diff --git a/app/dialogs/palette-import-dialog.c b/app/dialogs/palette-import-dialog.c index 135bfcf32e..b3a054e98d 100644 --- a/app/dialogs/palette-import-dialog.c +++ b/app/dialogs/palette-import-dialog.c @@ -116,7 +116,7 @@ static void palette_import_image_callback (GtkWidget *widget, ImportDialog *private); static void palette_import_file_callback (GtkWidget *widget, ImportDialog *private); -static void palette_import_columns_changed (GimpScaleEntry *columns, +static void palette_import_columns_changed (GimpLabelSpin *columns, ImportDialog *private); static void palette_import_image_add (GimpContainer *container, GimpImage *image, @@ -709,12 +709,12 @@ palette_import_file_callback (GtkWidget *widget, } static void -palette_import_columns_changed (GimpScaleEntry *columns, - ImportDialog *private) +palette_import_columns_changed (GimpLabelSpin *columns, + ImportDialog *private) { if (private->palette) gimp_palette_set_columns (private->palette, - ROUND (gimp_scale_entry_get_value (columns))); + ROUND (gimp_label_spin_get_value (columns))); } @@ -761,9 +761,9 @@ palette_import_make_palette (ImportDialog *private) if (! palette_name || ! strlen (palette_name)) palette_name = _("Untitled"); - n_colors = ROUND (gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (private->num_colors))); - n_columns = ROUND (gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (private->columns))); - threshold = ROUND (gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (private->threshold))); + n_colors = ROUND (gimp_label_spin_get_value (GIMP_LABEL_SPIN (private->num_colors))); + n_columns = ROUND (gimp_label_spin_get_value (GIMP_LABEL_SPIN (private->columns))); + threshold = ROUND (gimp_label_spin_get_value (GIMP_LABEL_SPIN (private->threshold))); switch (private->import_type) { diff --git a/app/widgets/gimpstrokeeditor.c b/app/widgets/gimpstrokeeditor.c index 646310a928..b37b6b692a 100644 --- a/app/widgets/gimpstrokeeditor.c +++ b/app/widgets/gimpstrokeeditor.c @@ -167,7 +167,7 @@ gimp_stroke_editor_constructed (GObject *object) scale = gimp_prop_scale_entry_new (G_OBJECT (options), "miter-limit", NULL, 1, FALSE, 0.0, 0.0); - gtk_widget_hide (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_widget_hide (gimp_labeled_get_label (GIMP_LABELED (scale))); gimp_grid_attach_aligned (GTK_GRID (grid), 0, row++, _("_Miter limit:"), 0.0, 0.5, scale, 2); diff --git a/libgimpwidgets/gimpcolorscales.c b/libgimpwidgets/gimpcolorscales.c index b03d67c8b1..0e06b5eea6 100644 --- a/libgimpwidgets/gimpcolorscales.c +++ b/libgimpwidgets/gimpcolorscales.c @@ -314,8 +314,8 @@ create_group (GimpColorScales *scales, scale_defs[i].spin_max_value, 1); gtk_grid_attach (GTK_GRID (grid), scales->scales[i], 1, row, 3, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scales->scales[i]), - 1.0, scale_defs[i].scale_inc); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scales->scales[i]), + 1.0, scale_defs[i].scale_inc); gimp_help_set_help_data (scales->scales[i], gettext (enum_desc->value_help), NULL); @@ -334,7 +334,7 @@ create_group (GimpColorScales *scales, gtk_size_group_add_widget (size_group1, scales->scales[i]); gtk_size_group_add_widget (size_group2, - gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scales->scales[i]))); + gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scales->scales[i]))); g_signal_connect (scales->scales[i], "value-changed", G_CALLBACK (gimp_color_scales_scale_changed), @@ -711,7 +711,7 @@ gimp_color_scales_update_scales (GimpColorScales *scales, gimp_color_scales_scale_changed, scales); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (scales->scales[i]), values[i]); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (scales->scales[i]), values[i]); g_signal_handlers_unblock_by_func (scales->scales[i], gimp_color_scales_scale_changed, @@ -757,7 +757,7 @@ gimp_color_scales_scale_changed (GtkWidget *scale, GimpColorScales *scales) { GimpColorSelector *selector = GIMP_COLOR_SELECTOR (scales); - gdouble value = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (scale)); + gdouble value = gimp_label_spin_get_value (GIMP_LABEL_SPIN (scale)); GimpLCH lch; gint i; diff --git a/libgimpwidgets/gimppropwidgets.c b/libgimpwidgets/gimppropwidgets.c index a9d9104cac..4986f9445c 100644 --- a/libgimpwidgets/gimppropwidgets.c +++ b/libgimpwidgets/gimppropwidgets.c @@ -1664,7 +1664,7 @@ gimp_prop_opacity_entry_new (GObject *config, if (widget) { - gimp_prop_widget_set_factor (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (widget)), + gimp_prop_widget_set_factor (gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (widget)), NULL, 100.0, 0.0, 0.0, 1); } diff --git a/modules/color-selector-cmyk.c b/modules/color-selector-cmyk.c index c041313345..189c91ce49 100644 --- a/modules/color-selector-cmyk.c +++ b/modules/color-selector-cmyk.c @@ -71,7 +71,7 @@ static void colorsel_cmyk_set_color (GimpColorSelector *selector, static void colorsel_cmyk_set_config (GimpColorSelector *selector, GimpColorConfig *config); -static void colorsel_cmyk_scale_update (GimpScaleEntry *scale, +static void colorsel_cmyk_scale_update (GimpLabelSpin *scale, ColorselCmyk *module); static void colorsel_cmyk_config_changed (ColorselCmyk *module); @@ -248,7 +248,7 @@ colorsel_cmyk_set_color (GimpColorSelector *selector, colorsel_cmyk_scale_update, module); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (module->scales[i]), values[i]); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (module->scales[i]), values[i]); g_signal_handlers_unblock_by_func (module->scales[i], colorsel_cmyk_scale_update, @@ -281,18 +281,18 @@ colorsel_cmyk_set_config (GimpColorSelector *selector, } static void -colorsel_cmyk_scale_update (GimpScaleEntry *scale, - ColorselCmyk *module) +colorsel_cmyk_scale_update (GimpLabelSpin *scale, + ColorselCmyk *module) { GimpColorSelector *selector = GIMP_COLOR_SELECTOR (module); gint i; gdouble value; for (i = 0; i < 4; i++) - if (GIMP_SCALE_ENTRY (module->scales[i]) == scale) + if (GIMP_LABEL_SPIN (module->scales[i]) == scale) break; - value = gimp_scale_entry_get_value (scale) / 100.0; + value = gimp_label_spin_get_value (scale) / 100.0; switch (i) { diff --git a/plug-ins/common/align-layers.c b/plug-ins/common/align-layers.c index c288bb2791..b5dc126b0f 100644 --- a/plug-ins/common/align-layers.c +++ b/plug-ins/common/align-layers.c @@ -123,7 +123,7 @@ 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, +static void align_layers_scale_entry_update_int (GimpLabelSpin *entry, gint *value); @@ -780,8 +780,8 @@ align_layers_dialog (void) } static void -align_layers_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +align_layers_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/blinds.c b/plug-ins/common/blinds.c index 5115b14080..8dfbcfb772 100644 --- a/plug-ins/common/blinds.c +++ b/plug-ins/common/blinds.c @@ -87,7 +87,7 @@ static GimpValueArray * blinds_run (GimpProcedure *procedure gpointer run_data); static gboolean blinds_dialog (GimpDrawable *drawable); -static void blinds_scale_entry_update_int (GimpScaleEntry *entry, +static void blinds_scale_entry_update_int (GimpLabelSpin *entry, gint *value); static void dialog_update_preview (GimpDrawable *drawable, @@ -356,7 +356,7 @@ blinds_dialog (GimpDrawable *drawable) gtk_widget_show (grid); scale = gimp_scale_entry_new (_("_Displacement:"), bvals.angledsp, 1, 90, 0); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (blinds_scale_entry_update_int), &bvals.angledsp); @@ -386,10 +386,10 @@ blinds_dialog (GimpDrawable *drawable) } static void -blinds_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +blinds_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } static void diff --git a/plug-ins/common/cml-explorer.c b/plug-ins/common/cml-explorer.c index 39f60ddd92..a303588cfe 100644 --- a/plug-ins/common/cml-explorer.c +++ b/plug-ins/common/cml-explorer.c @@ -1483,14 +1483,14 @@ CML_explorer_dialog (void) g_object_unref (group); scale = gimp_scale_entry_new (_("Zoom scale:"), VALS.scale, 1, 10, 0); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); CML_explorer_int_entry_init (&widget_pointers[3][1], scale, &VALS.scale); gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1); gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Start offset:"), VALS.start_offset, 0, 100, 0); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); CML_explorer_int_entry_init (&widget_pointers[3][2], scale, &VALS.start_offset); gtk_grid_attach (GTK_GRID (grid), scale, 0, 2, 3, 1); @@ -1508,7 +1508,7 @@ CML_explorer_dialog (void) gtk_widget_show (grid); scale = gimp_scale_entry_new (_("Seed:"), VALS.seed, 0, (guint32) -1, 0); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); CML_explorer_int_entry_init (&widget_pointers[3][3], scale, &VALS.seed); gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1); @@ -1772,7 +1772,7 @@ CML_dialog_channel_panel_new (CML_PARAM *param, index++; scale = gimp_scale_entry_new (_("P(ower factor):"), param->power, 0.0, 10.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 1.0); CML_explorer_double_entry_init (&widget_pointers[channel_id][index], scale, ¶m->power); gtk_grid_attach (GTK_GRID (grid), scale, 0, index, 3, 1); @@ -1780,7 +1780,7 @@ CML_dialog_channel_panel_new (CML_PARAM *param, index++; scale = gimp_scale_entry_new (_("Parameter k:"), param->parameter_k, 0.0, 10.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 1.0); CML_explorer_double_entry_init (&widget_pointers[channel_id][index], scale, ¶m->parameter_k); gtk_grid_attach (GTK_GRID (grid), scale, 0, index, 3, 1); @@ -2534,10 +2534,10 @@ CML_explorer_toggle_entry_init (WidgetEntry *widget_entry, /* int adjustment functions */ static void -CML_explorer_int_adjustment_update (GimpScaleEntry *scale, - gint *value) +CML_explorer_int_adjustment_update (GimpLabelSpin *scale, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (scale); + *value = (gint) gimp_label_spin_get_value (scale); preview_update (); } @@ -2545,9 +2545,9 @@ CML_explorer_int_adjustment_update (GimpScaleEntry *scale, static void CML_explorer_int_entry_change_value (WidgetEntry *widget_entry) { - GimpScaleEntry *scale = GIMP_SCALE_ENTRY (widget_entry->widget); + GimpLabelSpin *scale = GIMP_LABEL_SPIN (widget_entry->widget); - gimp_scale_entry_set_value (scale, *(gint *) (widget_entry->value)); + gimp_label_spin_set_value (scale, *(gint *) (widget_entry->value)); } static void @@ -2567,10 +2567,10 @@ CML_explorer_int_entry_init (WidgetEntry *widget_entry, /* double adjustment functions */ static void -CML_explorer_double_adjustment_update (GimpScaleEntry *scale, - gdouble *value) +CML_explorer_double_adjustment_update (GimpLabelSpin *scale, + gdouble *value) { - *value = gimp_scale_entry_get_value (scale); + *value = gimp_label_spin_get_value (scale); preview_update (); } @@ -2578,9 +2578,9 @@ CML_explorer_double_adjustment_update (GimpScaleEntry *scale, static void CML_explorer_double_entry_change_value (WidgetEntry *widget_entry) { - GimpScaleEntry *scale = GIMP_SCALE_ENTRY (widget_entry->widget); + GimpLabelSpin *scale = GIMP_LABEL_SPIN (widget_entry->widget); - gimp_scale_entry_set_value (scale, *(gdouble *) (widget_entry->value)); + gimp_label_spin_set_value (scale, *(gdouble *) (widget_entry->value)); } static void diff --git a/plug-ins/common/compose.c b/plug-ins/common/compose.c index 228c20a143..356d197833 100644 --- a/plug-ins/common/compose.c +++ b/plug-ins/common/compose.c @@ -179,7 +179,7 @@ static gboolean check_gray (GimpImage *image, static void combo_callback (GimpIntComboBox *cbox, gpointer data); -static void scale_callback (GimpScaleEntry *scale, +static void scale_callback (GimpLabelSpin *scale, ComposeInput *input); static void check_response (GtkWidget *dialog, @@ -1406,7 +1406,7 @@ combo_callback (GimpIntComboBox *widget, composeint.selected[n].is_object = FALSE; composeint.selected[n].comp.val = - gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (composeint.scales[n])); + gimp_label_spin_get_value (GIMP_LABEL_SPIN (composeint.scales[n])); } else { @@ -1418,10 +1418,10 @@ combo_callback (GimpIntComboBox *widget, } static void -scale_callback (GimpScaleEntry *scale, - ComposeInput *input) +scale_callback (GimpLabelSpin *scale, + ComposeInput *input) { - input->comp.val = gimp_scale_entry_get_value (scale); + input->comp.val = gimp_label_spin_get_value (scale); } static void diff --git a/plug-ins/common/contrast-retinex.c b/plug-ins/common/contrast-retinex.c index 6c9820a5e8..d66bd84b3e 100644 --- a/plug-ins/common/contrast-retinex.c +++ b/plug-ins/common/contrast-retinex.c @@ -124,10 +124,10 @@ static void gausssmooth (gfloat *in, gint rowtride, gauss3_coefs *c); -static void contrast_retinex_scale_entry_update_int (GimpScaleEntry *entry, - gint *value); -static void contrast_retinex_scale_entry_update_float (GimpScaleEntry *entry, - gfloat *value); +static void contrast_retinex_scale_entry_update_int (GimpLabelSpin *entry, + gint *value); +static void contrast_retinex_scale_entry_update_float (GimpLabelSpin *entry, + gfloat *value); /* * MSRCR = MultiScale Retinex with Color Restoration @@ -877,15 +877,15 @@ compute_mean_var (gfloat *src, gfloat *mean, gfloat *var, gint size, gint bytes) } static void -contrast_retinex_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +contrast_retinex_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } static void -contrast_retinex_scale_entry_update_float (GimpScaleEntry *entry, - gfloat *value) +contrast_retinex_scale_entry_update_float (GimpLabelSpin *entry, + gfloat *value) { - *value = (gfloat) gimp_scale_entry_get_value (entry); + *value = (gfloat) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/depth-merge.c b/plug-ins/common/depth-merge.c index ac66af7545..62394657de 100644 --- a/plug-ins/common/depth-merge.c +++ b/plug-ins/common/depth-merge.c @@ -157,7 +157,7 @@ static void dialogDepthMap1ChangedCallback (GtkWidget *widget, static void dialogDepthMap2ChangedCallback (GtkWidget *widget, DepthMerge *dm); -static void dialogValueScaleUpdateCallback (GimpScaleEntry *scale, +static void dialogValueScaleUpdateCallback (GimpLabelSpin *scale, gfloat *value); static void util_fillReducedBuffer (guchar *dest, @@ -811,7 +811,7 @@ DepthMerge_dialog (DepthMerge *dm) /* Numeric parameters */ scale = gimp_scale_entry_new (_("O_verlap:"), dm->params.overlap, 0, 2, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (dialogValueScaleUpdateCallback), &(dm->params.overlap)); @@ -820,7 +820,7 @@ DepthMerge_dialog (DepthMerge *dm) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("O_ffset:"), dm->params.offset, -1, 1, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (dialogValueScaleUpdateCallback), &(dm->params.offset)); @@ -829,7 +829,7 @@ DepthMerge_dialog (DepthMerge *dm) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Sc_ale 1:"), dm->params.scale1, -1, 1, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (dialogValueScaleUpdateCallback), &(dm->params.scale1)); @@ -838,7 +838,7 @@ DepthMerge_dialog (DepthMerge *dm) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Sca_le 2:"), dm->params.scale2, -1, 1, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (dialogValueScaleUpdateCallback), &(dm->params.scale2)); @@ -1048,12 +1048,12 @@ dialogDepthMap2ChangedCallback (GtkWidget *widget, } static void -dialogValueScaleUpdateCallback (GimpScaleEntry *scale, - gfloat *value) +dialogValueScaleUpdateCallback (GimpLabelSpin *scale, + gfloat *value) { DepthMerge *dm = g_object_get_data (G_OBJECT (scale), "dm"); - *value = (gfloat) gimp_scale_entry_get_value (scale); + *value = (gfloat) gimp_label_spin_get_value (scale); DepthMerge_updatePreview (dm); } diff --git a/plug-ins/common/destripe.c b/plug-ins/common/destripe.c index 11a97fb8c9..c5c369392a 100644 --- a/plug-ins/common/destripe.c +++ b/plug-ins/common/destripe.c @@ -82,7 +82,7 @@ static void destripe_preview (GimpDrawable *drawabl GimpPreview *preview); static gboolean destripe_dialog (GimpDrawable *drawable); -static void destripe_scale_entry_update_int (GimpScaleEntry *entry, +static void destripe_scale_entry_update_int (GimpLabelSpin *entry, gint *value); @@ -515,8 +515,8 @@ destripe_dialog (GimpDrawable *drawable) } static void -destripe_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +destripe_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/file-gbr.c b/plug-ins/common/file-gbr.c index c5bdc3e911..95545d89b2 100644 --- a/plug-ins/common/file-gbr.c +++ b/plug-ins/common/file-gbr.c @@ -319,7 +319,7 @@ save_dialog (GimpProcedure *procedure, scale = gimp_prop_scale_entry_new (config, "spacing", NULL, 0, FALSE, 0, 0); - gtk_widget_hide (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_widget_hide (gimp_labeled_get_label (GIMP_LABELED (scale))); gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1, _("_Spacing:"), 0.0, 0.5, scale, 4); diff --git a/plug-ins/common/file-heif.c b/plug-ins/common/file-heif.c index e171c8e0ce..c651d33fbc 100644 --- a/plug-ins/common/file-heif.c +++ b/plug-ins/common/file-heif.c @@ -2522,7 +2522,7 @@ save_dialog (GimpProcedure *procedure, scale = gimp_prop_scale_entry_new (config, "quality", NULL, 0, FALSE, 0, 0); - gtk_widget_hide (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_widget_hide (gimp_labeled_get_label (GIMP_LABELED (scale))); gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1, _("_Quality"), 0.0, 0.5, scale, 2); diff --git a/plug-ins/common/file-png.c b/plug-ins/common/file-png.c index 43104a0545..6e433e27da 100644 --- a/plug-ins/common/file-png.c +++ b/plug-ins/common/file-png.c @@ -2326,7 +2326,7 @@ save_dialog (GimpImage *image, /* Compression level scale */ scale = gimp_prop_scale_entry_new (config, "compression", NULL, 0, FALSE, 0, 0); - gtk_widget_hide (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_widget_hide (gimp_labeled_get_label (GIMP_LABELED (scale))); gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1, _("Co_mpression level:"), 0.0, 0.5, scale, 2); diff --git a/plug-ins/common/file-raw-data.c b/plug-ins/common/file-raw-data.c index d9c60b7446..bcba851a33 100644 --- a/plug-ins/common/file-raw-data.c +++ b/plug-ins/common/file-raw-data.c @@ -199,7 +199,7 @@ static gboolean save_dialog (GimpImage *image, static void palette_callback (GtkFileChooser *button, GimpPreviewArea *preview); -static void file_raw_scale_entry_update_int (GimpScaleEntry *entry, +static void file_raw_scale_entry_update_int (GimpLabelSpin *entry, gint *value); G_DEFINE_TYPE (Raw, raw, GIMP_TYPE_PLUG_IN) @@ -1911,7 +1911,7 @@ load_dialog (GFile *file, preview); scale = gimp_scale_entry_new (_("O_ffset:"), runtime->file_offset, 0, file_size, 0); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1, 1000); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1, 1000); g_signal_connect (scale, "value-changed", G_CALLBACK (file_raw_scale_entry_update_int), @@ -1981,7 +1981,7 @@ load_dialog (GFile *file, preview); scale = gimp_scale_entry_new (_("Off_set:"), runtime->palette_offset, 0, 1 << 24, 0); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1, 768); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1, 768); g_signal_connect (scale, "value-changed", G_CALLBACK (file_raw_scale_entry_update_int), @@ -2079,8 +2079,8 @@ palette_callback (GtkFileChooser *button, } static void -file_raw_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +file_raw_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/film.c b/plug-ins/common/film.c index 6eb5458145..ae8f2c5180 100644 --- a/plug-ins/common/film.c +++ b/plug-ins/common/film.c @@ -145,7 +145,7 @@ static void film_font_select_callback (GimpFontSelectButton *button, gboolean closing, gpointer data); -static void film_scale_entry_update_double (GimpScaleEntry *entry, +static void film_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); G_DEFINE_TYPE (Film, film, GIMP_TYPE_PLUG_IN) @@ -1211,7 +1211,7 @@ create_advanced_tab (GtkWidget *notebook) filmint.scales[0] = scale = gimp_scale_entry_new (_("Image _height:"), filmvals.picture_height, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.picture_height); @@ -1220,19 +1220,19 @@ create_advanced_tab (GtkWidget *notebook) filmint.scales[1] = scale = gimp_scale_entry_new (_("Image spac_ing:"), filmvals.picture_space, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.picture_space); 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_labeled_get_label (GIMP_LABELED (scale)), 6); gtk_widget_set_margin_bottom (gimp_scale_entry_get_range (GIMP_SCALE_ENTRY (scale)), 6); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)), 6); + gtk_widget_set_margin_bottom (gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)), 6); gtk_widget_show (scale); filmint.scales[2] = scale = gimp_scale_entry_new (_("_Hole offset:"), filmvals.hole_offset, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.hole_offset); @@ -1241,7 +1241,7 @@ create_advanced_tab (GtkWidget *notebook) filmint.scales[3] = scale = gimp_scale_entry_new (_("Ho_le width:"), filmvals.hole_width, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.hole_width); @@ -1250,7 +1250,7 @@ create_advanced_tab (GtkWidget *notebook) filmint.scales[4] = scale = gimp_scale_entry_new (_("Hol_e height:"), filmvals.hole_height, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.hole_height); @@ -1259,19 +1259,19 @@ create_advanced_tab (GtkWidget *notebook) filmint.scales[5] = scale = gimp_scale_entry_new (_("Hole sp_acing:"), filmvals.hole_space, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.hole_space); 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_labeled_get_label (GIMP_LABELED (scale)), 6); gtk_widget_set_margin_bottom (gimp_scale_entry_get_range (GIMP_SCALE_ENTRY (scale)), 6); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)), 6); + gtk_widget_set_margin_bottom (gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)), 6); gtk_widget_show (scale); filmint.scales[6] = scale = gimp_scale_entry_new (_("_Number height:"), filmvals.number_height, 0.0, 1.0, 3); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.001, 0.01); g_signal_connect (scale, "value-changed", G_CALLBACK (film_scale_entry_update_double), &filmvals.number_height); @@ -1375,8 +1375,8 @@ film_reset_callback (GtkWidget *widget, gint i; for (i = 0; i < G_N_ELEMENTS (advanced_defaults) ; i++) - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (filmint.scales[i]), - advanced_defaults[i]); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (filmint.scales[i]), + advanced_defaults[i]); } static void @@ -1391,8 +1391,8 @@ film_font_select_callback (GimpFontSelectButton *button, } static void -film_scale_entry_update_double (GimpScaleEntry *entry, +film_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/jigsaw.c b/plug-ins/common/jigsaw.c index 3d19a9f3db..f221e04140 100644 --- a/plug-ins/common/jigsaw.c +++ b/plug-ins/common/jigsaw.c @@ -220,9 +220,9 @@ static void jigsaw_preview (GimpDrawable *drawable, GimpPreview *preview); static gboolean jigsaw_dialog (GimpDrawable *drawable); -static void jigsaw_scale_entry_update_double (GimpScaleEntry *entry, +static void jigsaw_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); -static void jigsaw_scale_entry_update_int (GimpScaleEntry *entry, +static void jigsaw_scale_entry_update_int (GimpLabelSpin *entry, gint *value); static void draw_jigsaw (guchar *buffer, @@ -2513,7 +2513,7 @@ jigsaw_dialog (GimpDrawable *drawable) gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1); gtk_widget_show (scale); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); g_object_unref (group); g_signal_connect (scale, "value-changed", @@ -2529,7 +2529,7 @@ jigsaw_dialog (GimpDrawable *drawable) 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))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); g_signal_connect (scale, "value-changed", G_CALLBACK (jigsaw_scale_entry_update_int), @@ -2555,7 +2555,7 @@ jigsaw_dialog (GimpDrawable *drawable) gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1); gtk_widget_show (scale); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); g_signal_connect (scale, "value-changed", G_CALLBACK (jigsaw_scale_entry_update_int), @@ -2570,7 +2570,7 @@ jigsaw_dialog (GimpDrawable *drawable) 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))); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); g_signal_connect (scale, "value-changed", G_CALLBACK (jigsaw_scale_entry_update_double), @@ -2615,15 +2615,15 @@ jigsaw_dialog (GimpDrawable *drawable) } static void -jigsaw_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +jigsaw_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } static void -jigsaw_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +jigsaw_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/nl-filter.c b/plug-ins/common/nl-filter.c index 3b9252d000..dcbc056259 100644 --- a/plug-ins/common/nl-filter.c +++ b/plug-ins/common/nl-filter.c @@ -107,7 +107,7 @@ static void nlfiltRow (guchar *srclast, gint bpp, gint filtno); -static void nlfilter_scale_entry_update_double (GimpScaleEntry *entry, +static void nlfilter_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); @@ -1187,8 +1187,8 @@ nlfilter_dialog (GimpDrawable *drawable) } static void -nlfilter_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +nlfilter_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/sparkle.c b/plug-ins/common/sparkle.c index 083311d414..424a23e5fb 100644 --- a/plug-ins/common/sparkle.c +++ b/plug-ins/common/sparkle.c @@ -99,7 +99,7 @@ static GimpValueArray * sparkle_run (GimpProcedure *procedur gpointer run_data); static gboolean sparkle_dialog (GimpDrawable *drawable); -static void sparkle_scale_entry_update_double (GimpScaleEntry *entry, +static void sparkle_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); @@ -478,7 +478,7 @@ sparkle_dialog (GimpDrawable *drawable) scale = gimp_scale_entry_new (_("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); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (sparkle_scale_entry_update_double), &svals.spike_angle); @@ -623,10 +623,10 @@ sparkle_dialog (GimpDrawable *drawable) } static void -sparkle_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +sparkle_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/sphere-designer.c b/plug-ins/common/sphere-designer.c index a2b715b267..278eef3cee 100644 --- a/plug-ins/common/sphere-designer.c +++ b/plug-ins/common/sphere-designer.c @@ -1899,24 +1899,24 @@ setvals (texture *t) return; noupdate = TRUE; - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (amountscale), t->amount); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (amountscale), t->amount); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (scalescale), t->oscale); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (scalescale), t->oscale); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (scalexscale), t->scale.x); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (scaleyscale), t->scale.y); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (scalezscale), t->scale.z); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (scalexscale), t->scale.x); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (scaleyscale), t->scale.y); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (scalezscale), t->scale.z); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (rotxscale), t->rotate.x); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (rotyscale), t->rotate.y); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (rotzscale), t->rotate.z); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (rotxscale), t->rotate.x); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (rotyscale), t->rotate.y); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (rotzscale), t->rotate.z); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (posxscale), t->translate.x); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (posyscale), t->translate.y); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (poszscale), t->translate.z); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (posxscale), t->translate.x); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (posyscale), t->translate.y); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (poszscale), t->translate.z); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (turbulencescale), t->turbulence.x); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (expscale), t->exp); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (turbulencescale), t->turbulence.x); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (expscale), t->exp); drawcolor1 (NULL); drawcolor2 (NULL); @@ -2444,25 +2444,25 @@ getscales (GtkWidget *widget, if (!t) return; - t->amount = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (amountscale)); - t->exp = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (expscale)); + t->amount = gimp_label_spin_get_value (GIMP_LABEL_SPIN (amountscale)); + t->exp = gimp_label_spin_get_value (GIMP_LABEL_SPIN (expscale)); - f = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (turbulencescale)); + f = gimp_label_spin_get_value (GIMP_LABEL_SPIN (turbulencescale)); vset (&t->turbulence, f, f, f); - t->oscale = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (scalescale)); + t->oscale = gimp_label_spin_get_value (GIMP_LABEL_SPIN (scalescale)); - t->scale.x = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (scalexscale)); - t->scale.y = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (scaleyscale)); - t->scale.z = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (scalezscale)); + t->scale.x = gimp_label_spin_get_value (GIMP_LABEL_SPIN (scalexscale)); + t->scale.y = gimp_label_spin_get_value (GIMP_LABEL_SPIN (scaleyscale)); + t->scale.z = gimp_label_spin_get_value (GIMP_LABEL_SPIN (scalezscale)); - t->rotate.x = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (rotxscale)); - t->rotate.y = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (rotyscale)); - t->rotate.z = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (rotzscale)); + t->rotate.x = gimp_label_spin_get_value (GIMP_LABEL_SPIN (rotxscale)); + t->rotate.y = gimp_label_spin_get_value (GIMP_LABEL_SPIN (rotyscale)); + t->rotate.z = gimp_label_spin_get_value (GIMP_LABEL_SPIN (rotzscale)); - t->translate.x = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (posxscale)); - t->translate.y = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (posyscale)); - t->translate.z = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (poszscale)); + t->translate.x = gimp_label_spin_get_value (GIMP_LABEL_SPIN (posxscale)); + t->translate.y = gimp_label_spin_get_value (GIMP_LABEL_SPIN (posyscale)); + t->translate.z = gimp_label_spin_get_value (GIMP_LABEL_SPIN (poszscale)); restartrender (); } @@ -2826,7 +2826,7 @@ makewindow (void) NULL); scalescale = gimp_scale_entry_new (_("Scale:"), 1.0, 0.0, 10.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scalescale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scalescale), 0.1, 1.0); g_signal_connect (scalescale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2834,7 +2834,7 @@ makewindow (void) gtk_widget_show (scalescale); turbulencescale = gimp_scale_entry_new (_("Turbulence:"), 1.0, 0.0, 10.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (turbulencescale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (turbulencescale), 0.1, 1.0); g_signal_connect (turbulencescale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2870,7 +2870,7 @@ makewindow (void) gtk_widget_show (grid); scalexscale = gimp_scale_entry_new (_("Scale X:"), 1.0, 0.0, 10.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scalexscale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scalexscale), 0.1, 1.0); g_signal_connect (scalexscale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2878,7 +2878,7 @@ makewindow (void) gtk_widget_show (scalexscale); scaleyscale = gimp_scale_entry_new (_("Scale Y:"), 1.0, 0.0, 10.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scaleyscale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scaleyscale), 0.1, 1.0); g_signal_connect (scaleyscale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2886,10 +2886,10 @@ makewindow (void) gtk_widget_show (scaleyscale); scalezscale = gimp_scale_entry_new (_("Scale Z:"), 1.0, 0.0, 10.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scalezscale), 0.1, 1.0); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scalezscale)), 6); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scalezscale), 0.1, 1.0); + gtk_widget_set_margin_bottom (gimp_labeled_get_label (GIMP_LABELED (scalezscale)), 6); gtk_widget_set_margin_bottom (gimp_scale_entry_get_range (GIMP_SCALE_ENTRY (scalezscale)), 6); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scalezscale)), 6); + gtk_widget_set_margin_bottom (gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scalezscale)), 6); g_signal_connect (scalezscale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2911,9 +2911,9 @@ makewindow (void) gtk_widget_show (rotyscale); rotzscale = gimp_scale_entry_new (_("Rotate Z:"), 0.0, 0.0, 360.0, 1); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (rotzscale)), 6); + gtk_widget_set_margin_bottom (gimp_labeled_get_label (GIMP_LABELED (rotzscale)), 6); gtk_widget_set_margin_bottom (gimp_scale_entry_get_range (GIMP_SCALE_ENTRY (rotzscale)), 6); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (rotzscale)), 6); + gtk_widget_set_margin_bottom (gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (rotzscale)), 6); g_signal_connect (rotzscale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2921,7 +2921,7 @@ makewindow (void) gtk_widget_show (rotzscale); posxscale = gimp_scale_entry_new (_("Position X:"), 0.0, -20.0, 20.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (posxscale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (posxscale), 0.1, 1.0); g_signal_connect (posxscale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2929,7 +2929,7 @@ makewindow (void) gtk_widget_show (posxscale); posyscale = gimp_scale_entry_new (_("Position Y:"), 0.0, -20.0, 20.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (posyscale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (posyscale), 0.1, 1.0); g_signal_connect (posyscale, "value-changed", G_CALLBACK (getscales), NULL); @@ -2937,7 +2937,7 @@ makewindow (void) gtk_widget_show (posyscale); poszscale = gimp_scale_entry_new (_("Position Z:"), 0.0, -20.0, 20.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (poszscale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (poszscale), 0.1, 1.0); g_signal_connect (poszscale, "value-changed", G_CALLBACK (getscales), NULL); diff --git a/plug-ins/common/tile-small.c b/plug-ins/common/tile-small.c index df0dc44794..4939756b78 100644 --- a/plug-ins/common/tile-small.c +++ b/plug-ins/common/tile-small.c @@ -115,7 +115,7 @@ static GimpValueArray * tile_run (GimpProcedure *procedure, static gboolean tileit_dialog (GimpDrawable *drawable); -static void tileit_scale_update (GimpScaleEntry *entry, +static void tileit_scale_update (GimpLabelSpin *entry, gint *value); static void tileit_exp_update (GtkWidget *widget, @@ -858,10 +858,10 @@ tileit_radio_update (GtkWidget *widget, static void -tileit_scale_update (GimpScaleEntry *scale, - gint *value) +tileit_scale_update (GimpLabelSpin *scale, + gint *value) { - *value = RINT (gimp_scale_entry_get_value (scale)); + *value = RINT (gimp_label_spin_get_value (scale)); dialog_update_preview (); } diff --git a/plug-ins/common/van-gogh-lic.c b/plug-ins/common/van-gogh-lic.c index ae2184f758..d6d108e54c 100644 --- a/plug-ins/common/van-gogh-lic.c +++ b/plug-ins/common/van-gogh-lic.c @@ -91,7 +91,7 @@ static GimpValueArray * lic_run (GimpProcedure *procedure, GimpDrawable *drawable, const GimpValueArray *args, gpointer run_data); -static void lic_scale_entry_update (GimpScaleEntry *entry, +static void lic_scale_entry_update (GimpLabelSpin *entry, gdouble *value); @@ -786,7 +786,7 @@ create_main_dialog (void) row = 0; scale = gimp_scale_entry_new (_("_Filter length:"), licvals.filtlen, 0.1, 64, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 8.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 8.0); g_signal_connect (scale, "value-changed", G_CALLBACK (lic_scale_entry_update), &licvals.filtlen); @@ -794,7 +794,7 @@ create_main_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("_Noise magnitude:"), licvals.noisemag, 1, 5, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (lic_scale_entry_update), &licvals.noisemag); @@ -950,8 +950,8 @@ lic_run (GimpProcedure *procedure, } static void -lic_scale_entry_update (GimpScaleEntry *entry, - gdouble *value) +lic_scale_entry_update (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } diff --git a/plug-ins/common/wavelet-decompose.c b/plug-ins/common/wavelet-decompose.c index 463d836e81..e874e2f7a8 100644 --- a/plug-ins/common/wavelet-decompose.c +++ b/plug-ins/common/wavelet-decompose.c @@ -72,7 +72,7 @@ static void wavelet_blur (GimpDrawable *drawable gint radius); static gboolean wavelet_decompose_dialog (void); -static void wavelet_scale_entry_update_int (GimpScaleEntry *entry, +static void wavelet_scale_entry_update_int (GimpLabelSpin *entry, gint *value); @@ -445,8 +445,8 @@ wavelet_decompose_dialog (void) } static void -wavelet_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +wavelet_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (int) gimp_scale_entry_get_value (entry); + *value = (int) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/file-jpeg/jpeg-save.c b/plug-ins/file-jpeg/jpeg-save.c index 88db95a575..8f2537b05f 100644 --- a/plug-ins/file-jpeg/jpeg-save.c +++ b/plug-ins/file-jpeg/jpeg-save.c @@ -117,7 +117,7 @@ typedef struct static void make_preview (void); -static void scale_entry_update (GimpScaleEntry *entry, +static void scale_entry_update (GimpLabelSpin *entry, gdouble *value); static void save_restart_update (GtkAdjustment *adjustment, GtkWidget *toggle); @@ -128,7 +128,7 @@ static void quality_changed (GimpScaleEntry *scale_entry, static void subsampling_changed2 (GtkWidget *combo, GtkWidget *toggle); static void use_orig_qual_changed (GtkWidget *toggle, - GimpScaleEntry *scale_entry); + GimpLabelSpin *scale_entry); static void use_orig_qual_changed2 (GtkWidget *toggle, GtkWidget *combo); @@ -1421,12 +1421,12 @@ load_gui_defaults (JpegSaveGui *pg) gtk_adjustment_set_value (restart_markers, jsvals.restart); g_signal_handler_unblock (pg->use_restart_markers, pg->handler_id_restart); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (pg->smoothing), jsvals.smoothing); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (pg->smoothing), jsvals.smoothing); /* Don't override quality and subsampling setting if we already set it from original */ if (!jsvals.use_orig_quality) { - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (pg->quality), jsvals.quality); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (pg->quality), jsvals.quality); if (gimp_drawable_is_rgb (drawable_global)) { @@ -1440,10 +1440,10 @@ load_gui_defaults (JpegSaveGui *pg) } static void -scale_entry_update (GimpScaleEntry *entry, +scale_entry_update (GimpLabelSpin *entry, gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } static void @@ -1500,13 +1500,13 @@ subsampling_changed2 (GtkWidget *combo, } static void -use_orig_qual_changed (GtkWidget *toggle, - GimpScaleEntry *scale_entry) +use_orig_qual_changed (GtkWidget *toggle, + GimpLabelSpin *scale_entry) { if (jsvals.use_orig_quality && orig_quality > 0) { g_signal_handlers_block_by_func (scale_entry, quality_changed, toggle); - gimp_scale_entry_set_value (scale_entry, orig_quality); + gimp_label_spin_set_value (scale_entry, orig_quality); g_signal_handlers_unblock_by_func (scale_entry, quality_changed, toggle); } } diff --git a/plug-ins/flame/flame.c b/plug-ins/flame/flame.c index 80de79885f..66d882e33a 100644 --- a/plug-ins/flame/flame.c +++ b/plug-ins/flame/flame.c @@ -103,9 +103,9 @@ static void combo_callback (GtkWidget *widget, gpointer data); static void init_mutants (void); -static void flame_scale_entry_update_int (GimpScaleEntry *entry, +static void flame_scale_entry_update_int (GimpLabelSpin *entry, gint *value); -static void flame_scale_entry_update_double (GimpScaleEntry *entry, +static void flame_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); G_DEFINE_TYPE (Flame, flame, GIMP_TYPE_PLUG_IN) @@ -754,7 +754,7 @@ edit_callback (GtkWidget *widget, gtk_widget_show (vbox); scale = gimp_scale_entry_new (_("_Speed:"), pick_speed, 0.05, 0.5, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.01, 0.1); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1111,7 +1111,7 @@ flame_dialog (void) gtk_widget_show (grid); scale = gimp_scale_entry_new (_("_Brightness:"), config.cp.brightness, 0, 5, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1123,7 +1123,7 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Co_ntrast:"), config.cp.contrast, 0, 5, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1135,10 +1135,10 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("_Gamma:"), config.cp.gamma, 1, 5, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 1.0); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6); - gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 1.0); + gtk_widget_set_margin_bottom (gimp_labeled_get_label (GIMP_LABELED (scale)), 6); + gtk_widget_set_margin_bottom (gimp_scale_entry_get_range (GIMP_SCALE_ENTRY (scale)), 6); + gtk_widget_set_margin_bottom (gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)), 6); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1150,7 +1150,7 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Sample _density:"), config.cp.sample_density, 0.1, 20, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.1, 5.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.1, 5.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1159,7 +1159,7 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Spa_tial oversample:"), config.cp.spatial_oversample, 1, 4, 0); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.01, 0.1); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_int), @@ -1168,7 +1168,7 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Spatial _filter radius:"), config.cp.spatial_filter_radius, 0, 4, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.2, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.2, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1258,7 +1258,7 @@ flame_dialog (void) gtk_widget_show (grid); scale = gimp_scale_entry_new (_("_Zoom:"), config.cp.zoom, -4, 4, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.5, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.5, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1270,7 +1270,7 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("_X:"), config.cp.center[0], -2, 2, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.5, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.5, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1282,7 +1282,7 @@ flame_dialog (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("_Y:"), config.cp.center[1], -2, 2, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.5, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.5, 1.0); g_signal_connect (scale, "value-changed", G_CALLBACK (flame_scale_entry_update_double), @@ -1305,15 +1305,15 @@ flame_dialog (void) } static void -flame_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +flame_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } static void -flame_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +flame_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } diff --git a/plug-ins/fractal-explorer/fractal-explorer-dialogs.c b/plug-ins/fractal-explorer/fractal-explorer-dialogs.c index 290f586256..b3c93f5e37 100644 --- a/plug-ins/fractal-explorer/fractal-explorer-dialogs.c +++ b/plug-ins/fractal-explorer/fractal-explorer-dialogs.c @@ -269,10 +269,10 @@ explorer_radio_update (GtkWidget *widget, } static void -explorer_double_adjustment_update (GimpScaleEntry *entry, - gdouble *value) +explorer_double_adjustment_update (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); set_cmap_preview (); dialog_update_preview (); @@ -729,7 +729,7 @@ explorer_dialog (void) elements->xmin = gimp_scale_entry_new (_("Left:"), wvals.xmin, -3, 3, 5); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (elements->xmin), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (elements->xmin), 0.001, 0.01); g_signal_connect (elements->xmin, "value-changed", G_CALLBACK (explorer_double_adjustment_update), &wvals.xmin); @@ -738,7 +738,7 @@ explorer_dialog (void) elements->xmax = gimp_scale_entry_new (_("Right:"), wvals.xmax, -3, 3, 5); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (elements->xmax), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (elements->xmax), 0.001, 0.01); g_signal_connect (elements->xmax, "value-changed", G_CALLBACK (explorer_double_adjustment_update), &wvals.xmax); @@ -747,7 +747,7 @@ explorer_dialog (void) elements->ymin = gimp_scale_entry_new (_("Top:"), wvals.ymin, -3, 3, 5); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (elements->ymin), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (elements->ymin), 0.001, 0.01); g_signal_connect (elements->ymin, "value-changed", G_CALLBACK (explorer_double_adjustment_update), &wvals.ymin); @@ -756,7 +756,7 @@ explorer_dialog (void) elements->ymax = gimp_scale_entry_new (_("Bottom:"), wvals.ymax, -3, 3, 5); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (elements->ymax), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (elements->ymax), 0.001, 0.01); g_signal_connect (elements->ymax, "value-changed", G_CALLBACK (explorer_double_adjustment_update), &wvals.ymax); @@ -777,7 +777,7 @@ explorer_dialog (void) elements->cx = gimp_scale_entry_new (_("CX:"), wvals.cx, -2.5, 2.5, 5); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (elements->cx), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (elements->cx), 0.001, 0.01); gimp_help_set_help_data (elements->cx, _("Changes aspect of fractal"), NULL); g_signal_connect (elements->cx, "value-changed", @@ -788,7 +788,7 @@ explorer_dialog (void) elements->cy = gimp_scale_entry_new (_("CY:"), wvals.cy, -2.5, 2.5, 5); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (elements->cy), 0.001, 0.01); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (elements->cy), 0.001, 0.01); gimp_help_set_help_data (elements->cy, _("Changes aspect of fractal"), NULL); g_signal_connect (elements->cy, "value-changed", @@ -1441,17 +1441,17 @@ dialog_change_scale (void) { ready_now = FALSE; - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->xmin), wvals.xmin); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->xmax), wvals.xmax); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->ymin), wvals.ymin); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->ymax), wvals.ymax); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->iter), wvals.iter); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->cx), wvals.cx); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->cy), wvals.cy); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->xmin), wvals.xmin); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->xmax), wvals.xmax); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->ymin), wvals.ymin); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->ymax), wvals.ymax); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->iter), wvals.iter); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->cx), wvals.cx); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->cy), wvals.cy); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->red), wvals.redstretch); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->green), wvals.greenstretch); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (elements->blue), wvals.bluestretch); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->red), wvals.redstretch); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->green), wvals.greenstretch); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (elements->blue), wvals.bluestretch); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (elements->type[wvals.fractaltype]), TRUE); diff --git a/plug-ins/gfig/gfig-dialog.c b/plug-ins/gfig/gfig-dialog.c index 4f965b709a..d8593afb2e 100644 --- a/plug-ins/gfig/gfig-dialog.c +++ b/plug-ins/gfig/gfig-dialog.c @@ -191,9 +191,9 @@ static void toggle_obj_type (GtkRadioAction *action, static GtkUIManager *create_ui_manager (GtkWidget *window); -static void gfig_scale_entry_update_double (GimpScaleEntry *entry, +static void gfig_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); -static void gfig_scale_entry_update_int (GimpScaleEntry *entry, +static void gfig_scale_entry_update_int (GimpLabelSpin *entry, gint *value); @@ -1556,20 +1556,20 @@ options_update (GFigObj *old_obj) if (selvals.opts.gridspacing != gfig_context->current_obj->opts.gridspacing) { if (gfig_opt_widget.gridspacing) - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (gfig_opt_widget.gridspacing), - gfig_context->current_obj->opts.gridspacing); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (gfig_opt_widget.gridspacing), + gfig_context->current_obj->opts.gridspacing); } if (selvals.opts.grid_sectors_desired != gfig_context->current_obj->opts.grid_sectors_desired) { if (gfig_opt_widget.grid_sectors_desired) - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (gfig_opt_widget.grid_sectors_desired), - gfig_context->current_obj->opts.grid_sectors_desired); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (gfig_opt_widget.grid_sectors_desired), + gfig_context->current_obj->opts.grid_sectors_desired); } if (selvals.opts.grid_radius_interval != gfig_context->current_obj->opts.grid_radius_interval) { if (gfig_opt_widget.grid_radius_interval) - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (gfig_opt_widget.grid_radius_interval), - gfig_context->current_obj->opts.grid_radius_interval); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (gfig_opt_widget.grid_radius_interval), + gfig_context->current_obj->opts.grid_radius_interval); } if (selvals.opts.gridtype != gfig_context->current_obj->opts.gridtype) { @@ -2187,15 +2187,15 @@ gfig_draw_line (gint x0, gint y0, gint x1, gint y1, cairo_t *cr) } static void -gfig_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +gfig_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } static void -gfig_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +gfig_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/gimpressionist/brush.c b/plug-ins/gimpressionist/brush.c index eba567f2ac..0cfbc425ed 100644 --- a/plug-ins/gimpressionist/brush.c +++ b/plug-ins/gimpressionist/brush.c @@ -55,8 +55,8 @@ brush_restore (void) { reselect (brush_list, pcvals.selected_brush); gtk_adjustment_set_value (brush_gamma_adjust, pcvals.brushgamma); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (brush_relief_scale), pcvals.brush_relief); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (brush_aspect_scale), pcvals.brush_aspect); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (brush_relief_scale), pcvals.brush_relief); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (brush_aspect_scale), pcvals.brush_aspect); } void @@ -147,7 +147,7 @@ brushdmenuselect (GtkWidget *widget, } gtk_adjustment_set_value (brush_gamma_adjust, 1.0); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (brush_aspect_scale), 0.0); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (brush_aspect_scale), 0.0); if (! gimp_drawable_mask_intersect (drawable, &x1, &y1, &w, &h)) return; @@ -387,7 +387,7 @@ update_brush_preview (const gchar *fn) gammatable[i] = i; newheight = p.height * - pow (10, gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (brush_aspect_scale))); + pow (10, gimp_label_spin_get_value (GIMP_LABEL_SPIN (brush_aspect_scale))); sc = p.width > newheight ? p.width : newheight; sc = 100.0 / sc; @@ -463,7 +463,7 @@ brush_select (GtkTreeSelection *selection, gboolean force) brush_dont_update = TRUE; gtk_adjustment_set_value (brush_gamma_adjust, 1.0); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (brush_aspect_scale), 0.0); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (brush_aspect_scale), 0.0); brush_dont_update = FALSE; if (brush) @@ -500,8 +500,8 @@ brush_preview_size_allocate (GtkWidget *preview) } static void -brush_aspect_adjust_cb (GimpScaleEntry *scale, - gdouble *value) +brush_aspect_adjust_cb (GimpLabelSpin *scale, + gdouble *value) { gimpressionist_scale_entry_update_double (scale, value); update_brush_preview (pcvals.selected_brush); @@ -615,7 +615,7 @@ create_brushpage (GtkNotebook *notebook) _("Specifies the aspect ratio of the brush"), NULL); gtk_size_group_add_widget (group, - gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (brush_aspect_scale))); + gimp_labeled_get_label (GIMP_LABELED (brush_aspect_scale))); g_signal_connect (brush_aspect_scale, "value-changed", G_CALLBACK (brush_aspect_adjust_cb), &pcvals.brush_aspect); @@ -628,7 +628,7 @@ create_brushpage (GtkNotebook *notebook) _("Specifies the amount of embossing to apply to the image (in percent)"), NULL); gtk_size_group_add_widget (group, - gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (brush_relief_scale))); + gimp_labeled_get_label (GIMP_LABELED (brush_relief_scale))); g_signal_connect (brush_relief_scale, "value-changed", G_CALLBACK (gimpressionist_scale_entry_update_double), &pcvals.brush_relief); diff --git a/plug-ins/gimpressionist/color.c b/plug-ins/gimpressionist/color.c index b3fec30313..809b5a7833 100644 --- a/plug-ins/gimpressionist/color.c +++ b/plug-ins/gimpressionist/color.c @@ -39,8 +39,8 @@ color_restore (void) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (colorradio[pcvals.color_type]), TRUE); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (colornoiseadjust), - pcvals.color_noise); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (colornoiseadjust), + pcvals.color_noise); } int diff --git a/plug-ins/gimpressionist/general.c b/plug-ins/gimpressionist/general.c index 6ef3fdd85f..73e1bcb815 100644 --- a/plug-ins/gimpressionist/general.c +++ b/plug-ins/gimpressionist/general.c @@ -62,13 +62,13 @@ void general_store (void) { pcvals.general_paint_edges = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (general_paint_edges)); - pcvals.general_dark_edge = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (general_dark_edge_scale)); + pcvals.general_dark_edge = gimp_label_spin_get_value (GIMP_LABEL_SPIN (general_dark_edge_scale)); pcvals.general_tileable = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (general_tileable)); pcvals.general_drop_shadow = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (general_drop_shadow)); - pcvals.general_shadow_darkness = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (general_shadow_scale)); - pcvals.general_shadow_depth = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (general_shadow_depth)); - pcvals.general_shadow_blur = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (general_shadow_blur)); - pcvals.devthresh = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (dev_thresh_scale)); + pcvals.general_shadow_darkness = gimp_label_spin_get_value (GIMP_LABEL_SPIN (general_shadow_scale)); + pcvals.general_shadow_depth = gimp_label_spin_get_value (GIMP_LABEL_SPIN (general_shadow_depth)); + pcvals.general_shadow_blur = gimp_label_spin_get_value (GIMP_LABEL_SPIN (general_shadow_blur)); + pcvals.devthresh = gimp_label_spin_get_value (GIMP_LABEL_SPIN (dev_thresh_scale)); } int @@ -86,22 +86,22 @@ general_restore (void) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (general_paint_edges), pcvals.general_paint_edges); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (general_dark_edge_scale), - pcvals.general_dark_edge); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (general_shadow_scale), - pcvals.general_shadow_darkness); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (general_dark_edge_scale), + pcvals.general_dark_edge); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (general_shadow_scale), + pcvals.general_shadow_darkness); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (general_drop_shadow), pcvals.general_drop_shadow); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (general_shadow_depth), - pcvals.general_shadow_depth); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (general_shadow_blur), - pcvals.general_shadow_blur); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (general_shadow_depth), + pcvals.general_shadow_depth); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (general_shadow_blur), + pcvals.general_shadow_blur); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (general_tileable), pcvals.general_tileable); gimp_color_button_set_color (GIMP_COLOR_BUTTON (general_color_button), &pcvals.color); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (dev_thresh_scale), - pcvals.devthresh); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (dev_thresh_scale), + pcvals.devthresh); } static void @@ -244,7 +244,7 @@ create_generalpage (GtkNotebook *notebook) general_shadow_scale = gimp_scale_entry_new (_("Shadow darken:"), pcvals.general_shadow_darkness, 0.0, 99.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (general_shadow_scale), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (general_shadow_scale), 0.1, 1.0); gimp_help_set_help_data (general_shadow_scale, _("How much to \"darken\" the drop shadow"), NULL); diff --git a/plug-ins/gimpressionist/gimpressionist.h b/plug-ins/gimpressionist/gimpressionist.h index e9e36d522e..5d4f829255 100644 --- a/plug-ins/gimpressionist/gimpressionist.h +++ b/plug-ins/gimpressionist/gimpressionist.h @@ -174,10 +174,10 @@ GtkWidget *create_radio_button (GtkWidget *box, int orient_type, GtkWidget **buttons_array ); -void gimpressionist_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value); -void gimpressionist_scale_entry_update_int (GimpScaleEntry *entry, - gint *value); +void gimpressionist_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value); +void gimpressionist_scale_entry_update_int (GimpLabelSpin *entry, + gint *value); #define CLAMP_UP_TO(x, max) (CLAMP((x),(0),(max-1))) diff --git a/plug-ins/gimpressionist/orientation.c b/plug-ins/gimpressionist/orientation.c index 885cffa388..729d729123 100644 --- a/plug-ins/gimpressionist/orientation.c +++ b/plug-ins/gimpressionist/orientation.c @@ -49,12 +49,12 @@ void orientation_restore (void) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (orient_radio[pcvals.orient_type]), TRUE); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (orient_num_adjust), - pcvals.orient_num); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (orient_first_adjust), - pcvals.orient_first); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (orient_last_adjust), - pcvals.orient_last); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (orient_num_adjust), + pcvals.orient_num); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (orient_first_adjust), + pcvals.orient_first); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (orient_last_adjust), + pcvals.orient_last); } static void diff --git a/plug-ins/gimpressionist/orientmap.c b/plug-ins/gimpressionist/orientmap.c index 9f7dc00632..455ea5ed3b 100644 --- a/plug-ins/gimpressionist/orientmap.c +++ b/plug-ins/gimpressionist/orientmap.c @@ -80,8 +80,8 @@ double get_direction (double x, double y, int from) { n = num_vectors; vec = vector; - angoff = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (angle_offset_adjust)); - strexp = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (orient_map_str_exp_adjust)); + angoff = gimp_label_spin_get_value (GIMP_LABEL_SPIN (angle_offset_adjust)); + strexp = gimp_label_spin_get_value (GIMP_LABEL_SPIN (orient_map_str_exp_adjust)); voronoi = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (orient_voronoi)); } else @@ -286,8 +286,8 @@ update_slides (void) gint type; adjignore = TRUE; - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (angle_adjust), vector[selectedvector].dir); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (strength_adjust), vector[selectedvector].str); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (angle_adjust), vector[selectedvector].dir); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (strength_adjust), vector[selectedvector].str); type = vector[selectedvector].type; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vector_types[type]), TRUE); adjignore = FALSE; @@ -388,7 +388,7 @@ angle_adjust_move_callback (GtkWidget *w, gpointer data) { if (adjignore) return; - vector[selectedvector].dir = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (angle_adjust)); + vector[selectedvector].dir = gimp_label_spin_get_value (GIMP_LABEL_SPIN (angle_adjust)); vector[selectedvector].dx = sin (gimp_deg_to_rad (vector[selectedvector].dir)); vector[selectedvector].dy = @@ -402,7 +402,7 @@ strength_adjust_move_callback (GtkWidget *w, gpointer data) { if (adjignore) return; - vector[selectedvector].str = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (strength_adjust)); + vector[selectedvector].str = gimp_label_spin_get_value (GIMP_LABEL_SPIN (strength_adjust)); update_vector_prev (); update_orient_map_preview_prev (); } @@ -453,8 +453,8 @@ orient_map_response (GtkWidget *widget, pcvals.orient_vectors[i] = vector[i]; pcvals.num_orient_vectors = num_vectors; - pcvals.orient_strength_exponent = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (orient_map_str_exp_adjust)); - pcvals.orient_angle_offset = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (angle_offset_adjust)); + pcvals.orient_strength_exponent = gimp_label_spin_get_value (GIMP_LABEL_SPIN (orient_map_str_exp_adjust)); + pcvals.orient_angle_offset = gimp_label_spin_get_value (GIMP_LABEL_SPIN (angle_offset_adjust)); pcvals.orient_voronoi = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (orient_voronoi)); } }; @@ -490,10 +490,10 @@ update_orientmap_dialog (void) init_vectors (); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (orient_map_str_exp_adjust), - pcvals.orient_strength_exponent); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (angle_offset_adjust), - pcvals.orient_angle_offset); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (orient_map_str_exp_adjust), + pcvals.orient_strength_exponent); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (angle_offset_adjust), + pcvals.orient_angle_offset); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (orient_voronoi), pcvals.orient_voronoi); @@ -686,7 +686,7 @@ create_orientmap_dialog (GtkWidget *parent) strength_adjust = gimp_scale_entry_new (_("_Strength:"), 1.0, 0.1, 5.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (strength_adjust), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (strength_adjust), 0.1, 1.0); gimp_help_set_help_data (strength_adjust, _("Change the strength of the selected vector"), NULL); @@ -697,7 +697,7 @@ create_orientmap_dialog (GtkWidget *parent) orient_map_str_exp_adjust = gimp_scale_entry_new (_("S_trength exp.:"), 1.0, 0.1, 10.9, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (orient_map_str_exp_adjust), 0.1, 1.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (orient_map_str_exp_adjust), 0.1, 1.0); gimp_help_set_help_data (orient_map_str_exp_adjust, _("Change the exponent of the strength"), NULL); diff --git a/plug-ins/gimpressionist/paper.c b/plug-ins/gimpressionist/paper.c index 79b7cd2b7e..e46cde9adf 100644 --- a/plug-ins/gimpressionist/paper.c +++ b/plug-ins/gimpressionist/paper.c @@ -109,8 +109,8 @@ void paper_restore (void) { reselect (paper_list, pcvals.selected_paper); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (paper_relief_adjust), pcvals.paper_relief); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (paper_scale_adjust), pcvals.paper_scale); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (paper_relief_adjust), pcvals.paper_relief); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (paper_scale_adjust), pcvals.paper_scale); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (paper_invert), pcvals.paper_invert); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (paper_overlay), pcvals.paper_overlay); } diff --git a/plug-ins/gimpressionist/placement.c b/plug-ins/gimpressionist/placement.c index 98de7de642..4dc89b4614 100644 --- a/plug-ins/gimpressionist/placement.c +++ b/plug-ins/gimpressionist/placement.c @@ -41,8 +41,8 @@ place_restore (void) (GTK_TOGGLE_BUTTON (placement_radio[pcvals.place_type]), TRUE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (placement_center), pcvals.placement_center); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (brush_density_adjust), - pcvals.brush_density); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (brush_density_adjust), + pcvals.brush_density); } int diff --git a/plug-ins/gimpressionist/size.c b/plug-ins/gimpressionist/size.c index 700b1993e3..ab999a8fef 100644 --- a/plug-ins/gimpressionist/size.c +++ b/plug-ins/gimpressionist/size.c @@ -58,12 +58,12 @@ void size_restore (void) { size_type_restore (); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (sizenumadjust), - pcvals.size_num); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (sizefirstadjust), - pcvals.size_first); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (sizelastadjust), - pcvals.size_last); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (sizenumadjust), + pcvals.size_num); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (sizefirstadjust), + pcvals.size_first); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (sizelastadjust), + pcvals.size_last); } static void diff --git a/plug-ins/gimpressionist/sizemap.c b/plug-ins/gimpressionist/sizemap.c index dd6f8e9ad6..b2fc663b53 100644 --- a/plug-ins/gimpressionist/sizemap.c +++ b/plug-ins/gimpressionist/sizemap.c @@ -61,7 +61,7 @@ static double getsiz_from_gui (double x, double y) { return getsiz_proto (x,y, numsmvect, smvector, - gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (smstrexpadjust)), + gimp_label_spin_get_value (GIMP_LABEL_SPIN (smstrexpadjust)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (size_voronoi))); } @@ -181,8 +181,8 @@ static void updatesmsliders (void) { smadjignore = TRUE; - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (sizadjust), smvector[selectedsmvector].siz); - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (smstradjust), smvector[selectedsmvector].str); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (sizadjust), smvector[selectedsmvector].siz); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (smstradjust), smvector[selectedsmvector].str); smadjignore = FALSE; } @@ -278,7 +278,7 @@ angsmadjmove (GtkWidget *w, gpointer data) { if (!smadjignore) { - smvector[selectedsmvector].siz = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (sizadjust)); + smvector[selectedsmvector].siz = gimp_label_spin_get_value (GIMP_LABEL_SPIN (sizadjust)); updatesmvectorprev (); updatesmpreviewprev (); } @@ -289,7 +289,7 @@ strsmadjmove (GtkWidget *w, gpointer data) { if (!smadjignore) { - smvector[selectedsmvector].str = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (smstradjust)); + smvector[selectedsmvector].str = gimp_label_spin_get_value (GIMP_LABEL_SPIN (smstradjust)); updatesmvectorprev (); updatesmpreviewprev (); } @@ -321,7 +321,7 @@ smresponse (GtkWidget *widget, pcvals.size_vectors[i] = smvector[i]; pcvals.num_size_vectors = numsmvect; - pcvals.size_strength_exponent = gimp_scale_entry_get_value (GIMP_SCALE_ENTRY (smstrexpadjust)); + pcvals.size_strength_exponent = gimp_label_spin_get_value (GIMP_LABEL_SPIN (smstrexpadjust)); pcvals.size_voronoi = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (size_voronoi)); } break; @@ -516,7 +516,7 @@ create_sizemap_dialog (GtkWidget *parent) smstradjust = gimp_scale_entry_new (_("S_trength:"), 1.0, 0.1, 5.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (smstradjust), 0.1, 0.5); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (smstradjust), 0.1, 0.5); gimp_help_set_help_data (smstradjust, _("Change the strength of the selected smvector"), NULL); @@ -527,7 +527,7 @@ create_sizemap_dialog (GtkWidget *parent) smstrexpadjust = gimp_scale_entry_new (_("St_rength exp.:"), 1.0, 0.1, 10.9, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (smstradjust), 0.1, 0.5); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (smstradjust), 0.1, 0.5); gimp_help_set_help_data (smstrexpadjust, _("Change the exponent of the strength"), NULL); diff --git a/plug-ins/gimpressionist/utils.c b/plug-ins/gimpressionist/utils.c index bf2c606948..403b658c60 100644 --- a/plug-ins/gimpressionist/utils.c +++ b/plug-ins/gimpressionist/utils.c @@ -410,15 +410,15 @@ create_radio_button (GtkWidget *box, } void -gimpressionist_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +gimpressionist_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } void -gimpressionist_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +gimpressionist_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } diff --git a/plug-ins/gradient-flare/gradient-flare.c b/plug-ins/gradient-flare/gradient-flare.c index 568ca52931..7d654881dc 100644 --- a/plug-ins/gradient-flare/gradient-flare.c +++ b/plug-ins/gradient-flare/gradient-flare.c @@ -662,9 +662,9 @@ 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, +static void gradient_scale_entry_update_double (GimpLabelSpin *entry, gdouble *value); -static void gradient_scale_entry_update_int (GimpScaleEntry *entry, +static void gradient_scale_entry_update_int (GimpLabelSpin *entry, gint *value); @@ -2910,7 +2910,7 @@ dlg_make_page_settings (GFlareDialog *dlg, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Ro_tation:"), pvals.rotation, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &pvals.rotation); @@ -2921,7 +2921,7 @@ dlg_make_page_settings (GFlareDialog *dlg, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("_Hue rotation:"), pvals.hue, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &pvals.hue); @@ -2932,7 +2932,7 @@ dlg_make_page_settings (GFlareDialog *dlg, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Vector _angle:"), pvals.vangle, 0.0, 359.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &pvals.vangle); @@ -2991,7 +2991,7 @@ dlg_make_page_settings (GFlareDialog *dlg, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("_Threshold"), pvals.asupsample_threshold, 0.0, 4.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.01, 0.1); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &pvals.asupsample_threshold); @@ -3729,7 +3729,7 @@ ed_make_page_glow (GFlareEditor *ed, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Rotation:"), gflare->glow_rotation, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &gflare->glow_rotation); @@ -3740,7 +3740,7 @@ ed_make_page_glow (GFlareEditor *ed, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Hue rotation:"), gflare->glow_hue, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &gflare->glow_hue); @@ -3831,7 +3831,7 @@ ed_make_page_rays (GFlareEditor *ed, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Rotation:"), gflare->rays_rotation, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &gflare->rays_rotation); @@ -3842,7 +3842,7 @@ ed_make_page_rays (GFlareEditor *ed, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Hue rotation:"), gflare->rays_hue, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &gflare->rays_hue); @@ -3962,7 +3962,7 @@ ed_make_page_sflare (GFlareEditor *ed, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Rotation:"), gflare->sflare_rotation, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &gflare->sflare_rotation); @@ -3973,7 +3973,7 @@ ed_make_page_sflare (GFlareEditor *ed, gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Hue rotation:"), gflare->sflare_hue, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); g_signal_connect (scale, "value-changed", G_CALLBACK (gradient_scale_entry_update_double), &gflare->sflare_hue); @@ -5136,17 +5136,17 @@ gradient_cache_zorch (void) } static void -gradient_scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +gradient_scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); } static void -gradient_scale_entry_update_int (GimpScaleEntry *entry, - gint *value) +gradient_scale_entry_update_int (GimpLabelSpin *entry, + gint *value) { - *value = (gint) gimp_scale_entry_get_value (entry); + *value = (gint) gimp_label_spin_get_value (entry); } #ifdef DEBUG diff --git a/plug-ins/lighting/lighting-ui.c b/plug-ins/lighting/lighting-ui.c index be566d0077..3145308928 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 (GimpScaleEntry *scale, +static void distance_update (GimpLabelSpin *scale, gpointer data); static gboolean bumpmap_constrain (GimpImage *image, @@ -116,10 +116,10 @@ toggle_update (GtkWidget *widget, static void -distance_update (GimpScaleEntry *scale, - gpointer data) +distance_update (GimpLabelSpin *scale, + gpointer data) { - mapvals.viewpoint.z = gimp_scale_entry_get_value (scale); + mapvals.viewpoint.z = gimp_label_spin_get_value (scale); preview_compute (); gtk_widget_queue_draw (previewarea); diff --git a/plug-ins/map-object/map-object-ui.c b/plug-ins/map-object/map-object-ui.c index 2b24438196..3f29685d07 100644 --- a/plug-ins/map-object/map-object-ui.c +++ b/plug-ins/map-object/map-object-ui.c @@ -74,10 +74,10 @@ static GtkWidget * create_cylinder_page (void); /******************************************************/ static void -scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); if (mapvals.livepreview) compute_preview_image (); @@ -976,7 +976,7 @@ create_orientation_page (void) scale = gimp_scale_entry_new (_("X:"), mapvals.position.x, -1.0, 2.0, 5); gimp_help_set_help_data (scale, _("Object X position in XYZ space"), NULL); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_size_group_add_widget (group, spinbutton); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.01, 5); @@ -988,7 +988,7 @@ create_orientation_page (void) scale = gimp_scale_entry_new (_("Y:"), mapvals.position.y, -1.0, 2.0, 5); gimp_help_set_help_data (scale, _("Object Y position in XYZ space"), NULL); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_size_group_add_widget (group, spinbutton); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.01, 5); @@ -1000,7 +1000,7 @@ create_orientation_page (void) scale = gimp_scale_entry_new (_("Z:"), mapvals.position.z, -1.0, 2.0, 5); gimp_help_set_help_data (scale, _("Object Z position in XYZ space"), NULL); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_size_group_add_widget (group, spinbutton); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.01, 5); @@ -1021,9 +1021,9 @@ create_orientation_page (void) gtk_widget_show (grid); scale = gimp_scale_entry_new (_("X:"), mapvals.alpha, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); gimp_help_set_help_data (scale, _("Rotation angle about X axis"), NULL); - gtk_size_group_add_widget (group, gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale))); g_signal_connect (scale, "value-changed", G_CALLBACK (scale_entry_update_double), @@ -1032,9 +1032,9 @@ create_orientation_page (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Y:"), mapvals.beta, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); gimp_help_set_help_data (scale, _("Rotation angle about Y axis"), NULL); - gtk_size_group_add_widget (group, gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale))); g_signal_connect (scale, "value-changed", G_CALLBACK (scale_entry_update_double), @@ -1043,9 +1043,9 @@ create_orientation_page (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Z:"), mapvals.gamma, -180.0, 180.0, 1); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 1.0, 15.0); gimp_help_set_help_data (scale, _("Rotation angle about Z axis"), NULL); - gtk_size_group_add_widget (group, gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale))); + gtk_size_group_add_widget (group, gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale))); g_signal_connect (scale, "value-changed", G_CALLBACK (scale_entry_update_double), @@ -1119,9 +1119,9 @@ create_box_page (void) gtk_widget_show (grid); scale = gimp_scale_entry_new (_("Scale X:"), mapvals.scale.x, 0.0, 5.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.01, 0.1); gimp_help_set_help_data (scale, _("X scale (size)"), NULL); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.1, 2); g_signal_connect (scale, "value-changed", @@ -1131,9 +1131,9 @@ create_box_page (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Y:"), mapvals.scale.y, 0.0, 5.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.01, 0.1); gimp_help_set_help_data (scale, _("Y scale (size)"), NULL); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.1, 2); g_signal_connect (scale, "value-changed", @@ -1143,9 +1143,9 @@ create_box_page (void) gtk_widget_show (scale); scale = gimp_scale_entry_new (_("Z:"), mapvals.scale.z, 0.0, 5.0, 2); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (scale), 0.01, 0.1); gimp_help_set_help_data (scale, _("Z scale (size)"), NULL); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.1, 2); g_signal_connect (scale, "value-changed", @@ -1216,8 +1216,8 @@ create_cylinder_page (void) scale = gimp_scale_entry_new (_("R_adius:"), mapvals.cylinder_radius, 0.0, 2.0, 2); gimp_help_set_help_data (scale, _("Cylinder radius"), NULL); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.1, 2); g_signal_connect (scale, "value-changed", @@ -1228,8 +1228,8 @@ create_cylinder_page (void) scale = gimp_scale_entry_new (_("L_ength:"), mapvals.cylinder_length, 0.0, 2.0, 2); gimp_help_set_help_data (scale, _("Cylinder length"), NULL); - gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale))); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)); + gtk_size_group_add_widget (group, gimp_labeled_get_label (GIMP_LABELED (scale))); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (scale)); gtk_spin_button_configure (GTK_SPIN_BUTTON (spinbutton), NULL, 0.1, 2); g_signal_connect (scale, "value-changed", diff --git a/plug-ins/pagecurl/pagecurl.c b/plug-ins/pagecurl/pagecurl.c index 5559452daf..da8f04c671 100644 --- a/plug-ins/pagecurl/pagecurl.c +++ b/plug-ins/pagecurl/pagecurl.c @@ -133,7 +133,7 @@ static GimpValueArray * pagecurl_run (GimpProcedure *procedu const GimpValueArray *args, gpointer run_data); -static void dialog_scale_update (GimpScaleEntry *adjustment, +static void dialog_scale_update (GimpLabelSpin *spin, gdouble *value); static gboolean dialog (void); @@ -414,10 +414,10 @@ inside_circle (gdouble x, /********************************************************************/ static void -dialog_scale_update (GimpScaleEntry *scale, - gdouble *value) +dialog_scale_update (GimpLabelSpin *scale, + gdouble *value) { - *value = ((gdouble) gimp_scale_entry_get_value (scale)) / 100.0; + *value = ((gdouble) gimp_label_spin_get_value (scale)) / 100.0; } static void diff --git a/plug-ins/script-fu/script-fu-interface.c b/plug-ins/script-fu/script-fu-interface.c index f5cfc97f65..b81d0b2e7f 100644 --- a/plug-ins/script-fu/script-fu-interface.c +++ b/plug-ins/script-fu/script-fu-interface.c @@ -417,10 +417,10 @@ script_fu_interface (SFScript *script, arg->default_value.sfa_adjustment.lower, arg->default_value.sfa_adjustment.upper, arg->default_value.sfa_adjustment.digits); - gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (widget), - arg->default_value.sfa_adjustment.step, - arg->default_value.sfa_adjustment.page); - spinbutton = gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (widget)); + gimp_label_spin_set_increments (GIMP_LABEL_SPIN (widget), + arg->default_value.sfa_adjustment.step, + arg->default_value.sfa_adjustment.page); + spinbutton = gimp_label_spin_get_spin_button (GIMP_LABEL_SPIN (widget)); arg->value.sfa_adjustment.adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton)); gtk_entry_set_activates_default (GTK_ENTRY (spinbutton), TRUE); diff --git a/plug-ins/selection-to-path/selection-to-path-dialog.c b/plug-ins/selection-to-path/selection-to-path-dialog.c index 4783b72719..917a93ca19 100644 --- a/plug-ins/selection-to-path/selection-to-path-dialog.c +++ b/plug-ins/selection-to-path/selection-to-path-dialog.c @@ -40,8 +40,8 @@ static GSList * adjust_widgets = NULL; -void scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value); +void scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value); /* Reset to recommended defaults */ void @@ -69,8 +69,8 @@ reset_adv_dialog (void) } else if (GIMP_IS_SCALE_ENTRY (widget)) { - gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (widget), - *value); + gimp_label_spin_set_value (GIMP_LABEL_SPIN (widget), + *value); } else g_warning ("Internal widget list error"); @@ -380,8 +380,8 @@ dialog_create_selection_area (SELVALS *sels) } void -scale_entry_update_double (GimpScaleEntry *entry, - gdouble *value) +scale_entry_update_double (GimpLabelSpin *entry, + gdouble *value) { - *value = gimp_scale_entry_get_value (entry); + *value = gimp_label_spin_get_value (entry); }