dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
Jehan 2020-10-30 23:28:57 +01:00
parent 10dfaead68
commit f342b566c8
9 changed files with 520 additions and 548 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
plug-ins/common/align-layers.c
View File

@ -28,7 +28,6 @@
#define PLUG_IN_PROC "plug-in-align-layers"
#define PLUG_IN_BINARY "align-layers"
#define PLUG_IN_ROLE "gimp-align-layers"
#define SCALE_WIDTH 150
enum
{
@ -124,6 +123,8 @@ static void align_layers_get_align_offsets (GimpDrawable
gint *x,
gint *y);
static gint align_layers_dialog (void);
static void align_layers_scale_entry_update_int (GimpScaleEntry *entry,
gint *value);
G_DEFINE_TYPE (AlignLayers, align_layers, GIMP_TYPE_PLUG_IN)
@ -647,12 +648,12 @@ align_layers_get_align_offsets (GimpDrawable *drawable,
static int
align_layers_dialog (void)
{
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *combo;
GtkWidget *toggle;
GtkAdjustment *adj;
gboolean run;
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *combo;
GtkWidget *toggle;
GtkWidget *scale;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
@ -741,14 +742,12 @@ align_layers_dialog (void)
_("Ver_tical base:"), 0.0, 0.5,
combo, 2);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 4,
_("_Grid size:"), SCALE_WIDTH, 0,
VALS.grid_size, 1, 200, 1, 10, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Grid size:"), VALS.grid_size, 1, 200, 0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (align_layers_scale_entry_update_int),
&VALS.grid_size);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 4, 3, 1);
gtk_widget_show (scale);
toggle = gtk_check_button_new_with_mnemonic
(_("_Ignore the bottom layer even if visible"));
@ -779,3 +778,10 @@ align_layers_dialog (void)
return run;
}
static void
align_layers_scale_entry_update_int (GimpScaleEntry *entry,
gint *value)
{
*value = (gint) gimp_scale_entry_get_value (entry);
}

62
plug-ins/common/blinds.c
View File

