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

emit the "color_changed" signal whenever the user selects "Use FG/BG 

2000-01-17  Michael Natterer  <mitch@gimp.org>

	* libgimp/gimpcolorbutton.c: emit the "color_changed" signal
	whenever the user selects "Use FG/BG Color" from the popup menu.

	* libgimp/gimpwidgets.c: gimp_table_attach_aligned(): allow the
	function to be called with label == NULL.

	* plug-ins/AlienMap/AlienMap.c
	* plug-ins/AlienMap2/AlienMap2.c
	* plug-ins/common/CEL.c
	* plug-ins/common/CML_explorer.c
	* plug-ins/common/apply_lens.c
	* plug-ins/common/checkerboard.c
	* plug-ins/common/engrave.c
	* plug-ins/common/exchange.c
	* plug-ins/common/gauss_iir.c
	* plug-ins/common/gauss_rle.c
	* plug-ins/common/illusion.c
	* plug-ins/common/max_rgb.c
	* plug-ins/common/mblur.c
	* plug-ins/common/oilify.c
	* plug-ins/common/sel_gauss.c
	* plug-ins/common/shift.c
	* plug-ins/common/smooth_palette.c
	* plug-ins/common/sparkle.c
	* plug-ins/common/video.c
	* plug-ins/common/vpropagate.c
	* plug-ins/common/warp.c
	* plug-ins/sgi/sgi.c: more ui updates.
This commit is contained in:
Michael Natterer 2000-01-17 17:02:26 +00:00 committed by Michael Natterer
parent f9ebad26d7
commit 2f4a226ed2
27 changed files with 2020 additions and 2475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
ChangeLog
View File

@ -1,3 +1,34 @@
2000-01-17 Michael Natterer <mitch@gimp.org>
* libgimp/gimpcolorbutton.c: emit the "color_changed" signal
whenever the user selects "Use FG/BG Color" from the popup menu.
* libgimp/gimpwidgets.c: gimp_table_attach_aligned(): allow the
function to be called with label == NULL.
* plug-ins/AlienMap/AlienMap.c
* plug-ins/AlienMap2/AlienMap2.c
* plug-ins/common/CEL.c
* plug-ins/common/CML_explorer.c
* plug-ins/common/apply_lens.c
* plug-ins/common/checkerboard.c
* plug-ins/common/engrave.c
* plug-ins/common/exchange.c
* plug-ins/common/gauss_iir.c
* plug-ins/common/gauss_rle.c
* plug-ins/common/illusion.c
* plug-ins/common/max_rgb.c
* plug-ins/common/mblur.c
* plug-ins/common/oilify.c
* plug-ins/common/sel_gauss.c
* plug-ins/common/shift.c
* plug-ins/common/smooth_palette.c
* plug-ins/common/sparkle.c
* plug-ins/common/video.c
* plug-ins/common/vpropagate.c
* plug-ins/common/warp.c
* plug-ins/sgi/sgi.c: more ui updates.
2000-01-17 Shirasaki Yasuhiro <yasuhiro@gnome.gr.jp>
* plug-ins/common/csource.c

6
libgimp/gimpcolorbutton.c
View File

@ -494,6 +494,9 @@ gimp_color_button_use_fg (gpointer callback_data,
gimp_palette_get_foreground (gcb->color, gcb->color+1, gcb->color+2);
gimp_color_button_update (gcb);
gtk_signal_emit (GTK_OBJECT (gcb),
gimp_color_button_signals[COLOR_CHANGED]);
}
@ -510,6 +513,9 @@ gimp_color_button_use_bg (gpointer callback_data,
gimp_palette_get_background (gcb->color, gcb->color+1, gcb->color+2);
gimp_color_button_update (gcb);
gtk_signal_emit (GTK_OBJECT (gcb),
gimp_color_button_signals[COLOR_CHANGED]);
}
static gchar*

17
libgimp/gimpwidgets.c
View File

@ -468,14 +468,17 @@ gimp_table_attach_aligned (GtkTable *table,
GtkWidget *widget,
gboolean left_adjust)
{
GtkWidget *label;
if (text)
{
GtkWidget *label;
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
}
if (left_adjust)
{

6
libgimpwidgets/gimpcolorbutton.c
View File

@ -494,6 +494,9 @@ gimp_color_button_use_fg (gpointer callback_data,
gimp_palette_get_foreground (gcb->color, gcb->color+1, gcb->color+2);
gimp_color_button_update (gcb);
gtk_signal_emit (GTK_OBJECT (gcb),
gimp_color_button_signals[COLOR_CHANGED]);
}
@ -510,6 +513,9 @@ gimp_color_button_use_bg (gpointer callback_data,
gimp_palette_get_background (gcb->color, gcb->color+1, gcb->color+2);
gimp_color_button_update (gcb);
gtk_signal_emit (GTK_OBJECT (gcb),
gimp_color_button_signals[COLOR_CHANGED]);
}
static gchar*

17
libgimpwidgets/gimpwidgets.c
View File

@ -468,14 +468,17 @@ gimp_table_attach_aligned (GtkTable *table,
GtkWidget *widget,
gboolean left_adjust)
{
GtkWidget *label;
if (text)
{
GtkWidget *label;
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
label = gtk_label_new (text);
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_table_attach (table, GTK_WIDGET (label), 0, 1, row, row + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (label);
}
if (left_adjust)
{

426
plug-ins/AlienMap/AlienMap.c
View File

@ -99,42 +99,32 @@ static void build_preview_source_image( void);
static gint alienmap_dialog (void);
static void dialog_update_preview (void);
static void dialog_create_value (char *title, GtkTable *table, int row,
gdouble *value,
int left, int right, const char *desc);
static void dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value);
static void dialog_entry_update (GtkWidget *widget, gdouble *value);
static void dialog_ok_callback (GtkWidget *widget, gpointer data);
static void alienmap_toggle_update (GtkWidget *widget,
gpointer data);
static void alienmap_logo_dialog (void);
/***** Variables *****/
GtkWidget *maindlg;
GtkWidget *logodlg;
GtkTooltips *tips;
GdkColor tips_fg,tips_bg;
GtkWidget *maindlg;
GtkWidget *logodlg;
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static alienmap_interface_t wint =
{
NULL, /* preview */
NULL, /* image */
NULL, /* wimage */
FALSE /* run */
NULL, /* image */
NULL, /* wimage */
FALSE /* run */
};
static alienmap_vals_t wvals =
@ -148,29 +138,17 @@ static alienmap_vals_t wvals =
};
static GDrawable *drawable;
static gint tile_width, tile_height;
static gint img_width, img_height, img_bpp;
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint preview_width, preview_height;
static GTile *the_tile = NULL;
static double cen_x, cen_y;
static double scale_x, scale_y;
static gint tile_width, tile_height;
static gint img_width, img_height, img_bpp;
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint preview_width, preview_height;
static GTile *the_tile = NULL;
static gdouble cen_x, cen_y;
static gdouble scale_x, scale_y;
gint do_redsinus;
gint do_redcosinus;
gint do_rednone;
gint do_greensinus;
gint do_greencosinus;
gint do_greennone;
gint do_bluesinus;
gint do_bluecosinus;
gint do_bluenone;
/***** Functions *****/
MAIN ()
static void
@ -342,17 +320,17 @@ run (char *name,
/* Calculate preview size */
if (sel_width > sel_height)
{
pwidth = MIN(sel_width, PREVIEW_SIZE);
pwidth = MIN (sel_width, PREVIEW_SIZE);
pheight = sel_height * pwidth / sel_width;
}
else
{
pheight = MIN(sel_height, PREVIEW_SIZE);
pheight = MIN (sel_height, PREVIEW_SIZE);
pwidth = sel_width * pheight / sel_height;
}
preview_width = MAX(pwidth, 2); /* Min size is 2 */
preview_height = MAX(pheight, 2);
preview_width = MAX (pwidth, 2); /* Min size is 2 */
preview_height = MAX (pheight, 2);
/* See how we will run */
switch (run_mode)
@ -374,19 +352,19 @@ run (char *name,
if (status == STATUS_SUCCESS)
{
wvals.redstretch = param[3].data.d_int8;
wvals.redstretch = param[3].data.d_int8;
wvals.greenstretch = param[4].data.d_int8;
wvals.bluestretch = param[5].data.d_int8;
wvals.redmode = param[6].data.d_int8;
wvals.greenmode = param[7].data.d_int8;
wvals.bluemode = param[8].data.d_int8;
wvals.bluestretch = param[5].data.d_int8;
wvals.redmode = param[6].data.d_int8;
wvals.greenmode = param[7].data.d_int8;
wvals.bluemode = param[8].data.d_int8;
}
break;
case RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data("plug_in_alienmap", &wvals);
gimp_get_data ("plug_in_alienmap", &wvals);
break;
default:
@ -619,25 +597,14 @@ alienmap_dialog (void)
GtkWidget *dialog;
GtkWidget *top_table;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *toggle_vbox;
GtkWidget *toggle1;
GtkWidget *toggle2;
GtkWidget *toggle3;
GtkWidget *table;
GtkObject *adj;
gint argc;
gchar **argv;
guchar *color_cube;
GSList *redmode_group = NULL;
GSList *greenmode_group = NULL;
GSList *bluemode_group = NULL;
do_redsinus = (wvals.redmode == SINUS);
do_redcosinus = (wvals.redmode == COSINUS);
do_rednone = (wvals.redmode == NONE);
do_greensinus = (wvals.greenmode == SINUS);
do_greencosinus = (wvals.greenmode == COSINUS);
do_greennone = (wvals.greenmode == NONE);
do_bluesinus = (wvals.bluemode == SINUS);
do_bluecosinus = (wvals.bluemode == COSINUS);
do_bluenone = (wvals.bluemode == NONE);
argc = 1;
argv = g_new (gchar *, 1);
@ -705,156 +672,99 @@ alienmap_dialog (void)
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (table);
dialog_create_value("R", GTK_TABLE (table), 0, &wvals.redstretch,
0, 128.0,
_("Change intensity of the red channel"));
dialog_create_value ("G", GTK_TABLE (table), 1, &wvals.greenstretch,
0, 128.0,
_("Change intensity of the green channel"));
dialog_create_value ("B", GTK_TABLE (table), 2, &wvals.bluestretch,
0, 128.0,
_("Change intensity of the blue channel"));
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Red:"), SCALE_WIDTH, 0,
wvals.redstretch, 0, 128, 1, 8, 2,
_("Change intensity of the red channel"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.redstretch);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Green:"), SCALE_WIDTH, 0,
wvals.greenstretch, 0, 128, 1, 8, 2,
_("Change intensity of the green channel"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.greenstretch);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("Blue:"), SCALE_WIDTH, 0,
wvals.bluestretch, 0, 128, 1, 8, 2,
_("Change intensity of the blue channel"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.bluestretch);
/* Redmode toggle box */
frame = gtk_frame_new (_("Red"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_table_attach (GTK_TABLE (top_table), frame, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
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);
frame = gimp_radio_group_new2 (TRUE, _("Red"),
alienmap_toggle_update,
&wvals.redmode, (gpointer) wvals.redmode,
toggle = gtk_radio_button_new_with_label (redmode_group, _("Sine"));
redmode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_redsinus);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_redsinus);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Use sine-function for red component"), NULL);
_("Sine"), (gpointer) SINUS, &toggle1,
_("Cosine"), (gpointer) COSINUS, &toggle2,
_("None"), (gpointer) NONE, &toggle3,
toggle = gtk_radio_button_new_with_label (redmode_group, _("Cosine"));
redmode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_redcosinus);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_redcosinus);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Use cosine-function for red component"), NULL);
NULL);
toggle = gtk_radio_button_new_with_label (redmode_group, _("None"));
redmode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_rednone);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_rednone);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
gimp_help_set_help_data (toggle1,
_("Use sine-function for red component."), NULL);
gimp_help_set_help_data (toggle2,
_("Use cosine-function for red component."), NULL);
gimp_help_set_help_data (toggle3,
_("Red channel: use linear mapping instead "
"of any trigonometrical function"), NULL);
gtk_widget_show (toggle_vbox);
gtk_table_attach (GTK_TABLE (top_table), frame, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
gtk_widget_show (frame);
/* Greenmode toggle box */
frame = gtk_frame_new (_("Green"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
frame = gimp_radio_group_new2 (TRUE, _("Green"),
alienmap_toggle_update,
&wvals.greenmode, (gpointer) wvals.greenmode,
_("Sine"), (gpointer) SINUS, &toggle1,
_("Cosine"), (gpointer) COSINUS, &toggle2,
_("None"), (gpointer) NONE, &toggle3,
NULL);
gimp_help_set_help_data (toggle1,
_("Use sine-function for green component."), NULL);
gimp_help_set_help_data (toggle2,
_("Use cosine-function for green component."), NULL);
gimp_help_set_help_data (toggle3,
_("Green channel: use linear mapping instead "
"of any trigonometrical function"), NULL);
gtk_table_attach (GTK_TABLE (top_table), frame, 2, 3, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
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);
toggle = gtk_radio_button_new_with_label (greenmode_group, _("Sine"));
greenmode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_greensinus);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_greensinus);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Use sine-function for green component"), NULL);
toggle = gtk_radio_button_new_with_label (greenmode_group, _("Cosine"));
greenmode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_greencosinus);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_greencosinus);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Use cosine-function for green component"), NULL);
toggle = gtk_radio_button_new_with_label (greenmode_group, _("None"));
greenmode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_greennone);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_greennone);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Green channel: use linear mapping instead of "
"any trigonometrical function"), NULL);
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* Bluemode toggle box */
frame = gtk_frame_new (_("Blue:"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
frame = gimp_radio_group_new2 (TRUE, _("Blue"),
alienmap_toggle_update,
&wvals.bluemode, (gpointer) wvals.bluemode,
_("Sine"), (gpointer) SINUS, &toggle1,
_("Cosine"), (gpointer) COSINUS, &toggle2,
_("None"), (gpointer) NONE, &toggle3,
NULL);
gimp_help_set_help_data (toggle1,
_("Use sine-function for blue component."), NULL);
gimp_help_set_help_data (toggle2,
_("Use cosine-function for blue component."), NULL);
gimp_help_set_help_data (toggle3,
_("Blue channel: use linear mapping instead "
"of any trigonometrical function"), NULL);
gtk_table_attach (GTK_TABLE (top_table), frame, 3, 4, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
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);
toggle = gtk_radio_button_new_with_label (bluemode_group, _("Sine"));
bluemode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_bluesinus);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_bluesinus);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Use sine-function for blue component"), NULL);
toggle = gtk_radio_button_new_with_label (bluemode_group, _("Cosine"));
bluemode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_bluecosinus);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_bluecosinus);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Use cosine-function for blue component"), NULL);
toggle = gtk_radio_button_new_with_label (bluemode_group, _("None"));
bluemode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap_toggle_update),
&do_bluenone);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), do_bluenone);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle,
_("Blue channel: use linear mapping instead of "
"any trigonometrical function"), NULL);
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* Done */
gtk_widget_show (dialog);
dialog_update_preview ();
@ -935,107 +845,13 @@ dialog_update_preview (void)
gdk_flush();
}
static void
dialog_create_value (gchar *title,
GtkTable *table,
gint row,
gdouble *value,
gint left,
gint right,
const gchar *desc)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *entry;
GtkObject *scale_data;
gchar buf[256];
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,
(right - left) / 128,
(right - left) / 128,
0);
gtk_signal_connect(GTK_OBJECT(scale_data), "value_changed",
(GtkSignalFunc) dialog_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), 3);
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS);
gtk_widget_show(scale);
gimp_help_set_help_data (scale, desc, NULL);
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), "%0.2f", *value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) dialog_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);
gimp_help_set_help_data (entry, desc, NULL);
}
static void
dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value)
{
GtkWidget *entry;
char buf[256];
gimp_double_adjustment_update (adjustment, value);
if (*value != adjustment->value)
{
*value = adjustment->value;
entry = gtk_object_get_user_data(GTK_OBJECT(adjustment));
g_snprintf (buf, sizeof (buf), "%0.2f", *value);
gtk_signal_handler_block_by_data(GTK_OBJECT(entry), value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_handler_unblock_by_data(GTK_OBJECT(entry), value);
dialog_update_preview();
}
}
static void
dialog_entry_update (GtkWidget *widget,
gdouble *value)
{
GtkAdjustment *adjustment;
gdouble new_value;
new_value = atof(gtk_entry_get_text(GTK_ENTRY(widget)));
if (*value != new_value)
{
adjustment = gtk_object_get_user_data(GTK_OBJECT(widget));
if ((new_value >= adjustment->lower) &&
(new_value <= adjustment->upper))
{
*value = new_value;
adjustment->value = new_value;
gtk_signal_emit_by_name(GTK_OBJECT(adjustment), "value_changed");
dialog_update_preview();
}
}
dialog_update_preview ();
}
static void
@ -1043,6 +859,7 @@ dialog_ok_callback (GtkWidget *widget,
gpointer data)
{
wint.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
@ -1050,35 +867,8 @@ static void
alienmap_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
gimp_radio_button_update (widget, data);
toggle_val = (int *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
if (do_redsinus)
wvals.redmode = SINUS;
else if (do_redcosinus)
wvals.redmode = COSINUS;
else if (do_rednone)
wvals.redmode = NONE;
if (do_greensinus)
wvals.greenmode = SINUS;
else if (do_greencosinus)
wvals.greenmode = COSINUS;
else if (do_greennone)
wvals.greenmode = NONE;
if (do_bluesinus)
wvals.bluemode = SINUS;
else if (do_bluecosinus)
wvals.bluemode = COSINUS;
else if (do_bluenone)
wvals.bluemode = NONE;
dialog_update_preview ();
}

321
plug-ins/AlienMap2/AlienMap2.c
View File

@ -48,10 +48,6 @@
#define SCALE_WIDTH 200
#define ENTRY_WIDTH 45
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif /* M_PI */
/***** Color model *****/
#define RGB_MODEL 0
@ -66,7 +62,7 @@ typedef struct
gdouble greenangle;
gdouble bluefrequency;
gdouble blueangle;
gint colormodel;
gint colormodel;
gint redmode;
gint greenmode;
gint bluemode;
@ -105,15 +101,13 @@ static void build_preview_source_image (void);
static gint alienmap2_dialog (void);
static void dialog_update_preview (void);
static void dialog_create_value (char *title, GtkTable *table,
int row, gdouble *value,
int left, int right, const char *desc);
static void dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value);
static void dialog_entry_update (GtkWidget *widget, gdouble *value);
static void dialog_ok_callback (GtkWidget *widget, gpointer data);
static void alienmap2_toggle_update (GtkWidget *widget,
gpointer data);
static void alienmap2_radio_update (GtkWidget *widget,
gpointer data);
static void alienmap2_logo_dialog (void);
static void rgb_to_hsl (gdouble r,
@ -133,23 +127,21 @@ static void hsl_to_rgb (gdouble h,
GtkWidget *maindlg;
GtkWidget *logodlg;
GtkTooltips *tips;
GdkColor tips_fg,tips_bg;
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static alienmap2_interface_t wint =
{
NULL, /* preview */
NULL, /* image */
NULL, /* wimage */
FALSE /* run */
NULL, /* image */
NULL, /* wimage */
FALSE /* run */
};
static alienmap2_vals_t wvals =
@ -167,17 +159,14 @@ static alienmap2_vals_t wvals =
};
static GDrawable *drawable;
static gint tile_width, tile_height;
static gint img_width, img_height, img_bpp;
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint preview_width, preview_height;
static GTile *the_tile = NULL;
static double cen_x, cen_y;
static double scale_x, scale_y;
gint use_rgb;
gint use_hsl;
static gint tile_width, tile_height;
static gint img_width, img_height, img_bpp;
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint preview_width, preview_height;
static GTile *the_tile = NULL;
static gdouble cen_x, cen_y;
static gdouble scale_x, scale_y;
/***** Functions *****/
@ -239,11 +228,11 @@ transform (short int *r,
b1 = (gdouble) blue / 255.0;
rgb_to_hsl (r1, g1, b1, &h, &s, &l);
if (wvals.redmode)
h = 0.5*(1.0+sin(((2*h-1.0)*wvals.redfrequency+wvals.redangle/180.0)*M_PI));
h = 0.5*(1.0+sin(((2*h-1.0)*wvals.redfrequency+wvals.redangle/180.0)*G_PI));
if (wvals.greenmode)
s = 0.5*(1.0+sin(((2*s-1.0)*wvals.greenfrequency+wvals.greenangle/180.0)*M_PI));
s = 0.5*(1.0+sin(((2*s-1.0)*wvals.greenfrequency+wvals.greenangle/180.0)*G_PI));
if (wvals.bluemode)
l = 0.5*(1.0+sin(((2*l-1.0)*wvals.bluefrequency+wvals.blueangle/180.0)*M_PI));
l = 0.5*(1.0+sin(((2*l-1.0)*wvals.bluefrequency+wvals.blueangle/180.0)*G_PI));
hsl_to_rgb (h, s, l, &r1, &g1, &b1);
red = (gint) (255.0 * r1 + 0.5);
green = (gint) (255.0 * g1 + 0.5);
@ -252,11 +241,11 @@ transform (short int *r,
else if (wvals.colormodel == RGB_MODEL)
{
if (wvals.redmode)
red = (int) (127.5*(1.0+sin(((red/127.5-1.0)*wvals.redfrequency+wvals.redangle/180.0)*M_PI))+0.5);
red = (int) (127.5*(1.0+sin(((red/127.5-1.0)*wvals.redfrequency+wvals.redangle/180.0)*G_PI))+0.5);
if (wvals.greenmode)
green = (int) (127.5*(1.0+sin(((green/127.5-1.0)*wvals.greenfrequency+wvals.greenangle/180.0)*M_PI))+0.5);
green = (int) (127.5*(1.0+sin(((green/127.5-1.0)*wvals.greenfrequency+wvals.greenangle/180.0)*G_PI))+0.5);
if (wvals.bluemode)
blue = (int) (127.5*(1.0+sin(((blue/127.5-1.0)*wvals.bluefrequency+wvals.blueangle/180.0)*M_PI))+0.5);
blue = (int) (127.5*(1.0+sin(((blue/127.5-1.0)*wvals.bluefrequency+wvals.blueangle/180.0)*G_PI))+0.5);
}
*r = red;
@ -361,16 +350,16 @@ run (char *name,
if (status == STATUS_SUCCESS)
{
wvals.redfrequency = param[3].data.d_float;
wvals.redangle = param[4].data.d_float;
wvals.redfrequency = param[3].data.d_float;
wvals.redangle = param[4].data.d_float;
wvals.greenfrequency = param[5].data.d_float;
wvals.greenangle = param[6].data.d_float;
wvals.bluefrequency = param[7].data.d_float;
wvals.blueangle = param[8].data.d_float;
wvals.colormodel = param[9].data.d_int8;
wvals.redmode = param[10].data.d_int8 ? TRUE : FALSE;
wvals.greenmode = param[11].data.d_int8 ? TRUE : FALSE;
wvals.bluemode = param[12].data.d_int8 ? TRUE : FALSE;
wvals.greenangle = param[6].data.d_float;
wvals.bluefrequency = param[7].data.d_float;
wvals.blueangle = param[8].data.d_float;
wvals.colormodel = param[9].data.d_int8;
wvals.redmode = param[10].data.d_int8 ? TRUE : FALSE;
wvals.greenmode = param[11].data.d_int8 ? TRUE : FALSE;
wvals.bluemode = param[12].data.d_int8 ? TRUE : FALSE;
}
break;
@ -597,20 +586,18 @@ build_preview_source_image (void)
static gint
alienmap2_dialog (void)
{
GtkWidget *dialog;
GtkWidget *top_table;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *toggle_vbox;
GtkWidget *table;
GSList *mode_group = NULL;
GtkWidget *dialog;
GtkWidget *top_table;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *toggle_vbox;
GtkWidget *sep;
GtkWidget *table;
GtkObject *adj;
gint argc;
gchar **argv;
guchar *color_cube;
use_rgb = (wvals.colormodel == RGB_MODEL);
use_hsl = (wvals.colormodel == HSL_MODEL);
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("alienmap2");
@ -676,64 +663,80 @@ alienmap2_dialog (void)
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_attach (GTK_TABLE (top_table), table, 0, 2, 1, 2,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show(table);
gtk_widget_show (table);
dialog_create_value (_("R/H-Frequency:"), GTK_TABLE (table), 0,
&wvals.redfrequency, 0, 5.0,
_("Change frequency of the red/hue channel"));
if (wvals.redfrequency!=1.0)
exit;
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("R/H-Frequency:"), SCALE_WIDTH, 0,
wvals.redfrequency, 0, 5.0, 0.1, 1, 2,
_("Change frequency of the red/hue channel"),
NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.redfrequency);
dialog_create_value (_("R/H-Phaseshift:"), GTK_TABLE (table), 1,
&wvals.redangle, 0, 360.0,
_("Change angle of the red/hue channel"));
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("R/H-Phaseshift:"), SCALE_WIDTH, 0,
wvals.redangle, 0, 360.0, 1, 15, 2,
_("Change angle of the red/hue channel"),
NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.redangle);
dialog_create_value (_("G/S-Frequency:"), GTK_TABLE (table), 2,
&wvals.greenfrequency, 0, 5.0,
_("Change frequeny of the green/saturation channel"));
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("G/S-Frequency:"), SCALE_WIDTH, 0,
wvals.greenfrequency, 0, 5.0, 0.1, 1, 2,
_("Change frequency of the green/saturation "
"channel"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.greenfrequency);
dialog_create_value (_("G/S-Phaseshift:"), GTK_TABLE (table), 3,
&wvals.greenangle, 0, 360.0,
_("Change angle of the green/saturation channel"));
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 3,
_("G/S-Phaseshift:"), SCALE_WIDTH, 0,
wvals.redangle, 0, 360.0, 1, 15, 2,
_("Change angle of the green/saturation channel"),
NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.greenangle);
dialog_create_value (_("B/L-Frequency:"), GTK_TABLE (table), 4,
&wvals.bluefrequency, 0, 5.0,
_("Change frequency of the blue/luminance channel"));
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 4,
_("B/L-Frequency:"), SCALE_WIDTH, 0,
wvals.bluefrequency, 0, 5.0, 0.1, 1, 2,
_("Change frequency of the blue/luminance "
"channel"), NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.bluefrequency);
dialog_create_value (_("B/L-Phaseshift:"), GTK_TABLE (table), 5,
&wvals.blueangle, 0, 360.0,
_("Change angle of the blue/luminance channel"));
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 5,
_("B/L-Phaseshift:"), SCALE_WIDTH, 0,
wvals.blueangle, 0, 360.0, 1, 15, 2,
_("Change angle of the blue/luminance channel"),
NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&wvals.blueangle);
/* Mode toggle box */
frame = gtk_frame_new (_("Mode"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
frame =
gimp_radio_group_new2 (TRUE, _("Mode"),
alienmap2_radio_update,
&wvals.colormodel, (gpointer) wvals.colormodel,
_("RGB Color Model"), (gpointer) RGB_MODEL, NULL,
_("HSL Color Model"), (gpointer) HSL_MODEL, NULL,
NULL);
gtk_table_attach (GTK_TABLE (top_table), frame, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
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);
toggle = gtk_radio_button_new_with_label (mode_group,
_("RGB_MODEL Color Model"));
mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap2_toggle_update),
&use_rgb);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), use_rgb);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle, _("Use RGB_MODEL color model"), NULL);
toggle_vbox = GTK_BIN (frame)->child;
toggle = gtk_radio_button_new_with_label (mode_group,
_("HSL_MODEL Color Model"));
mode_group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (alienmap2_toggle_update),
&use_hsl);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), use_hsl);
gtk_widget_show (toggle);
gimp_help_set_help_data (toggle, _("Use HSL_MODEL color model"), NULL);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (toggle_vbox), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
toggle = gtk_check_button_new_with_label (_("Modify Red/Hue Channel"));
gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0);
@ -767,7 +770,6 @@ alienmap2_dialog (void)
_("Use function for blue/luminance component"),
NULL);
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
gtk_widget_show (dialog);
@ -845,106 +847,13 @@ dialog_update_preview (void)
gdk_flush ();
}
static void
dialog_create_value (char *title,
GtkTable *table,
int row,
gdouble *value,
int left,
int right,
const char *desc)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *entry;
GtkObject *scale_data;
gchar buf[256];
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,
(right - left) / 128,
(right - left) / 128,
0);
gtk_signal_connect(GTK_OBJECT(scale_data), "value_changed",
(GtkSignalFunc) dialog_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), 3);
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS);
gtk_widget_show(scale);
gimp_help_set_help_data (scale, desc, NULL);
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), "%0.2f", *value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) dialog_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);
gimp_help_set_help_data (entry, desc, NULL);
}
static void
dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value)
{
GtkWidget *entry;
gchar buf[256];
gimp_double_adjustment_update (adjustment, value);
if (*value != adjustment->value)
{
*value = adjustment->value;
entry = gtk_object_get_user_data(GTK_OBJECT(adjustment));
g_snprintf(buf, sizeof (buf), "%0.2f", *value);
gtk_signal_handler_block_by_data(GTK_OBJECT(entry), value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_handler_unblock_by_data(GTK_OBJECT(entry), value);
dialog_update_preview();
}
}
static void
dialog_entry_update (GtkWidget *widget,
gdouble *value)
{
GtkAdjustment *adjustment;
gdouble new_value;
new_value = atof(gtk_entry_get_text(GTK_ENTRY(widget)));
if (*value != new_value)
{
adjustment = gtk_object_get_user_data(GTK_OBJECT(widget));
if ((new_value >= adjustment->lower) &&
(new_value <= adjustment->upper))
{
*value = new_value;
adjustment->value = new_value;
gtk_signal_emit_by_name(GTK_OBJECT(adjustment), "value_changed");
dialog_update_preview();
}
}
dialog_update_preview();
}
static void
@ -960,20 +869,16 @@ static void
alienmap2_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
gimp_toggle_button_update (widget, data);
toggle_val = (int *) data;
dialog_update_preview ();
}
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
/* determine colormodel */
if (use_rgb)
wvals.colormodel = RGB_MODEL;
else if (use_hsl)
wvals.colormodel = HSL_MODEL;
static void
alienmap2_radio_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
dialog_update_preview ();
}

