/* * wind 1.1.0 - a plug-in for the GIMP * * Copyright (C) Nigel Wetten * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * Contact info: nigel@cs.nwu.edu * Version: 1.0.0 * * Version: 1.1.0 * May 2000 tim copperfield [timecop@japan.co.jp] * * Added dynamic preview. * */ #include "config.h" #include #include #include #ifdef __GNUC__ #warning GTK_DISABLE_DEPRECATED #endif #undef GTK_DISABLE_DEPRECATED #include #include #include #include "libgimp/stdplugins-intl.h" #define PLUG_IN_NAME "wind" #define COMPARE_WIDTH 3 #define SCALE_WIDTH 200 #define MIN_THRESHOLD 0 #define MAX_THRESHOLD 50 #define MIN_STRENGTH 1 #define MAX_STRENGTH 50 #define PREVIEW_SIZE 128 typedef enum { LEFT, RIGHT } direction_t; typedef enum { RENDER_WIND, RENDER_BLAST } algorithm_t; typedef enum { BOTH, LEADING, TRAILING } edge_t; static void query (void); static void run (gchar *name, gint nparams, GimpParam *param, gint *nreturn_vals, GimpParam **return_vals); static void dialog_box (GimpDrawable *drawable); static void ok_callback (GtkWidget *widget, gpointer data); static void radio_callback (GtkWidget *widget, gpointer data); static gint render_effect (GimpDrawable *drawable, gboolean preview_mode); static void render_wind (GimpDrawable *drawable, gint threshold, gint strength, direction_t direction, edge_t edge, gboolean preview_mode); static void render_blast (GimpDrawable *drawable, gint threshold, gint strength, direction_t direction, edge_t edge, gboolean preview_mode); static gint render_blast_row (guchar *buffer, gint bytes, gint lpi, gint threshold, gint strength, edge_t edge); static void render_wind_row (guchar *sb, gint bytes, gint lpi, gint threshold, gint strength, edge_t edge); static void get_derivative (guchar *pixel_R1, guchar *pixel_R2, edge_t edge, gboolean has_alpha, gint *derivative_R, gint *derivative_G, gint *derivative_B, gint *derivative_A); static gint threshold_exceeded (guchar *pixel_R1, guchar *pixel_R2, edge_t edge, gint threshold, gboolean has_alpha); static void reverse_buffer (guchar *buffer, gint length, gint bytes); static void fill_preview (GtkWidget *preview_widget, GimpDrawable *drawable); static GtkWidget *preview_widget (GimpDrawable *drawable); GimpPlugInInfo PLUG_IN_INFO = { NULL, /* init_proc */ NULL, /* quit_proc */ query, /* query_proc */ run /* run_proc */ }; /********************* Globals *******************/ /* This is needed to communicate the result from the dialog box button's callback function*/ static gint dialog_result = -1; struct config_tag { gint threshold; /* derivative comparison for edge detection */ direction_t direction; /* of wind, LEFT or RIGHT */ gint strength; /* how many pixels to bleed */ algorithm_t alg; /* which algorithm */ edge_t edge; /* controls abs, ne+ static guchar *preview_bits; + static GtkWidget *preview; gation of derivative */ }; typedef struct config_tag config_t; config_t config = { 10, /* threshold for derivative edge detection */ LEFT, /* bleed to the right */ 10, /* how many pixels to bleed */ RENDER_WIND, /* default algorithm */ LEADING /* abs(derivative); */ }; static guchar *preview_cache; static GtkWidget *preview; static gint preview_cache_rowstride; static gint preview_cache_bpp; MAIN () static void query (void) { static GimpParamDef args[] = { { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_INT32, "threshold", "Controls where blending will be done >= 0" }, { GIMP_PDB_INT32, "direction", "Left or Right: 0 or 1" }, { GIMP_PDB_INT32, "strength", "Controls the extent of the blending > 1" }, { GIMP_PDB_INT32, "alg", "WIND, BLAST" }, { GIMP_PDB_INT32, "edge", "LEADING, TRAILING, or BOTH" } }; gimp_install_procedure ("plug_in_wind", "Renders a wind effect.", "Renders a wind effect.", "Nigel Wetten", "Nigel Wetten", "May 2000", N_("/Filters/Distorts/Wind..."), "RGB*", GIMP_PLUGIN, G_N_ELEMENTS (args), 0, args, NULL); } static void run (gchar *name, gint nparams, GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get (param[2].data.d_drawable); gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1)); switch (run_mode) { case GIMP_RUN_NONINTERACTIVE: INIT_I18N(); if (nparams != 8) { status = GIMP_PDB_CALLING_ERROR; } else { config.threshold = param[3].data.d_int32; config.direction = param[4].data.d_int32; config.strength = param[5].data.d_int32; config.alg = param[6].data.d_int32; config.edge = param[7].data.d_int32; if (render_effect(drawable, 0) == -1) status = GIMP_PDB_EXECUTION_ERROR; } break; case GIMP_RUN_INTERACTIVE: INIT_I18N_UI(); gimp_get_data("plug_in_wind", &config); dialog_box(drawable); if (dialog_result == -1) { status = GIMP_PDB_EXECUTION_ERROR; break; } if (render_effect(drawable, 0) == -1) { status = GIMP_PDB_CALLING_ERROR; break; } g_free(preview_cache); gimp_set_data("plug_in_wind", &config, sizeof(config_t)); gimp_displays_flush(); break; case GIMP_RUN_WITH_LAST_VALS: INIT_I18N(); gimp_get_data("plug_in_wind", &config); if (render_effect (drawable, FALSE) == -1) { status = GIMP_PDB_EXECUTION_ERROR; gimp_message("An execution error occured."); } else { gimp_displays_flush (); } } gimp_drawable_detach(drawable); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; return; } static gint render_effect (GimpDrawable *drawable, gboolean preview_mode) { if (config.alg == RENDER_WIND) { render_wind (drawable, config.threshold, config.strength, config.direction, config.edge, preview_mode); } else if (config.alg == RENDER_BLAST) { render_blast (drawable, config.threshold, config.strength, config.direction, config.edge, preview_mode); } return 0; } static void preview_do_row(gint row, gint width, guchar *even, guchar *odd, guchar *src) { gint x; guchar *p0 = even; guchar *p1 = odd; gdouble r, g, b, a; gdouble c0, c1; for (x = 0; x < width; x++) { if (preview_cache_bpp == 4) { r = ((gdouble)src[x*4+0]) / 255.0; g = ((gdouble)src[x*4+1]) / 255.0; b = ((gdouble)src[x*4+2]) / 255.0; a = ((gdouble)src[x*4+3]) / 255.0; } else if (preview_cache_bpp == 3) { r = ((gdouble)src[x*3+0]) / 255.0; g = ((gdouble)src[x*3+1]) / 255.0; b = ((gdouble)src[x*3+2]) / 255.0; a = 1.0; } else { r = ((gdouble)src[x*preview_cache_bpp+0]) / 255.0; g = b = r; if (preview_cache_bpp == 2) a = ((gdouble)src[x*preview_cache_bpp+1]) / 255.0; else a = 1.0; } if ((x / GIMP_CHECK_SIZE) & 1) { c0 = GIMP_CHECK_LIGHT; c1 = GIMP_CHECK_DARK; } else { c0 = GIMP_CHECK_DARK; c1 = GIMP_CHECK_LIGHT; } *p0++ = (c0 + (r - c0) * a) * 255.0; *p0++ = (c0 + (g - c0) * a) * 255.0; *p0++ = (c0 + (b - c0) * a) * 255.0; *p1++ = (c1 + (r - c1) * a) * 255.0; *p1++ = (c1 + (g - c1) * a) * 255.0; *p1++ = (c1 + (b - c1) * a) * 255.0; } /* for */ if ((row / GIMP_CHECK_SIZE) & 1) { gtk_preview_draw_row (GTK_PREVIEW (preview), (guchar *)odd, 0, row, width); } else { gtk_preview_draw_row (GTK_PREVIEW (preview), (guchar *)even, 0, row, width); } } static void render_blast (GimpDrawable *drawable, gint threshold, gint strength, direction_t direction, edge_t edge, gboolean preview_mode) { gint x1, x2, y1, y2; gint width; gint height; gint bytes = drawable->bpp; guchar *buffer; GimpPixelRgn src_region, dest_region; gint row; gint row_stride; gint marker = 0; gint lpi; guchar *odd = NULL; guchar *even = NULL; if (preview_mode) { width = GTK_PREVIEW (preview)->buffer_width; height = GTK_PREVIEW (preview)->buffer_height; bytes = preview_cache_bpp; x1 = y1 = 0; x2 = width; y2 = height; row_stride = preview_cache_rowstride; even = g_malloc (width * 3); odd = g_malloc (width * 3); } else { gimp_progress_init( _("Rendering Blast...")); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); width = x2 - x1; height = y2 - y1; gimp_pixel_rgn_init (&src_region, drawable, x1, y1, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dest_region, drawable, x1, y1, width, height, TRUE, TRUE); row_stride = width * bytes; } lpi = row_stride - bytes; buffer = (guchar *) g_malloc (row_stride); for (row = y1; row < y2; row++) { if (preview_mode) memcpy (buffer, preview_cache + (row * row_stride), row_stride); else gimp_pixel_rgn_get_row (&src_region, buffer, x1, row, width); if (direction == RIGHT) { reverse_buffer (buffer, row_stride, bytes); } marker = render_blast_row (buffer, bytes, lpi, threshold, strength, edge); if (direction == RIGHT) { reverse_buffer (buffer, row_stride, bytes); } if (preview_mode) { preview_do_row(row,width,even,odd,buffer); } else { gimp_pixel_rgn_set_row (&dest_region, buffer, x1, row, width); gimp_progress_update ((double) (row - y1)/ (double) (height)); } if (marker) { gint j, limit; limit = 1 + rand () % 2; for (j = 0; (j < limit) && (row < y2); j++) { row++; if (row < y2) { if (preview_mode) { memcpy (buffer, preview_cache + (row * row_stride), row_stride); preview_do_row(row,width,even,odd,buffer); } else { gimp_pixel_rgn_get_row (&src_region, buffer, x1, row, width); gimp_pixel_rgn_set_row (&dest_region, buffer, x1, row, width); } } } marker = 0; } } if(even) g_free(even); if(odd) g_free(odd); g_free(buffer); /* update the region */ if (preview_mode) { gtk_widget_queue_draw (preview); } else { gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1); } return; } static void render_wind (GimpDrawable *drawable, gint threshold, gint strength, direction_t direction, edge_t edge, gboolean preview_mode) { GimpPixelRgn src_region, dest_region; gint width; gint height; gint bytes; gint row_stride; gint comp_stride; gint row; guchar *sb; gint lpi; gint x1, y1, x2, y2; guchar *odd = NULL; guchar *even = NULL; if (preview_mode) { width = GTK_PREVIEW (preview)->buffer_width; height = GTK_PREVIEW (preview)->buffer_height; bytes = preview_cache_bpp; x1 = y1 = 0; x2 = width; y2 = height; row_stride = preview_cache_rowstride; even = g_malloc (width * 3); odd = g_malloc (width * 3); } else { gimp_progress_init( _("Rendering Wind...")); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); bytes = drawable->bpp; width = x2 - x1; height = y2 - y1; gimp_pixel_rgn_init (&src_region, drawable, x1, y1, width, height, FALSE, FALSE); gimp_pixel_rgn_init (&dest_region, drawable, x1, y1, width, height, TRUE, TRUE); row_stride = width * bytes; } comp_stride = bytes * COMPARE_WIDTH; lpi = row_stride - comp_stride; sb = g_malloc (row_stride); for (row = y1; row < y2; row++) { if (preview_mode) memcpy (sb, preview_cache + (row * row_stride), row_stride); else gimp_pixel_rgn_get_row (&src_region, sb, x1, row, width); if (direction == RIGHT) reverse_buffer (sb, row_stride, bytes); render_wind_row (sb, bytes, lpi, threshold, strength, edge); if (direction == RIGHT) reverse_buffer(sb, row_stride, bytes); if (preview_mode) { preview_do_row(row,width,even,odd,sb); } else { gimp_pixel_rgn_set_row (&dest_region, sb, x1, row, width); gimp_progress_update ((double) (row - y1)/ (double) (height)); } } if(even) g_free(even); if(odd) g_free(odd); g_free(sb); /* update the region */ if (preview_mode) { gtk_widget_queue_draw (preview); } else { gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, x2 - x1, y2 - y1); } return; } static gint render_blast_row (guchar *buffer, gint bytes, gint lpi, gint threshold, gint strength, edge_t edge) { gint Ri, Gi, Bi, Ai= 0; gint sbi, lbi; gint bleed_length; gint i, j; gint weight, random_factor; gint skip = 0; for (j = 0; j < lpi; j += bytes) { Ri = j; Gi = j + 1; Bi = j + 2; if(bytes > 3) Ai = j + 3; if (threshold_exceeded(buffer+Ri, buffer+Ri+bytes, edge, threshold, (bytes > 3))) { /* we have found an edge, do bleeding */ sbi = Ri; weight = rand() % 10; if (weight > 5) { random_factor = 2; } else if (weight > 3) { random_factor = 3; } else { random_factor = 4; } bleed_length = 0; switch (rand() % random_factor) { case 3: bleed_length += strength; /* fall through to add up multiples of strength */ case 2: bleed_length += strength; /* fall through */ case 1: bleed_length += strength; /* fall through */ case 0: bleed_length += strength; /* fall through */ } lbi = sbi + bytes * bleed_length; if (lbi > lpi) { lbi = lpi; } for (i = sbi; i < lbi; i += bytes) { buffer[i] = buffer[Ri]; buffer[i+1] = buffer[Gi]; buffer[i+2] = buffer[Bi]; if(bytes > 3) buffer[i+3] = buffer[Ai]; } j = lbi - bytes; if ((rand() % 10) > 7) { skip = 1; } } } return skip; } static void render_wind_row (guchar *sb, gint bytes, gint lpi, gint threshold, gint strength, edge_t edge) { gint i, j; gint bleed_length; gint blend_amt_R, blend_amt_G, blend_amt_B, blend_amt_A = 0 ; gint blend_colour_R, blend_colour_G, blend_colour_B, blend_colour_A = 0 ; gint target_colour_R, target_colour_G, target_colour_B, target_colour_A = 0; gdouble bleed_length_max; gint bleed_variation; gint n; gint sbi; /* starting bleed index */ gint lbi; /* last bleed index */ gdouble denominator; gint comp_stride = bytes * COMPARE_WIDTH; for (j = 0; j < lpi; j += bytes) { gint Ri = j; gint Gi = j + 1; gint Bi = j + 2; gint Ai = 0; if(bytes > 3) Ai = j + 3; if (threshold_exceeded(sb+Ri, sb+Ri+comp_stride, edge, threshold,(bytes > 3))) { /* we have found an edge, do bleeding */ sbi = Ri + comp_stride; blend_colour_R = sb[Ri]; blend_colour_G = sb[Gi]; blend_colour_B = sb[Bi]; target_colour_R = sb[sbi]; target_colour_G = sb[sbi+1]; target_colour_B = sb[sbi+2]; bleed_length_max = strength; if(bytes > 3) { blend_colour_A = sb[Ai]; target_colour_A = sb[sbi+3]; } if (rand() % 3) /* introduce weighted randomness */ { bleed_length_max = strength; } else { bleed_length_max = 4 * strength; } bleed_variation = 1 + (gint) (bleed_length_max * rand() / (G_MAXRAND + 1.0)); lbi = sbi + bleed_variation * bytes; if (lbi > lpi) { lbi = lpi; /* stop overunning the buffer */ } bleed_length = bleed_variation; blend_amt_R = target_colour_R - blend_colour_R; blend_amt_G = target_colour_G - blend_colour_G; blend_amt_B = target_colour_B - blend_colour_B; if(bytes > 3) { blend_amt_A = target_colour_A - blend_colour_A; } denominator = bleed_length * bleed_length + bleed_length; denominator = 2.0 / denominator; n = bleed_length; for (i = sbi; i < lbi; i += bytes) { /* check against original colour */ if (!threshold_exceeded(sb+Ri, sb+i, edge, threshold,(bytes>3)) && (rand() % 2)) { break; } blend_colour_R += blend_amt_R * n * denominator; blend_colour_G += blend_amt_G * n * denominator; blend_colour_B += blend_amt_B * n * denominator; if(bytes > 3) { blend_colour_A += blend_amt_A * n * denominator; if (blend_colour_A > 255) blend_colour_A = 255; else if (blend_colour_A < 0) blend_colour_A = 0; } if (blend_colour_R > 255) blend_colour_R = 255; else if (blend_colour_R < 0) blend_colour_R = 0; if (blend_colour_G > 255) blend_colour_G = 255; else if (blend_colour_G < 0) blend_colour_G = 0; if (blend_colour_B > 255) blend_colour_B = 255; else if (blend_colour_B < 0) blend_colour_B = 0; sb[i] = (blend_colour_R * 2 + sb[i]) / 3; sb[i+1] = (blend_colour_G * 2 + sb[i+1]) / 3; sb[i+2] = (blend_colour_B * 2 + sb[i+2]) / 3; if(bytes > 3) sb[i+3] = (blend_colour_A * 2 + sb[i+3]) / 3; if (threshold_exceeded(sb+i, sb+i+comp_stride, BOTH, threshold,(bytes>3))) { target_colour_R = sb[i+comp_stride]; target_colour_G = sb[i+comp_stride+1]; target_colour_B = sb[i+comp_stride+2]; if(bytes > 3) target_colour_A = sb[i+comp_stride+3]; blend_amt_R = target_colour_R - blend_colour_R; blend_amt_G = target_colour_G - blend_colour_G; blend_amt_B = target_colour_B - blend_colour_B; if(bytes > 3) blend_amt_A = target_colour_A - blend_colour_A; denominator = n * n + n; denominator = 2.0 / denominator; } n--; } } } return; } static gint threshold_exceeded (guchar *pixel_R1, guchar *pixel_R2, edge_t edge, gint threshold, gboolean has_alpha) { gint derivative_R, derivative_G, derivative_B, derivative_A; gint return_value; get_derivative(pixel_R1, pixel_R2, edge, has_alpha, &derivative_R, &derivative_G, &derivative_B, &derivative_A); if(((derivative_R + derivative_G + derivative_B + derivative_A) / 4) > threshold) { return_value = 1; } else { return_value = 0; } return return_value; } static void get_derivative (guchar *pixel_R1, guchar *pixel_R2, edge_t edge, gboolean has_alpha, gint *derivative_R, gint *derivative_G, gint *derivative_B, gint *derivative_A) { guchar *pixel_G1 = pixel_R1 + 1; guchar *pixel_B1 = pixel_R1 + 2; guchar *pixel_G2 = pixel_R2 + 1; guchar *pixel_B2 = pixel_R2 + 2; guchar *pixel_A1; guchar *pixel_A2; if(has_alpha) { pixel_A1 = pixel_R1 + 3; pixel_A2 = pixel_R2 + 3; *derivative_A = *pixel_A2 - *pixel_A1; } else { *derivative_A = 0; } *derivative_R = *pixel_R2 - *pixel_R1; *derivative_G = *pixel_G2 - *pixel_G1; *derivative_B = *pixel_B2 - *pixel_B1; if (edge == BOTH) { *derivative_R = abs(*derivative_R); *derivative_G = abs(*derivative_G); *derivative_B = abs(*derivative_B); *derivative_A = abs(*derivative_A); } else if (edge == LEADING) { *derivative_R = -(*derivative_R); *derivative_G = -(*derivative_G); *derivative_B = -(*derivative_B); *derivative_A = -(*derivative_A); } else if (edge == TRAILING) { /* no change needed */ } return; } static void reverse_buffer (guchar *buffer, gint length, gint bytes) { gint i, si; gint temp; gint midpoint; midpoint = length / 2; for (i = 0; i < midpoint; i += bytes) { si = length - bytes - i; temp = buffer[i]; buffer[i] = buffer[si]; buffer[si] = (guchar) temp; temp = buffer[i+1]; buffer[i+1] = buffer[si+1]; buffer[si+1] = (guchar) temp; temp = buffer[i+2]; buffer[i+2] = buffer[si+2]; buffer[si+2] = (guchar) temp; if(bytes > 3) { temp = buffer[i+3]; buffer[i+3] = buffer[si+3]; buffer[si+3] = (guchar) temp; } } return; } /*************************************************** GUI ***************************************************/ static void ok_callback (GtkWidget *widget, gpointer data) { /* we have to stop the dialog from being closed with strength < 1 */ /* since we use spinbuttons this should never happen ... */ if (config.strength < 1) { g_message (_("Wind Strength must be greater than 0.")); } else { dialog_result = 1; gtk_widget_destroy (GTK_WIDGET (data)); } } static void radio_callback (GtkWidget *widget, gpointer data) { GimpDrawable *drawable; gimp_radio_button_update (widget, data); if (GTK_TOGGLE_BUTTON (widget)->active) { drawable = g_object_get_data (G_OBJECT (widget), "drawable"); if (drawable != NULL) render_effect (drawable, TRUE); } } static void dialog_box (GimpDrawable *drawable) { GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *abox; GtkWidget *table; GtkObject *adj; GtkWidget *frame; GtkWidget *dlg; GtkWidget *style1; GtkWidget *style2; GtkWidget *dir1; GtkWidget *dir2; GtkWidget *edge1; GtkWidget *edge2; GtkWidget *edge3; gimp_ui_init ("wind", TRUE); dlg = gimp_dialog_new ( _("Wind"), "wind", gimp_standard_help_func, "filters/wind.html", GTK_WIN_POS_MOUSE, FALSE, TRUE, FALSE, GTK_STOCK_CANCEL, gtk_widget_destroy, NULL, 1, NULL, FALSE, TRUE, GTK_STOCK_OK, ok_callback, NULL, NULL, NULL, TRUE, FALSE, NULL); g_signal_connect (G_OBJECT (dlg), "destroy", G_CALLBACK (gtk_main_quit), NULL); /* init tooltips */ gimp_help_init (); vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gtk_frame_new (_("Preview")); gtk_container_set_border_width (GTK_CONTAINER (frame), 6); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_container_set_border_width (GTK_CONTAINER (abox), 4); gtk_container_add (GTK_CONTAINER (frame), abox); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); preview = preview_widget (drawable); /* we are here */ gtk_container_add (GTK_CONTAINER (frame), preview); render_effect (drawable, TRUE); /* render preview image */ gtk_widget_show (preview); frame = gtk_frame_new (_("Parameter Settings")); gtk_container_set_border_width (GTK_CONTAINER (frame), 6); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); main_vbox = gtk_vbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6); gtk_container_add (GTK_CONTAINER (frame), main_vbox); gtk_widget_show (main_vbox); /***************************************************** outer frame and table ***************************************************/ table = gtk_table_new (1, 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 (main_vbox), table, FALSE, FALSE, 0); /********************************************************* radio buttons for choosing wind rendering algorithm ******************************************************/ frame = gimp_radio_group_new2 (TRUE, _("Style"), G_CALLBACK (radio_callback), &config.alg, GINT_TO_POINTER (config.alg), _("Wind"), GINT_TO_POINTER (RENDER_WIND), &style1, _("Blast"), GINT_TO_POINTER (RENDER_BLAST), &style2, NULL); g_object_set_data (G_OBJECT (style1), "drawable", drawable); g_object_set_data (G_OBJECT (style2), "drawable", drawable); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); gtk_widget_show (frame); /****************************************************** radio buttons for choosing LEFT or RIGHT **************************************************/ frame = gimp_radio_group_new2 (TRUE, _("Direction"), G_CALLBACK (radio_callback), &config.direction, GINT_TO_POINTER (config.direction), _("Left"), GINT_TO_POINTER (LEFT), &dir1, _("Right"), GINT_TO_POINTER (RIGHT), &dir2, NULL); g_object_set_data (G_OBJECT (dir1), "drawable", drawable); g_object_set_data (G_OBJECT (dir2), "drawable", drawable); gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); gtk_widget_show (frame); /***************************************************** radio buttons for choosing BOTH, LEADING, TRAILING ***************************************************/ frame = gimp_radio_group_new2 (TRUE, _("Edge Affected"), G_CALLBACK (radio_callback), &config.edge, GINT_TO_POINTER (config.edge), _("Leading"), GINT_TO_POINTER (LEADING), &edge1, _("Trailing"), GINT_TO_POINTER (TRAILING), &edge2, _("Both"), GINT_TO_POINTER (BOTH), &edge3, NULL); g_object_set_data (G_OBJECT (edge1), "drawable", drawable); g_object_set_data (G_OBJECT (edge2), "drawable", drawable); g_object_set_data (G_OBJECT (edge3), "drawable", drawable); gtk_table_attach (GTK_TABLE (table), frame, 2, 3, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0); gtk_widget_show (frame); gtk_widget_show (table); /**************************************************** table for sliders ****************************************************/ 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 (main_vbox), table, FALSE, FALSE, 0); /***************************************************** slider and entry for threshold ***************************************************/ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Threshold:"), SCALE_WIDTH, 0, config.threshold, MIN_THRESHOLD, MAX_THRESHOLD, 1.0, 10, 0, TRUE, 0, 0, _("Higher values restrict the effect to fewer areas of the image"), NULL); g_signal_connect (G_OBJECT (adj), "value_changed", G_CALLBACK (gimp_int_adjustment_update), &config.threshold); g_signal_connect_swapped (G_OBJECT (adj), "value_changed", G_CALLBACK (render_effect), drawable); /***************************************************** slider and entry for strength of wind ****************************************************/ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("Strength:"), SCALE_WIDTH, 0, config.strength, MIN_STRENGTH, MAX_STRENGTH, 1.0, 10.0, 0, TRUE, 0, 0, _("Higher values increase the magnitude of the effect"), NULL); g_signal_connect (G_OBJECT (adj), "value_changed", G_CALLBACK (gimp_int_adjustment_update), &config.strength); g_signal_connect_swapped (G_OBJECT (adj), "value_changed", G_CALLBACK (render_effect), drawable); gtk_widget_show (table); gtk_widget_show (dlg); gtk_main (); gimp_help_free (); gdk_flush (); } static GtkWidget * preview_widget (GimpDrawable *drawable) { gint size; preview = gtk_preview_new (GTK_PREVIEW_COLOR); fill_preview (preview, drawable); size = GTK_PREVIEW (preview)->rowstride * GTK_PREVIEW (preview)->buffer_height; return preview; } static void fill_preview (GtkWidget *widget, GimpDrawable *drawable) { GimpPixelRgn srcPR; gint width; gint height; gint x1, x2, y1, y2; gint bpp; gint y; guchar *src; guchar *even, *odd; gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); if (x2 - x1 > PREVIEW_SIZE) x2 = x1 + PREVIEW_SIZE; if (y2 - y1 > PREVIEW_SIZE) y2 = y1 + PREVIEW_SIZE; width = x2 - x1; height = y2 - y1; bpp = gimp_drawable_bpp (drawable->drawable_id); if (width < 1 || height < 1) return; gtk_preview_size (GTK_PREVIEW (widget), width, height); gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, x2, y2, FALSE, FALSE); even = g_malloc (width * 3); odd = g_malloc (width * 3); src = g_malloc (width * bpp); preview_cache = g_malloc(width * bpp * height); preview_cache_rowstride = width * bpp; preview_cache_bpp = bpp; for (y = 0; y < height; y++) { gimp_pixel_rgn_get_row (&srcPR, src, x1, y + y1, width); memcpy(preview_cache + (y*width*bpp),src,width*bpp); } for (y = 0; y < height; y++) { preview_do_row(y,width,even,odd,preview_cache + (y*width*bpp)); } g_free (even); g_free (odd); g_free (src); }