@ -44,8 +44,6 @@
#define PLUG_IN_BINARY "blinds"
#define PLUG_IN_ROLE "gimp-blinds"
#define SCALE_WIDTH 150
#define MAX_FANS 100
/* Variables set in dialog box */
@ -89,6 +87,8 @@ static GimpValueArray * blinds_run (GimpProcedure *procedure
gpointer run_data);
static gboolean blinds_dialog (GimpDrawable *drawable);
static void blinds_scale_entry_update_int (GimpScaleEntry *entry,
gint *value);
static void dialog_update_preview (GimpDrawable *drawable,
GimpPreview *preview);
@ -256,17 +256,17 @@ blinds_run (GimpProcedure *procedure,
static gboolean
blinds_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *grid;
GtkAdjustment *size_data;
GtkWidget *toggle;
GtkWidget *horizontal;
GtkWidget *vertical;
gboolean run;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *scale;
GtkWidget *toggle;
GtkWidget *horizontal;
GtkWidget *vertical;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
@ -355,29 +355,26 @@ blinds_dialog (GimpDrawable *drawable)
gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
size_data = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("_Displacement:"), SCALE_WIDTH, 0,
bvals.angledsp, 1, 90, 1, 15, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (size_data, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Displacement:"), bvals.angledsp, 1, 90, 0);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (blinds_scale_entry_update_int),
&bvals.angledsp);
g_signal_connect_swapped (size_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 2);
gtk_widget_show (scale);
size_data = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
_("_Number of segments:"), SCALE_WIDTH, 0,
bvals.numsegs, 1, MAX_FANS, 1, 2, 0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (size_data, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Number of segments:"), bvals.numsegs, 1, MAX_FANS, 0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (blinds_scale_entry_update_int),
&bvals.numsegs);
g_signal_connect_swapped (size_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 2);
gtk_widget_show (scale);
gtk_widget_show (dialog);
@ -388,6 +385,13 @@ blinds_dialog (GimpDrawable *drawable)
return run;
}
static void
blinds_scale_entry_update_int (GimpScaleEntry *entry,
gint *value)
{
*value = (gint) gimp_scale_entry_get_value (entry);
}
static void
blindsapply (guchar *srow,
guchar *drow,

153
plug-ins/common/film.c
View File

@ -67,7 +67,7 @@ typedef struct
/* Data to use for the dialog */
typedef struct
{
GtkAdjustment *advanced_adj[7];
GtkWidget *scales[7];
GtkTreeModel *image_list_all;
GtkTreeModel *image_list_film;
} FilmInterface;
@ -145,6 +145,8 @@ static void film_font_select_callback (GimpFontSelectButton *button,
gboolean closing,
gpointer data);
static void film_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value);
G_DEFINE_TYPE (Film, film, GIMP_TYPE_PLUG_IN)
@ -1181,13 +1183,13 @@ create_selection_tab (GtkWidget *notebook,
static void
create_advanced_tab (GtkWidget *notebook)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *grid;
GtkWidget *frame;
GtkAdjustment *adj;
GtkWidget *button;
gint row;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *grid;
GtkWidget *frame;
GtkWidget *scale;
GtkWidget *button;
gint row;
frame = gimp_frame_new (_("All Values are Fractions of the Strip Height"));
gtk_container_set_border_width (GTK_CONTAINER (frame), 12);
@ -1207,88 +1209,74 @@ create_advanced_tab (GtkWidget *notebook)
row = 0;
filmint.advanced_adj[0] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Image _height:"), 0, 0,
filmvals.picture_height,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[0] = scale =
gimp_scale_entry_new2 (_("Image _height:"), filmvals.picture_height, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.picture_height);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
filmint.advanced_adj[1] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Image spac_ing:"), 0, 0,
filmvals.picture_space,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 0, 1), 6);
gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 1, 1), 6);
gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 2, 1), 6);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[1] = scale =
gimp_scale_entry_new2 (_("Image spac_ing:"), filmvals.picture_space, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.picture_space);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6);
gtk_widget_set_margin_bottom (gimp_scale_entry_get_scale (GIMP_SCALE_ENTRY (scale)), 6);
gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)), 6);
gtk_widget_show (scale);
filmint.advanced_adj[2] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("_Hole offset:"), 0, 0,
filmvals.hole_offset,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[2] = scale =
gimp_scale_entry_new2 (_("_Hole offset:"), filmvals.hole_offset, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.hole_offset);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
filmint.advanced_adj[3] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Ho_le width:"), 0, 0,
filmvals.hole_width,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[3] = scale =
gimp_scale_entry_new2 (_("Ho_le width:"), filmvals.hole_width, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.hole_width);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
filmint.advanced_adj[4] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Hol_e height:"), 0, 0,
filmvals.hole_height,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[4] = scale =
gimp_scale_entry_new2 (_("Hol_e height:"), filmvals.hole_height, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.hole_height);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
filmint.advanced_adj[5] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Hole sp_acing:"), 0, 0,
filmvals.hole_space,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 0, 5), 6);
gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 1, 5), 6);
gtk_widget_set_margin_bottom (gtk_grid_get_child_at (GTK_GRID (grid), 2, 5), 6);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[5] = scale =
gimp_scale_entry_new2 (_("Hole sp_acing:"), filmvals.hole_space, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.hole_space);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_set_margin_bottom (gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)), 6);
gtk_widget_set_margin_bottom (gimp_scale_entry_get_scale (GIMP_SCALE_ENTRY (scale)), 6);
gtk_widget_set_margin_bottom (gimp_scale_entry_get_spin_button (GIMP_SCALE_ENTRY (scale)), 6);
gtk_widget_show (scale);
filmint.advanced_adj[6] = adj =
gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("_Number height:"), 0, 0,
filmvals.number_height,
0.0, 1.0, 0.001, 0.01, 3,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
filmint.scales[6] = scale =
gimp_scale_entry_new2 (_("_Number height:"), filmvals.number_height, 0.0, 1.0, 3);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.001, 0.01);
g_signal_connect (scale, "value-changed",
G_CALLBACK (film_scale_entry_update_double),
&filmvals.number_height);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
@ -1387,8 +1375,8 @@ film_reset_callback (GtkWidget *widget,
gint i;
for (i = 0; i < G_N_ELEMENTS (advanced_defaults) ; i++)
gtk_adjustment_set_value (filmint.advanced_adj[i],
advanced_defaults[i]);
gimp_scale_entry_set_value (GIMP_SCALE_ENTRY (filmint.scales[i]),
advanced_defaults[i]);
}
static void
@ -1401,3 +1389,10 @@ film_font_select_callback (GimpFontSelectButton *button,
g_strlcpy (vals->number_font, name, FONT_LEN);
}
static void
film_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value)
{
*value = gimp_scale_entry_get_value (entry);
}

95
plug-ins/common/jigsaw.c
View File