745
plug-ins/common/CEL.c
View File

@ -35,37 +35,48 @@
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
static void query(void);
static void run(char *name, int nparams, GParam *param,
int *nreturn_vals, GParam **return_vals);
static gint load_palette(FILE *fp, guchar palette[]);
static gint32 load_image(char *file, char *brief);
static gint save_image(char *file, char *brief,
gint32 image, gint32 layer);
static gint palette_dialog(char *title);
static void query (void);
static void run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static gint load_palette (FILE *fp,
guchar palette[]);
static gint32 load_image (gchar *file,
gchar *brief);
static gint save_image (gchar *file,
gchar *brief,
gint32 image,
gint32 layer);
static gint palette_dialog (gchar *title);
/* Globals... */
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
char *palette_file= NULL;
size_t data_length= 0;
static char *palette_file = NULL;
static size_t data_length = 0;
/* Let GIMP library handle initialisation (and inquisitive users) */
MAIN()
MAIN ()
/* GIMP queries plug-in for parameters etc. */
static void query(void) {
static void
query (void)
{
static GParamDef load_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
@ -78,9 +89,9 @@ static void query(void) {
{
{ PARAM_IMAGE, "image", "Output image" },
};
static int nload_args = sizeof (load_args) / sizeof (load_args[0]);
static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef save_args[] =
static gint nload_args = sizeof (load_args) / sizeof (load_args[0]);
static gint nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef save_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" },
@ -89,33 +100,47 @@ static void query(void) {
{ PARAM_STRING, "raw_filename", "Name entered" },
{ PARAM_STRING, "palette_filename", "Filename to save palette to" },
};
static int nsave_args = sizeof (save_args) / sizeof (save_args[0]);
static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]);
INIT_I18N();
gimp_install_procedure("file_cel_load",
_("Loads files in KISS CEL file format"),
_("This plug-in loads individual KISS cell files."),
"Nick Lamb", "Nick Lamb <njl195@zepler.org.uk>", "May 1998",
"<Load>/CEL", NULL, PROC_PLUG_IN,
nload_args, nload_return_vals, load_args, load_return_vals);
gimp_install_procedure ("file_cel_load",
_("Loads files in KISS CEL file format"),
_("This plug-in loads individual KISS cell files."),
"Nick Lamb",
"Nick Lamb <njl195@zepler.org.uk>",
"May 1998",
"<Load>/CEL",
NULL,
PROC_PLUG_IN,
nload_args, nload_return_vals,
load_args, load_return_vals);
gimp_register_magic_load_handler("file_cel_load", "cel",
"", "0,string,KiSS\040");
gimp_register_magic_load_handler ("file_cel_load", "cel",
"", "0,string,KiSS\040");
gimp_install_procedure("file_cel_save",
_("Saves files in KISS CEL file format"),
_("This plug-in saves individual KISS cell files."),
"Nick Lamb", "Nick Lamb <njl195@zepler.org.uk>", "May 1998",
"<Save>/CEL", "INDEXEDA",
PROC_PLUG_IN, nsave_args, 0, save_args, NULL);
gimp_install_procedure ("file_cel_save",
_("Saves files in KISS CEL file format"),
_("This plug-in saves individual KISS cell files."),
"Nick Lamb",
"Nick Lamb <njl195@zepler.org.uk>",
"May 1998",
"<Save>/CEL",
"INDEXEDA",
PROC_PLUG_IN,
nsave_args, 0,
save_args, NULL);
gimp_register_save_handler("file_cel_save", "cel", "");
gimp_register_save_handler ("file_cel_save", "cel", "");
}
static void run(char *name, int nparams, GParam *param,
int *nreturn_vals, GParam **return_vals) {
static void
run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals)
{
gint32 image; /* image ID after load */
gint status; /* status after save */
static GParam values[2]; /* Return values */
@ -130,63 +155,84 @@ static void run(char *name, int nparams, GParam *param,
values[0].data.d_status = STATUS_SUCCESS;
*return_vals = values;
if (run_mode == RUN_INTERACTIVE) {
INIT_I18N_UI();
} else {
INIT_I18N();
}
if (strcmp(name, "file_cel_load") == 0) {
if (run_mode != RUN_NONINTERACTIVE) {
gimp_get_data ("file_cel_save:length", &data_length);
if (data_length > 0) {
palette_file= (char *) g_malloc(data_length);
gimp_get_data ("file_cel_save:data", palette_file);
} else {
palette_file= g_strdup("*.kcf");
data_length= strlen(palette_file) + 1;
}
if (run_mode == RUN_INTERACTIVE)
{
INIT_I18N_UI();
}
else
{
INIT_I18N();
}
if (run_mode == RUN_NONINTERACTIVE) {
palette_file= param[3].data.d_string;
data_length= strlen(palette_file) + 1;
} else if (run_mode == RUN_INTERACTIVE) {
if (strcmp (name, "file_cel_load") == 0)
{
if (run_mode != RUN_NONINTERACTIVE)
{
gimp_get_data ("file_cel_save:length", &data_length);
if (data_length > 0)
{
palette_file = (char *) g_malloc(data_length);
gimp_get_data ("file_cel_save:data", palette_file);
}
else
{
palette_file = g_strdup("*.kcf");
data_length = strlen(palette_file) + 1;
}
}
/* Let user choose KCF palette (cancel ignores) */
palette_dialog( _("Load KISS Palette"));
gimp_set_data ("file_cel_save:length", &data_length, sizeof (size_t));
gimp_set_data ("file_cel_save:data", palette_file, data_length);
if (run_mode == RUN_NONINTERACTIVE)
{
palette_file = param[3].data.d_string;
data_length = strlen(palette_file) + 1;
}
else if (run_mode == RUN_INTERACTIVE)
{
/* Let user choose KCF palette (cancel ignores) */
palette_dialog (_("Load KISS Palette"));
gimp_set_data ("file_cel_save:length", &data_length, sizeof (size_t));
gimp_set_data ("file_cel_save:data", palette_file, data_length);
}
image = load_image (param[1].data.d_string, param[2].data.d_string);
if (image != -1)
{
*nreturn_vals = 2;
values[1].type = PARAM_IMAGE;
values[1].data.d_image = image;
}
else
{
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
}
image = load_image(param[1].data.d_string, param[2].data.d_string);
if (image != -1) {
*nreturn_vals = 2;
values[1].type = PARAM_IMAGE;
values[1].data.d_image = image;
} else {
else if (strcmp (name, "file_cel_save") == 0)
{
status = save_image (param[3].data.d_string, param[4].data.d_string,
param[1].data.d_int32, param[2].data.d_int32);
if (status != TRUE)
{
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
else
{
gimp_set_data ("file_cel_save:length", &data_length, sizeof (size_t));
gimp_set_data ("file_cel_save:data", palette_file, data_length);
}
}
else
{
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
} else if (strcmp (name, "file_cel_save") == 0) {
status = save_image(param[3].data.d_string, param[4].data.d_string,
param[1].data.d_int32, param[2].data.d_int32);
if (status != TRUE) {
values[0].data.d_status = STATUS_EXECUTION_ERROR;
} else {
gimp_set_data ("file_cel_save:length", &data_length, sizeof (size_t));
gimp_set_data ("file_cel_save:data", palette_file, data_length);
}
} else {
values[0].data.d_status = STATUS_EXECUTION_ERROR;
}
}
/* Load CEL image into The GIMP */
static gint32 load_image(char *file, char *brief) {
static gint32
load_image (gchar *file,
gchar *brief)
{
FILE* fp; /* Read file pointer */
char *progress; /* Title for progress display */
guchar header[32]; /* File header */
@ -205,182 +251,224 @@ static gint32 load_image(char *file, char *brief) {
int i, j, k; /* Counters */
/* Open the file for reading */
/* Open the file for reading */
fp = fopen(file, "r");
if (fp == NULL) {
g_message( _("%s\nis not present or is unreadable"), file);
gimp_quit();
}
if (fp == NULL)
{
g_message (_("%s\nis not present or is unreadable"), file);
gimp_quit ();
}
progress = g_strdup_printf (_("Loading %s:"), brief);
gimp_progress_init (progress);
g_free (progress);
/* Get the image dimensions and create the image... */
/* Get the image dimensions and create the image... */
fread(header, 4, 1, fp);
fread (header, 4, 1, fp);
if (strncmp(header, "KiSS", 4)) {
colours= 16;
width= header[0] + (256 * header[1]);
height= header[2] + (256 * header[3]);
offx= 0;
offy= 0;
} else { /* New-style image file, read full header */
fread(header, 28, 1, fp);
colours= (1 << header[1]);
width= header[4] + (256 * header[5]);
height= header[6] + (256 * header[7]);
offx= header[8] + (256 * header[9]);
offy= header[10] + (256 * header[11]);
}
image = gimp_image_new(width + offx, height + offy, INDEXED);
if (image == -1) {
g_message( _("CEL Can't create a new image"));
gimp_quit();
}
gimp_image_set_filename(image, file);
/* Create an indexed-alpha layer to hold the image... */
layer = gimp_layer_new(image, _("Background"), width, height,
INDEXEDA_IMAGE, 100, NORMAL_MODE);
gimp_image_add_layer(image, layer, 0);
gimp_layer_set_offsets(layer, offx, offy);
/* Get the drawable and set the pixel region for our load... */
drawable = gimp_drawable_get(layer);
gimp_pixel_rgn_init(&pixel_rgn, drawable, 0, 0, drawable->width,
drawable->height, TRUE, FALSE);
/* Read the image in and give it to the GIMP a line at a time */
buffer = g_new(guchar, width);
line = g_new(guchar, (width+1) * 2);
for (i = 0; i < height && !feof(fp); ++i) {
switch (colours) {
case 16:
fread(buffer, (width+1)/2, 1, fp);
for (j = 0, k = 0; j < width*2; j+= 4, ++k) {
if (buffer[k] / 16 == 0) {
line[j]= 16;
line[j+1]= 0;
} else {
line[j]= (buffer[k] / 16) - 1;
line[j+1]= 255;
}
if (buffer[k] % 16 == 0) {
line[j+2]= 16;
line[j+3]= 0;
} else {
line[j+2]= (buffer[k] % 16) - 1;
line[j+3]= 255;
}
}
break;
case 256:
fread(buffer, width, 1, fp);
for (j = 0, k = 0; j < width*2; j+= 2, ++k) {
if (buffer[k] == 0) {
line[j]= 255;
line[j+1]= 0;
} else {
line[j]= buffer[k] - 1;
line[j+1]= 255;
}
}
break;
default:
g_message( _("Unsupported number of colours (%d)"), colours);
gimp_quit();
if (strncmp(header, "KiSS", 4))
{
colours= 16;
width= header[0] + (256 * header[1]);
height= header[2] + (256 * header[3]);
offx= 0;
offy= 0;
}
else
{ /* New-style image file, read full header */
fread (header, 28, 1, fp);
colours = (1 << header[1]);
width = header[4] + (256 * header[5]);
height = header[6] + (256 * header[7]);
offx = header[8] + (256 * header[9]);
offy = header[10] + (256 * header[11]);
}
image = gimp_image_new (width + offx, height + offy, INDEXED);
if (image == -1)
{
g_message (_("CEL Can't create a new image"));
gimp_quit ();
}
gimp_image_set_filename (image, file);
/* Create an indexed-alpha layer to hold the image... */
layer = gimp_layer_new (image, _("Background"), width, height,
INDEXEDA_IMAGE, 100, NORMAL_MODE);
gimp_image_add_layer (image, layer, 0);
gimp_layer_set_offsets (layer, offx, offy);
/* Get the drawable and set the pixel region for our load... */
drawable = gimp_drawable_get (layer);
gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, drawable->width,
drawable->height, TRUE, FALSE);
/* Read the image in and give it to the GIMP a line at a time */
buffer = g_new (guchar, width);
line = g_new (guchar, (width+1) * 2);
for (i = 0; i < height && !feof(fp); ++i)
{
switch (colours)
{
case 16:
fread (buffer, (width+1)/2, 1, fp);
for (j = 0, k = 0; j < width*2; j+= 4, ++k)
{
if (buffer[k] / 16 == 0)
{
line[j]= 16;
line[j+1]= 0;
}
else
{
line[j]= (buffer[k] / 16) - 1;
line[j+1]= 255;
}
if (buffer[k] % 16 == 0)
{
line[j+2]= 16;
line[j+3]= 0;
}
else
{
line[j+2]= (buffer[k] % 16) - 1;
line[j+3]= 255;
}
}
break;
case 256:
fread (buffer, width, 1, fp);
for (j = 0, k = 0; j < width*2; j+= 2, ++k)
{
if (buffer[k] == 0)
{
line[j]= 255;
line[j+1]= 0;
}
else
{
line[j]= buffer[k] - 1;
line[j+1]= 255;
}
}
break;
default:
g_message (_("Unsupported number of colours (%d)"), colours);
gimp_quit ();
}
gimp_pixel_rgn_set_rect(&pixel_rgn, line, 0, i, drawable->width, 1);
gimp_progress_update((float) i / (float) height);
}
/* Close image files, give back allocated memory */
fclose(fp);
g_free(buffer);
g_free(line);
/* Use palette from file or otherwise default grey palette */
palette = g_new(guchar, colours*3);
/* Open the file for reading if user picked one */
if (palette_file == NULL) {
fp= NULL;
} else {
fp = fopen(palette_file, "r");
}
if (fp != NULL) {
colours= load_palette(fp, palette);
} else {
for (i= 0; i < colours; ++i) {
palette[i*3]= palette[i*3+1]= palette[i*3+2]= i * 256 / colours;
gimp_pixel_rgn_set_rect (&pixel_rgn, line, 0, i, drawable->width, 1);
gimp_progress_update ((float) i / (float) height);
}
}
gimp_image_set_cmap(image, palette + 3, colours - 1);
/* Close image files, give back allocated memory */
/* Close palette file, give back allocated memory */
fclose (fp);
g_free (buffer);
g_free (line);
fclose(fp);
g_free(palette);
/* Use palette from file or otherwise default grey palette */
palette = g_new (guchar, colours*3);
/* Now get everything redrawn and hand back the finished image */
/* Open the file for reading if user picked one */
if (palette_file == NULL)
{
fp= NULL;
}
else
{
fp = fopen (palette_file, "r");
}
gimp_drawable_flush(drawable);
gimp_drawable_detach(drawable);
if (fp != NULL)
{
colours = load_palette (fp, palette);
}
else
{
for (i= 0; i < colours; ++i)
{
palette[i*3]= palette[i*3+1]= palette[i*3+2]= i * 256 / colours;
}
}
gimp_image_set_cmap (image, palette + 3, colours - 1);
/* Close palette file, give back allocated memory */
fclose (fp);
g_free (palette);
/* Now get everything redrawn and hand back the finished image */
gimp_drawable_flush (drawable);
gimp_drawable_detach (drawable);
return (image);
}
static gint load_palette(FILE *fp, guchar palette[]) {
static gint
load_palette (FILE *fp,
guchar palette[])
{
guchar header[32]; /* File header */
guchar buffer[2];
int i, bpp, colours= 0;
fread(header, 4, 1, fp);
if (!strncmp(header, "KiSS", 4)) {
fread(header+4, 28, 1, fp);
bpp= header[5];
colours= header[8] + header[9] * 256;
if (bpp == 12) {
for (i= 0; i < colours; ++i) {
fread(buffer, 1, 2, fp);
palette[i*3]= buffer[0] & 0xf0;
palette[i*3+1]= (buffer[1] & 0x0f) * 16;
palette[i*3+2]= (buffer[0] & 0x0f) * 16;
}
} else {
fread(palette, colours, 3, fp);
fread (header, 4, 1, fp);
if (!strncmp(header, "KiSS", 4))
{
fread (header+4, 28, 1, fp);
bpp = header[5];
colours = header[8] + header[9] * 256;
if (bpp == 12)
{
for (i= 0; i < colours; ++i)
{
fread (buffer, 1, 2, fp);
palette[i*3]= buffer[0] & 0xf0;
palette[i*3+1]= (buffer[1] & 0x0f) * 16;
palette[i*3+2]= (buffer[0] & 0x0f) * 16;
}
}
else
{
fread (palette, colours, 3, fp);
}
}
} else {
colours= 16; bpp= 12;
fseek(fp, 0, SEEK_SET);
for (i= 0; i < colours; ++i) {
fread(buffer, 1, 2, fp);
palette[i*3]= buffer[0] & 0xf0;
palette[i*3+1]= (buffer[1] & 0x0f) * 16;
palette[i*3+2]= (buffer[0] & 0x0f) * 16;
else
{
colours = 16; bpp = 12;
fseek (fp, 0, SEEK_SET);
for (i= 0; i < colours; ++i)
{
fread (buffer, 1, 2, fp);
palette[i*3] = buffer[0] & 0xf0;
palette[i*3+1] = (buffer[1] & 0x0f) * 16;
palette[i*3+2] = (buffer[0] & 0x0f) * 16;
}
}
}
return colours;
}
static gint save_image(char *file, char *brief, gint32 image, gint32 layer) {
static gint
save_image (gchar *file,
gchar *brief,
gint32 image,
gint32 layer)
{
FILE* fp; /* Write file pointer */
char *progress; /* Title for progress display */
guchar header[32]; /* File header */
@ -394,110 +482,121 @@ static gint save_image(char *file, char *brief, gint32 image, gint32 layer) {
int i, j, k; /* Counters */
/* Check that this is an indexed image, fail otherwise */
type= gimp_drawable_type(layer);
if (type != INDEXEDA_IMAGE) {
g_message( _("Only an indexed-alpha image can be saved in CEL format"));
gimp_quit();
}
/* Check that this is an indexed image, fail otherwise */
type = gimp_drawable_type (layer);
if (type != INDEXEDA_IMAGE)
{
g_message (_("Only an indexed-alpha image can be saved in CEL format"));
gimp_quit ();
}
/* Find out how offset this layer was */
gimp_drawable_offsets(layer, &offx, &offy);
gimp_drawable_offsets (layer, &offx, &offy);
drawable = gimp_drawable_get(layer);
drawable = gimp_drawable_get (layer);
/* Open the file for writing */
fp = fopen(file, "w");
/* Open the file for writing */
fp = fopen (file, "w");
if (fp == NULL) {
g_message( _("CEL Couldn't write image to\n%s"), file);
gimp_quit();
}
if (fp == NULL)
{
g_message (_("CEL Couldn't write image to\n%s"), file);
gimp_quit ();
}
progress = g_strdup_printf (_("Loading %s:"), brief);
gimp_progress_init (progress);
g_free (progress);
/* Headers */
memset(header, 0, 32);
strcpy(header, "KiSS");
/* Headers */
memset (header, 0, 32);
strcpy (header, "KiSS");
header[4]= 0x20;
/* Work out whether to save as 8bit or 4bit */
gimp_image_get_cmap(image, &colours);
if (colours > 15) {
header[5]= 8;
} else {
header[5]= 4;
}
/* Fill in the blanks ... */
header[8]= drawable->width % 256;
header[9]= drawable->width / 256;
header[10]= drawable->height % 256;
header[11]= drawable->height / 256;
header[12]= offx % 256;
header[13]= offx / 256;
header[14]= offy % 256;
header[15]= offy / 256;
fwrite(header, 32, 1, fp);
/* Arrange for memory etc. */
gimp_pixel_rgn_init(&pixel_rgn, drawable, 0, 0, drawable->width,
drawable->height, TRUE, FALSE);
buffer = g_new(guchar, drawable->width);
line = g_new(guchar, (drawable->width+1) * 2);
/* Get the image from the GIMP one line at a time and write it out */
for (i = 0; i < drawable->height; ++i) {
gimp_pixel_rgn_get_rect(&pixel_rgn, line, 0, i, drawable->width, 1);
memset(buffer, 0, drawable->width);
if (colours > 16) {
for (j = 0, k = 0; j < drawable->width*2; j+= 2, ++k) {
if (line[j+1] > 127) {
buffer[k]= line[j] + 1;
}
}
fwrite(buffer, drawable->width, 1, fp);
} else {
for (j = 0, k = 0; j < drawable->width*2; j+= 4, ++k) {
buffer[k]= 0;
if (line[j+1] > 127) {
buffer[k]+= (line[j] + 1)<< 4;
}
if (line[j+3] > 127) {
buffer[k]+= (line[j+2] + 1);
}
}
fwrite(buffer, (drawable->width+1)/2, 1, fp);
/* Work out whether to save as 8bit or 4bit */
gimp_image_get_cmap (image, &colours);
if (colours > 15)
{
header[5]= 8;
}
else
{
header[5]= 4;
}
gimp_progress_update((float) i / (float) drawable->height);
}
/* Fill in the blanks ... */
header[8] = drawable->width % 256;
header[9] = drawable->width / 256;
header[10] = drawable->height % 256;
header[11] = drawable->height / 256;
header[12] = offx % 256;
header[13] = offx / 256;
header[14] = offy % 256;
header[15] = offy / 256;
fwrite (header, 32, 1, fp);
/* Close files, give back allocated memory */
fclose(fp);
g_free(buffer);
g_free(line);
/* Arrange for memory etc. */
gimp_pixel_rgn_init (&pixel_rgn, drawable, 0, 0, drawable->width,
drawable->height, TRUE, FALSE);
buffer = g_new (guchar, drawable->width);
line = g_new (guchar, (drawable->width+1) * 2);
/* Get the image from the GIMP one line at a time and write it out */
for (i = 0; i < drawable->height; ++i)
{
gimp_pixel_rgn_get_rect (&pixel_rgn, line, 0, i, drawable->width, 1);
memset (buffer, 0, drawable->width);
if (colours > 16)
{
for (j = 0, k = 0; j < drawable->width*2; j+= 2, ++k)
{
if (line[j+1] > 127)
{
buffer[k]= line[j] + 1;
}
}
fwrite (buffer, drawable->width, 1, fp);
}
else
{
for (j = 0, k = 0; j < drawable->width*2; j+= 4, ++k)
{
buffer[k] = 0;
if (line[j+1] > 127)
{
buffer[k] += (line[j] + 1)<< 4;
}
if (line[j+3] > 127)
{
buffer[k] += (line[j+2] + 1);
}
}
fwrite (buffer, (drawable->width+1)/2, 1, fp);
}
gimp_progress_update ((float) i / (float) drawable->height);
}
/* Close files, give back allocated memory */
fclose (fp);
g_free (buffer);
g_free (line);
return TRUE;
}
static void palette_ok (GtkWidget *widget, GtkWidget **fs) {
g_free(palette_file);
palette_file= g_strdup(gtk_file_selection_get_filename
(GTK_FILE_SELECTION(fs)));
data_length= strlen(palette_file) + 1;
static void
palette_ok (GtkWidget *widget,
GtkWidget **fs)
{
g_free (palette_file);
palette_file =
g_strdup (gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
data_length = strlen (palette_file) + 1;
gtk_widget_destroy (GTK_WIDGET (fs));
}
static void palette_cancel (GtkWidget *widget, GtkWidget **window) {
gtk_main_quit ();
}
static gint
palette_dialog (gchar *title)
{
@ -505,8 +604,8 @@ palette_dialog (gchar *title)
gint argc = 1;
GtkWidget *dialog;
argv= g_malloc (sizeof (gchar *));
argv[0]= g_strdup ("CEL file-filter");
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("CEL file-filter");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
@ -515,11 +614,18 @@ palette_dialog (gchar *title)
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_file_selection_set_filename (GTK_FILE_SELECTION (dialog), palette_file);
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (dialog)->ok_button),
"clicked", (GtkSignalFunc) palette_ok, dialog);
gtk_signal_connect (GTK_OBJECT (dialog),
"destroy", (GtkSignalFunc) palette_cancel, NULL);
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (dialog)->cancel_button), "clicked", (GtkSignalFunc) palette_cancel, GTK_OBJECT (dialog));
gtk_signal_connect
(GTK_OBJECT (GTK_FILE_SELECTION (dialog)->ok_button), "clicked",
GTK_SIGNAL_FUNC (palette_ok),
dialog);
gtk_signal_connect_object
(GTK_OBJECT (GTK_FILE_SELECTION (dialog)->cancel_button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (dialog));
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
gimp_help_connect_help_accel (dialog, gimp_plugin_help_func,
"filters/cel.html");
@ -528,5 +634,6 @@ palette_dialog (gchar *title)
gtk_main ();
gdk_flush ();
return 0;
}

40
plug-ins/common/CML_explorer.c
View File

@ -81,9 +81,10 @@
#include <gtk/gtk.h>
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
#include "libgimp/gimpcolorspace.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimpcolorspace.h>
#include "libgimp/stdplugins-intl.h"
#ifndef RAND_MAX
@ -132,7 +133,6 @@ gint gtkW_align_x = GTK_FILL|GTK_EXPAND;
gint gtkW_align_y = GTK_FILL;
/* gtkW callback */
static void gtkW_close_callback (GtkWidget *widget, gpointer data);
static void gtkW_toggle_update (GtkWidget *widget, gpointer data);
static void gtkW_iscale_update (GtkAdjustment *adjustment, gpointer data);
static void gtkW_ientry_update (GtkWidget *widget, gpointer data);
@ -423,10 +423,10 @@ static gdouble parse_line_to_gdouble (FILE *file, gint *flag);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
typedef struct
@ -434,7 +434,10 @@ typedef struct
gint run;
} Interface;
static Interface INTERFACE = { FALSE };
static Interface INTERFACE =
{
FALSE
};
GtkWidget *preview;
gtkW_widget_table widget_pointers[4][CML_PARAM_NUM];
@ -464,7 +467,7 @@ gint mem_chank2_size = 0;
MAIN ()
static void
query ()
query (void)
{
static GParamDef args [] =
{
@ -474,8 +477,8 @@ query ()
{ PARAM_STRING, "parameter_file_name", "The name of parameter file. CML_explorer makes an image with its settings." },
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof (args) / sizeof (args[0]);
static int nreturn_vals = 0;
static gint nargs = sizeof (args) / sizeof (args[0]);
static gint nreturn_vals = 0;
INIT_I18N();
@ -1183,7 +1186,7 @@ DIALOG ()
dlg = gtkW_dialog_new (_("Coupled-Map-Lattice Explorer"),
(GtkSignalFunc) OK_CALLBACK,
(GtkSignalFunc) gtkW_close_callback);
(GtkSignalFunc) gtk_main_quit);
memset(&widget_pointers, (int)0, sizeof(widget_pointers));
@ -1678,7 +1681,7 @@ function_graph_new (GtkWidget *widget, gpointer data)
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtkW_close_callback),
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
frame = gtkW_frame_new (GTK_DIALOG (dlg)->vbox, _("The Graph"));
@ -2017,7 +2020,7 @@ force_overwrite (char *filename)
dlg = gtkW_dialog_new (_("CML file operation warning"),
(GtkSignalFunc) CML_overwrite_ok_callback,
(GtkSignalFunc) gtkW_close_callback);
(GtkSignalFunc) gtk_main_quit);
table = gtkW_table_new (NULL, 1, 1);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, TRUE, TRUE, 0);
@ -2327,13 +2330,6 @@ parse_line_to_gdouble (FILE *file, gint *flag)
/* gtkW functions */
/* gtkW callback */
static void
gtkW_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
gtkW_toggle_update (GtkWidget *widget,
gpointer data)

5
plug-ins/common/apply_lens.c
View File

@ -378,6 +378,7 @@ lens_dialog (GDrawable *drawable)
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *sep;
GtkWidget *hbox;
GtkWidget *spinbutton;
GtkObject *adj;
@ -461,6 +462,10 @@ lens_dialog (GDrawable *drawable)
gtk_widget_show (toggle);
}
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 2);
gtk_widget_show (sep);
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

82
plug-ins/common/checkerboard.c
View File

@ -54,24 +54,21 @@ static void run (gchar *name,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static void check (GDrawable * drawable);
static gint inblock (int pos, int size);
static void check (GDrawable *drawable);
static gint inblock (gint pos,
gint size);
static gint check_dialog (void);
static void check_ok_callback (GtkWidget *widget,
gpointer data);
static void check_toggle_update (GtkWidget *widget,
gpointer data);
static void check_slider_update (GtkAdjustment *adjustment,
gint *size_val);
static gint check_dialog (void);
static void check_ok_callback (GtkWidget *widget,
gpointer data);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static CheckVals cvals =
@ -165,7 +162,8 @@ run (gchar *name,
break;
}
if (gimp_drawable_is_rgb (drawable->id) || gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
{
gimp_progress_init (_("Adding Checkerboard..."));
@ -340,10 +338,8 @@ check_dialog (void)
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *toggle;
GtkWidget *slider;
GtkWidget *table;
GtkObject *size_data;
gchar **argv;
gint argc;
@ -377,39 +373,30 @@ check_dialog (void)
gtk_container_set_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, 2);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
toggle = gtk_check_button_new_with_label (_("Psychobilly"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) check_toggle_update,
GTK_SIGNAL_FUNC (gimp_toggle_button_update),
&cvals.mode);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), cvals.mode);
gtk_widget_show (toggle);
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
table = gtk_table_new (1, 3, FALSE);
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 (_("Check Size:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
size_data = gtk_adjustment_new (cvals.size, 1, 400, 1, 1, 0);
slider = gtk_hscale_new (GTK_ADJUSTMENT (size_data));
gtk_widget_set_usize (slider, 300, 0);
gtk_box_pack_start (GTK_BOX (hbox), slider, TRUE, TRUE, 0);
gtk_scale_set_digits (GTK_SCALE (slider), 0);
gtk_range_set_update_policy (GTK_RANGE (slider), GTK_UPDATE_DELAYED);
gtk_scale_set_value_pos (GTK_SCALE (slider), GTK_POS_TOP);
size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Check Size:"), 200, 0,
cvals.size, 1, 400, 1, 10, 0,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (size_data), "value_changed",
(GtkSignalFunc) check_slider_update,
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&cvals.size);
gtk_widget_show (slider);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (frame);
@ -421,27 +408,6 @@ check_dialog (void)
return cint.run;
}
static void
check_slider_update (GtkAdjustment *adjustment,
gint *size_val)
{
*size_val = adjustment->value;
}
static void
check_toggle_update (GtkWidget *widget,
gpointer data)
{
gint *toggle_val;
toggle_val = (gint *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
}
static void
check_ok_callback (GtkWidget *widget,
gpointer data)

2
plug-ins/common/engrave.c
View File

@ -252,7 +252,7 @@ engrave_dialog (void)
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);

830
plug-ins/common/exchange.c
View File

@ -42,215 +42,234 @@
#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"
/* big scales */
#define SCALE_WIDTH 225
/* preview width/height */
#define PREVIEW_SIZE 128
#define SCALE_WIDTH 128
#define PREVIEW_SIZE 128
/* datastructure to store parameters in */
typedef struct
{
guchar fromred, fromgreen, fromblue, tored, togreen, toblue;
guchar red_threshold, green_threshold, blue_threshold;
gint32 image;
gint32 drawable;
} myParams;
guchar fromred, fromgreen, fromblue;
guchar tored, togreen, toblue;
guchar red_threshold, green_threshold, blue_threshold;
gint32 image;
gint32 drawable;
} myParams;
/* lets prototype */
static void query();
static void run(char *, int, GParam *, int *, GParam **);
static int doDialog();
static void exchange();
static void real_exchange(gint, gint, gint, gint, int);
static void doLabelAndScale(char *, GtkWidget *, guchar *);
static void update_preview();
static void query (void);
static void run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static void ok_callback(GtkWidget *, gpointer);
static void lock_callback(GtkWidget *, gpointer);
static void scale_callback(GtkAdjustment *, gpointer);
static void exchange (void);
static void real_exchange (gint, gint, gint, gint, int);
static int doDialog (void);
static void update_preview (void);
static void ok_callback (GtkWidget *, gpointer);
static void lock_callback (GtkWidget *, gpointer);
static void color_button_callback (GtkWidget *, gpointer);
static void scale_callback (GtkAdjustment *, gpointer);
/* some global variables */
GDrawable *drw;
myParams xargs = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
int running = 0;
GPixelRgn origregion;
GtkWidget *preview;
gint sel_x1, sel_y1, sel_x2, sel_y2;
gint prev_width, prev_height, sel_width, sel_height;
gint lock_thres = 0;
GDrawable *drw;
gboolean has_alpha;
myParams xargs = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
gint running = 0;
GPixelRgn origregion;
GtkWidget *preview;
GtkWidget *from_colorbutton;
GtkWidget *to_colorbutton;
gint sel_x1, sel_y1, sel_x2, sel_y2;
gint prev_width, prev_height, sel_width, sel_height;
gint lock_thres = 0;
/* lets declare what we want to do */
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
/* run program */
MAIN()
/* tell GIMP who we are */
static
void query()
static void
query (void)
{
static GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive" },
{ PARAM_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT8, "fromred", "Red value (from)" },
{ PARAM_INT8, "fromgreen", "Green value (from)" },
{ PARAM_INT8, "fromblue", "Blue value (from)" },
{ PARAM_INT8, "tored", "Red value (to)" },
{ PARAM_INT8, "togreen", "Green value (to)" },
{ PARAM_INT8, "toblue", "Blue value (to)" },
{ PARAM_INT8, "red_threshold", "Red threshold" },
{ PARAM_INT8, "green_threshold", "Green threshold" },
{ PARAM_INT8, "blue_threshold", "Blue threshold" },
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof(args) / sizeof(args[0]);
static int nreturn_vals = 0;
static GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive" },
{ PARAM_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT8, "fromred", "Red value (from)" },
{ PARAM_INT8, "fromgreen", "Green value (from)" },
{ PARAM_INT8, "fromblue", "Blue value (from)" },
{ PARAM_INT8, "tored", "Red value (to)" },
{ PARAM_INT8, "togreen", "Green value (to)" },
{ PARAM_INT8, "toblue", "Blue value (to)" },
{ PARAM_INT8, "red_threshold", "Red threshold" },
{ PARAM_INT8, "green_threshold", "Green threshold" },
{ PARAM_INT8, "blue_threshold", "Blue threshold" },
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof(args) / sizeof(args[0]);
static int nreturn_vals = 0;
INIT_I18N();
INIT_I18N();
gimp_install_procedure("plug_in_exchange",
_("Color Exchange"),
_("Exchange one color with another, optionally setting a threshold to convert from one shade to another"),
"robert@experimental.net",
"robert@experimental.net",
"June 17th, 1997",
N_("<Image>/Filters/Colors/Map/Color Exchange..."),
"RGB*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
gimp_install_procedure ("plug_in_exchange",
_("Color Exchange"),
_("Exchange one color with another, optionally setting a threshold to convert from one shade to another"),
"robert@experimental.net",
"robert@experimental.net",
"June 17th, 1997",
N_("<Image>/Filters/Colors/Map/Color Exchange..."),
"RGB*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
}
/* main function */
static
void run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_vals)
static void
run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GRunModeType runmode;
GStatusType status = STATUS_SUCCESS;
static GParam values[1];
GRunModeType runmode;
GStatusType status = STATUS_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
runmode = param[0].data.d_int32;
xargs.image = param[1].data.d_image;
xargs.drawable = param[2].data.d_drawable;
drw = gimp_drawable_get(xargs.drawable);
runmode = param[0].data.d_int32;
xargs.image = param[1].data.d_image;
xargs.drawable = param[2].data.d_drawable;
drw = gimp_drawable_get (xargs.drawable);
switch (runmode)
switch (runmode)
{
case RUN_INTERACTIVE:
INIT_I18N_UI();
/* retrieve stored arguments (if any) */
gimp_get_data ("plug_in_exchange", &xargs);
/* initialize using foreground color */
gimp_palette_get_foreground (&xargs.fromred,
&xargs.fromgreen,
&xargs.fromblue);
/* and initialize some other things */
gimp_drawable_mask_bounds (drw->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
if (sel_width > PREVIEW_SIZE)
prev_width = PREVIEW_SIZE;
else
prev_width = sel_width;
if (sel_height > PREVIEW_SIZE)
prev_height = PREVIEW_SIZE;
else
prev_height = sel_height;
has_alpha = gimp_drawable_has_alpha (drw->id);
if (!doDialog ())
return;
break;
case RUN_WITH_LAST_VALS:
INIT_I18N();
gimp_get_data ("plug_in_exchange", &xargs);
/*
* instead of recalling the last-set values,
* run with the current foreground as 'from'
* color, making ALT-F somewhat more useful.
*/
gimp_palette_get_foreground (&xargs.fromred,
&xargs.fromgreen,
&xargs.fromblue);
break;
case RUN_NONINTERACTIVE:
INIT_I18N();
if (nparams != 10)
status = STATUS_EXECUTION_ERROR;
if (status == STATUS_SUCCESS)
{
case RUN_INTERACTIVE:
INIT_I18N_UI();
/* retrieve stored arguments (if any) */
gimp_get_data("plug_in_exchange", &xargs);
/* initialize using foreground color */
gimp_palette_get_foreground(&xargs.fromred, &xargs.fromgreen, &xargs.fromblue);
/* and initialize some other things */
gimp_drawable_mask_bounds(drw->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
if (sel_width > PREVIEW_SIZE)
prev_width = PREVIEW_SIZE;
else
prev_width = sel_width;
if (sel_height > PREVIEW_SIZE)
prev_height = PREVIEW_SIZE;
else
prev_height = sel_height;
if (!doDialog())
return;
break;
case RUN_WITH_LAST_VALS:
INIT_I18N();
gimp_get_data("plug_in_exchange", &xargs);
/*
* instead of recalling the last-set values,
* run with the current foreground as 'from'
* color, making ALT-F somewhat more useful.
*/
gimp_palette_get_foreground(&xargs.fromred, &xargs.fromgreen, &xargs.fromblue);
break;
case RUN_NONINTERACTIVE:
INIT_I18N();
if (nparams != 10)
status = STATUS_EXECUTION_ERROR;
if (status == STATUS_SUCCESS)
{
xargs.fromred = param[3].data.d_int8;
xargs.fromgreen = param[4].data.d_int8;
xargs.fromblue = param[5].data.d_int8;
xargs.tored = param[6].data.d_int8;
xargs.togreen = param[7].data.d_int8;
xargs.toblue = param[8].data.d_int8;
xargs.red_threshold = param[9].data.d_int32;
xargs.green_threshold = param[10].data.d_int32;
xargs.blue_threshold = param[11].data.d_int32;
}
break;
default:
break;
xargs.fromred = param[3].data.d_int8;
xargs.fromgreen = param[4].data.d_int8;
xargs.fromblue = param[5].data.d_int8;
xargs.tored = param[6].data.d_int8;
xargs.togreen = param[7].data.d_int8;
xargs.toblue = param[8].data.d_int8;
xargs.red_threshold = param[9].data.d_int32;
xargs.green_threshold = param[10].data.d_int32;
xargs.blue_threshold = param[11].data.d_int32;
}
if (status == STATUS_SUCCESS)
break;
default:
break;
}
if (status == STATUS_SUCCESS)
{
if (gimp_drawable_is_rgb (drw->id))
{
if (gimp_drawable_is_rgb(drw->id))
{
gimp_progress_init( _("Color Exchange..."));
gimp_tile_cache_ntiles(2 * (drw->width / gimp_tile_width() + 1));
exchange();
gimp_drawable_detach(drw);
/* store our settings */
if (runmode == RUN_INTERACTIVE)
gimp_set_data("plug_in_exchange", &xargs, sizeof(myParams));
/* and flush */
if (runmode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else
status = STATUS_EXECUTION_ERROR;
gimp_progress_init (_("Color Exchange..."));
gimp_tile_cache_ntiles (2 * (drw->width / gimp_tile_width () + 1));
exchange ();
gimp_drawable_detach( drw);
/* store our settings */
if (runmode == RUN_INTERACTIVE)
gimp_set_data ("plug_in_exchange", &xargs, sizeof (myParams));
/* and flush */
if (runmode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
values[0].data.d_status = status;
else
status = STATUS_EXECUTION_ERROR;
}
values[0].data.d_status = status;
}
/* do the exchanging */
static
void exchange()
static void
exchange (void)
{
/* do the real exchange */
real_exchange(-1, -1, -1, -1, 0);
/* do the real exchange */
real_exchange (-1, -1, -1, -1, FALSE);
}
/* show our dialog */
static int
static gint
doDialog (void)
{
GtkWidget *dialog;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *mainbox;
GtkWidget *tobox;
GtkWidget *frombox;
GtkWidget *prevbox;
guchar *color_cube;
gchar **argv;
gint argc;
gint framenumber;
GtkWidget *dialog;
GtkWidget *mainbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *colorbutton;
GtkObject *adj;
guchar *color_cube;
gchar **argv;
gint argc;
gint framenumber;
argc = 1;
argv = g_new (gchar *, 1);
@ -290,27 +309,14 @@ doDialog (void)
NULL);
/* do some boxes here */
mainbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (mainbox), 10);
mainbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (mainbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), mainbox,
TRUE, TRUE, 0);
prevbox = gtk_hbox_new(FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (prevbox), 0);
gtk_box_pack_start (GTK_BOX (mainbox), prevbox, TRUE, TRUE, 0);
frombox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (frombox), 0);
gtk_box_pack_start (GTK_BOX (mainbox), frombox, TRUE, TRUE, 0);
tobox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (tobox), 0);
gtk_box_pack_start (GTK_BOX (mainbox), tobox, TRUE, TRUE, 0);
frame = gtk_frame_new (_("Preview"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_box_pack_start (GTK_BOX (prevbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (mainbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
@ -322,46 +328,120 @@ doDialog (void)
/* and our scales */
for (framenumber = 0; framenumber < 2; framenumber++)
{
frame = gtk_frame_new (framenumber ? _("To color") : _("From color"));
guint id;
frame = gtk_frame_new (framenumber ? _("To Color") : _("From Color"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_set_border_width (GTK_CONTAINER (frame), 0);
gtk_box_pack_start (framenumber ? GTK_BOX (tobox) : GTK_BOX (frombox),
frame, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (mainbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (8, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 0);
table = gtk_table_new (framenumber ? 3 : 9, 4, FALSE);
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);
doLabelAndScale (_("Red"), table,
framenumber ? &xargs.tored : &xargs.fromred);
gtk_widget_show (table);
colorbutton = gimp_color_button_new (framenumber ?
_("Color Exchange: To Color") :
_("Color Exchange: From Color"),
SCALE_WIDTH / 2, 16,
framenumber ?
&xargs.tored : &xargs.fromred,
3);
gimp_table_attach_aligned (GTK_TABLE (table), 0,
NULL, 0.0, 0.0,
colorbutton, TRUE);
gtk_signal_connect (GTK_OBJECT (colorbutton), "color_changed",
GTK_SIGNAL_FUNC (color_button_callback),
NULL);
if (framenumber)
to_colorbutton = colorbutton;
else
from_colorbutton = colorbutton;
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Red:"), SCALE_WIDTH, 0,
framenumber ? xargs.tored : xargs.fromred,
0, 255, 1, 8, 0, NULL, NULL);
gtk_object_set_user_data (GTK_OBJECT (adj), colorbutton);
gtk_object_set_data (GTK_OBJECT (colorbutton), "red", adj);
id = gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scale_callback),
framenumber ? &xargs.tored : &xargs.fromred);
gtk_object_set_data (GTK_OBJECT (adj), "handler", (gpointer) id);
if (! framenumber)
doLabelAndScale (_("Red threshold"), table, &xargs.red_threshold);
doLabelAndScale (_("Green"), table,
framenumber ? &xargs.togreen : &xargs.fromgreen);
{
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("Red Threshold:"), SCALE_WIDTH, 0,
xargs.red_threshold,
0, 255, 1, 8, 0, NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scale_callback),
&xargs.red_threshold);
}
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, framenumber ? 2 : 3,
_("Green:"), SCALE_WIDTH, 0,
framenumber ? xargs.togreen : xargs.fromgreen,
0, 255, 1, 8, 0, NULL, NULL);
gtk_object_set_user_data (GTK_OBJECT (adj), colorbutton);
gtk_object_set_data (GTK_OBJECT (colorbutton), "green", adj);
id = gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scale_callback),
framenumber ? &xargs.togreen : &xargs.fromgreen);
gtk_object_set_data (GTK_OBJECT (adj), "handler", (gpointer) id);
if (! framenumber)
doLabelAndScale (_("Green threshold"), table, &xargs.green_threshold);
doLabelAndScale (_("Blue"), table,
framenumber ? &xargs.toblue : &xargs.fromblue);
{
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 4,
_("Green Threshold:"), SCALE_WIDTH, 0,
xargs.green_threshold,
0, 255, 1, 8, 0, NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scale_callback),
&xargs.green_threshold);
}
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, framenumber ? 3 : 5,
_("Blue:"), SCALE_WIDTH, 0,
framenumber ? xargs.toblue : xargs.fromblue,
0, 255, 1, 8, 0, NULL, NULL);
gtk_object_set_user_data (GTK_OBJECT (adj), colorbutton);
gtk_object_set_data (GTK_OBJECT (colorbutton), "blue", adj);
id = gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scale_callback),
framenumber ? &xargs.toblue : &xargs.fromblue);
gtk_object_set_data (GTK_OBJECT (adj), "handler", (gpointer) id);
if (! framenumber)
doLabelAndScale (_("Blue threshold"), table, &xargs.blue_threshold);
{
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 6,
_("Blue Threshold:"), SCALE_WIDTH, 0,
xargs.blue_threshold,
0, 255, 1, 8, 0, NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (scale_callback),
&xargs.blue_threshold);
}
if (! framenumber)
{
GtkWidget *button;
button = gtk_check_button_new_with_label (_("Lock thresholds"));
gtk_table_attach (GTK_TABLE (table), button, 1, 2, 6, 7,
button = gtk_check_button_new_with_label (_("Lock Thresholds"));
gtk_table_attach (GTK_TABLE (table), button, 1, 3, 7, 8,
GTK_FILL, 0, 0, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) lock_callback,
GTK_SIGNAL_FUNC (lock_callback),
dialog);
gtk_widget_show (button);
}
gtk_widget_show (table);
}
/* show everything */
gtk_widget_show (prevbox);
gtk_widget_show (tobox);
gtk_widget_show (frombox);
gtk_widget_show (mainbox);
gtk_widget_show (dialog);
@ -371,175 +451,223 @@ doDialog (void)
return running;
}
static
void doLabelAndScale(char *labelname, GtkWidget *table, guchar *dest)
static void
ok_callback (GtkWidget *widget,
gpointer data)
{
static int idx = -1;
GtkWidget *label, *scale;
GtkObject *scale_data;
running = TRUE;
idx++;
label = gtk_label_new(labelname);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, idx, idx + 1, GTK_FILL, 0, 0, 0);
scale_data = gtk_adjustment_new(*dest, 0.0, 255.0, 0.0, 0.0, 0.0);
scale = gtk_hscale_new(GTK_ADJUSTMENT(scale_data));
gtk_widget_set_usize(scale, SCALE_WIDTH, 0);
/* just need 1:1 resolution on scales */
gtk_scale_set_digits(GTK_SCALE(scale), 0);
gtk_table_attach(GTK_TABLE(table), scale, 1, 2, idx, idx + 1, GTK_FILL, 0, 0, 0);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_TOP);
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DISCONTINUOUS);
gtk_signal_connect(GTK_OBJECT(scale_data), "value_changed",
(GtkSignalFunc) scale_callback,
dest);
gtk_widget_show(label);
gtk_widget_show(scale);
gtk_widget_destroy (GTK_WIDGET (data));
}
static
void ok_callback(GtkWidget *widget, gpointer data)
static void
lock_callback (GtkWidget *widget,
gpointer data)
{
running = 1;
gtk_widget_destroy(GTK_WIDGET(data));
lock_thres = 1 - lock_thres;
}
static
void lock_callback(GtkWidget *widget, gpointer data)
static void
color_button_callback (GtkWidget *widget,
gpointer data)
{
lock_thres = 1 - lock_thres;
GtkObject *red_adj;
GtkObject *green_adj;
GtkObject *blue_adj;
guint red_handler;
guint green_handler;
guint blue_handler;
red_adj = (GtkObject *) gtk_object_get_data (GTK_OBJECT (widget), "red");
green_adj = (GtkObject *) gtk_object_get_data (GTK_OBJECT (widget), "green");
blue_adj = (GtkObject *) gtk_object_get_data (GTK_OBJECT (widget), "blue");
red_handler = (guint) gtk_object_get_data (GTK_OBJECT (red_adj),
"handler");
green_handler = (guint) gtk_object_get_data (GTK_OBJECT (green_adj),
"handler");
blue_handler = (guint) gtk_object_get_data (GTK_OBJECT (blue_adj),
"handler");
gtk_signal_handler_block (GTK_OBJECT (red_adj), red_handler);
gtk_signal_handler_block (GTK_OBJECT (green_adj), green_handler);
gtk_signal_handler_block (GTK_OBJECT (blue_adj), blue_handler);
if (widget == from_colorbutton)
{
gtk_adjustment_set_value (GTK_ADJUSTMENT (red_adj), xargs.fromred);
gtk_adjustment_set_value (GTK_ADJUSTMENT (green_adj), xargs.fromgreen);
gtk_adjustment_set_value (GTK_ADJUSTMENT (blue_adj), xargs.fromblue);
}
else
{
gtk_adjustment_set_value (GTK_ADJUSTMENT (red_adj), xargs.tored);
gtk_adjustment_set_value (GTK_ADJUSTMENT (green_adj), xargs.togreen);
gtk_adjustment_set_value (GTK_ADJUSTMENT (blue_adj), xargs.toblue);
}
gtk_signal_handler_unblock (GTK_OBJECT (red_adj), red_handler);
gtk_signal_handler_unblock (GTK_OBJECT (green_adj), green_handler);
gtk_signal_handler_unblock (GTK_OBJECT (blue_adj), blue_handler);
update_preview ();
}
static
void scale_callback(GtkAdjustment *adj, gpointer data)
static void
scale_callback (GtkAdjustment *adj,
gpointer data)
{
guchar *val = data;
GtkWidget *colorbutton;
guchar *val = data;
*val = (guchar) adj->value;
update_preview();
*val = (guchar) adj->value;
colorbutton = gtk_object_get_user_data (GTK_OBJECT (adj));
if (colorbutton)
gimp_color_button_update (GIMP_COLOR_BUTTON (colorbutton));
update_preview ();
}
static
void update_preview()
static void
update_preview (void)
{
real_exchange(sel_x1, sel_y1, sel_x1 + prev_width, sel_y1 + prev_height, 1);
gtk_widget_draw(preview, NULL);
gdk_flush();
real_exchange (sel_x1, sel_y1,
sel_x1 + prev_width, sel_y1 + prev_height,
TRUE);
gtk_widget_draw (preview, NULL);
gdk_flush ();
}
static
void real_exchange(gint x1, gint y1, gint x2, gint y2, int dopreview)
static void
real_exchange (gint x1,
gint y1,
gint x2,
gint y2,
gint dopreview)
{
GPixelRgn srcPR, destPR;
guchar *src_row, *dest_row;
int x, y, bpp = drw->bpp;
int width, height;
GPixelRgn srcPR, destPR;
guchar *src_row, *dest_row;
gint x, y, bpp = drw->bpp;
gint width, height;
/* fill if necessary */
if (x1 == -1 || y1 == -1 || x2 == -1 || y2 == -1)
/* fill if necessary */
if (x1 == -1 || y1 == -1 || x2 == -1 || y2 == -1)
{
x1 = sel_x1;
y1 = sel_y1;
x2 = sel_x2;
y2 = sel_y2;
}
/* check for valid coordinates */
width = x2 - x1;
height = y2 - y1;
/* allocate memory */
src_row = g_new (guchar, drw->width * bpp);
if (dopreview && has_alpha)
dest_row = g_new (guchar, drw->width * (bpp - 1));
else
dest_row = g_new (guchar, drw->width * bpp);
/* initialize the pixel regions */
/*
gimp_pixel_rgn_init (&srcPR, drw, x1, y1, width, height, FALSE, FALSE);
*/
gimp_pixel_rgn_init (&srcPR, drw, 0, 0, drw->width, drw->height, FALSE, FALSE);
if (! dopreview)
gimp_pixel_rgn_init (&destPR, drw, 0, 0, width, height, TRUE, TRUE);
for (y = y1; y < y2; y++)
{
gimp_pixel_rgn_get_row (&srcPR, src_row, 0, y, drw->width);
for (x = x1; x < x2; x++)
{
x1 = sel_x1;
y1 = sel_y1;
x2 = sel_x2;
y2 = sel_y2;
}
/* check for valid coordinates */
width = x2 - x1;
height = y2 - y1;
/* allocate memory */
src_row = g_malloc(drw->width * bpp * sizeof(guchar));
dest_row = g_malloc(drw->width * bpp * sizeof(guchar));
/* initialize the pixel regions */
/*
gimp_pixel_rgn_init(&srcPR, drw, x1, y1, width, height, FALSE, FALSE);
*/
gimp_pixel_rgn_init(&srcPR, drw, 0, 0, drw->width, drw->height, FALSE, FALSE);
if (! dopreview)
gimp_pixel_rgn_init(&destPR, drw, 0, 0, width, height, TRUE, TRUE);
for (y = y1; y < y2; y++)
{
gimp_pixel_rgn_get_row(&srcPR, src_row, 0, y, drw->width);
for (x = x1; x < x2; x++)
{
gint pixel_red, pixel_green, pixel_blue;
gint min_red, max_red,
min_green, max_green,
min_blue, max_blue;
gint new_red, new_green, new_blue;
gint idx, rest;
/* get boundary values */
min_red = MAX(xargs.fromred - xargs.red_threshold, 0);
min_green = MAX(xargs.fromgreen - xargs.green_threshold, 0);
min_blue = MAX(xargs.fromblue - xargs.blue_threshold, 0);
max_red = MIN(xargs.fromred + xargs.red_threshold, 255);
max_green = MIN(xargs.fromgreen + xargs.green_threshold, 255);
max_blue = MIN(xargs.fromblue + xargs.blue_threshold, 255);
/* get current pixel-values */
pixel_red = src_row[x * bpp];
pixel_green = src_row[x * bpp + 1];
pixel_blue = src_row[x * bpp + 2];
/* shift down for preview */
if (dopreview)
idx = (x - x1) * bpp;
else
idx = x * bpp;
/* want this pixel? */
if (pixel_red >= min_red && pixel_red <= max_red && pixel_green >= min_green && pixel_green <= max_green && pixel_blue >= min_blue && pixel_blue <= max_blue)
{
gint red_delta, green_delta, blue_delta;
red_delta = pixel_red - xargs.fromred;
green_delta = pixel_green - xargs.fromgreen;
blue_delta = pixel_blue - xargs.fromblue;
new_red = (guchar) MAX(MIN(xargs.tored + red_delta, 255), 0);
new_green = (guchar) MAX(MIN(xargs.togreen + green_delta, 255), 0);
new_blue = (guchar) MAX(MIN(xargs.toblue + blue_delta, 255), 0);
}
else
{
new_red = pixel_red;
new_green = pixel_green;
new_blue = pixel_blue;
}
/* fill buffer (cast it too) */
dest_row[idx + 0] = (guchar) new_red;
dest_row[idx + 1] = (guchar) new_green;
dest_row[idx + 2] = (guchar) new_blue;
/* copy rest (most likely alpha-channel) */
for (rest = 3; rest < bpp; rest++)
dest_row[idx + rest] = src_row[x * bpp + rest];
}
/* store the dest */
if (dopreview)
gtk_preview_draw_row(GTK_PREVIEW(preview), dest_row, 0, y - y1, width);
else
gimp_pixel_rgn_set_row(&destPR, dest_row, 0, y, drw->width);
/* and tell the user what we're doing */
if (! dopreview && (y % 10) == 0)
gimp_progress_update((double) y / (double) height);
}
g_free(src_row);
g_free(dest_row);
if (! dopreview)
{
/* update the processed region */
gimp_drawable_flush(drw);
gimp_drawable_merge_shadow(drw->id, TRUE);
gimp_drawable_update(drw->id, x1, y1, width, height);
gint pixel_red, pixel_green, pixel_blue;
gint min_red, max_red, min_green, max_green, min_blue, max_blue;
gint new_red, new_green, new_blue;
gint idx, rest;
/* get boundary values */
min_red = MAX (xargs.fromred - xargs.red_threshold, 0);
min_green = MAX (xargs.fromgreen - xargs.green_threshold, 0);
min_blue = MAX (xargs.fromblue - xargs.blue_threshold, 0);
max_red = MIN (xargs.fromred + xargs.red_threshold, 255);
max_green = MIN (xargs.fromgreen + xargs.green_threshold, 255);
max_blue = MIN (xargs.fromblue + xargs.blue_threshold, 255);
/* get current pixel-values */
pixel_red = src_row[x * bpp];
pixel_green = src_row[x * bpp + 1];
pixel_blue = src_row[x * bpp + 2];
/* shift down for preview */
if (dopreview)
{
if (has_alpha)
idx = (x - x1) * (bpp - 1);
else
idx = (x - x1) * bpp;
}
else
idx = x * bpp;
/* want this pixel? */
if (pixel_red >= min_red &&
pixel_red <= max_red &&
pixel_green >= min_green &&
pixel_green <= max_green &&
pixel_blue >= min_blue &&
pixel_blue <= max_blue)
{
gint red_delta, green_delta, blue_delta;
red_delta = pixel_red - xargs.fromred;
green_delta = pixel_green - xargs.fromgreen;
blue_delta = pixel_blue - xargs.fromblue;
new_red = (guchar) CLAMP (xargs.tored + red_delta, 0, 255);
new_green = (guchar) CLAMP (xargs.togreen + green_delta, 0, 255);
new_blue = (guchar) CLAMP (xargs.toblue + blue_delta, 0, 255);
}
else
{
new_red = pixel_red;
new_green = pixel_green;
new_blue = pixel_blue;
}
/* fill buffer (cast it too) */
dest_row[idx + 0] = (guchar) new_red;
dest_row[idx + 1] = (guchar) new_green;
dest_row[idx + 2] = (guchar) new_blue;
/* copy rest (most likely alpha-channel) */
for (rest = 3; rest < bpp; rest++)
dest_row[idx + rest] = src_row[x * bpp + rest];
}
/* store the dest */
if (dopreview)
gtk_preview_draw_row (GTK_PREVIEW (preview), dest_row, 0, y - y1, width);
else
gimp_pixel_rgn_set_row (&destPR, dest_row, 0, y, drw->width);
/* and tell the user what we're doing */
if (! dopreview && (y % 10) == 0)
gimp_progress_update ((double) y / (double) height);
}
g_free(src_row);
g_free(dest_row);
if (! dopreview)
{
/* update the processed region */
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->id, TRUE);
gimp_drawable_update (drw->id, x1, y1, width, height);
}
}

