/* Page Curl 0.9 --- image filter plug-in for PIKA * Copyright (C) 1996 Federico Mena Quintero * Ported to Pika 1.0 1998 by Simon Budig * * You can contact me at quartic@polloux.fciencias.unam.mx * You can contact the original PIKA authors at pika@xcf.berkeley.edu * * 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 . * */ /* * Ported to the 0.99.x architecture by Simon Budig, Simon.Budig@unix-ag.org * Ported to the 3.0 plug-in API by Michael Natterer */ /* * Version History * 0.5: (1996) Version for Pika 0.54 by Federico Mena Quintero * 0.6: (Feb '98) First Version for Pika 0.99.x, very buggy. * 0.8: (Mar '98) First "stable" version * 0.9: (May '98) * - Added support for Gradients. It is now possible to map * a gradient to the back of the curl. * - This implies a changed PDB-Interface: New "mode" parameter. * - Pagecurl now returns the ID of the new layer. * - Exchanged the meaning of FG/BG Color, because mostly the FG * color is darker. * 1.0: (July '04) * - Code cleanup, added reverse gradient option. */ #include "config.h" #include #include #include "libpika/stdplugins-intl.h" #define PLUG_IN_PROC "plug-in-pagecurl" #define PLUG_IN_BINARY "pagecurl" #define PLUG_IN_ROLE "pika-pagecurl" #define PLUG_IN_VERSION "July 2004, 1.0" #define NGRADSAMPLES 256 typedef enum { CURL_COLORS_FG_BG, CURL_COLORS_GRADIENT, CURL_COLORS_GRADIENT_REVERSE, CURL_COLORS_LAST = CURL_COLORS_GRADIENT_REVERSE } CurlColors; typedef enum { CURL_ORIENTATION_VERTICAL, CURL_ORIENTATION_HORIZONTAL, CURL_ORIENTATION_LAST = CURL_ORIENTATION_HORIZONTAL } CurlOrientation; typedef enum { CURL_EDGE_LOWER_RIGHT = 1, CURL_EDGE_LOWER_LEFT = 2, CURL_EDGE_UPPER_LEFT = 3, CURL_EDGE_UPPER_RIGHT = 4, CURL_EDGE_FIRST = CURL_EDGE_LOWER_RIGHT, CURL_EDGE_LAST = CURL_EDGE_UPPER_RIGHT } CurlEdge; #define CURL_EDGE_LEFT(e) ((e) == CURL_EDGE_LOWER_LEFT || \ (e) == CURL_EDGE_UPPER_LEFT) #define CURL_EDGE_RIGHT(e) ((e) == CURL_EDGE_LOWER_RIGHT || \ (e) == CURL_EDGE_UPPER_RIGHT) #define CURL_EDGE_LOWER(e) ((e) == CURL_EDGE_LOWER_RIGHT || \ (e) == CURL_EDGE_LOWER_LEFT) #define CURL_EDGE_UPPER(e) ((e) == CURL_EDGE_UPPER_LEFT || \ (e) == CURL_EDGE_UPPER_RIGHT) typedef struct _Pagecurl Pagecurl; typedef struct _PagecurlClass PagecurlClass; struct _Pagecurl { PikaPlugIn parent_instance; }; struct _PagecurlClass { PikaPlugInClass parent_class; }; #define PAGECURL_TYPE (pagecurl_get_type ()) #define PAGECURL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PAGECURL_TYPE, Pagecurl)) GType pagecurl_get_type (void) G_GNUC_CONST; static GList * pagecurl_query_procedures (PikaPlugIn *plug_in); static PikaProcedure * pagecurl_create_procedure (PikaPlugIn *plug_in, const gchar *name); static PikaValueArray * pagecurl_run (PikaProcedure *procedure, PikaRunMode run_mode, PikaImage *image, gint n_drawables, PikaDrawable **drawables, PikaProcedureConfig *config, gpointer run_data); static gboolean dialog (PikaProcedure *procedure, PikaProcedureConfig *config); static void init_calculation (PikaDrawable *drawable, PikaProcedureConfig *config); static PikaLayer * do_curl_effect (PikaDrawable *drawable, PikaProcedureConfig *config); static void clear_curled_region (PikaDrawable *drawable, PikaProcedureConfig *config); static PikaLayer * page_curl (PikaDrawable *drawable, PikaProcedureConfig *config); static PikaRGB * get_gradient_samples (PikaDrawable *drawable, gboolean reverse); G_DEFINE_TYPE (Pagecurl, pagecurl, PIKA_TYPE_PLUG_IN) PIKA_MAIN (PAGECURL_TYPE) DEFINE_STD_SET_I18N /* Image parameters */ static PikaImage *image = NULL; static gint sel_x, sel_y; static gint true_sel_width, true_sel_height; static gint sel_width, sel_height; static gint drawable_position; /* Center and radius of circle */ static PikaVector2 center; static double radius; /* Useful points to keep around */ static PikaVector2 left_tangent; static PikaVector2 right_tangent; /* Slopes --- these are *not* in the usual geometric sense! */ static gdouble diagl_slope; static gdouble diagr_slope; static gdouble diagb_slope; static gdouble diagm_slope; /* User-configured parameters */ static PikaRGB fg_color; static PikaRGB bg_color; static void pagecurl_class_init (PagecurlClass *klass) { PikaPlugInClass *plug_in_class = PIKA_PLUG_IN_CLASS (klass); plug_in_class->query_procedures = pagecurl_query_procedures; plug_in_class->create_procedure = pagecurl_create_procedure; plug_in_class->set_i18n = STD_SET_I18N; } static void pagecurl_init (Pagecurl *pagecurl) { } static GList * pagecurl_query_procedures (PikaPlugIn *plug_in) { return g_list_append (NULL, g_strdup (PLUG_IN_PROC)); } static PikaProcedure * pagecurl_create_procedure (PikaPlugIn *plug_in, const gchar *name) { PikaProcedure *procedure = NULL; if (! strcmp (name, PLUG_IN_PROC)) { procedure = pika_image_procedure_new (plug_in, name, PIKA_PDB_PROC_TYPE_PLUGIN, pagecurl_run, NULL, NULL); pika_procedure_set_image_types (procedure, "RGB*, GRAY*"); pika_procedure_set_sensitivity_mask (procedure, PIKA_PROCEDURE_SENSITIVE_DRAWABLE); pika_procedure_set_menu_label (procedure, _("_Pagecurl...")); pika_procedure_add_menu_path (procedure, "/Filters/Distorts"); pika_procedure_set_documentation (procedure, _("Curl up one of the image corners"), "This plug-in creates a pagecurl-effect.", name); pika_procedure_set_attribution (procedure, "Federico Mena Quintero and Simon Budig", "Federico Mena Quintero and Simon Budig", PLUG_IN_VERSION); PIKA_PROC_ARG_CHOICE (procedure, "colors", _("Colors"), NULL, pika_choice_new_with_values ("fg-bg", CURL_COLORS_FG_BG, _("Foreground / background colors"), NULL, "current-gradient", CURL_COLORS_GRADIENT, _("Current gradient"), NULL, "current-gradient-reversed", CURL_COLORS_GRADIENT_REVERSE, _("Current gradient (reversed)"), NULL, NULL), "fg-bg", G_PARAM_READWRITE); PIKA_PROC_ARG_CHOICE (procedure, "edge", _("Locatio_n"), _("Corner which is curled"), pika_choice_new_with_values ("upper-left", CURL_EDGE_UPPER_LEFT, _("Upper left"), NULL, "upper-right", CURL_EDGE_UPPER_RIGHT, _("Upper right"), NULL, "lower-left", CURL_EDGE_LOWER_LEFT, _("Lower left"), NULL, "lower-right", CURL_EDGE_LOWER_RIGHT, _("Lower right"), NULL, NULL), "lower-right", G_PARAM_READWRITE); PIKA_PROC_ARG_CHOICE (procedure, "orientation", _("Or_ientation"), NULL, pika_choice_new_with_values ("vertical", CURL_ORIENTATION_VERTICAL, _("Vertical"), NULL, "horizontal", CURL_ORIENTATION_HORIZONTAL, _("Horizontal"), NULL, NULL), "vertical", G_PARAM_READWRITE); PIKA_PROC_ARG_BOOLEAN (procedure, "shade", _("Sh_ade"), _("Shade the region under the curl"), TRUE, G_PARAM_READWRITE); PIKA_PROC_ARG_DOUBLE (procedure, "opacity", _("Opaci_ty"), _("Opacity"), 0.0, 1.0, 0.0, PIKA_PARAM_READWRITE); PIKA_PROC_VAL_LAYER (procedure, "curl-layer", "Curl layer", "The new layer with the curl.", FALSE, G_PARAM_READWRITE); } return procedure; } static PikaValueArray * pagecurl_run (PikaProcedure *procedure, PikaRunMode run_mode, PikaImage *_image, gint n_drawables, PikaDrawable **drawables, PikaProcedureConfig *config, gpointer run_data) { PikaDrawable *drawable; PikaValueArray *return_vals = NULL; gegl_init (NULL, NULL); image = _image; if (n_drawables != 1) { GError *error = NULL; g_set_error (&error, PIKA_PLUG_IN_ERROR, 0, _("Procedure '%s' only works with one drawable."), pika_procedure_get_name (procedure)); return pika_procedure_new_return_values (procedure, PIKA_PDB_CALLING_ERROR, error); } else { drawable = drawables[0]; } if (! pika_drawable_mask_intersect (drawable, &sel_x, &sel_y, &true_sel_width, &true_sel_height)) { return pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL); } if (! (pika_drawable_is_rgb (drawable) || pika_drawable_is_gray (drawable))) { /* Sorry - no indexed/noalpha images */ return pika_procedure_new_return_values (procedure, PIKA_PDB_EXECUTION_ERROR, NULL); } if (run_mode == PIKA_RUN_INTERACTIVE && ! dialog (procedure, config)) return pika_procedure_new_return_values (procedure, PIKA_PDB_CANCEL, NULL); return_vals = pika_procedure_new_return_values (procedure, PIKA_PDB_SUCCESS, NULL); PIKA_VALUES_SET_LAYER (return_vals, 1, page_curl (drawable, config)); if (run_mode != PIKA_RUN_NONINTERACTIVE) pika_displays_flush (); return return_vals; } /***************************************************** * Functions to locate the current point in the curl. * The following functions assume an curl in the * lower right corner. * diagb crosses the two tangential points from the * circle with diagl and diagr. * * +------------------------------------------------+ * | __-- /| * | __-- _/ | * | __-- / | * | __-- _/ | * | __-- / | * | __--____ _/ | * | __----~~ \ _/ | * | __-- | _/ | * | diagl __-- _/| _/diagr | * | __-- diagm_/ |/ | * | __-- /___/ | * +-------------------------+----------------------+ */ static inline gboolean left_of_diagl (gdouble x, gdouble y) { return (x < (sel_width + (y - sel_height) * diagl_slope)); } static inline gboolean right_of_diagr (gdouble x, gdouble y) { return (x > (sel_width + (y - sel_height) * diagr_slope)); } static inline gboolean below_diagb (gdouble x, gdouble y) { return (y < (right_tangent.y + (x - right_tangent.x) * diagb_slope)); } static inline gboolean right_of_diagm (gdouble x, gdouble y) { return (x > (sel_width + (y - sel_height) * diagm_slope)); } static inline gboolean inside_circle (gdouble x, gdouble y) { x -= center.x; y -= center.y; return x * x + y * y <= radius * radius; } /********************************************************************/ /* dialog callbacks */ /********************************************************************/ static void curl_pixbuf_update (PikaProcedureConfig *config, const GParamSpec *pspec, GtkWidget *curl_image) { GdkPixbuf *pixbuf; gint index; gchar *resource; CurlEdge edge; CurlOrientation orientation; edge = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "edge"); switch (edge) { case CURL_EDGE_LOWER_RIGHT: index = 0; break; case CURL_EDGE_LOWER_LEFT: index = 1; break; case CURL_EDGE_UPPER_RIGHT: index = 2; break; case CURL_EDGE_UPPER_LEFT: index = 3; break; default: return; } orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation"); index += orientation * 4; resource = g_strdup_printf ("/technology.heckin/pagecurl-icons/curl%c.png", '0' + index); pixbuf = gdk_pixbuf_new_from_resource (resource, NULL); g_free (resource); gtk_image_set_from_pixbuf (GTK_IMAGE (curl_image), pixbuf); g_object_unref (pixbuf); } static gboolean dialog (PikaProcedure *procedure, PikaProcedureConfig *config) { /* Missing options: Color-dialogs? / own curl layer ? / transparency to original drawable / Warp-curl (unsupported yet) */ GtkWidget *dialog; GtkWidget *curl_image; gboolean run; pika_ui_init (PLUG_IN_BINARY); dialog = pika_procedure_dialog_new (procedure, PIKA_PROCEDURE_CONFIG (config), _("Pagecurl Effect")); pika_procedure_dialog_get_spin_scale (PIKA_PROCEDURE_DIALOG (dialog), "opacity", 100.0); pika_procedure_dialog_fill (PIKA_PROCEDURE_DIALOG (dialog), "edge", "orientation", "shade", "colors", "opacity", NULL); curl_image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), curl_image, FALSE, FALSE, 0); gtk_widget_show (curl_image); g_signal_connect (config, "notify", G_CALLBACK (curl_pixbuf_update), curl_image); curl_pixbuf_update (config, NULL, curl_image); run = pika_procedure_dialog_run (PIKA_PROCEDURE_DIALOG (dialog)); gtk_widget_destroy (dialog); return run; } static void init_calculation (PikaDrawable *drawable, PikaProcedureConfig *config) { gdouble k; gdouble alpha, beta; gdouble angle; PikaVector2 v1, v2; GList *layers; CurlOrientation orientation; orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation"); pika_layer_add_alpha (PIKA_LAYER (drawable)); /* Image parameters */ /* Determine Position of original Layer in the Layer stack. */ layers = pika_image_list_layers (image); drawable_position = g_list_index (layers, drawable); g_list_free (layers); switch (orientation) { case CURL_ORIENTATION_VERTICAL: sel_width = true_sel_width; sel_height = true_sel_height; break; case CURL_ORIENTATION_HORIZONTAL: sel_width = true_sel_height; sel_height = true_sel_width; break; } /* Circle parameters */ alpha = atan ((double) sel_height / sel_width); beta = alpha / 2.0; k = sel_width / ((G_PI + alpha) * sin (beta) + cos (beta)); pika_vector2_set (¢er, k * cos (beta), k * sin (beta)); radius = center.y; /* left_tangent */ pika_vector2_set (&left_tangent, radius * -sin (alpha), radius * cos (alpha)); pika_vector2_add (&left_tangent, &left_tangent, ¢er); /* right_tangent */ pika_vector2_sub (&v1, &left_tangent, ¢er); pika_vector2_set (&v2, sel_width - center.x, sel_height - center.y); angle = -2.0 * acos (pika_vector2_inner_product (&v1, &v2) / (pika_vector2_length (&v1) * pika_vector2_length (&v2))); pika_vector2_set (&right_tangent, v1.x * cos (angle) + v1.y * -sin (angle), v1.x * sin (angle) + v1.y * cos (angle)); pika_vector2_add (&right_tangent, &right_tangent, ¢er); /* Slopes */ diagl_slope = (double) sel_width / sel_height; diagr_slope = (sel_width - right_tangent.x) / (sel_height - right_tangent.y); diagb_slope = ((right_tangent.y - left_tangent.y) / (right_tangent.x - left_tangent.x)); diagm_slope = (sel_width - center.x) / sel_height; /* Colors */ pika_context_get_foreground (&fg_color); pika_context_get_background (&bg_color); } static PikaLayer * do_curl_effect (PikaDrawable *drawable, PikaProcedureConfig *config) { gint x = 0; gint y = 0; gboolean color_image; gint x1, y1; guint progress, max_progress; gdouble intensity, alpha; PikaVector2 v, dl, dr; gdouble dl_mag, dr_mag, angle, factor; GeglBuffer *curl_buffer; PikaLayer *curl_layer; PikaRGB *grad_samples = NULL; gint width, height, n_ch; GeglRectangle *roi; GeglBufferIterator *iter; const Babl *format; CurlOrientation orientation; CurlColors colors; CurlEdge edge; gboolean shade; gdouble opacity; orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation"); colors = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "colors"); edge = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "edge"); g_object_get (config, "shade", &shade, "opacity", &opacity, NULL); color_image = pika_drawable_is_rgb (drawable); curl_layer = pika_layer_new (image, _("Curl Layer"), true_sel_width, true_sel_height, color_image ? PIKA_RGBA_IMAGE : PIKA_GRAYA_IMAGE, 100, pika_image_get_default_new_layer_mode (image)); pika_image_insert_layer (image, curl_layer, PIKA_LAYER (pika_item_get_parent (PIKA_ITEM (drawable))), drawable_position); pika_drawable_fill (PIKA_DRAWABLE (curl_layer), PIKA_FILL_TRANSPARENT); pika_drawable_get_offsets (drawable, &x1, &y1); pika_layer_set_offsets (curl_layer, sel_x + x1, sel_y + y1); curl_buffer = pika_drawable_get_shadow_buffer (PIKA_DRAWABLE (curl_layer)); width = gegl_buffer_get_width (curl_buffer); height = gegl_buffer_get_height (curl_buffer); format = babl_format ("R'G'B'A float"); n_ch = babl_format_get_n_components (format); iter = gegl_buffer_iterator_new (curl_buffer, GEGL_RECTANGLE (0, 0, width, height), 0, format, GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); /* Init shade_under */ pika_vector2_set (&dl, -sel_width, -sel_height); dl_mag = pika_vector2_length (&dl); pika_vector2_set (&dr, -(sel_width - right_tangent.x), -(sel_height - right_tangent.y)); dr_mag = pika_vector2_length (&dr); alpha = acos (pika_vector2_inner_product (&dl, &dr) / (dl_mag * dr_mag)); /* Gradient Samples */ switch (colors) { case CURL_COLORS_FG_BG: break; case CURL_COLORS_GRADIENT: grad_samples = get_gradient_samples (PIKA_DRAWABLE (curl_layer), FALSE); break; case CURL_COLORS_GRADIENT_REVERSE: grad_samples = get_gradient_samples (PIKA_DRAWABLE (curl_layer), TRUE); break; } max_progress = 2 * sel_width * sel_height; progress = 0; /* Main loop */ while (gegl_buffer_iterator_next (iter)) { gfloat *dest; roi = &iter->items[0].roi; dest = (gfloat *) iter->items[0].data; for (y1 = roi->y; y1 < roi->y + roi->height; y1++) { PikaRGB color; for (x1 = roi->x; x1 < roi->x + roi->width; x1++) { /* Map coordinates to get the curl correct... */ switch (orientation) { case CURL_ORIENTATION_VERTICAL: x = CURL_EDGE_RIGHT (edge) ? x1 : sel_width - 1 - x1; y = CURL_EDGE_UPPER (edge) ? y1 : sel_height - 1 - y1; break; case CURL_ORIENTATION_HORIZONTAL: x = CURL_EDGE_LOWER (edge) ? y1 : sel_width - 1 - y1; y = CURL_EDGE_LEFT (edge) ? x1 : sel_height - 1 - x1; break; } if (left_of_diagl (x, y)) { /* uncurled region: transparent black */ pika_rgba_set (&color, 0, 0, 0, 0); } else if (right_of_diagr (x, y) || (right_of_diagm (x, y) && below_diagb (x, y) && !inside_circle (x, y))) { /* curled region: transparent black */ pika_rgba_set (&color, 0, 0, 0, 0); } else { v.x = -(sel_width - x); v.y = -(sel_height - y); angle = acos (pika_vector2_inner_product (&v, &dl) / (pika_vector2_length (&v) * dl_mag)); if (inside_circle (x, y) || below_diagb (x, y)) { /* Below the curl. */ factor = angle / alpha; pika_rgba_set (&color, 0, 0, 0, shade ? factor : 0); } else { PikaRGB *gradrgb; /* On the curl */ switch (colors) { case CURL_COLORS_FG_BG: intensity = pow (sin (G_PI * angle / alpha), 1.5); pika_rgba_set (&color, intensity * bg_color.r + (1.0 - intensity) * fg_color.r, intensity * bg_color.g + (1.0 - intensity) * fg_color.g, intensity * bg_color.b + (1.0 - intensity) * fg_color.b, (1.0 - intensity * (1.0 - opacity))); break; case CURL_COLORS_GRADIENT: case CURL_COLORS_GRADIENT_REVERSE: /* Calculate position in Gradient */ intensity = (angle/alpha) + sin (G_PI*2 * angle/alpha) * 0.075; gradrgb = grad_samples + ((guint) (intensity * NGRADSAMPLES)); /* Check boundaries */ intensity = CLAMP (intensity, 0.0, 1.0); color = *gradrgb; color.a = gradrgb->a * (1.0 - intensity * (1.0 - opacity)); break; } } } dest[0] = color.r; dest[1] = color.g; dest[2] = color.b; dest[3] = color.a; dest += n_ch; } } progress += roi->width * roi->height; pika_progress_update ((double) progress / (double) max_progress); } pika_progress_update (0.5); gegl_buffer_flush (curl_buffer); pika_drawable_merge_shadow (PIKA_DRAWABLE (curl_layer), FALSE); pika_drawable_update (PIKA_DRAWABLE (curl_layer), 0, 0, width, height); g_free (grad_samples); return curl_layer; } /************************************************/ static void clear_curled_region (PikaDrawable *drawable, PikaProcedureConfig *config) { gint x = 0; gint y = 0; guint x1, y1; gfloat *dest, *src; guint progress, max_progress; GeglBuffer *buf; GeglBuffer *shadow_buf; GeglRectangle *roi; GeglBufferIterator *iter; const Babl *format; gint width, height, bpp, n_ch; gint buf_index; CurlOrientation orientation; CurlEdge edge; orientation = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "orientation"); edge = pika_procedure_config_get_choice_id (PIKA_PROCEDURE_CONFIG (config), "edge"); max_progress = 2 * sel_width * sel_height; progress = max_progress / 2; buf = pika_drawable_get_buffer (drawable); shadow_buf = pika_drawable_get_shadow_buffer (drawable); width = gegl_buffer_get_width (buf); height = gegl_buffer_get_height (buf); format = babl_format ("R'G'B'A float"); bpp = babl_format_get_bytes_per_pixel (format); n_ch = babl_format_get_n_components (format); iter = gegl_buffer_iterator_new (shadow_buf, GEGL_RECTANGLE (0, 0, width, height), 0, format, GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 2); buf_index = gegl_buffer_iterator_add (iter, buf, NULL, 0, format, GEGL_ACCESS_READ, GEGL_ABYSS_NONE); while (gegl_buffer_iterator_next (iter)) { roi = &iter->items[0].roi; dest = iter->items[0].data; src = iter->items[buf_index].data; memcpy (dest, src, roi->width * roi->height * bpp); for (y1 = roi->y; y1 < roi->y + roi->height; y1++) { for (x1 = roi->x; x1 < roi->x + roi->width; x1++) { /* Map coordinates to get the curl correct... */ switch (orientation) { case CURL_ORIENTATION_VERTICAL: x = (CURL_EDGE_RIGHT (edge) ? x1 - sel_x : sel_width - 1 - (x1 - sel_x)); y = (CURL_EDGE_UPPER (edge) ? y1 - sel_y : sel_height - 1 - (y1 - sel_y)); break; case CURL_ORIENTATION_HORIZONTAL: x = (CURL_EDGE_LOWER (edge) ? y1 - sel_y : sel_width - 1 - (y1 - sel_y)); y = (CURL_EDGE_LEFT (edge) ? x1 - sel_x : sel_height - 1 - (x1 - sel_x)); break; } if (right_of_diagr (x, y) || (right_of_diagm (x, y) && below_diagb (x, y) && !inside_circle (x, y))) { /* Right of the curl: Alpha = 0 */ dest[0] = src[0]; dest[1] = src[1]; dest[2] = src[2]; dest[3] = 0.0; } dest += n_ch; src += n_ch; } } progress += roi->width * roi->height; pika_progress_update ((double) progress / (double) max_progress); } pika_progress_update (1.0); gegl_buffer_flush (shadow_buf); pika_drawable_merge_shadow (drawable, TRUE); pika_drawable_update (drawable, sel_x, sel_y, true_sel_width, true_sel_height); } static PikaLayer * page_curl (PikaDrawable *drawable, PikaProcedureConfig *config) { PikaLayer *curl_layer; pika_image_undo_group_start (image); pika_progress_init (_("Page Curl")); init_calculation (drawable, config); curl_layer = do_curl_effect (drawable, config); clear_curled_region (drawable, config); pika_image_undo_group_end (image); return curl_layer; } /* Returns NGRADSAMPLES samples of active gradient. Each sample has (pika_drawable_get_bpp (drawable)) bytes. "ripped" from gradmap.c. */ static PikaRGB * get_gradient_samples (PikaDrawable *drawable, gboolean reverse) { PikaGradient *gradient; gint n_d_samples; gdouble *d_samples = NULL; PikaRGB *rgba; gint i; gradient = pika_context_get_gradient (); pika_gradient_get_uniform_samples (gradient, NGRADSAMPLES, reverse, &n_d_samples, &d_samples); rgba = g_new0 (PikaRGB, NGRADSAMPLES); for (i = 0; i < NGRADSAMPLES; i++) { pika_rgba_set (rgba + i, d_samples[i*4 + 0], d_samples[i*4 + 1], d_samples[i*4 + 2], d_samples[i*4 + 3]); } return rgba; }