@ -108,8 +108,6 @@ typedef enum
#define MIN_BLEND_AMOUNT 0
#define MAX_BLEND_AMOUNT 1.0
#define SCALE_WIDTH 200
#define DRAW_POINT(buffer, bufsize, index) \
do \
{ \
@ -221,7 +219,11 @@ static void jigsaw (GimpDrawable *drawable,
static void jigsaw_preview (GimpDrawable *drawable,
GimpPreview *preview);
static gboolean jigsaw_dialog (GimpDrawable *drawable);
static gboolean jigsaw_dialog (GimpDrawable *drawable);
static void jigsaw_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value);
static void jigsaw_scale_entry_update_int (GimpScaleEntry *entry,
gint *value);
static void draw_jigsaw (guchar *buffer,
gint bufsize,
@ -2460,7 +2462,7 @@ jigsaw_dialog (GimpDrawable *drawable)
GtkWidget *rbutton1;
GtkWidget *rbutton2;
GtkWidget *grid;
GtkAdjustment *adj;
GtkWidget *scale;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
@ -2506,35 +2508,33 @@ jigsaw_dialog (GimpDrawable *drawable)
group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* xtiles */
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("_Horizontal:"), SCALE_WIDTH, 0,
config.x, MIN_XTILES, MAX_XTILES, 1.0, 4.0, 0,
TRUE, 0, 0,
_("Number of pieces going across"), NULL);
scale = gimp_scale_entry_new2 (_("_Horizontal:"), config.x, MIN_XTILES, MAX_XTILES, 0);
gimp_help_set_help_data (scale, _("Number of pieces going across"), NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (scale));
g_object_unref (group);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
g_signal_connect (scale, "value-changed",
G_CALLBACK (jigsaw_scale_entry_update_int),
&config.x);
g_signal_connect_swapped (adj, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
/* ytiles */
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
_("_Vertical:"), SCALE_WIDTH, 0,
config.y, MIN_YTILES, MAX_YTILES, 1.0, 4.0, 0,
TRUE, 0, 0,
_("Number of pieces going down"), NULL);
scale = gimp_scale_entry_new2 (_("_Vertical:"), config.y, MIN_YTILES, MAX_YTILES, 0);
gimp_help_set_help_data (scale, _("Number of pieces going down"), NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1);
gtk_widget_show (scale);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)));
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
g_signal_connect (scale, "value-changed",
G_CALLBACK (jigsaw_scale_entry_update_int),
&config.y);
g_signal_connect_swapped (adj, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
@ -2550,37 +2550,32 @@ jigsaw_dialog (GimpDrawable *drawable)
gtk_container_add (GTK_CONTAINER (frame), grid);
/* number of blending lines */
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("_Bevel width:"), SCALE_WIDTH, 4,
config.blend_lines,
MIN_BLEND_LINES, MAX_BLEND_LINES, 1.0, 2.0, 0,
TRUE, 0, 0,
_("Degree of slope of each piece's edge"), NULL);
scale = gimp_scale_entry_new2 (_("_Bevel width:"), config.blend_lines, MIN_BLEND_LINES, MAX_BLEND_LINES, 0);
gimp_help_set_help_data (scale, _("Degree of slope of each piece's edge"), NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)));
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
g_signal_connect (scale, "value-changed",
G_CALLBACK (jigsaw_scale_entry_update_int),
&config.blend_lines);
g_signal_connect_swapped (adj, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
/* blending amount */
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
_("H_ighlight:"), SCALE_WIDTH, 4,
config.blend_amount,
MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 0.05, 0.1, 2,
TRUE, 0, 0,
_("The amount of highlighting on the edges "
"of each piece"), NULL);
scale = gimp_scale_entry_new2 (_("H_ighlight:"), config.blend_amount, MIN_BLEND_AMOUNT, MAX_BLEND_AMOUNT, 2);
gimp_help_set_help_data (scale, _("The amount of highlighting on the edges of each piece"), NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1);
gtk_widget_show (scale);
gtk_size_group_add_widget (group, GIMP_SCALE_ENTRY_LABEL (adj));
gtk_size_group_add_widget (group, gimp_scale_entry_get_label (GIMP_SCALE_ENTRY (scale)));
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
g_signal_connect (scale, "value-changed",
G_CALLBACK (jigsaw_scale_entry_update_double),
&config.blend_amount);
g_signal_connect_swapped (adj, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
@ -2618,3 +2613,17 @@ jigsaw_dialog (GimpDrawable *drawable)
return run;
}
static void
jigsaw_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value)
{
*value = gimp_scale_entry_get_value (entry);
}
static void
jigsaw_scale_entry_update_int (GimpScaleEntry *entry,
gint *value)
{
*value = (gint) gimp_scale_entry_get_value (entry);
}

181
plug-ins/common/sparkle.c
View File

