procyberian/gimp
2
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp.git synced 2025-07-03 09:23:24 +00:00
Code Issues 1 Projects 1 Releases Packages Wiki Activity Actions

app, libgimpwidgets, modules, plug-ins: code changes after GimpScaleEntry…

Browse source 
… reclassing as GimpLabelSpin subclass.
This commit is contained in:
Jehan 2020-11-05 17:37:15 +01:00
parent 079d8fd7f2
commit d95f417719
45 changed files with 366 additions and 366 deletions
Download patch file Download diff file Expand all files Collapse all files

14
app/dialogs/palette-import-dialog.c
View file

@ -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)
{

2
app/widgets/gimpstrokeeditor.c
View file

@ -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);

10
libgimpwidgets/gimpcolorscales.c
View file

@ -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;

2
libgimpwidgets/gimppropwidgets.c
View file

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

12
modules/color-selector-cmyk.c
View file

@ -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)
{

8
plug-ins/common/align-layers.c
View file

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

10
plug-ins/common/blinds.c
View file

@ -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

30
plug-ins/common/cml-explorer.c
View file

@ -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, &param->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, &param->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

10
plug-ins/common/compose.c
View file

@ -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

20
plug-ins/common/contrast-retinex.c
View file

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

16
plug-ins/common/depth-merge.c
View file

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

8
plug-ins/common/destripe.c
View file

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

2
plug-ins/common/file-gbr.c
View file

@ -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);

2
plug-ins/common/file-heif.c
View file

@ -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);

2
plug-ins/common/file-png.c
View file

@ -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);

12
plug-ins/common/file-raw-data.c
View file

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

32
plug-ins/common/film.c
View file

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

24
plug-ins/common/jigsaw.c
View file

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

8
plug-ins/common/nl-filter.c
View file

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

10
plug-ins/common/sparkle.c
View file

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

76
plug-ins/common/sphere-designer.c
View file

@ -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);

8
plug-ins/common/tile-small.c
View file

@ -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 ();
}

12
plug-ins/common/van-gogh-lic.c
View file

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

8
plug-ins/common/wavelet-decompose.c
View file

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

18
plug-ins/file-jpeg/jpeg-save.c
View file

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

42
plug-ins/flame/flame.c
View file

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

38
plug-ins/fractal-explorer/fractal-explorer-dialogs.c
View file

@ -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);

28
plug-ins/gfig/gfig-dialog.c
View file

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

18
plug-ins/gimpressionist/brush.c
View file

@ -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);

4
plug-ins/gimpressionist/color.c
View file

@ -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

32
plug-ins/gimpressionist/general.c
View file

@ -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);

8
plug-ins/gimpressionist/gimpressionist.h
View file

@ -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)))

12
plug-ins/gimpressionist/orientation.c
View file

@ -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

28
plug-ins/gimpressionist/orientmap.c
View file

@ -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);

4
plug-ins/gimpressionist/paper.c
View file

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

4
plug-ins/gimpressionist/placement.c
View file

@ -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

12
plug-ins/gimpressionist/size.c
View file

@ -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

16
plug-ins/gimpressionist/sizemap.c
View file

@ -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);

12
plug-ins/gimpressionist/utils.c
View file

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

36
plug-ins/gradient-flare/gradient-flare.c
View file

@ -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

8
plug-ins/lighting/lighting-ui.c
View file

@ -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);

44
plug-ins/map-object/map-object-ui.c
View file

@ -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",

8
plug-ins/pagecurl/pagecurl.c
View file

@ -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

8
plug-ins/script-fu/script-fu-interface.c
View file

@ -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);

14
plug-ins/selection-to-path/selection-to-path-dialog.c
View file

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