67
plug-ins/common/gauss_iir.c
View File

@ -23,8 +23,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"
@ -33,8 +33,8 @@
typedef struct
{
gdouble radius;
gint horizontal;
gint vertical;
gint horizontal;
gint vertical;
} BlurValues;
typedef struct
@ -80,23 +80,21 @@ static void transfer_pixels (gdouble * src1,
static void gauss_ok_callback (GtkWidget *widget,
gpointer data);
static void gauss_toggle_update (GtkWidget *widget,
gpointer data);
static void gauss_entry_callback (GtkWidget *widget,
gpointer data);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static BlurValues bvals =
{
5.0, /* radius */
5.0, /* radius */
TRUE, /* horizontal blur */
TRUE /* vertical blur */
TRUE /* vertical blur */
};
static BlurInterface bint =
@ -177,9 +175,9 @@ run (gchar *name,
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
bvals.radius = param[3].data.d_float;
bvals.radius = param[3].data.d_float;
bvals.horizontal = (param[4].data.d_int32) ? TRUE : FALSE;
bvals.vertical = (param[5].data.d_int32) ? TRUE : FALSE;
bvals.vertical = (param[5].data.d_int32) ? TRUE : FALSE;
}
if (status == STATUS_SUCCESS && (bvals.radius < 1.0))
status = STATUS_CALLING_ERROR;
@ -247,12 +245,12 @@ gauss_iir_dialog (void)
{
GtkWidget *dlg;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *spinbutton;
GtkWidget *adj;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
gchar buffer[12];
gchar **argv;
gint argc;
@ -292,7 +290,7 @@ gauss_iir_dialog (void)
toggle = gtk_check_button_new_with_label (_("Blur Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) gauss_toggle_update,
(GtkSignalFunc) gimp_toggle_button_update,
&bvals.horizontal);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal);
gtk_widget_show (toggle);
@ -300,7 +298,7 @@ gauss_iir_dialog (void)
toggle = gtk_check_button_new_with_label (_("Blur Vertically"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) gauss_toggle_update,
(GtkSignalFunc) gimp_toggle_button_update,
&bvals.vertical);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.vertical);
gtk_widget_show (toggle);
@ -312,15 +310,14 @@ gauss_iir_dialog (void)
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf (buffer, sizeof (buffer), "%f", bvals.radius);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) gauss_entry_callback,
NULL);
gtk_widget_show (entry);
spinbutton = gimp_spin_button_new (&adj,
bvals.radius, 1.0, G_MAXDOUBLE, 1.0, 5.0,
0, 1, 2);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
&bvals.radius);
gtk_widget_show (spinbutton);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
@ -427,7 +424,6 @@ gauss_iir (GDrawable *drawable,
/* First the vertical pass */
for (col = 0; col < width; col++)
{
memset(val_p, 0, height * bytes * sizeof (gdouble));
memset(val_m, 0, height * bytes * sizeof (gdouble));
@ -716,23 +712,10 @@ gauss_ok_callback (GtkWidget *widget,
gpointer data)
{
bint.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
gauss_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
toggle_val = (int *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
}
static void
gauss_entry_callback (GtkWidget *widget,
gpointer data)

65
plug-ins/common/gauss_rle.c
View File

@ -75,24 +75,20 @@ static void run_length_encode (guchar * src,
static void gauss_ok_callback (GtkWidget *widget,
gpointer data);
static void gauss_toggle_update (GtkWidget *widget,
gpointer data);
static void gauss_entry_callback (GtkWidget *widget,
gpointer data);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static BlurValues bvals =
{
5.0, /* radius */
5.0, /* radius */
TRUE, /* horizontal blur */
TRUE /* vertical blur */
TRUE /* vertical blur */
};
static BlurInterface bint =
@ -244,12 +240,12 @@ gauss_rle_dialog (void)
{
GtkWidget *dlg;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *spinbutton;
GtkObject *adj;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
gchar buffer[12];
gchar **argv;
gint argc;
@ -289,7 +285,7 @@ gauss_rle_dialog (void)
toggle = gtk_check_button_new_with_label (_("Blur Horizontally"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (gauss_toggle_update),
GTK_SIGNAL_FUNC (gimp_toggle_button_update),
&bvals.horizontal);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal);
gtk_widget_show (toggle);
@ -297,7 +293,7 @@ gauss_rle_dialog (void)
toggle = gtk_check_button_new_with_label (_("Blur Vertically"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
GTK_SIGNAL_FUNC (gauss_toggle_update),
GTK_SIGNAL_FUNC (gimp_toggle_button_update),
&bvals.vertical);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.vertical);
gtk_widget_show (toggle);
@ -309,15 +305,14 @@ gauss_rle_dialog (void)
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf (buffer, sizeof (buffer), "%f", bvals.radius);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
GTK_SIGNAL_FUNC (gauss_entry_callback),
NULL);
gtk_widget_show (entry);
spinbutton = gimp_spin_button_new (&adj,
bvals.radius, 1.0, G_MAXDOUBLE, 1.0, 5.0,
0, 1, 2);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
&bvals.radius);
gtk_widget_show (spinbutton);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
@ -646,28 +641,6 @@ gauss_ok_callback (GtkWidget *widget,
gpointer data)
{
bint.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
gauss_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
toggle_val = (int *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
}
static void
gauss_entry_callback (GtkWidget *widget,
gpointer data)
{
bvals.radius = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
if (bvals.radius < 1.0)
bvals.radius = 1.0;
}

116
plug-ins/common/illusion.c
View File

@ -28,9 +28,9 @@
#include <gtk/gtk.h>
#include "libgimp/gimp.h"
#include "libgimp/gimpui.h"
#include "libgimp/gimpmath.h"
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimpmath.h>
#include "libgimp/stdplugins-intl.h"
@ -41,26 +41,34 @@
/******************************************************************************/
static void query (void);
static void run (char *, int, GParam *, int *, GParam **);
static void run (gchar *name,
gint nparam,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static void filter (GDrawable *drawable);
static int dialog (void);
/******************************************************************************/
typedef struct {
typedef struct
{
gint32 division;
} parameter_t;
/******************************************************************************/
GPlugInInfo PLUG_IN_INFO = {
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static parameter_t parameters = {
static parameter_t parameters =
{
8
};
@ -79,11 +87,12 @@ static gdouble center_y;
/******************************************************************************/
MAIN()
MAIN ()
/******************************************************************************/
static void query (void)
static void
query (void)
{
static int nargs = 4;
static GParamDef args[] =
@ -116,11 +125,11 @@ static void query (void)
/******************************************************************************/
static void
run (char *name,
int paramc,
run (gchar *name,
gint nparams,
GParam *params,
int *returnc,
GParam **returns)
gint *nreturn_vals,
GParam **return_vals)
{
GDrawable *drawable;
GRunModeType run_mode;
@ -129,8 +138,8 @@ run (char *name,
run_mode = params[0].data.d_int32;
drawable = gimp_drawable_get (params[2].data.d_drawable);
*returnc = 1;
*returns = returnv;
*nreturn_vals = 1;
*return_vals = returnv;
/* get the drawable info */
image_width = gimp_drawable_width (drawable->id);
@ -150,12 +159,13 @@ run (char *name,
case RUN_INTERACTIVE:
INIT_I18N_UI();
gimp_get_data (PLUG_IN_NAME, &parameters);
if (! dialog()) return;
if (! dialog())
return;
gimp_set_data (PLUG_IN_NAME, &parameters, sizeof (parameter_t));
break;
case RUN_NONINTERACTIVE:
if (paramc != 4)
if (nparams != 4)
{
status = STATUS_CALLING_ERROR;
}
@ -272,17 +282,12 @@ filter (GDrawable *drawable)
static int dialog_status = FALSE;
static GtkWidget *entry_division;
static void
dialog_ok_handler (GtkWidget *widget,
gpointer data)
{
dialog_status = TRUE;
parameters.division =
(gint32) atof (gtk_entry_get_text (GTK_ENTRY (entry_division)));
gtk_widget_destroy (GTK_WIDGET (data));
}
@ -292,16 +297,17 @@ static int
dialog (void)
{
GtkWidget *window;
{
gint argc = 1;
gchar **argv = g_new (gchar *, 1);
GtkWidget *table;
GtkWidget *spinbutton;
GtkObject *adj;
argv[0] = g_strdup ("illusion");
gint argc = 1;
gchar **argv = g_new (gchar *, 1);
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
}
argv[0] = g_strdup ("illusion");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
/* dialog window */
window = gimp_dialog_new (_("Illusion"), "illusion",
@ -320,31 +326,23 @@ dialog (void)
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
{
/* text boxes */
GtkWidget *table;
GtkWidget *label;
gchar buffer[32];
/* table */
table = gtk_table_new (1, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), table,
TRUE, TRUE, 0 );
gtk_widget_show (table);
/* table */
table = gtk_table_new (1, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), table,
TRUE, TRUE, 0 );
gtk_widget_show (table);
/* tile width */
label = gtk_label_new (_("Division:"));
entry_division = gtk_entry_new ();
g_snprintf (buffer, sizeof (buffer), "%d", parameters.division);
gtk_entry_set_text (GTK_ENTRY (entry_division), buffer);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (table), entry_division, 1, 2, 0, 1);
gtk_widget_show (label);
gtk_widget_show (entry_division);
}
spinbutton = gimp_spin_button_new (&adj, parameters.division,
G_MININT, G_MAXINT, 1, 10, 0, 1, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0,
_("Division:"), 1.0, 0.5,
spinbutton, TRUE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&parameters.division);
gtk_widget_show (window);
@ -353,5 +351,3 @@ dialog (void)
return dialog_status;
}
/******************************************************************************/

175
plug-ins/common/max_rgb.c
View File

@ -35,14 +35,9 @@
#include "libgimp/stdplugins-intl.h"
/* Replace them with the right ones */
#define PLUG_IN_NAME "plug_in_max_rgb"
#define SHORT_NAME "max_rgb"
#define MAIN_FUNCTION max_rgb
/* you need not change the following names */
#define INTERFACE max_rgb_interface
#define DIALOG max_rgb_dialog
#define VALS max_rgb_vals
#define OK_CALLBACK _max_rgbok_callback
#define PLUG_IN_NAME "plug_in_max_rgb"
#define SHORT_NAME "max_rgb"
#define PROGRESS_UPDATE_NUM 100
static void query (void);
static void run (gchar *name,
@ -50,30 +45,26 @@ static void run (gchar *name,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static GStatusType MAIN_FUNCTION (gint32 drawable_id);
static gint DIALOG ();
static void OK_CALLBACK (GtkWidget *widget, gpointer data);
static GStatusType main_function (gint32 drawable_id);
static gint dialog (void);
static void ok_callback (GtkWidget *widget,
gpointer data);
/* gtkWrapper functions */
#define PROGRESS_UPDATE_NUM 100
#define ENTRY_WIDTH 100
#define SCALE_WIDTH 100
static void
gtkW_toggle_update (GtkWidget *widget, gpointer data);
static GSList *
gtkW_vbox_add_radio_button (GtkWidget *vbox,
gchar *name,
GSList *group,
GtkSignalFunc update,
gint *value);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
run, /* run_proc */
};
enum
{
MIN_CHANNELS = 0,
MAX_CHANNELS = 1
};
typedef struct
@ -81,20 +72,21 @@ typedef struct
gint max_p; /* gint, gdouble, and so on */
} ValueType;
static ValueType VALS =
{
1
};
typedef struct
{
gint run;
} Interface;
static Interface INTERFACE = { FALSE };
static ValueType pvals =
{
MAX_CHANNELS
};
static Interface interface =
{
FALSE
};
gint hold_max;
gint hold_min;
MAIN ()
@ -152,52 +144,50 @@ run (char *name,
{
case RUN_INTERACTIVE:
INIT_I18N_UI();
gimp_get_data (PLUG_IN_NAME, &VALS);
hold_max = VALS.max_p;
hold_min = VALS.max_p ? 0 : 1;
gimp_get_data (PLUG_IN_NAME, &pvals);
/* Since a channel might be selected, we must check wheter RGB or not. */
if (!gimp_drawable_is_rgb(drawable_id))
{
gimp_message (_("RGB drawable is not selected."));
return;
}
if (! DIALOG ())
if (! dialog ())
return;
break;
case RUN_NONINTERACTIVE:
INIT_I18N();
/* You must copy the values of parameters to VALS or dialog variables. */
/* You must copy the values of parameters to pvals or dialog variables. */
break;
case RUN_WITH_LAST_VALS:
INIT_I18N();
gimp_get_data (PLUG_IN_NAME, &VALS);
gimp_get_data (PLUG_IN_NAME, &pvals);
break;
}
status = MAIN_FUNCTION (drawable_id);
status = main_function (drawable_id);
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush();
if (run_mode == RUN_INTERACTIVE && status == STATUS_SUCCESS )
gimp_set_data (PLUG_IN_NAME, &VALS, sizeof (ValueType));
gimp_set_data (PLUG_IN_NAME, &pvals, sizeof (ValueType));
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
}
static GStatusType
MAIN_FUNCTION (gint32 drawable_id)
main_function (gint32 drawable_id)
{
GDrawable *drawable;
GPixelRgn src_rgn, dest_rgn;
guchar *src, *dest;
gpointer pr;
gint x, y, x1, x2, y1, y2;
gint gap, total, processed = 0;
gint init_value, flag;
GDrawable *drawable;
GPixelRgn src_rgn, dest_rgn;
guchar *src, *dest;
gpointer pr;
gint x, y, x1, x2, y1, y2;
gint gap, total, processed = 0;
gint init_value, flag;
init_value = (VALS.max_p > 0) ? 0 : 255;
flag = (0 < VALS.max_p) ? 1 : -1;
init_value = (pvals.max_p > 0) ? 0 : 255;
flag = (0 < pvals.max_p) ? 1 : -1;
drawable = gimp_drawable_get (drawable_id);
gap = (gimp_drawable_has_alpha (drawable_id)) ? 1 : 0;
@ -251,15 +241,13 @@ MAIN_FUNCTION (gint32 drawable_id)
}
/* dialog stuff */
static int
DIALOG ()
static gint
dialog (void)
{
GtkWidget *dlg;
GtkWidget *vbox;
GtkWidget *frame;
GSList *group = NULL;
gchar **argv;
gint argc;
gchar **argv;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
@ -273,7 +261,7 @@ DIALOG ()
GTK_WIN_POS_MOUSE,
FALSE, TRUE, FALSE,
_("OK"), OK_CALLBACK,
_("OK"), ok_callback,
NULL, NULL, NULL, TRUE, FALSE,
_("Cancel"), gtk_widget_destroy,
NULL, 1, NULL, FALSE, TRUE,
@ -284,74 +272,33 @@ DIALOG ()
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
frame = gtk_frame_new (_("Parameter Settings"));
frame = gimp_radio_group_new2 (TRUE, _("Parameter Settings"),
gimp_radio_button_update,
&pvals.max_p, (gpointer) pvals.max_p,
_("Hold the Maximal Channels"),
(gpointer) MAX_CHANNELS, NULL,
_("Hold the Minimal Channels"),
(gpointer) MIN_CHANNELS, NULL,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dlg)->vbox), frame);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
group =
gtkW_vbox_add_radio_button (vbox, _("Hold the Maximal Channels"), group,
(GtkSignalFunc) gtkW_toggle_update,
&hold_max);
group =
gtkW_vbox_add_radio_button (vbox, _("Hold the Minimal Channels"), group,
(GtkSignalFunc) gtkW_toggle_update,
&hold_min);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
return INTERFACE.run;
return interface.run;
}
static void
OK_CALLBACK (GtkWidget *widget,
gpointer data)
ok_callback (GtkWidget *widget,
gpointer data)
{
VALS.max_p = hold_max;
INTERFACE.run = TRUE;
interface.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
/* VFtext interface functions */
static void
gtkW_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
toggle_val = (int *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
}
static GSList *
gtkW_vbox_add_radio_button (GtkWidget *vbox,
gchar *name,
GSList *group,
GtkSignalFunc update,
gint *value)
{
GtkWidget *toggle;
toggle = gtk_radio_button_new_with_label(group, name);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) update, value);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), *value);
gtk_widget_show (toggle);
return group;
}

133
plug-ins/common/mblur.c
View File

@ -62,17 +62,17 @@
#define PLUG_IN_NAME "plug_in_mblur"
#define PLUG_IN_VERSION "Sep 1997, 1.2"
#define MBLUR_LINEAR 0
#define MBLUR_RADIAL 1
#define MBLUR_ZOOM 2
#define MBLUR_LINEAR 0
#define MBLUR_RADIAL 1
#define MBLUR_ZOOM 2
#define MBLUR_MAX MBLUR_ZOOM
#define MBLUR_MAX MBLUR_ZOOM
typedef struct
{
gint32 mblur_type;
gint32 length;
gint32 angle;
gint32 mblur_type;
gint32 length;
gint32 angle;
} mblur_vals_t;
typedef struct
@ -108,8 +108,6 @@ static void mblur_radial (void);
static void mblur_zoom (void);
static void dialog_ok_callback (GtkWidget *, gpointer);
static void dialog_scale_update (GtkAdjustment *, gint32 *);
static void dialog_toggle_update (GtkWidget *, gint32);
static gboolean mblur_dialog (void);
@ -117,10 +115,10 @@ static gboolean mblur_dialog (void);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run /* run_proc */
};
static mblur_vals_t mbvals =
@ -763,12 +761,7 @@ mblur_dialog (void)
GtkWidget *oframe;
GtkWidget *iframe;
GtkWidget *ovbox;
GtkWidget *ivbox;
GtkWidget *table;
GtkWidget *button;
GtkWidget *label;
GtkWidget *scale;
GtkObject *adjustment;
gint argc;
@ -808,82 +801,39 @@ mblur_dialog (void)
gtk_container_set_border_width (GTK_CONTAINER (ovbox), 4);
gtk_container_add (GTK_CONTAINER (oframe), ovbox);
iframe = gtk_frame_new (_("Blur Type"));
gtk_frame_set_shadow_type (GTK_FRAME (iframe), GTK_SHADOW_ETCHED_IN);
iframe =
gimp_radio_group_new2 (TRUE, _("Blur Type"),
gimp_radio_button_update,
&mbvals.mblur_type, (gpointer) mbvals.mblur_type,
_("Linear"), (gpointer) MBLUR_LINEAR, NULL,
_("Radial"), (gpointer) MBLUR_RADIAL, NULL,
_("Zoom"), (gpointer) MBLUR_ZOOM, NULL,
NULL);
gtk_box_pack_start (GTK_BOX (ovbox), iframe, FALSE, FALSE, 0);
ivbox= gtk_vbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (ivbox), 2);
gtk_container_add (GTK_CONTAINER (iframe), ivbox);
{
int i;
gchar *name[3]= { N_("Linear"), N_("Radial"), N_("Zoom")};
button = NULL;
for (i = 0; i < 3; i++)
{
button= gtk_radio_button_new_with_label
((button == NULL) ? NULL :
gtk_radio_button_group (GTK_RADIO_BUTTON (button)),
gettext (name[i]));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
(mbvals.mblur_type == i));
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (dialog_toggle_update),
(gpointer) i);
gtk_box_pack_start (GTK_BOX (ivbox), button, FALSE, FALSE,0);
gtk_widget_show (button);
}
}
gtk_widget_show (ivbox);
gtk_widget_show (iframe);
table = gtk_table_new (2, 2, FALSE);
table = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_box_pack_start (GTK_BOX (ovbox), table, FALSE, FALSE, 0);
label = gtk_label_new( _("Length:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
gtk_widget_show (label);
adjustment = gtk_adjustment_new (mbvals.length, 0.0, 256.0,
1.0, 1.0, 1.0);
adjustment = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Length:"), 150, 0,
mbvals.length, 0.0, 256.0, 1.0, 8.0, 0,
NULL, NULL);
gtk_signal_connect (adjustment, "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&(mbvals.length));
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&mbvals.length);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
gtk_widget_set_usize (GTK_WIDGET (scale), 150, -1);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), scale, 1, 2, 0, 1);
gtk_widget_show (scale);
label = gtk_label_new (_("Angle:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 1.0);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
gtk_widget_show (label);
adjustment = gtk_adjustment_new (mbvals.angle, 0.0, 360.0,
1.0, 1.0, 1.0);
adjustment = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Angle:"), 150, 0,
mbvals.angle, 0.0, 360.0, 1.0, 15.0, 0,
NULL, NULL);
gtk_signal_connect (adjustment, "value_changed",
GTK_SIGNAL_FUNC (dialog_scale_update),
&(mbvals.angle));
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
gtk_widget_set_usize (GTK_WIDGET (scale), 150, -1);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE);
gtk_table_attach_defaults (GTK_TABLE (table), scale, 1, 2, 1, 2);
gtk_widget_show (scale);
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&mbvals.angle);
gtk_widget_show (table);
@ -906,18 +856,3 @@ dialog_ok_callback (GtkWidget *widget,
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
dialog_scale_update (GtkAdjustment *adjustment,
gint32 *value)
{
*value= adjustment->value;
}
static void
dialog_toggle_update (GtkWidget *widget,
gint32 value)
{
if (GTK_TOGGLE_BUTTON (widget)->active)
mbvals.mblur_type= value;
}

2
plug-ins/common/oilify.c
View File

@ -481,7 +481,7 @@ oilify_dialog (void)
gtk_container_add (GTK_CONTAINER (frame), table);
toggle = gtk_check_button_new_with_label (_("Use Intensity Algorithm"));
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 (gimp_toggle_button_update),
&ovals.mode);

