graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-19 22:34:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

plug-ins/common/plugin-defs.pl plug-ins/common/Makefile.am

Browse source 
2000-01-08  Michael Natterer  <mitch@gimp.org>

	* plug-ins/common/plugin-defs.pl
	* plug-ins/common/Makefile.am
	* plug-ins/common/engrave.c
	* plug-ins/common/flarefx.c
	* plug-ins/common/gbr.c
	* plug-ins/common/gicon.c
	* plug-ins/common/glasstile.c
	* plug-ins/common/mail.c
	* plug-ins/common/psd.c
	* plug-ins/common/smooth_palette.c
	* plug-ins/common/tga.c
	* plug-ins/common/threshold_alpha.c
	* plug-ins/common/tiff.c
	* plug-ins/common/tile.c
	* plug-ins/common/tileit.c
	* plug-ins/common/video.c
	* plug-ins/common/vpropagate.c
	* plug-ins/common/warp.c
	* plug-ins/common/waves.c
	* plug-ins/common/whirlpinch.c
	* plug-ins/common/wind.c
	* plug-ins/common/wmf.c: more plugin tuning... and this time I
	added the needed libs in plugin-defs.pl instead of Makefile.am :-)
This commit is contained in:
Michael Natterer 2000-01-08 20:00:10 +00:00 committed by Michael Natterer
parent c0ce01da0e
commit 7439bd6720
23 changed files with 2336 additions and 2655 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
ChangeLog
View file

@ -1,3 +1,29 @@
2000-01-08 Michael Natterer <mitch@gimp.org>
* plug-ins/common/plugin-defs.pl
* plug-ins/common/Makefile.am
* plug-ins/common/engrave.c
* plug-ins/common/flarefx.c
* plug-ins/common/gbr.c
* plug-ins/common/gicon.c
* plug-ins/common/glasstile.c
* plug-ins/common/mail.c
* plug-ins/common/psd.c
* plug-ins/common/smooth_palette.c
* plug-ins/common/tga.c
* plug-ins/common/threshold_alpha.c
* plug-ins/common/tiff.c
* plug-ins/common/tile.c
* plug-ins/common/tileit.c
* plug-ins/common/video.c
* plug-ins/common/vpropagate.c
* plug-ins/common/warp.c
* plug-ins/common/waves.c
* plug-ins/common/whirlpinch.c
* plug-ins/common/wind.c
* plug-ins/common/wmf.c: more plugin tuning... and this time I
added the needed libs in plugin-defs.pl instead of Makefile.am :-)
2000-01-08 Asbjorn Pettersen <asbjornP@dualog.no>
* modules/modregister.h: add types for GimpColorDisplayxxxxx

12
plug-ins/common/Makefile.am
View file

@ -292,6 +292,7 @@ color_enhance_SOURCES = \
color_enhance.c
color_enhance_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -580,6 +581,7 @@ gradmap_SOURCES = \
gradmap.c
gradmap_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GLIB_LIBS) \
$(INTLLIBS)
@ -687,6 +689,7 @@ laplace_SOURCES = \
laplace.c
laplace_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GLIB_LIBS) \
$(INTLLIBS)
@ -1082,6 +1085,7 @@ threshold_alpha_SOURCES = \
threshold_alpha.c
threshold_alpha_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1100,6 +1104,7 @@ tile_SOURCES = \
tile.c
tile_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1108,6 +1113,7 @@ tileit_SOURCES = \
tileit.c
tileit_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1132,6 +1138,7 @@ video_SOURCES = \
video.c
video_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1148,6 +1155,7 @@ vpropagate_SOURCES = \
vpropagate.c
vpropagate_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1166,6 +1174,7 @@ waves_SOURCES = \
waves_LDADD = \
$(top_builddir)/plug-ins/megawidget/libmegawidget.a \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1174,6 +1183,7 @@ whirlpinch_SOURCES = \
whirlpinch.c
whirlpinch_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1182,6 +1192,7 @@ wind_SOURCES = \
wind.c
wind_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)
@ -1190,6 +1201,7 @@ wmf_SOURCES = \
wmf.c
wmf_LDADD = \
$(top_builddir)/libgimp/libgimpui.la \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS) \
$(INTLLIBS)

89
plug-ins/common/engrave.c
View file

@ -217,8 +217,6 @@ engrave_dialog (void)
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *toggle;
gchar **argv;
gint argc;
@ -249,21 +247,24 @@ engrave_dialog (void)
/* parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (2, 3, FALSE);
gtk_container_set_border_width (GTK_CONTAINER(table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
toggle = gtk_check_button_new_with_label (_("Limit line width"));
gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 0, 1, GTK_FILL, 0, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 3, 0, 1, GTK_FILL, 0, 0, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (engrave_toggle_update),
&pvals.limit);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), pvals.limit);
gtk_widget_show (toggle);
dialog_create_value (_("Height"), GTK_TABLE (table), 1,
dialog_create_value (_("Height:"), GTK_TABLE (table), 1,
&pvals.height, 2.0, 16.0);
gtk_widget_show (frame);
@ -558,47 +559,53 @@ engrave_toggle_update (GtkWidget *widget,
* Thanks to Quartic for these.
*/
static void
dialog_create_value(char *title, GtkTable *table, int row, gint *value, int left, int right)
dialog_create_value (char *title,
GtkTable *table,
int row,
gint *value,
int left,
int right)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *entry;
GtkObject *scale_data;
char buf[256];
GtkWidget *label;
GtkWidget *scale;
GtkWidget *entry;
GtkObject *scale_data;
gchar buf[256];
label = gtk_label_new(title);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(table, label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 4, 0);
gtk_widget_show(label);
label = gtk_label_new (title);
gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5);
gtk_table_attach(table, label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show(label);
scale_data = gtk_adjustment_new(*value, left, right,
1.0,
1.0,
0.0);
scale_data = gtk_adjustment_new(*value, left, right,
1.0,
1.0,
0.0);
gtk_signal_connect(GTK_OBJECT(scale_data), "value_changed",
(GtkSignalFunc) engrave_scale_update,
value);
gtk_signal_connect(GTK_OBJECT(scale_data), "value_changed",
(GtkSignalFunc) engrave_scale_update,
value);
scale = gtk_hscale_new(GTK_ADJUSTMENT(scale_data));
gtk_widget_set_usize(scale, SCALE_WIDTH, 0);
gtk_table_attach(table, scale, 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
gtk_scale_set_digits(GTK_SCALE(scale), 0);
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS);
gtk_widget_show(scale);
scale = gtk_hscale_new(GTK_ADJUSTMENT(scale_data));
gtk_widget_set_usize(scale, SCALE_WIDTH, 0);
gtk_table_attach(table, scale, 1, 2, row, row + 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS);
gtk_widget_show(scale);
entry = gtk_entry_new();
gtk_object_set_user_data(GTK_OBJECT(entry), scale_data);
gtk_object_set_user_data(scale_data, entry);
gtk_widget_set_usize(entry, ENTRY_WIDTH, 0);
sprintf(buf, "%d", *value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) engrave_entry_update,
value);
gtk_table_attach(GTK_TABLE(table), entry, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, 4, 0);
gtk_widget_show(entry);
entry = gtk_entry_new();
gtk_object_set_user_data(GTK_OBJECT(entry), scale_data);
gtk_object_set_user_data(scale_data, entry);
gtk_widget_set_usize(entry, ENTRY_WIDTH, 0);
g_snprintf (buf, sizeof (buf), "%d", *value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) engrave_entry_update,
value);
gtk_table_attach (GTK_TABLE (table), entry, 2, 3, row, row + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (entry);
}
static void

20
plug-ins/common/flarefx.c
View file

