From 3c57dd931145d43f2b0aef96c4d178135956bf91 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 05:13:10 +0200 Subject: Adding upstream version 2.10.36. Signed-off-by: Daniel Baumann --- plug-ins/common/curve-bend.c | 3402 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3402 insertions(+) create mode 100644 plug-ins/common/curve-bend.c (limited to 'plug-ins/common/curve-bend.c') diff --git a/plug-ins/common/curve-bend.c b/plug-ins/common/curve-bend.c new file mode 100644 index 0000000..dfa9ff7 --- /dev/null +++ b/plug-ins/common/curve-bend.c @@ -0,0 +1,3402 @@ +/* curve_bend plugin for GIMP */ + +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 3 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, see . + */ + +/* Revision history + * (2004/02/08) v1.3.18 hof: #133244 exit with execution error if there is + * an empty selection + * (2003/08/24) v1.3.18 hof: #119937 show busy cursor when recalculating + * preview + * (2002/09/xx) v1.1.18 mitch and gsr: clean interface + * (2000/02/16) v1.1.17b hof: added spinbuttons for rotate entry + * (2000/02/16) v1.1.17 hof: undo bugfix (#6012) + * don't call gimp_undo_push_group_end + * after gimp_displays_flush + * (1999/09/13) v1.01 hof: PDB-calls updated for gimp 1.1.9 + * (1999/05/10) v1.0 hof: first public release + * (1999/04/23) v0.0 hof: coding started, + * splines and dialog parts are similar to curves.c + */ + +#include "config.h" + +#include +#include +#include + +#include + +#include +#include + +#include "libgimp/stdplugins-intl.h" + + +/* Defines */ +#define PLUG_IN_PROC "plug-in-curve-bend" +#define PLUG_IN_BINARY "curve-bend" +#define PLUG_IN_ROLE "gimp-curve-bend" +#define PLUG_IN_VERSION "v1.3.18 (2003/08/26)" +#define PLUG_IN_IMAGE_TYPES "RGB*, GRAY*" +#define PLUG_IN_AUTHOR "Wolfgang Hofer (hof@hotbot.com)" +#define PLUG_IN_COPYRIGHT "Wolfgang Hofer" + +#define PLUG_IN_ITER_NAME "plug_in_curve_bend_Iterator" +#define PLUG_IN_DATA_ITER_FROM "plug_in_curve_bend_ITER_FROM" +#define PLUG_IN_DATA_ITER_TO "plug_in_curve_bend_ITER_TO" + +#define KEY_POINTFILE "POINTFILE_CURVE_BEND" +#define KEY_POINTS "POINTS" +#define KEY_VAL_Y "VAL_Y" + +#define MIDDLE 127 + +#define MIX_CHANNEL(a, b, m) (((a * m) + (b * (255 - m))) / 255) + +#define UP_GRAPH 0x1 +#define UP_PREVIEW_EXPOSE 0x4 +#define UP_PREVIEW 0x8 +#define UP_DRAW 0x10 +#define UP_ALL 0xFF + +#define GRAPH_WIDTH 256 +#define GRAPH_HEIGHT 256 +#define PREVIEW_SIZE_X 256 +#define PREVIEW_SIZE_Y 256 +#define PV_IMG_WIDTH 128 +#define PV_IMG_HEIGHT 128 +#define RADIUS 3 +#define MIN_DISTANCE 8 +#define PREVIEW_BPP 4 + +#define SMOOTH 0 +#define GFREE 1 + +#define GRAPH_MASK GDK_EXPOSURE_MASK | \ + GDK_POINTER_MOTION_MASK | \ + GDK_POINTER_MOTION_HINT_MASK | \ + GDK_ENTER_NOTIFY_MASK | \ + GDK_BUTTON_PRESS_MASK | \ + GDK_BUTTON_RELEASE_MASK | \ + GDK_BUTTON1_MOTION_MASK + + +#define OUTLINE_UPPER 0 +#define OUTLINE_LOWER 1 + +typedef struct _BenderValues BenderValues; +struct _BenderValues +{ + guchar curve[2][256]; /* for curve_type freehand mode 0 <= curve <= 255 */ + gdouble points[2][17][2]; /* for curve_type smooth mode 0.0 <= points <= 1.0 */ + + gint curve_type; + + gint smoothing; + gint antialias; + gint work_on_copy; + gdouble rotation; + + gint32 total_steps; + gdouble current_step; +}; + +typedef struct _Curves Curves; + +struct _Curves +{ + int x, y; /* coords for last mouse click */ +}; + +typedef struct _BenderDialog BenderDialog; + +struct _BenderDialog +{ + GtkWidget *shell; + GtkWidget *outline_menu; + GtkWidget *pv_widget; + GtkWidget *graph; + GtkAdjustment *rotate_data; + GdkPixmap *pixmap; + GtkWidget *filechooser; + + GdkCursor *cursor_busy; + + gint32 drawable_id; + int color; + int outline; + gint preview; + + int grab_point; + int last; + int leftmost; + int rightmost; + int curve_type; + gdouble points[2][17][2]; /* 0.0 <= points <= 1.0 */ + guchar curve[2][256]; /* 0 <= curve <= 255 */ + gint32 *curve_ptr[2]; /* 0 <= curve_ptr <= src_drawable_width + * both arrays are allocated dynamic, + * depending on drawable width + */ + gint32 min2[2]; + gint32 max2[2]; + gint32 zero2[2]; + + gboolean show_progress; + gboolean smoothing; + gboolean antialias; + gboolean work_on_copy; + gdouble rotation; + + gint32 preview_image_id; + gint32 preview_layer_id1; + gint32 preview_layer_id2; + + BenderValues *bval_from; + BenderValues *bval_to; + BenderValues *bval_curr; + + gboolean run; +}; + +/* points Coords: + * + * 1.0 +----+----+----+----+ + * | . | | | + * +--.-+--.-+----+----+ + * . | . | | + * 0.5 +----+----+-.--+----+ + * | | | . . + * +----+----+----+-.-.+ + * | | | | | + * 0.0 +----+----+----+----+ + * 0.0 0.5 1.0 + * + * curve Coords: + * + * OUTLINE_UPPER OUTLINE_LOWER + * + * 255 +----+----+----+----+ 255 +----+----+----+----+ + * | . | | | --- max | . | | | --- max + * +--.-+--.-+----+----+ +--.-+--.-+----+----+ + * . | . | | zero ___ . | . | | + * +----+----+-.--+----+ +----+----+-.--+----+ + * | | | . . --- zero | | | . . + * +----+----+----+-.-.+ ___ min +----+----+----+-.-.+ ___ min + * | | | | | | | | | | + * 0 +----+----+----+----+ 0 +----+----+----+----+ + * 0 255 0 255 + */ + +typedef double CRMatrix[4][4]; + +typedef struct +{ + guint32 drawable_id; + gint width; + gint height; + GeglBuffer *buffer; + const Babl *format; + gint x1; + gint y1; + gint x2; + gint y2; + gint index_alpha; /* 0 == no alpha, 1 == GREYA, 3 == RGBA */ + gint bpp; + gint tile_width; + gint tile_height; +} t_GDRW; + +typedef struct +{ + gint32 y; + guchar color[4]; +} t_Last; + + +/* curves action functions */ +static void query (void); +static void run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals); + +static BenderDialog * bender_new_dialog (gint32 drawable_id); +static void bender_update (BenderDialog *, + int); +static void bender_plot_curve (BenderDialog *, + int, + int, + int, + int, + gint32, + gint32, + gint); +static void bender_calculate_curve (BenderDialog *, + gint32, + gint32, + gint); +static void bender_rotate_adj_callback (GtkAdjustment *, + gpointer); +static void bender_border_callback (GtkWidget *, + gpointer); +static void bender_type_callback (GtkWidget *, + gpointer); +static void bender_reset_callback (GtkWidget *, + gpointer); +static void bender_copy_callback (GtkWidget *, + gpointer); +static void bender_copy_inv_callback (GtkWidget *, + gpointer); +static void bender_swap_callback (GtkWidget *, + gpointer); +static void bender_response (GtkWidget *, + gint, + BenderDialog *); +static void bender_smoothing_callback (GtkWidget *, + gpointer); +static void bender_antialias_callback (GtkWidget *, + gpointer); +static void bender_work_on_copy_callback (GtkWidget *, + gpointer); +static void bender_preview_update (GtkWidget *, + gpointer); +static void bender_preview_update_once (GtkWidget *, + gpointer); +static void bender_load_callback (GtkWidget *, + BenderDialog *); +static void bender_save_callback (GtkWidget *, + BenderDialog *); +static gint bender_graph_events (GtkWidget *, + GdkEvent *, + BenderDialog *); +static void bender_CR_compose (CRMatrix, + CRMatrix, + CRMatrix); +static void bender_init_min_max (BenderDialog *, + gint32); +static BenderDialog * do_dialog (gint32 drawable_id); +static void p_init_gdrw (t_GDRW *gdrw, + gint32 drawable_id, + int shadow); +static void p_end_gdrw (t_GDRW *gdrw); +static gint32 p_main_bend (BenderDialog *cd, + guint32, + gint); +static gint32 p_create_pv_image (gint32 src_drawable_id, + gint32 *layer_id); +static void p_render_preview (BenderDialog *cd, + gint32 layer_id); +static void p_get_pixel (t_GDRW *gdrw, + gint32 x, + gint32 y, + guchar *pixel); +static void p_put_pixel (t_GDRW *gdrw, + gint32 x, + gint32 y, + guchar *pixel); +static void p_put_mix_pixel (t_GDRW *gdrw, + gint32 x, + gint32 y, + guchar *color, + gint32 nb_curvy, + gint32 nb2_curvy, + gint32 curvy); +static void p_stretch_curves (BenderDialog *cd, + gint32 xmax, + gint32 ymax); +static void p_cd_to_bval (BenderDialog *cd, + BenderValues *bval); +static void p_cd_from_bval (BenderDialog *cd, + BenderValues *bval); +static void p_store_values (BenderDialog *cd); +static void p_retrieve_values (BenderDialog *cd); +static void p_bender_calculate_iter_curve (BenderDialog *cd, + gint32 xmax, + gint32 ymax); +static void p_delta_gdouble (double *val, + double val_from, + double val_to, + gint32 total_steps, + gdouble current_step); +static void p_delta_gint32 (gint32 *val, + gint32 val_from, + gint32 val_to, + gint32 total_steps, + gdouble current_step); +static void p_copy_points (BenderDialog *cd, + int outline, + int xy, + int argc, + gdouble *floatarray); +static void p_copy_yval (BenderDialog *cd, + int outline, + int argc, + guint8 *int8array); +static int p_save_pointfile (BenderDialog *cd, + const gchar *filename); + + +/* Global Variables */ +const GimpPlugInInfo PLUG_IN_INFO = +{ + NULL, /* init_proc */ + NULL, /* quit_proc */ + query, /* query_proc */ + run /* run_proc */ +}; + +static CRMatrix CR_basis = +{ + { -0.5, 1.5, -1.5, 0.5 }, + { 1.0, -2.5, 2.0, -0.5 }, + { -0.5, 0.0, 0.5, 0.0 }, + { 0.0, 1.0, 0.0, 0.0 }, +}; + +static int gb_debug = FALSE; + +/* Functions */ +/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX PDB_STUFF XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */ + +#ifdef ROTATE_OPTIMIZE + +/* ============================================================================ + * p_pdb_procedure_available + * if requested procedure is available in the PDB return the number of args + * (0 upto n) that are needed to call the procedure. + * if not available return -1 + * ============================================================================ + */ + +static gint +p_pdb_procedure_available (const gchar *proc_name) +{ + gint nparams; + gint nreturn_vals; + GimpPDBProcType proc_type; + gchar *proc_blurb; + gchar *proc_help; + gchar *proc_author; + gchar *proc_copyright; + gchar *proc_date; + GimpParamDef *params; + GimpParamDef *return_vals; + gint rc; + + rc = 0; + + /* Query the gimp application's procedural database + * regarding a particular procedure. + */ + if (gimp_procedural_db_proc_info (proc_name, + &proc_blurb, + &proc_help, + &proc_author, + &proc_copyright, + &proc_date, + &proc_type, + &nparams, &nreturn_vals, + ¶ms, &return_vals)) + { + /* procedure found in PDB */ + return nparams; + } + + g_printerr ("Warning: Procedure %s not found.\n", proc_name); + return -1; +} + +#endif /* ROTATE_OPTIMIZE */ + +static gint +p_gimp_rotate (gint32 image_id, + gint32 drawable_id, + gint32 interpolation, + gdouble angle_deg) +{ + gdouble angle_rad; + gint rc; + +#ifdef ROTATE_OPTIMIZE + static gchar *rotate_proc = "plug-in-rotate"; + GimpParam *return_vals; + gint nreturn_vals; + gint32 angle_step; + gint nparams; + + if (angle_deg == 90.0) { angle_step = 1; } + else if(angle_deg == 180.0) { angle_step = 2; } + else if(angle_deg == 270.0) { angle_step = 3; } + else { angle_step = 0; } + + if (angle_step != 0) + { + nparams = p_pdb_procedure_available (rotate_proc); + if (nparams == 5) + { + /* use faster rotate plugin on multiples of 90 degrees */ + return_vals = gimp_run_procedure (rotate_proc, + &nreturn_vals, + GIMP_PDB_INT32, GIMP_RUN_NONINTERACTIVE, + GIMP_PDB_IMAGE, image_id, + GIMP_PDB_DRAWABLE, drawable_id, + GIMP_PDB_INT32, angle_step, + GIMP_PDB_INT32, FALSE, /* don't rotate the whole image */ + GIMP_PDB_END); + + if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS) + { + return 0; + } + } + } +#endif /* ROTATE_OPTIMIZE */ + + angle_rad = (angle_deg * G_PI) / 180.0; + + gimp_context_push (); + if (! interpolation) + gimp_context_set_interpolation (GIMP_INTERPOLATION_NONE); + gimp_context_set_transform_resize (GIMP_TRANSFORM_RESIZE_ADJUST); + rc = gimp_item_transform_rotate (drawable_id, + angle_rad, + TRUE /*auto_center*/, + -1.0 /*center_x*/, + -1.0 /*center_y*/); + gimp_context_pop (); + + if (rc == -1) + g_printerr ("Error: gimp_drawable_transform_rotate_default call failed\n"); + + return rc; +} + +/* ============================================================================ + * p_if_selection_float_it + * ============================================================================ + */ + +static gint32 +p_if_selection_float_it (gint32 image_id, + gint32 layer_id) +{ + if (! gimp_layer_is_floating_sel (layer_id)) + { + gint32 sel_channel_id; + gint32 x1, x2, y1, y2; + gint32 non_empty; + + /* check and see if we have a selection mask */ + sel_channel_id = gimp_image_get_selection (image_id); + + gimp_selection_bounds (image_id, &non_empty, &x1, &y1, &x2, &y2); + + if (non_empty && sel_channel_id >= 0) + { + /* selection is TRUE, make a layer (floating selection) from + the selection */ + if (gimp_edit_copy (layer_id)) + { + layer_id = gimp_edit_paste (layer_id, FALSE); + } + else + { + return -1; + } + } + } + + return layer_id; +} + +/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX END_PDB_STUFF XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */ + +/* + * M M AAAAA IIIIII N N + * M M M M A A II NN N + * M M M AAAAAAA II N N N + * M M A A II N NN + * M M A A IIIIII N N + */ + +MAIN () + +static void +query (void) +{ + static const GimpParamDef args[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }"}, + { GIMP_PDB_IMAGE, "image", "Input image" }, + { GIMP_PDB_DRAWABLE, "drawable", "Input drawable (must be a layer without layermask)"}, + { GIMP_PDB_FLOAT, "rotation", "Direction {angle 0 to 360 degree } of the bend effect"}, + { GIMP_PDB_INT32, "smoothing", "Smoothing { TRUE, FALSE }"}, + { GIMP_PDB_INT32, "antialias", "Antialias { TRUE, FALSE }"}, + { GIMP_PDB_INT32, "work-on-copy", "{ TRUE, FALSE } TRUE: copy the drawable and bend the copy"}, + { GIMP_PDB_INT32, "curve-type", " { 0, 1 } 0 == smooth (use 17 points), 1 == freehand (use 256 val_y) "}, + { GIMP_PDB_INT32, "argc-upper-point-x", "{2 <= argc <= 17} "}, + { GIMP_PDB_FLOATARRAY, "upper-point-x", "array of 17 x point_koords { 0.0 <= x <= 1.0 or -1 for unused point }"}, + { GIMP_PDB_INT32, "argc-upper-point-y", "{2 <= argc <= 17} "}, + { GIMP_PDB_FLOATARRAY, "upper-point-y", "array of 17 y point_koords { 0.0 <= y <= 1.0 or -1 for unused point }"}, + { GIMP_PDB_INT32, "argc-lower_point-x", "{2 <= argc <= 17} "}, + { GIMP_PDB_FLOATARRAY, "lower-point-x", "array of 17 x point_koords { 0.0 <= x <= 1.0 or -1 for unused point }"}, + { GIMP_PDB_INT32, "argc-lower-point-y", "{2 <= argc <= 17} "}, + { GIMP_PDB_FLOATARRAY, "lower_point_y", "array of 17 y point_koords { 0.0 <= y <= 1.0 or -1 for unused point }"}, + { GIMP_PDB_INT32, "argc-upper-val-y", "{ 256 } "}, + { GIMP_PDB_INT8ARRAY, "upper-val-y", "array of 256 y freehand koord { 0 <= y <= 255 }"}, + { GIMP_PDB_INT32, "argc-lower-val-y", "{ 256 } "}, + { GIMP_PDB_INT8ARRAY, "lower-val-y", "array of 256 y freehand koord { 0 <= y <= 255 }"} + }; + + static const GimpParamDef return_vals[] = + { + { GIMP_PDB_LAYER, "bent-layer", "the handled layer" } + }; + + static const GimpParamDef args_iter[] = + { + { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-NONINTERACTIVE (1) }" }, + { GIMP_PDB_INT32, "total-steps", "total number of steps (# of layers-1 to apply the related plug-in)" }, + { GIMP_PDB_FLOAT, "current-step", "current (for linear iterations this is the layerstack position, otherwise some value in between)" }, + { GIMP_PDB_INT32, "len-struct", "length of stored data structure with id is equal to the plug_in proc_name" }, + }; + + /* the actual installation of the bend plugin */ + gimp_install_procedure (PLUG_IN_PROC, + N_("Bend the image using two control curves"), + "This plug-in does bend the active layer " + "If there is a current selection it is copied to " + "floating selection and the curve_bend distortion " + "is done on the floating selection. If " + "work_on_copy parameter is TRUE, the curve_bend " + "distortion is done on a copy of the active layer " + "(or floating selection). The upper and lower edges " + "are bent in shape of 2 spline curves. both (upper " + "and lower) curves are determined by upto 17 points " + "or by 256 Y-Values if curve_type == 1 (freehand " + "mode) If rotation is not 0, the layer is rotated " + "before and rotated back after the bend operation. " + "This enables bending in other directions than " + "vertical. bending usually changes the size of " + "the handled layer. this plug-in sets the offsets " + "of the handled layer to keep its center at the " + "same position", + PLUG_IN_AUTHOR, + PLUG_IN_COPYRIGHT, + PLUG_IN_VERSION, + N_("_Curve Bend..."), + PLUG_IN_IMAGE_TYPES, + GIMP_PLUGIN, + G_N_ELEMENTS (args), + G_N_ELEMENTS (return_vals), + args, + return_vals); + + gimp_plugin_menu_register (PLUG_IN_PROC, "/Filters/Distorts"); + + /* the installation of the Iterator procedure for the bend plugin */ + gimp_install_procedure (PLUG_IN_ITER_NAME, + "This procedure calculates the modified values " + "for one iterationstep for the call of " + "plug_in_curve_bend", + "", + PLUG_IN_AUTHOR, + PLUG_IN_COPYRIGHT, + PLUG_IN_VERSION, + NULL, /* do not appear in menus */ + NULL, + GIMP_PLUGIN, + G_N_ELEMENTS (args_iter), 0, + args_iter, NULL); +} + +static void +run (const gchar *name, + gint nparams, + const GimpParam *param, + gint *nreturn_vals, + GimpParam **return_vals) +{ + const gchar *env; + BenderDialog *cd; + gint32 active_drawable_id = -1; + gint32 image_id = -1; + gint32 layer_id = -1; + GError *error = NULL; + + /* Get the runmode from the in-parameters */ + GimpRunMode run_mode = param[0].data.d_int32; + + /* status variable, use it to check for errors in invocation usually only + during non-interactive calling */ + GimpPDBStatusType status = GIMP_PDB_SUCCESS; + + /*always return at least the status to the caller. */ + static GimpParam values[2]; + + INIT_I18N (); + gegl_init (NULL, NULL); + + cd = NULL; + + env = g_getenv ("BEND_DEBUG"); + if (env != NULL) + { + if ((*env != 'n') && (*env != 'N')) gb_debug = 1; + } + + if (gb_debug) g_printerr ("\n\nDEBUG: run %s\n", name); + + values[0].type = GIMP_PDB_STATUS; + values[0].data.d_status = status; + + values[1].type = GIMP_PDB_LAYER; + values[1].data.d_int32 = -1; + + *nreturn_vals = 2; + *return_vals = values; + + if (strcmp (name, PLUG_IN_ITER_NAME) == 0) + { + gint32 len_struct; + gint32 total_steps; + gdouble current_step; + BenderValues bval; /* current values while iterating */ + BenderValues bval_from, bval_to; /* start and end values */ + + /* Iterator procedure for animated calls is usually called from + * "plug_in_gap_layers_run_animfilter" + * (always run noninteractive) + */ + if ((run_mode == GIMP_RUN_NONINTERACTIVE) && (nparams == 4)) + { + total_steps = param[1].data.d_int32; + current_step = param[2].data.d_float; + len_struct = param[3].data.d_int32; + + if (len_struct == sizeof (bval)) + { + /* get _FROM and _TO data, + * This data was stored by plug_in_gap_layers_run_animfilter + */ + gimp_get_data (PLUG_IN_DATA_ITER_FROM, &bval_from); + gimp_get_data (PLUG_IN_DATA_ITER_TO, &bval_to); + bval = bval_from; + + p_delta_gdouble (&bval.rotation, bval_from.rotation, + bval_to.rotation, total_steps, current_step); + /* note: iteration of curve and points arrays would not + * give useful results. (there might be different + * number of points in the from/to bender values ) + * the iteration is done later, (see + * p_bender_calculate_iter_curve) when the curve + * is calculated. + */ + + bval.total_steps = total_steps; + bval.current_step = current_step; + + gimp_set_data (PLUG_IN_PROC, &bval, sizeof (bval)); + } + else + { + status = GIMP_PDB_CALLING_ERROR; + } + } + else + { + status = GIMP_PDB_CALLING_ERROR; + } + + values[0].data.d_status = status; + return; + } + + /* get image and drawable */ + image_id = param[1].data.d_int32; + layer_id = param[2].data.d_drawable; + + if (! gimp_item_is_layer (layer_id)) + { + g_set_error (&error, 0, 0, "%s", + _("Can operate on layers only " + "(but was called on channel or mask).")); + status = GIMP_PDB_EXECUTION_ERROR; + } + + /* check for layermask */ + if (gimp_layer_get_mask (layer_id) > 0) + { + g_set_error (&error, 0, 0, "%s", + _("Cannot operate on layers with masks.")); + status = GIMP_PDB_EXECUTION_ERROR; + } + + /* if there is a selection, make it the floating selection layer */ + active_drawable_id = p_if_selection_float_it (image_id, layer_id); + if (active_drawable_id < 0) + { + /* could not float the selection because selection rectangle + * is completely empty return GIMP_PDB_EXECUTION_ERROR + */ + g_set_error (&error, 0, 0, "%s", + _("Cannot operate on empty selections.")); + status = GIMP_PDB_EXECUTION_ERROR; + } + + /* how are we running today? */ + if (status == GIMP_PDB_SUCCESS) + { + /* how are we running today? */ + switch (run_mode) + { + case GIMP_RUN_INTERACTIVE: + /* Possibly retrieve data from a previous run */ + /* gimp_get_data (PLUG_IN_PROC, &g_bndvals); */ + + /* Get information from the dialog */ + cd = do_dialog (active_drawable_id); + cd->show_progress = TRUE; + break; + + case GIMP_RUN_NONINTERACTIVE: + /* check to see if invoked with the correct number of parameters */ + if (nparams >= 20) + { + cd = g_new (BenderDialog, 1); + cd->run = TRUE; + cd->show_progress = TRUE; + cd->drawable_id = active_drawable_id; + + cd->rotation = param[3].data.d_float; + cd->smoothing = param[4].data.d_int32 != 0; + cd->antialias = param[5].data.d_int32 != 0; + cd->work_on_copy = param[6].data.d_int32 != 0; + cd->curve_type = param[7].data.d_int32 != 0; + + p_copy_points (cd, OUTLINE_UPPER, 0, + param[8].data.d_int32, + param[9].data.d_floatarray); + p_copy_points (cd, OUTLINE_UPPER, 1, + param[10].data.d_int32, + param[11].data.d_floatarray); + p_copy_points (cd, OUTLINE_LOWER, 0, + param[12].data.d_int32, + param[13].data.d_floatarray); + p_copy_points (cd, OUTLINE_LOWER, 1, + param[14].data.d_int32, + param[15].data.d_floatarray); + + p_copy_yval (cd, OUTLINE_UPPER, + param[16].data.d_int32, + param[17].data.d_int8array); + p_copy_yval (cd, OUTLINE_LOWER, + param[18].data.d_int32, + param[19].data.d_int8array); + } + else + { + status = GIMP_PDB_CALLING_ERROR; + } + break; + + case GIMP_RUN_WITH_LAST_VALS: + cd = g_new (BenderDialog, 1); + cd->run = TRUE; + cd->show_progress = TRUE; + cd->drawable_id = active_drawable_id; + p_retrieve_values (cd); /* Possibly retrieve data from a previous run */ + break; + + default: + break; + } + } + + if (! cd) + { + status = GIMP_PDB_EXECUTION_ERROR; + } + + if (status == GIMP_PDB_SUCCESS) + { + /* Run the main function */ + + if (cd->run) + { + gint32 bent_layer_id; + + gimp_image_undo_group_start (image_id); + + bent_layer_id = p_main_bend (cd, cd->drawable_id, + cd->work_on_copy); + + gimp_image_undo_group_end (image_id); + + /* Store variable states for next run */ + if (run_mode == GIMP_RUN_INTERACTIVE) + { + p_store_values (cd); + } + + /* return the id of handled layer */ + values[1].data.d_int32 = bent_layer_id; + } + else + { + status = GIMP_PDB_CANCEL; + } + + if (run_mode != GIMP_RUN_NONINTERACTIVE) + gimp_displays_flush (); + } + + if (status != GIMP_PDB_SUCCESS && error) + { + *nreturn_vals = 2; + values[1].type = GIMP_PDB_STRING; + values[1].data.d_string = error->message; + } + + values[0].data.d_status = status; +} + +static int +p_save_pointfile (BenderDialog *cd, + const gchar *filename) +{ + FILE *fp; + gint j; + + fp = g_fopen(filename, "w+b"); + if (! fp) + { + g_message (_("Could not open '%s' for writing: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return -1; + } + + fprintf (fp, "%s\n", KEY_POINTFILE); + fprintf (fp, "VERSION 1.0\n\n"); + + fprintf (fp, "# points for upper and lower smooth curve (0.0 <= pt <= 1.0)\n"); + fprintf (fp, "# there are upto 17 points where unused points are set to -1\n"); + fprintf (fp, "# UPPERX UPPERY LOWERX LOWERY\n"); + fprintf (fp, "\n"); + + for(j = 0; j < 17; j++) + { + fprintf (fp, "%s %+.6f %+.6f %+.6f %+.6f\n", KEY_POINTS, + (float)cd->points[OUTLINE_UPPER][j][0], + (float)cd->points[OUTLINE_UPPER][j][1], + (float)cd->points[OUTLINE_LOWER][j][0], + (float)cd->points[OUTLINE_LOWER][j][1] ); + } + + fprintf (fp, "\n"); + fprintf (fp, "# y values for upper/lower freehand curve (0 <= y <= 255) \n"); + fprintf (fp, "# there must be exactly 256 y values \n"); + fprintf (fp, "# UPPER_Y LOWER_Y\n"); + fprintf (fp, "\n"); + + for (j = 0; j < 256; j++) + { + fprintf (fp, "%s %3d %3d\n", KEY_VAL_Y, + (int)cd->curve[OUTLINE_UPPER][j], + (int)cd->curve[OUTLINE_LOWER][j]); + } + + fclose (fp); + + return 0; +} + +static int +p_load_pointfile (BenderDialog *cd, + const gchar *filename) +{ + gint pi, ci, n, len; + FILE *fp; + char buff[2000]; + float fux, fuy, flx, fly; + gint iuy, ily ; + + fp = g_fopen(filename, "rb"); + if (! fp) + { + g_message (_("Could not open '%s' for reading: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return -1; + } + + pi = 0; + ci = 0; + + if (! fgets (buff, 2000 - 1, fp)) + { + g_message (_("Error while reading '%s': %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + fclose (fp); + return -1; + } + + if (strncmp (buff, KEY_POINTFILE, strlen(KEY_POINTFILE)) == 0) + { + while (NULL != fgets (buff, 2000-1, fp)) + { + len = strlen(KEY_POINTS); + + if (strncmp (buff, KEY_POINTS, len) == 0) + { + n = sscanf (&buff[len], + "%f %f %f %f", &fux, &fuy, &flx, &fly); + + if ((n == 4) && (pi < 17)) + { + cd->points[OUTLINE_UPPER][pi][0] = fux; + cd->points[OUTLINE_UPPER][pi][1] = fuy; + cd->points[OUTLINE_LOWER][pi][0] = flx; + cd->points[OUTLINE_LOWER][pi][1] = fly; + pi++; + } + else + { + g_printf("warning: BAD points[%d] in file %s are ignored\n", pi, filename); + } + } + + len = strlen (KEY_VAL_Y); + + if (strncmp (buff, KEY_VAL_Y, len) == 0) + { + n = sscanf (&buff[len], "%d %d", &iuy, &ily); + + if ((n == 2) && (ci < 256)) + { + cd->curve[OUTLINE_UPPER][ci] = iuy; + cd->curve[OUTLINE_LOWER][ci] = ily; + ci++; + } + else + { + g_printf("warning: BAD y_vals[%d] in file %s are ignored\n", ci, filename); + } + } + } + } + + fclose (fp); + + return 0; +} + +static void +p_cd_to_bval (BenderDialog *cd, + BenderValues *bval) +{ + gint i, j; + + for (i = 0; i < 2; i++) + { + for (j = 0; j < 256; j++) + { + bval->curve[i][j] = cd->curve[i][j]; + } + + for (j = 0; j < 17; j++) + { + bval->points[i][j][0] = cd->points[i][j][0]; /* x */ + bval->points[i][j][1] = cd->points[i][j][1]; /* y */ + } + } + + bval->curve_type = cd->curve_type; + bval->smoothing = cd->smoothing; + bval->antialias = cd->antialias; + bval->work_on_copy = cd->work_on_copy; + bval->rotation = cd->rotation; + + bval->total_steps = 0; + bval->current_step = 0.0; +} + +static void +p_cd_from_bval (BenderDialog *cd, + BenderValues *bval) +{ + gint i, j; + + for (i = 0; i < 2; i++) + { + for (j = 0; j < 256; j++) + { + cd->curve[i][j] = bval->curve[i][j]; + } + + for (j = 0; j < 17; j++) + { + cd->points[i][j][0] = bval->points[i][j][0]; /* x */ + cd->points[i][j][1] = bval->points[i][j][1]; /* y */ + } + } + + cd->curve_type = bval->curve_type; + cd->smoothing = bval->smoothing; + cd->antialias = bval->antialias; + cd->work_on_copy = bval->work_on_copy; + cd->rotation = bval->rotation; +} + +static void +p_store_values (BenderDialog *cd) +{ + BenderValues bval; + + p_cd_to_bval (cd, &bval); + gimp_set_data (PLUG_IN_PROC, &bval, sizeof (bval)); +} + +static void +p_retrieve_values (BenderDialog *cd) +{ + BenderValues bval; + + bval.total_steps = 0; + bval.current_step = -444.4; /* init with an invalid dummy value */ + + gimp_get_data (PLUG_IN_PROC, &bval); + + if (bval.total_steps == 0) + { + cd->bval_from = NULL; + cd->bval_to = NULL; + if(bval.current_step != -444.4) + { + /* last_value data was retrieved (and dummy value was overwritten) */ + p_cd_from_bval(cd, &bval); + } + } + else + { + cd->bval_from = g_new (BenderValues, 1); + cd->bval_to = g_new (BenderValues, 1); + cd->bval_curr = g_new (BenderValues, 1); + *cd->bval_curr = bval; + + /* it seems that we are called from GAP with "Varying Values" */ + gimp_get_data(PLUG_IN_DATA_ITER_FROM, cd->bval_from); + gimp_get_data(PLUG_IN_DATA_ITER_TO, cd->bval_to); + *cd->bval_curr = bval; + p_cd_from_bval(cd, cd->bval_curr); + cd->work_on_copy = FALSE; + } +} + +static void +p_delta_gdouble (double *val, + double val_from, + double val_to, + gint32 total_steps, + gdouble current_step) +{ + double delta; + + if (total_steps < 1) + return; + + delta = ((double)(val_to - val_from) / (double)total_steps) * ((double)total_steps - current_step); + *val = val_from + delta; +} + +static void +p_delta_gint32 (gint32 *val, + gint32 val_from, + gint32 val_to, + gint32 total_steps, + gdouble current_step) +{ + double delta; + + if (total_steps < 1) + return; + + delta = ((double)(val_to - val_from) / (double)total_steps) * ((double)total_steps - current_step); + *val = val_from + delta; +} + +static void +p_copy_points (BenderDialog *cd, + int outline, + int xy, + int argc, + gdouble *floatarray) +{ + int j; + + for (j = 0; j < 17; j++) + { + cd->points[outline][j][xy] = -1; + } + + for (j = 0; j < argc; j++) + { + cd->points[outline][j][xy] = floatarray[j]; + } +} + +static void +p_copy_yval (BenderDialog *cd, + int outline, + int argc, + guint8 *int8array) +{ + int j; + guchar fill; + + fill = MIDDLE; + + for (j = 0; j < 256; j++) + { + if (j < argc) + { + fill = cd->curve[outline][j] = int8array[j]; + } + else + { + cd->curve[outline][j] = fill; + } + } +} + +/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */ +/* curves machinery */ +/* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */ + +static BenderDialog * +do_dialog (gint32 drawable_id) +{ + BenderDialog *cd; + + /* Init GTK */ + gimp_ui_init (PLUG_IN_BINARY, TRUE); + + /* The curve_bend dialog */ + cd = bender_new_dialog (drawable_id); + + /* create temporary image (with a small copy of drawable) for the preview */ + cd->preview_image_id = p_create_pv_image (drawable_id, + &cd->preview_layer_id1); + cd->preview_layer_id2 = -1; + + if (! gtk_widget_get_visible (cd->shell)) + gtk_widget_show (cd->shell); + + bender_update (cd, UP_GRAPH | UP_DRAW | UP_PREVIEW_EXPOSE); + + gtk_main (); + gdk_flush (); + + gimp_image_delete(cd->preview_image_id); + cd->preview_image_id = -1; + cd->preview_layer_id1 = -1; + cd->preview_layer_id2 = -1; + + return cd; +} + +/**************************/ +/* Select Curves dialog */ +/**************************/ + +static BenderDialog * +bender_new_dialog (gint32 drawable_id) +{ + BenderDialog *cd; + GtkWidget *main_hbox; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *vbox2; + GtkWidget *abox; + GtkWidget *frame; + GtkWidget *upper, *lower; + GtkWidget *smooth, *freew; + GtkWidget *toggle; + GtkWidget *button; + GtkWidget *spinbutton; + GtkWidget *label; + GdkDisplay *display; + gint i, j; + + cd = g_new (BenderDialog, 1); + + cd->preview = FALSE; + cd->curve_type = SMOOTH; + cd->pixmap = NULL; + cd->filechooser = NULL; + cd->outline = OUTLINE_UPPER; + cd->show_progress = FALSE; + cd->smoothing = TRUE; + cd->antialias = TRUE; + cd->work_on_copy = FALSE; + cd->rotation = 0.0; /* vertical bend */ + + cd->drawable_id = drawable_id; + + cd->color = gimp_drawable_is_rgb (drawable_id); + + cd->run = FALSE; + cd->bval_from = NULL; + cd->bval_to = NULL; + cd->bval_curr = NULL; + + for (i = 0; i < 2; i++) + for (j = 0; j < 256; j++) + cd->curve[i][j] = MIDDLE; + + cd->grab_point = -1; + for (i = 0; i < 2; i++) + { + for (j = 0; j < 17; j++) + { + cd->points[i][j][0] = -1; + cd->points[i][j][1] = -1; + } + cd->points[i][0][0] = 0.0; /* x */ + cd->points[i][0][1] = 0.5; /* y */ + cd->points[i][16][0] = 1.0; /* x */ + cd->points[i][16][1] = 0.5; /* y */ + } + + p_retrieve_values(cd); /* Possibly retrieve data from a previous run */ + + /* The shell and main vbox */ + cd->shell = gimp_dialog_new (_("Curve Bend"), PLUG_IN_ROLE, + NULL, 0, + gimp_standard_help_func, PLUG_IN_PROC, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_OK"), GTK_RESPONSE_OK, + + NULL); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (cd->shell), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + + gimp_window_set_transient (GTK_WINDOW (cd->shell)); + + g_signal_connect (cd->shell, "response", + G_CALLBACK (bender_response), + cd); + + /* busy cursor */ + display = gtk_widget_get_display (cd->shell); + cd->cursor_busy = gdk_cursor_new_for_display (display, GDK_WATCH); + + /* The main hbox */ + main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); + gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (cd->shell))), + main_hbox, TRUE, TRUE, 0); + gtk_widget_show (main_hbox); + + /* Left side column */ + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); + gtk_widget_show (vbox); + + /* Preview area, top of column */ + frame = gimp_frame_new (_("Preview")); + gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); + gtk_container_add (GTK_CONTAINER (frame), vbox2); + gtk_widget_show (vbox2); + + abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); + gtk_box_pack_start (GTK_BOX (vbox2), abox, FALSE, FALSE, 0); + gtk_widget_show (abox); + + /* The range drawing area */ + 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); + + cd->pv_widget = gimp_preview_area_new (); + gtk_widget_set_size_request (cd->pv_widget, + PREVIEW_SIZE_X, PREVIEW_SIZE_Y); + gtk_container_add (GTK_CONTAINER (frame), cd->pv_widget); + gtk_widget_show (cd->pv_widget); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_box_pack_end (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* The preview button */ + button = gtk_button_new_with_mnemonic (_("_Preview Once")); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); + gtk_widget_show (button); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_preview_update_once), + cd); + + /* The preview toggle */ + toggle = gtk_check_button_new_with_mnemonic (_("Automatic pre_view")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), cd->preview); + gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); + gtk_widget_show (toggle); + + g_signal_connect (toggle, "toggled", + G_CALLBACK (bender_preview_update), + cd); + + /* Options area, bottom of column */ + frame = gimp_frame_new (_("Options")); + gtk_box_pack_end (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); + gtk_container_add (GTK_CONTAINER (frame), vbox); + gtk_widget_show (vbox); + + /* Render Options */ + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* Rotate spinbutton */ + label = gtk_label_new_with_mnemonic (_("Rotat_e:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + gtk_widget_show (label); + + cd->rotate_data = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0.0, 360.0, 1, 45, 0)); + gtk_adjustment_set_value (cd->rotate_data, cd->rotation); + + spinbutton = gimp_spin_button_new (cd->rotate_data, 0.5, 1); + gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); + gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); + gtk_widget_show (spinbutton); + + gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); + + g_signal_connect (cd->rotate_data, "value-changed", + G_CALLBACK (bender_rotate_adj_callback), + cd); + + /* The smoothing toggle */ + toggle = gtk_check_button_new_with_mnemonic (_("Smoo_thing")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), cd->smoothing); + gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); + gtk_widget_show (toggle); + + g_signal_connect (toggle, "toggled", + G_CALLBACK (bender_smoothing_callback), + cd); + + /* The antialiasing toggle */ + toggle = gtk_check_button_new_with_mnemonic (_("_Antialiasing")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), cd->antialias); + gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); + gtk_widget_show (toggle); + + g_signal_connect (toggle, "toggled", + G_CALLBACK (bender_antialias_callback), + cd); + + /* The work_on_copy toggle */ + toggle = gtk_check_button_new_with_mnemonic (_("Work on cop_y")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), cd->work_on_copy); + gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); + gtk_widget_show (toggle); + + g_signal_connect (toggle, "toggled", + G_CALLBACK (bender_work_on_copy_callback), + cd); + + /* The curves graph */ + frame = gimp_frame_new (_("Modify Curves")); + gtk_box_pack_start (GTK_BOX (main_hbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_container_add (GTK_CONTAINER (frame), vbox); + gtk_widget_show (vbox); + + abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); + gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); + gtk_widget_show (abox); + + cd->graph = gtk_drawing_area_new (); + gtk_widget_set_size_request (cd->graph, + GRAPH_WIDTH + RADIUS * 2, + GRAPH_HEIGHT + RADIUS * 2); + gtk_widget_set_events (cd->graph, GRAPH_MASK); + gtk_container_add (GTK_CONTAINER (abox), cd->graph); + gtk_widget_show (cd->graph); + + g_signal_connect (cd->graph, "event", + G_CALLBACK (bender_graph_events), + cd); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + frame = gimp_int_radio_group_new (TRUE, _("Curve for Border"), + G_CALLBACK (bender_border_callback), + &cd->outline, cd->outline, + + C_("curve-border", "_Upper"), OUTLINE_UPPER, &upper, + C_("curve-border", "_Lower"), OUTLINE_LOWER, &lower, + + NULL); + + g_object_set_data (G_OBJECT (upper), "cd", cd); + g_object_set_data (G_OBJECT (lower), "cd", cd); + + gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + frame = gimp_int_radio_group_new (TRUE, _("Curve Type"), + G_CALLBACK (bender_type_callback), + &cd->curve_type, cd->curve_type, + + _("Smoot_h"), SMOOTH, &smooth, + _("_Free"), GFREE, &freew, + + NULL); + g_object_set_data (G_OBJECT (smooth), "cd", cd); + g_object_set_data (G_OBJECT (freew), "cd", cd); + + gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + /* hbox for curve options */ + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* The Copy button */ + button = gtk_button_new_with_mnemonic (_("_Copy")); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, + _("Copy the active curve to the other border"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_copy_callback), + cd); + + /* The CopyInv button */ + button = gtk_button_new_with_mnemonic (_("_Mirror")); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, + _("Mirror the active curve to the other border"), + NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_copy_inv_callback), + cd); + + /* The Swap button */ + button = gtk_button_new_with_mnemonic (_("S_wap")); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, + _("Swap the two curves"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_swap_callback), + cd); + + /* The Reset button */ + button = gtk_button_new_with_mnemonic (_("_Reset")); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, + _("Reset the active curve"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_reset_callback), + cd); + + /* hbox for curve load and save */ + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); + gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + /* The Load button */ + button = gtk_button_new_with_mnemonic (_("_Open")); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, + _("Load the curves from a file"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_load_callback), + cd); + + /* The Save button */ + button = gtk_button_new_with_mnemonic (_("_Save")); + gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, + _("Save the curves to a file"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (bender_save_callback), + cd); + + gtk_widget_show (main_hbox); + + return cd; +} + +static void +bender_update (BenderDialog *cd, + int update) +{ + GtkStyle *graph_style = gtk_widget_get_style (cd->graph); + gint i; + gint other; + + if (update & UP_PREVIEW) + { + gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (cd->shell)), + cd->cursor_busy); + gdk_flush (); + + if (cd->preview_layer_id2 >= 0) + gimp_image_remove_layer(cd->preview_image_id, cd->preview_layer_id2); + + cd->preview_layer_id2 = p_main_bend(cd, cd->preview_layer_id1, TRUE /* work_on_copy*/ ); + p_render_preview(cd, cd->preview_layer_id2); + + if (update & UP_DRAW) + gtk_widget_queue_draw (cd->pv_widget); + + gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (cd->shell)), + NULL); + } + if (update & UP_PREVIEW_EXPOSE) + { + /* on expose just redraw cd->preview_layer_id2 + * that holds the bent version of the preview (if there is one) + */ + if (cd->preview_layer_id2 < 0) + cd->preview_layer_id2 = p_main_bend(cd, cd->preview_layer_id1, TRUE /* work_on_copy*/ ); + p_render_preview(cd, cd->preview_layer_id2); + + if (update & UP_DRAW) + gtk_widget_queue_draw (cd->pv_widget); + } + if ((update & UP_GRAPH) && (update & UP_DRAW) && cd->pixmap != NULL) + { + cairo_t *cr; + + cr = gdk_cairo_create (gtk_widget_get_window (cd->graph)); + + cairo_set_line_width (cr, 1.0); + cairo_translate (cr, 0.5, 0.5); + + /* Clear the background */ + gdk_cairo_set_source_color (cr, &graph_style->bg[GTK_STATE_NORMAL]); + cairo_paint (cr); + + /* Draw the grid lines */ + for (i = 0; i < 5; i++) + { + cairo_move_to (cr, RADIUS, i * (GRAPH_HEIGHT / 4) + RADIUS); + cairo_line_to (cr, GRAPH_WIDTH + RADIUS, i * (GRAPH_HEIGHT / 4) + RADIUS); + + cairo_move_to (cr, i * (GRAPH_WIDTH / 4) + RADIUS, RADIUS); + cairo_line_to (cr, i * (GRAPH_WIDTH / 4) + RADIUS, GRAPH_HEIGHT + RADIUS); + } + + gdk_cairo_set_source_color (cr, &graph_style->dark[GTK_STATE_NORMAL]); + cairo_stroke (cr); + + /* Draw the other curve */ + other = (cd->outline == 0) ? 1 : 0; + + cairo_move_to (cr, RADIUS, 255 - cd->curve[other][0] + RADIUS); + + for (i = 1; i < 256; i++) + { + cairo_line_to (cr, i + RADIUS, 255 - cd->curve[other][i] + RADIUS); + } + + gdk_cairo_set_source_color (cr, &graph_style->dark[GTK_STATE_NORMAL]); + cairo_stroke (cr); + + /* Draw the active curve */ + cairo_move_to (cr, RADIUS, 255 - cd->curve[cd->outline][0] + RADIUS); + + for (i = 1; i < 256; i++) + { + cairo_line_to (cr, i + RADIUS, 255 - cd->curve[cd->outline][i] + RADIUS); + } + + /* Draw the points */ + if (cd->curve_type == SMOOTH) + { + for (i = 0; i < 17; i++) + { + if (cd->points[cd->outline][i][0] != -1) + { + cairo_new_sub_path (cr); + cairo_arc (cr, + (cd->points[cd->outline][i][0] * 255.0) + RADIUS, + 255 - (cd->points[cd->outline][i][1] * 255.0) + RADIUS, + RADIUS, + 0, 2 * G_PI); + } + } + } + + gdk_cairo_set_source_color (cr, &graph_style->black); + cairo_stroke (cr); + + cairo_destroy (cr); + } +} + +static void +bender_plot_curve (BenderDialog *cd, + int p1, + int p2, + int p3, + int p4, + gint32 xmax, + gint32 ymax, + gint fix255) +{ + CRMatrix geometry; + CRMatrix tmp1, tmp2; + CRMatrix deltas; + double x, dx, dx2, dx3; + double y, dy, dy2, dy3; + double d, d2, d3; + int lastx, lasty; + gint32 newx, newy; + gint32 ntimes; + gint32 i; + + /* construct the geometry matrix from the segment */ + for (i = 0; i < 4; i++) + { + geometry[i][2] = 0; + geometry[i][3] = 0; + } + + geometry[0][0] = (cd->points[cd->outline][p1][0] * xmax); + geometry[1][0] = (cd->points[cd->outline][p2][0] * xmax); + geometry[2][0] = (cd->points[cd->outline][p3][0] * xmax); + geometry[3][0] = (cd->points[cd->outline][p4][0] * xmax); + + geometry[0][1] = (cd->points[cd->outline][p1][1] * ymax); + geometry[1][1] = (cd->points[cd->outline][p2][1] * ymax); + geometry[2][1] = (cd->points[cd->outline][p3][1] * ymax); + geometry[3][1] = (cd->points[cd->outline][p4][1] * ymax); + + /* subdivide the curve ntimes (1000) times */ + ntimes = 4 * xmax; + /* ntimes can be adjusted to give a finer or coarser curve */ + d = 1.0 / ntimes; + d2 = d * d; + d3 = d * d * d; + + /* construct a temporary matrix for determining the forward differencing deltas */ + tmp2[0][0] = 0; tmp2[0][1] = 0; tmp2[0][2] = 0; tmp2[0][3] = 1; + tmp2[1][0] = d3; tmp2[1][1] = d2; tmp2[1][2] = d; tmp2[1][3] = 0; + tmp2[2][0] = 6*d3; tmp2[2][1] = 2*d2; tmp2[2][2] = 0; tmp2[2][3] = 0; + tmp2[3][0] = 6*d3; tmp2[3][1] = 0; tmp2[3][2] = 0; tmp2[3][3] = 0; + + /* compose the basis and geometry matrices */ + bender_CR_compose (CR_basis, geometry, tmp1); + + /* compose the above results to get the deltas matrix */ + bender_CR_compose (tmp2, tmp1, deltas); + + /* extract the x deltas */ + x = deltas[0][0]; + dx = deltas[1][0]; + dx2 = deltas[2][0]; + dx3 = deltas[3][0]; + + /* extract the y deltas */ + y = deltas[0][1]; + dy = deltas[1][1]; + dy2 = deltas[2][1]; + dy3 = deltas[3][1]; + + lastx = CLAMP (x, 0, xmax); + lasty = CLAMP (y, 0, ymax); + + + if (fix255) + { + cd->curve[cd->outline][lastx] = lasty; + } + else + { + cd->curve_ptr[cd->outline][lastx] = lasty; + if(gb_debug) g_printf("bender_plot_curve xmax:%d ymax:%d\n", + (int)xmax, (int)ymax); + } + + /* loop over the curve */ + for (i = 0; i < ntimes; i++) + { + /* increment the x values */ + x += dx; + dx += dx2; + dx2 += dx3; + + /* increment the y values */ + y += dy; + dy += dy2; + dy2 += dy3; + + newx = CLAMP ((ROUND (x)), 0, xmax); + newy = CLAMP ((ROUND (y)), 0, ymax); + + /* if this point is different than the last one...then draw it */ + if ((lastx != newx) || (lasty != newy)) + { + if (fix255) + { + /* use fixed array size (for the curve graph) */ + cd->curve[cd->outline][newx] = newy; + } + else + { + /* use dynamic allocated curve_ptr (for the real curve) */ + cd->curve_ptr[cd->outline][newx] = newy; + + if(gb_debug) g_printf("outline: %d cX: %d cY: %d\n", + (int)cd->outline, (int)newx, (int)newy); + } + } + + lastx = newx; + lasty = newy; + } +} + +static void +bender_calculate_curve (BenderDialog *cd, + gint32 xmax, + gint32 ymax, + gint fix255) +{ + int i; + int points[17]; + int num_pts; + int p1, p2, p3, p4; + int xmid; + int yfirst, ylast; + + switch (cd->curve_type) + { + case GFREE: + break; + + case SMOOTH: + /* cycle through the curves */ + num_pts = 0; + for (i = 0; i < 17; i++) + if (cd->points[cd->outline][i][0] != -1) + points[num_pts++] = i; + + xmid = xmax / 2; + /* Initialize boundary curve points */ + if (num_pts != 0) + { + if (fix255) + { + for (i = 0; i < (cd->points[cd->outline][points[0]][0] * 255); i++) + cd->curve[cd->outline][i] = + (cd->points[cd->outline][points[0]][1] * 255); + + for (i = (cd->points[cd->outline][points[num_pts - 1]][0] * 255); i < 256; i++) + cd->curve[cd->outline][i] = + (cd->points[cd->outline][points[num_pts - 1]][1] * 255); + } + else + { + yfirst = cd->points[cd->outline][points[0]][1] * ymax; + ylast = cd->points[cd->outline][points[num_pts - 1]][1] * ymax; + + for (i = 0; i < xmid; i++) + { + cd->curve_ptr[cd->outline][i] = yfirst; + } + + for (i = xmid; i <= xmax; i++) + { + cd->curve_ptr[cd->outline][i] = ylast; + } + } + } + + for (i = 0; i < num_pts - 1; i++) + { + p1 = (i == 0) ? points[i] : points[(i - 1)]; + p2 = points[i]; + p3 = points[(i + 1)]; + p4 = (i == (num_pts - 2)) ? points[(num_pts - 1)] : points[(i + 2)]; + + bender_plot_curve (cd, p1, p2, p3, p4, xmax, ymax, fix255); + } + break; + } +} + +static void +bender_rotate_adj_callback (GtkAdjustment *adjustment, + gpointer client_data) +{ + BenderDialog *cd = client_data; + + if (gtk_adjustment_get_value (adjustment) != cd->rotation) + { + cd->rotation = gtk_adjustment_get_value (adjustment); + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); + } +} + +static void +bender_border_callback (GtkWidget *widget, + gpointer data) +{ + BenderDialog *cd; + + gimp_radio_button_update (widget, data); + cd = g_object_get_data (G_OBJECT (widget), "cd"); + bender_update (cd, UP_GRAPH | UP_DRAW); +} + +static void +bender_type_callback (GtkWidget *widget, + gpointer data) +{ + BenderDialog *cd; + + gimp_radio_button_update (widget, data); + + cd = g_object_get_data (G_OBJECT (widget), "cd"); + if (! cd) + return; + + if (cd->curve_type == SMOOTH) + { + gint i; + + /* pick representative points from the curve and make them control points */ + for (i = 0; i <= 8; i++) + { + gint index = CLAMP ((i * 32), 0, 255); + cd->points[cd->outline][i * 2][0] = (gdouble)index / 255.0; + cd->points[cd->outline][i * 2][1] = (gdouble)cd->curve[cd->outline][index] / 255.0; + } + + bender_calculate_curve (cd, 255, 255, TRUE); + bender_update (cd, UP_GRAPH | UP_DRAW); + + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); + } + else + { + bender_update (cd, UP_GRAPH | UP_DRAW); + } +} + +static void +bender_reset_callback (GtkWidget *widget, + gpointer client_data) +{ + BenderDialog *cd = (BenderDialog *) client_data; + gint i; + + /* Initialize the values */ + for (i = 0; i < 256; i++) + cd->curve[cd->outline][i] = MIDDLE; + + cd->grab_point = -1; + for (i = 0; i < 17; i++) + { + cd->points[cd->outline][i][0] = -1; + cd->points[cd->outline][i][1] = -1; + } + cd->points[cd->outline][0][0] = 0.0; /* x */ + cd->points[cd->outline][0][1] = 0.5; /* y */ + cd->points[cd->outline][16][0] = 1.0; /* x */ + cd->points[cd->outline][16][1] = 0.5; /* y */ + + bender_update (cd, UP_GRAPH | UP_DRAW); + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +bender_copy_callback (GtkWidget *widget, + gpointer client_data) +{ + BenderDialog *cd = (BenderDialog *) client_data; + int i; + int other; + + other = (cd->outline) ? 0 : 1; + + for (i = 0; i < 17; i++) + { + cd->points[other][i][0] = cd->points[cd->outline][i][0]; + cd->points[other][i][1] = cd->points[cd->outline][i][1]; + } + + for (i= 0; i < 256; i++) + { + cd->curve[other][i] = cd->curve[cd->outline][i]; + } + + bender_update (cd, UP_GRAPH | UP_DRAW); + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +bender_copy_inv_callback (GtkWidget *widget, + gpointer client_data) +{ + BenderDialog *cd = (BenderDialog*) client_data; + int i; + int other; + + other = (cd->outline) ? 0 : 1; + + for (i = 0; i < 17; i++) + { + cd->points[other][i][0] = cd->points[cd->outline][i][0]; /* x */ + cd->points[other][i][1] = 1.0 - cd->points[cd->outline][i][1]; /* y */ + } + + for (i= 0; i < 256; i++) + { + cd->curve[other][i] = 255 - cd->curve[cd->outline][i]; + } + + bender_update (cd, UP_GRAPH | UP_DRAW); + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + + +static void +bender_swap_callback (GtkWidget *widget, + gpointer client_data) +{ +#define SWAP_VALUE(a, b, h) { h=a; a=b; b=h; } + BenderDialog *cd = (BenderDialog*) client_data; + int i; + int other; + gdouble hd; + guchar hu; + + other = (cd->outline) ? 0 : 1; + + for (i = 0; i < 17; i++) + { + SWAP_VALUE(cd->points[other][i][0], cd->points[cd->outline][i][0], hd); /* x */ + SWAP_VALUE(cd->points[other][i][1], cd->points[cd->outline][i][1], hd); /* y */ + } + + for (i= 0; i < 256; i++) + { + SWAP_VALUE(cd->curve[other][i], cd->curve[cd->outline][i], hu); + } + + bender_update (cd, UP_GRAPH | UP_DRAW); + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +bender_response (GtkWidget *widget, + gint response_id, + BenderDialog *cd) +{ + if (response_id == GTK_RESPONSE_OK) + cd->run = TRUE; + + gtk_widget_destroy (GTK_WIDGET (cd->shell)); + gtk_main_quit (); +} + +static void +bender_preview_update (GtkWidget *widget, + gpointer data) +{ + BenderDialog *cd = (BenderDialog*) data; + + cd->preview = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); + + if(cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +bender_preview_update_once (GtkWidget *widget, + gpointer data) +{ + BenderDialog *cd = (BenderDialog*) data; + + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +p_points_save_to_file_response (GtkWidget *dialog, + gint response_id, + BenderDialog *cd) +{ + if (response_id == GTK_RESPONSE_OK) + { + gchar *filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); + + p_save_pointfile (cd, filename); + + g_free (filename); + } + + gtk_widget_destroy (dialog); +} + +static void +p_points_load_from_file_response (GtkWidget *dialog, + gint response_id, + BenderDialog *cd) +{ + if (response_id == GTK_RESPONSE_OK) + { + gchar *filename; + + filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); + + p_load_pointfile (cd, filename); + bender_update (cd, UP_ALL); + + g_free (filename); + } + + gtk_widget_destroy (dialog); +} + +static void +bender_load_callback (GtkWidget *w, + BenderDialog *cd) +{ + if (! cd->filechooser) + { + cd->filechooser = + gtk_file_chooser_dialog_new (_("Load Curve Points from File"), + GTK_WINDOW (gtk_widget_get_toplevel (w)), + GTK_FILE_CHOOSER_ACTION_OPEN, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Open"), GTK_RESPONSE_OK, + + NULL); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (cd->filechooser), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + + gtk_dialog_set_default_response (GTK_DIALOG (cd->filechooser), + GTK_RESPONSE_OK); + + g_signal_connect (cd->filechooser, "response", + G_CALLBACK (p_points_load_from_file_response), + cd); + g_signal_connect (cd->filechooser, "destroy", + G_CALLBACK (gtk_widget_destroyed), + &cd->filechooser); + } + + gtk_window_present (GTK_WINDOW (cd->filechooser)); +} + +static void +bender_save_callback (GtkWidget *w, + BenderDialog *cd) +{ + if (! cd->filechooser) + { + cd->filechooser = + gtk_file_chooser_dialog_new (_("Save Curve Points to File"), + GTK_WINDOW (gtk_widget_get_toplevel (w)), + GTK_FILE_CHOOSER_ACTION_SAVE, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Save"), GTK_RESPONSE_OK, + + NULL); + + g_signal_connect (cd->filechooser, "response", + G_CALLBACK (p_points_save_to_file_response), + cd); + g_signal_connect (cd->filechooser, "destroy", + G_CALLBACK (gtk_widget_destroyed), + &cd->filechooser); + + gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (cd->filechooser), + "curve_bend.points"); + } + + gtk_window_present (GTK_WINDOW (cd->filechooser)); +} + +static void +bender_smoothing_callback (GtkWidget *w, + gpointer data) +{ + BenderDialog *cd = (BenderDialog*) data; + + cd->smoothing = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)); + + if(cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +bender_antialias_callback (GtkWidget *w, + gpointer data) +{ + BenderDialog *cd = (BenderDialog*) data; + + cd->antialias = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)); + + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); +} + +static void +bender_work_on_copy_callback (GtkWidget *w, + gpointer data) +{ + BenderDialog *cd = (BenderDialog*) data; + + cd->work_on_copy = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)); +} + +static gboolean +bender_graph_events (GtkWidget *widget, + GdkEvent *event, + BenderDialog *cd) +{ + static GdkCursorType cursor_type = GDK_TOP_LEFT_ARROW; + GdkCursorType new_type; + GdkEventMotion *mevent; + int i; + int tx, ty; + int x, y; + int closest_point; + int distance; + int x1, x2, y1, y2; + + new_type = GDK_X_CURSOR; + closest_point = 0; + + /* get the pointer position */ + gdk_window_get_pointer (gtk_widget_get_window (cd->graph), &tx, &ty, NULL); + x = CLAMP ((tx - RADIUS), 0, 255); + y = CLAMP ((ty - RADIUS), 0, 255); + + distance = G_MAXINT; + for (i = 0; i < 17; i++) + { + if (cd->points[cd->outline][i][0] != -1) + if (abs ((int) (x - (cd->points[cd->outline][i][0] * 255.0))) < distance) + { + distance = abs ((int) (x - (cd->points[cd->outline][i][0] * 255.0))); + closest_point = i; + } + } + if (distance > MIN_DISTANCE) + closest_point = (x + 8) / 16; + + switch (event->type) + { + case GDK_EXPOSE: + if (cd->pixmap == NULL) + cd->pixmap = gdk_pixmap_new (gtk_widget_get_window (cd->graph), + GRAPH_WIDTH + RADIUS * 2, + GRAPH_HEIGHT + RADIUS * 2, -1); + + bender_update (cd, UP_GRAPH | UP_DRAW); + break; + + case GDK_BUTTON_PRESS: + new_type = GDK_TCROSS; + + switch (cd->curve_type) + { + case SMOOTH: + /* determine the leftmost and rightmost points */ + cd->leftmost = -1; + for (i = closest_point - 1; i >= 0; i--) + if (cd->points[cd->outline][i][0] != -1) + { + cd->leftmost = (cd->points[cd->outline][i][0] * 255.0); + break; + } + cd->rightmost = 256; + for (i = closest_point + 1; i < 17; i++) + if (cd->points[cd->outline][i][0] != -1) + { + cd->rightmost = (cd->points[cd->outline][i][0] * 255.0); + break; + } + + cd->grab_point = closest_point; + cd->points[cd->outline][cd->grab_point][0] = (gdouble)x / 255.0; + cd->points[cd->outline][cd->grab_point][1] = (gdouble)(255 - y) / 255.0; + + bender_calculate_curve (cd, 255, 255, TRUE); + break; + + case GFREE: + cd->curve[cd->outline][x] = 255 - y; + cd->grab_point = x; + cd->last = y; + break; + } + + bender_update (cd, UP_GRAPH | UP_DRAW); + break; + + case GDK_BUTTON_RELEASE: + new_type = GDK_FLEUR; + cd->grab_point = -1; + + if (cd->preview) + bender_update (cd, UP_PREVIEW | UP_DRAW); + break; + + case GDK_MOTION_NOTIFY: + mevent = (GdkEventMotion *) event; + + if (mevent->is_hint) + { + mevent->x = tx; + mevent->y = ty; + } + + switch (cd->curve_type) + { + case SMOOTH: + /* If no point is grabbed... */ + if (cd->grab_point == -1) + { + if (cd->points[cd->outline][closest_point][0] != -1) + new_type = GDK_FLEUR; + else + new_type = GDK_TCROSS; + } + /* Else, drag the grabbed point */ + else + { + new_type = GDK_TCROSS; + + cd->points[cd->outline][cd->grab_point][0] = -1; + + if (x > cd->leftmost && x < cd->rightmost) + { + closest_point = (x + 8) / 16; + if (cd->points[cd->outline][closest_point][0] == -1) + cd->grab_point = closest_point; + cd->points[cd->outline][cd->grab_point][0] = (gdouble)x / 255.0; + cd->points[cd->outline][cd->grab_point][1] = (gdouble)(255 - y) / 255.0; + } + + bender_calculate_curve (cd, 255, 255, TRUE); + bender_update (cd, UP_GRAPH | UP_DRAW); + } + break; + + case GFREE: + if (cd->grab_point != -1) + { + if (cd->grab_point > x) + { + x1 = x; + x2 = cd->grab_point; + y1 = y; + y2 = cd->last; + } + else + { + x1 = cd->grab_point; + x2 = x; + y1 = cd->last; + y2 = y; + } + + if (x2 != x1) + for (i = x1; i <= x2; i++) + cd->curve[cd->outline][i] = 255 - (y1 + ((y2 - y1) * (i - x1)) / (x2 - x1)); + else + cd->curve[cd->outline][x] = 255 - y; + + cd->grab_point = x; + cd->last = y; + + bender_update (cd, UP_GRAPH | UP_DRAW); + } + + if (mevent->state & GDK_BUTTON1_MASK) + new_type = GDK_TCROSS; + else + new_type = GDK_PENCIL; + break; + } + + if (new_type != cursor_type) + { + cursor_type = new_type; + /* change_win_cursor (gtk_widget_get_window (cd->graph), cursor_type); */ + } + break; + + default: + break; + } + + return FALSE; +} + +static void +bender_CR_compose (CRMatrix a, + CRMatrix b, + CRMatrix ab) +{ + gint i, j; + + for (i = 0; i < 4; i++) + { + for (j = 0; j < 4; j++) + { + ab[i][j] = (a[i][0] * b[0][j] + + a[i][1] * b[1][j] + + a[i][2] * b[2][j] + + a[i][3] * b[3][j]); + } + } +} + +static void +p_render_preview (BenderDialog *cd, + gint32 layer_id) +{ + guchar pixel[4]; + guchar *buf, *ptr; + gint x, y; + gint ofx, ofy; + gint width, height; + t_GDRW l_gdrw; + t_GDRW *gdrw; + + width = gimp_drawable_width (layer_id); + height = gimp_drawable_height (layer_id); + + ptr = buf = g_new (guchar, PREVIEW_BPP * PREVIEW_SIZE_X * PREVIEW_SIZE_Y); + gdrw = &l_gdrw; + p_init_gdrw(gdrw, layer_id, FALSE); + + /* offsets to set bend layer to preview center */ + ofx = (width / 2) - (PREVIEW_SIZE_X / 2); + ofy = (height / 2) - (PREVIEW_SIZE_Y / 2); + + /* render preview */ + for (y = 0; y < PREVIEW_SIZE_Y; y++) + { + for (x = 0; x < PREVIEW_SIZE_X; x++) + { + p_get_pixel (gdrw, x + ofx, y + ofy, &pixel[0]); + + if (cd->color) + { + ptr[0] = pixel[0]; + ptr[1] = pixel[1]; + ptr[2] = pixel[2]; + } + else + { + ptr[0] = pixel[0]; + ptr[1] = pixel[0]; + ptr[2] = pixel[0]; + } + + ptr[3] = pixel[gdrw->index_alpha]; + + ptr += PREVIEW_BPP; + } + } + + gimp_preview_area_draw (GIMP_PREVIEW_AREA (cd->pv_widget), + 0, 0, PREVIEW_SIZE_X, PREVIEW_SIZE_Y, + GIMP_RGBA_IMAGE, + buf, + PREVIEW_BPP * PREVIEW_SIZE_X); + g_free (buf); + + p_end_gdrw(gdrw); +} + +/* ===================================================== */ +/* curve_bend worker procedures */ +/* ===================================================== */ + +static void +p_stretch_curves (BenderDialog *cd, + gint32 xmax, + gint32 ymax) +{ + gint32 x1, x2; + gdouble ya, yb; + gdouble rest; + int outline; + + for (outline = 0; outline < 2; outline++) + { + for(x1 = 0; x1 <= xmax; x1++) + { + x2 = (x1 * 255) / xmax; + + if ((xmax <= 255) && (x2 < 255)) + { + cd->curve_ptr[outline][x1] = + ROUND ((cd->curve[outline][x2] * ymax) / 255); + } + else + { + /* interpolate */ + rest = (((gdouble)x1 * 255.0) / (gdouble)xmax) - x2; + ya = cd->curve[outline][x2]; /* y of this point */ + yb = cd->curve[outline][x2 +1]; /* y of next point */ + + cd->curve_ptr[outline][x1] = + ROUND (((ya + ((yb -ya) * rest)) * ymax) / 255); + } + } + } +} + +static void +bender_init_min_max (BenderDialog *cd, + gint32 xmax) +{ + int i, j; + + for (i = 0; i < 2; i++) + { + cd->min2[i] = 65000; + cd->max2[i] = 0; + + for (j = 0; j <= xmax; j++) + { + if(cd->curve_ptr[i][j] > cd->max2[i]) + { + cd->max2[i] = cd->curve_ptr[i][j]; + } + + if(cd->curve_ptr[i][j] < cd->min2[i]) + { + cd->min2[i] = cd->curve_ptr[i][j]; + } + } + } + + /* for UPPER outline : y-zero line is assumed at the min leftmost or + * rightmost point + */ + cd->zero2[OUTLINE_UPPER] = MIN (cd->curve_ptr[OUTLINE_UPPER][0], + cd->curve_ptr[OUTLINE_UPPER][xmax]); + + /* for LOWER outline : y-zero line is assumed at the min leftmost or + * rightmost point + */ + cd->zero2[OUTLINE_LOWER] = MAX (cd->curve_ptr[OUTLINE_LOWER][0], + cd->curve_ptr[OUTLINE_LOWER][xmax]); +} + +static gint32 +p_curve_get_dy (BenderDialog *cd, + gint32 x, + gint32 drawable_width, + gint32 total_steps, + gdouble current_step) +{ + /* get y values of both upper and lower curve, + * and return the iterated value in between + */ + gdouble y1, y2; + gdouble delta; + + y1 = cd->zero2[OUTLINE_UPPER] - cd->curve_ptr[OUTLINE_UPPER][x]; + y2 = cd->zero2[OUTLINE_LOWER] - cd->curve_ptr[OUTLINE_LOWER][x]; + + delta = ((double)(y2 - y1) / (double)(total_steps - 1)) * current_step; + + return SIGNED_ROUND (y1 + delta); +} + +static gint32 +p_upper_curve_extend (BenderDialog *cd, + gint32 drawable_width, + gint32 drawable_height) +{ + gint32 y1, y2; + + y1 = cd->max2[OUTLINE_UPPER] - cd->zero2[OUTLINE_UPPER]; + y2 = (cd->max2[OUTLINE_LOWER] - cd->zero2[OUTLINE_LOWER]) - drawable_height; + + return MAX (y1, y2); +} + +static gint32 +p_lower_curve_extend (BenderDialog *cd, + gint32 drawable_width, + gint32 drawable_height) +{ + gint32 y1, y2; + + y1 = cd->zero2[OUTLINE_LOWER] - cd->min2[OUTLINE_LOWER]; + y2 = (cd->zero2[OUTLINE_UPPER] - cd->min2[OUTLINE_UPPER]) - drawable_height; + + return MAX (y1, y2); +} + +static void +p_end_gdrw (t_GDRW *gdrw) +{ + g_object_unref (gdrw->buffer); +} + +static void +p_init_gdrw (t_GDRW *gdrw, + gint32 drawable_id, + int shadow) +{ + gint w, h; + + gdrw->drawable_id = drawable_id; + + if (shadow) + gdrw->buffer = gimp_drawable_get_shadow_buffer (drawable_id); + else + gdrw->buffer = gimp_drawable_get_buffer (drawable_id); + + gdrw->width = gimp_drawable_width (gdrw->drawable_id); + gdrw->height = gimp_drawable_height (gdrw->drawable_id); + + gdrw->tile_width = gimp_tile_width (); + gdrw->tile_height = gimp_tile_height (); + + if (! gimp_drawable_mask_intersect (gdrw->drawable_id, + &gdrw->x1, &gdrw->y1, &w, &h)) + { + w = 0; + h = 0; + } + + gdrw->x2 = gdrw->x1 + w; + gdrw->y2 = gdrw->y1 + h; + + if (gimp_drawable_has_alpha (drawable_id)) + gdrw->format = babl_format ("R'G'B'A u8"); + else + gdrw->format = babl_format ("R'G'B' u8"); + + gdrw->bpp = babl_format_get_bytes_per_pixel (gdrw->format); + + if (gimp_drawable_has_alpha (drawable_id)) + { + /* index of the alpha channelbyte {1|3} */ + gdrw->index_alpha = gdrw->bpp - 1; + } + else + { + gdrw->index_alpha = 0; /* there is no alpha channel */ + } +} + +/* get pixel value + * return light transparent black gray pixel if out of bounds + * (should occur in the previews only) + */ +static void +p_get_pixel (t_GDRW *gdrw, + gint32 x, + gint32 y, + guchar *pixel) +{ + pixel[1] = 255; + pixel[3] = 255; /* simulate full visible alpha channel */ + + gegl_buffer_sample (gdrw->buffer, x, y, NULL, pixel, gdrw->format, + GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE); +} + +static void +p_put_pixel (t_GDRW *gdrw, + gint32 x, + gint32 y, + guchar *pixel) +{ + gegl_buffer_set (gdrw->buffer, GEGL_RECTANGLE (x, y, 1, 1), 0, + gdrw->format, pixel, GEGL_AUTO_ROWSTRIDE); +} + +static void +p_put_mix_pixel (t_GDRW *gdrw, + gint32 x, + gint32 y, + guchar *color, + gint32 nb_curvy, + gint32 nb2_curvy, + gint32 curvy) +{ + guchar pixel[4]; + guchar mixmask; + gint idx; + gint diff; + + mixmask = 255 - 96; + diff = abs(nb_curvy - curvy); + + if (diff == 0) + { + mixmask = 255 - 48; + diff = abs(nb2_curvy - curvy); + + if (diff == 0) + { + /* last 2 neighbours were not shifted against current pixel, do not mix */ + p_put_pixel(gdrw, x, y, color); + return; + } + } + + /* get left neighbour pixel */ + p_get_pixel(gdrw, x-1, y, &pixel[0]); + + if (pixel[gdrw->index_alpha] < 10) + { + /* neighbour is (nearly or full) transparent, do not mix */ + p_put_pixel(gdrw, x, y, color); + return; + } + + for (idx = 0; idx < gdrw->index_alpha ; idx++) + { + /* mix in left neighbour color */ + pixel[idx] = MIX_CHANNEL(color[idx], pixel[idx], mixmask); + } + + pixel[gdrw->index_alpha] = color[gdrw->index_alpha]; + p_put_pixel(gdrw, x, y, &pixel[0]); +} + +/* ============================================================================ + * p_create_pv_image + * ============================================================================ + */ +static gint32 +p_create_pv_image (gint32 src_drawable_id, + gint32 *layer_id) +{ + gint32 new_image_id; + guint new_width; + guint new_height; + GimpImageType type; + guint x, y; + double scale; + guchar pixel[4]; + t_GDRW src_gdrw; + t_GDRW dst_gdrw; + gint src_width; + gint src_height; + + src_width = gimp_drawable_width (src_drawable_id); + src_height = gimp_drawable_height (src_drawable_id); + + new_image_id = gimp_image_new (PREVIEW_SIZE_X, PREVIEW_SIZE_Y, + gimp_image_base_type (gimp_item_get_image (src_drawable_id))); + gimp_image_undo_disable (new_image_id); + + type = gimp_drawable_type (src_drawable_id); + if (src_height > src_width) + { + new_height = PV_IMG_HEIGHT; + new_width = (src_width * new_height) / src_height; + scale = (float) src_height / PV_IMG_HEIGHT; + } + else + { + new_width = PV_IMG_WIDTH; + new_height = (src_height * new_width) / src_width; + scale = (float) src_width / PV_IMG_WIDTH; + } + + *layer_id = gimp_layer_new(new_image_id, "preview_original", + new_width, new_height, + type, + 100.0, /* opacity */ + 0); /* mode NORMAL */ + if (! gimp_drawable_has_alpha(*layer_id)) + { + /* always add alpha channel */ + gimp_layer_add_alpha(*layer_id); + } + + gimp_image_insert_layer(new_image_id, *layer_id, -1, 0); + + p_init_gdrw (&src_gdrw, src_drawable_id, FALSE); + p_init_gdrw (&dst_gdrw, *layer_id, FALSE); + + for (y = 0; y < new_height; y++) + { + for (x = 0; x < new_width; x++) + { + p_get_pixel(&src_gdrw, x * scale, y * scale, &pixel[0]); + p_put_pixel(&dst_gdrw, x, y, &pixel[0]); + } + } + + p_end_gdrw (&src_gdrw); + p_end_gdrw (&dst_gdrw); + + return new_image_id; +} + +/* ============================================================================ + * p_add_layer + * ============================================================================ + */ +static gint32 +p_add_layer (gint width, + gint height, + gint32 src_drawable_id) +{ + GimpImageType type; + gint32 new_layer_id; + char *name; + char *name2; + gdouble opacity; + GimpLayerMode mode; + gint visible; + gint32 image_id; + gint stack_position; + + image_id = gimp_item_get_image (src_drawable_id); + stack_position = 0; /* TODO: should be same as src_layer */ + + /* copy type, name, opacity and mode from src_drawable */ + type = gimp_drawable_type (src_drawable_id); + visible = gimp_item_get_visible (src_drawable_id); + + name2 = gimp_item_get_name (src_drawable_id); + name = g_strdup_printf ("%s_b", name2); + g_free (name2); + + mode = gimp_layer_get_mode (src_drawable_id); + opacity = gimp_layer_get_opacity (src_drawable_id); /* full opacity */ + + new_layer_id = gimp_layer_new (image_id, name, + width, height, + type, + opacity, + mode); + + g_free (name); + if (!gimp_drawable_has_alpha (new_layer_id)) + { + /* always add alpha channel */ + gimp_layer_add_alpha (new_layer_id); + } + + /* add the copied layer to the temp. working image */ + gimp_image_insert_layer (image_id, new_layer_id, -1, stack_position); + + /* copy visibility state */ + gimp_item_set_visible (new_layer_id, visible); + + return new_layer_id; +} + +/* ============================================================================ + * p_bender_calculate_iter_curve + * ============================================================================ + */ + +static void +p_bender_calculate_iter_curve (BenderDialog *cd, + gint32 xmax, + gint32 ymax) +{ + gint x; + gint outline; + BenderDialog *cd_from; + BenderDialog *cd_to; + + outline = cd->outline; + + if ((cd->bval_from == NULL) || + (cd->bval_to == NULL) || + (cd->bval_curr == NULL)) + { + if(gb_debug) g_printf("p_bender_calculate_iter_curve NORMAL1\n"); + if (cd->curve_type == SMOOTH) + { + cd->outline = OUTLINE_UPPER; + bender_calculate_curve (cd, xmax, ymax, FALSE); + cd->outline = OUTLINE_LOWER; + bender_calculate_curve (cd, xmax, ymax, FALSE); + } + else + { + p_stretch_curves(cd, xmax, ymax); + } + } + else + { + /* compose curves by iterating between FROM/TO values */ + if(gb_debug) g_printf ("p_bender_calculate_iter_curve ITERmode 1\n"); + + /* init FROM curves */ + cd_from = g_new (BenderDialog, 1); + p_cd_from_bval (cd_from, cd->bval_from); + cd_from->curve_ptr[OUTLINE_UPPER] = g_new (gint32, 1+xmax); + cd_from->curve_ptr[OUTLINE_LOWER] = g_new (gint32, 1+xmax); + + /* init TO curves */ + cd_to = g_new (BenderDialog, 1); + p_cd_from_bval (cd_to, cd->bval_to); + cd_to->curve_ptr[OUTLINE_UPPER] = g_new (gint32, 1+xmax); + cd_to->curve_ptr[OUTLINE_LOWER] = g_new (gint32, 1+xmax); + + if (cd_from->curve_type == SMOOTH) + { + /* calculate FROM curves */ + cd_from->outline = OUTLINE_UPPER; + bender_calculate_curve (cd_from, xmax, ymax, FALSE); + cd_from->outline = OUTLINE_LOWER; + bender_calculate_curve (cd_from, xmax, ymax, FALSE); + } + else + { + p_stretch_curves (cd_from, xmax, ymax); + } + + if (cd_to->curve_type == SMOOTH) + { + /* calculate TO curves */ + cd_to->outline = OUTLINE_UPPER; + bender_calculate_curve (cd_to, xmax, ymax, FALSE); + cd_to->outline = OUTLINE_LOWER; + bender_calculate_curve (cd_to, xmax, ymax, FALSE); + } + else + { + p_stretch_curves (cd_to, xmax, ymax); + } + + /* MIX Y-koords of the curves according to current iteration step */ + for (x = 0; x <= xmax; x++) + { + p_delta_gint32 (&cd->curve_ptr[OUTLINE_UPPER][x], + cd_from->curve_ptr[OUTLINE_UPPER][x], + cd_to->curve_ptr[OUTLINE_UPPER][x], + cd->bval_curr->total_steps, + cd->bval_curr->current_step); + + p_delta_gint32 (&cd->curve_ptr[OUTLINE_LOWER][x], + cd_from->curve_ptr[OUTLINE_LOWER][x], + cd_to->curve_ptr[OUTLINE_LOWER][x], + cd->bval_curr->total_steps, + cd->bval_curr->current_step); + } + + g_free (cd_from->curve_ptr[OUTLINE_UPPER]); + g_free (cd_from->curve_ptr[OUTLINE_LOWER]); + + g_free (cd_from); + g_free (cd_to); + } + + cd->outline = outline; +} + +/* ============================================================================ + * p_vertical_bend + * ============================================================================ + */ + +static void +p_vertical_bend (BenderDialog *cd, + t_GDRW *src_gdrw, + t_GDRW *dst_gdrw) +{ + gint32 row, col; + gint32 first_row, first_col, last_row, last_col; + gint32 x, y; + gint32 x2, y2; + gint32 curvy, nb_curvy, nb2_curvy; + gint32 desty, othery; + gint32 miny, maxy; + gint32 sign, dy, diff; + gint32 topshift; + float progress_step; + float progress_max; + float progress; + + t_Last *last_arr; + t_Last *first_arr; + guchar color[4]; + guchar mixcolor[4]; + gint alias_dir; + guchar mixmask; + + topshift = p_upper_curve_extend (cd, + src_gdrw->width, + src_gdrw->height); + diff = curvy = nb_curvy = nb2_curvy= miny = maxy = 0; + + /* allocate array of last values (one element foreach x coordinate) */ + last_arr = g_new (t_Last, src_gdrw->x2); + first_arr = g_new (t_Last, src_gdrw->x2); + + /* ------------------------------------------------ + * foreach pixel in the SAMPLE_drawable: + * ------------------------------------------------ + * the inner loops (x/y) are designed to process + * all pixels of one tile in the sample drawable, the outer loops (row/col) do step + * to the next tiles. (this was done to reduce tile swapping) + */ + + first_row = src_gdrw->y1 / src_gdrw->tile_height; + last_row = (src_gdrw->y2 / src_gdrw->tile_height); + first_col = src_gdrw->x1 / src_gdrw->tile_width; + last_col = (src_gdrw->x2 / src_gdrw->tile_width); + + /* init progress */ + progress_max = (1 + last_row - first_row) * (1 + last_col - first_col); + progress_step = 1.0 / progress_max; + progress = 0.0; + if (cd->show_progress) + gimp_progress_init ( _("Curve Bend")); + + for (row = first_row; row <= last_row; row++) + { + for (col = first_col; col <= last_col; col++) + { + if (col == first_col) + x = src_gdrw->x1; + else + x = col * src_gdrw->tile_width; + if (col == last_col) + x2 = src_gdrw->x2; + else + x2 = (col +1) * src_gdrw->tile_width; + + if (cd->show_progress) + gimp_progress_update (progress += progress_step); + + for( ; x < x2; x++) + { + if (row == first_row) + y = src_gdrw->y1; + else + y = row * src_gdrw->tile_height; + + if (row == last_row) + y2 = src_gdrw->y2; + else + y2 = (row +1) * src_gdrw->tile_height ; + + for( ; y < y2; y++) + { + /* ---------- copy SRC_PIXEL to curve position ------ */ + + p_get_pixel (src_gdrw, x, y, color); + + curvy = p_curve_get_dy (cd, x, + (gint32)src_gdrw->width, + (gint32)src_gdrw->height, + (gdouble)y); + desty = y + topshift + curvy; + + /* ----------- SMOOTHING ------------------ */ + if (cd->smoothing && (x > 0)) + { + nb_curvy = p_curve_get_dy (cd, x -1, + (gint32)src_gdrw->width, + (gint32)src_gdrw->height, + (gdouble)y); + if ((nb_curvy == curvy) && (x > 1)) + { + nb2_curvy = p_curve_get_dy (cd, x -2, + (gint32)src_gdrw->width, + (gint32)src_gdrw->height, + (gdouble)y); + } + else + { + nb2_curvy = nb_curvy; + } + + p_put_mix_pixel (dst_gdrw, x, desty, color, nb_curvy, nb2_curvy, curvy); + } + else + { + p_put_pixel (dst_gdrw, x, desty, color); + } + + /* ----------- render ANTIALIAS ------------------ */ + + if (cd->antialias) + { + othery = desty; + + if (y == src_gdrw->y1) /* Upper outline */ + { + first_arr[x].y = curvy; + memcpy (first_arr[x].color, color, + dst_gdrw->bpp); + + if (x > 0) + { + memcpy (mixcolor, first_arr[x-1].color, + dst_gdrw->bpp); + + diff = abs(first_arr[x - 1].y - curvy) +1; + miny = MIN(first_arr[x - 1].y, curvy) -1; + maxy = MAX(first_arr[x - 1].y, curvy) +1; + + othery = (src_gdrw->y2 -1) + + topshift + + p_curve_get_dy(cd, x, + (gint32)src_gdrw->width, + (gint32)src_gdrw->height, + (gdouble)(src_gdrw->y2 -1)); + } + } + + if (y == src_gdrw->y2 - 1) /* Lower outline */ + { + if (x > 0) + { + memcpy (mixcolor, last_arr[x-1].color, + dst_gdrw->bpp); + + diff = abs (last_arr[x - 1].y - curvy) +1; + maxy = MAX (last_arr[x - 1].y, curvy) +1; + miny = MIN (last_arr[x - 1].y, curvy) -1; + } + + othery = (src_gdrw->y1) + + topshift + + p_curve_get_dy(cd, x, + (gint32)src_gdrw->width, + (gint32)src_gdrw->height, + (gdouble)(src_gdrw->y1)); + } + + if(desty < othery) { alias_dir = 1; } /* fade to transp. with descending dy */ + else if(desty > othery) { alias_dir = -1; } /* fade to transp. with ascending dy */ + else { alias_dir = 0; } /* no antialias at curve crossing point(s) */ + + if (alias_dir != 0) + { + guchar alpha_lo = 20; + + if (gimp_drawable_has_alpha (src_gdrw->drawable_id)) + { + alpha_lo = MIN (20, mixcolor[src_gdrw->index_alpha]); + } + + for (dy = 0; dy < diff; dy++) + { + /* iterate for fading alpha channel */ + mixmask = 255 * ((gdouble)(dy + 1) / (gdouble) (diff+1)); + mixcolor[dst_gdrw->index_alpha] = MIX_CHANNEL(color[dst_gdrw->index_alpha], alpha_lo, mixmask); + + if(alias_dir > 0) + { + p_put_pixel (dst_gdrw, x -1, y + topshift + miny + dy, mixcolor); + } + else + { + p_put_pixel (dst_gdrw, x -1, y + topshift + (maxy - dy), mixcolor); + } + + } + } + } + + /* ------------------ FILL HOLES ------------------ */ + + if (y == src_gdrw->y1) + { + diff = 0; + sign = 1; + } + else + { + diff = last_arr[x].y - curvy; + if (diff < 0) + { + diff = 0 - diff; + sign = -1; + } + else + { + sign = 1; + } + + memcpy (mixcolor, color, dst_gdrw->bpp); + } + + for (dy = 1; dy <= diff; dy++) + { + /* y differs more than 1 pixel from last y in the + * destination drawable. So we have to fill the empty + * space between using a mixed color + */ + + if (cd->smoothing) + { + /* smoothing is on, so we are using a mixed color */ + gulong alpha1 = last_arr[x].color[3]; + gulong alpha2 = color[3]; + gulong alpha; + + mixmask = 255 * ((gdouble)(dy) / (gdouble)(diff+1)); + alpha = alpha1 * mixmask + alpha2 * (255 - mixmask); + mixcolor[3] = alpha/255; + if (mixcolor[3]) + { + mixcolor[0] = (alpha1 * mixmask * last_arr[x].color[0] + + alpha2 * (255 - mixmask) * color[0])/alpha; + mixcolor[1] = (alpha1 * mixmask * last_arr[x].color[1] + + alpha2 * (255 - mixmask) * color[1])/alpha; + mixcolor[2] = (alpha1 * mixmask * last_arr[x].color[2] + + alpha2 * (255 - mixmask) * color[2])/alpha; + /*mixcolor[2] = MIX_CHANNEL(last_arr[x].color[2], color[2], mixmask);*/ + } + } + else + { + /* smoothing is off, so we are using this color or + the last color */ + if (dy < diff / 2) + { + memcpy (mixcolor, color, + dst_gdrw->bpp); + } + else + { + memcpy (mixcolor, last_arr[x].color, + dst_gdrw->bpp); + } + } + + if (cd->smoothing) + { + p_put_mix_pixel (dst_gdrw, x, + desty + (dy * sign), + mixcolor, + nb_curvy, nb2_curvy, curvy ); + } + else + { + p_put_pixel (dst_gdrw, x, + desty + (dy * sign), mixcolor); + } + } + + /* store y and color */ + last_arr[x].y = curvy; + memcpy (last_arr[x].color, color, dst_gdrw->bpp); + } + } + } + } + + gimp_progress_update (1.0); + + g_free (last_arr); + g_free (first_arr); +} + +/* ============================================================================ + * p_main_bend + * ============================================================================ + */ + +static gint32 +p_main_bend (BenderDialog *cd, + guint32 original_drawable_id, + gint work_on_copy) +{ + t_GDRW src_gdrw; + t_GDRW dst_gdrw; + gint32 src_drawable_id; + gint32 dst_drawable_id; + gint src_width; + gint src_height; + gint32 dst_height; + gint32 image_id; + gint32 tmp_layer_id; + gint32 interpolation; + gint offset_x, offset_y; + gint center_x, center_y; + gint32 xmax, ymax; + + interpolation = cd->smoothing; + image_id = gimp_item_get_image (original_drawable_id); + gimp_drawable_offsets(original_drawable_id, &offset_x, &offset_y); + + center_x = offset_x + (gimp_drawable_width (original_drawable_id) / 2 ); + center_y = offset_y + (gimp_drawable_height (original_drawable_id) / 2 ); + + /* always copy original_drawable to a tmp src_layer */ + tmp_layer_id = gimp_layer_copy(original_drawable_id); + /* set layer invisible and dummyname and + * add at top of the image while working + * (for the case of undo GIMP must know, + * that the layer was part of the image) + */ + gimp_image_insert_layer (image_id, tmp_layer_id, -1, 0); + gimp_item_set_visible (tmp_layer_id, FALSE); + gimp_item_set_name (tmp_layer_id, "curve_bend_dummylayer"); + + if(gb_debug) g_printf("p_main_bend tmp_layer_id %d\n", (int)tmp_layer_id); + + if (cd->rotation != 0.0) + { + if(gb_debug) g_printf("p_main_bend rotate: %f\n", (float)cd->rotation); + p_gimp_rotate(image_id, tmp_layer_id, interpolation, cd->rotation); + } + + src_drawable_id = tmp_layer_id; + + src_width = gimp_drawable_width (tmp_layer_id); + src_height = gimp_drawable_height (tmp_layer_id); + + xmax = ymax = src_width -1; + cd->curve_ptr[OUTLINE_UPPER] = g_new (gint32, 1+xmax); + cd->curve_ptr[OUTLINE_LOWER] = g_new (gint32, 1+xmax); + + p_bender_calculate_iter_curve(cd, xmax, ymax); + bender_init_min_max(cd, xmax); + + dst_height = src_height + + p_upper_curve_extend(cd, src_width, src_height) + + p_lower_curve_extend(cd, src_width, src_height); + + if(gb_debug) g_printf("p_main_bend: dst_height:%d\n", dst_height); + + if (work_on_copy) + { + dst_drawable_id = p_add_layer (src_width, dst_height, + src_drawable_id); + if (gb_debug) g_printf("p_main_bend: DONE add layer\n"); + } + else + { + /* work on the original */ + gimp_layer_resize (original_drawable_id, + src_width, + dst_height, + offset_x, offset_y); + if (gb_debug) g_printf("p_main_bend: DONE layer resize\n"); + if (! gimp_drawable_has_alpha (original_drawable_id)) + { + /* always add alpha channel */ + gimp_layer_add_alpha (original_drawable_id); + } + + dst_drawable_id = original_drawable_id; + } + + gimp_drawable_fill (dst_drawable_id, GIMP_FILL_TRANSPARENT); + + p_init_gdrw (&src_gdrw, src_drawable_id, FALSE); + p_init_gdrw (&dst_gdrw, dst_drawable_id, FALSE); + + p_vertical_bend (cd, &src_gdrw, &dst_gdrw); + + if(gb_debug) g_printf("p_main_bend: DONE vertical bend\n"); + + p_end_gdrw (&src_gdrw); + p_end_gdrw (&dst_gdrw); + + if (cd->rotation != 0.0) + { + p_gimp_rotate (image_id, dst_drawable_id, + interpolation, (gdouble)(360.0 - cd->rotation)); + + /* TODO: here we should crop dst_drawable to cut off full transparent borderpixels */ + } + + /* set offsets of the resulting new layer + *(center == center of original_drawable) + */ + offset_x = center_x - (gimp_drawable_width (dst_drawable_id) / 2 ); + offset_y = center_y - (gimp_drawable_height (dst_drawable_id) / 2 ); + gimp_layer_set_offsets (dst_drawable_id, offset_x, offset_y); + + /* delete the temp layer */ + gimp_image_remove_layer (image_id, tmp_layer_id); + + g_free (cd->curve_ptr[OUTLINE_UPPER]); + g_free (cd->curve_ptr[OUTLINE_LOWER]); + + if (gb_debug) g_printf("p_main_bend: DONE bend main\n"); + + return dst_drawable_id; +} -- cgit v1.2.3