From fdb4b50f5878b0d9fb66907155fe0b313008e46b Mon Sep 17 00:00:00 2001 From: Manish Singh Date: Tue, 14 Jul 1998 06:15:10 +0000 Subject: [PATCH] check for inline by ourselves if it's not defined in glibconfig.h. So * configure.in: check for inline by ourselves if it's not defined in glibconfig.h. So inline works if glib is compiled with a different compiler than gimp. The plug-ins that use inline #include "config.h" now (blur, destripe, emboss, gfli, nlfilt, ps, randomize, sinus, and zealouscrop) * app/main.c: applied gimp-kc-980707-0; fixes command line parsing * plug-ins/dbbrowser/dbbrowser_utils.c: searching by name does - <-> _ translation * Added filter pack plugin -Yosh --- ChangeLog | 16 + acconfig.h | 3 - app/Makefile.am | 10 +- app/main.c | 11 +- config.h.in | 6 +- configure.in | 16 +- libgimp/gimpprocbrowserdialog.c | 21 +- libgimp/gimpprocview.c | 21 +- plug-ins/Makefile.am | 1 + plug-ins/blur/blur.c | 4 + plug-ins/common/blur.c | 4 + plug-ins/common/destripe.c | 4 + plug-ins/common/emboss.c | 6 +- plug-ins/common/fp.c | 281 +++++++ plug-ins/common/nlfilt.c | 5 +- plug-ins/common/postscript.c | 4 + plug-ins/common/ps.c | 4 + plug-ins/common/randomize.c | 4 +- plug-ins/common/zealouscrop.c | 4 + plug-ins/dbbrowser/dbbrowser_utils.c | 21 +- plug-ins/dbbrowser/gimpprocbrowser.c | 21 +- plug-ins/dbbrowser/gimpprocview.c | 21 +- plug-ins/destripe/destripe.c | 4 + plug-ins/emboss/emboss.c | 6 +- plug-ins/flarefx/Makefile.am | 2 +- plug-ins/fp/.cvsignore | 6 + plug-ins/fp/Makefile.am | 44 + plug-ins/fp/fp.c | 281 +++++++ plug-ins/fp/fp.h | 213 +++++ plug-ins/fp/fp_gdk.c | 162 ++++ plug-ins/fp/fp_gtk.c | 1124 ++++++++++++++++++++++++++ plug-ins/fp/fp_hsv.c | 93 +++ plug-ins/fp/fp_hsv.h | 13 + plug-ins/fp/fp_misc.c | 404 +++++++++ plug-ins/gfli/gfli.c | 4 + plug-ins/nlfilt/nlfilt.c | 5 +- plug-ins/ps/ps.c | 4 + plug-ins/randomize/randomize.c | 4 +- plug-ins/sinus/sinus.c | 5 + plug-ins/zealouscrop/zealouscrop.c | 4 + 40 files changed, 2827 insertions(+), 39 deletions(-) create mode 100644 plug-ins/common/fp.c create mode 100644 plug-ins/fp/.cvsignore create mode 100644 plug-ins/fp/Makefile.am create mode 100644 plug-ins/fp/fp.c create mode 100644 plug-ins/fp/fp.h create mode 100644 plug-ins/fp/fp_gdk.c create mode 100644 plug-ins/fp/fp_gtk.c create mode 100644 plug-ins/fp/fp_hsv.c create mode 100644 plug-ins/fp/fp_hsv.h create mode 100644 plug-ins/fp/fp_misc.c diff --git a/ChangeLog b/ChangeLog index 84f31f459a..f361a5ff52 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,19 @@ +Mon Jul 13 22:49:15 PDT 1998 Manish Singh + + * configure.in: check for inline by ourselves if it's not + defined in glibconfig.h. So inline works if glib is compiled + with a different compiler than gimp. The plug-ins that use + inline #include "config.h" now (blur, destripe, emboss, + gfli, nlfilt, ps, randomize, sinus, and zealouscrop) + + * app/main.c: applied gimp-kc-980707-0; fixes command line + parsing + + * plug-ins/dbbrowser/dbbrowser_utils.c: searching by name does + - <-> _ translation + + * Added filter pack plugin + Mon Jul 13 22:00:31 EDT 1998 Adrian Likins * app/rect_select.c : argh, s/snprintf/g_snprintf diff --git a/acconfig.h b/acconfig.h index c273a47ab2..3eb73f8516 100644 --- a/acconfig.h +++ b/acconfig.h @@ -42,9 +42,6 @@ #undef USE_PTHREADS -/* #undef PACKAGE */ -/* #undef VERSION */ - /* Leave that blank line there!! Autoheader needs it. If you're adding to this file, keep in mind: diff --git a/app/Makefile.am b/app/Makefile.am index d980d76143..fdc540eaad 100644 --- a/app/Makefile.am +++ b/app/Makefile.am @@ -89,6 +89,10 @@ gimp_SOURCES = \ dialog_types.h \ disp_callbacks.c \ disp_callbacks.h \ + docindex.c \ + docindex.h \ + docindexif.c \ + docindexif.h \ draw_core.c \ draw_core.h \ drawable.c \ @@ -290,11 +294,7 @@ gimp_SOURCES = \ undo_cmds.h \ wilber.h \ xcf.c \ - xcf.h \ - docindex.c \ - docindex.h \ - docindexif.c \ - docindexif.h + xcf.h EXTRA_DIST = \ tools/channel.xbm \ diff --git a/app/main.c b/app/main.c index f7213633b0..1f61236bcc 100644 --- a/app/main.c +++ b/app/main.c @@ -134,18 +134,17 @@ main (int argc, char **argv) (strcmp (argv[i], "-n") == 0)) { no_interface = TRUE; - argv[i] = NULL; } else if ((strcmp (argv[i], "--batch") == 0) || (strcmp (argv[i], "-b") == 0)) { - argv[i] = NULL; - for (j = 0, i++ ; i < argc; j++, i++) - { + for (j = 0, i++ ; i < argc && argv[i][0] != '-'; j++, i++) batch_cmds[j] = argv[i]; - argv[i] = NULL; - } batch_cmds[j] = NULL; + if (batch_cmds[0] == NULL) /* We need at least one batch command */ + show_help = TRUE; + if (argv[i-1][0] != '-') /* Did loop end due to a new argument? */ + --i; /* Ensure new argument gets processed */ } else if (strcmp (argv[i], "--system-gimprc") == 0) { diff --git a/config.h.in b/config.h.in index 24b936cfbb..789b7b7edb 100644 --- a/config.h.in +++ b/config.h.in @@ -25,6 +25,9 @@ /* Define if you have the vprintf function. */ #undef HAVE_VPRINTF +/* Define as __inline if that's what the C compiler calls it. */ +#undef inline + /* Define to `int' if doesn't define. */ #undef pid_t @@ -74,9 +77,6 @@ #undef USE_PTHREADS -/* #undef PACKAGE */ -/* #undef VERSION */ - /* Define if you have the header file. */ #undef HAVE_DIRENT_H diff --git a/configure.in b/configure.in index 6b4f50a601..3fb0a1bcee 100644 --- a/configure.in +++ b/configure.in @@ -303,6 +303,19 @@ AC_CHECK_FUNC(random, [ dnl check for difftime AC_CHECK_FUNC(difftime, , AC_DEFINE(NO_DIFFTIME)) +dnl check for inline +AC_MSG_CHECKING([for inline definition in glibconfig.h]) +AC_EGREP_CPP(glib_defines_inline, +[#include +#ifdef inline + glib_defines_inline +#endif +], have_glib_inline=yes, have_glib_inline=no) +AC_MSG_RESULT($have_glib_inline) +if test "$have_glib_inline" = "no"; then + AC_C_INLINE +fi + dnl Threads AC_ARG_WITH(threads, [ --with-threads=[posix] support threading ]) THREAD_LIBS= @@ -312,7 +325,6 @@ if test "x$with_threads" = "xposix" || test "x$with_threads" = "xyes"; then CFLAGS="$CFLAGS -D_REENTRANT" THREAD_LIBS="-lpthread") fi -AC_SUBST(THREAD_LIBS) CPPFLAGS="$gimp_save_CPPFLAGS" LDFLAGS="$gimp_save_LDFLAGS" @@ -439,6 +451,7 @@ AC_SUBST(LPSTAT_DEF) AC_SUBST(LPR_DEF) AC_SUBST(LPC_DEF) AC_SUBST(MAILER) +AC_SUBST(THREAD_LIBS) dnl Output the Makefiles @@ -502,6 +515,7 @@ plug-ins/film/Makefile plug-ins/fits/Makefile plug-ins/flame/Makefile plug-ins/flarefx/Makefile +plug-ins/fp/Makefile plug-ins/fractaltrace/Makefile plug-ins/gauss_iir/Makefile plug-ins/gauss_rle/Makefile diff --git a/libgimp/gimpprocbrowserdialog.c b/libgimp/gimpprocbrowserdialog.c index ba85d89726..2c96e3d7f3 100644 --- a/libgimp/gimpprocbrowserdialog.c +++ b/libgimp/gimpprocbrowserdialog.c @@ -502,7 +502,8 @@ dialog_search_callback (GtkWidget *widget, int num_procs; int i, j; dbbrowser_t* dbbrowser = data; - gchar *func_name, *label; + gchar *func_name, *label, *query_text; + GString *query; gtk_clist_freeze(GTK_CLIST(dbbrowser->clist)); gtk_clist_clear(GTK_CLIST(dbbrowser->clist)); @@ -513,9 +514,25 @@ dialog_search_callback (GtkWidget *widget, { gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), "DB Browser (by name - please wait)"); - gimp_query_database (gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ), + + query = g_string_new (""); + query_text = gtk_entry_get_text(GTK_ENTRY(dbbrowser->search_entry)); + + while (*query_text) + { + if ((*query_text == '_') || (*query_text == '-')) + g_string_append (query, "[-_]"); + else + g_string_append_c (query, *query_text); + + query_text++; + } + + gimp_query_database (query->str, ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list); + + g_string_free (query, TRUE); } else if ( widget == (dbbrowser->blurb_button) ) { diff --git a/libgimp/gimpprocview.c b/libgimp/gimpprocview.c index ba85d89726..2c96e3d7f3 100644 --- a/libgimp/gimpprocview.c +++ b/libgimp/gimpprocview.c @@ -502,7 +502,8 @@ dialog_search_callback (GtkWidget *widget, int num_procs; int i, j; dbbrowser_t* dbbrowser = data; - gchar *func_name, *label; + gchar *func_name, *label, *query_text; + GString *query; gtk_clist_freeze(GTK_CLIST(dbbrowser->clist)); gtk_clist_clear(GTK_CLIST(dbbrowser->clist)); @@ -513,9 +514,25 @@ dialog_search_callback (GtkWidget *widget, { gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), "DB Browser (by name - please wait)"); - gimp_query_database (gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ), + + query = g_string_new (""); + query_text = gtk_entry_get_text(GTK_ENTRY(dbbrowser->search_entry)); + + while (*query_text) + { + if ((*query_text == '_') || (*query_text == '-')) + g_string_append (query, "[-_]"); + else + g_string_append_c (query, *query_text); + + query_text++; + } + + gimp_query_database (query->str, ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list); + + g_string_free (query, TRUE); } else if ( widget == (dbbrowser->blurb_button) ) { diff --git a/plug-ins/Makefile.am b/plug-ins/Makefile.am index b0fc74fe54..160c6738ef 100644 --- a/plug-ins/Makefile.am +++ b/plug-ins/Makefile.am @@ -52,6 +52,7 @@ SUBDIRS = \ fits \ flame \ flarefx \ + fp \ fractaltrace \ gauss_iir \ gauss_rle \ diff --git a/plug-ins/blur/blur.c b/plug-ins/blur/blur.c index fb409fb819..492fbf6a40 100644 --- a/plug-ins/blur/blur.c +++ b/plug-ins/blur/blur.c @@ -58,6 +58,10 @@ #include "gtk/gtk.h" #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + /********************************* * * PLUGIN-SPECIFIC CONSTANTS diff --git a/plug-ins/common/blur.c b/plug-ins/common/blur.c index fb409fb819..492fbf6a40 100644 --- a/plug-ins/common/blur.c +++ b/plug-ins/common/blur.c @@ -58,6 +58,10 @@ #include "gtk/gtk.h" #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + /********************************* * * PLUGIN-SPECIFIC CONSTANTS diff --git a/plug-ins/common/destripe.c b/plug-ins/common/destripe.c index 5bd1a08559..19c835dea8 100644 --- a/plug-ins/common/destripe.c +++ b/plug-ins/common/destripe.c @@ -50,6 +50,10 @@ #include #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + /* * Constants... */ diff --git a/plug-ins/common/emboss.c b/plug-ins/common/emboss.c index c88f9b452d..c816b4106f 100644 --- a/plug-ins/common/emboss.c +++ b/plug-ins/common/emboss.c @@ -33,11 +33,13 @@ #include #include - #include - #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #ifndef M_PI #define M_PI 3.14159265358979323846 #endif /* M_PI */ diff --git a/plug-ins/common/fp.c b/plug-ins/common/fp.c new file mode 100644 index 0000000000..c4ff14b014 --- /dev/null +++ b/plug-ins/common/fp.c @@ -0,0 +1,281 @@ +#include +#include +#include "gtk/gtk.h" +#include "libgimp/gimp.h" +#include "fp.h" +#include "fp_hsv.h" + +FP_Params Current = +{ + 1, + .25, /* Initial Roughness */ + NULL, + .6, /* Initial Degree of Aliasing */ + NULL, + 80, + NULL, + MIDTONES, /* Initial Range */ + BY_VAL, /* Initial God knows what */ + TRUE, /* Selection Only */ + TRUE, /* Real Time */ + 0, /* Offset */ + 0, + {32,224,255}, + {0,0,0} +}; + +GDrawable *drawable, *mask; + +void query (void); +void run (char *name, + int nparams, + GParam *param, + int *nreturn_vals, + GParam **return_vals); + +GPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + +MAIN() + + +void +query () +{ + GParamDef args[] = + { + { PARAM_INT32, "run_mode", "Interactive, non-interactive" }, + { PARAM_IMAGE, "image", "Input image (used for indexed images)" }, + { PARAM_DRAWABLE, "drawable", "Input drawable" }, + }; + GParamDef *return_vals = NULL; + int nargs = sizeof (args) / sizeof (args[0]); + int nreturn_vals = 0; + + gimp_install_procedure ("Filter Pack Simulation", + "Allows the user to change H, S, or C with many previews", + "Then something else here", + "Pavel Grinfeld (pavel@ml.com)", + "Pavel Grinfeld (pavel@ml.com)", + "27th March 1997", + "/Filters/Darkroom/Filter Pack", + "RGB*,INDEXED*,GRAY*", + PROC_PLUG_IN, + nargs, nreturn_vals, + args, return_vals); +} + +/********************************STANDARD RUN*************************/ +void +run (char *name, + int nparams, + GParam *param, + int *nreturn_vals, + GParam **return_vals) +{ + GParam values[1]; + GStatusType status = STATUS_SUCCESS; + + *nreturn_vals = 1; + *return_vals = values; + + values[0].type = PARAM_STATUS; + values[0].data.d_status = status; + + initializeFilterPacks(); + + drawable = gimp_drawable_get (param[2].data.d_drawable); + mask=gimp_drawable_get(gimp_image_get_selection(param[1].data.d_image)); + + if (gimp_drawable_indexed (drawable->id) ||gimp_drawable_gray (drawable->id) ) { + ErrorMessage("Convert the image to RGB first!"); + status = STATUS_EXECUTION_ERROR; + } + + else if (gimp_drawable_color (drawable->id) && fp_dialog()) + { + gimp_progress_init ("Applying the Filter Pack..."); + gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1)); + fp (drawable); + gimp_displays_flush (); + } + else status = STATUS_EXECUTION_ERROR; + + + values[0].data.d_status = status; + if (status==STATUS_SUCCESS) + gimp_drawable_detach (drawable); +} + + +void +fp_row (const guchar *src_row, + guchar *dest_row, + gint row, + gint row_width, + gint bytes) +{ + gint col, bytenum, k; + int JudgeBy, Intensity=0, P[3], backupP[3]; + hsv H,S,V; + gint M, m, middle; + + for (col = 0; col < row_width ; col++) + { + + backupP[0] = P[0] = src_row[col*bytes+0]; + backupP[0] = P[1] = src_row[col*bytes+1]; + backupP[0] = P[2] = src_row[col*bytes+2]; + + + rgb_to_hsv(P[0]/255.0, P[1]/255.0, P[2]/255.0, &H, &S, &V); + + for (JudgeBy=BY_HUE; JudgeBy3) + for (bytenum = 3; bytenumid, &x1, &y1, &x2, &y2); + + width = drawable->width; + height = drawable->height; + bytes = drawable->bpp; + + src_row = (guchar *) malloc ((x2 - x1) * bytes); + dest_row = (guchar *) malloc ((x2 - x1) * bytes); + + gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE); + gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height, TRUE, TRUE); + + for (row = y1; row < y2; row++) + { + gimp_pixel_rgn_get_row (&srcPR, src_row, x1, row, (x2 - x1)); + + fp_row (src_row, + dest_row, + row, + (x2 - x1), + bytes + ); + + gimp_pixel_rgn_set_row (&destPR, dest_row, x1, row, (x2 - x1)); + + if ((row % 10) == 0) + gimp_progress_update ((double) row / (double) (y2 - y1)); + } + + + /* update the processed region */ + + gimp_drawable_flush (drawable); + gimp_drawable_merge_shadow (drawable->id, TRUE); + gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1)); + + free (src_row); + free (dest_row); + +} + + +void +ErrorMessage(guchar *message) +{ + GtkWidget *window, *label, *button,*table; + gchar **argv=g_new (gchar *, 1); + gint argc=1; + argv[0] = g_strdup ("fp"); + gtk_init (&argc, &argv); + gtk_rc_parse (gimp_gtkrc()); + + window=gtk_dialog_new(); + gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); + gtk_window_set_title(GTK_WINDOW(window),"Filter Pack Simulation Message"); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + (GtkSignalFunc) fp_close_callback, + NULL); + + button = gtk_button_new_with_label ("Got It!"); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) fp_ok_callback, + window); + gtk_widget_grab_default (button); + gtk_widget_show (button); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); + + table=gtk_table_new(2,2,FALSE); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),table,TRUE,TRUE,0); + gtk_widget_show(table); + + label=gtk_label_new(""); + gtk_label_set(GTK_LABEL(label),message); + gtk_widget_show(label); + gtk_table_attach(GTK_TABLE(table),label,0,1,0,1, + GTK_FILL|GTK_EXPAND,GTK_FILL|GTK_EXPAND,15,15); + + gtk_widget_show(window); + gtk_main (); + +} diff --git a/plug-ins/common/nlfilt.c b/plug-ins/common/nlfilt.c index 8a262840cf..f1bf7d9059 100644 --- a/plug-ins/common/nlfilt.c +++ b/plug-ins/common/nlfilt.c @@ -34,10 +34,13 @@ #include #include - #include #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + static mw_preview_t nlfilt_do_preview; struct Grgb { diff --git a/plug-ins/common/postscript.c b/plug-ins/common/postscript.c index 3a407dc714..079008e841 100644 --- a/plug-ins/common/postscript.c +++ b/plug-ins/common/postscript.c @@ -50,6 +50,10 @@ static char ident[] = "@(#) GIMP PostScript/PDF file-plugin v1.04 20-Dec-97"; #include "gtk/gtk.h" #include "libgimp/gimp.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #define STR_LENGTH 64 /* Load info */ diff --git a/plug-ins/common/ps.c b/plug-ins/common/ps.c index 3a407dc714..079008e841 100644 --- a/plug-ins/common/ps.c +++ b/plug-ins/common/ps.c @@ -50,6 +50,10 @@ static char ident[] = "@(#) GIMP PostScript/PDF file-plugin v1.04 20-Dec-97"; #include "gtk/gtk.h" #include "libgimp/gimp.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #define STR_LENGTH 64 /* Load info */ diff --git a/plug-ins/common/randomize.c b/plug-ins/common/randomize.c index f0fe99f6e1..f4c35bffee 100644 --- a/plug-ins/common/randomize.c +++ b/plug-ins/common/randomize.c @@ -74,8 +74,8 @@ #include "gtk/gtk.h" #include -#if ! defined(__GNUC__) -# define inline +#ifdef HAVE_CONFIG_H +#include "config.h" #endif /********************************* diff --git a/plug-ins/common/zealouscrop.c b/plug-ins/common/zealouscrop.c index 8ab9318aba..29aa6232aa 100644 --- a/plug-ins/common/zealouscrop.c +++ b/plug-ins/common/zealouscrop.c @@ -16,6 +16,10 @@ #include "libgimp/gimp.h" #include "gtk/gtk.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + /* Declare local functions. */ static void query(void); static void run(char *name, diff --git a/plug-ins/dbbrowser/dbbrowser_utils.c b/plug-ins/dbbrowser/dbbrowser_utils.c index ba85d89726..2c96e3d7f3 100644 --- a/plug-ins/dbbrowser/dbbrowser_utils.c +++ b/plug-ins/dbbrowser/dbbrowser_utils.c @@ -502,7 +502,8 @@ dialog_search_callback (GtkWidget *widget, int num_procs; int i, j; dbbrowser_t* dbbrowser = data; - gchar *func_name, *label; + gchar *func_name, *label, *query_text; + GString *query; gtk_clist_freeze(GTK_CLIST(dbbrowser->clist)); gtk_clist_clear(GTK_CLIST(dbbrowser->clist)); @@ -513,9 +514,25 @@ dialog_search_callback (GtkWidget *widget, { gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), "DB Browser (by name - please wait)"); - gimp_query_database (gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ), + + query = g_string_new (""); + query_text = gtk_entry_get_text(GTK_ENTRY(dbbrowser->search_entry)); + + while (*query_text) + { + if ((*query_text == '_') || (*query_text == '-')) + g_string_append (query, "[-_]"); + else + g_string_append_c (query, *query_text); + + query_text++; + } + + gimp_query_database (query->str, ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list); + + g_string_free (query, TRUE); } else if ( widget == (dbbrowser->blurb_button) ) { diff --git a/plug-ins/dbbrowser/gimpprocbrowser.c b/plug-ins/dbbrowser/gimpprocbrowser.c index ba85d89726..2c96e3d7f3 100644 --- a/plug-ins/dbbrowser/gimpprocbrowser.c +++ b/plug-ins/dbbrowser/gimpprocbrowser.c @@ -502,7 +502,8 @@ dialog_search_callback (GtkWidget *widget, int num_procs; int i, j; dbbrowser_t* dbbrowser = data; - gchar *func_name, *label; + gchar *func_name, *label, *query_text; + GString *query; gtk_clist_freeze(GTK_CLIST(dbbrowser->clist)); gtk_clist_clear(GTK_CLIST(dbbrowser->clist)); @@ -513,9 +514,25 @@ dialog_search_callback (GtkWidget *widget, { gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), "DB Browser (by name - please wait)"); - gimp_query_database (gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ), + + query = g_string_new (""); + query_text = gtk_entry_get_text(GTK_ENTRY(dbbrowser->search_entry)); + + while (*query_text) + { + if ((*query_text == '_') || (*query_text == '-')) + g_string_append (query, "[-_]"); + else + g_string_append_c (query, *query_text); + + query_text++; + } + + gimp_query_database (query->str, ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list); + + g_string_free (query, TRUE); } else if ( widget == (dbbrowser->blurb_button) ) { diff --git a/plug-ins/dbbrowser/gimpprocview.c b/plug-ins/dbbrowser/gimpprocview.c index ba85d89726..2c96e3d7f3 100644 --- a/plug-ins/dbbrowser/gimpprocview.c +++ b/plug-ins/dbbrowser/gimpprocview.c @@ -502,7 +502,8 @@ dialog_search_callback (GtkWidget *widget, int num_procs; int i, j; dbbrowser_t* dbbrowser = data; - gchar *func_name, *label; + gchar *func_name, *label, *query_text; + GString *query; gtk_clist_freeze(GTK_CLIST(dbbrowser->clist)); gtk_clist_clear(GTK_CLIST(dbbrowser->clist)); @@ -513,9 +514,25 @@ dialog_search_callback (GtkWidget *widget, { gtk_window_set_title (GTK_WINDOW (dbbrowser->dlg), "DB Browser (by name - please wait)"); - gimp_query_database (gtk_entry_get_text( GTK_ENTRY(dbbrowser->search_entry) ), + + query = g_string_new (""); + query_text = gtk_entry_get_text(GTK_ENTRY(dbbrowser->search_entry)); + + while (*query_text) + { + if ((*query_text == '_') || (*query_text == '-')) + g_string_append (query, "[-_]"); + else + g_string_append_c (query, *query_text); + + query_text++; + } + + gimp_query_database (query->str, ".*", ".*", ".*", ".*", ".*", ".*", &num_procs, &proc_list); + + g_string_free (query, TRUE); } else if ( widget == (dbbrowser->blurb_button) ) { diff --git a/plug-ins/destripe/destripe.c b/plug-ins/destripe/destripe.c index 5bd1a08559..19c835dea8 100644 --- a/plug-ins/destripe/destripe.c +++ b/plug-ins/destripe/destripe.c @@ -50,6 +50,10 @@ #include #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + /* * Constants... */ diff --git a/plug-ins/emboss/emboss.c b/plug-ins/emboss/emboss.c index c88f9b452d..c816b4106f 100644 --- a/plug-ins/emboss/emboss.c +++ b/plug-ins/emboss/emboss.c @@ -33,11 +33,13 @@ #include #include - #include - #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #ifndef M_PI #define M_PI 3.14159265358979323846 #endif /* M_PI */ diff --git a/plug-ins/flarefx/Makefile.am b/plug-ins/flarefx/Makefile.am index 445d2ff2a4..f3d2ac4cb6 100644 --- a/plug-ins/flarefx/Makefile.am +++ b/plug-ins/flarefx/Makefile.am @@ -5,7 +5,7 @@ pluginlibdir = $(gimpplugindir)/plug-ins pluginlib_PROGRAMS = flarefx flarefx_SOURCES = \ - flarefx.c + flarefx.c INCLUDES = \ -I$(top_srcdir) \ diff --git a/plug-ins/fp/.cvsignore b/plug-ins/fp/.cvsignore new file mode 100644 index 0000000000..d8e717143b --- /dev/null +++ b/plug-ins/fp/.cvsignore @@ -0,0 +1,6 @@ +Makefile.in +Makefile +.deps +_libs +.libs +fp diff --git a/plug-ins/fp/Makefile.am b/plug-ins/fp/Makefile.am new file mode 100644 index 0000000000..c6760a27f5 --- /dev/null +++ b/plug-ins/fp/Makefile.am @@ -0,0 +1,44 @@ +## Process this file with automake to produce Makefile.in + +pluginlibdir = $(gimpplugindir)/plug-ins + +pluginlib_PROGRAMS = fp + +fp_SOURCES = \ + fp.c \ + fp.h \ + fp_gdk.c \ + fp_gtk.c \ + fp_hsv.c \ + fp_hsv.h \ + fp_misc.c + +INCLUDES = \ + -I$(top_srcdir) \ + $(GTK_CFLAGS) \ + -I$(includedir) + +LDADD = \ + $(top_builddir)/libgimp/libgimpui-@LT_RELEASE@.la \ + $(top_builddir)/libgimp/libgimp-@LT_RELEASE@.la \ + $(GTK_LIBS) \ + -lc + +DEPS = \ + $(top_builddir)/libgimp/libgimpui-@LT_RELEASE@.la \ + $(top_builddir)/libgimp/libgimp-@LT_RELEASE@.la + +fp_DEPENDENCIES = $(DEPS) + +.PHONY: files + +files: + @files=`ls $(DISTFILES) 2> /dev/null`; for p in $$files; do \ + echo $$p; \ + done + @for subdir in $(SUBDIRS); do \ + files=`cd $$subdir; $(MAKE) files | grep -v "make\[[1-9]\]"`; \ + for file in $$files; do \ + echo $$subdir/$$file; \ + done; \ + done diff --git a/plug-ins/fp/fp.c b/plug-ins/fp/fp.c new file mode 100644 index 0000000000..c4ff14b014 --- /dev/null +++ b/plug-ins/fp/fp.c @@ -0,0 +1,281 @@ +#include +#include +#include "gtk/gtk.h" +#include "libgimp/gimp.h" +#include "fp.h" +#include "fp_hsv.h" + +FP_Params Current = +{ + 1, + .25, /* Initial Roughness */ + NULL, + .6, /* Initial Degree of Aliasing */ + NULL, + 80, + NULL, + MIDTONES, /* Initial Range */ + BY_VAL, /* Initial God knows what */ + TRUE, /* Selection Only */ + TRUE, /* Real Time */ + 0, /* Offset */ + 0, + {32,224,255}, + {0,0,0} +}; + +GDrawable *drawable, *mask; + +void query (void); +void run (char *name, + int nparams, + GParam *param, + int *nreturn_vals, + GParam **return_vals); + +GPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run, /* run_proc */ +}; + +MAIN() + + +void +query () +{ + GParamDef args[] = + { + { PARAM_INT32, "run_mode", "Interactive, non-interactive" }, + { PARAM_IMAGE, "image", "Input image (used for indexed images)" }, + { PARAM_DRAWABLE, "drawable", "Input drawable" }, + }; + GParamDef *return_vals = NULL; + int nargs = sizeof (args) / sizeof (args[0]); + int nreturn_vals = 0; + + gimp_install_procedure ("Filter Pack Simulation", + "Allows the user to change H, S, or C with many previews", + "Then something else here", + "Pavel Grinfeld (pavel@ml.com)", + "Pavel Grinfeld (pavel@ml.com)", + "27th March 1997", + "/Filters/Darkroom/Filter Pack", + "RGB*,INDEXED*,GRAY*", + PROC_PLUG_IN, + nargs, nreturn_vals, + args, return_vals); +} + +/********************************STANDARD RUN*************************/ +void +run (char *name, + int nparams, + GParam *param, + int *nreturn_vals, + GParam **return_vals) +{ + GParam values[1]; + GStatusType status = STATUS_SUCCESS; + + *nreturn_vals = 1; + *return_vals = values; + + values[0].type = PARAM_STATUS; + values[0].data.d_status = status; + + initializeFilterPacks(); + + drawable = gimp_drawable_get (param[2].data.d_drawable); + mask=gimp_drawable_get(gimp_image_get_selection(param[1].data.d_image)); + + if (gimp_drawable_indexed (drawable->id) ||gimp_drawable_gray (drawable->id) ) { + ErrorMessage("Convert the image to RGB first!"); + status = STATUS_EXECUTION_ERROR; + } + + else if (gimp_drawable_color (drawable->id) && fp_dialog()) + { + gimp_progress_init ("Applying the Filter Pack..."); + gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1)); + fp (drawable); + gimp_displays_flush (); + } + else status = STATUS_EXECUTION_ERROR; + + + values[0].data.d_status = status; + if (status==STATUS_SUCCESS) + gimp_drawable_detach (drawable); +} + + +void +fp_row (const guchar *src_row, + guchar *dest_row, + gint row, + gint row_width, + gint bytes) +{ + gint col, bytenum, k; + int JudgeBy, Intensity=0, P[3], backupP[3]; + hsv H,S,V; + gint M, m, middle; + + for (col = 0; col < row_width ; col++) + { + + backupP[0] = P[0] = src_row[col*bytes+0]; + backupP[0] = P[1] = src_row[col*bytes+1]; + backupP[0] = P[2] = src_row[col*bytes+2]; + + + rgb_to_hsv(P[0]/255.0, P[1]/255.0, P[2]/255.0, &H, &S, &V); + + for (JudgeBy=BY_HUE; JudgeBy3) + for (bytenum = 3; bytenumid, &x1, &y1, &x2, &y2); + + width = drawable->width; + height = drawable->height; + bytes = drawable->bpp; + + src_row = (guchar *) malloc ((x2 - x1) * bytes); + dest_row = (guchar *) malloc ((x2 - x1) * bytes); + + gimp_pixel_rgn_init (&srcPR, drawable, 0, 0, width, height, FALSE, FALSE); + gimp_pixel_rgn_init (&destPR, drawable, 0, 0, width, height, TRUE, TRUE); + + for (row = y1; row < y2; row++) + { + gimp_pixel_rgn_get_row (&srcPR, src_row, x1, row, (x2 - x1)); + + fp_row (src_row, + dest_row, + row, + (x2 - x1), + bytes + ); + + gimp_pixel_rgn_set_row (&destPR, dest_row, x1, row, (x2 - x1)); + + if ((row % 10) == 0) + gimp_progress_update ((double) row / (double) (y2 - y1)); + } + + + /* update the processed region */ + + gimp_drawable_flush (drawable); + gimp_drawable_merge_shadow (drawable->id, TRUE); + gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1)); + + free (src_row); + free (dest_row); + +} + + +void +ErrorMessage(guchar *message) +{ + GtkWidget *window, *label, *button,*table; + gchar **argv=g_new (gchar *, 1); + gint argc=1; + argv[0] = g_strdup ("fp"); + gtk_init (&argc, &argv); + gtk_rc_parse (gimp_gtkrc()); + + window=gtk_dialog_new(); + gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE); + gtk_window_set_title(GTK_WINDOW(window),"Filter Pack Simulation Message"); + gtk_signal_connect (GTK_OBJECT (window), "destroy", + (GtkSignalFunc) fp_close_callback, + NULL); + + button = gtk_button_new_with_label ("Got It!"); + GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) fp_ok_callback, + window); + gtk_widget_grab_default (button); + gtk_widget_show (button); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0); + + table=gtk_table_new(2,2,FALSE); + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),table,TRUE,TRUE,0); + gtk_widget_show(table); + + label=gtk_label_new(""); + gtk_label_set(GTK_LABEL(label),message); + gtk_widget_show(label); + gtk_table_attach(GTK_TABLE(table),label,0,1,0,1, + GTK_FILL|GTK_EXPAND,GTK_FILL|GTK_EXPAND,15,15); + + gtk_widget_show(window); + gtk_main (); + +} diff --git a/plug-ins/fp/fp.h b/plug-ins/fp/fp.h new file mode 100644 index 0000000000..ba5f5c4b13 --- /dev/null +++ b/plug-ins/fp/fp.h @@ -0,0 +1,213 @@ +#define MAX_PREVIEW_SIZE 125 +#define MAX_ROUGHNESS 128 +#define RANGE_HEIGHT 15 +#define PR_BX_BRDR 10 +#define ALL 255 +#define MARGIN 5 + +#define RANGE_ADJUST_MASK GDK_EXPOSURE_MASK | \ + GDK_ENTER_NOTIFY_MASK | \ + GDK_BUTTON_PRESS_MASK | \ + GDK_BUTTON_RELEASE_MASK | \ + GDK_BUTTON1_MOTION_MASK | \ + GDK_POINTER_MOTION_HINT_MASK + + +typedef struct { + gint run; +} fpInterface; + +typedef double hsv; + +typedef struct { + gint width; + gint height; + guchar *rgb; + hsv *hsv; + guchar *mask; +} ReducedImage; + +typedef enum { + SHADOWS, + MIDTONES, + HIGHLIGHTS, + INTENSITIES +}FP_Intensity; + +enum { + NONEATALL =0, + CURRENT =1, + HUE =2, + SATURATION =4, + VALUE =8 +}; + + +enum { + RED, + GREEN, + BLUE, + CYAN, + YELLOW, + MAGENTA, + ALL_PRIMARY +}; + +enum { + DOWN = -1, + UP = 1 +}; + +enum { + BY_HUE, + BY_SAT, + BY_VAL, + JUDGE_BY +}; + + +typedef struct { + GtkWidget *window; + GtkWidget *shadowsEntry; + GtkWidget *midtonesEntry; + GtkWidget *rangePreview; + GtkWidget *aliasingPreview; + GtkObject *aliasingData; + GtkWidget *aliasingGraph; +} AdvancedWindow; + + +typedef struct { + int Color; + float Rough; + GtkWidget *roughnessScale; + float Alias; + GtkWidget *aliasingScale; + float PreviewSize; + GtkWidget *previewSizeScale; + FP_Intensity Range; + gint ValueBy; + gint SlctnOnly; + gint RealTime; + guchar Offset; + guchar VisibleFrames; + guchar Cutoffs[INTENSITIES]; + gint Touched[JUDGE_BY]; + gint redAdj[JUDGE_BY][256]; + gint blueAdj[JUDGE_BY][256]; + gint greenAdj[JUDGE_BY][256]; + gint satAdj[JUDGE_BY][256]; + GtkWidget *rangeLabels[12]; +}FP_Params; + +GtkWidget *fp_create_bna(void); +GtkWidget *fp_create_rough(void); +GtkWidget *fp_create_range(void); +GtkWidget *fp_create_circle_palette(void); +GtkWidget *fp_create_lnd(void); +GtkWidget *fp_create_show(void); +GtkWidget *fp_create_msnls(); +GtkWidget *fp_create_frame_select(); +GtkWidget *fp_create_pixels_select_by(); + +void fp_show_hide_frame(GtkWidget *button, + GtkWidget *frame); + +ReducedImage *Reduce_The_Image (GDrawable *, + GDrawable *, + gint, + gint); + +void fp_render_preview (GtkWidget *, + gint, + gint ); + +void Update_Current_FP (gint, + gint ); + +void fp_Create_Nudge (gint* ); + +gint fp_dialog (void); +gint fp_advanced_dialog (void); + +void fp_advanced_call (void); + +void fp_entire_image (GtkWidget *, + gpointer ); +void fp_selection_only (GtkWidget *, + gpointer ); + +void fp_selection_in_context (GtkWidget *, + gpointer ); + +void selectionMade (GtkWidget *, + gpointer ); +void fp_close_callback (GtkWidget *, + gpointer ); +void fp_ok_callback (GtkWidget *, + gpointer ); +void fp_scale_update (GtkAdjustment *, + float* ); +void fp_change_current_range (GtkAdjustment*, + gint* ); +void fp_change_current_pixels_by (GtkWidget *, + gint *); +void resetFilterPacks (void); + +void update_range_labels (void); + +void fp_create_smoothness_graph (GtkWidget* ); + +void fp_range_preview_spill (GtkWidget*, + gint ); + +void Create_A_Preview (GtkWidget **, + GtkWidget **, + int, + int ); + +void Create_A_Table_Entry (GtkWidget **, + GtkWidget *, + char *); + +GSList* Button_In_A_Box (GtkWidget *, + GSList *, + guchar *, + GtkSignalFunc, + gpointer, + int ); + +void Check_Button_In_A_Box (GtkWidget *, + guchar *label, + GtkSignalFunc func, + gpointer data, + int clicked); + +void Adjust_Preview_Sizes (int width, + int height ); +void refreshPreviews (int); +void initializeFilterPacks (void); + +void fp (GDrawable *drawable); +void fp_row (const guchar *src_row, + guchar *dest_row, + gint row, + gint row_width, + gint bytes); + +void draw_slider (GdkWindow *window, + GdkGC *border_gc, + GdkGC *fill_gc, + int xpos); +gint FP_Range_Change_Events (GtkWidget *, + GdkEvent *, + FP_Params *); + +void As_You_Drag (GtkWidget *button); +void preview_size_scale_update (GtkAdjustment *adjustment, + float *scale_val); +void ErrorMessage (guchar *); + + +void fp_advanced_ok(); +gint fp_fake_transparency(gint i, gint j); diff --git a/plug-ins/fp/fp_gdk.c b/plug-ins/fp/fp_gdk.c new file mode 100644 index 0000000000..e10b13f26b --- /dev/null +++ b/plug-ins/fp/fp_gdk.c @@ -0,0 +1,162 @@ +#include +#include +#include +#include "gtk/gtk.h" +#include "libgimp/gimp.h" +#include "fp.h" +#include "fp_hsv.h" + +extern AdvancedWindow AW; +extern FP_Params Current; + + +extern gint nudgeArray[256]; + + +void +slider_erase (GdkWindow *window, + int xpos) +{ + gdk_window_clear_area (window, MARGIN + xpos - (RANGE_HEIGHT - 1) / 2, 0, + RANGE_HEIGHT, RANGE_HEIGHT); +} + +void +draw_slider(GdkWindow *window, + GdkGC *border_gc, + GdkGC *fill_gc, + int xpos) +{ + int i; + for (i = 0; i < RANGE_HEIGHT; i++) + gdk_draw_line(window, fill_gc, MARGIN + xpos-i/2, i, MARGIN + xpos+i/2,i); + + gdk_draw_line(window, border_gc, MARGIN + xpos, 0, + MARGIN + xpos - (RANGE_HEIGHT - 1) / 2, RANGE_HEIGHT - 1); + + gdk_draw_line(window, border_gc, MARGIN + xpos, 0, + MARGIN + xpos + (RANGE_HEIGHT - 1) / 2, RANGE_HEIGHT - 1); + + gdk_draw_line(window, border_gc, MARGIN + xpos-(RANGE_HEIGHT-1)/2,RANGE_HEIGHT-1, + MARGIN + xpos + (RANGE_HEIGHT-1)/2, RANGE_HEIGHT-1); +} + + +void +draw_it(GtkWidget *widget) +{ + draw_slider(AW.aliasingGraph->window, + AW.aliasingGraph->style->black_gc, + AW.aliasingGraph->style->dark_gc[GTK_STATE_NORMAL], + Current.Cutoffs[SHADOWS]); + + draw_slider(AW.aliasingGraph->window, + AW.aliasingGraph->style->black_gc, + AW.aliasingGraph->style->dark_gc[GTK_STATE_NORMAL], + Current.Cutoffs[MIDTONES]); + + draw_slider(AW.aliasingGraph->window, + AW.aliasingGraph->style->black_gc, + AW.aliasingGraph->style->dark_gc[GTK_STATE_SELECTED], + Current.Offset); +} + +gint +FP_Range_Change_Events (GtkWidget *widget, + GdkEvent *event, + FP_Params *current) +{ + GdkEventButton *bevent; + GdkEventMotion *mevent; + gint shad, mid, offset, min; + static guchar *new; + gint x; + + switch(event->type) { + + case GDK_EXPOSE: + draw_it(NULL); + break; + + case GDK_BUTTON_PRESS: + bevent=(GdkEventButton *) event; + + shad = abs(bevent->x - Current.Cutoffs[SHADOWS]); + mid = abs(bevent->x - Current.Cutoffs[MIDTONES]); + offset = abs(bevent->x - Current.Offset); + + min= MIN(MIN(shad,mid),offset); + + + if (bevent->x >0 && bevent->x<256) { + if (min==shad) + new = &Current.Cutoffs[SHADOWS]; + else if (min==mid) + new = &Current.Cutoffs[MIDTONES]; + else + new = &Current.Offset; + + slider_erase(AW.aliasingGraph->window,*new); + *new=bevent->x; + } + + draw_it(NULL); + + if (Current.RealTime) { + fp_range_preview_spill(AW.rangePreview,Current.ValueBy); + update_range_labels(); + fp_create_smoothness_graph(AW.aliasingPreview); + refreshPreviews(Current.VisibleFrames); + } + break; + + case GDK_BUTTON_RELEASE: + if (!Current.RealTime) { + fp_range_preview_spill(AW.rangePreview,Current.ValueBy); + update_range_labels(); + fp_create_smoothness_graph(AW.aliasingPreview); + refreshPreviews(Current.VisibleFrames); + } + break; + + case GDK_MOTION_NOTIFY: + mevent= (GdkEventMotion *) event; + gdk_window_get_pointer(widget->window, &x,NULL, NULL); + + if (x>=0 && x<256) { + slider_erase(AW.aliasingGraph->window,*new); + *new=x; + draw_it(NULL); + if (Current.RealTime) { + fp_range_preview_spill(AW.rangePreview,Current.ValueBy); + update_range_labels(); + fp_create_smoothness_graph(AW.aliasingPreview); + refreshPreviews(Current.VisibleFrames); + } + } + + break; + + default: + break; + } +return 0; +} + +void +update_range_labels() +{ + guchar buffer[3]; + + gtk_label_set(GTK_LABEL(Current.rangeLabels[1]),"0"); + + sprintf(buffer,"%d",Current.Cutoffs[SHADOWS]); + gtk_label_set(GTK_LABEL(Current.rangeLabels[3]),buffer); + gtk_label_set(GTK_LABEL(Current.rangeLabels[5]),buffer); + + sprintf(buffer,"%d",Current.Cutoffs[MIDTONES]); + gtk_label_set(GTK_LABEL(Current.rangeLabels[7]),buffer); + gtk_label_set(GTK_LABEL(Current.rangeLabels[9]),buffer); + + gtk_label_set(GTK_LABEL(Current.rangeLabels[11]),"255"); +} diff --git a/plug-ins/fp/fp_gtk.c b/plug-ins/fp/fp_gtk.c new file mode 100644 index 0000000000..476019a233 --- /dev/null +++ b/plug-ins/fp/fp_gtk.c @@ -0,0 +1,1124 @@ +#include +#include +#include +#include "gtk/gtk.h" +#include "libgimp/gimp.h" +#include "fp.h" +#include "fp_hsv.h" + +AdvancedWindow AW={NULL,NULL,NULL,NULL,NULL,NULL,NULL}; + +extern FP_Params Current; + +extern GDrawable *drawable, *mask; + +FP_Intensity ShMidHi[] ={SHADOWS,MIDTONES,HIGHLIGHTS}; +int HueSatVal[] ={BY_HUE,BY_SAT,BY_VAL}; + +gint nudgeArray[256]; + +GtkWidget *origPreview, *curPreview; +GtkWidget *rPreview, *gPreview, *bPreview; +GtkWidget *cPreview, *yPreview, *mPreview; +GtkWidget *centerPreview; +GtkWidget *darkerPreview, *lighterPreview, *middlePreview; +GtkWidget *allOrSell, *dlg; +GtkWidget *plusSatPreview, *SatPreview, *minusSatPreview; + +struct +{ + GtkWidget *bna, + *palette, + *rough, + *range, + *show, + *lnd, + *pixelsBy, + *frameSelect, + *satur; +} fpFrames; + + +fpInterface FPint = +{ + FALSE /* run */ +}; +ReducedImage *reduced; + +/***********************************************************/ +/************ Main Dialog Window ******************/ +/***********************************************************/ + +GtkWidget *fp_create_bna(void) +{ + GtkWidget *frame, *blabel, *alabel, *bframe, *aframe, *table; + + Create_A_Preview(&origPreview,&bframe, reduced->width, reduced->height); + Create_A_Preview(&curPreview,&aframe, reduced->width, reduced->height); + + frame = gtk_frame_new ("Before And After"); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + + /* All the previews */ + alabel=gtk_label_new("Current:"); + gtk_widget_show(alabel); + gtk_misc_set_alignment(GTK_MISC(alabel), 0.0, 0.5); + + blabel=gtk_label_new("Original:"); + gtk_widget_show(blabel); + gtk_misc_set_alignment(GTK_MISC(blabel), 0.0, 0.5); + + table=gtk_table_new(2,2,FALSE); + gtk_container_border_width(GTK_CONTAINER(table),10); + gtk_table_set_row_spacings(GTK_TABLE(table),0); + gtk_table_set_col_spacings(GTK_TABLE(table),20); + + gtk_container_add (GTK_CONTAINER (frame), table); + + gtk_table_attach(GTK_TABLE(table),blabel,0,1,0,1, + 0, + GTK_EXPAND|GTK_FILL, + 0,0); + gtk_table_attach(GTK_TABLE(table),alabel,1,2,0,1, + 0, + GTK_EXPAND|GTK_FILL, + 0,0); + gtk_table_attach(GTK_TABLE(table),bframe,0,1,1,2, + GTK_EXPAND, + GTK_EXPAND, + 0,0); + gtk_table_attach(GTK_TABLE(table),aframe,1,2,1,2, + GTK_EXPAND, + GTK_EXPAND, + 0,0); + + gtk_widget_show(table); + gtk_widget_show (frame); + return frame; +} + +GtkWidget *fp_create_circle_palette(void) +{ + GtkWidget *frame, *table; + GtkWidget *rVbox, *rFrame; + GtkWidget *gVbox, *gFrame; + GtkWidget *bVbox, *bFrame; + GtkWidget *cVbox, *cFrame; + GtkWidget *yVbox, *yFrame; + GtkWidget *mVbox, *mFrame; + GtkWidget *centerVbox, *centerFrame; + + GtkWidget *win; + + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show (frame); + + table = gtk_table_new(11,11,FALSE); + gtk_container_border_width(GTK_CONTAINER(table),0); + gtk_table_set_row_spacings(GTK_TABLE(table),0); + gtk_table_set_col_spacings(GTK_TABLE(table),3); + gtk_widget_show (table); + + gtk_container_add (GTK_CONTAINER (frame), table); + + Create_A_Preview(&rPreview,&rFrame, reduced->width, reduced->height); + Create_A_Preview(&gPreview,&gFrame, reduced->width, reduced->height); + Create_A_Preview(&bPreview,&bFrame, reduced->width, reduced->height); + Create_A_Preview(&cPreview,&cFrame, reduced->width, reduced->height); + Create_A_Preview(&yPreview,&yFrame, reduced->width, reduced->height); + Create_A_Preview(&mPreview,&mFrame, reduced->width, reduced->height); + Create_A_Preview(¢erPreview,¢erFrame, reduced->width, reduced->height); + + Create_A_Table_Entry(&rVbox,rFrame,"Red:"); + Create_A_Table_Entry(&gVbox,gFrame,"Green:"); + Create_A_Table_Entry(&bVbox,bFrame,"Blue:"); + Create_A_Table_Entry(&cVbox,cFrame,"Cyan:"); + Create_A_Table_Entry(&yVbox,yFrame,"Yellow:"); + Create_A_Table_Entry(&mVbox,mFrame,"Magenta:"); + Create_A_Table_Entry(¢erVbox,centerFrame,"Current:"); + + gtk_table_attach( GTK_TABLE(table), rVbox,8,11,4,7, + GTK_EXPAND , GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), gVbox,2,5,0,3, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), bVbox,2,5,8,11, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), cVbox,0,3,4,7, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), yVbox,6,9,0,3, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), mVbox,6,9,8,11, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), centerVbox,4,7,4,7, + GTK_EXPAND, GTK_EXPAND,0,0); + + win = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(win),"Hue Variations"); + gtk_container_add(GTK_CONTAINER(win),frame); + + return win; +} + +GtkWidget *fp_create_rough(void) +{ + GtkWidget *frame, *scale, *vbox; + GtkObject *data; + + frame = gtk_frame_new ("Roughness"); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show (frame); + + data = gtk_adjustment_new (Current.Rough, + 0, 1.0, 0.05, 0.01, 0.0); + Current.roughnessScale= + scale = gtk_hscale_new (GTK_ADJUSTMENT (data)); + + gtk_widget_set_usize (scale, 60, 0); + gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP); + gtk_scale_set_digits (GTK_SCALE (scale), 2); + gtk_signal_connect (GTK_OBJECT (data), "value_changed", + (GtkSignalFunc) fp_scale_update, + &Current.Rough); + gtk_widget_show (scale); + + vbox=gtk_vbox_new(FALSE,5); + gtk_widget_show(vbox); + gtk_box_pack_start (GTK_BOX(vbox), scale,TRUE,TRUE,5); + gtk_container_add (GTK_CONTAINER(frame), vbox); + + return frame; +} + +GtkWidget *fp_create_range(void) +{ + GtkWidget *frame, *vbox; + GSList *group=NULL; + + frame = gtk_frame_new ("Affected Range"); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + + gtk_widget_show (frame); + + /********THE THREE RANGES*************/ + vbox=gtk_vbox_new(FALSE,5); + gtk_container_add(GTK_CONTAINER(frame),vbox); + gtk_container_border_width(GTK_CONTAINER(vbox),5); + gtk_widget_show(vbox); + + group=Button_In_A_Box(vbox,group,"Shadows", + (GtkSignalFunc) fp_change_current_range, + ShMidHi+SHADOWS, + Current.Range==SHADOWS); + group=Button_In_A_Box(vbox,group,"Midtones", + (GtkSignalFunc) fp_change_current_range, + ShMidHi+MIDTONES, + Current.Range==MIDTONES); + group=Button_In_A_Box(vbox,group,"Highlights", + (GtkSignalFunc) fp_change_current_range, + ShMidHi+HIGHLIGHTS, + Current.Range==HIGHLIGHTS); + return frame; +} + + /********THE THREE RANGES*************/ + /********THE THREE RANGES*************/ + /********THE THREE RANGES*************/ + /********THE THREE RANGES*************/ + /********THE THREE RANGES*************/ +GtkWidget *fp_create_control(void) +{ + GtkWidget *frame, *box; + + frame = gtk_frame_new ("Windows"); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + + gtk_widget_show (frame); + + /********THE THREE RANGES*************/ + box=gtk_vbox_new(FALSE,5); + gtk_container_add(GTK_CONTAINER(frame),box); + gtk_container_border_width(GTK_CONTAINER(box),5); + gtk_widget_show(box); + + Check_Button_In_A_Box(box,"Hue", + (GtkSignalFunc) fp_show_hide_frame, + fpFrames.palette, + Current.VisibleFrames&HUE); + Check_Button_In_A_Box(box,"Saturation", + (GtkSignalFunc) fp_show_hide_frame, + fpFrames.satur, + Current.VisibleFrames&SATURATION); + Check_Button_In_A_Box(box,"Value", + (GtkSignalFunc) fp_show_hide_frame, + fpFrames.lnd, + Current.VisibleFrames&VALUE); + Check_Button_In_A_Box(box,"Advanced", + (GtkSignalFunc) fp_show_hide_frame, + AW.window, + FALSE); + + return frame; +} + +GtkWidget *fp_create_lnd() +{ + GtkWidget *frame, *table, *lighterFrame, *middleFrame, *darkerFrame; + GtkWidget *lighterVbox, *middleVbox, *darkerVbox; + GtkWidget *win; + + Create_A_Preview(&lighterPreview,&lighterFrame, reduced->width, reduced->height); + Create_A_Preview(&middlePreview,&middleFrame, reduced->width, reduced->height); + Create_A_Preview(&darkerPreview,&darkerFrame, reduced->width, reduced->height); + + Create_A_Table_Entry(&lighterVbox,lighterFrame,"Lighter:"); + Create_A_Table_Entry(&middleVbox,middleFrame,"Current:"); + Create_A_Table_Entry(&darkerVbox,darkerFrame,"Darker:"); + + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show (frame); + + table = gtk_table_new(1,11,FALSE); + gtk_container_border_width(GTK_CONTAINER(table),0); + gtk_table_set_row_spacings(GTK_TABLE(table),0); + gtk_table_set_col_spacings(GTK_TABLE(table),3); + gtk_widget_show (table); + + + gtk_table_attach( GTK_TABLE(table), lighterVbox,0,3,0,1, + GTK_EXPAND , GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), middleVbox,4,7,0,1, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), darkerVbox,8,11,0,1, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_container_add (GTK_CONTAINER (frame), table); + + win = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(win),"Value Variations"); + gtk_container_add(GTK_CONTAINER(win),frame); + + return win; +} + +GtkWidget *fp_create_msnls() +{ + + GtkWidget *frame, *table, *lessFrame, *middleFrame, *moreFrame; + GtkWidget *lessVbox, *middleVbox, *moreVbox; + GtkWidget *win; + + Create_A_Preview(&minusSatPreview,&lessFrame, reduced->width, reduced->height); + Create_A_Preview(&SatPreview,&middleFrame, reduced->width, reduced->height); + Create_A_Preview(&plusSatPreview,&moreFrame, reduced->width, reduced->height); + + Create_A_Table_Entry(&moreVbox,moreFrame,"More Sat:"); + Create_A_Table_Entry(&middleVbox,middleFrame,"Current:"); + Create_A_Table_Entry(&lessVbox,lessFrame,"Less Sat:"); + + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show(frame); + + table = gtk_table_new(1,11,FALSE); + gtk_container_border_width(GTK_CONTAINER(table),0); + gtk_table_set_row_spacings(GTK_TABLE(table),0); + gtk_table_set_col_spacings(GTK_TABLE(table),3); + gtk_widget_show (table); + + + gtk_table_attach( GTK_TABLE(table), moreVbox,0,3,0,1, + GTK_EXPAND , GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), middleVbox,4,7,0,1, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_table_attach( GTK_TABLE(table), lessVbox,8,11,0,1, + GTK_EXPAND, GTK_EXPAND,0,0); + gtk_container_add (GTK_CONTAINER (frame), table); + + win = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(win),"Saturation Variations"); + gtk_container_add(GTK_CONTAINER(win),frame); + + return win; +} + + +GtkWidget *fp_create_pixels_select_by() +{ + GtkWidget *frame, *vbox; + GSList *group=NULL; + + frame = gtk_frame_new ("Select Pixels By"); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show(frame); + + vbox=gtk_vbox_new(FALSE,5); + gtk_container_add(GTK_CONTAINER(frame),vbox); + gtk_container_border_width(GTK_CONTAINER(vbox),5); + gtk_widget_show(vbox); + + group=Button_In_A_Box(vbox,group,"Hue", + (GtkSignalFunc) fp_change_current_pixels_by, + HueSatVal+0, + Current.ValueBy==BY_HUE); + group=Button_In_A_Box(vbox,group,"Saturation", + (GtkSignalFunc) fp_change_current_pixels_by, + HueSatVal+1, + Current.ValueBy==BY_SAT); + + group=Button_In_A_Box(vbox,group,"Value", + (GtkSignalFunc) fp_change_current_pixels_by, + HueSatVal+2, + Current.ValueBy==BY_VAL); + return frame; +} + +GtkWidget *fp_create_show() +{ + GtkWidget *frame, *vbox; + GSList *group=NULL; + + frame=gtk_frame_new("Show"); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show(frame); + + vbox=gtk_vbox_new(FALSE,5); + gtk_container_add(GTK_CONTAINER(frame),vbox); + gtk_container_border_width(GTK_CONTAINER(vbox),5); + gtk_widget_show(vbox); + + + group=Button_In_A_Box(vbox,group,"Entire Image", + (GtkSignalFunc) fp_entire_image, + &Current.SlctnOnly, + FALSE); + + group=Button_In_A_Box(vbox,group,"Selection Only", + (GtkSignalFunc) fp_selection_only, + &Current.SlctnOnly, + TRUE); + + group=Button_In_A_Box(vbox,group,"Selection In Context", + (GtkSignalFunc) fp_selection_in_context, + &Current.SlctnOnly, + FALSE); + return frame; +} +GtkWidget *fp_create_frame_select() +{ + GtkWidget *frame, *box; + + frame=gtk_frame_new("Display"); + gtk_container_border_width (GTK_CONTAINER (frame), 5); + gtk_widget_show(frame); + + box=gtk_hbox_new(FALSE,15); + gtk_container_add(GTK_CONTAINER(frame),box); + gtk_container_border_width(GTK_CONTAINER(box),5); + gtk_widget_show(box); + + Check_Button_In_A_Box (box,"CirclePalette", + (GtkSignalFunc) fp_show_hide_frame, + fpFrames.palette,TRUE); + Check_Button_In_A_Box (box,"Lighter And Darker", + (GtkSignalFunc) fp_show_hide_frame, + fpFrames.lnd,TRUE); + Check_Button_In_A_Box (box,"Saturation", + (GtkSignalFunc) fp_show_hide_frame, + fpFrames.satur,FALSE); + return frame; +} + +void Create_A_Preview (GtkWidget **preview, + GtkWidget **frame, + int previewWidth, + int previewHeight) +{ + *frame=gtk_frame_new(NULL); + gtk_frame_set_shadow_type (GTK_FRAME (*frame), GTK_SHADOW_IN); + gtk_container_border_width (GTK_CONTAINER(*frame),0); + gtk_widget_show(*frame); + + *preview=gtk_preview_new (Current.Color?GTK_PREVIEW_COLOR + :GTK_PREVIEW_GRAYSCALE); + gtk_preview_size (GTK_PREVIEW (*preview), previewWidth, previewHeight); + gtk_widget_show(*preview); + gtk_container_add(GTK_CONTAINER(*frame),*preview); +} + + +GSList * Button_In_A_Box (GtkWidget *vbox, + GSList *group, + guchar *label, + GtkSignalFunc function, + gpointer data, + int clicked) +{ + GtkWidget *button; + + button=gtk_radio_button_new_with_label(group,label); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) function, + data); + gtk_widget_show(button); + gtk_box_pack_start (GTK_BOX(vbox),button, TRUE, TRUE, 0); + if (clicked) + gtk_button_clicked(GTK_BUTTON(button)); + return gtk_radio_button_group(GTK_RADIO_BUTTON(button)); +} + +void Check_Button_In_A_Box (GtkWidget *vbox, + guchar *label, + GtkSignalFunc function, + gpointer data, + int clicked) +{ + GtkWidget *button; + + + button=gtk_check_button_new_with_label(label); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) function, + data); + gtk_box_pack_start (GTK_BOX(vbox),button, TRUE, TRUE, 0); + gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button),clicked); + + gtk_widget_show(button); +} + + +void Create_A_Table_Entry (GtkWidget **box, + GtkWidget *SmallerFrame, + char *description) +{ + GtkWidget *label, *button, *table; + *box = gtk_vbox_new(FALSE,1); + gtk_container_border_width (GTK_CONTAINER (*box),PR_BX_BRDR); + gtk_widget_show (*box); + label = gtk_label_new(description); + gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); + gtk_widget_show (label); + + table=gtk_table_new(2,1,FALSE); + gtk_widget_show(table); + + gtk_box_pack_start (GTK_BOX(*box),table, TRUE, TRUE, 0); + + gtk_table_attach(GTK_TABLE(table),label,0,1,0,1,0,0,0,0); + + if (strcmp(description,"Current:")) { + button = gtk_button_new(); + gtk_signal_connect (GTK_OBJECT (button), "clicked", + (GtkSignalFunc) selectionMade, + description); + + gtk_container_add(GTK_CONTAINER(button),SmallerFrame); + gtk_container_border_width (GTK_CONTAINER (button),0); + gtk_widget_show(button); + gtk_table_attach(GTK_TABLE(table), button, 0,1,1,2,0,0,0,5); + } + else + gtk_table_attach(GTK_TABLE(table), SmallerFrame, 0,1,1,2,0,0,0,5); +} + +void +fp_redraw_all_windows() +{ + + reduced=Reduce_The_Image(drawable,mask, + Current.PreviewSize, + Current.SlctnOnly); + Adjust_Preview_Sizes(reduced->width,reduced->height); + + /*gtk_container_check_resize(GTK_CONTAINER(fpFrames.palette), NULL);*/ + gtk_widget_draw(fpFrames.palette,NULL); + + /*gtk_container_check_resize(GTK_CONTAINER(fpFrames.satur), NULL);*/ + gtk_widget_draw(fpFrames.satur,NULL); + + /*gtk_container_check_resize(GTK_CONTAINER(fpFrames.lnd), NULL);*/ + gtk_widget_draw(fpFrames.lnd,NULL); + + /*gtk_container_check_resize(GTK_CONTAINER(dlg), NULL);*/ + gtk_widget_draw(dlg,NULL); + + refreshPreviews(Current.VisibleFrames); +} + +void +fp_entire_image (GtkWidget *button, + gpointer data ) +{ + if (!GTK_TOGGLE_BUTTON(button)->active) + return; + Current.SlctnOnly = 0; + fp_redraw_all_windows(); +} + + +void +fp_selection_only (GtkWidget *button, + gpointer data ) +{ + static int notFirstTime=0; + + if (!(notFirstTime++)) return; + + if (!GTK_TOGGLE_BUTTON(button)->active) + return; + Current.SlctnOnly = 1; + fp_redraw_all_windows(); +} + + +void +fp_selection_in_context (GtkWidget *button, + gpointer data ) +{ + if (!GTK_TOGGLE_BUTTON(button)->active) + return; + Current.SlctnOnly = 2; + fp_redraw_all_windows(); +} + +void fp_show_hide_frame (GtkWidget *button, + GtkWidget *frame) +{ + int prev=Current.VisibleFrames; + if (frame == NULL) return; + if (GTK_TOGGLE_BUTTON(button)->active) + if (!GTK_WIDGET_VISIBLE(frame)) { + gtk_widget_show(frame); + if (frame==fpFrames.palette) + Current.VisibleFrames |= HUE; + else if (frame==fpFrames.satur) + Current.VisibleFrames |= SATURATION; + else if (frame==fpFrames.lnd) + Current.VisibleFrames |= VALUE; + refreshPreviews(Current.VisibleFrames & ~prev); + } + else ; + + else + if (GTK_WIDGET_VISIBLE(frame)) { + gtk_widget_hide(frame); + if (frame==fpFrames.palette) + Current.VisibleFrames &= ~HUE; + else if (frame==fpFrames.satur) + Current.VisibleFrames &= ~SATURATION; + else if (frame==fpFrames.lnd) + Current.VisibleFrames &= ~VALUE; + } +} + +void Adjust_Preview_Sizes(int width, int height) +{ + gtk_preview_size (GTK_PREVIEW (origPreview), width, height); + gtk_preview_size (GTK_PREVIEW (curPreview), width, height); + gtk_preview_size (GTK_PREVIEW (rPreview), width, height); + gtk_preview_size (GTK_PREVIEW (gPreview), width, height); + gtk_preview_size (GTK_PREVIEW (bPreview), width, height); + gtk_preview_size (GTK_PREVIEW (cPreview), width, height); + gtk_preview_size (GTK_PREVIEW (yPreview), width, height); + gtk_preview_size (GTK_PREVIEW (mPreview), width, height); + gtk_preview_size (GTK_PREVIEW (centerPreview), width, height); + gtk_preview_size (GTK_PREVIEW (lighterPreview), width, height); + gtk_preview_size (GTK_PREVIEW (darkerPreview), width, height); + gtk_preview_size (GTK_PREVIEW (middlePreview), width, height); + gtk_preview_size (GTK_PREVIEW (minusSatPreview), width, height); + gtk_preview_size (GTK_PREVIEW (SatPreview), width, height); + gtk_preview_size (GTK_PREVIEW (plusSatPreview), width, height); +} + + +void +selectionMade (GtkWidget *widget, + gpointer data) +{ + Current.Touched[Current.ValueBy] = 1; + + if (!strcmp("Red:",data)) Update_Current_FP( HUE, RED ); + else if (!strcmp("Green:",data)) Update_Current_FP( HUE, GREEN ); + else if (!strcmp("Blue:",data)) Update_Current_FP( HUE, BLUE ); + else if (!strcmp("Cyan:",data)) Update_Current_FP( HUE, CYAN ); + else if (!strcmp("Yellow:",data)) Update_Current_FP( HUE, YELLOW ); + else if (!strcmp("Magenta:",data)) Update_Current_FP( HUE, MAGENTA ); + else if (!strcmp("Darker:",data)) Update_Current_FP( VALUE, DOWN ); + else if (!strcmp("Lighter:",data)) Update_Current_FP( VALUE, UP ); + else if (!strcmp("More Saturated:",data)) + Update_Current_FP( SATURATION, UP ); + else if (!strcmp("Less Saturated:",data)) + Update_Current_FP( SATURATION, DOWN ); + + refreshPreviews(Current.VisibleFrames); +} + + +void refreshPreviews(gint which) +{ + fp_Create_Nudge(nudgeArray); + fp_render_preview ( origPreview, NONEATALL, 0 ); + fp_render_preview ( curPreview, CURRENT, 0 ); + if (which & HUE) { + fp_render_preview( rPreview, HUE, RED ); + fp_render_preview( gPreview, HUE, GREEN ); + fp_render_preview( bPreview, HUE, BLUE ); + fp_render_preview( cPreview, HUE, CYAN ); + fp_render_preview( yPreview, HUE, YELLOW ); + fp_render_preview( mPreview, HUE, MAGENTA ); + fp_render_preview( centerPreview, CURRENT, 0 ); + } + if (which & VALUE) { + fp_render_preview( lighterPreview, VALUE, UP ); + fp_render_preview( middlePreview, CURRENT, 0 ); + fp_render_preview( darkerPreview, VALUE, DOWN ); + } + if (which & SATURATION) { + fp_render_preview( plusSatPreview, SATURATION, UP ); + fp_render_preview( SatPreview, CURRENT, 0 ); + fp_render_preview( minusSatPreview, SATURATION, DOWN ); + } + +} + +void +fp_close_callback (GtkWidget *widget, + gpointer data) +{ + gtk_main_quit (); +} + +void +fp_ok_callback (GtkWidget *widget, + gpointer data) +{ + FPint.run = TRUE; + gtk_widget_destroy (GTK_WIDGET (data)); +} + + +void +fp_scale_update (GtkAdjustment *adjustment, + float *scale_val) +{ + static float prevValue=.25; + *scale_val = adjustment->value; + if (prevValue != adjustment->value) { + fp_Create_Nudge(nudgeArray); + refreshPreviews(Current.VisibleFrames); + if (AW.window != NULL && GTK_WIDGET_VISIBLE (AW.window)) + fp_create_smoothness_graph(AW.aliasingPreview); + prevValue = adjustment->value; + } +} + +void +fp_change_current_range (GtkAdjustment *button, + gint *Intensity) +{ + static FP_Intensity prevValue=MIDTONES; + static int notFirstTime=0; + + if (!(notFirstTime++)) return; + if (!GTK_TOGGLE_BUTTON(button)->active) return; + if (*Intensity == prevValue) return; + + Current.Range = *Intensity; + refreshPreviews(Current.VisibleFrames); + if (AW.window != NULL && GTK_WIDGET_VISIBLE (AW.window)) + fp_create_smoothness_graph(AW.aliasingPreview); + prevValue = *Intensity; +} + +void +fp_change_current_pixels_by (GtkWidget *button, + gint *valueBy) +{ + int prevValue=VALUE; + static int notFirstTime=0; + + if (!(notFirstTime++)) return; + if (!GTK_TOGGLE_BUTTON(button)->active) return; + if (*valueBy == prevValue) return; + + Current.ValueBy = *valueBy; + refreshPreviews(Current.VisibleFrames); + if (AW.window != NULL && GTK_WIDGET_VISIBLE (AW.window) && AW.rangePreview != NULL) + fp_range_preview_spill(AW.rangePreview,Current.ValueBy); + + prevValue = *valueBy; +} + +void +fp_advanced_call () +{ + if (AW.window!=NULL) + if(GTK_WIDGET_VISIBLE(AW.window)) + gtk_widget_hide(AW.window); + else + gtk_widget_show(AW.window); + else + fp_advanced_dialog(); +} + +int fp_dialog() +{ + GtkWidget *bna; + GtkWidget *palette; + GtkWidget *lnd; + GtkWidget *show; + GtkWidget *rough; + GtkWidget *range; + GtkWidget *pixelsBy; + GtkWidget *satur; + GtkWidget *control; + + GtkWidget *table; + GtkWidget *OKbutton, *CANCELbutton, *RESETbutton; + GtkWidget *buttonTable; + + guchar *color_cube; + gchar **argv; + gint argc; + + + reduced=Reduce_The_Image(drawable,mask, + Current.PreviewSize, + Current.SlctnOnly); + + argc = 1; + argv = g_new (gchar *, 1); + argv[0] = g_strdup ("fp"); + + gtk_init (&argc, &argv); + gtk_rc_parse (gimp_gtkrc ()); + + gtk_preview_set_gamma (gimp_gamma ()); + gtk_preview_set_install_cmap (gimp_install_cmap ()); + color_cube = gimp_color_cube (); + gtk_preview_set_color_cube (color_cube[0], color_cube[1], + color_cube[2], color_cube[3]); + + gtk_widget_set_default_visual (gtk_preview_get_visual ()); + gtk_widget_set_default_colormap (gtk_preview_get_cmap ()); + + /********************************************************************/ + /************************* All the Standard Stuff *******************/ + dlg = gtk_dialog_new (); + gtk_window_set_title (GTK_WINDOW (dlg), "Filter Pack Simulation"); + gtk_signal_connect (GTK_OBJECT (dlg), "destroy", + (GtkSignalFunc) fp_close_callback, + NULL); + + + OKbutton = gtk_button_new_with_label ("OK"); + GTK_WIDGET_SET_FLAGS (OKbutton, GTK_CAN_DEFAULT); + gtk_signal_connect (GTK_OBJECT (OKbutton), "clicked", + (GtkSignalFunc) fp_ok_callback, + dlg); + gtk_widget_grab_default (OKbutton); + gtk_widget_show (OKbutton); + + CANCELbutton = gtk_button_new_with_label ("Cancel"); + GTK_WIDGET_SET_FLAGS (CANCELbutton, GTK_CAN_DEFAULT); + gtk_signal_connect_object (GTK_OBJECT (CANCELbutton), "clicked", + (GtkSignalFunc) gtk_widget_destroy, + GTK_OBJECT (dlg)); + gtk_widget_show (CANCELbutton); + + + RESETbutton = gtk_button_new_with_label ("Reset"); + GTK_WIDGET_SET_FLAGS (RESETbutton, GTK_CAN_DEFAULT); + gtk_signal_connect_object (GTK_OBJECT (RESETbutton), "clicked", + (GtkSignalFunc) resetFilterPacks, + NULL); + gtk_widget_show (RESETbutton); + + + buttonTable=gtk_table_new(1,4,TRUE); + gtk_container_border_width(GTK_CONTAINER(buttonTable),0); + gtk_table_set_col_spacings(GTK_TABLE(buttonTable),3); + + + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), buttonTable, TRUE, TRUE, 0); + + gtk_table_attach( GTK_TABLE(buttonTable), OKbutton,0,1,0,1, + GTK_FILL|GTK_EXPAND,0,0,0); + gtk_table_attach( GTK_TABLE(buttonTable), CANCELbutton,1,2,0,1, + GTK_FILL|GTK_EXPAND,0,0,0); + gtk_table_attach( GTK_TABLE(buttonTable), RESETbutton,3,4,0,1, + GTK_FILL|GTK_EXPAND,0,0,0); + + gtk_widget_show (buttonTable); + + /********************************************************************/ + + fp_advanced_dialog(); + + fpFrames.bna = bna = fp_create_bna(); + fpFrames.rough = rough = fp_create_rough(); + fpFrames.range = range = fp_create_range(); + fpFrames.palette = palette = fp_create_circle_palette(); + fpFrames.lnd = lnd = fp_create_lnd(); + fpFrames.show = show = fp_create_show(); + fpFrames.satur = satur = fp_create_msnls(); + fpFrames.pixelsBy = pixelsBy = fp_create_pixels_select_by(); + control = fp_create_control(); + /********************************************************************/ + /******************** PUT EVRYTHING TOGETHER ******************/ + + + table=gtk_table_new(4,2,FALSE); + gtk_table_attach(GTK_TABLE(table), + bna,0,2,0,1, + GTK_EXPAND|GTK_FILL, + GTK_EXPAND|GTK_FILL, + 0,0); + + gtk_table_attach(GTK_TABLE(table), + control,1,2,1,3, + GTK_EXPAND|GTK_FILL, + GTK_EXPAND|GTK_FILL, + 0,0); + gtk_table_attach(GTK_TABLE(table), + rough,1,2,3,4, + GTK_EXPAND|GTK_FILL, + GTK_EXPAND|GTK_FILL, + 0,0); + + + gtk_table_attach(GTK_TABLE(table), + show,0,1,1,2, + GTK_FILL, + GTK_EXPAND|GTK_FILL, + 0,0); + gtk_table_attach(GTK_TABLE(table), + range,0,1,2,3, + GTK_EXPAND|GTK_FILL, + GTK_EXPAND|GTK_FILL, + 0,0); + gtk_table_attach(GTK_TABLE(table), + pixelsBy,0,1,3,4, + GTK_EXPAND|GTK_FILL, + GTK_EXPAND|GTK_FILL, + 0,0); + + gtk_box_pack_start(GTK_BOX(GTK_DIALOG (dlg)->vbox), table, TRUE,TRUE,0); + gtk_widget_show(table); + gtk_widget_show (dlg); + + refreshPreviews(Current.VisibleFrames); + gtk_main (); + gdk_flush (); + + return FPint.run; +} + +/***********************************************************/ +/************ Advanced Options Window ******************/ +/***********************************************************/ + +void fp_advanced_ok() +{ + gtk_widget_hide(AW.window); +} + + +void +As_You_Drag (GtkWidget *button) +{ + static int notFirstTime=0; + if (!(notFirstTime++)) return; + + if (GTK_TOGGLE_BUTTON(button)->active) { + Current.RealTime=TRUE; + gtk_range_set_update_policy (GTK_RANGE (Current.roughnessScale),0); + gtk_range_set_update_policy (GTK_RANGE (Current.aliasingScale),0); + gtk_range_set_update_policy (GTK_RANGE (Current.previewSizeScale),0); + } + else { + Current.RealTime=FALSE; + gtk_range_set_update_policy (GTK_RANGE (Current.roughnessScale), + GTK_UPDATE_DELAYED); + gtk_range_set_update_policy (GTK_RANGE (Current.aliasingScale), + GTK_UPDATE_DELAYED); + gtk_range_set_update_policy (GTK_RANGE (Current.previewSizeScale), + GTK_UPDATE_DELAYED); + } + + return; +} + + +void +preview_size_scale_update (GtkAdjustment *adjustment, + float *scale_val) +{ + Current.PreviewSize = adjustment->value; + fp_redraw_all_windows(); +} + + +gint fp_advanced_dialog() +{ + guchar *rangeNames[]={"Shadows:", "Midtones:", "Highlights:"}; + GtkWidget *frame, *mainvbox; + GtkObject *smoothnessData; + GtkWidget *graphFrame, *table, *scale; + GtkWidget *vbox, *label, *labelTable; + GtkWidget *optionsFrame; + int i; + + AW.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(AW.window),"Advanced Filter Pack Options"); + + mainvbox=gtk_hbox_new(FALSE,5); + gtk_container_add(GTK_CONTAINER(AW.window),mainvbox); + gtk_widget_show(mainvbox); + /************************************************************/ + frame = gtk_frame_new("Smoothness of Aliasing"); + gtk_container_border_width(GTK_CONTAINER(frame),10); + gtk_widget_show(frame); + + gtk_box_pack_start(GTK_BOX (mainvbox),frame, TRUE, TRUE,0); + + table=gtk_table_new(3,1,FALSE); + gtk_widget_show(table); + gtk_container_add(GTK_CONTAINER(frame),table); + + graphFrame=gtk_frame_new(NULL); + gtk_frame_set_shadow_type (GTK_FRAME (graphFrame), GTK_SHADOW_IN); + gtk_container_border_width (GTK_CONTAINER(graphFrame),0); + gtk_widget_show(graphFrame); + gtk_table_attach(GTK_TABLE(table),graphFrame,0,1,0,1, + GTK_EXPAND, + 0, + 10,10); + + vbox=gtk_vbox_new(FALSE,0); + gtk_widget_show(vbox); + gtk_container_add(GTK_CONTAINER(graphFrame),vbox); + + AW.aliasingPreview=gtk_preview_new (GTK_PREVIEW_COLOR); + gtk_preview_size (GTK_PREVIEW (AW.aliasingPreview), 256, MAX_ROUGHNESS); + gtk_widget_show(AW.aliasingPreview); + gtk_box_pack_start(GTK_BOX(vbox),AW.aliasingPreview,TRUE,TRUE,0); + fp_create_smoothness_graph(AW.aliasingPreview); + + AW.rangePreview=gtk_preview_new (GTK_PREVIEW_COLOR); + gtk_preview_size (GTK_PREVIEW (AW.rangePreview), 256, RANGE_HEIGHT); + gtk_widget_show(AW.rangePreview); + gtk_box_pack_start(GTK_BOX(vbox),AW.rangePreview,TRUE,TRUE,0); + fp_range_preview_spill(AW.rangePreview,Current.ValueBy); + + + labelTable=gtk_table_new(3,4,FALSE); + gtk_widget_show(labelTable); + gtk_table_attach(GTK_TABLE(table),labelTable,0,1,1,2, + GTK_EXPAND, + 0, + 0,15); + + for (i=0; i<12; i++) + { + label=Current.rangeLabels[i]=gtk_label_new("-"); + if (!(i%4)) { + gtk_label_set(GTK_LABEL(label),rangeNames[i/4]); + gtk_misc_set_alignment(GTK_MISC(label),0.0,1.0); + } + gtk_widget_show(label); + gtk_table_attach(GTK_TABLE(labelTable),label,i%4, i%4+1,i/4, i/4+1, + GTK_EXPAND|GTK_FILL,0,5,0); + } + /************************************************************/ + /************************************************************/ + /************************************************************/ + + + AW.aliasingGraph = gtk_drawing_area_new(); + gtk_drawing_area_size (GTK_DRAWING_AREA (AW.aliasingGraph), + 2*MARGIN + 256, + RANGE_HEIGHT); + gtk_box_pack_start(GTK_BOX(vbox), AW.aliasingGraph, TRUE, TRUE, 0); + gtk_widget_show(AW.aliasingGraph); + gtk_widget_set_events(AW.aliasingGraph,RANGE_ADJUST_MASK); + gtk_signal_connect(GTK_OBJECT(AW.aliasingGraph),"event", + (GtkSignalFunc) FP_Range_Change_Events, + &Current); + + + /************************************************************/ + /************************************************************/ + /************************************************************/ + + + smoothnessData = gtk_adjustment_new (Current.Alias, 0, 1.0, 0.05, 0.01, 0.0); + + Current.aliasingScale = + scale=gtk_hscale_new (GTK_ADJUSTMENT (smoothnessData)); + gtk_widget_set_usize (scale, 200, 0); + gtk_scale_set_digits (GTK_SCALE (scale), 2); + gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP); + gtk_range_set_update_policy (GTK_RANGE (scale), 0); + gtk_signal_connect (GTK_OBJECT (smoothnessData), "value_changed", + (GtkSignalFunc) fp_scale_update, + &Current.Alias); + gtk_widget_show (scale); + gtk_table_attach(GTK_TABLE(table),scale,0,1,2,3,0,0,0,15); + + /************************************************************/ + /******************* MISC OPTIONS ***************************/ + /************************************************************/ + + + optionsFrame=gtk_frame_new("Miscellaneous Options"); + gtk_container_border_width(GTK_CONTAINER(optionsFrame),10); + gtk_widget_show(optionsFrame); + + gtk_box_pack_start(GTK_BOX(mainvbox),optionsFrame, TRUE, TRUE,0); + + table=gtk_table_new(2,2,FALSE); + gtk_widget_show(table); + gtk_container_add(GTK_CONTAINER(optionsFrame),table); + + vbox=gtk_vbox_new(FALSE,8); + gtk_container_border_width(GTK_CONTAINER(vbox),10); + gtk_widget_show(vbox); + gtk_table_attach(GTK_TABLE(table),vbox,0,1,0,1,0,0,5,5); + + Check_Button_In_A_Box (vbox,"Preview As You Drag", + (GtkSignalFunc) As_You_Drag, + NULL,TRUE); + + frame=gtk_frame_new("Preview Size"); + gtk_widget_show(frame); + gtk_container_border_width(GTK_CONTAINER(frame),10); + + smoothnessData = gtk_adjustment_new (Current.PreviewSize, + 50, MAX_PREVIEW_SIZE, + 5, 5, 0.0); + + Current.previewSizeScale= + scale=gtk_hscale_new (GTK_ADJUSTMENT (smoothnessData)); + gtk_container_add(GTK_CONTAINER(frame),scale); + gtk_widget_set_usize (scale, 100, 0); + gtk_scale_set_digits (GTK_SCALE (scale), 0); + gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP); + gtk_range_set_update_policy (GTK_RANGE (scale), 0); + gtk_signal_connect (GTK_OBJECT (smoothnessData), "value_changed", + (GtkSignalFunc) preview_size_scale_update, + &Current.PreviewSize); + gtk_widget_show (scale); + gtk_table_attach(GTK_TABLE(table),frame,0,1,1,2,GTK_FILL,0,5,5); + + return 1; +} + diff --git a/plug-ins/fp/fp_hsv.c b/plug-ins/fp/fp_hsv.c new file mode 100644 index 0000000000..f16a08fb89 --- /dev/null +++ b/plug-ins/fp/fp_hsv.c @@ -0,0 +1,93 @@ +#include +#include +#include +#include "libgimp/gimp.h" + +typedef double hsv; +void rgb_to_hsv (hsv r, + hsv g, + hsv b, + hsv *h, + hsv *s, + hsv *l) +{ + hsv v; + hsv m; + hsv vm; + hsv r2, g2, b2; + + v = MAX(r,g); + v = MAX(v,b); + m = MIN(r,g); + m = MIN(m,b); + + if ((*l = (m + v) / 2.0) <= 0.0) + { + *s=*h=0; + return; + } + if ((*s = vm = v - m) > 0.0) + { + *s /= (*l <= 0.5) ? (v + m ) : + (2.0 - v - m) ; + } + else + { + *h=0; + return; + } + + r2 = (v - r) / vm; + g2 = (v - g) / vm; + b2 = (v - b) / vm; + + if (r == v) + *h = (g == m ? 5.0 + b2 : 1.0 - g2); + else if (g == v) + *h = (b == m ? 1.0 + r2 : 3.0 - b2); + else + *h = (r == m ? 3.0 + g2 : 5.0 - r2); + + *h /= 6; +} + +void hsv_to_rgb (hsv h, + hsv sl, + hsv l, + hsv *r, + hsv *g, + hsv *b) +{ + hsv v; + + v = (l <= 0.5) ? (l * (1.0 + sl)) : (l + sl - l * sl); + if (v <= 0) + { + *r = *g = *b = 0.0; + } + else + { + hsv m; + hsv sv; + gint sextant; + hsv fract, vsf, mid1, mid2; + + m = l + l - v; + sv = (v - m ) / v; + h *= 6.0; + sextant = h; + fract = h - sextant; + vsf = v * sv * fract; + mid1 = m + vsf; + mid2 = v - vsf; + switch (sextant) + { + case 0: *r = v; *g = mid1; *b = m; break; + case 1: *r = mid2; *g = v; *b = m; break; + case 2: *r = m; *g = v; *b = mid1; break; + case 3: *r = m; *g = mid2; *b = v; break; + case 4: *r = mid1; *g = m; *b = v; break; + case 5: *r = v; *g = m; *b = mid2; break; + } + } +} diff --git a/plug-ins/fp/fp_hsv.h b/plug-ins/fp/fp_hsv.h new file mode 100644 index 0000000000..743e9bc9e4 --- /dev/null +++ b/plug-ins/fp/fp_hsv.h @@ -0,0 +1,13 @@ +void rgb_to_hsv (hsv r, + hsv g, + hsv b, + hsv *h, + hsv *s, + hsv *l); + +void hsv_to_rgb (hsv h, + hsv sl, + hsv l, + hsv *r, + hsv *g, + hsv *b); diff --git a/plug-ins/fp/fp_misc.c b/plug-ins/fp/fp_misc.c new file mode 100644 index 0000000000..375e386e67 --- /dev/null +++ b/plug-ins/fp/fp_misc.c @@ -0,0 +1,404 @@ +#include +#include +#include +#include "gtk/gtk.h" +#include "libgimp/gimp.h" +#include "fp.h" +#include "fp_hsv.h" + +extern FP_Params Current; + +extern GDrawable *drawable, *mask; +extern ReducedImage *reduced; + +extern gint nudgeArray[256]; + +gint colorSign[3][ALL_PRIMARY]= +{{1,-1,-1,-1,1,1},{-1,1,-1,1,1,-1},{-1,-1,1,1,-1,1}}; + + +void initializeFilterPacks() +{ + gint i, j; + for (i=0; i<256; i++) + for (j=BY_HUE; jbpp; + ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage)); + guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B; + gint i, j, whichcol, whichrow, x1, x2, y1, y2; + GPixelRgn srcPR, srcMask; + gint NoSelectionMade=TRUE; + hsv *tempHSV, H, S, V; + + gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2); + width = x2-x1; + height = y2-y1; + + if (width != drawable->width && height != drawable->height) + NoSelectionMade=FALSE; + + if (Slctn==0) { + x1=0; + x2=drawable->width; + y1=0; + y2=drawable->height; + } + + if (Slctn==2) { + x1=MAX(0, x1-width/2.0); + x2=MIN(drawable->width, x2+width/2.0); + y1=MAX(0, y1-height/2.0); + y2=MIN(drawable->height, y2+height/2.0); + } + + width = x2-x1; + height = y2-y1; + + if (width>height) { + RW=LongerSize; + RH=(float) height * (float) LongerSize/ (float) width; + } + else { + RH=LongerSize; + RW=(float)width * (float) LongerSize/ (float) height; + } + + tempRGB = (guchar *) malloc(RW*RH*bytes); + tempHSV = (hsv *) malloc(RW*RH*bytes*sizeof(hsv)); + tempmask = (guchar *) malloc(RW*RH); + + gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, width, height, FALSE, FALSE); + gimp_pixel_rgn_init (&srcMask, mask, x1, y1, width, height, FALSE, FALSE); + + src_row = (guchar *) malloc (width*bytes); + src_mask_row = (guchar *) malloc (width*bytes); + + for (i=0; iwidth=RW; + temp->height=RH; + temp->rgb=tempRGB; + temp->hsv=tempHSV; + temp->mask=tempmask; + return temp; +} + +/*************************************************************/ +/************** The Preview Function *************************/ +void +fp_render_preview(GtkWidget *preview, + gint changewhat, + gint changewhich) +{ + guchar *a; + gint Inten, bytes=drawable->bpp; + gint i, j, k, nudge, M, m, middle,JudgeBy; + float partial; + gint RW=reduced->width; + gint RH=reduced->height; + gint backupP[3], P[3], tempSat[JUDGE_BY][256]; + + a =(guchar *) malloc(bytes*RW); + + if (changewhat==SATURATION) + for (k=0; k<256; k++) { + for (JudgeBy=BY_HUE; JudgeByrgb[i*RW*bytes + j*bytes + 0]; + backupP[1] = P[1] = (int) reduced->rgb[i*RW*bytes + j*bytes + 1]; + backupP[2] = P[2] = (int) reduced->rgb[i*RW*bytes + j*bytes + 2]; + + m = MIN(MIN(P[0],P[1]),P[2]); + M = MAX(MAX(P[0],P[1]),P[2]); + middle=(M+m)/2; + for (k=0; k<3; k++) + if (P[k]!=m && P[k]!=M) middle=P[k]; + + partial = reduced->mask[i*RW+j]/255.0; + + for (JudgeBy=BY_HUE; JudgeByhsv[i*RW*bytes + j*bytes + JudgeBy]*255.0; + + /*DO SATURATION FIRST*/ + if (changewhat != NONEATALL) { + if (M!=m) + for (k=0; k<3; k++) + if (backupP[k] == M) + P[k] = MAX(P[k]+partial*Current.satAdj[JudgeBy][Inten],middle); + else if (backupP[k] == m) + P[k] = MIN(P[k]-partial*Current.satAdj[JudgeBy][Inten],middle); + + P[0] += partial*Current.redAdj[JudgeBy][Inten]; + P[1] += partial*Current.greenAdj[JudgeBy][Inten]; + P[2] += partial*Current.blueAdj[JudgeBy][Inten]; + } + } + + Inten = reduced->hsv[i*RW*bytes + j*bytes + Current.ValueBy]*255.0; + nudge = partial*nudgeArray[(Inten+Current.Offset)%256]; + + switch (changewhat) { + case HUE: + P[0] += colorSign[RED][changewhich] * nudge; + P[1] += colorSign[GREEN][changewhich] * nudge; + P[2] += colorSign[BLUE][changewhich] * nudge; + break; + + case SATURATION: + for (JudgeBy=BY_HUE; JudgeByrgb[i*RW*bytes+j*bytes+3]/255.0; + a[3*j+k]=transp*a[3*j+k]+(1-transp)*fp_fake_transparency(i,j); + } + } + gtk_preview_draw_row( GTK_PREVIEW(preview),a,0,i,RW); + } + + free(a); + gtk_widget_draw(preview,NULL); + gdk_flush(); +} + +void +Update_Current_FP (gint changewhat, + gint changewhich) +{ + int i, nudge; + + for (i=0; i<256; i++) { + + fp_Create_Nudge(nudgeArray); + nudge=nudgeArray[(i+Current.Offset)%256]; + + switch (changewhat) { + case HUE: + Current.redAdj[Current.ValueBy][i] += + colorSign[RED][changewhich] * nudge; + + Current.greenAdj[Current.ValueBy][i] += + colorSign[GREEN][changewhich] * nudge; + + Current.blueAdj[Current.ValueBy][i] += + colorSign[BLUE][changewhich] * nudge; + break; + + case SATURATION: + Current.satAdj[Current.ValueBy][i] += changewhich*nudge; + break; + + case VALUE: + Current.redAdj[Current.ValueBy][i] += changewhich * nudge; + Current.greenAdj[Current.ValueBy][i] += changewhich * nudge; + Current.blueAdj[Current.ValueBy][i] += changewhich * nudge; + break; + + default: + break; + } /* switch */ + + } /* for */ +} + + +void +fp_create_smoothness_graph (GtkWidget *preview) +{ + guchar data[256*3]; + gint nArray[256]; + int i, j, toBeBlack; + + fp_Create_Nudge(nArray); + + for (i=0; i0 ) + return 64; + else + return 196; +} diff --git a/plug-ins/gfli/gfli.c b/plug-ins/gfli/gfli.c index ddafa241d3..de1e5d5853 100644 --- a/plug-ins/gfli/gfli.c +++ b/plug-ins/gfli/gfli.c @@ -50,6 +50,10 @@ #include "fli.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + static void query (void); static void run (gchar *name, gint nparams, GParam *param, gint *nreturn_vals, GParam **return_vals); diff --git a/plug-ins/nlfilt/nlfilt.c b/plug-ins/nlfilt/nlfilt.c index 8a262840cf..f1bf7d9059 100644 --- a/plug-ins/nlfilt/nlfilt.c +++ b/plug-ins/nlfilt/nlfilt.c @@ -34,10 +34,13 @@ #include #include - #include #include +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + static mw_preview_t nlfilt_do_preview; struct Grgb { diff --git a/plug-ins/ps/ps.c b/plug-ins/ps/ps.c index 3a407dc714..079008e841 100644 --- a/plug-ins/ps/ps.c +++ b/plug-ins/ps/ps.c @@ -50,6 +50,10 @@ static char ident[] = "@(#) GIMP PostScript/PDF file-plugin v1.04 20-Dec-97"; #include "gtk/gtk.h" #include "libgimp/gimp.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #define STR_LENGTH 64 /* Load info */ diff --git a/plug-ins/randomize/randomize.c b/plug-ins/randomize/randomize.c index f0fe99f6e1..f4c35bffee 100644 --- a/plug-ins/randomize/randomize.c +++ b/plug-ins/randomize/randomize.c @@ -74,8 +74,8 @@ #include "gtk/gtk.h" #include -#if ! defined(__GNUC__) -# define inline +#ifdef HAVE_CONFIG_H +#include "config.h" #endif /********************************* diff --git a/plug-ins/sinus/sinus.c b/plug-ins/sinus/sinus.c index a3e6d0bd07..1ae07b369b 100644 --- a/plug-ins/sinus/sinus.c +++ b/plug-ins/sinus/sinus.c @@ -38,6 +38,11 @@ #include #include #include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #ifdef USE_LOGO #include "sinus_logo.h" #endif diff --git a/plug-ins/zealouscrop/zealouscrop.c b/plug-ins/zealouscrop/zealouscrop.c index 8ab9318aba..29aa6232aa 100644 --- a/plug-ins/zealouscrop/zealouscrop.c +++ b/plug-ins/zealouscrop/zealouscrop.c @@ -16,6 +16,10 @@ #include "libgimp/gimp.h" #include "gtk/gtk.h" +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + /* Declare local functions. */ static void query(void); static void run(char *name,