@ -296,8 +296,6 @@ flare_dialog (GDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *hbbox;
GtkWidget *button;
guchar *color_cube;
gchar **argv;
gint argc;
@ -343,7 +341,7 @@ flare_dialog (GDrawable *drawable)
/* parameter settings */
frame = flare_center_create (drawable);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
@ -730,18 +728,18 @@ flare_center_create (GDrawable *drawable)
(GtkSignalFunc) flare_center_destroy,
center );
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
table = gtk_table_new (2, 4, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_set_row_spacings (GTK_TABLE (table), 3);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
label = gtk_label_new (_("X: "));
label = gtk_label_new (_("X:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5 );
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
center->xentry = entry = gtk_entry_new ();
@ -754,10 +752,10 @@ flare_center_create (GDrawable *drawable)
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (entry);
label = gtk_label_new (_("Y: "));
label = gtk_label_new (_("Y:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5 );
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
center->yentry = entry = gtk_entry_new ();

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

@ -438,8 +438,6 @@ static gint
save_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *table;
@ -463,18 +461,18 @@ save_dialog (void)
/* The main table */
table = gtk_table_new (2, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 10);
gtk_container_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
/**********************
* label
**********************/
label = gtk_label_new (_("Spacing:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
@ -497,7 +495,7 @@ save_dialog (void)
* label
**********************/
label = gtk_label_new (_("Description:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);

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

@ -427,8 +427,6 @@ static gint
save_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *table;
@ -451,18 +449,18 @@ save_dialog (void)
/* The main table */
table = gtk_table_new (1, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 10);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
gtk_table_set_row_spacings (GTK_TABLE (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 10);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
/**********************
* label
**********************/
label = gtk_label_new (_("Icon Name:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);

25
plug-ins/common/glasstile.c
View file

@ -212,8 +212,6 @@ glass_dialog (void)
{
GtkWidget *dlg;
GtkWidget *label;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *scale;
GtkWidget *frame;
GtkWidget *table;
@ -247,16 +245,20 @@ glass_dialog (void)
/* Parameter settings */
frame = gtk_frame_new (_("Parameter Settings"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_container_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (2, 2, FALSE); /* table height, width */
gtk_container_border_width (GTK_CONTAINER (table), 10);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
/* Horizontal scale - Width */
label = gtk_label_new (_("Tile Width"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 5, 0);
label = gtk_label_new (_("Tile Width:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
/* xStart, xEnd, yStart, yEnd */
adjustment = gtk_adjustment_new (gtvals.xblock, 10, 50, 1, 1, 0);
@ -274,9 +276,10 @@ glass_dialog (void)
gtk_widget_show (scale);
/* Horizontal scale - Height */
label = gtk_label_new (_("Tile Height"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, 0, 5, 0);
label = gtk_label_new (_("Tile Height:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
adjustment = gtk_adjustment_new (gtvals.yblock, 10, 50, 1, 1, 0);
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",

22
plug-ins/common/mail.c
View file

@ -120,8 +120,8 @@
#include <gtk/gtk.h>
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
@ -460,10 +460,10 @@ save_dialog (void)
GtkWidget *vscrollbar;
GSList *group;
gint argc;
gint argc;
gchar **argv;
gchar buffer[32];
gint nreturn_vals;
gchar buffer[32];
gint nreturn_vals;
GParam *return_vals;
argc = 1;
@ -513,7 +513,7 @@ save_dialog (void)
/* To: Label */
label = gtk_label_new ("To:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 0, 1,
GTK_SHRINK | GTK_FILL,
@ -538,7 +538,7 @@ save_dialog (void)
/* From Label */
label = gtk_label_new ("From:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 1, 2,
GTK_SHRINK | GTK_FILL,
@ -564,7 +564,7 @@ save_dialog (void)
/* Subject Label */
label = gtk_label_new ("Subject:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 2, 3,
GTK_SHRINK | GTK_FILL,
@ -589,7 +589,7 @@ save_dialog (void)
/* Comment label */
label = gtk_label_new ("Comment:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 3, 4,
GTK_SHRINK | GTK_FILL,
@ -614,7 +614,7 @@ save_dialog (void)
/* Filename label */
label = gtk_label_new (_("Filename:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
0, 1, 4, 5,
GTK_SHRINK | GTK_FILL,
@ -669,7 +669,7 @@ save_dialog (void)
/* Encapsulation label */
label = gtk_label_new (_("Encapsulation:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach( GTK_TABLE (table), label ,
0, 1, 6, 7,
GTK_SHRINK | GTK_FILL,

136
plug-ins/common/plugin-defs.pl
View file

@ -1,121 +1,121 @@
%plugins = (
'CEL' => { libdep => 'gtk' },
'CML_explorer' => { libdep => 'gtk' },
'CEL' => { libdep => 'gtk', ui => 1 },
'CML_explorer' => { libdep => 'gtk', ui => 1 },
'aa' => { libdep => 'gtk', ui => 1, optional => 1 },
'align_layers' => { libdep => 'gtk' },
'animationplay' => { libdep => 'gtk' },
'align_layers' => { libdep => 'gtk', ui => 1 },
'animationplay' => { libdep => 'gtk', ui => 1 },
'animoptimize' => { libdep => 'glib' },
'apply_lens' => { libdep => 'gtk' },
'apply_lens' => { libdep => 'gtk', ui => 1 },
'autocrop' => { libdep => 'glib' },
'autostretch_hsv' => { libdep => 'glib' },
'blinds' => { libdep => 'gtk' },
'blur' => { libdep => 'gtk', libsupp => 'gpc' },
'blinds' => { libdep => 'gtk', ui => 1 },
'blur' => { libdep => 'gtk', ui => 1, libsupp => 'gpc' },
'bumpmap' => { libdep => 'gtk', ui => 1 },
'bz2' => { libdep => 'glib' },
'c_astretch' => { libdep => 'glib' },
'checkerboard' => { libdep => 'gtk' },
'checkerboard' => { libdep => 'gtk', ui => 1 },
'color_enhance' => { libdep => 'gtk', ui => 1 },
'colortoalpha' => { libdep => 'gtk', ui => 1 },
'colorify' => { libdep => 'gtk' },
'colorify' => { libdep => 'gtk', ui => 1 },
'compose' => { libdep => 'gtk', ui => 1 },
'convmatrix' => { libdep => 'gtk' },
'convmatrix' => { libdep => 'gtk', ui => 1 },
'csource' => { libdep => 'gtk', ui => 1 },
'cubism' => { libdep => 'gtk' },
'curve_bend' => { libdep => 'gtk' },
'decompose' => { libdep => 'gtk' },
'deinterlace' => { libdep => 'gtk', libsupp => 'megawidget' },
'cubism' => { libdep => 'gtk', ui => 1 },
'curve_bend' => { libdep => 'gtk', ui => 1 },
'decompose' => { libdep => 'gtk', ui => 1 },
'deinterlace' => { libdep => 'gtk', ui => 1, libsupp => 'megawidget' },
'depthmerge' => { libdep => 'gtk', ui => 1 },
'despeckle' => { libdep => 'gtk' },
'destripe' => { libdep => 'gtk' },
'diffraction' => { libdep => 'gtk' },
'despeckle' => { libdep => 'gtk', ui => 1 },
'destripe' => { libdep => 'gtk', ui => 1 },
'diffraction' => { libdep => 'gtk', ui => 1 },
'displace' => { libdep => 'gtk', ui => 1 },
'edge' => { libdep => 'gtk' },
'emboss' => { libdep => 'gtk', libsupp => 'megawidget' },
'engrave' => { libdep => 'gtk' },
'exchange' => { libdep => 'gtk' },
'edge' => { libdep => 'gtk', ui => 1 },
'emboss' => { libdep => 'gtk', ui => 1, libsupp => 'megawidget' },
'engrave' => { libdep => 'gtk', ui => 1 },
'exchange' => { libdep => 'gtk', ui => 1 },
'film' => { libdep => 'gtk', ui => 1 },
'flarefx' => { libdep => 'gtk' },
'fractaltrace' => { libdep => 'gtk' },
'gauss_iir' => { libdep => 'gtk' },
'gauss_rle' => { libdep => 'gtk' },
'flarefx' => { libdep => 'gtk', ui => 1 },
'fractaltrace' => { libdep => 'gtk', ui => 1 },
'gauss_iir' => { libdep => 'gtk', ui => 1 },
'gauss_rle' => { libdep => 'gtk', ui => 1 },
'gbr' => { libdep => 'gtk', ui => 1 },
'gpb' => { libdep => 'gtk', ui => 1 },
'gee' => { libdep => 'gtk' },
'gee' => { libdep => 'gtk', ui => 1 },
'gicon' => { libdep => 'gtk', ui => 1 },
'gif' => { libdep => 'gtk', ui => 1 },
'gifload' => { libdep => 'gtk' },
'glasstile' => { libdep => 'gtk' },
'gqbist' => { libdep => 'gtk' },
'gradmap' => { libdep => 'glib' },
'glasstile' => { libdep => 'gtk', ui => 1 },
'gqbist' => { libdep => 'gtk', ui => 1 },
'gradmap' => { libdep => 'glib', ui => 1 },
'grid' => { libdep => 'gtk', ui => 1 },
'gtm' => { libdep => 'gtk' },
'gtm' => { libdep => 'gtk', ui => 1 },
'guillotine' => { libdep => 'glib' },
'gz' => { libdep => 'glib' },
'header' => { libdep => 'gtk', ui => 1 },
'hot' => { libdep => 'gtk', libsupp => 'megawidget' },
'hot' => { libdep => 'gtk', ui => 1, libsupp => 'megawidget' },
'hrz' => { libdep => 'gtk', ui => 1 },
'illusion' => { libdep => 'gtk' },
'iwarp' => { libdep => 'gtk' },
'jigsaw' => { libdep => 'gtk' },
'illusion' => { libdep => 'gtk', ui => 1 },
'iwarp' => { libdep => 'gtk', ui => 1 },
'jigsaw' => { libdep => 'gtk', ui => 1 },
'jpeg' => { libdep => 'gtk', ui => 1, optional => 1 },
'laplace' => { libdep => 'glib' },
'laplace' => { libdep => 'glib', ui => 1 },
'lic' => { libdep => 'gtk', ui => 1 },
'mail' => { libdep => 'gtk' },
'mail' => { libdep => 'gtk', ui => 1 },
'mapcolor' => { libdep => 'gtk', ui => 1 },
'max_rgb' => { libdep => 'gtk' },
'mblur' => { libdep => 'gtk' },
'max_rgb' => { libdep => 'gtk', ui => 1 },
'mblur' => { libdep => 'gtk', ui => 1 },
'mpeg' => { libdep => 'gtk', optional => 1 },
'newsprint' => { libdep => 'gtk' },
'nlfilt' => { libdep => 'gtk', libsupp => 'megawidget' },
'noisify' => { libdep => 'gtk' },
'newsprint' => { libdep => 'gtk', ui => 1 },
'nlfilt' => { libdep => 'gtk', ui => 1, libsupp => 'megawidget' },
'noisify' => { libdep => 'gtk', ui => 1 },
'normalize' => { libdep => 'glib' },
'nova' => { libdep => 'gtk', ui => 1 },
'oilify' => { libdep => 'gtk' },
'oilify' => { libdep => 'gtk', ui => 1 },
'papertile' => { libdep => 'gtk', ui => 1 },
'pat' => { libdep => 'gtk', ui => 1 },
'pcx' => { libdep => 'gtk', ui => 1 },
'pix' => { libdep => 'gtk', ui => 1 },
'pixelize' => { libdep => 'gtk' },
'plasma' => { libdep => 'gtk' },
'plugindetails' => { libdep => 'gtk' },
'pixelize' => { libdep => 'gtk', ui => 1 },
'plasma' => { libdep => 'gtk', ui => 1 },
'plugindetails' => { libdep => 'gtk', ui => 1 },
'png' => { libdep => 'gtk', ui => 1, optional => 1 },
'pnm' => { libdep => 'gtk', ui => 1 },
'polar' => { libdep => 'gtk' },
'polar' => { libdep => 'gtk', ui => 1 },
'ps' => { libdep => 'gtk', ui => 1 },
'psd' => { libdep => 'glib' },
'psp' => { libdep => 'gtk', ui => 1, optional => 1, libopt => 'z' },
'randomize' => { libdep => 'gtk', libsupp => 'gpc' },
'ripple' => { libdep => 'gtk' },
'randomize' => { libdep => 'gtk', libsupp => 'gpc', ui => 1 },
'ripple' => { libdep => 'gtk', ui => 1 },
'rotate' => { libdep => 'glib' },
'sample_colorize' => { libdep => 'gtk', ui => 1 },
'scatter_hsv' => { libdep => 'gtk' },
'screenshot' => { libdep => 'gtk' },
'sel_gauss' => { libdep => 'gtk' },
'scatter_hsv' => { libdep => 'gtk', ui => 1 },
'screenshot' => { libdep => 'gtk', ui => 1 },
'sel_gauss' => { libdep => 'gtk', ui => 1 },
'semiflatten' => { libdep => 'glib' },
'sharpen' => { libdep => 'gtk' },
'shift' => { libdep => 'gtk' },
'smooth_palette' => { libdep => 'gtk' },
'snoise' => { libdep => 'gtk' },
'sobel' => { libdep => 'gtk' },
'sparkle' => { libdep => 'gtk' },
'spheredesigner' => { libdep => 'gtk' },
'spread' => { libdep => 'gtk' },
'sharpen' => { libdep => 'gtk', ui => 1 },
'shift' => { libdep => 'gtk', ui => 1 },
'smooth_palette' => { libdep => 'gtk', ui => 1 },
'snoise' => { libdep => 'gtk', ui => 1 },
'sobel' => { libdep => 'gtk', ui => 1 },
'sparkle' => { libdep => 'gtk', ui => 1 },
'spheredesigner' => { libdep => 'gtk', ui => 1 },
'spread' => { libdep => 'gtk', ui => 1 },
'sunras' => { libdep => 'gtk', ui => 1 },
'tga' => { libdep => 'gtk', ui => 1 },
'threshold_alpha' => { libdep => 'gtk' },
'threshold_alpha' => { libdep => 'gtk', ui => 1 },
'tiff' => { libdep => 'gtk', ui => 1, optional => 1 },
'tile' => { libdep => 'gtk' },
'tileit' => { libdep => 'gtk' },
'tile' => { libdep => 'gtk', ui => 1 },
'tileit' => { libdep => 'gtk', ui => 1 },
'tiler' => { libdep => 'glib' },
'url' => { libdep => 'glib' },
'video' => { libdep => 'gtk' },
'video' => { libdep => 'gtk', ui => 1 },
'vinvert' => { libdep => 'glib' },
'vpropagate' => { libdep => 'gtk' },
'vpropagate' => { libdep => 'gtk', ui => 1 },
'warp' => { libdep => 'gtk', ui => 1 },
'waves' => { libdep => 'gtk', libsupp => 'megawidget' },
'whirlpinch' => { libdep => 'gtk' },
'wind' => { libdep => 'gtk' },
'wmf' => { libdep => 'gtk' },
'waves' => { libdep => 'gtk', ui => 1, libsupp => 'megawidget' },
'whirlpinch' => { libdep => 'gtk', ui => 1 },
'wind' => { libdep => 'gtk', ui => 1 },
'wmf' => { libdep => 'gtk', ui => 1 },
'xbm' => { libdep => 'gtk', ui => 1 },
'xpm' => { libdep => 'gtk', ui => 1, optional => 1 },
'xwd' => { libdep => 'gtk', ui => 1 },

13
plug-ins/common/psd.c
View file

@ -1628,7 +1628,6 @@ load_image(char *name)
gboolean want_aux;
char *name_buf;
guchar *cmykbuf;
static int number = 1;
guchar *dest, *temp;
long channels, nguchars;
psd_imagetype imagetype;
@ -1640,10 +1639,8 @@ load_image(char *name)
gint32 iter;
fpos_t tmpfpos;
IFDBG printf("------- %s ---------------------------------\n",name);
name_buf = g_strdup_printf( _("Loading %s:"), name);
gimp_progress_init(name_buf);
@ -1654,17 +1651,8 @@ load_image(char *name)
return(-1);
}
read_whole_file(fd);
if (psd_image.num_layers > 0) /* PS3-style */
{
int lnum;
@ -1927,7 +1915,6 @@ load_image(char *name)
}
if (want_aux || (psd_image.num_layers==0)) /* Photoshop2-style: NO LAYERS. */
{

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

@ -395,7 +395,7 @@ callback (GtkWidget *widget,
}
else
{
g_print (stderr, "bad data in callback: %x\n", (int) data);
fprintf (stderr, "bad data in callback: %x\n", (int) data);
}
}

77
plug-ins/common/tga.c
View file

@ -80,9 +80,11 @@
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <gtk/gtk.h>
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
/* Round up a division to the nearest integer. */
#define ROUNDUP_DIVIDE(n,d) (((n) + (d - 1)) / (d))
@ -176,8 +178,6 @@ static gint save_image (char *filename,
static void init_gtk (void);
static gint save_dialog (void);
static void save_close_callback (GtkWidget *widget,
gpointer data);
static void save_ok_callback (GtkWidget *widget,
gpointer data);
static void save_toggle_update (GtkWidget *widget,
@ -1427,59 +1427,41 @@ init_gtk ()
}
static gint
save_dialog ()
save_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), "Save as Tga");
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
dlg = gimp_dialog_new ("Save as TGA", "tga",
gimp_plugin_help_func, "filters/tga.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", save_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) save_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) save_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* regular tga parameter settings */
frame = gtk_frame_new ("Targa Options");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_container_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 5);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
/* rle */
toggle = gtk_check_button_new_with_label ("RLE compression");
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) save_toggle_update,
&tsvals.rle);
@ -1499,13 +1481,6 @@ save_dialog ()
/* Save interface functions */
static void
save_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
save_ok_callback (GtkWidget *widget,
gpointer data)
@ -1527,11 +1502,3 @@ save_toggle_update (GtkWidget *widget,
else
*toggle_val = FALSE;
}
/* The End */
/*
Local Variables:
compile-command:"gcc -Wall -g -O -o tga tga.c -lgimp -lgtk -lgdk -lglib -lm"
End:
*/

171
plug-ins/common/threshold_alpha.c
View file

@ -22,14 +22,18 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <math.h>
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gtk/gtk.h"
#include "config.h"
#include "libgimp/gimp.h"
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimpmath.h>
#include "libgimp/stdplugins-intl.h"
/* Replace them with the right ones */
@ -52,9 +56,7 @@ static void run (char *name,
static GStatusType MAIN_FUNCTION ();
static gint DIALOG ();
static void ERROR_DIALOG (gint gtk_was_not_initialized, gchar *message);
static void
OK_CALLBACK (GtkWidget *widget, gpointer data);
static void OK_CALLBACK (GtkWidget *widget, gpointer data);
/* gtkWrapper functions */
#define PROGRESS_UPDATE_NUM 100
@ -66,8 +68,6 @@ gtkW_gint_update (GtkWidget *widget, gpointer data);
static void
gtkW_scale_update (GtkAdjustment *adjustment, double *data);
*/
static void
gtkW_close_callback (GtkWidget *widget, gpointer data);
/*
static void
gtkW_toggle_update (GtkWidget *widget, gpointer data);
@ -78,12 +78,6 @@ gtkW_iscale_update (GtkAdjustment *adjustment,
static void
gtkW_ientry_update (GtkWidget *widget,
gpointer data);
static GtkWidget *
gtkW_dialog_new (char *name,
GtkSignalFunc ok_callback,
GtkSignalFunc close_callback);
static GtkWidget *
gtkW_error_dialog_new (char * name);
/*
static void
gtkW_table_add_toggle (GtkWidget *table,
@ -332,26 +326,37 @@ static int
DIALOG ()
{
GtkWidget *dlg;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
gchar **argv;
gint argc;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("threshold_alpha");
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup (PLUG_IN_NAME);
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
dlg = gtkW_dialog_new (PLUG_IN_NAME,
(GtkSignalFunc) OK_CALLBACK,
(GtkSignalFunc) gtkW_close_callback);
hbox = gtkW_hbox_new ((GTK_DIALOG (dlg)->vbox));
frame = gtkW_frame_new (hbox, _("Parameter Settings"));
table = gtkW_table_new (frame, 2, 2);
gtkW_table_add_iscale_entry (table, _("Threshold"), 0, 0,
dlg = gimp_dialog_new (_("Threshold Alpha"), "threshold_alpha",
gimp_plugin_help_func, "filters/threshold_alpha.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), OK_CALLBACK,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
frame = gtkW_frame_new (GTK_DIALOG (dlg)->vbox, _("Parameter Settings"));
table = gtkW_table_new (frame, 1, 2);
gtkW_table_add_iscale_entry (table, _("Threshold:"), 0, 0,
(GtkSignalFunc) gtkW_iscale_update,
(GtkSignalFunc) gtkW_ientry_update,
&VALS.threshold,
@ -382,10 +387,18 @@ ERROR_DIALOG (gint gtk_was_not_initialized, gchar *message)
gtk_rc_parse (gimp_gtkrc ());
}
dlg = gtkW_error_dialog_new (PLUG_IN_NAME);
dlg = gimp_dialog_new (_("Threshold Aplha"), "threshold_alpha",
gimp_plugin_help_func, "filters/threshold_alpha.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), gtk_main_quit,
NULL, NULL, NULL, TRUE, TRUE,
NULL);
table = gtk_table_new (1,1, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 10);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, TRUE, TRUE, 0);
label = gtk_label_new (message);
@ -426,13 +439,6 @@ gtkW_scale_update (GtkAdjustment *adjustment,
}
*/
static void
gtkW_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
/*
static void
gtkW_toggle_update (GtkWidget *widget,
@ -449,79 +455,14 @@ gtkW_toggle_update (GtkWidget *widget,
}
*/
/* gtkW is the abbreviation of gtk Wrapper */
static GtkWidget *
gtkW_dialog_new (char * name,
GtkSignalFunc ok_callback,
GtkSignalFunc close_callback)
{
GtkWidget *dlg, *button, *hbbox;
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), name);
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) close_callback, NULL);
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
return dlg;
}
static GtkWidget *
gtkW_error_dialog_new (char * name)
{
GtkWidget *dlg, *button;
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), name);
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) gtkW_close_callback, NULL);
/* Action Area */
button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtkW_close_callback, dlg);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
return dlg;
}
GtkWidget *
gtkW_table_new (GtkWidget *parent, gint col, gint row)
{
GtkWidget *table;
table = gtk_table_new (col,row, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 10);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (parent), table);
gtk_widget_show (table);
@ -531,10 +472,10 @@ gtkW_table_new (GtkWidget *parent, gint col, gint row)
GtkWidget *
gtkW_hbox_new (GtkWidget *parent)
{
GtkWidget *hbox;
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (hbox), 5);
GtkWidget *hbox;
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (parent), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
@ -581,7 +522,7 @@ gtkW_frame_new (GtkWidget *parent,
frame = gtk_frame_new (name);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 5);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX(parent), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
return frame;
@ -715,12 +656,12 @@ gtkW_table_add_iscale_entry (GtkWidget *table,
GtkWidget *label, *hbox, *scale, *entry;
label = gtk_label_new (name);
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC(label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE(table), label, x, x+1, y, y+1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 5, 0);
GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 5);
hbox = gtk_hbox_new (FALSE, 4);
gtk_table_attach (GTK_TABLE (table), hbox, x+1, x+2, y, y+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
@ -730,9 +671,7 @@ gtkW_table_add_iscale_entry (GtkWidget *table,
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
gtk_widget_set_usize (scale, SCALE_WIDTH, 0);
gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
(GtkSignalFunc) scale_update, value);

93
plug-ins/common/tiff.c
View file

@ -34,8 +34,9 @@
#include <stdlib.h>
#include <string.h>
#include <tiffio.h>
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
typedef struct
{
@ -99,8 +100,6 @@ static gint save_image (char *filename,
static void init_gtk ();
static gint save_dialog ();
static void save_close_callback (GtkWidget *widget,
gpointer data);
static void save_ok_callback (GtkWidget *widget,
gpointer data);
static void save_toggle_update (GtkWidget *widget,
@ -1368,7 +1367,7 @@ static gint save_image (char *filename,
}
static void
init_gtk ()
init_gtk (void)
{
gchar **argv;
gint argc;
@ -1382,11 +1381,9 @@ init_gtk ()
}
static gint
save_dialog ()
save_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *toggle_vbox;
@ -1394,52 +1391,38 @@ save_dialog ()
GtkWidget *label;
GtkWidget *entry;
GSList *group;
gint use_none = (tsvals.compression == COMPRESSION_NONE);
gint use_lzw = (tsvals.compression == COMPRESSION_LZW);
gint use_none = (tsvals.compression == COMPRESSION_NONE);
gint use_lzw = (tsvals.compression == COMPRESSION_LZW);
gint use_packbits = (tsvals.compression == COMPRESSION_PACKBITS);
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), "Save as Tiff");
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
dlg = gimp_dialog_new ("Save as TIFF", "tiff",
gimp_plugin_help_func, "filters/tiff.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", save_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) save_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) save_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* hbox for compression and fillorder settings */
hbox = gtk_hbox_new (FALSE, 5);
hbox = gtk_hbox_new (FALSE, 6);
/* compression */
frame = gtk_frame_new ("Compression");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, FALSE, 0);
toggle_vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (toggle_vbox), 5);
toggle_vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (toggle_vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), toggle_vbox);
group = NULL;
@ -1476,17 +1459,20 @@ save_dialog ()
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
/* comment entry */
frame = gtk_frame_new(NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, FALSE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
label = gtk_label_new ("Comment: ");
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
label = gtk_label_new ("Comment:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
entry = gtk_entry_new ();
gtk_widget_show (entry);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
@ -1495,8 +1481,6 @@ save_dialog ()
(GtkSignalFunc) comment_entry_callback,
NULL);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
@ -1517,13 +1501,6 @@ save_dialog ()
/* Save interface functions */
static void
save_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
save_ok_callback (GtkWidget *widget,
gpointer data)

105
plug-ins/common/tile.c
View file

@ -22,8 +22,11 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "gtk/gtk.h"
#include "libgimp/gimp.h"
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#define ENTRY_WIDTH 60
#define ENTRY_HEIGHT 25
@ -59,8 +62,6 @@ static gint32 tile (gint32 image_id,
static gint tile_dialog (gint width,
gint height);
static void tile_close_callback (GtkWidget *widget,
gpointer data);
static void tile_ok_callback (GtkWidget *widget,
gpointer data);
static void tile_toggle_update (GtkWidget *widget,
@ -361,17 +362,15 @@ tile_dialog (gint width, gint height)
{
GtkWidget *dlg;
GtkWidget *label;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *table;
char buffer[12];
gchar buffer[12];
gchar **argv;
gint argc;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("tile");
gtk_init (&argc, &argv);
@ -382,59 +381,43 @@ tile_dialog (gint width, gint height)
tvals.new_width = width;
tvals.new_height = height;
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), "Tile");
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
dlg = gimp_dialog_new ("Tile", "tile",
gimp_plugin_help_func, "filters/tile.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", tile_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) tile_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) tile_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* parameter settings */
frame = gtk_frame_new ("Tile to New Size:");
frame = gtk_frame_new ("Tile to New Size");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
table = gtk_table_new (4, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 10);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 5);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 5);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 5);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
label = gtk_label_new ("Width: ");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ("Width:");
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
tint.width_entry = gtk_entry_new ();
gtk_widget_set_usize (tint.width_entry, ENTRY_WIDTH, ENTRY_HEIGHT);
sprintf (buffer, "%d", width);
g_snprintf (buffer, sizeof (buffer), "%d", width);
gtk_entry_set_text (GTK_ENTRY (tint.width_entry), buffer);
gtk_table_attach (GTK_TABLE (table), tint.width_entry,
1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
@ -443,14 +426,15 @@ tile_dialog (gint width, gint height)
&tvals.new_width);
gtk_widget_show (tint.width_entry);
label = gtk_label_new ("Height: ");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ("Height:");
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
tint.height_entry = gtk_entry_new ();
gtk_widget_set_usize (tint.height_entry, ENTRY_WIDTH, ENTRY_HEIGHT);
sprintf (buffer, "%d", height);
g_snprintf (buffer, sizeof (buffer), "%d", height);
gtk_entry_set_text (GTK_ENTRY (tint.height_entry), buffer);
gtk_table_attach (GTK_TABLE (table), tint.height_entry,
1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
@ -460,8 +444,8 @@ tile_dialog (gint width, gint height)
gtk_widget_show (tint.height_entry);
toggle = gtk_check_button_new_with_label ("Constrain Ratio");
gtk_table_attach (GTK_TABLE (table), toggle,
0, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) tile_toggle_update,
&tvals.constrain);
@ -469,8 +453,8 @@ tile_dialog (gint width, gint height)
gtk_widget_show (toggle);
toggle = gtk_check_button_new_with_label ("New Image");
gtk_table_attach (GTK_TABLE (table), toggle,
0, 2, 3, 4, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 3, 4,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) tile_toggle_update,
&tvals.new_image);
@ -490,13 +474,6 @@ tile_dialog (gint width, gint height)
/* Tile interface functions */
static void
tile_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
tile_ok_callback (GtkWidget *widget,
gpointer data)

374
plug-ins/common/tileit.c
View file

@ -40,8 +40,11 @@
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include "gtk/gtk.h"
#include "libgimp/gimp.h"
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
@ -98,7 +101,6 @@ static void run (gchar *name,
/* static void check (GDrawable * drawable); */
static gint tileit_dialog (void);
static void tileit_close_callback (GtkWidget *widget, gpointer data);
static void tileit_ok_callback (GtkWidget *widget, gpointer data);
static void tileit_scale_update (GtkAdjustment *adjustment, gint *size_val);
static void tileit_entry_update(GtkWidget *widget, gint *value);
@ -326,121 +328,121 @@ run (gchar *name,
/* Build the dialog up. This was the hard part! */
static gint
tileit_dialog ()
tileit_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *main_vbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *frame;
GtkWidget *xframe;
GtkWidget *table;
GtkWidget *table2;
GtkWidget *table3;
GtkWidget *table4;
GtkWidget *button;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *slider;
GtkObject *size_data;
GtkObject *op_data;
GtkWidget *toggle;
GSList *orientation_group = NULL;
guchar *color_cube;
GSList *orientation_group = NULL;
guchar *color_cube;
gchar **argv;
gint argc;
char buf[256];
gint argc;
gchar buf[256];
argc = 1;
argv = g_new (gchar *, 1);
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("tileit");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
/* Get the stuff for the preview window...*/
gtk_preview_set_gamma(gimp_gamma());
gtk_preview_set_install_cmap(gimp_install_cmap());
color_cube = gimp_color_cube();
gtk_preview_set_color_cube(color_cube[0], color_cube[1], color_cube[2], color_cube[3]);
gtk_preview_set_gamma (gimp_gamma ());
gtk_preview_set_install_cmap (gimp_install_cmap ());
color_cube = gimp_color_cube ();
gtk_preview_set_color_cube (color_cube[0], color_cube[1],
color_cube[2], color_cube[3]);
gtk_widget_set_default_visual(gtk_preview_get_visual());
gtk_widget_set_default_colormap(gtk_preview_get_cmap());
gtk_widget_set_default_visual (gtk_preview_get_visual ());
gtk_widget_set_default_colormap (gtk_preview_get_cmap ());
cache_preview(); /* Get the preview image and store it also set has_alpha */
cache_preview (); /* Get the preview image and store it also set has_alpha */
/* Start buildng the dialog up */
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), "TileIt");
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
dlg = gimp_dialog_new ("TileIt", "tileit",
gimp_plugin_help_func, "filters/tileit.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", tileit_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) tileit_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) tileit_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
main_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_vbox,
TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Start building the frame for the preview area */
frame = gtk_frame_new ("preview");
frame = gtk_frame_new ("Preview");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 1);
table = gtk_table_new (6, 6, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 1);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
tint.preview = gtk_preview_new(GTK_PREVIEW_COLOR);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
gtk_widget_set_events( GTK_WIDGET(tint.preview), PREVIEW_MASK );
gtk_signal_connect_after( GTK_OBJECT(tint.preview), "expose_event",
(GtkSignalFunc) tileit_preview_expose,
NULL);
vbox2 = gtk_vbox_new (TRUE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
gtk_widget_show (vbox2);
gtk_signal_connect( GTK_OBJECT(tint.preview), "event",
xframe = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (xframe), 2);
gtk_frame_set_shadow_type (GTK_FRAME (xframe), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox2), xframe, TRUE, FALSE, 0);
gtk_widget_show (xframe);
tint.preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_widget_set_events (GTK_WIDGET (tint.preview), PREVIEW_MASK);
gtk_signal_connect_after (GTK_OBJECT (tint.preview), "expose_event",
(GtkSignalFunc) tileit_preview_expose,
NULL);
gtk_signal_connect (GTK_OBJECT (tint.preview), "event",
(GtkSignalFunc) tileit_preview_events,
NULL);
gtk_preview_size(GTK_PREVIEW(tint.preview), preview_width, preview_height);
xframe = gtk_frame_new(NULL);
gtk_frame_set_shadow_type (GTK_FRAME (xframe), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(xframe), tint.preview);
gtk_widget_show(xframe);
gtk_table_attach(GTK_TABLE(table), xframe, 0, 1, 0, 2, GTK_EXPAND , GTK_EXPAND, 0, 0);
gtk_widget_show(frame);
gtk_widget_show(table);
gtk_preview_size (GTK_PREVIEW (tint.preview), preview_width, preview_height);
gtk_container_add (GTK_CONTAINER (xframe), tint.preview);
/* Area for buttons etc */
/* This was built up incrementally... shows does'nt it */
frame = gtk_frame_new("Flipping");
frame = gtk_frame_new ("Flipping");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 1);
table2 = gtk_table_new (7, 7, FALSE);
gtk_container_border_width (GTK_CONTAINER (table2), 1);
gtk_container_add (GTK_CONTAINER (frame), table2);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
hbox = gtk_hbox_new (TRUE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
toggle = gtk_check_button_new_with_label ("Horizontal");
gtk_table_attach (GTK_TABLE (table2), toggle, 0, 1, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) tileit_hvtoggle_update,
&do_horz);
@ -448,84 +450,88 @@ tileit_dialog ()
res_call.htoggle = toggle;
toggle = gtk_check_button_new_with_label ("Vertical");
gtk_table_attach (GTK_TABLE (table2), toggle, 1, 2, 1, 2, GTK_EXPAND , GTK_EXPAND , 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) tileit_hvtoggle_update,
&do_vert);
gtk_widget_show (toggle);
res_call.vtoggle = toggle;
xframe = gtk_frame_new("Applied to tile");
xframe = gtk_frame_new("Applied to Tile");
gtk_frame_set_shadow_type (GTK_FRAME (xframe), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (xframe), 10);
gtk_table_attach (GTK_TABLE (table2), xframe, 0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), xframe, FALSE, FALSE, 0);
gtk_widget_show(xframe);
/* Table for the inner widgets..*/
table4 = gtk_table_new (6, 6, FALSE);
gtk_container_border_width (GTK_CONTAINER (table4), 10);
gtk_container_add (GTK_CONTAINER (xframe), table4);
gtk_widget_show(table4);
table = gtk_table_new (5, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (xframe), table);
gtk_widget_show (table);
toggle = gtk_radio_button_new_with_label (orientation_group,"All tiles");
toggle = gtk_radio_button_new_with_label (orientation_group, "All Tiles");
orientation_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_table_attach (GTK_TABLE (table4), toggle, 0, 3, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 4, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) tileit_toggle_update,
(gpointer)ALL);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (orientation_group,"Alternate tiles");
toggle = gtk_radio_button_new_with_label (orientation_group,
"Alternate Tiles");
orientation_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_table_attach (GTK_TABLE (table4), toggle, 0, 3, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 4, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) tileit_toggle_update,
(gpointer)ALT);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (orientation_group,"Explict tile");
toggle = gtk_radio_button_new_with_label (orientation_group, "Explict Tile");
orientation_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_table_attach (GTK_TABLE (table4), toggle, 0, 1, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle, 0, 1, 2, 4,
GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
gtk_widget_show (toggle);
/* Table for the stuff next to the explict button */
table3 = gtk_table_new (6, 6, FALSE);
gtk_container_border_width (GTK_CONTAINER (table3), 0);
label = gtk_label_new ("Row");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show(label);
gtk_table_attach (GTK_TABLE (table3), label, 0 , 1, 0, 1, GTK_FILL | GTK_EXPAND , GTK_FILL, 1, 1);
gtk_widget_set_sensitive(label,FALSE);
label = gtk_label_new ("Row:");
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 2, 3,
GTK_FILL | GTK_SHRINK , GTK_FILL, 0, 0);
gtk_widget_show (label);
gtk_widget_set_sensitive (label, FALSE);
exp_call.r_label = label;
entry = gtk_entry_new();
gtk_widget_set_usize(entry, ENTRY_WIDTH, 0);
sprintf(buf, "%.1d", 2);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
entry = gtk_entry_new ();
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf(buf, sizeof (buf), "%.1d", 2);
gtk_entry_set_text (GTK_ENTRY (entry), buf);
gtk_widget_show (entry);
gtk_table_attach (GTK_TABLE (table3), entry, 2 , 3, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_set_sensitive(entry,FALSE);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) tileit_exp_update_f,
&exp_call);
gtk_table_attach (GTK_TABLE (table), entry, 2, 3, 2, 3,
GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
gtk_widget_set_sensitive (entry, FALSE);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) tileit_exp_update_f,
&exp_call);
exp_call.r_entry = entry;
label = gtk_label_new ("Column");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show(label);
gtk_table_attach (GTK_TABLE (table3), label, 0 , 1, 1, 2, GTK_FILL , GTK_FILL, 1, 1);
gtk_widget_set_sensitive(label,FALSE);
label = gtk_label_new ("Column:");
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 3, 4,
GTK_FILL , GTK_FILL, 0, 0);
gtk_widget_set_sensitive (label, FALSE);
exp_call.c_label = label;
entry = gtk_entry_new();
gtk_widget_set_usize(entry, ENTRY_WIDTH, 0);
sprintf(buf, "%.1d", 2);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
entry = gtk_entry_new ();
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf (buf, sizeof (buf), "%.1d", 2);
gtk_entry_set_text (GTK_ENTRY (entry), buf);
gtk_widget_show (entry);
gtk_widget_set_sensitive(entry,FALSE);
gtk_table_attach (GTK_TABLE (table3), entry, 2 , 3, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_set_sensitive (entry, FALSE);
gtk_table_attach (GTK_TABLE (table), entry, 2, 3, 3, 4,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) tileit_exp_update_f,
&exp_call);
@ -536,115 +542,106 @@ tileit_dialog ()
(gpointer)EXPLICT);
button = gtk_button_new_with_label ("Apply");
gtk_widget_set_sensitive(button,FALSE);
gtk_table_attach (GTK_TABLE (table3), button, 3, 4, 0, 3, 0, 0, 1, 1);
gtk_widget_set_sensitive (button, FALSE);
gtk_table_attach (GTK_TABLE (table), button, 3, 4, 2, 4, 0, 0, 0, 0);
gtk_widget_show (button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) tileit_exp_update,
(gpointer)&exp_call);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) tileit_exp_update,
(gpointer)&exp_call);
exp_call.applybut = button;
/* Widget for selecting the Opacity */
sprintf(buf,"Opacity: ");
label = gtk_label_new (buf);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table4), label, 0, 1, 3, 4, 0, 0, 0, 0);
label = gtk_label_new ("Opacity:");
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0);
gtk_widget_show (label);
op_data = gtk_adjustment_new (100, 0, 100, 1, 1, 0);
slider = gtk_hscale_new (GTK_ADJUSTMENT (op_data));
gtk_widget_set_usize (slider, SCALE_WIDTH, 0);
gtk_table_attach (GTK_TABLE (table4), slider, 1,3 , 3, 4, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), slider, 1 ,3, 4, 5,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (slider), 0);
gtk_range_set_update_policy (GTK_RANGE (slider),GTK_UPDATE_CONTINUOUS );
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_CONTINUOUS);
gtk_signal_connect (GTK_OBJECT (op_data), "value_changed",
(GtkSignalFunc) tileit_scale_update,
&opacity);
if(!has_alpha)
gtk_widget_set_sensitive(slider,FALSE);
if (!has_alpha)
gtk_widget_set_sensitive (slider,FALSE);
gtk_widget_show (slider);
entry = gtk_entry_new();
gtk_object_set_user_data(GTK_OBJECT(entry), op_data);
gtk_object_set_user_data(op_data, entry);
gtk_widget_set_usize(entry, 3*ENTRY_WIDTH/2, 0);
sprintf(buf, "%.1d", opacity);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) tileit_entry_update,
&opacity);
gtk_table_attach(GTK_TABLE(table4), entry, 3, 4, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
if(!has_alpha)
gtk_widget_set_sensitive(entry,FALSE);
gtk_widget_show(entry);
gtk_widget_show(table3);
gtk_table_attach (GTK_TABLE (table4), table3, 1, 2, 2, 3, GTK_FILL , GTK_FILL, 0, 0);
entry = gtk_entry_new ();
gtk_object_set_user_data (GTK_OBJECT (entry), op_data);
gtk_object_set_user_data (op_data, entry);
gtk_widget_set_usize (entry, 3 * ENTRY_WIDTH / 2, 0);
g_snprintf (buf, sizeof (buf), "%.1d", opacity);
gtk_entry_set_text (GTK_ENTRY (entry), buf);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) tileit_entry_update,
&opacity);
gtk_table_attach (GTK_TABLE (table), entry, 3, 4, 4, 5,
GTK_FILL, GTK_FILL, 0, 0);
if (!has_alpha)
gtk_widget_set_sensitive (entry,FALSE);
gtk_widget_show (entry);
button = gtk_button_new_with_label ("Reset");
gtk_table_attach (GTK_TABLE (table2), button, 0, 2, 5, 6, 0 , 0, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) tileit_reset,
(gpointer)&res_call);
gtk_widget_show(frame);
gtk_widget_show(table2);
gtk_table_attach(GTK_TABLE(table), frame, 1, 2, 0, 2, GTK_EXPAND , GTK_EXPAND, 0, 0);
/* Lower frame saying howmany segments */
frame = gtk_frame_new ("Segment Setting");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 1);
table = gtk_table_new (5, 5, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 1);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
sprintf(buf,"1/(%d**n) ",2);
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
g_snprintf (buf, sizeof (buf), "1 / (%d ** n) ", 2);
label = gtk_label_new (buf);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_EXPAND, GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
size_data = gtk_adjustment_new (itvals.numtiles, 2, MAX_SEGS, 1, 1, 0);
slider = gtk_hscale_new (GTK_ADJUSTMENT (size_data));
gtk_widget_set_usize (slider, SCALE_WIDTH, 0);
gtk_table_attach (GTK_TABLE (table), slider, 2,3 , 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_LEFT);
gtk_scale_set_digits (GTK_SCALE (slider), 0);
gtk_range_set_update_policy (GTK_RANGE (slider),GTK_UPDATE_CONTINUOUS );
gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0);
gtk_scale_set_draw_value (GTK_SCALE (slider), FALSE);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_CONTINUOUS);
gtk_signal_connect (GTK_OBJECT (size_data), "value_changed",
(GtkSignalFunc) tileit_scale_update,
&itvals.numtiles);
gtk_widget_show (slider);
entry = gtk_entry_new();
gtk_object_set_user_data(GTK_OBJECT(entry), size_data);
gtk_object_set_user_data(size_data, entry);
gtk_widget_set_usize(entry, ENTRY_WIDTH, 0);
sprintf(buf, "%.1d", itvals.numtiles);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) tileit_entry_update,
&itvals.numtiles);
gtk_table_attach(GTK_TABLE(table), entry, 3, 4, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_object_set_user_data (GTK_OBJECT (entry), size_data);
gtk_object_set_user_data (size_data, entry);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf (buf, sizeof (buf), "%.1d", itvals.numtiles);
gtk_entry_set_text (GTK_ENTRY (entry), buf);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) tileit_entry_update,
&itvals.numtiles);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_widget_show(entry);
gtk_widget_show(frame);
gtk_widget_show(table);
gtk_widget_show(tint.preview);
gtk_widget_show (tint.preview);
gtk_widget_show (dlg);
dialog_update_preview();
dialog_update_preview ();
gtk_main ();
gdk_flush ();
@ -652,13 +649,6 @@ tileit_dialog ()
return tint.run;
}
static void
tileit_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
tileit_ok_callback (GtkWidget *widget,
gpointer data)