@ -42,8 +42,6 @@
#define PLUG_IN_BINARY "sparkle"
#define PLUG_IN_ROLE "gimp-sparkle"
#define SCALE_WIDTH 175
#define ENTRY_WIDTH 7
#define MAX_CHANNELS 4
#define PSV 2 /* point spread value */
@ -101,6 +99,9 @@ static GimpValueArray * sparkle_run (GimpProcedure *procedur
gpointer run_data);
static gboolean sparkle_dialog (GimpDrawable *drawable);
static void sparkle_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value);
static gint compute_luminosity (const guchar *pixel,
gboolean gray,
@ -382,16 +383,16 @@ sparkle_run (GimpProcedure *procedure,
static gboolean
sparkle_dialog (GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *grid;
GtkWidget *toggle;
GtkWidget *r1, *r2, *r3;
GtkAdjustment *scale_data;
gboolean run;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *preview;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *grid;
GtkWidget *toggle;
GtkWidget *r1, *r2, *r3;
GtkWidget *scale;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
@ -430,124 +431,106 @@ sparkle_dialog (GimpDrawable *drawable)
gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("Luminosity _threshold:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.lum_threshold, 0.0, 0.1, 0.001, 0.01, 3,
TRUE, 0, 0,
_("Adjust the luminosity threshold"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Luminosity _threshold:"), svals.lum_threshold, 0.0, 0.1, 3);
gimp_help_set_help_data (scale, _("Adjust the luminosity threshold"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.lum_threshold);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 1,
_("F_lare intensity:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.flare_inten, 0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0, 0,
_("Adjust the flare intensity"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("F_lare intensity:"), svals.flare_inten, 0.0, 1.0, 2);
gimp_help_set_help_data (scale, _("Adjust the flare intensity"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.flare_inten);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 1, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 2,
_("_Spike length:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.spike_len, 1, 100, 1, 10, 0,
TRUE, 0, 0,
_("Adjust the spike length"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Spike length:"), svals.spike_len, 1, 100, 0);
gimp_help_set_help_data (scale, _("Adjust the spike length"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.spike_len);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 2, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 3,
_("Sp_ike points:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.spike_pts, 0, 16, 1, 4, 0,
TRUE, 0, 0,
_("Adjust the number of spikes"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Sp_ike points:"), svals.spike_pts, 0, 16, 0);
gimp_help_set_help_data (scale, _("Adjust the number of spikes"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.spike_pts);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 3, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 4,
_("Spi_ke angle (-1: random):"), SCALE_WIDTH, ENTRY_WIDTH,
svals.spike_angle, -1, 360, 1, 15, 0,
TRUE, 0, 0,
_("Adjust the spike angle "
"(-1 causes a random angle to be chosen)"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Spi_ke angle (-1: random):"), svals.spike_angle, -1, 360, 0);
gimp_help_set_help_data (scale, _("Adjust the spike angle "
"(-1 causes a random angle to be chosen)"), NULL);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.spike_angle);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 4, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 5,
_("Spik_e density:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.density, 0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0, 0,
_("Adjust the spike density"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Spik_e density:"), svals.density, 0.0, 1.0, 2);
gimp_help_set_help_data (scale, _("Adjust the spike density"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.density);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 5, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 6,
_("Tr_ansparency:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.transparency, 0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0, 0,
_("Adjust the opacity of the spikes"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Tr_ansparency:"), svals.transparency, 0.0, 1.0, 2);
gimp_help_set_help_data (scale, _("Adjust the opacity of the spikes"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.transparency);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 6, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 7,
_("_Random hue:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.random_hue, 0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0, 0,
_("Adjust how much the hue should be changed randomly"), NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Random hue:"), svals.random_hue, 0.0, 1.0, 2);
gimp_help_set_help_data (scale, _("Adjust how much the hue should be changed randomly"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.random_hue);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 7, 3, 1);
gtk_widget_show (scale);
scale_data =
gimp_scale_entry_new (GTK_GRID (grid), 0, 8,
_("Rando_m saturation:"), SCALE_WIDTH, ENTRY_WIDTH,
svals.random_saturation, 0.0, 1.0, 0.01, 0.1, 2,
TRUE, 0, 0,
_("Adjust how much the saturation should be changed randomly"),
NULL);
g_signal_connect (scale_data, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Rando_m saturation:"), svals.random_saturation, 0.0, 1.0, 2);
gimp_help_set_help_data (scale, _("Adjust how much the saturation should be changed randomly"), NULL);
g_signal_connect (scale, "value-changed",
G_CALLBACK (sparkle_scale_entry_update_double),
&svals.random_saturation);
g_signal_connect_swapped (scale_data, "value-changed",
g_signal_connect_swapped (scale, "value-changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 8, 3, 1);
gtk_widget_show (scale);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
@ -639,6 +622,14 @@ sparkle_dialog (GimpDrawable *drawable)
return run;
}
static void
sparkle_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value)
{
*value = gimp_scale_entry_get_value (entry);
}
static gint
compute_luminosity (const guchar *pixel,
gboolean gray,

44
plug-ins/common/wavelet-decompose.c
View File

@ -29,9 +29,6 @@
#define PLUG_IN_ROLE "gimp-wavelet-decompose"
#define PLUG_IN_BINARY "wavelet-decompose"
#define SCALE_WIDTH 120
#define ENTRY_WIDTH 5
typedef struct
{
@ -72,9 +69,11 @@ static GimpValueArray * wavelet_run (GimpProcedure *procedur
gpointer run_data);
static void wavelet_blur (GimpDrawable *drawable,
gint radius);
gint radius);
static gboolean wavelet_decompose_dialog (void);
static void wavelet_scale_entry_update_int (GimpScaleEntry *entry,
gint *value);
G_DEFINE_TYPE (Wavelet, wavelet, GIMP_TYPE_PLUG_IN)
@ -372,12 +371,11 @@ wavelet_blur (GimpDrawable *drawable,
static gboolean
wavelet_decompose_dialog (void)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *grid;
GtkWidget *button;
GtkAdjustment *adj;
gboolean run;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *button;
GtkWidget *scale;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
@ -403,23 +401,14 @@ wavelet_decompose_dialog (void)
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (main_vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
/* scales */
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("Scales:"), SCALE_WIDTH, ENTRY_WIDTH,
wavelet_params.scales,
1.0, 7.0, 1.0, 1.0, 0,
TRUE, 0, 0,
NULL, NULL);
scale = gimp_scale_entry_new2 (_("Scales:"), wavelet_params.scales, 1.0, 7.0, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), scale, FALSE, FALSE, 6);
gtk_widget_show (scale);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
g_signal_connect (scale, "value-changed",
G_CALLBACK (wavelet_scale_entry_update_int),
&wavelet_params.scales);
/* create group layer */
@ -454,3 +443,10 @@ wavelet_decompose_dialog (void)
return run;
}
static void
wavelet_scale_entry_update_int (GimpScaleEntry *entry,
gint *value)
{
*value = (int) gimp_scale_entry_get_value (entry);
}

425
plug-ins/gradient-flare/gradient-flare.c
View File

@ -85,8 +85,6 @@
#define GM_PREVIEW_WIDTH 80
#define GM_PREVIEW_HEIGHT 16
#define SCALE_WIDTH 80
#ifndef OPAQUE
#define OPAQUE 255
#endif
@ -664,6 +662,10 @@ static void gradient_get_values_real_external (const gchar *gradient_name,
static GradientCacheItem *gradient_cache_lookup (const gchar *name,
gboolean *found);
static void gradient_cache_zorch (void);
static void gradient_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value);
static void gradient_scale_entry_update_int (GimpScaleEntry *entry,
gint *value);
G_DEFINE_TYPE (Gflare, gflare, GIMP_TYPE_PLUG_IN)
@ -2838,16 +2840,16 @@ static void
dlg_make_page_settings (GFlareDialog *dlg,
GtkWidget *notebook)
{
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *center;
GtkWidget *chain;
GtkWidget *grid;
GtkWidget *button;
GtkWidget *asup_grid;
GtkAdjustment *adj;
gdouble xres, yres;
gint row;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *center;
GtkWidget *chain;
GtkWidget *grid;
GtkWidget *button;
GtkWidget *asup_grid;
GtkWidget *scale;
gdouble xres, yres;
gint row;
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
@ -2896,67 +2898,60 @@ dlg_make_page_settings (GFlareDialog *dlg,
row = 0;
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("_Radius:"), SCALE_WIDTH, 6,
pvals.radius, 0.0,
gimp_drawable_width (drawable) / 2,
1.0, 10.0, 1,
FALSE, 0.0, GIMP_MAX_IMAGE_SIZE,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Radius:"), pvals.radius, 0.0, GIMP_MAX_IMAGE_SIZE, 1);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 0.0, gimp_drawable_width (drawable) / 2, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&pvals.radius);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (dlg_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Ro_tation:"), SCALE_WIDTH, 6,
pvals.rotation, -180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Ro_tation:"), pvals.rotation, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&pvals.rotation);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (dlg_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("_Hue rotation:"), SCALE_WIDTH, 6,
pvals.hue, -180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Hue rotation:"), pvals.hue, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&pvals.hue);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (dlg_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Vector _angle:"), SCALE_WIDTH, 6,
pvals.vangle, 0.0, 359.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Vector _angle:"), pvals.vangle, 0.0, 359.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&pvals.vangle);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (dlg_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Vector _length:"), SCALE_WIDTH, 6,
pvals.vlength, 1, 1000, 1.0, 10.0, 1,
FALSE, 1, GIMP_MAX_IMAGE_SIZE,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Vector _length:"), pvals.vlength, 1, GIMP_MAX_IMAGE_SIZE, 1);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1, 1000, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&pvals.vlength);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (dlg_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
/**
*** Asupsample settings
@ -2988,25 +2983,20 @@ dlg_make_page_settings (GFlareDialog *dlg,
asup_grid, "sensitive",
G_BINDING_SYNC_CREATE);
adj = gimp_scale_entry_new (GTK_GRID (asup_grid), 0, 0,
_("_Max depth:"), -1, 4,
pvals.asupsample_max_depth,
1.0, 10.0, 1.0, 1.0, 0,
TRUE, 0.0, 0.0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Max depth:"), pvals.asupsample_max_depth, 1.0, 10.0, 0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_int),
&pvals.asupsample_max_depth);
gtk_grid_attach (GTK_GRID (asup_grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (asup_grid), 0, 1,
_("_Threshold"), -1, 4,
pvals.asupsample_threshold,
0.0, 4.0, 0.01, 0.01, 2,
TRUE, 0.0, 0.0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("_Threshold"), pvals.asupsample_threshold, 0.0, 4.0, 2);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 0.01, 0.1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&pvals.asupsample_threshold);
gtk_grid_attach (GTK_GRID (asup_grid), scale, 0, 1, 3, 1);
gtk_widget_show (scale);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox,
gtk_label_new_with_mnemonic (_("_Settings")));
@ -3574,12 +3564,12 @@ static void
ed_make_page_general (GFlareEditor *ed,
GtkWidget *notebook)
{
GFlare *gflare = ed->gflare;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *combo;
GtkAdjustment *adj;
GFlare *gflare = ed->gflare;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *combo;
GtkWidget *scale;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@ -3596,17 +3586,15 @@ ed_make_page_general (GFlareEditor *ed,
gtk_container_add (GTK_CONTAINER (frame), grid);
gtk_widget_show (grid);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("Opacity:"), SCALE_WIDTH, 6,
gflare->glow_opacity, 0.0, 100.0, 1.0, 10.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Opacity:"), gflare->glow_opacity, 0.0, 100.0, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->glow_opacity);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
combo = ed_mode_menu_new (&gflare->glow_mode);
gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1,
@ -3624,17 +3612,15 @@ ed_make_page_general (GFlareEditor *ed,
gtk_container_add (GTK_CONTAINER (frame), grid);
gtk_widget_show (grid);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("Opacity:"), SCALE_WIDTH, 6,
gflare->rays_opacity, 0.0, 100.0, 1.0, 10.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Opacity:"), gflare->rays_opacity, 0.0, 100.0, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->rays_opacity);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
combo = ed_mode_menu_new (&gflare->rays_mode);
gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1,
@ -3652,17 +3638,15 @@ ed_make_page_general (GFlareEditor *ed,
gtk_container_add (GTK_CONTAINER (frame), grid);
gtk_widget_show (grid);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("Opacity:"), SCALE_WIDTH, 6,
gflare->sflare_opacity, 0.0, 100.0, 1.0, 10.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Opacity:"), gflare->sflare_opacity, 0.0, 100.0, 1);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->sflare_opacity);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, 0, 3, 1);
gtk_widget_show (scale);
combo = ed_mode_menu_new (&gflare->sflare_mode);
gimp_grid_attach_aligned (GTK_GRID (grid), 0, 1,
@ -3680,13 +3664,13 @@ static void
ed_make_page_glow (GFlareEditor *ed,
GtkWidget *notebook)
{
GFlare *gflare = ed->gflare;
GradientMenu *gm;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkAdjustment *adj;
gint row;
GFlare *gflare = ed->gflare;
GradientMenu *gm;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *scale;
gint row;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@ -3733,41 +3717,38 @@ ed_make_page_glow (GFlareEditor *ed,
row = 0;
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Size (%):"), SCALE_WIDTH, 6,
gflare->glow_size, 0.0, 200.0, 1.0, 10.0, 1,
FALSE, 0, G_MAXINT,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Size (%):"), gflare->glow_size, 0.0, G_MAXINT, 1);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 0.0, 200.0, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->glow_size);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Rotation:"), SCALE_WIDTH, 6,
gflare->glow_rotation, -180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Rotation:"), gflare->glow_rotation, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->glow_rotation);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Hue rotation:"), SCALE_WIDTH, 6,
gflare->glow_hue, -180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Hue rotation:"), gflare->glow_hue, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->glow_hue);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
gtk_widget_show (grid);
@ -3783,13 +3764,13 @@ static void
ed_make_page_rays (GFlareEditor *ed,
GtkWidget *notebook)
{
GFlare *gflare = ed->gflare;
GradientMenu *gm;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkAdjustment *adj;
gint row;
GFlare *gflare = ed->gflare;
GradientMenu *gm;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *grid;
GtkWidget *scale;
gint row;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@ -3838,66 +3819,60 @@ ed_make_page_rays (GFlareEditor *ed,
row = 0;
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Size (%):"), SCALE_WIDTH, 6,
gflare->rays_size, 0.0, 200.0, 1.0, 10.0, 1,
FALSE, 0, G_MAXINT,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Size (%):"), gflare->rays_size, 0.0, G_MAXINT, 1);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 0.0, 200.0, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->rays_size);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Rotation:"), SCALE_WIDTH, 6,
gflare->rays_rotation,
-180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Rotation:"), gflare->rays_rotation, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->rays_rotation);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Hue rotation:"), SCALE_WIDTH, 6,
gflare->rays_hue, -180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Hue rotation:"), gflare->rays_hue, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->rays_hue);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("# of Spikes:"), SCALE_WIDTH, 6,
gflare->rays_nspikes, 1, 300, 1.0, 10.0, 0,
FALSE, 0, G_MAXINT,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_int_adjustment_update),
scale = gimp_scale_entry_new2 (_("# of Spikes:"), gflare->rays_nspikes, 1, G_MAXINT, 0);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1.0, 300.0, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_int),
&gflare->rays_nspikes);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Spike thickness:"), SCALE_WIDTH, 6,
gflare->rays_thickness, 1.0, 100.0, 1.0, 10.0, 1,
FALSE, 0, GIMP_MAX_IMAGE_SIZE,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Spike thickness:"), gflare->rays_thickness, 1.0, GIMP_MAX_IMAGE_SIZE, 1);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1.0, 100.0, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->rays_thickness);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
gtk_widget_show (grid);
@ -3913,22 +3888,22 @@ static void
ed_make_page_sflare (GFlareEditor *ed,
GtkWidget *notebook)
{
GFlare *gflare = ed->gflare;
GradientMenu *gm;
GtkWidget *vbox;
GtkWidget *grid;
GtkWidget *frame;
GtkWidget *shape_vbox;
GSList *shape_group = NULL;
GtkWidget *polygon_hbox;
GtkWidget *seed_hbox;
GtkWidget *toggle;
GtkWidget *label;
GtkWidget *seed;
GtkWidget *entry;
GtkAdjustment *adj;
gchar buf[256];
gint row;
GFlare *gflare = ed->gflare;
GradientMenu *gm;
GtkWidget *vbox;
GtkWidget *grid;
GtkWidget *frame;
GtkWidget *shape_vbox;
GSList *shape_group = NULL;
GtkWidget *polygon_hbox;
GtkWidget *seed_hbox;
GtkWidget *toggle;
GtkWidget *label;
GtkWidget *seed;
GtkWidget *entry;
GtkWidget *scale;
gchar buf[256];
gint row;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
@ -3975,42 +3950,38 @@ ed_make_page_sflare (GFlareEditor *ed,
row = 0;
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Size (%):"), SCALE_WIDTH, 6,
gflare->sflare_size, 0.0, 200.0, 1.0, 10.0, 1,
FALSE, 0, G_MAXINT,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Size (%):"), gflare->sflare_size, 0.0, G_MAXINT, 1);
gimp_scale_entry_set_range (GIMP_SCALE_ENTRY (scale), 1.0, 200.0, TRUE);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->sflare_size);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Rotation:"), SCALE_WIDTH, 6,
gflare->sflare_rotation,
-180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Rotation:"), gflare->sflare_rotation, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->sflare_rotation);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, row++,
_("Hue rotation:"), SCALE_WIDTH, 6,
gflare->sflare_hue, -180.0, 180.0, 1.0, 15.0, 1,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_double_adjustment_update),
scale = gimp_scale_entry_new2 (_("Hue rotation:"), gflare->sflare_hue, -180.0, 180.0, 1);
gimp_scale_entry_set_increments (GIMP_SCALE_ENTRY (scale), 1.0, 15.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (gradient_scale_entry_update_double),
&gflare->sflare_hue);
g_signal_connect (adj, "value-changed",
g_signal_connect (scale, "value-changed",
G_CALLBACK (ed_preview_update),
NULL);
gtk_grid_attach (GTK_GRID (grid), scale, 0, row++, 3, 1);
gtk_widget_show (scale);
gtk_widget_show (grid);
@ -5164,6 +5135,20 @@ gradient_cache_zorch (void)
}
}
static void
gradient_scale_entry_update_double (GimpScaleEntry *entry,
gdouble *value)
{
*value = gimp_scale_entry_get_value (entry);
}
static void
gradient_scale_entry_update_int (GimpScaleEntry *entry,
gint *value)
{
*value = (gint) gimp_scale_entry_get_value (entry);
}
#ifdef DEBUG
void
gradient_report (void)

30
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 (GtkAdjustment *adj,
static void distance_update (GimpScaleEntry *scale,
gpointer data);
static gboolean bumpmap_constrain (GimpImage *image,
@ -116,10 +116,10 @@ toggle_update (GtkWidget *widget,
static void
distance_update (GtkAdjustment *adj,
gpointer data)
distance_update (GimpScaleEntry *scale,
gpointer data)
{
mapvals.viewpoint.z = gtk_adjustment_get_value (adj);
mapvals.viewpoint.z = gimp_scale_entry_get_value (scale);
preview_compute ();
gtk_widget_queue_draw (previewarea);
@ -301,8 +301,7 @@ create_options_page (void)
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *toggle;
GtkWidget *grid;
GtkAdjustment *adj;
GtkWidget *scale;
page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (page), 12);
@ -354,20 +353,15 @@ create_options_page (void)
gimp_help_set_help_data (toggle,
_("Enable/disable high quality preview"), NULL);
grid = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 12);
gtk_widget_show (grid);
adj = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("Distance:"), 100, 6,
mapvals.viewpoint.z,
0.0, 2.0, 0.01, 0.05,
3, TRUE, 0.0, 0.0,
"Distance of observer from surface",
"plug-in-lighting");
g_signal_connect (adj, "value-changed",
scale = gimp_scale_entry_new2 (_("Distance:"), mapvals.viewpoint.z, 0.0, 2.0, 3);
gimp_help_set_help_data (scale,
"Distance of observer from surface",
"plug-in-lighting");
g_signal_connect (scale, "value-changed",
G_CALLBACK (distance_update),
NULL);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 12);
gtk_widget_show (scale);
gtk_widget_show (page);

44
plug-ins/pagecurl/pagecurl.c
View File

@ -133,8 +133,8 @@ static GimpValueArray * pagecurl_run (GimpProcedure *procedu
const GimpValueArray *args,
gpointer run_data);
static void dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value);
static void dialog_scale_update (GimpScaleEntry *adjustment,
gdouble *value);
static gboolean dialog (void);
@ -414,10 +414,10 @@ inside_circle (gdouble x,
/********************************************************************/
static void
dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value)
dialog_scale_update (GimpScaleEntry *scale,
gdouble *value)
{
*value = ((gdouble) gtk_adjustment_get_value (adjustment)) / 100.0;
*value = ((gdouble) gimp_scale_entry_get_value (scale)) / 100.0;
}
static void
@ -454,15 +454,15 @@ dialog (void)
/* Missing options: Color-dialogs? / own curl layer ? / transparency
to original drawable / Warp-curl (unsupported yet) */
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *grid;
GtkWidget *frame;
GtkWidget *button;
GtkWidget *combo;
GtkAdjustment *adjustment;
gboolean run;
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *grid;
GtkWidget *frame;
GtkWidget *button;
GtkWidget *combo;
GtkWidget *scale;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY);
@ -662,20 +662,12 @@ dialog (void)
G_CALLBACK (gimp_int_combo_box_get_active),
&curl.colors, NULL);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, FALSE, FALSE, 0);
gtk_widget_show (grid);
adjustment = gimp_scale_entry_new (GTK_GRID (grid), 0, 0,
_("_Opacity:"), 100, 0,
curl.opacity * 100.0, 0.0, 100.0,
1.0, 1.0, 0.0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adjustment, "value-changed",
scale = gimp_scale_entry_new2 (_("_Opacity:"), curl.opacity * 100.0, 0.0, 100.0, 0.0);
g_signal_connect (scale, "value-changed",
G_CALLBACK (dialog_scale_update),
&curl.opacity);
gtk_box_pack_start (GTK_BOX (vbox), scale, FALSE, FALSE, 6);
gtk_widget_show (scale);
gtk_widget_show (dialog);