137
plug-ins/common/sel_gauss.c
View File

@ -48,12 +48,10 @@
#include "libgimp/stdplugins-intl.h"
#define ENTRY_WIDTH 100
typedef struct
{
gdouble radius;
gint maxdelta;
gint maxdelta;
} BlurValues;
typedef struct
@ -64,46 +62,38 @@ typedef struct
/* Declare local functions.
*/
static void query (void);
static void run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static void query (void);
static void run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static void sel_gauss (GDrawable *drawable,
gdouble radius,
gint maxdelta);
static void sel_gauss (GDrawable *drawable,
gdouble radius,
gint maxdelta);
/*
* Gaussian blur interface
*/
static gint sel_gauss_dialog (void);
/*
* Gaussian blur helper functions
*/
static void sel_gauss_ok_callback (GtkWidget *widget, gpointer data);
static void sel_gauss_entry_callback (GtkWidget *widget, gpointer data);
static void sel_gauss_delta_callback (GtkWidget *widget, gpointer data);
static gint sel_gauss_dialog (void);
static void sel_gauss_ok_callback (GtkWidget *widget,
gpointer data);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static BlurValues bvals =
{
5.0, /* radius */
50 /* maxdelta */
5.0, /* radius */
50 /* maxdelta */
};
static BlurInterface bint =
{
FALSE /* run */
FALSE /* run */
};
MAIN ()
@ -178,10 +168,8 @@ run (gchar *name,
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
bvals.radius = param[3].data.d_float;
bvals.maxdelta = (param[4].data.d_int32);
if (bvals.maxdelta < 0) bvals.maxdelta = 0;
else if (bvals.maxdelta > 255) bvals.maxdelta = 255;
bvals.radius = param[3].data.d_float;
bvals.maxdelta = CLAMP (param[4].data.d_int32, 0, 255);
}
if (status == STATUS_SUCCESS && (bvals.radius < 1.0))
status = STATUS_CALLING_ERROR;
@ -238,11 +226,10 @@ static gint
sel_gauss_dialog (void)
{
GtkWidget *dlg;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *frame;
GtkWidget *table;
gchar buffer[12];
GtkWidget *spinbutton;
GtkObject *adj;
gchar **argv;
gint argc;
@ -282,35 +269,23 @@ sel_gauss_dialog (void)
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
label = gtk_label_new (_("Blur Radius:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
gtk_widget_show (label);
spinbutton = gimp_spin_button_new (&adj,
bvals.radius, 1.0, G_MAXINT, 1.0, 5.0,
0, 1, 2);
gimp_table_attach_aligned (GTK_TABLE (table), 0,
_("Blur Radius:"), 1.0, 0.5,
spinbutton, TRUE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
&bvals.radius);
entry = gtk_entry_new ();
gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 0, 1);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf (buffer, sizeof (buffer), "%f", bvals.radius);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) sel_gauss_entry_callback,
NULL);
gtk_widget_show (entry);
label = gtk_label_new (_("Max. Delta:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 1, 2);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
g_snprintf (buffer, sizeof (buffer), "%d", bvals.maxdelta);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) sel_gauss_delta_callback,
NULL);
gtk_widget_show (entry);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Max. Delta:"), 128, 0,
bvals.maxdelta, 0, 255, 1, 8, 0,
FALSE, FALSE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&bvals.maxdelta);
gtk_widget_show (table);
gtk_widget_show (frame);
@ -407,7 +382,7 @@ matrixmult (guchar *src,
dest[dix+b] = sum/fact;
}
}
if (!(y%5))
if (!(y % 5))
gimp_progress_update((double)y / (double)height);
}
}
@ -430,12 +405,12 @@ sel_gauss (GDrawable *drawable,
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
width = (x2 - x1);
height = (y2 - y1);
bytes = drawable->bpp;
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->id);
if ((width<1)||(height<1)||(bytes<1))
if ((width < 1) || (height < 1) || (bytes < 1))
return;
numrad = (gint)(radius + 1.0);
@ -452,8 +427,8 @@ sel_gauss (GDrawable *drawable,
gimp_pixel_rgn_get_rect (&src_rgn, src, x1, y1, width, height);
matrixmult(src, dest, width, height, mat, numrad,
bytes, has_alpha, maxdelta);
matrixmult (src, dest, width, height, mat, numrad,
bytes, has_alpha, maxdelta);
gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, width, height,
TRUE, TRUE);
@ -482,23 +457,3 @@ sel_gauss_ok_callback (GtkWidget *widget,
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
sel_gauss_entry_callback (GtkWidget *widget,
gpointer data)
{
bvals.radius = atof (gtk_entry_get_text (GTK_ENTRY (widget)));
if (bvals.radius < 1.0)
bvals.radius = 1.0;
}
static void
sel_gauss_delta_callback (GtkWidget *widget,
gpointer data)
{
bvals.maxdelta = atoi (gtk_entry_get_text (GTK_ENTRY (widget)));
if (bvals.maxdelta < 0)
bvals.maxdelta = 0;
if (bvals.maxdelta > 255)
bvals.maxdelta = 255;
}

30
plug-ins/common/shift.c
View File

@ -361,8 +361,8 @@ shift_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *radio_vbox;
GtkWidget *sep;
GtkWidget *table;
GtkObject *amount_data;
gchar **argv;
@ -392,17 +392,8 @@ shift_dialog (void)
NULL);
/* 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), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (frame), vbox);
radio_vbox =
gimp_radio_group_new2 (FALSE, NULL,
frame =
gimp_radio_group_new2 (TRUE, _("Parameter Settings"),
gimp_radio_button_update,
&shvals.orientation, (gpointer) shvals.orientation,
@ -410,13 +401,19 @@ shift_dialog (void)
_("Shift Vertically"), (gpointer) VERTICAL, NULL,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (radio_vbox), 0);
gtk_box_pack_start (GTK_BOX (vbox), radio_vbox, FALSE, FALSE, 0);
gtk_widget_show (radio_vbox);
gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
radio_vbox = GTK_BIN (frame)->child;
gtk_container_set_border_width (GTK_CONTAINER (radio_vbox), 4);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (radio_vbox), sep, FALSE, FALSE, 3);
gtk_widget_show (sep);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (radio_vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
amount_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
@ -427,7 +424,6 @@ shift_dialog (void)
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&shvals.shift_amount);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);

309
plug-ins/common/smooth_palette.c
View File

@ -31,44 +31,47 @@
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include <libgimp/gimplimits.h>
#include "libgimp/stdplugins-intl.h"
/* Declare local functions. */
static void query (void);
static void run (char *name,
int nparams,
GParam * param,
int *nreturn_vals,
GParam ** return_vals);
static gint dialog (void);
static void run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static gint32 doit (GDrawable * drawable, gint32 *layer_id);
static gint dialog (void);
static gint32 doit (GDrawable *drawable,
gint32 *layer_id);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
run, /* run_proc */
};
gboolean run_flag = FALSE;
MAIN()
MAIN ()
static void
query (void)
{
static GParamDef args[] =
{
{PARAM_INT32, "run_mode", "Interactive, non-interactive"},
{PARAM_IMAGE, "image", "Input image (unused)"},
{PARAM_DRAWABLE, "drawable", "Input drawable"},
{PARAM_INT32, "width", "Width"},
{PARAM_INT32, "height", "Height"},
{PARAM_INT32, "ntries", "Search Time"},
{PARAM_INT32, "show_image","Show Image?"},
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (unused)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT32, "width", "Width" },
{ PARAM_INT32, "height", "Height" },
{ PARAM_INT32, "ntries", "Search Time" },
{ PARAM_INT32, "show_image","Show Image?" },
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof(args) / sizeof(args[0]);
@ -76,20 +79,19 @@ query (void)
INIT_I18N();
gimp_install_procedure("plug_in_smooth_palette",
_("derive smooth palette from image"),
"help!",
"Scott Draves",
"Scott Draves",
"1997",
N_("<Image>/Filters/Colors/Smooth Palette..."),
"RGB*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
gimp_install_procedure ("plug_in_smooth_palette",
_("derive smooth palette from image"),
"help!",
"Scott Draves",
"Scott Draves",
"1997",
N_("<Image>/Filters/Colors/Smooth Palette..."),
"RGB*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
}
static struct {
gint width;
gint height;
@ -104,12 +106,11 @@ static struct {
1
};
static void
run (char *name,
int nparams,
run (gchar *name,
gint nparams,
GParam *param,
int *nreturn_vals,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[3];
@ -132,7 +133,8 @@ run (char *name,
case RUN_INTERACTIVE:
INIT_I18N_UI();
gimp_get_data ("plug_in_smooth_palette", &config);
if (! dialog ()) return;
if (! dialog ())
return;
break;
case RUN_NONINTERACTIVE:
@ -141,15 +143,15 @@ run (char *name,
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
config.width = param[3].data.d_int32;
config.height = param[4].data.d_int32;
config.ntries = param[5].data.d_int32;
config.show_image = (param[6].data.d_int32) ? TRUE : FALSE;
config.width = param[3].data.d_int32;
config.height = param[4].data.d_int32;
config.ntries = param[5].data.d_int32;
config.show_image = param[6].data.d_int32 ? TRUE : FALSE;
}
if (status == STATUS_SUCCESS &&
((config.width <= 0) || (config.height <= 0) || config.ntries <= 0))
status = STATUS_CALLING_ERROR;
break;
case RUN_WITH_LAST_VALS:
@ -164,12 +166,12 @@ run (char *name,
if (status == STATUS_SUCCESS)
{
drawable = gimp_drawable_get(param[2].data.d_drawable);
if (gimp_drawable_is_rgb(drawable->id))
drawable = gimp_drawable_get (param[2].data.d_drawable);
if (gimp_drawable_is_rgb (drawable->id))
{
gimp_progress_init ( _("Deriving smooth palette..."));
gimp_progress_init (_("Deriving smooth palette..."));
gimp_tile_cache_ntiles (2 * (drawable->width + 1) / gimp_tile_width ());
values[1].data.d_image = doit(drawable, &values[2].data.d_layer);
values[1].data.d_image = doit (drawable, &values[2].data.d_layer);
if (run_mode == RUN_INTERACTIVE)
gimp_set_data ("plug_in_smooth_palette", &config, sizeof (config));
if (config.show_image)
@ -177,7 +179,7 @@ run (char *name,
}
else
status = STATUS_EXECUTION_ERROR;
gimp_drawable_detach(drawable);
gimp_drawable_detach (drawable);
}
values[0].data.d_status = status;
@ -187,12 +189,12 @@ run (char *name,
static long
pix_diff (guchar *pal,
int bpp,
int i,
int j)
gint bpp,
gint i,
gint j)
{
long r = 0;
int k;
glong r = 0;
gint k;
for (k = 0; k < bpp; k++)
{
@ -206,11 +208,11 @@ pix_diff (guchar *pal,
static void
pix_swap (guchar *pal,
int bpp,
int i,
int j)
gint bpp,
gint i,
gint j)
{
int k;
gint k;
for (k = 0; k < bpp; k++)
{
@ -243,11 +245,11 @@ doit (GDrawable *drawable,
psize = config.width;
pal = malloc(psize * bpp);
pal = g_malloc (psize * bpp);
gimp_pixel_rgn_init(&pr, drawable, 0, 0, drawable->width,
drawable->height,
FALSE, FALSE);
gimp_pixel_rgn_init (&pr, drawable, 0, 0, drawable->width,
drawable->height,
FALSE, FALSE);
/* get initial palette */
for (i = 0; i < psize; i++)
@ -260,107 +262,108 @@ doit (GDrawable *drawable,
/* reorder */
if (1)
{
guchar *pal_best = malloc(psize * bpp);
guchar *original = malloc(psize * bpp);
guchar *pal_best = g_malloc (psize * bpp);
guchar *original = g_malloc (psize * bpp);
double len_best = 0;
int try;
memcpy(pal_best, pal, bpp * psize);
memcpy(original, pal, bpp * psize);
memcpy (pal_best, pal, bpp * psize);
memcpy (original, pal, bpp * psize);
for (try = 0; try < config.ntries; try++)
{
double len;
if (!(try%5))
gimp_progress_update(try/(double)config.ntries);
memcpy(pal, original, bpp * psize);
gimp_progress_update (try / (double) config.ntries);
memcpy (pal, original, bpp * psize);
/* scramble */
for (i = 1; i < psize; i++)
pix_swap(pal, bpp, i, R % psize);
pix_swap (pal, bpp, i, R % psize);
/* measure */
len = 0.0;
for (i = 1; i < psize; i++)
len += pix_diff(pal, bpp, i, i-1);
len += pix_diff (pal, bpp, i, i-1);
/* improve */
for (i = 0; i < config.try_size; i++)
{
int i0 = 1 + (R % (psize-2));
int i1 = 1 + (R % (psize-2));
long as_is, swapd;
gint i0 = 1 + (R % (psize-2));
gint i1 = 1 + (R % (psize-2));
glong as_is, swapd;
if (1 == (i0 - i1))
{
as_is = (pix_diff(pal, bpp, i1 - 1, i1) +
pix_diff(pal, bpp, i0, i0 + 1));
swapd = (pix_diff(pal, bpp, i1 - 1, i0) +
pix_diff(pal, bpp, i1, i0 + 1));
as_is = (pix_diff (pal, bpp, i1 - 1, i1) +
pix_diff (pal, bpp, i0, i0 + 1));
swapd = (pix_diff (pal, bpp, i1 - 1, i0) +
pix_diff (pal, bpp, i1, i0 + 1));
}
else if
(1 == (i1 - i0))
else if (1 == (i1 - i0))
{
as_is = (pix_diff(pal, bpp, i0 - 1, i0) +
pix_diff(pal, bpp, i1, i1 + 1));
swapd = (pix_diff(pal, bpp, i0 - 1, i1) +
pix_diff(pal, bpp, i0, i1 + 1));
as_is = (pix_diff (pal, bpp, i0 - 1, i0) +
pix_diff (pal, bpp, i1, i1 + 1));
swapd = (pix_diff (pal, bpp, i0 - 1, i1) +
pix_diff (pal, bpp, i0, i1 + 1));
}
else
{
as_is = (pix_diff(pal, bpp, i0, i0 + 1) +
pix_diff(pal, bpp, i0, i0 - 1) +
pix_diff(pal, bpp, i1, i1 + 1) +
pix_diff(pal, bpp, i1, i1 - 1));
swapd = (pix_diff(pal, bpp, i1, i0 + 1) +
pix_diff(pal, bpp, i1, i0 - 1) +
pix_diff(pal, bpp, i0, i1 + 1) +
pix_diff(pal, bpp, i0, i1 - 1));
as_is = (pix_diff (pal, bpp, i0, i0 + 1) +
pix_diff (pal, bpp, i0, i0 - 1) +
pix_diff (pal, bpp, i1, i1 + 1) +
pix_diff (pal, bpp, i1, i1 - 1));
swapd = (pix_diff (pal, bpp, i1, i0 + 1) +
pix_diff (pal, bpp, i1, i0 - 1) +
pix_diff (pal, bpp, i0, i1 + 1) +
pix_diff (pal, bpp, i0, i1 - 1));
}
if (swapd < as_is)
{
pix_swap(pal, bpp, i0, i1);
pix_swap (pal, bpp, i0, i1);
len += swapd - as_is;
}
}
/* best? */
if (0 == try || len < len_best)
{
memcpy(pal_best, pal, bpp * psize);
memcpy (pal_best, pal, bpp * psize);
len_best = len;
}
}
memcpy(pal, pal_best, bpp * psize);
free(pal_best);
free(original);
memcpy (pal, pal_best, bpp * psize);
g_free (pal_best);
g_free (original);
/* clean */
for (i = 1; i < 4 * psize; i++)
{
long as_is, swapd;
int i0 = 1 + R % (psize - 2);
int i1 = i0 + 1;
as_is = (pix_diff(pal, bpp, i0 - 1, i0) +
pix_diff(pal, bpp, i1, i1 + 1));
swapd = (pix_diff(pal, bpp, i0 - 1, i1) +
pix_diff(pal, bpp, i0, i1 + 1));
glong as_is, swapd;
gint i0 = 1 + R % (psize - 2);
gint i1 = i0 + 1;
as_is = (pix_diff (pal, bpp, i0 - 1, i0) +
pix_diff (pal, bpp, i1, i1 + 1));
swapd = (pix_diff (pal, bpp, i0 - 1, i1) +
pix_diff (pal, bpp, i0, i1 + 1));
if (swapd < as_is)
{
pix_swap(pal, bpp, i0, i1);
pix_swap (pal, bpp, i0, i1);
len_best += swapd - as_is;
}
}
}
/* store smooth palette */
gimp_pixel_rgn_init(&pr, new_layer, 0, 0,
config.width, config.height,
TRUE, TRUE);
gimp_pixel_rgn_init (&pr, new_layer, 0, 0,
config.width, config.height,
TRUE, TRUE);
for (j = 0; j < config.height; j++)
for (i = 0; i < config.width; i++)
gimp_pixel_rgn_set_pixel(&pr, pal + bpp * i, i, j);
free(pal);
gimp_pixel_rgn_set_pixel (&pr, pal + bpp * i, i, j);
g_free (pal);
gimp_drawable_flush(new_layer);
gimp_drawable_merge_shadow(new_layer->id, TRUE);
gimp_drawable_flush (new_layer);
gimp_drawable_merge_shadow (new_layer->id, TRUE);
gimp_drawable_update(new_layer->id, 0, 0,
config.width, config.height);
@ -377,37 +380,15 @@ ok_callback (GtkWidget *widget,
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
callback (GtkWidget *widget,
gpointer data)
{
if (&config.width == data)
{
config.width = atoi (gtk_entry_get_text (GTK_ENTRY (widget)));
}
else if (&config.height == data)
{
config.height = atoi (gtk_entry_get_text (GTK_ENTRY (widget)));
}
else if (&config.ntries == data)
{
config.ntries = atoi (gtk_entry_get_text (GTK_ENTRY (widget)));
}
else
{
fprintf (stderr, "bad data in callback: %x\n", (int) data);
}
}
static gint
dialog (void)
{
GtkWidget *dlg;
GtkWidget *table;
GtkWidget *w;
GtkWidget *spinbutton;
GtkObject *adj;
gchar **argv;
gint argc;
gchar b[12];
argc = 1;
argv = g_new (gchar *, 1);
@ -440,56 +421,32 @@ dialog (void)
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
w = gtk_label_new (_("Width:"));
gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), w, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (w);
w = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), w, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_set_usize (w, 50, 0);
g_snprintf (b, sizeof (b), "%d", config.width);
gtk_entry_set_text (GTK_ENTRY (w), b);
gtk_signal_connect (GTK_OBJECT (w), "changed",
(GtkSignalFunc) callback,
spinbutton = gimp_spin_button_new (&adj, config.width,
1, GIMP_MAX_IMAGE_SIZE, 1, 10, 0, 1, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0,
_("Width:"), 1.0, 0.5,
spinbutton, FALSE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&config.width);
gtk_widget_show (w);
w = gtk_label_new (_("Height:"));
gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), w, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (w);
w = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), w, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_set_usize (w, 50, 0);
g_snprintf (b, sizeof (b), "%d", config.height);
gtk_entry_set_text (GTK_ENTRY (w), b);
gtk_signal_connect (GTK_OBJECT (w), "changed",
(GtkSignalFunc) callback,
spinbutton = gimp_spin_button_new (&adj, config.height,
1, GIMP_MAX_IMAGE_SIZE, 1, 10, 0, 1, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 1,
_("Height:"), 1.0, 0.5,
spinbutton, FALSE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&config.height);
gtk_widget_show (w);
w = gtk_label_new (_("Search Time:"));
gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), w, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (w);
w = gtk_entry_new ();
gtk_table_attach (GTK_TABLE (table), w, 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_set_usize (w, 50, 0);
g_snprintf (b, sizeof (b), "%d", config.ntries);
gtk_entry_set_text (GTK_ENTRY (w), b);
gtk_signal_connect (GTK_OBJECT (w), "changed",
(GtkSignalFunc) callback,
spinbutton = gimp_spin_button_new (&adj, config.ntries,
1, 1024, 1, 10, 0, 1, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 2,
_("Search Time:"), 1.0, 0.5,
spinbutton, FALSE);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&config.ntries);
gtk_widget_show (w);
gtk_widget_show (dlg);

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

@ -341,6 +341,7 @@ sparkle_dialog (void)
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
@ -485,8 +486,12 @@ sparkle_dialog (void)
gtk_box_pack_start (GTK_BOX (main_vbox), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
toggle = gtk_check_button_new_with_label (_("Preserve Luminosity"));
@ -520,10 +525,14 @@ sparkle_dialog (void)
_("Draw a Border of Spikes around the Image"),
NULL);
sep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 0);
sep = gtk_vseparator_new ();
gtk_box_pack_start (GTK_BOX (hbox), sep, FALSE, FALSE, 0);
gtk_widget_show (sep);
vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
/* colortype */
toggle = gtk_radio_button_new_with_label (group, _("Natural Color"));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);

310
plug-ins/common/video.c
View File

@ -28,15 +28,17 @@
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
#define MAX_PATTERNS 9
#define MAX_PATTERN_SIZE 108
const gint pattern_width[MAX_PATTERNS] = {2,4,1,1,2,3,6,6,5};
const gint pattern_height[MAX_PATTERNS] = {6,12,3,6,12,3,6,18,15};
const char *pattern_name[MAX_PATTERNS] = {
const gint pattern_width[MAX_PATTERNS] = { 2, 4, 1, 1, 2, 3, 6, 6, 5 };
const gint pattern_height[MAX_PATTERNS] = { 6, 12, 3, 6, 12, 3, 6, 18, 15 };
const gchar *pattern_name[MAX_PATTERNS] =
{
N_("Staggered"),
N_("Large staggered"),
N_("Striped"),
@ -51,26 +53,26 @@ const char *pattern_name[MAX_PATTERNS] = {
const gint pattern[MAX_PATTERNS][MAX_PATTERN_SIZE] =
{
{
0,1,
0,2,
1,2,
1,0,
2,0,
2,1,
0, 1,
0, 2,
1, 2,
1, 0,
2, 0,
2, 1,
},
{
0,0,1,1,
0,0,1,1,
0,0,2,2,
0,0,2,2,
1,1,2,2,
1,1,2,2,
1,1,0,0,
1,1,0,0,
2,2,0,0,
2,2,0,0,
2,2,1,1,
2,2,1,1,
0, 0, 1, 1,
0, 0, 1, 1,
0, 0, 2, 2,
0, 0, 2, 2,
1, 1, 2, 2,
1, 1, 2, 2,
1, 1, 0, 0,
1, 1, 0, 0,
2, 2, 0, 0,
2, 2, 0, 0,
2, 2, 1, 1,
2, 2, 1, 1,
},
{
0,
@ -86,74 +88,75 @@ const gint pattern[MAX_PATTERNS][MAX_PATTERN_SIZE] =
2,
},
{
0,1,
0,1,
0,2,
0,2,
1,2,
1,2,
1,0,
1,0,
2,0,
2,0,
2,1,
2,1,
0, 1,
0, 1,
0, 2,
0, 2,
1, 2,
1, 2,
1, 0,
1, 0,
2, 0,
2, 0,
2, 1,
2, 1,
},
{
0,1,2,
2,0,1,
1,2,0,
0, 1, 2,
2, 0, 1,
1, 2, 0,
},
{
0,0,1,1,2,2,
0,0,1,1,2,2,
2,2,0,0,1,1,
2,2,0,0,1,1,
1,1,2,2,0,0,
1,1,2,2,0,0,
0, 0, 1, 1, 2, 2,
0, 0, 1, 1, 2, 2,
2, 2, 0, 0, 1, 1,
2, 2, 0, 0, 1, 1,
1, 1, 2, 2, 0, 0,
1, 1, 2, 2, 0, 0,
},
{
2,2,0,0,0,0,
2,2,2,0,0,2,
2,2,2,2,2,2,
2,2,2,1,1,2,
2,2,1,1,1,1,
1,1,1,1,1,1,
0,0,1,1,1,1,
0,0,0,1,1,0,
0,0,0,0,0,0,
0,0,0,2,2,0,
0,0,2,2,2,2,
2,2,2,2,2,2,
1,1,2,2,2,2,
1,1,1,2,2,1,
1,1,1,1,1,1,
1,1,1,0,0,1,
1,1,0,0,0,0,
0,0,0,0,0,0,
2, 2, 0, 0, 0, 0,
2, 2, 2, 0, 0, 2,
2, 2, 2, 2, 2, 2,
2, 2, 2, 1, 1, 2,
2, 2, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 1, 1, 1, 1,
0, 0, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 2, 2, 0,
0, 0, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2,
1, 1, 2, 2, 2, 2,
1, 1, 1, 2, 2, 1,
1, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 1,
1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
},
{
0,1,2,0,0,
1,1,1,2,0,
0,1,2,2,2,
0,0,1,2,0,
0,1,1,1,2,
2,0,1,2,2,
0,0,0,1,2,
2,0,1,1,1,
2,2,0,1,2,
2,0,0,0,1,
1,2,0,1,1,
2,2,2,0,1,
1,2,0,0,0,
1,1,2,0,1,
1,2,2,2,0,
0, 1, 2, 0, 0,
1, 1, 1, 2, 0,
0, 1, 2, 2, 2,
0, 0, 1, 2, 0,
0, 1, 1, 1, 2,
2, 0, 1, 2, 2,
0, 0, 0, 1, 2,
2, 0, 1, 1, 1,
2, 2, 0, 1, 2,
2, 0, 0, 0, 1,
1, 2, 0, 1, 1,
2, 2, 2, 0, 1,
1, 2, 0, 0, 0,
1, 1, 2, 0, 1,
1, 2, 2, 2, 0,
}
};
#define PREVIEW_WIDTH 100
#define PREVIEW_WIDTH 100
#define PREVIEW_HEIGHT 100
/* The raw preview image */
const guchar preview_raw[3 * PREVIEW_WIDTH * PREVIEW_HEIGHT] =
{
@ -1738,23 +1741,21 @@ const guchar preview_raw[3 * PREVIEW_WIDTH * PREVIEW_HEIGHT] =
219,229,238,222,229,238,221,228,237,221,228,237,220,227,236,217,224,233
};
typedef struct {
typedef struct
{
gint pattern_number;
gint additive;
gint rotated;
} VideoValues;
typedef struct {
typedef struct
{
gint run;
} VideoInterface;
static GtkWidget *preview = NULL;
static gint radio_pressed[MAX_PATTERNS];
static gint in_main_loop = FALSE;
static gint in_main_loop = FALSE;
static VideoValues vvals =
{
@ -1769,52 +1770,49 @@ static VideoInterface vint =
};
/* Declare local functions.
*/
static void query (void);
static void run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals);
static void run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals);
static void video (GDrawable *drawable);
static void video (GDrawable *drawable);
static gint video_dialog (void);
static gint video_dialog (void);
static void video_ok_callback (GtkWidget *widget,
gpointer data);
static void video_toggle_update (GtkWidget *widget,
gpointer data);
static void video_radio_update (GtkWidget *widget,
gpointer data);
static void video_render_preview (gint raw);
static void video_render_row (const guchar *src_row,
guchar *dest_row,
gint row,
gint rotated,
gint additive,
gint pattern_number,
gint row_width,
gint bytes);
guchar *dest_row,
gint row,
gint rotated,
gint additive,
gint pattern_number,
gint row_width,
gint bytes);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
MAIN ()
static void
query ()
query (void)
{
static GParamDef args[] =
{
@ -1845,10 +1843,10 @@ query ()
}
static void
run (char *name,
int nparams,
run (gchar *name,
gint nparams,
GParam *param,
int *nreturn_vals,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
@ -1931,18 +1929,15 @@ run (char *name,
gimp_drawable_detach (drawable);
}
static void
video_render_row (const guchar *src_row,
guchar *dest_row,
gint row,
gint rotated,
gint additive,
gint pattern_number,
gint row_width,
gint bytes)
guchar *dest_row,
gint row,
gint rotated,
gint additive,
gint pattern_number,
gint row_width,
gint bytes)
{
gint col, bytenum;
@ -2022,10 +2017,6 @@ video_render_row (const guchar *src_row,
}
}
static void
video (GDrawable *drawable)
{
@ -2093,33 +2084,18 @@ video (GDrawable *drawable)
free (dest_row);
}
static void
video_render_preview (gint raw)
{
gint x,y;
guchar preview_row[PREVIEW_WIDTH*3];
/* determine pattern number from radio buttons */
vvals.pattern_number=-1;
for (y=0;y<MAX_PATTERNS;y++)
{
if (radio_pressed[y]==TRUE)
{
vvals.pattern_number = y;
break;
}
}
if (vvals.pattern_number==-1)
{
vvals.pattern_number=0;
return;
}
if (raw)
{
for (y = 0; y < PREVIEW_HEIGHT; y++)
@ -2158,10 +2134,8 @@ video_render_preview (gint raw)
gdk_flush ();
}
static gint
video_dialog ()
video_dialog (void)
{
GtkWidget *dlg;
GtkWidget *frame;
@ -2180,11 +2154,6 @@ video_dialog ()
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("video");
for (y = 0; y < MAX_PATTERNS; y++)
{
radio_pressed[y] = (vvals.pattern_number == y);
}
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
@ -2215,7 +2184,7 @@ video_dialog ()
NULL);
/* main parameter frame */
frame = gtk_frame_new ( _("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), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
@ -2236,7 +2205,7 @@ video_dialog ()
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"));
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",
(GtkSignalFunc) video_toggle_update,
@ -2277,11 +2246,12 @@ video_dialog ()
gettext(pattern_name[y]));
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_object_set_user_data (GTK_OBJECT (toggle), (gpointer) y);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) video_toggle_update,
&radio_pressed[y]);
(GtkSignalFunc) video_radio_update,
&vvals.pattern_number);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
radio_pressed[y]);
vvals.pattern_number == y);
gtk_widget_show (toggle);
}
@ -2297,27 +2267,15 @@ video_dialog ()
in_main_loop = FALSE;
gdk_flush ();
vvals.pattern_number = 0;
for (y = 0; y < MAX_PATTERNS; y++)
{
if (radio_pressed[y]==TRUE)
{
vvals.pattern_number = y;
break;
}
}
return vint.run;
}
/* Video interface functions */
static void
video_ok_callback (GtkWidget *widget,
gpointer data)
{
vint.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
@ -2325,14 +2283,18 @@ static void
video_toggle_update (GtkWidget *widget,
gpointer data)
{
gint *toggle_val;
gimp_toggle_button_update (widget, data);
toggle_val = (int *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
if (in_main_loop) video_render_preview(FALSE);
if (in_main_loop)
video_render_preview (FALSE);
}
static void
video_radio_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
if (in_main_loop)
video_render_preview (FALSE);
}

438
plug-ins/common/vpropagate.c
View File

@ -27,16 +27,18 @@
In other word, pixel itself is not a neighbor of it.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.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"
#define PLUG_IN_NAME "plug_in_vpropagate"
@ -69,14 +71,8 @@ static void prepare_row (GPixelRgn *pixel_rgn,
int y,
int w);
static void gtkW_gint_update (GtkWidget *widget,
gpointer data);
static void gtkW_scale_update (GtkAdjustment *adjustment,
double *data);
static void vpropagate_ok_callback (GtkWidget *widget,
gpointer data);
static void gtkW_toggle_update (GtkWidget *widget,
gpointer data);
static GtkWidget * gtkW_table_add_toggle (GtkWidget *table,
gchar *name,
gint x1,
@ -84,31 +80,6 @@ static GtkWidget * gtkW_table_add_toggle (GtkWidget *table,
gint y,
GtkSignalFunc update,
gint *value);
static GSList * gtkW_vbox_add_radio_button (GtkWidget *vbox,
gchar *name,
GSList *group,
GtkSignalFunc update,
gint *value);
static void gtkW_table_add_gint (GtkWidget *table,
gchar *name,
gint x,
gint y,
GtkSignalFunc update,
gint *value,
gchar *buffer);
static void gtkW_table_add_scale (GtkWidget *table,
gchar *name,
gint x1,
gint y,
GtkSignalFunc update,
gdouble *value,
gdouble min,
gdouble max,
gdouble step);
static GtkWidget * gtkW_frame_new (gchar *name,
GtkWidget *parent);
static GtkWidget * gtkW_hbox_new (GtkWidget *parent);
static GtkWidget * gtkW_vbox_new (GtkWidget *parent);
static int value_difference_check (CH *, CH *, int);
static void set_value (GImageType, int, CH *, CH *, CH *, void *);
@ -128,17 +99,17 @@ static void propagate_transparent (GImageType, int, CH *, CH *, CH *, void
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
#define ENTRY_WIDTH 100
#define UPDATE_STEP 20
#define SCALE_WIDTH 100
#define PROPAGATING_VALUE 1<<0
#define PROPAGATING_ALPHA 1<<1
#define ENTRY_WIDTH 100
#define UPDATE_STEP 20
#define SCALE_WIDTH 100
#define PROPAGATING_VALUE 1<<0
#define PROPAGATING_ALPHA 1<<1
/* parameters */
typedef struct
@ -168,7 +139,7 @@ static VPValueType vpvals =
gint propagate_alpha;
gint propagate_value;
gint direction_mask_vec[4];
gint channel_mask [] = {1, 1, 1};
gint channel_mask[] = { 1, 1, 1 };
gint peak_max = 1;
gint peak_min = 1;
gint peak_includes_equals = 1;
@ -176,33 +147,40 @@ guchar fore[3];
typedef struct
{
int applicable_image_type;
char *name;
void (*initializer)();
void (*updater)();
void (*finalizer)();
gint selected;
gint applicable_image_type;
gchar *name;
void (*initializer) ();
void (*updater) ();
void (*finalizer) ();
} ModeParam;
#define num_mode 8
static ModeParam modes[num_mode] =
{
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA, N_("more white (larger value)"),
initialize_white, propagate_white, set_value, FALSE},
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA, N_("more black (smaller value)"),
initialize_black, propagate_black, set_value, FALSE},
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA, N_("middle value to peaks"),
initialize_middle, propagate_middle, set_middle_to_peak, FALSE},
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA, N_("foreground to peaks"),
initialize_middle, propagate_middle, set_foreground_to_peak, FALSE},
{ VP_RGB | VP_WITH_ALPHA | VP_WO_ALPHA, N_("only foreground"),
initialize_foreground, propagate_a_color, set_value, FALSE},
{ VP_RGB | VP_WITH_ALPHA | VP_WO_ALPHA, N_("only background"),
initialize_background, propagate_a_color, set_value, FALSE},
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA, N_("more opaque"),
NULL, propagate_opaque, set_value, FALSE},
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA, N_("more transparent"),
NULL, propagate_transparent, set_value, FALSE}
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA,
N_("More White (Larger Value)"),
initialize_white, propagate_white, set_value },
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA,
N_("More Black (Smaller Value)"),
initialize_black, propagate_black, set_value },
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA,
N_("Middle Value to Peaks"),
initialize_middle, propagate_middle, set_middle_to_peak },
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA | VP_WO_ALPHA,
N_("Foreground to Peaks"),
initialize_middle, propagate_middle, set_foreground_to_peak },
{ VP_RGB | VP_WITH_ALPHA | VP_WO_ALPHA,
N_("Only Foreground"),
initialize_foreground, propagate_a_color, set_value },
{ VP_RGB | VP_WITH_ALPHA | VP_WO_ALPHA,
N_("Only Background"),
initialize_background, propagate_a_color, set_value },
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA,
N_("More Opaque"),
NULL, propagate_opaque, set_value },
{ VP_RGB | VP_GRAY | VP_WITH_ALPHA,
N_("More Transparent"),
NULL, propagate_transparent, set_value },
};
typedef struct
@ -211,12 +189,12 @@ typedef struct
} VPInterface;
static VPInterface vpropagate_interface = { FALSE };
gint drawable_id;
gint drawable_id;
MAIN ()
static void
query ()
query (void)
{
static GParamDef args [] =
{
@ -250,11 +228,11 @@ query ()
}
static void
run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals)
run (gchar *name,
gint nparams,
GParam *param,
gint *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GStatusType status = STATUS_SUCCESS;
@ -275,11 +253,10 @@ run (char *name,
INIT_I18N_UI();
gimp_get_data (PLUG_IN_NAME, &vpvals);
/* building the values of dialog variables from vpvals. */
modes[vpvals.propagate_mode].selected = TRUE;
propagate_alpha = (vpvals.propagating_channel & PROPAGATING_ALPHA) ?
TRUE : FALSE;
propagate_value = (vpvals.propagating_channel & PROPAGATING_VALUE) ?
TRUE : FALSE;
propagate_alpha =
(vpvals.propagating_channel & PROPAGATING_ALPHA) ? TRUE : FALSE;
propagate_value =
(vpvals.propagating_channel & PROPAGATING_VALUE) ? TRUE : FALSE;
{
int i;
for (i = 0; i < 4; i++)
@ -317,7 +294,7 @@ run (char *name,
/* registered function entry */
static GStatusType
value_propagate (gint drawable_id)
value_propagate (gint drawable_id)
{
/* check the validness of parameters */
if (!(vpvals.propagating_channel & (PROPAGATING_VALUE | PROPAGATING_ALPHA)))
@ -342,7 +319,7 @@ value_propagate (gint drawable_id)
}
static void
value_propagate_body (gint drawable_id)
value_propagate_body (gint drawable_id)
{
GDrawable *drawable;
GImageType dtype;
@ -947,11 +924,14 @@ vpropagate_dialog (GImageType image_type)
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle_vbox;
GtkWidget *button;
GtkWidget *sep;
GtkObject *adj;
GSList *group = NULL;
gchar **argv;
gint argc;
static gchar buffer[3][10];
gint index = 0;
argc = 1;
argv = g_new (gchar *, 1);
@ -974,82 +954,109 @@ vpropagate_dialog (GImageType image_type)
GTK_SIGNAL_FUNC (gtk_main_quit),
NULL);
hbox = gtkW_hbox_new((GTK_DIALOG (dlg)->vbox));
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* Propagate Mode */
{
GtkWidget *frame;
GtkWidget *toggle_vbox;
GSList *group = NULL;
gint index = 0;
frame = gtk_frame_new (_("Propagate Mode"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
frame = gtkW_frame_new ( _("Propagate Mode"), hbox);
toggle_vbox = gtkW_vbox_new (frame);
toggle_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (toggle_vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), toggle_vbox);
for (index = 0; index < num_mode ; index++ )
group = gtkW_vbox_add_radio_button (toggle_vbox, gettext(modes[index].name), group,
(GtkSignalFunc) gtkW_toggle_update,
&modes[index].selected);
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
}
for (index = 0; index < num_mode; index++)
{
button = gtk_radio_button_new_with_label (group,
gettext (modes[index].name));
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (toggle_vbox), button, FALSE, FALSE, 0);
gtk_object_set_user_data (GTK_OBJECT (button), (gpointer) index);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC (gimp_radio_button_update),
&vpvals.propagate_mode);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
index == vpvals.propagate_mode);
gtk_widget_show (button);
}
gtk_widget_show (toggle_vbox);
gtk_widget_show (frame);
/* Parameter settings */
frame = gtkW_frame_new ( _("Parameter Settings"), hbox);
table = gtk_table_new (9,2, FALSE); /* 4 raw, 2 columns(name and value) */
gtk_container_border_width (GTK_CONTAINER (table), 10);
frame = gtk_frame_new (_("Parameter Settings"));
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (10, 3, FALSE); /* 4 raw, 2 columns(name and value) */
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);
gtkW_table_add_gint (table, _("Lower threshold"), 0, 0,
(GtkSignalFunc) gtkW_gint_update,
&vpvals.lower_limit, buffer[0]);
gtkW_table_add_gint (table, _("Upper threshold"), 0, 1,
(GtkSignalFunc) gtkW_gint_update,
&vpvals.upper_limit, buffer[1]);
gtkW_table_add_scale (table, _("Propagating Rate"), 0, 2,
(GtkSignalFunc) gtkW_scale_update,
&vpvals.propagating_rate, 0.0, 1.0, 0.01);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("Lower Threshold:"), SCALE_WIDTH, 0,
vpvals.lower_limit, 0, 255, 1, 8, 0,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&vpvals.lower_limit);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("Upper Threshold:"), SCALE_WIDTH, 0,
vpvals.upper_limit, 0, 255, 1, 8, 0,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_int_adjustment_update),
&vpvals.upper_limit);
adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2,
_("Propagating Rate:"), SCALE_WIDTH, 0,
vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2,
NULL, NULL);
gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
GTK_SIGNAL_FUNC (gimp_double_adjustment_update),
&vpvals.propagating_rate);
sep = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (table), sep, 0, 2, 3, 4, GTK_FILL, 0, 0, 0);
gtk_table_attach (GTK_TABLE (table), sep, 0, 3, 3, 4, GTK_FILL, 0, 0, 0);
gtk_widget_show (sep);
gtkW_table_add_toggle (table, _("to Left"), 0, 1, 4,
(GtkSignalFunc) gtkW_toggle_update,
gtkW_table_add_toggle (table, _("To Left"), 0, 1, 5,
(GtkSignalFunc) gimp_toggle_button_update,
&direction_mask_vec[Right2Left]);
gtkW_table_add_toggle (table, _("to Right"), 1, 2, 4,
(GtkSignalFunc) gtkW_toggle_update,
gtkW_table_add_toggle (table, _("To Right"), 2, 3, 5,
(GtkSignalFunc) gimp_toggle_button_update,
&direction_mask_vec[Left2Right]);
gtkW_table_add_toggle (table, _("to Top"), 0, 1, 5,
(GtkSignalFunc) gtkW_toggle_update,
gtkW_table_add_toggle (table, _("To Top"), 1, 2, 4,
(GtkSignalFunc) gimp_toggle_button_update,
&direction_mask_vec[Bottom2Top]);
gtkW_table_add_toggle (table, _("to Bottom"), 1, 2, 5,
(GtkSignalFunc) gtkW_toggle_update,
gtkW_table_add_toggle (table, _("To Bottom"), 1, 2, 6,
(GtkSignalFunc) gimp_toggle_button_update,
&direction_mask_vec[Top2Bottom]);
if ((image_type == RGBA_IMAGE) | (image_type == GRAYA_IMAGE))
{
GtkWidget *sep;
sep = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (table), sep, 0, 2, 6, 7, GTK_FILL, 0, 0, 0);
gtk_table_attach (GTK_TABLE (table), sep, 0, 3, 7, 8, GTK_FILL, 0, 0, 0);
gtk_widget_show (sep);
{
GtkWidget *toggle;
toggle = gtkW_table_add_toggle (table, _("Propagating Alpha Channel"),
0, 2, 7,
(GtkSignalFunc) gtkW_toggle_update,
&propagate_alpha);
toggle =
gtkW_table_add_toggle (table, _("Propagating Alpha Channel"),
0, 3, 8,
(GtkSignalFunc) gimp_toggle_button_update,
&propagate_alpha);
if (gimp_layer_get_preserve_transparency (drawable_id))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0);
gtk_widget_set_sensitive (toggle, FALSE);
}
}
gtkW_table_add_toggle (table, _("Propagating Value Channel"), 0, 2, 8,
(GtkSignalFunc) gtkW_toggle_update,
gtkW_table_add_toggle (table, _("Propagating Value Channel"), 0, 3, 9,
(GtkSignalFunc) gimp_toggle_button_update,
&propagate_value);
}
gtk_widget_show (table);
@ -1063,96 +1070,24 @@ vpropagate_dialog (GImageType image_type)
return vpropagate_interface.run;
}
/* VFtext interface functions */
static void
gtkW_gint_update (GtkWidget *widget,
gpointer data)
{
*(gint *)data = (gint)atof (gtk_entry_get_text (GTK_ENTRY (widget)));
}
static void
gtkW_scale_update (GtkAdjustment *adjustment,
gdouble *scale_val)
{
*scale_val = (gdouble) adjustment->value;
}
static void
vpropagate_ok_callback (GtkWidget *widget,
gpointer data)
{
gint index;
gint i, result;
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0));
for (index = 0; index < num_mode; index++ )
if (modes[index].selected)
{
vpvals.propagate_mode = index;
break;
}
{
gint i, result;
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
}
vpvals.propagating_channel = (propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0);
vpropagate_interface.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
gtkW_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
toggle_val = (int *) data;
if (GTK_TOGGLE_BUTTON (widget)->active)
*toggle_val = TRUE;
else
*toggle_val = FALSE;
}
GtkWidget *
gtkW_hbox_new (GtkWidget *parent)
{
GtkWidget *hbox;
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (hbox), 5);
gtk_box_pack_start (GTK_BOX (parent), hbox, FALSE, TRUE, 0);
return hbox;
}
GtkWidget *
gtkW_vbox_new (GtkWidget *parent)
{
GtkWidget *vbox;
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 10);
/* gtk_box_pack_start (GTK_BOX (parent), vbox, TRUE, TRUE, 0); */
gtk_container_add (GTK_CONTAINER (parent), vbox);
return vbox;
}
GtkWidget *
gtkW_frame_new (gchar *name,
GtkWidget *parent)
{
GtkWidget *frame;
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_box_pack_start (GTK_BOX(parent), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
return frame;
}
static GtkWidget *
gtkW_table_add_toggle (GtkWidget *table,
gchar *name,
@ -1174,92 +1109,3 @@ gtkW_table_add_toggle (GtkWidget *table,
gtk_widget_show (toggle);
return toggle;
}
static GSList *
gtkW_vbox_add_radio_button (GtkWidget *vbox,
gchar *name,
GSList *group,
GtkSignalFunc update,
gint *value)
{
GtkWidget *toggle;
toggle = gtk_radio_button_new_with_label(group, name);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) update, value);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), *value);
gtk_widget_show (toggle);
return group;
}
static void
gtkW_table_add_gint (GtkWidget *table,
gchar *name,
gint x,
gint y,
GtkSignalFunc update,
gint *value,
gchar *buffer)
{
GtkWidget *label, *entry;
label = gtk_label_new (name);
gtk_misc_set_alignment (GTK_MISC(label), 0.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_widget_show(label);
entry = gtk_entry_new();
gtk_table_attach (GTK_TABLE(table), entry, x+1, x+2, y, y+1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 10, 0);
gtk_widget_set_usize (entry, ENTRY_WIDTH, 0);
sprintf (buffer, "%d", *(gint *)value);
gtk_entry_set_text (GTK_ENTRY (entry), buffer);
gtk_signal_connect (GTK_OBJECT (entry), "changed",
(GtkSignalFunc) update, value);
gtk_widget_show(entry);
}
static void
gtkW_table_add_scale (GtkWidget *table,
gchar *name,
gint x,
gint y,
GtkSignalFunc update,
gdouble *value,
gdouble min,
gdouble max,
gdouble step)
{
GtkObject *scale_data;
GtkWidget *label, *scale;
label = gtk_label_new (name);
gtk_misc_set_alignment (GTK_MISC(label), 0.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_widget_show (label);
scale_data = gtk_adjustment_new (*value, min, max, step, step, 0.0);
scale = gtk_hscale_new (GTK_ADJUSTMENT (scale_data));
gtk_widget_set_usize (scale, SCALE_WIDTH, 0);
gtk_table_attach (GTK_TABLE (table), scale, x+1, x+2, y, y+1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 10, 5);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
gtk_scale_set_digits (GTK_SCALE (scale), 2);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_signal_connect (GTK_OBJECT (scale_data), "value_changed",
(GtkSignalFunc) update, value);
gtk_widget_show (label);
gtk_widget_show (scale);
}
/* end of vpropagate.c */

115
plug-ins/common/warp.c
View File

@ -90,7 +90,8 @@
#define BLACK 2
#define COLOR 3
typedef struct {
typedef struct
{
gdouble amount;
gint warp_map;
gint iter;
@ -107,7 +108,8 @@ typedef struct {
gdouble vector_angle;
} WarpVals;
typedef struct {
typedef struct
{
GtkWidget *amount;
GtkWidget *angle;
GtkWidget *iter;
@ -140,7 +142,7 @@ static void blur16 (GDrawable *drawable);
static void diff (GDrawable *drawable,
gint32 *xl_id,
gint32 *yl_id );
gint32 *yl_id);
static void diff_prepare_row (GPixelRgn *pixel_rgn,
guchar *data,
@ -154,26 +156,27 @@ static void warp_one (GDrawable *draw,
GDrawable *map_y,
GDrawable *mag_draw,
gint first_time,
gint step );
gint step);
static void warp (GDrawable *drawable,
GDrawable **map_x_p,
GDrawable **map_y_p );
static void warp (GDrawable *drawable,
GDrawable **map_x_p,
GDrawable **map_y_p);
static gint warp_dialog (GDrawable *drawable);
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 bilinear (gdouble x,
gdouble y,
guchar * v);
@ -183,31 +186,31 @@ static gint bilinear16 (gdouble x,
gint * v);
static gint warp_map_constrain (gint32 image_id,
gint32 drawable_id,
gpointer data);
gint32 drawable_id,
gpointer data);
static void warp_map_callback (gint32 id,
gpointer data);
gpointer data);
static void warp_map_mag_callback (gint32 id,
gpointer data);
gpointer data);
static void warp_map_grad_callback (gint32 id,
gpointer data);
gpointer data);
static void warp_map_vector_callback (gint32 id,
gpointer data);
gpointer data);
static void warp_ok_callback (GtkWidget *widget,
gpointer data);
gpointer data);
static void warp_toggle_update (GtkWidget *widget,
gpointer data);
gpointer data);
static void warp_entry_callback (GtkWidget *widget,
gpointer data);
gpointer data);
static void warp_entry_int_callback (GtkWidget *widget,
gpointer data);
static gdouble warp_map_mag_give_value (guchar *pt,
gint alpha,
gint bytes);
/* -------------------------------------------------------------------------------- */
/* Variables global over entire plug-in scope */
/* -------------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* Variables global over entire plug-in scope */
/* -------------------------------------------------------------------------- */
GPlugInInfo PLUG_IN_INFO =
{
@ -253,7 +256,7 @@ static WarpInterface dint =
FALSE, /* run */
};
/* -------------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
gint display_diff_map = TRUE; /* show 16-bit diff. vectormap */
gint progress = 0; /* progress indicator bar */
@ -262,7 +265,7 @@ GRunModeType run_mode; /* interactive, non-, etc. */
guchar color_pixel[4] = {0, 0, 0, 255}; /* current selected foreground color */
/* -------------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/***** Functions *****/
@ -270,7 +273,7 @@ guchar color_pixel[4] = {0, 0, 0, 255}; /* current selected foreground co
MAIN ()
static void
query ()
query (void)
{
static GParamDef args[] =
{
@ -322,10 +325,10 @@ run (gchar *name,
GDrawable *drawable;
GDrawable *map_x = NULL; /* satisfy compiler complaints */
GDrawable *map_y = NULL;
gint32 image_ID; /* image id of drawable */
gint32 image_ID; /* image id of drawable */
GStatusType status = STATUS_SUCCESS;
gint pcnt; /* parameter counter for scanning input params. */
gint pcnt; /* parameter counter for scanning input params. */
run_mode = param[0].data.d_int32;
@ -333,9 +336,9 @@ run (gchar *name,
tile_height = gimp_tile_height();
/* get currently selected foreground pixel color */
gimp_palette_get_foreground (&color_pixel[0], &color_pixel[1], &color_pixel[2]);
gimp_palette_get_foreground (&color_pixel[0],
&color_pixel[1],
&color_pixel[2]);
/* Get the specified drawable */
drawable = gimp_drawable_get (param[2].data.d_drawable);
@ -360,24 +363,26 @@ run (gchar *name,
case RUN_NONINTERACTIVE:
INIT_I18N();
/* Make sure minimum args (mode, image, draw, amount, warp_map, iter) are there */
/* Make sure minimum args
* (mode, image, draw, amount, warp_map, iter) are there
*/
if (nparams < MIN_ARGS)
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
pcnt = MIN_ARGS; /* parameter counter */
dvals.amount = param[3].data.d_float;
dvals.amount = param[3].data.d_float;
dvals.warp_map = param[4].data.d_int32;
dvals.iter = param[5].data.d_int32;
if (nparams > pcnt++) dvals.dither = param[6].data.d_float;
if (nparams > pcnt++) dvals.angle = param[7].data.d_float;
if (nparams > pcnt++) dvals.wrap_type = param[8].data.d_int32;
if (nparams > pcnt++) dvals.mag_map = param[9].data.d_int32;
if (nparams > pcnt++) dvals.mag_use = param[10].data.d_int32;
if (nparams > pcnt++) dvals.substeps = param[11].data.d_int32;
if (nparams > pcnt++) dvals.grad_map = param[12].data.d_int32;
if (nparams > pcnt++) dvals.grad_scale = param[13].data.d_float;
if (nparams > pcnt++) dvals.vector_map = param[14].data.d_int32;
dvals.iter = param[5].data.d_int32;
if (nparams > pcnt++) dvals.dither = param[6].data.d_float;
if (nparams > pcnt++) dvals.angle = param[7].data.d_float;
if (nparams > pcnt++) dvals.wrap_type = param[8].data.d_int32;
if (nparams > pcnt++) dvals.mag_map = param[9].data.d_int32;
if (nparams > pcnt++) dvals.mag_use = param[10].data.d_int32;
if (nparams > pcnt++) dvals.substeps = param[11].data.d_int32;
if (nparams > pcnt++) dvals.grad_map = param[12].data.d_int32;
if (nparams > pcnt++) dvals.grad_scale = param[13].data.d_float;
if (nparams > pcnt++) dvals.vector_map = param[14].data.d_int32;
if (nparams > pcnt++) dvals.vector_scale = param[15].data.d_float;
if (nparams > pcnt++) dvals.vector_angle = param[16].data.d_float;
}
@ -397,8 +402,8 @@ run (gchar *name,
/* set the tile cache size */
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
/* run the warp effect */
warp (drawable, &map_x, &map_y);
/* run the warp effect */
warp (drawable, &map_x, &map_y);
/* Store data */
if (run_mode == RUN_INTERACTIVE)
@ -426,7 +431,7 @@ run (gchar *name,
gimp_drawable_detach (map_y);
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush ();
gimp_displays_flush ();
}
static int
@ -614,7 +619,7 @@ warp_dialog (GDrawable *drawable)
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (3, 3, FALSE);
gtk_container_border_width (GTK_CONTAINER (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);

55
plug-ins/sgi/sgi.c
View File

@ -32,6 +32,38 @@
* Revision History:
*
* $Log$
* Revision 1.18 2000/01/17 17:02:26 mitch
* 2000-01-17 Michael Natterer <mitch@gimp.org>
*
* * libgimp/gimpcolorbutton.c: emit the "color_changed" signal
* whenever the user selects "Use FG/BG Color" from the popup menu.
*
* * libgimp/gimpwidgets.c: gimp_table_attach_aligned(): allow the
* function to be called with label == NULL.
*
* * plug-ins/AlienMap/AlienMap.c
* * plug-ins/AlienMap2/AlienMap2.c
* * plug-ins/common/CEL.c
* * plug-ins/common/CML_explorer.c
* * plug-ins/common/apply_lens.c
* * plug-ins/common/checkerboard.c
* * plug-ins/common/engrave.c
* * plug-ins/common/exchange.c
* * plug-ins/common/gauss_iir.c
* * plug-ins/common/gauss_rle.c
* * plug-ins/common/illusion.c
* * plug-ins/common/max_rgb.c
* * plug-ins/common/mblur.c
* * plug-ins/common/oilify.c
* * plug-ins/common/sel_gauss.c
* * plug-ins/common/shift.c
* * plug-ins/common/smooth_palette.c
* * plug-ins/common/sparkle.c
* * plug-ins/common/video.c
* * plug-ins/common/vpropagate.c
* * plug-ins/common/warp.c
* * plug-ins/sgi/sgi.c: more ui updates.
*
* Revision 1.17 2000/01/13 15:39:25 mitch
* 2000-01-13 Michael Natterer <mitch@gimp.org>
*
@ -278,8 +310,8 @@ static gint save_image (gchar *filename,
gint32 image_ID,
gint32 drawable_ID);
static void init_gtk (void);
static gint save_dialog (void);
static void init_gtk (void);
static gint save_dialog (void);
/*
* Globals...
@ -293,8 +325,8 @@ GPlugInInfo PLUG_IN_INFO =
run, /* run_proc */
};
gint compression = SGI_COMP_RLE;
gint runme = FALSE;
static gint compression = SGI_COMP_RLE;
static gint runme = FALSE;
MAIN ()
@ -302,19 +334,20 @@ MAIN ()
static void
query (void)
{
static GParamDef load_args[] =
static GParamDef load_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_STRING, "filename", "The name of the file to load" },
{ PARAM_STRING, "raw_filename", "The name of the file to load" },
};
static GParamDef load_return_vals[] =
static GParamDef load_return_vals[] =
{
{ PARAM_IMAGE, "image", "Output image" },
};
static int nload_args = sizeof (load_args) / sizeof (load_args[0]);
static int nload_return_vals = sizeof (load_return_vals) / sizeof (load_return_vals[0]);
static GParamDef save_args[] =
static gint nload_args = sizeof (load_args) / sizeof (load_args[0]);
static gint nload_return_vals = (sizeof (load_return_vals) /
sizeof (load_return_vals[0]));
static GParamDef save_args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" },
@ -323,7 +356,7 @@ query (void)
{ PARAM_STRING, "raw_filename", "The name of the file to save the image in" },
{ PARAM_INT32, "compression", "Compression level (0 = none, 1 = RLE, 2 = ARLE)" }
};
static int nsave_args = sizeof (save_args) / sizeof (save_args[0]);
static gint nsave_args = sizeof (save_args) / sizeof (save_args[0]);
INIT_I18N();
@ -357,6 +390,7 @@ query (void)
gimp_register_magic_load_handler ("file_sgi_load", "rgb,bw,sgi,icon",
"", "0,short,474");
gimp_register_save_handler ("file_sgi_save", "rgb,bw,sgi,icon", "");
}
@ -427,6 +461,7 @@ run (gchar *name,
return;
}
break;
default:
break;
}