209
plug-ins/common/video.c
View file

@ -20,11 +20,13 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include "gtk/gtk.h"
#include "libgimp/gimp.h"
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#define MAX_PATTERNS 9
@ -1780,8 +1782,6 @@ static void video (GDrawable *drawable);
static gint video_dialog (void);
static void video_close_callback (GtkWidget *widget,
gpointer data);
static void video_ok_callback (GtkWidget *widget,
gpointer data);
@ -2157,25 +2157,23 @@ static gint
video_dialog ()
{
GtkWidget *dlg;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *radioframe;
GtkWidget *previewframe;
GtkWidget *vbox;
GtkWidget *box;
GtkWidget *toggle;
GSList *group = NULL;
guchar *color_cube;
gchar **argv;
gint argc;
gint y;
GSList *group = NULL;
guchar *color_cube;
gchar **argv;
gint argc;
gint y;
argc = 1;
argv = g_new (gchar *, 1);
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("video");
for (y=0;y<MAX_PATTERNS;y++)
for (y = 0; y < MAX_PATTERNS; y++)
{
radio_pressed[y] = (vvals.pattern_number == y);
}
@ -2193,77 +2191,44 @@ video_dialog ()
gtk_widget_set_default_visual (gtk_preview_get_visual ());
gtk_widget_set_default_colormap (gtk_preview_get_cmap ());
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), "Video");
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
dlg = gimp_dialog_new ("Video", "video",
gimp_plugin_help_func, "filters/video.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", video_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) video_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) video_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* main parameter frame */
frame = gtk_frame_new ("Parameter Settings");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
/* table = gtk_table_new (4, 8, FALSE);*/
box = gtk_hbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box), 10);
box = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (box), 4);
gtk_container_add (GTK_CONTAINER (frame), box);
/* frame for the radio buttons */
radioframe = gtk_frame_new ("RGB Pattern Type");
gtk_frame_set_shadow_type (GTK_FRAME (radioframe), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (radioframe), 1);
gtk_box_pack_start (GTK_BOX (box), radioframe, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), radioframe, FALSE, FALSE, 0);
/* vbox for toggle&preview */
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (vbox), 1);
/* put the vbox in the hbox */
gtk_box_pack_start (GTK_BOX (box), vbox, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (box), vbox, FALSE, FALSE, 0);
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (preview), PREVIEW_WIDTH, PREVIEW_HEIGHT);
toggle = gtk_check_button_new_with_label ("Additive");
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
@ -2280,137 +2245,52 @@ video_dialog ()
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), vvals.rotated);
gtk_widget_show (toggle);
previewframe = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (previewframe), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), previewframe, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (previewframe), preview);
gtk_widget_show (preview);
gtk_widget_show (previewframe);
gtk_widget_show (radioframe);
gtk_widget_show (vbox);
/* vbox for RGB pattern typees */
vbox = gtk_vbox_new (FALSE, 1);
gtk_container_border_width (GTK_CONTAINER (vbox), 10);
/* put the vbox in the radioframe */
gtk_container_set_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (radioframe), vbox);
/* radio buttons */
for (y=0;y<MAX_PATTERNS;y++)
for (y = 0; y < MAX_PATTERNS; y++)
{
toggle = gtk_radio_button_new_with_label (group,pattern_name[y]);
toggle = gtk_radio_button_new_with_label (group, pattern_name[y]);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[y]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[y]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
radio_pressed[y]);
gtk_widget_show (toggle);
}
/* toggle = gtk_radio_button_new_with_label (group,"Staggered");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[0]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[0]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"Large staggered");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[1]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[1]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"Striped");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[2]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[2]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"Wide-striped");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[3]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[3]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"Long-staggered");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[4]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[4]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"3x3");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[5]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[5]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"Large 3x3");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[6]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[6]);
gtk_widget_show (toggle);
toggle = gtk_radio_button_new_with_label (group,"Hex");
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[7]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), radio_pressed[7]);
gtk_widget_show (toggle);*/
video_render_preview(FALSE);
video_render_preview (FALSE);
gtk_widget_show (vbox);
gtk_widget_show (box);
gtk_widget_show (frame);
gtk_widget_show (dlg);
/* video_render_preview(FALSE);*/
in_main_loop = TRUE;
gtk_main ();
in_main_loop = FALSE;
gdk_flush ();
vvals.pattern_number=0;
for (y=0;y<MAX_PATTERNS;y++)
vvals.pattern_number = 0;
for (y = 0; y < MAX_PATTERNS; y++)
{
if (radio_pressed[y]==TRUE)
{
@ -2425,13 +2305,6 @@ video_dialog ()
/* Video interface functions */
static void
video_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
video_ok_callback (GtkWidget *widget,
gpointer data)

95
plug-ins/common/vpropagate.c
View file

@ -27,13 +27,16 @@
In other word, pixel itself is not a neighbor of it.
*/
#include "libgimp/gimp.h"
#include "gtk/gtk.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimpmath.h>
#define PLUG_IN_NAME "plug_in_vpropagate"
#define SHORT_NAME "vpropagate"
#define PROGRESS_NAME "value propagating..."
@ -70,15 +73,10 @@ static void gtkW_gint_update (GtkWidget *widget,
gpointer data);
static void gtkW_scale_update (GtkAdjustment *adjustment,
double *data);
static void gtkW_close_callback (GtkWidget *widget,
gpointer data);
static void vpropagate_ok_callback (GtkWidget *widget,
gpointer data);
static void gtkW_toggle_update (GtkWidget *widget,
gpointer data);
static GtkWidget * gtkW_dialog_new (char *name,
GtkSignalFunc ok_callback,
GtkSignalFunc close_callback);
static GtkWidget * gtkW_table_add_toggle (GtkWidget *table,
gchar *name,
gint x1,
@ -940,25 +938,39 @@ propagate_transparent (GImageType image_type,
static int
vpropagate_dialog (GImageType image_type)
{
GtkWidget *dlg;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *dlg;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *sep;
gchar **argv;
gint argc;
static gchar buffer[3][10];
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
static gchar buffer[3][10];
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup (SHORT_NAME);
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
dlg = gtkW_dialog_new (PLUG_IN_NAME,
(GtkSignalFunc) vpropagate_ok_callback,
(GtkSignalFunc) gtkW_close_callback);
dlg = gimp_dialog_new ("Value Propagate", "vpropagate",
gimp_plugin_help_func, "filters/vpropagate.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", vpropagate_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
hbox = gtkW_hbox_new((GTK_DIALOG (dlg)->vbox));
/* Propagate Mode */
@ -1063,13 +1075,6 @@ gtkW_scale_update (GtkAdjustment *adjustment,
*scale_val = (gdouble) adjustment->value;
}
static void
gtkW_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
vpropagate_ok_callback (GtkWidget *widget,
gpointer data)
@ -1108,42 +1113,6 @@ gtkW_toggle_update (GtkWidget *widget,
*toggle_val = FALSE;
}
/* gtkW is the abbreviation of gtk Wrapper */
static GtkWidget *
gtkW_dialog_new (char *name,
GtkSignalFunc ok_callback,
GtkSignalFunc close_callback)
{
GtkWidget *dlg, *button;
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), name);
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) gtkW_close_callback, NULL);
/* Action Area */
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) ok_callback, dlg);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(dlg));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_show (button);
return dlg;
}
GtkWidget *
gtkW_hbox_new (GtkWidget *parent)
{

388
plug-ins/common/warp.c
View file

@ -63,18 +63,21 @@
* Version 0.3 10/20/97 Initial release for Gimp 0.99.xx
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <signal.h>
#include <time.h> /* time(NULL) for random # seed */
#include "gtk/gtk.h"
#include "config.h"
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimpmath.h>
#include "libgimp/stdplugins-intl.h"
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
/* Some useful macros */
@ -190,8 +193,6 @@ static void warp_map_grad_callback (gint32 id,
gpointer data);
static void warp_map_vector_callback (gint32 id,
gpointer data);
static void warp_close_callback (GtkWidget *widget,
gpointer data);
static void warp_ok_callback (GtkWidget *widget,
gpointer data);
static void warp_toggle_update (GtkWidget *widget,
@ -421,23 +422,19 @@ run (gchar *name,
}
*/
gimp_drawable_detach (map_x);
gimp_drawable_detach (map_y);
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
static int
warp_dialog (GDrawable *drawable)
{
GtkWidget *dlg;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *toggle;
GtkWidget *toggle_hbox;
GtkWidget *frame;
@ -452,133 +449,101 @@ warp_dialog (GDrawable *drawable)
GtkWidget *magmenu;
GtkWidget *gradmenu;
GtkWidget *vectormenu;
GtkTooltips *tooltips;
GdkColor tips_fg, tips_bg;
GSList *group = NULL;
GSList *groupmag = NULL;
gchar **argv;
gchar buffer[32];
gint argc;
gint use_wrap = (dvals.wrap_type == WRAP);
gint use_smear = (dvals.wrap_type == SMEAR);
gint use_black = (dvals.wrap_type == BLACK);
gint use_color = (dvals.wrap_type == COLOR);
GSList *group = NULL;
GSList *groupmag = NULL;
gchar **argv;
gchar buffer[32];
gint argc;
gint use_wrap = (dvals.wrap_type == WRAP);
gint use_smear = (dvals.wrap_type == SMEAR);
gint use_black = (dvals.wrap_type == BLACK);
gint use_color = (dvals.wrap_type == COLOR);
gint mag_use_yes = (dvals.mag_use == TRUE);
gint mag_use_no = (dvals.mag_use == FALSE);
gint mag_use_no = (dvals.mag_use == FALSE);
argc = 1;
argv = g_new (gchar *, 1);
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("Warp");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
dlg = gimp_dialog_new (_("Warp"), "warp",
gimp_plugin_help_func, "filters/warp.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), warp_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), _("Warp"));
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) warp_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* use black as foreground: */
tooltips = gtk_tooltips_new (); /* obtain a tooltips widget */
tips_fg.red = 0;
tips_fg.green = 0;
tips_fg.blue = 0;
/* postit yellow (khaki) as background: */
gdk_color_alloc (gtk_widget_get_colormap (dlg), &tips_fg);
tips_bg.red = 61669;
tips_bg.green = 59113;
tips_bg.blue = 35979;
gdk_color_alloc (gtk_widget_get_colormap (dlg), &tips_bg);
gtk_tooltips_set_colors (tooltips,&tips_bg,&tips_fg);
/* gtk_tooltips_set_delay (tooltips, 0);*/ /* any longer and the tooltip will persist and
obscure the popup menu if mouse button clicked before 1 second */
gimp_help_init ();
/*
This call does not seem to work. leaves tooltip 100% black, no color
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
gtk_tooltips_set_colors (tooltips, &yellow_color, &grey_color);
void gtk_tooltips_set_colors (GtkTooltips *tooltips,
GdkColor *background,
GdkColor *foreground);
*/
/* Action area */
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 2);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dlg)->action_area), FALSE);
hbbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbbox), 4);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dlg)->action_area), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) warp_ok_callback,
dlg);
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label (_("Cancel"));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
/* The main table */
frame = gtk_frame_new ( _("Main Options"));
frame = gtk_frame_new (_("Main Options"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 1);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* table params: rows, columns */
table = gtk_table_new (4, 3, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 1);
table = gtk_table_new (3, 3, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_set_row_spacings (GTK_TABLE (table), 1);
gtk_table_set_col_spacings (GTK_TABLE (table), 1);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
/* on_x, on_y */
label = gtk_label_new ( _("Step Size"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Step Size:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
label = gtk_label_new ( _("Iterations"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Iterations:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
/* amount, angle, iter */
dint.amount = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%3.3f", dvals.amount);
g_snprintf (buffer, sizeof (buffer), "%3.3f", dvals.amount);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_callback,
&dvals.amount);
gtk_widget_show (entry);
dint.iter = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%d", dvals.iter);
g_snprintf (buffer, sizeof (buffer), "%d", dvals.iter);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_int_callback,
&dvals.iter);
gtk_widget_show (entry);
/* Displacement map menu */
label = gtk_label_new ( _("Displacement Map:"));
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.warp_map = option_menu = gtk_option_menu_new ();
@ -589,15 +554,14 @@ warp_dialog (GDrawable *drawable)
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_widget_show (option_menu);
/* ================================================================================== */
/* ======================================================================= */
/* Displacement Type */
toggle_hbox = gtk_hbox_new (FALSE, 10);
gtk_container_border_width (GTK_CONTAINER (toggle_hbox), 1);
gtk_table_attach (GTK_TABLE (table), toggle_hbox, 0, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
toggle_hbox = gtk_hbox_new (FALSE, 4);
gtk_table_attach (GTK_TABLE (table), toggle_hbox, 0, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("On Edges: "));
label = gtk_label_new ( _("On Edges:"));
gtk_box_pack_start (GTK_BOX (toggle_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
@ -645,67 +609,72 @@ warp_dialog (GDrawable *drawable)
/* -------------------------------------------------------------------- */
/* --------- The secondary table -------------------------- */
frame = gtk_frame_new ( _("Secondary Options"));
frame = gtk_frame_new (_("Secondary Options"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 1);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* table params: rows, columns */
table = gtk_table_new (3, 3, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 1);
gtk_container_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_set_row_spacings (GTK_TABLE (table), 1);
gtk_table_set_col_spacings (GTK_TABLE (table), 1);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
label = gtk_label_new ( _("Dither Size"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Dither Size:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.dither = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%3.3f", dvals.dither);
g_snprintf (buffer, sizeof (buffer), "%3.3f", dvals.dither);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_callback,
&dvals.dither);
gtk_widget_show (entry);
label = gtk_label_new ( _("Substeps"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Substeps:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.substeps = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%d", dvals.substeps);
g_snprintf (buffer, sizeof (buffer), "%d", dvals.substeps);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_int_callback,
&dvals.substeps);
gtk_widget_show (entry);
/* -------------------------------------------------------- */
label = gtk_label_new ( _("Rotation Angle"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.angle = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%3.1f", dvals.angle);
g_snprintf (buffer, sizeof (buffer), "%3.1f", dvals.angle);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_callback,
&dvals.angle);
gtk_widget_show (entry);
/* Magnitude map menu */
label = gtk_label_new ( _("Magnitude Map:"));
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.mag_map = option_menu_mag = gtk_option_menu_new ();
@ -716,14 +685,14 @@ warp_dialog (GDrawable *drawable)
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu_mag), magmenu);
gtk_widget_show (option_menu_mag);
/* ----------------------------------------------------------------------- */
/* Magnitude Usage */
toggle_hbox = gtk_hbox_new (FALSE, 10);
toggle_hbox = gtk_hbox_new (FALSE, 4);
gtk_container_border_width (GTK_CONTAINER (toggle_hbox), 1);
gtk_table_attach (GTK_TABLE (table), toggle_hbox, 2, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), toggle_hbox, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Use Mag Map: "));
label = gtk_label_new ( _("Use Mag Map:"));
gtk_box_pack_start (GTK_BOX (toggle_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
@ -753,27 +722,29 @@ warp_dialog (GDrawable *drawable)
/* -------------------------------------------------------------------- */
/* --------- The "other" table -------------------------- */
frame = gtk_frame_new ( _("Other Options"));
frame = gtk_frame_new (_("Other Options"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 1);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* table params: rows, columns */
otable = gtk_table_new (3, 3, FALSE);
gtk_container_border_width (GTK_CONTAINER (otable), 1);
gtk_container_set_border_width (GTK_CONTAINER (otable), 4);
gtk_container_add (GTK_CONTAINER (frame), otable);
gtk_table_set_row_spacings (GTK_TABLE (otable), 1);
gtk_table_set_col_spacings (GTK_TABLE (otable), 1);
gtk_table_set_row_spacings (GTK_TABLE (otable), 2);
gtk_table_set_col_spacings (GTK_TABLE (otable), 4);
label = gtk_label_new ( _("Gradient Scale"));
gtk_table_attach (GTK_TABLE (otable), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Gradient Scale:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (otable), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.grad_scale = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (otable), entry, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (otable), entry, 1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%3.3f", dvals.grad_scale);
g_snprintf (buffer, sizeof (buffer), "%3.3f", dvals.grad_scale);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_callback,
@ -788,23 +759,24 @@ warp_dialog (GDrawable *drawable)
gradmenu = gimp_drawable_menu_new (warp_map_constrain, warp_map_grad_callback,
drawable, dvals.grad_map);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu_grad), gradmenu);
gtk_tooltips_set_tip (tooltips, option_menu_grad, _("Gradient map selection menu"), NULL);
gimp_help_set_help_data (option_menu_grad,
_("Gradient map selection menu"), NULL);
gtk_widget_show (option_menu_grad);
/* ---------------------------------------------- */
label = gtk_label_new ( _("Vector Mag"));
gtk_table_attach (GTK_TABLE (otable), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Vector Mag:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (otable), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.vector_scale = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (otable), entry, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (otable), entry, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%3.3f", dvals.vector_scale);
g_snprintf (buffer, sizeof (buffer), "%3.3f", dvals.vector_scale);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_callback,
@ -812,14 +784,18 @@ warp_dialog (GDrawable *drawable)
gtk_widget_show (entry);
/* -------------------------------------------------------- */
label = gtk_label_new ( _("Angle"));
gtk_table_attach (GTK_TABLE (otable), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
label = gtk_label_new ( _("Angle:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (otable), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
dint.vector_angle = entry = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (otable), entry, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (otable), entry, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%3.1f", dvals.vector_angle);
g_snprintf (buffer, sizeof (buffer), "%3.1f", dvals.vector_angle);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) warp_entry_callback,
@ -830,23 +806,23 @@ warp_dialog (GDrawable *drawable)
dint.vector_map = option_menu_vector = gtk_option_menu_new ();
gtk_table_attach (GTK_TABLE (otable), option_menu_vector, 2, 3, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
vectormenu = gimp_drawable_menu_new (warp_map_constrain, warp_map_vector_callback,
drawable, dvals.vector_map);
vectormenu = gimp_drawable_menu_new (warp_map_constrain,
warp_map_vector_callback,
drawable, dvals.vector_map);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu_vector), vectormenu);
gtk_tooltips_set_tip (tooltips, option_menu_vector, _("Fixed-direction-vector map selection menu"), NULL);
gimp_help_set_help_data (option_menu_vector,
_("Fixed-direction-vector map selection menu"),
NULL);
gtk_widget_show (option_menu_vector);
/* -------------------------------------------------------- */
gtk_widget_show (otable);
gtk_widget_show (frame);
/* --------------------------------------------------------------- */
gtk_widget_show (dlg);
gtk_main ();
gtk_object_unref (GTK_OBJECT (tooltips));
gimp_help_free ();
gdk_flush ();
/* determine wrap type */
@ -998,14 +974,15 @@ diff_prepare_row (GPixelRgn *pixel_rgn,
}
}
/* --------------------------------------------------------------------------------------------- */
/* 'diff' combines the input drawables to prepare the two 16-bit (X,Y) vector displacement maps */
/* --------------------------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* 'diff' combines the input drawables to prepare the two */
/* 16-bit (X,Y) vector displacement maps */
/* -------------------------------------------------------------------------- */
static void
diff (GDrawable *drawable,
gint32 *xl_id,
gint32 *yl_id )
gint32 *xl_id,
gint32 *yl_id)
{
GDrawable *draw_xd, *draw_yd; /* vector disp. drawables */
GDrawable *mdraw, *vdraw, *gdraw;
@ -1047,7 +1024,7 @@ diff (GDrawable *drawable,
gdouble scale_vec_x, scale_vec_y; /* fixed vector X,Y component scaling factors */
gint has_alpha, ind;
/* -------------------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------- */
if (dvals.grad_scale != 0.0)
do_gradmap = TRUE; /* add in gradient of gradmap if scale != 0.000 */
@ -1270,7 +1247,7 @@ diff (GDrawable *drawable,
*dy++ = (guchar) (dvaly % 256);
dy += dest_bytes_inc;
} /* ------------------------------- for (col...) --------------------------- */
} /* ------------------------------- for (col...) ---------------- */
/* store the dest */
gimp_pixel_rgn_set_row (&destxPR, destx, x1, row, (x2 - x1));
@ -1331,9 +1308,9 @@ diff (GDrawable *drawable,
} /* end diff() */
/* -------------------------------------------------------------------------------- */
/* The Warp displacement is done here. */
/* -------------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* The Warp displacement is done here. */
/* -------------------------------------------------------------------------- */
static void
warp (GDrawable *orig_draw,
@ -1358,7 +1335,7 @@ warp (GDrawable *orig_draw,
gint32 xdlayer = -1;
gint32 ydlayer = -1;
gint warp_iter; /* index var. over all "warp" Displacement iterations */
gint warp_iter; /* index var. over all "warp" Displacement iterations */
disp_map = gimp_drawable_get(dvals.warp_map);
@ -1368,7 +1345,7 @@ warp (GDrawable *orig_draw,
gimp_progress_init ( _("Finding XY gradient..."));
diff(disp_map, &xdlayer, &ydlayer); /* generate x,y differential images (arrays) */
diff(disp_map, &xdlayer, &ydlayer); /* generate x,y differential images (arrays) */
/* Get selection area */
gimp_drawable_mask_bounds (orig_draw->id, &x1, &y1, &x2, &y2);
@ -1412,7 +1389,7 @@ warp (GDrawable *orig_draw,
} /* Warp */
/* -------------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
static void
warp_one(GDrawable *draw,
@ -1482,7 +1459,7 @@ warp_one(GDrawable *draw,
srand(time(NULL)); /* seed random # generator */
/* ================ Outer Loop calculation =================================== */
/* ================ Outer Loop calculation ================================ */
/* Get selection area */
@ -1690,10 +1667,12 @@ warp_one(GDrawable *draw,
} /* warp_one */
/* -------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
static gdouble
warp_map_mag_give_value(guchar *pt, gint alpha, gint bytes)
warp_map_mag_give_value (guchar *pt,
gint alpha,
gint bytes)
{
gdouble ret, val_alpha;
@ -1714,18 +1693,18 @@ warp_map_mag_give_value(guchar *pt, gint alpha, gint bytes)
static GTile *
warp_pixel (GDrawable * drawable,
GTile * tile,
gint width,
gint height,
gint x1,
gint y1,
gint x2,
gint y2,
gint x,
gint y,
gint * row,
gint * col,
guchar * pixel)
GTile * tile,
gint width,
gint height,
gint x1,
gint y1,
gint x2,
gint y2,
gint x,
gint y,
gint * row,
gint * col,
guchar * pixel)
{
static guchar empty_pixel[4] = {0, 0, 0, 0};
guchar *data;
@ -1786,9 +1765,10 @@ warp_pixel (GDrawable * drawable,
return tile;
}
static guchar
bilinear (gdouble x, gdouble y, guchar *v)
bilinear (gdouble x,
gdouble y,
guchar *v)
{
gdouble m0, m1;
@ -1807,7 +1787,9 @@ bilinear (gdouble x, gdouble y, guchar *v)
} /* bilinear */
static gint
bilinear16 (gdouble x, gdouble y, gint *v)
bilinear16 (gdouble x,
gdouble y,
gint *v)
{
gdouble m0, m1;
@ -1830,8 +1812,8 @@ bilinear16 (gdouble x, gdouble y, gint *v)
static gint
warp_map_constrain (gint32 image_id,
gint32 drawable_id,
gpointer data)
gint32 drawable_id,
gpointer data)
{
GDrawable *drawable;
@ -1849,43 +1831,35 @@ warp_map_constrain (gint32 image_id,
static void
warp_map_callback (gint32 id,
gpointer data)
gpointer data)
{
dvals.warp_map = id;
}
static void
warp_map_mag_callback (gint32 id,
gpointer data)
gpointer data)
{
dvals.mag_map = id;
}
static void
warp_map_grad_callback (gint32 id,
gpointer data)
gpointer data)
{
dvals.grad_map = id;
}
static void
warp_map_vector_callback (gint32 id,
gpointer data)
gpointer data)
{
dvals.vector_map = id;
}
static void
warp_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
warp_ok_callback (GtkWidget *widget,
gpointer data)
gpointer data)
{
dint.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
@ -1893,7 +1867,7 @@ warp_ok_callback (GtkWidget *widget,
static void
warp_toggle_update (GtkWidget *widget,
gpointer data)
gpointer data)
{
int *toggle_val;
@ -1907,7 +1881,7 @@ warp_toggle_update (GtkWidget *widget,
static void
warp_entry_callback (GtkWidget *widget,
gpointer data)
gpointer data)
{
gdouble *text_val;

585
plug-ins/common/waves.c
View file

@ -30,8 +30,11 @@
#include <string.h>
#include <stdlib.h>
#include <libgimp/gimp.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <plug-ins/megawidget/megawidget.h>
struct Grgb {
@ -57,23 +60,24 @@ struct piArgs {
struct mwPreview *mwp;
static void query(void);
static void run(char *name, int nparam, GParam *param,
int *nretvals, GParam **retvals);
static void query (void);
static void run (char *name, int nparam, GParam *param,
int *nretvals, GParam **retvals);
int pluginCore(struct piArgs *argp, gint32 drawable);
int pluginCoreIA(struct piArgs *argp, gint32 drawable);
int pluginCore (struct piArgs *argp, gint32 drawable);
int pluginCoreIA (struct piArgs *argp, gint32 drawable);
static mw_preview_t waves_do_preview;
static void wave(guchar *src, guchar *dest, gint width, gint height, gint bypp,
gdouble amplitude, gdouble wavelength, gdouble phase,
gint smear, gint reflective, gint verbose);
static void wave (guchar *src, guchar *dest, gint width, gint height, gint bypp,
gdouble amplitude, gdouble wavelength, gdouble phase,
gint smear, gint reflective, gint verbose);
static guchar bilinear(gdouble x, gdouble y, guchar *v);
static guchar bilinear (gdouble x, gdouble y, guchar *v);
#define WITHIN(a, b, c) ((((a) <= (b)) && ((b) <= (c))) ? 1 : 0)
GPlugInInfo PLUG_IN_INFO = {
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init */
NULL, /* quit */
query, /* query */
@ -83,8 +87,10 @@ GPlugInInfo PLUG_IN_INFO = {
MAIN()
static void
query(void){
static GParamDef args[] = {
query (void)
{
static GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "The Image" },
{ PARAM_DRAWABLE, "drawable", "The Drawable" },
@ -99,22 +105,26 @@ query(void){
static GParamDef *rets = NULL;
static int nrets = 0;
gimp_install_procedure("plug_in_waves",
"Distort the image with waves",
"none yet",
"Eric L. Hernes, Stephen Norris",
"Stephen Norris",
"1997",
"<Image>/Filters/Distorts/Waves...",
"RGB*, GRAY*",
PROC_PLUG_IN,
nargs, nrets,
args, rets);
gimp_install_procedure ("plug_in_waves",
"Distort the image with waves",
"none yet",
"Eric L. Hernes, Stephen Norris",
"Stephen Norris",
"1997",
"<Image>/Filters/Distorts/Waves...",
"RGB*, GRAY*",
PROC_PLUG_IN,
nargs, nrets,
args, rets);
}
static void
run(char *name, int nparam, GParam *param,
int *nretvals, GParam **retvals){
run (char *name,
int nparam,
GParam *param,
int *nretvals,
GParam **retvals)
{
static GParam rvals[1];
struct piArgs args;
@ -122,102 +132,124 @@ run(char *name, int nparam, GParam *param,
*nretvals = 1;
*retvals = rvals;
memset(&args,(int)0,sizeof(struct piArgs));
memset (&args, (int)0, sizeof (struct piArgs));
args.type=-1;
gimp_get_data("plug_in_waves", &args);
gimp_get_data ("plug_in_waves", &args);
rvals[0].type = PARAM_STATUS;
rvals[0].data.d_status = STATUS_SUCCESS;
switch (param[0].data.d_int32) {
GDrawable *drw;
switch (param[0].data.d_int32)
{
GDrawable *drw;
case RUN_INTERACTIVE:
/* XXX: add code here for interactive running */
if(args.type == -1) {
args.amplitude = 10.0;
args.wavelength = 10;
args.phase = 0.0;
args.type = 0;
args.reflective = 0;
}
if (args.type == -1)
{
args.amplitude = 10.0;
args.wavelength = 10;
args.phase = 0.0;
args.type = 0;
args.reflective = 0;
}
drw = gimp_drawable_get(param[2].data.d_drawable);
mwp=mw_preview_build(drw);
drw = gimp_drawable_get (param[2].data.d_drawable);
mwp=mw_preview_build (drw);
if (pluginCoreIA(&args, param[2].data.d_drawable)==-1) {
rvals[0].data.d_status = STATUS_EXECUTION_ERROR;
} else {
gimp_set_data("plug_in_waves", &args, sizeof(struct piArgs));
}
if (pluginCoreIA(&args, param[2].data.d_drawable)==-1)
{
rvals[0].data.d_status = STATUS_EXECUTION_ERROR;
}
else
{
gimp_set_data ("plug_in_waves", &args, sizeof (struct piArgs));
}
break;
case RUN_NONINTERACTIVE:
/* XXX: add code here for non-interactive running */
if (nparam != 8) {
rvals[0].data.d_status = STATUS_CALLING_ERROR;
break;
}
if (nparam != 8)
{
rvals[0].data.d_status = STATUS_CALLING_ERROR;
break;
}
args.amplitude = param[3].data.d_float;
args.phase = param[4].data.d_float;
args.wavelength = param[5].data.d_float;
args.type = param[6].data.d_int32;
args.reflective = param[7].data.d_int32;
if (pluginCore(&args, param[2].data.d_drawable)==-1) {
rvals[0].data.d_status = STATUS_EXECUTION_ERROR;
break;
}
if (pluginCore(&args, param[2].data.d_drawable)==-1)
{
rvals[0].data.d_status = STATUS_EXECUTION_ERROR;
break;
}
break;
case RUN_WITH_LAST_VALS:
/* XXX: add code here for last-values running */
if (pluginCore(&args, param[2].data.d_drawable)==-1) {
rvals[0].data.d_status = STATUS_EXECUTION_ERROR;
}
break;
}
if (pluginCore(&args, param[2].data.d_drawable)==-1)
{
rvals[0].data.d_status = STATUS_EXECUTION_ERROR;
}
break;
}
}
gint
pluginCore(struct piArgs *argp, gint32 drawable) {
pluginCore (struct piArgs *argp,
gint32 drawable)
{
gint retval=0;
GDrawable *drw;
GPixelRgn srcPr, dstPr;
guchar *src, *dst;
guint width, height, Bpp;
drw = gimp_drawable_get(drawable);
drw = gimp_drawable_get (drawable);
width = drw->width;
height = drw->height;
Bpp = drw->bpp;
src = (guchar*)malloc(width*height*Bpp);
dst = (guchar*)malloc(width*height*Bpp);
src = g_new (guchar, width * height * Bpp);
dst = g_new (guchar, width * height * Bpp);
gimp_pixel_rgn_init (&srcPr, drw, 0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dstPr, drw, 0, 0, width, height, TRUE, TRUE);
gimp_pixel_rgn_get_rect(&srcPr, src, 0, 0, width, height);
gimp_pixel_rgn_get_rect (&srcPr, src, 0, 0, width, height);
wave(src, dst, width, height, Bpp, argp->amplitude, argp->wavelength,
wave (src, dst, width, height, Bpp, argp->amplitude, argp->wavelength,
argp->phase, argp->type==0, argp->reflective, 1);
gimp_pixel_rgn_set_rect(&dstPr, dst, 0, 0, width, height);
gimp_pixel_rgn_set_rect (&dstPr, dst, 0, 0, width, height);
free(src);
free(dst);
g_free (src);
g_free (dst);
gimp_drawable_flush(drw);
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->id, TRUE);
gimp_drawable_update(drw->id, 0, 0, width, height);
gimp_drawable_update (drw->id, 0, 0, width, height);
gimp_displays_flush();
gimp_displays_flush ();
return retval;
}
static gboolean run_flag = FALSE;
static void
waves_ok_callback (GtkWidget *widget,
gpointer data)
{
run_flag = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
gint
pluginCoreIA(struct piArgs *argp, gint32 drawable) {
pluginCoreIA (struct piArgs *argp,
gint32 drawable)
{
gint r=-1; /* default to error return */
GtkWidget *dlg;
GtkWidget *frame;
@ -225,124 +257,155 @@ pluginCoreIA(struct piArgs *argp, gint32 drawable) {
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *preview;
gint runp;
gchar **argv;
gint argc;
static struct mwRadioGroup mode[] = {
{ "Smear", 1 },
{ "Blacken", 0 },
{ NULL, 0 },
};
gchar **argv;
gint argc;
/* Set args */
argc = 1;
argv = g_new(gchar *, 1);
argv[0] = g_strdup("waves");
gtk_init(&argc, &argv);
gtk_rc_parse(gimp_gtkrc());
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("waves");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
dlg = mw_app_new("plug_in_waves", "Waves", &runp);
dlg = gimp_dialog_new ("Waves", "waves",
gimp_plugin_help_func, "filters/waves.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
hbox = gtk_hbox_new(FALSE, 5);
gtk_container_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
"OK", waves_ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show(vbox);
NULL);
preview = mw_preview_new(vbox, mwp, &waves_do_preview);
gtk_object_set_data(GTK_OBJECT(preview), "piArgs", argp);
gtk_object_set_data(GTK_OBJECT(preview), "mwRadioGroup", mode);
waves_do_preview(preview);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
mw_toggle_button_new(vbox, NULL, "Reflective", &argp->reflective);
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
frame = gtk_frame_new("Parameters");
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
preview = mw_preview_new (vbox, mwp, &waves_do_preview);
gtk_object_set_data (GTK_OBJECT (preview), "piArgs", argp);
gtk_object_set_data (GTK_OBJECT (preview), "mwRadioGroup", mode);
waves_do_preview (preview);
table = gtk_table_new(4, 2, FALSE);
gtk_container_border_width(GTK_CONTAINER (table), 5);
gtk_container_add(GTK_CONTAINER(frame), table);
mw_toggle_button_new (vbox, NULL, "Reflective", &argp->reflective);
mw_fscale_entry_new(table, "Amplitude", 0.0, 101.0, 1.0, 5.0, 0.0,
0, 1, 1, 2, &argp->amplitude);
mw_fscale_entry_new(table, "Phase", 0.0, 360.0, 2.0, 5.0, 0.0,
0, 1, 2, 3, &argp->phase);
mw_fscale_entry_new(table, "Wavelength", 0.1, 50.0, 1.0, 5.0, 0.0,
0, 1, 3, 4, &argp->wavelength);
gtk_widget_show(table);
vbox = gtk_vbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
mw_radio_group_new(vbox, "Mode", mode);
frame = gtk_frame_new ("Parameters");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
gtk_widget_show(table);
gtk_widget_show(dlg);
gtk_main();
gdk_flush();
table = gtk_table_new (4, 2, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
mw_fscale_entry_new (table, "Amplitude:", 0.0, 101.0, 1.0, 5.0, 0.0,
0, 1, 1, 2, &argp->amplitude);
mw_fscale_entry_new (table, "Phase:", 0.0, 360.0, 2.0, 5.0, 0.0,
0, 1, 2, 3, &argp->phase);
mw_fscale_entry_new (table, "Wavelength:", 0.1, 50.0, 1.0, 5.0, 0.0,
0, 1, 3, 4, &argp->wavelength);
gtk_widget_show (table);
mw_radio_group_new (vbox, "Mode", mode);
gtk_widget_show (table);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
argp->type = mw_radio_result(mode);
if(runp){
if (run_flag)
{
#if 0
fprintf(stderr, "running:\n");
/*fprintf(stderr, "\t(image %d)\n", argp->image);*/
fprintf(stderr, "\t(drawable %d)\n", argp->drawable);
fprintf(stderr, "\t(amplitude %f)\n", argp->amplitude);
fprintf(stderr, "\t(phase %f)\n", argp->phase);
fprintf(stderr, "\t(wavelength %f)\n", argp->wavelength);
fprintf(stderr, "\t(type %d)\n", argp->type);
fprintf(stderr, "\t(reflective %d)\n", argp->reflective);
fprintf(stderr, "running:\n");
/*fprintf(stderr, "\t(image %d)\n", argp->image);*/
fprintf(stderr, "\t(drawable %d)\n", argp->drawable);
fprintf(stderr, "\t(amplitude %f)\n", argp->amplitude);
fprintf(stderr, "\t(phase %f)\n", argp->phase);
fprintf(stderr, "\t(wavelength %f)\n", argp->wavelength);
fprintf(stderr, "\t(type %d)\n", argp->type);
fprintf(stderr, "\t(reflective %d)\n", argp->reflective);
#endif
return pluginCore(argp, drawable);
} else {
return r;
}
return pluginCore (argp, drawable);
}
else
{
return r;
}
}
static void
waves_do_preview(GtkWidget *w) {
waves_do_preview (GtkWidget *w)
{
static GtkWidget *theWidget = NULL;
struct piArgs *argp;
struct mwRadioGroup *rgp;
guchar *dst;
gint y;
if(theWidget==NULL){
theWidget=w;
}
if (theWidget==NULL)
{
theWidget=w;
}
argp = gtk_object_get_data(GTK_OBJECT(theWidget), "piArgs");
rgp = gtk_object_get_data(GTK_OBJECT(theWidget), "mwRadioGroup");
argp->type = mw_radio_result(rgp);
dst = (guchar*)malloc(mwp->width*mwp->height*mwp->bpp);
dst = g_new (guchar, mwp->width * mwp->height * mwp->bpp);
wave(mwp->bits, dst, mwp->width, mwp->height,
mwp->bpp, (argp->amplitude/mwp->scale), (argp->wavelength/mwp->scale),
argp->phase, argp->type==0, argp->reflective, 0);
wave (mwp->bits, dst, mwp->width, mwp->height,
mwp->bpp, (argp->amplitude/mwp->scale), (argp->wavelength/mwp->scale),
argp->phase, argp->type==0, argp->reflective, 0);
for(y=0;y<mwp->height; y++){
gtk_preview_draw_row(GTK_PREVIEW(theWidget),
dst+(y*mwp->width*mwp->bpp), 0, y,
mwp->width);
}
for (y = 0; y < mwp->height; y++)
{
gtk_preview_draw_row (GTK_PREVIEW (theWidget),
dst+(y*mwp->width*mwp->bpp), 0, y,
mwp->width);
}
gtk_widget_draw(theWidget, NULL);
gdk_flush();
free(dst);
gtk_widget_draw (theWidget, NULL);
gdk_flush ();
g_free (dst);
}
static void
wave(guchar *src, guchar *dst, gint width, gint height, gint bypp,
gdouble amplitude, gdouble wavelength, gdouble phase, gint smear,
gint reflective, gint verbose) {
wave (guchar *src,
guchar *dst,
gint width,
gint height,
gint bypp,
gdouble amplitude,
gdouble wavelength,
gdouble phase,
gint smear,
gint reflective,
gint verbose)
{
long rowsiz;
guchar *p;
guchar *dest;
@ -369,11 +432,11 @@ wave(guchar *src, guchar *dst, gint width, gint height, gint bypp,
phase = phase*G_PI/180;
rowsiz = width * bypp;
if (verbose) {
gimp_progress_init("Waves");
prog_interval=height/10;
}
if (verbose)
{
gimp_progress_init ("Waves");
prog_interval=height/10;
}
x1=y1=0;
x2=width;
@ -396,28 +459,31 @@ wave(guchar *src, guchar *dst, gint width, gint height, gint bypp,
*/
/* Center of selection */
cen_x = (double) (x2 - 1 + x1) / 2.0;
cen_y = (double) (y2 - 1 + y1) / 2.0;
/* Compute wave radii (semiaxes) */
xhsiz = (double) (x2 - x1) / 2.0;
yhsiz = (double) (y2 - y1) / 2.0;
/* These are the necessary scaling factors to turn the wave
ellipse into a large circle */
if (xhsiz < yhsiz) {
xscale = yhsiz / xhsiz;
yscale = 1.0;
} else if (xhsiz > yhsiz) {
xscale = 1.0;
yscale = xhsiz / yhsiz;
} else {
xscale = 1.0;
yscale = 1.0;
} /* else */
if (xhsiz < yhsiz)
{
xscale = yhsiz / xhsiz;
yscale = 1.0;
}
else if (xhsiz > yhsiz)
{
xscale = 1.0;
yscale = xhsiz / yhsiz;
}
else
{
xscale = 1.0;
yscale = 1.0;
}
radius = MAX(xhsiz, yhsiz);
radius2 = radius * radius;
@ -428,112 +494,130 @@ wave(guchar *src, guchar *dst, gint width, gint height, gint bypp,
wavelength = (wavelength * 2);
for (y = y1; y < y2; y++) {
dest = dst;
for (y = y1; y < y2; y++)
{
dest = dst;
if (verbose && (y % prog_interval == 0))
gimp_progress_update((double)y/(double)height);
if (verbose && (y % prog_interval == 0))
gimp_progress_update((double)y/(double)height);
for (x = x1; x < x2; x++) {
/* Distance from current point to wave center, scaled */
for (x = x1; x < x2; x++)
{
/* Distance from current point to wave center, scaled */
dx = (x - cen_x) * xscale;
dy = (y - cen_y) * yscale;
dx = (x - cen_x) * xscale;
dy = (y - cen_y) * yscale;
/* Distance^2 to center of *circle* (our scaled ellipse) */
d = sqrt(dx * dx + dy * dy);
/* Distance^2 to center of *circle* (our scaled ellipse) */
/* Use the formula described above. */
d = sqrt(dx * dx + dy * dy);
/* Calculate waved point and scale again to ellipsify */
/* Use the formula described above. */
/*
* Reflective waves are strange - the effect is much
* more like a mirror which is in the shape of
* the wave than anything else.
*/
/* Calculate waved point and scale again to ellipsify */
if (reflective)
{
amnt = amplitude * fabs (sin (((d / wavelength)
* (2.0 * G_PI) + phase)));
/*
* Reflective waves are strange - the effect is much
* more like a mirror which is in the shape of
* the wave than anything else.
*/
needx = (amnt * dx) / xscale + cen_x;
needy = (amnt * dy) / yscale + cen_y;
}
else
{
amnt = amplitude * sin (((d / wavelength)
* (2.0 * G_PI) + phase));
if (reflective){
amnt = amplitude * fabs(sin(((d / wavelength)
* (2.0 * G_PI) + phase)));
needx = (amnt + dx) / xscale + cen_x;
needy = (amnt + dy) / yscale + cen_y;
}
needx = (amnt * dx) / xscale + cen_x;
needy = (amnt * dy) / yscale + cen_y;
} else {
amnt = amplitude * sin(((d / wavelength)
* (2.0 * G_PI) + phase));
/* Calculations complete; now copy the proper pixel */
needx = (amnt + dx) / xscale + cen_x;
needy = (amnt + dy) / yscale + cen_y;
}
xi = needx;
yi = needy;
/* Calculations complete; now copy the proper pixel */
if (smear)
{
if (xi > width - 2)
{
xi = width - 2;
}
else if (xi < 0)
{
xi = 0;
}
if (yi > height - 2)
{
yi = height - 2;
}
else if (yi < 0)
{
yi = 0;
}
}
xi = needx;
yi = needy;
p = src + rowsiz * yi + xi * bypp;
if (smear){
if (xi > width - 2){
xi = width - 2;
} else if (xi < 0){
xi = 0;
}
if (yi > height - 2){
yi = height - 2;
} else if (yi < 0){
yi = 0;
}
}
x1_in = WITHIN (0, xi, width - 1);
y1_in = WITHIN (0, yi, height - 1);
x2_in = WITHIN (0, xi + 1, width - 1);
y2_in = WITHIN (0, yi + 1, height - 1);
p = src + rowsiz * yi + xi * bypp;
for (k = 0; k < bypp; k++)
{
if (x1_in && y1_in)
values[0] = *(p + k);
else
values[0] = 0;
x1_in = WITHIN(0, xi, width - 1);
y1_in = WITHIN(0, yi, height - 1);
x2_in = WITHIN(0, xi + 1, width - 1);
y2_in = WITHIN(0, yi + 1, height - 1);
if (x2_in && y1_in)
values[1] = *(p + bypp + k);
else
values[1] = 0;
for (k = 0; k < bypp; k++) {
if (x1_in && y1_in)
values[0] = *(p + k);
else
values[0] = 0;
if (x1_in && y2_in)
values[2] = *(p + rowsiz + k);
else
values[2] = 0;
if (x2_in && y1_in)
values[1] = *(p + bypp + k);
else
values[1] = 0;
if (x2_in)
{
if (y2_in)
values[3] = *(p + bypp + k + rowsiz);
else
values[3] = 0;
}
else
values[3] = 0;
if (x1_in && y2_in)
values[2] = *(p + rowsiz + k);
else
values[2] = 0;
val = bilinear (needx, needy, values);
if (x2_in) {
if (y2_in)
values[3] = *(p + bypp + k + rowsiz);
else
values[3] = 0;
} else
values[3] = 0;
*dest++ = val;
}
}
val = bilinear(needx, needy, values);
dst += rowsiz;
}
*dest++ = val;
} /* for */
} /* for */
if (verbose)
gimp_progress_update (1.0);
dst += rowsiz;
} /* for */
if (verbose) gimp_progress_update(1.0);
} /* wave */
}
static guchar
bilinear(gdouble x, gdouble y, guchar *v) {
bilinear (gdouble x,
gdouble y,
guchar *v)
{
double m0, m1;
x = fmod(x, 1.0);
y = fmod(y, 1.0);
x = fmod (x, 1.0);
y = fmod (y, 1.0);
if (x < 0)
x += 1.0;
@ -544,15 +628,4 @@ bilinear(gdouble x, gdouble y, guchar *v) {
m1 = (1.0 - x) * v[2] + x * v[3];
return (guchar) ((1.0 - y) * m0 + y * m1);
} /* bilinear */
/*
* Local Variables:
* c-file-style: GNU
* mode: C
* c-auto-newline: t
*
* End:
*/
/* end of file waves/waves.c */
}

1628
plug-ins/common/whirlpinch.c
View file

File diff suppressed because it is too large Load diff

810
plug-ins/common/wind.c
View file

File diff suppressed because it is too large Load diff

89
plug-ins/common/wmf.c
View file

@ -25,10 +25,11 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "gtk/gtk.h"
#include "libgimp/gimp.h"
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
typedef guchar BYTE;
typedef guint16 WORD;
@ -889,14 +890,6 @@ static GRunModeType l_run_mode;
static int pixs_per_in;
static void
load_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
load_ok_callback (GtkWidget *widget,
gpointer data)
@ -916,9 +909,7 @@ load_dialog (char *file_name)
{
LoadDialogVals *vals;
GtkWidget *frame;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *table;
GtkWidget *slider;
@ -926,67 +917,51 @@ load_dialog (char *file_name)
gchar **argv;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("load");
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("wmf");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
vals = g_malloc (sizeof (LoadDialogVals));
vals->dialog = gtk_dialog_new ();
vals = g_new (LoadDialogVals, 1);
vals->dialog = gimp_dialog_new ("Load Windows Metafile", "wmf",
gimp_plugin_help_func, "filters/wmf.html",
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
"OK", load_ok_callback,
vals, NULL, NULL, TRUE, FALSE,
"Cancel", gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
NULL);
gtk_window_set_title (GTK_WINDOW (vals->dialog), "Load Windows Metafile");
gtk_window_position (GTK_WINDOW (vals->dialog), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (vals->dialog), "destroy",
(GtkSignalFunc) load_close_callback,
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
/* Action area */
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) load_ok_callback,
vals);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dialog)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (vals->dialog));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dialog)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_show (button);
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (hbox), 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dialog)->vbox), hbox,
TRUE, TRUE, 0);
gtk_widget_show (hbox);
/* Rendering */
frame = gtk_frame_new (g_strdup_printf ("Rendering %s", file_name));
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 10);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (vals->dialog)->vbox), frame,
TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
/* Scale label */
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
label = gtk_label_new ("Scale (log 2)");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label = gtk_label_new ("Scale (log 2):");
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);