From a779e74817c44f702ef6b35eddd16a7e6d29fa75 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Fri, 12 Mar 2004 22:46:25 +0000 Subject: [PATCH] Cleaned up the remaining libgimp API issues: 2004-03-12 Michael Natterer Cleaned up the remaining libgimp API issues: * libgimp/gimppixelfetcher.[ch] (enum GimpPixelFetcherEdgeMode): added new enum value GIMP_PIXEL_FETCHER_EDGE_BACKGROUND so we can actually use the bg_color feature of the GimpPixelFetcher. (gimp_pixel_fetcher_new): added "gboolean shadow" parameter because it must not change while the GimpPixelFetcher exists. (gimp_pixel_fetcher_set_shadow): removed. (gimp_pixel_fetcher_set_bg_color): added "GimpRGB *color" parameter and don't call gimp_palette_get_foreground(). (gimp_pixel_fetcher_get_pixel): handle BACKGROUND mode. Cleaned up the function. (gimp_get_bg_guchar) (gimp_get_fg_guchar): removed these functions... * libgimp/gimpdrawable.[ch]: ...and added gimp_drawable_get_color_uchar() instead. * libgimp/gimp.def * plug-ins/common/blinds.c * plug-ins/common/checkerboard.c * plug-ins/common/cubism.c * plug-ins/common/curve_bend.c * plug-ins/common/displace.c * plug-ins/common/edge.c * plug-ins/common/illusion.c * plug-ins/common/mblur.c * plug-ins/common/mosaic.c * plug-ins/common/plasma.c * plug-ins/common/polar.c * plug-ins/common/ripple.c * plug-ins/common/shift.c * plug-ins/common/spread.c * plug-ins/common/tileit.c * plug-ins/common/whirlpinch.c * plug-ins/gflare/gflare.c * plug-ins/libgimpoldpreview/gimpoldpreview.c: changed accordingly. (Didn't test the changed plug-ins because I wanted to get this API change into CVS as soon as possible) --- ChangeLog | 48 +++ libgimp/gimp.def | 4 +- libgimp/gimpdrawable.c | 37 +++ libgimp/gimpdrawable.h | 4 + libgimp/gimppixelfetcher.c | 325 +++++++++----------- libgimp/gimppixelfetcher.h | 39 +-- plug-ins/common/blinds.c | 46 ++- plug-ins/common/checkerboard.c | 12 +- plug-ins/common/cubism.c | 53 ++-- plug-ins/common/curve_bend.c | 10 +- plug-ins/common/displace.c | 2 +- plug-ins/common/edge.c | 21 +- plug-ins/common/illusion.c | 11 +- plug-ins/common/mblur.c | 30 +- plug-ins/common/mosaic.c | 27 +- plug-ins/common/plasma.c | 3 +- plug-ins/common/polar.c | 59 ++-- plug-ins/common/ripple.c | 28 +- plug-ins/common/shift.c | 27 +- plug-ins/common/spread.c | 32 +- plug-ins/common/tileit.c | 154 +++++----- plug-ins/common/whirlpinch.c | 32 +- plug-ins/gflare/gflare.c | 5 +- plug-ins/libgimpoldpreview/gimpoldpreview.c | 3 +- 24 files changed, 556 insertions(+), 456 deletions(-) diff --git a/ChangeLog b/ChangeLog index 4115738182..689b41345c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,51 @@ +2004-03-12 Michael Natterer + + Cleaned up the remaining libgimp API issues: + + * libgimp/gimppixelfetcher.[ch] (enum GimpPixelFetcherEdgeMode): + added new enum value GIMP_PIXEL_FETCHER_EDGE_BACKGROUND so we + can actually use the bg_color feature of the GimpPixelFetcher. + + (gimp_pixel_fetcher_new): added "gboolean shadow" parameter + because it must not change while the GimpPixelFetcher exists. + + (gimp_pixel_fetcher_set_shadow): removed. + + (gimp_pixel_fetcher_set_bg_color): added "GimpRGB *color" + parameter and don't call gimp_palette_get_foreground(). + + (gimp_pixel_fetcher_get_pixel): handle BACKGROUND mode. Cleaned up + the function. + + (gimp_get_bg_guchar) + (gimp_get_fg_guchar): removed these functions... + + * libgimp/gimpdrawable.[ch]: ...and added + gimp_drawable_get_color_uchar() instead. + + * libgimp/gimp.def + * plug-ins/common/blinds.c + * plug-ins/common/checkerboard.c + * plug-ins/common/cubism.c + * plug-ins/common/curve_bend.c + * plug-ins/common/displace.c + * plug-ins/common/edge.c + * plug-ins/common/illusion.c + * plug-ins/common/mblur.c + * plug-ins/common/mosaic.c + * plug-ins/common/plasma.c + * plug-ins/common/polar.c + * plug-ins/common/ripple.c + * plug-ins/common/shift.c + * plug-ins/common/spread.c + * plug-ins/common/tileit.c + * plug-ins/common/whirlpinch.c + * plug-ins/gflare/gflare.c + * plug-ins/libgimpoldpreview/gimpoldpreview.c: changed accordingly. + + (Didn't test the changed plug-ins because I wanted to get this + API change into CVS as soon as possible) + 2004-03-12 Raphaël Quinet * app/core/gimpdrawable-transform.c (RECURSION_LEVEL): Set to 0 in diff --git a/libgimp/gimp.def b/libgimp/gimp.def index 02a3b12eeb..77fc9d4b22 100644 --- a/libgimp/gimp.def +++ b/libgimp/gimp.def @@ -54,6 +54,7 @@ EXPORTS gimp_drawable_fill gimp_drawable_flush gimp_drawable_get + gimp_drawable_get_color_uchar gimp_drawable_get_image gimp_drawable_get_linked gimp_drawable_get_name @@ -121,9 +122,7 @@ EXPORTS gimp_free_select gimp_fuzzy_select gimp_gamma - gimp_get_bg_guchar gimp_get_default_comment - gimp_get_fg_guchar gimp_get_module_load_inhibit gimp_get_monitor_resolution gimp_get_path_by_tattoo @@ -314,7 +313,6 @@ EXPORTS gimp_pixel_fetcher_put_pixel gimp_pixel_fetcher_set_bg_color gimp_pixel_fetcher_set_edge_mode - gimp_pixel_fetcher_set_shadow gimp_pixel_rgn_get_col gimp_pixel_rgn_get_pixel gimp_pixel_rgn_get_rect diff --git a/libgimp/gimpdrawable.c b/libgimp/gimpdrawable.c index d7931574d8..8c45d353bc 100644 --- a/libgimp/gimpdrawable.c +++ b/libgimp/gimpdrawable.c @@ -182,6 +182,43 @@ gimp_drawable_get_tile2 (GimpDrawable *drawable, return gimp_drawable_get_tile (drawable, shadow, row, col); } +void +gimp_drawable_get_color_uchar (gint32 drawable_ID, + const GimpRGB *color, + guchar *color_uchar) +{ + g_return_if_fail (color != NULL); + g_return_if_fail (color_uchar != NULL); + + switch (gimp_drawable_type (drawable_ID)) + { + case GIMP_RGB_IMAGE: + gimp_rgb_get_uchar (color, + &color_uchar[0], &color_uchar[1], &color_uchar[2]); + color_uchar[3] = 255; + break; + + case GIMP_RGBA_IMAGE: + gimp_rgba_get_uchar (color, + &color_uchar[0], &color_uchar[1], &color_uchar[2], + &color_uchar[3]); + break; + + case GIMP_GRAY_IMAGE: + color_uchar[0] = gimp_rgb_intensity_uchar (color); + color_uchar[1] = 255; + break; + + case GIMP_GRAYA_IMAGE: + color_uchar[0] = gimp_rgb_intensity_uchar (color); + gimp_rgba_get_uchar (color, NULL, NULL, NULL, &color_uchar[1]); + break; + + default: + break; + } +} + guchar * gimp_drawable_get_thumbnail_data (gint32 drawable_ID, gint *width, diff --git a/libgimp/gimpdrawable.h b/libgimp/gimpdrawable.h index 47346040ba..642f8b17d8 100644 --- a/libgimp/gimpdrawable.h +++ b/libgimp/gimpdrawable.h @@ -52,6 +52,10 @@ GimpTile * gimp_drawable_get_tile2 (GimpDrawable *drawable, gint x, gint y); +void gimp_drawable_get_color_uchar (gint32 drawable_ID, + const GimpRGB *color, + guchar *color_uchar); + guchar * gimp_drawable_get_thumbnail_data (gint32 drawable_ID, gint *width, gint *height, diff --git a/libgimp/gimppixelfetcher.c b/libgimp/gimppixelfetcher.c index 0c1076b02a..f4ea56e77b 100644 --- a/libgimp/gimppixelfetcher.c +++ b/libgimp/gimppixelfetcher.c @@ -27,12 +27,7 @@ #include "config.h" -#include - -#include - #include "gimp.h" -#include "gimppixelfetcher.h" struct _GimpPixelFetcher @@ -51,12 +46,34 @@ struct _GimpPixelFetcher gboolean shadow; }; + +/* local function prototypes */ + +static guchar * gimp_pixel_fetcher_provide_tile (GimpPixelFetcher *pf, + gint x, + gint y); + + +/* public functions */ + GimpPixelFetcher * -gimp_pixel_fetcher_new (GimpDrawable *drawable) +gimp_pixel_fetcher_new (GimpDrawable *drawable, + gboolean shadow) { GimpPixelFetcher *pf; + gint width; + gint height; + gint bpp; - pf = g_new (GimpPixelFetcher, 1); + g_return_val_if_fail (drawable != NULL, NULL); + + width = gimp_drawable_width (drawable->drawable_id); + height = gimp_drawable_height (drawable->drawable_id); + bpp = gimp_drawable_bpp (drawable->drawable_id); + + g_return_val_if_fail (width > 0 && height > 0 && bpp > 0, NULL); + + pf = g_new0 (GimpPixelFetcher, 1); gimp_drawable_mask_bounds (drawable->drawable_id, &pf->sel_x1, &pf->sel_y1, @@ -64,9 +81,9 @@ gimp_pixel_fetcher_new (GimpDrawable *drawable) pf->col = -1; pf->row = -1; - pf->img_width = gimp_drawable_width (drawable->drawable_id); - pf->img_height = gimp_drawable_height (drawable->drawable_id); - pf->img_bpp = gimp_drawable_bpp (drawable->drawable_id); + pf->img_width = width; + pf->img_height = height; + pf->img_bpp = bpp; pf->tile_width = gimp_tile_width (); pf->tile_height = gimp_tile_height (); pf->bg_color[0] = 0; @@ -77,50 +94,160 @@ gimp_pixel_fetcher_new (GimpDrawable *drawable) pf->drawable = drawable; pf->tile = NULL; pf->tile_dirty = FALSE; - pf->shadow = FALSE; - - /* this allows us to use (slightly faster) do-while loops */ - g_assert (pf->img_bpp > 0); + pf->shadow = shadow; return pf; } +void +gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf) +{ + g_return_if_fail (pf != NULL); + + if (pf->tile) + gimp_tile_unref (pf->tile, pf->tile_dirty); + + g_free (pf); +} + void gimp_pixel_fetcher_set_edge_mode (GimpPixelFetcher *pf, GimpPixelFetcherEdgeMode mode) { + g_return_if_fail (pf != NULL); + pf->mode = mode; } void -gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf) +gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf, + const GimpRGB *color) { - GimpRGB background; - - gimp_palette_get_background (&background); + g_return_if_fail (pf != NULL); + g_return_if_fail (color != NULL); switch (pf->img_bpp) { case 2: pf->bg_color[1] = 255; case 1: - pf->bg_color[0] = gimp_rgb_intensity_uchar (&background); + pf->bg_color[0] = gimp_rgb_intensity_uchar (color); break; case 4: pf->bg_color[3] = 255; case 3: - gimp_rgb_get_uchar (&background, + gimp_rgb_get_uchar (color, pf->bg_color, pf->bg_color + 1, pf->bg_color + 2); break; } } void -gimp_pixel_fetcher_set_shadow (GimpPixelFetcher *pf, - gboolean shadow) +gimp_pixel_fetcher_get_pixel (GimpPixelFetcher *pf, + gint x, + gint y, + guchar *pixel) { - pf->shadow = shadow; + guchar *p; + gint i; + + g_return_if_fail (pf != NULL); + g_return_if_fail (pixel != NULL); + + if (pf->mode == GIMP_PIXEL_FETCHER_EDGE_NONE && + (x < pf->sel_x1 || x >= pf->sel_x2 || + y < pf->sel_y1 || y >= pf->sel_y2)) + { + return; + } + + if (x < 0 || x >= pf->img_width || + y < 0 || y >= pf->img_height) + { + switch (pf->mode) + { + case GIMP_PIXEL_FETCHER_EDGE_WRAP: + if (x < 0 || x >= pf->img_width) + { + x %= pf->img_width; + + if (x < 0) + x += pf->img_width; + } + + if (y < 0 || y >= pf->img_height) + { + y %= pf->img_height; + + if (y < 0) + y += pf->img_height; + } + break; + + case GIMP_PIXEL_FETCHER_EDGE_SMEAR: + x = CLAMP (x, 0, pf->img_width - 1); + y = CLAMP (y, 0, pf->img_height - 1); + break; + + case GIMP_PIXEL_FETCHER_EDGE_BLACK: + for (i = 0; i < pf->img_bpp; i++) + pixel[i] = 0; + return; + + case GIMP_PIXEL_FETCHER_EDGE_BACKGROUND: + for (i = 0; i < pf->img_bpp; i++) + pixel[i] = pf->bg_color[i]; + return; + + default: + return; + } + } + + p = gimp_pixel_fetcher_provide_tile (pf, x, y); + + i = pf->img_bpp; + + do + { + *pixel++ = *p++; + } + while (--i); } +void +gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf, + gint x, + gint y, + const guchar *pixel) +{ + guchar *p; + gint i; + + g_return_if_fail (pf != NULL); + g_return_if_fail (pixel != NULL); + + if (x < pf->sel_x1 || x >= pf->sel_x2 || + y < pf->sel_y1 || y >= pf->sel_y2) + { + return; + } + + p = gimp_pixel_fetcher_provide_tile (pf, x, y); + + i = pf->img_bpp; + + do + { + *p++ = *pixel++; + } + while (--i); + + pf->tile_dirty = TRUE; +} + + +/* private functions */ + static guchar * gimp_pixel_fetcher_provide_tile (GimpPixelFetcher *pf, gint x, @@ -149,155 +276,3 @@ gimp_pixel_fetcher_provide_tile (GimpPixelFetcher *pf, return pf->tile->data + pf->img_bpp * (pf->tile->ewidth * rowoff + coloff); } - -void -gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf, - gint x, - gint y, - const guchar *pixel) -{ - guchar *p; - gint i; - - if (x < pf->sel_x1 || x >= pf->sel_x2 || - y < pf->sel_y1 || y >= pf->sel_y2) - { - return; - } - - p = gimp_pixel_fetcher_provide_tile (pf, x, y); - - i = pf->img_bpp; - do - *p++ = *pixel++; - while (--i); - - pf->tile_dirty = TRUE; -} - -void -gimp_pixel_fetcher_get_pixel (GimpPixelFetcher *pf, - gint x, - gint y, - guchar *pixel) -{ - guchar *p; - gint i; - - if (pf->mode == GIMP_PIXEL_FETCHER_EDGE_NONE && - (x < pf->sel_x1 || x >= pf->sel_x2 || - y < pf->sel_y1 || y >= pf->sel_y2)) - { - return; - } - else if (x < 0 || x >= pf->img_width || - y < 0 || y >= pf->img_height) - switch (pf->mode) - { - case GIMP_PIXEL_FETCHER_EDGE_WRAP: - if (x < 0 || x >= pf->img_width) - { - x %= pf->img_width; - if (x < 0) - x += pf->img_width; - } - if (y < 0 || y >= pf->img_height) - { - y %= pf->img_height; - if (y < 0) - y += pf->img_height; - } - break; - - case GIMP_PIXEL_FETCHER_EDGE_SMEAR: - x = CLAMP (x, 0, pf->img_width - 1); - y = CLAMP (y, 0, pf->img_height - 1); - break; - - case GIMP_PIXEL_FETCHER_EDGE_BLACK: - if (x < 0 || x >= pf->img_width || - y < 0 || y >= pf->img_height) - { - for (i = 0; i < pf->img_bpp; i++) - pixel[i] = 0; - - return; - } - break; - - default: - return; - } - - p = gimp_pixel_fetcher_provide_tile (pf, x, y); - - i = pf->img_bpp; - do - *pixel++ = *p++; - while (--i); -} - -void -gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf) -{ - if (pf->tile) - gimp_tile_unref (pf->tile, pf->tile_dirty); - - g_free (pf); -} - -static void -gimp_get_color_guchar (GimpDrawable *drawable, - GimpRGB *color, - gboolean transparent, - guchar *bg) -{ - switch (gimp_drawable_type (drawable->drawable_id)) - { - case GIMP_RGB_IMAGE : - gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]); - bg[3] = 255; - break; - - case GIMP_RGBA_IMAGE: - gimp_rgb_get_uchar (color, &bg[0], &bg[1], &bg[2]); - bg[3] = transparent ? 0 : 255; - break; - - case GIMP_GRAY_IMAGE: - bg[0] = gimp_rgb_intensity_uchar (color); - bg[1] = 255; - break; - - case GIMP_GRAYA_IMAGE: - bg[0] = gimp_rgb_intensity_uchar (color); - bg[1] = transparent ? 0 : 255; - break; - - default: - break; - } -} - -void -gimp_get_bg_guchar (GimpDrawable *drawable, - gboolean transparent, - guchar *bg) -{ - GimpRGB background; - - gimp_palette_get_background (&background); - gimp_get_color_guchar (drawable, &background, transparent, bg); -} - -void -gimp_get_fg_guchar (GimpDrawable *drawable, - gboolean transparent, - guchar *fg) -{ - GimpRGB foreground; - - gimp_palette_get_foreground (&foreground); - gimp_get_color_guchar (drawable, &foreground, transparent, fg); -} - diff --git a/libgimp/gimppixelfetcher.h b/libgimp/gimppixelfetcher.h index 6a22b22a7d..3f0b4e6336 100644 --- a/libgimp/gimppixelfetcher.h +++ b/libgimp/gimppixelfetcher.h @@ -35,36 +35,31 @@ typedef enum GIMP_PIXEL_FETCHER_EDGE_NONE, GIMP_PIXEL_FETCHER_EDGE_WRAP, GIMP_PIXEL_FETCHER_EDGE_SMEAR, - GIMP_PIXEL_FETCHER_EDGE_BLACK + GIMP_PIXEL_FETCHER_EDGE_BLACK, + GIMP_PIXEL_FETCHER_EDGE_BACKGROUND } GimpPixelFetcherEdgeMode; typedef struct _GimpPixelFetcher GimpPixelFetcher; -GimpPixelFetcher * gimp_pixel_fetcher_new (GimpDrawable *drawable); -void gimp_pixel_fetcher_set_edge_mode (GimpPixelFetcher *pf, - GimpPixelFetcherEdgeMode mode); -void gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf); -void gimp_pixel_fetcher_set_shadow (GimpPixelFetcher *pf, - gboolean shadow); -void gimp_pixel_fetcher_get_pixel (GimpPixelFetcher *pf, - gint x, - gint y, - guchar *pixel); -void gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf, - gint x, - gint y, - const guchar *pixel); -void gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf); +GimpPixelFetcher * gimp_pixel_fetcher_new (GimpDrawable *drawable, + gboolean shadow); +void gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf); +void gimp_pixel_fetcher_set_edge_mode (GimpPixelFetcher *pf, + GimpPixelFetcherEdgeMode mode); +void gimp_pixel_fetcher_set_bg_color (GimpPixelFetcher *pf, + const GimpRGB *color); -void gimp_get_bg_guchar (GimpDrawable *drawable, - gboolean transparent, - guchar *bg); -void gimp_get_fg_guchar (GimpDrawable *drawable, - gboolean transparent, - guchar *fg); +void gimp_pixel_fetcher_get_pixel (GimpPixelFetcher *pf, + gint x, + gint y, + guchar *pixel); +void gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf, + gint x, + gint y, + const guchar *pixel); G_END_DECLS diff --git a/plug-ins/common/blinds.c b/plug-ins/common/blinds.c index e5d4e8bfd7..69c61cad84 100644 --- a/plug-ins/common/blinds.c +++ b/plug-ins/common/blinds.c @@ -528,13 +528,19 @@ blindsapply (guchar *srow, static void dialog_update_preview (void) { - gint y; - guchar *p, *buffer; - guchar bg[4]; + gint y; + guchar *p, *buffer; + GimpRGB background; + guchar bg[4]; p = preview->cache; - gimp_get_bg_guchar (blindsdrawable, bvals.bg_trans, bg); + gimp_palette_get_background (&background); + + if (bvals.bg_trans) + gimp_rgb_set_alpha (&background, 0.0); + + gimp_drawable_get_color_uchar (blindsdrawable->drawable_id, &background, bg); buffer = (guchar*) g_malloc (preview->rowstride); @@ -620,18 +626,24 @@ dialog_update_preview (void) static void apply_blinds (void) { - GimpPixelRgn des_rgn; - GimpPixelRgn src_rgn; - guchar *src_rows, *des_rows; - gint x,y; - guchar bg[4]; - gint sel_x1, sel_y1, sel_x2, sel_y2; - gint sel_width, sel_height; + GimpPixelRgn des_rgn; + GimpPixelRgn src_rgn; + guchar *src_rows, *des_rows; + gint x, y; + GimpRGB background; + guchar bg[4]; + gint sel_x1, sel_y1, sel_x2, sel_y2; + gint sel_width, sel_height; - gimp_get_bg_guchar (blindsdrawable, bvals.bg_trans, bg); + gimp_palette_get_background (&background); - gimp_drawable_mask_bounds (blindsdrawable->drawable_id, &sel_x1, &sel_y1, - &sel_x2, &sel_y2); + if (bvals.bg_trans) + gimp_rgb_set_alpha (&background, 0.0); + + gimp_drawable_get_color_uchar (blindsdrawable->drawable_id, &background, bg); + + gimp_drawable_mask_bounds (blindsdrawable->drawable_id, + &sel_x1, &sel_y1, &sel_x2, &sel_y2); sel_width = sel_x2 - sel_x1; sel_height = sel_y2 - sel_y1; @@ -648,8 +660,8 @@ apply_blinds (void) { for (y = 0; y < sel_height; y += STEP) { - int rr; - int step; + gint rr; + gint step; if((y + STEP) > sel_height) step = sel_height - y; @@ -686,7 +698,7 @@ apply_blinds (void) * this act as a transfomation matrix for the * rows. Make row 0 invalid so we can find it again! */ - int i; + gint i; gint *sr = g_new (gint, sel_height * 4); gint *dr = g_new (gint, sel_height * 4); guchar *dst = g_new (guchar, STEP * 4); diff --git a/plug-ins/common/checkerboard.c b/plug-ins/common/checkerboard.c index 29bef90399..be8aff326f 100644 --- a/plug-ins/common/checkerboard.c +++ b/plug-ins/common/checkerboard.c @@ -216,11 +216,15 @@ checkerboard_func (gint x, static void do_checkerboard_pattern (GimpDrawable *drawable) { - CheckerboardParam_t param; - GimpRgnIterator *iter; + CheckerboardParam_t param; + GimpRgnIterator *iter; + GimpRGB color; - gimp_get_bg_guchar (drawable, FALSE, param.bg); - gimp_get_fg_guchar (drawable, FALSE, param.fg); + gimp_palette_get_background (&color); + gimp_drawable_get_color_uchar (drawable->drawable_id, &color, param.bg); + + gimp_palette_get_foreground (&color); + gimp_drawable_get_color_uchar (drawable->drawable_id, &color, param.fg); if (cvals.size < 1) { diff --git a/plug-ins/common/cubism.c b/plug-ins/common/cubism.c index 45ce8a9a20..fc3f1a3650 100644 --- a/plug-ins/common/cubism.c +++ b/plug-ins/common/cubism.c @@ -317,25 +317,25 @@ static void cubism (GimpDrawable *drawable) { GimpPixelRgn src_rgn; - guchar bg_col[4]; - gdouble x, y; - gdouble width, height; - gdouble theta; - gint ix, iy; - gint rows, cols; - gint i, j, count; - gint num_tiles; - gint x1, y1, x2, y2; - Polygon poly; - guchar col[4]; - guchar *dest; - gint bytes; - gint has_alpha; - gint *random_indices; - gpointer pr; - GRand *gr; + guchar bg_col[4]; + gdouble x, y; + gdouble width, height; + gdouble theta; + gint ix, iy; + gint rows, cols; + gint i, j, count; + gint num_tiles; + gint x1, y1, x2, y2; + Polygon poly; + guchar col[4]; + guchar *dest; + gint bytes; + gboolean has_alpha; + gint *random_indices; + gpointer pr; + GRand *gr; - gr = g_rand_new(); + gr = g_rand_new (); has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); bytes = drawable->bpp; gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); @@ -347,7 +347,11 @@ cubism (GimpDrawable *drawable) } else { - gimp_get_bg_guchar (drawable, TRUE, bg_col); + GimpRGB color; + + gimp_palette_get_background (&color); + gimp_rgb_set_alpha (&color, 0.0); + gimp_drawable_get_color_uchar (drawable->drawable_id, &color, bg_col); } gimp_progress_init (_("Cubistic Transformation")); @@ -358,6 +362,7 @@ cubism (GimpDrawable *drawable) /* Fill the image with the background color */ gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE); + for (pr = gimp_pixel_rgns_register (1, &src_rgn); pr != NULL; pr = gimp_pixel_rgns_process (pr)) @@ -385,15 +390,15 @@ cubism (GimpDrawable *drawable) { i = random_indices[count] / (cols + 1); j = random_indices[count] % (cols + 1); - x = j * cvals.tile_size + (cvals.tile_size / 4.0) + x = j * cvals.tile_size + (cvals.tile_size / 4.0) - g_rand_double_range (gr, 0, cvals.tile_size/2.0) + x1; - y = i * cvals.tile_size + (cvals.tile_size / 4.0) + y = i * cvals.tile_size + (cvals.tile_size / 4.0) - g_rand_double_range (gr, 0, cvals.tile_size/2.0) + y1; - width = (cvals.tile_size + + width = (cvals.tile_size + g_rand_double_range (gr, 0, cvals.tile_size / 4.0) - cvals.tile_size / 8.0) * cvals.tile_saturation; - height = (cvals.tile_size + - g_rand_double_range (gr, 0, cvals.tile_size / 4.0) - + height = (cvals.tile_size + + g_rand_double_range (gr, 0, cvals.tile_size / 4.0) - cvals.tile_size / 8.0) * cvals.tile_saturation; theta = g_rand_double_range (gr, 0, 2 * G_PI); polygon_reset (&poly); diff --git a/plug-ins/common/curve_bend.c b/plug-ins/common/curve_bend.c index 10f27fae1d..33c02a00cc 100644 --- a/plug-ins/common/curve_bend.c +++ b/plug-ins/common/curve_bend.c @@ -2552,13 +2552,13 @@ p_end_gdrw (t_GDRW *gdrw) } static void -p_init_gdrw (t_GDRW *gdrw, +p_init_gdrw (t_GDRW *gdrw, GimpDrawable *drawable, - int dirty, - int shadow) + int dirty, + int shadow) { gdrw->drawable = drawable; - gdrw->pft = gimp_pixel_fetcher_new (drawable); + gdrw->pft = gimp_pixel_fetcher_new (drawable, FALSE); gimp_pixel_fetcher_set_edge_mode (gdrw->pft, GIMP_PIXEL_FETCHER_EDGE_BLACK); gdrw->tile_width = gimp_tile_width (); gdrw->tile_height = gimp_tile_height (); @@ -2586,7 +2586,7 @@ static void p_get_pixel (t_GDRW *gdrw, gint32 x, gint32 y, - guchar *pixel ) + guchar *pixel) { pixel[1] = 255; pixel[3] = 255; /* simulate full visible alpha channel */ diff --git a/plug-ins/common/displace.c b/plug-ins/common/displace.c index 1d9f336d2f..28272a19bc 100644 --- a/plug-ins/common/displace.c +++ b/plug-ins/common/displace.c @@ -469,7 +469,7 @@ displace (GimpDrawable *drawable) mxrow = NULL; myrow = NULL; - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); gimp_pixel_fetcher_set_edge_mode (pft, dvals.displace_type); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); diff --git a/plug-ins/common/edge.c b/plug-ins/common/edge.c index 37d152c7b2..52166cbb68 100644 --- a/plug-ins/common/edge.c +++ b/plug-ins/common/edge.c @@ -275,7 +275,7 @@ edge (GimpDrawable *drawable) if (evals.amount < 1.0) evals.amount = 1.0; - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); gimp_pixel_fetcher_set_edge_mode (pft, evals.wrapmode); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); @@ -299,20 +299,22 @@ edge (GimpDrawable *drawable) pr != NULL; pr = gimp_pixel_rgns_process (pr)) { - srcrow = src_rgn.data; + srcrow = src_rgn.data; destrow = dest_rgn.data; + for (y = dest_rgn.y; - y < (dest_rgn.y + dest_rgn.h); - y++, srcrow += src_rgn.rowstride, destrow += dest_rgn.rowstride) + y < (dest_rgn.y + dest_rgn.h); + y++, srcrow += src_rgn.rowstride, destrow += dest_rgn.rowstride) { - src = srcrow; + src = srcrow; dest = destrow; + for (x = dest_rgn.x; x < (dest_rgn.x + dest_rgn.w); x++, src += src_rgn.bpp, dest += dest_rgn.bpp) { - if(dest_rgn.x < x && x < dest_rgn.x + dest_rgn.w - 2 && - dest_rgn.y < y && y < dest_rgn.y + dest_rgn.h - 2) + if (dest_rgn.x < x && x < dest_rgn.x + dest_rgn.w - 2 && + dest_rgn.y < y && y < dest_rgn.y + dest_rgn.h - 2) { /* ** 3x3 kernel is inside of the tile -- do fast @@ -323,13 +325,16 @@ edge (GimpDrawable *drawable) /* get the 3x3 kernel into a guchar array, * and send it to edge_detect */ guchar kernel[9]; - int i,j; + gint i,j; + #define PIX(X,Y) src[ (Y-1)*(int)src_rgn.rowstride + (X-1)*(int)src_rgn.bpp + chan ] /* make convolution */ for(i = 0; i < 3; i++) for(j = 0; j < 3; j++) kernel[3*i + j] = PIX(i,j); + #undef PIX + dest[chan] = edge_detect(kernel); } } diff --git a/plug-ins/common/illusion.c b/plug-ins/common/illusion.c index cf2b0b73cc..f1fb80c093 100644 --- a/plug-ins/common/illusion.c +++ b/plug-ins/common/illusion.c @@ -255,17 +255,18 @@ illusion_func (gint x, static void filter (GimpDrawable *drawable) { - IllusionParam_t param; + IllusionParam_t param; GimpRgnIterator *iter; - gint width, height; - gint x1, y1, x2, y2; + gint width, height; + gint x1, y1, x2, y2; gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); - width = x2 - x1; + width = x2 - x1; height = y2 - y1; - param.pft = gimp_pixel_fetcher_new (drawable); + param.pft = gimp_pixel_fetcher_new (drawable, FALSE); gimp_pixel_fetcher_set_edge_mode (param.pft, GIMP_PIXEL_FETCHER_EDGE_SMEAR); + param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); param.center_x = (x1 + x2) / 2.0; param.center_y = (y1 + y2) / 2.0; diff --git a/plug-ins/common/mblur.c b/plug-ins/common/mblur.c index 8de908040d..afde278de5 100644 --- a/plug-ins/common/mblur.c +++ b/plug-ins/common/mblur.c @@ -264,9 +264,10 @@ run (const gchar *name, static void mblur_linear (void) { - GimpPixelRgn dest_rgn; + GimpPixelRgn dest_rgn; GimpPixelFetcher *pft; - gpointer pr; + gpointer pr; + GimpRGB background; guchar *dest; guchar *d; @@ -280,9 +281,10 @@ mblur_linear (void) gimp_pixel_rgn_init (&dest_rgn, drawable, sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE); - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); - gimp_pixel_fetcher_set_bg_color (pft); + gimp_palette_get_background (&background); + gimp_pixel_fetcher_set_bg_color (pft, &background); progress = 0; max_progress = sel_width * sel_height; @@ -423,9 +425,10 @@ mblur_linear (void) static void mblur_radial (void) { - GimpPixelRgn dest_rgn; + GimpPixelRgn dest_rgn; GimpPixelFetcher *pft; - gpointer pr; + gpointer pr; + GimpRGB background; guchar *dest; guchar *d; @@ -446,9 +449,10 @@ mblur_radial (void) gimp_pixel_rgn_init (&dest_rgn, drawable, sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE); - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); - gimp_pixel_fetcher_set_bg_color (pft); + gimp_palette_get_background (&background); + gimp_pixel_fetcher_set_bg_color (pft, &background); progress = 0; max_progress = sel_width * sel_height; @@ -559,9 +563,10 @@ mblur_radial (void) static void mblur_zoom (void) { - GimpPixelRgn dest_rgn; + GimpPixelRgn dest_rgn; GimpPixelFetcher *pft; - gpointer pr; + gpointer pr; + GimpRGB background; guchar *dest, *d; guchar pixel[4]; @@ -579,9 +584,10 @@ mblur_zoom (void) gimp_pixel_rgn_init (&dest_rgn, drawable, sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE); - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); - gimp_pixel_fetcher_set_bg_color (pft); + gimp_palette_get_background (&background); + gimp_pixel_fetcher_set_bg_color (pft, &background); progress = 0; max_progress = sel_width * sel_height; diff --git a/plug-ins/common/mosaic.c b/plug-ins/common/mosaic.c index 521986a24c..5a3ee0e6f5 100644 --- a/plug-ins/common/mosaic.c +++ b/plug-ins/common/mosaic.c @@ -39,7 +39,6 @@ #define HORIZONTAL 0 #define VERTICAL 1 -#define OPAQUE 255 #define SUPERSAMPLE 3 #define MAG_THRESHOLD 7.5 #define COUNT_THRESHOLD 0.1 @@ -425,6 +424,7 @@ mosaic (GimpDrawable *drawable) { gint x1, y1, x2, y2; gint alpha; + GimpRGB color; /* Find the mask bounds */ gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); @@ -460,18 +460,17 @@ mosaic (GimpDrawable *drawable) fore[0] = fore[1] = fore[2] = 255; back[0] = back[1] = back[2] = 0; break; + case FG_BG: - gimp_get_fg_guchar (drawable, FALSE, fore); - gimp_get_bg_guchar (drawable, FALSE, back); + gimp_palette_get_foreground (&color); + gimp_drawable_get_color_uchar (drawable->drawable_id, &color, fore); + + gimp_palette_get_background (&color); + gimp_drawable_get_color_uchar (drawable->drawable_id, &color, back); break; } alpha = drawable->bpp - 1; - if (gimp_drawable_has_alpha (drawable->drawable_id)) - { - fore[alpha] = OPAQUE; - back[alpha] = OPAQUE; - } light_x = -cos (mvals.light_dir * G_PI / 180.0); light_y = sin (mvals.light_dir * G_PI / 180.0); @@ -760,7 +759,7 @@ find_gradients (GimpDrawable *drawable, else { hmax = *dh - 128; vmax = *dv - 128; - + *gr = (guchar)sqrt (SQR (hmax) + SQR (hmax)); } @@ -1994,9 +1993,9 @@ fill_poly_color (Polygon *poly, ys = (gint) pts_tmp[poly_npts-1].y; xe = (gint) pts_tmp->x; ye = (gint) pts_tmp->y; - + calc_spec_vec (vecs, xs, ys, xe, ye); - + for (i = 1; i < poly_npts; i++) { xs = (gint) (pts_tmp->x); @@ -2004,7 +2003,7 @@ fill_poly_color (Polygon *poly, pts_tmp++; xe = (gint) pts_tmp->x; ye = (gint) pts_tmp->y; - + calc_spec_vec (vecs+i, xs, ys, xe, ye); } } @@ -2356,9 +2355,9 @@ convert_segment (gint x1, gdouble xinc, xstart; if (y1 > y2) - { + { tmp = y2; y2 = y1; y1 = tmp; - tmp = x2; x2 = x1; x1 = tmp; + tmp = x2; x2 = x1; x1 = tmp; } ydiff = y2 - y1; diff --git a/plug-ins/common/plasma.c b/plug-ins/common/plasma.c index 5b84211b02..1826101d5c 100644 --- a/plug-ins/common/plasma.c +++ b/plug-ins/common/plasma.c @@ -445,8 +445,7 @@ init_plasma (GimpDrawable *drawable, has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); alpha = (has_alpha) ? bpp - 1 : bpp; - pft = gimp_pixel_fetcher_new (drawable); - gimp_pixel_fetcher_set_shadow (pft, TRUE); + pft = gimp_pixel_fetcher_new (drawable, TRUE); } progress = 0; diff --git a/plug-ins/common/polar.c b/plug-ins/common/polar.c index ef8c16ba1f..fb83021724 100644 --- a/plug-ins/common/polar.c +++ b/plug-ins/common/polar.c @@ -341,17 +341,21 @@ polarize_func (gint x, static void polarize (void) { - GimpRgnIterator *iter; + GimpRgnIterator *iter; GimpPixelFetcher *pft; + GimpRGB background; - pft = gimp_pixel_fetcher_new (drawable); - gimp_pixel_fetcher_set_bg_color (pft); + pft = gimp_pixel_fetcher_new (drawable, FALSE); + + gimp_palette_get_background (&background); + gimp_pixel_fetcher_set_bg_color (pft, &background); gimp_progress_init (_("Polarizing...")); + iter = gimp_rgn_iterator_new (drawable, run_mode); gimp_rgn_iterator_dest (iter, polarize_func, pft); - gimp_rgn_iterator_free (iter); + gimp_pixel_fetcher_destroy (pft); } @@ -362,33 +366,33 @@ calc_undistorted_coords (gdouble wx, gdouble *y) { gboolean inside; - gdouble phi, phi2; - gdouble xx, xm, ym, yy; - gint xdiff, ydiff; - gdouble r; - gdouble m; - gdouble xmax, ymax, rmax; - gdouble x_calc, y_calc; - gdouble xi, yi; - gdouble circle, angl, t, angle; - gint x1, x2, y1, y2; + gdouble phi, phi2; + gdouble xx, xm, ym, yy; + gint xdiff, ydiff; + gdouble r; + gdouble m; + gdouble xmax, ymax, rmax; + gdouble x_calc, y_calc; + gdouble xi, yi; + gdouble circle, angl, t, angle; + gint x1, x2, y1, y2; /* initialize */ phi = 0.0; - r = 0.0; + r = 0.0; - x1 = 0; - y1 = 0; - x2 = img_width; - y2 = img_height; - xdiff = x2 - x1; - ydiff = y2 - y1; - xm = xdiff / 2.0; - ym = ydiff / 2.0; + x1 = 0; + y1 = 0; + x2 = img_width; + y2 = img_height; + xdiff = x2 - x1; + ydiff = y2 - y1; + xm = xdiff / 2.0; + ym = ydiff / 2.0; circle = pcvals.circle; - angle = pcvals.angle; - angl = (double)angle / 180.0 * G_PI; + angle = pcvals.angle; + angl = (gdouble) angle / 180.0 * G_PI; if (pcvals.polrec) { @@ -725,10 +729,13 @@ dialog_update_preview (void) gint bpp; gdouble scale_x, scale_y; guchar *p_ul, *i; + GimpRGB background; guchar outside[4]; guchar *buffer; - gimp_get_bg_guchar (drawable, TRUE, outside); + gimp_palette_get_background (&background); + gimp_rgb_set_alpha (&background, 0.0); + gimp_drawable_get_color_uchar (drawable->drawable_id, &background, outside); left = sel_x1; right = sel_x2 - 1; diff --git a/plug-ins/common/ripple.c b/plug-ins/common/ripple.c index 17109db03e..9421e1cc80 100644 --- a/plug-ins/common/ripple.c +++ b/plug-ins/common/ripple.c @@ -264,7 +264,7 @@ ripple_vertical (gint x, needy = y + displace_amount(x); yi = floor(needy); - + /* Tile the image. */ if (rvals.edges == WRAP) { @@ -276,7 +276,7 @@ ripple_vertical (gint x, { yi = CLAMP (yi, 0, height - 1); } - + if (rvals.antialias) { if (yi == height - 1) @@ -291,7 +291,7 @@ ripple_vertical (gint x, { gimp_pixel_fetcher_get_pixel (pft, x, yi, pixel[0]); gimp_pixel_fetcher_get_pixel (pft, x, yi + 1, pixel[1]); - + average_two_pixels (dest, pixel, needy, bpp, param->has_alpha); } else @@ -300,7 +300,7 @@ ripple_vertical (gint x, gimp_pixel_fetcher_get_pixel (pft, x, yi + 1, pixel[1]); gimp_pixel_fetcher_get_pixel (pft, x, yi - 1, pixel[2]); gimp_pixel_fetcher_get_pixel (pft, x, yi + 2, pixel[3]); - + average_four_pixels (dest, pixel, needy, bpp, param->has_alpha); } } /* antialias */ @@ -328,7 +328,7 @@ ripple_horizontal (gint x, needx = x + displace_amount(y); xi = floor (needx); - + /* Tile the image. */ if (rvals.edges == WRAP) { @@ -340,7 +340,7 @@ ripple_horizontal (gint x, { xi = CLAMP(xi, 0, width - 1); } - + if (rvals.antialias) { if (xi == width - 1) @@ -351,12 +351,12 @@ ripple_horizontal (gint x, { gimp_pixel_fetcher_get_pixel (pft, 0, y, dest); } - + else if (xi == width - 2 || xi == 0) { gimp_pixel_fetcher_get_pixel (pft, xi, y, pixel[0]); gimp_pixel_fetcher_get_pixel (pft, xi + 1, y, pixel[1]); - + average_two_pixels (dest, pixel, needx, bpp, param->has_alpha); } else @@ -365,11 +365,11 @@ ripple_horizontal (gint x, gimp_pixel_fetcher_get_pixel (pft, xi + 1, y, pixel[1]); gimp_pixel_fetcher_get_pixel (pft, xi - 1, y, pixel[2]); gimp_pixel_fetcher_get_pixel (pft, xi + 2, y, pixel[3]); - + average_four_pixels (dest, pixel, needx, bpp, param->has_alpha); } } /* antialias */ - + else { gimp_pixel_fetcher_get_pixel (pft, xi, y, dest); @@ -380,12 +380,12 @@ static void ripple (GimpDrawable *drawable) { GimpRgnIterator *iter; - RippleParam_t param; + RippleParam_t param; - param.pft = gimp_pixel_fetcher_new (drawable); + param.pft = gimp_pixel_fetcher_new (drawable, FALSE); param.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); - param.width = drawable->width; - param.height = drawable->height; + param.width = drawable->width; + param.height = drawable->height; if ( rvals.tile ) { diff --git a/plug-ins/common/shift.c b/plug-ins/common/shift.c index 5b561da95b..45a72cbaaa 100644 --- a/plug-ins/common/shift.c +++ b/plug-ins/common/shift.c @@ -210,24 +210,23 @@ run (const gchar *name, static void shift (GimpDrawable *drawable) { - GimpPixelRgn dest_rgn; - gpointer pr; + GimpPixelRgn dest_rgn; + gpointer pr; GimpPixelFetcher *pft; - gint width, height; - gint bytes; - guchar *destline; - guchar *dest; - gint x1, y1, x2, y2; - gint x, y; - gint progress, max_progress; - gint amount; - gint xdist, ydist; - - GRand *gr; /* The random number generator we're using */ + gint width, height; + gint bytes; + guchar *destline; + guchar *dest; + gint x1, y1, x2, y2; + gint x, y; + gint progress, max_progress; + gint amount; + gint xdist, ydist; + GRand *gr; gr = g_rand_new (); - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); gimp_pixel_fetcher_set_edge_mode (pft, GIMP_PIXEL_FETCHER_EDGE_WRAP); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); diff --git a/plug-ins/common/spread.c b/plug-ins/common/spread.c index 5e64887a11..5625ff72ad 100644 --- a/plug-ins/common/spread.c +++ b/plug-ins/common/spread.c @@ -21,6 +21,7 @@ * You can contact Federico Mena Quintero at quartic@polloux.fciencias.unam.mx * You can contact the original The Gimp authors at gimp@xcf.berkeley.edu */ + #include "config.h" #include @@ -212,27 +213,26 @@ run (const gchar *name, static void spread (GimpDrawable *drawable) { - GimpPixelRgn dest_rgn; - gpointer pr; + GimpPixelRgn dest_rgn; + gpointer pr; GimpPixelFetcher *pft; - gint width, height; - gint bytes; - guchar *destrow; - guchar *dest; - gint x1, y1, x2, y2; - gint x, y; - gint progress, max_progress; - gdouble x_amount, y_amount; - gdouble angle; - gint xdist, ydist; - gint xi, yi; - - GRand *gr; + gint width, height; + gint bytes; + guchar *destrow; + guchar *dest; + gint x1, y1, x2, y2; + gint x, y; + gint progress, max_progress; + gdouble x_amount, y_amount; + gdouble angle; + gint xdist, ydist; + gint xi, yi; + GRand *gr; gr = g_rand_new (); - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); diff --git a/plug-ins/common/tileit.c b/plug-ins/common/tileit.c index 5c99595742..f234847f23 100644 --- a/plug-ins/common/tileit.c +++ b/plug-ins/common/tileit.c @@ -974,109 +974,113 @@ cache_preview (void) static void do_tiles(void) { - GimpPixelRgn dest_rgn; - gpointer pr; - gint progress, max_progress; - guchar *dest_row; - guchar *dest; - gint row, col; - gint bpp; - guchar pixel[4]; - int nc,nr; - int i; + GimpPixelRgn dest_rgn; + gpointer pr; + gint progress, max_progress; + guchar *dest_row; + guchar *dest; + gint row, col; + gint bpp; + guchar pixel[4]; + gint nc, nr; + gint i; GimpPixelFetcher *pft; /* Initialize pixel region */ - pft = gimp_pixel_fetcher_new (tileitdrawable); + pft = gimp_pixel_fetcher_new (tileitdrawable, FALSE); - gimp_pixel_rgn_init(&dest_rgn, tileitdrawable, sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE); + gimp_pixel_rgn_init (&dest_rgn, tileitdrawable, + sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE); progress = 0; max_progress = sel_width * sel_height; - img_bpp = gimp_drawable_bpp(tileitdrawable->drawable_id); + img_bpp = gimp_drawable_bpp (tileitdrawable->drawable_id); bpp = (has_alpha) ? img_bpp - 1 : img_bpp; for (pr = gimp_pixel_rgns_register(1, &dest_rgn); - pr != NULL; pr = gimp_pixel_rgns_process(pr)) { - dest_row = dest_rgn.data; + pr != NULL; + pr = gimp_pixel_rgns_process(pr)) + { + dest_row = dest_rgn.data; - for (row = dest_rgn.y; row < (dest_rgn.y + dest_rgn.h); row++) { - dest = dest_row; + for (row = dest_rgn.y; row < (dest_rgn.y + dest_rgn.h); row++) + { + dest = dest_row; - for (col = dest_rgn.x; col < (dest_rgn.x + dest_rgn.w); col++) - { - int an_action; + for (col = dest_rgn.x; col < (dest_rgn.x + dest_rgn.w); col++) + { + gint an_action; - an_action = - tiles_xy(sel_width, - sel_height, - col-sel_x1,row-sel_y1, - &nc,&nr); + an_action = tiles_xy (sel_width, + sel_height, + col-sel_x1,row-sel_y1, + &nc,&nr); - gimp_pixel_fetcher_get_pixel (pft, nc + sel_x1, nr + sel_y1, - pixel); + gimp_pixel_fetcher_get_pixel (pft, nc + sel_x1, nr + sel_y1, + pixel); - for (i = 0; i < bpp; i++) - *dest++ = pixel[i]; + for (i = 0; i < bpp; i++) + *dest++ = pixel[i]; - if (has_alpha) - { - *dest++ = (pixel[bpp]*opacity)/100; - } - } - dest_row += dest_rgn.rowstride; + if (has_alpha) + *dest++ = (pixel[bpp] * opacity) / 100; + } + + dest_row += dest_rgn.rowstride; + } + + progress += dest_rgn.w * dest_rgn.h; + gimp_progress_update ((double) progress / max_progress); } - progress += dest_rgn.w * dest_rgn.h; - gimp_progress_update((double) progress / max_progress); - } - gimp_pixel_fetcher_destroy (pft); - gimp_drawable_flush(tileitdrawable); - gimp_drawable_merge_shadow(tileitdrawable->drawable_id, TRUE); - gimp_drawable_update(tileitdrawable->drawable_id, - sel_x1, sel_y1, sel_width, sel_height); + gimp_drawable_flush (tileitdrawable); + gimp_drawable_merge_shadow (tileitdrawable->drawable_id, TRUE); + gimp_drawable_update (tileitdrawable->drawable_id, + sel_x1, sel_y1, sel_width, sel_height); } /* Get the xy pos and any action */ static gint -tiles_xy(gint width, - gint height, - gint x, - gint y, - gint *nx, - gint *ny) +tiles_xy (gint width, + gint height, + gint x, + gint y, + gint *nx, + gint *ny) { - gint px,py; - gint rnum,cnum; - gint actiontype; - gdouble rnd = 1 - (1.0/(gdouble)itvals.numtiles) +0.01; + gint px,py; + gint rnum,cnum; + gint actiontype; + gdouble rnd = 1 - (1.0 / (gdouble) itvals.numtiles) + 0.01; - rnum = y*itvals.numtiles/height; + rnum = y * itvals.numtiles / height; - py = (y*itvals.numtiles)%height; - px = (x*itvals.numtiles)%width; - cnum = x*itvals.numtiles/width; + py = (y * itvals.numtiles) % height; + px = (x * itvals.numtiles) % width; + cnum = x * itvals.numtiles / width; - if((actiontype = tileactions[cnum][rnum])) + if ((actiontype = tileactions[cnum][rnum])) { - if(actiontype & HORIZONTAL) + if (actiontype & HORIZONTAL) { gdouble pyr; + pyr = height - y - 1 + rnd; - py = ((int)(pyr*(gdouble)itvals.numtiles))%height; + py = ((gint) (pyr * (gdouble) itvals.numtiles)) % height; } - if(actiontype & VERTICAL) + if (actiontype & VERTICAL) { gdouble pxr; + pxr = width - x - 1 + rnd; - px = ((int)(pxr*(gdouble)itvals.numtiles))%width; + px = ((gint) (pxr * (gdouble) itvals.numtiles)) % width; } } @@ -1089,21 +1093,21 @@ tiles_xy(gint width, /* Given a row then srink it down a bit */ static void -do_tiles_preview(guchar *dest_row, - guchar *src_rows, - gint width, - gint dh, - gint height, - gint bpp) +do_tiles_preview (guchar *dest_row, + guchar *src_rows, + gint width, + gint dh, + gint height, + gint bpp) { - gint x; - gint i; - gint px,py; - gint rnum,cnum; - gint actiontype; - gdouble rnd = 1 - (1.0/(gdouble)itvals.numtiles) +0.01; + gint x; + gint i; + gint px, py; + gint rnum,cnum; + gint actiontype; + gdouble rnd = 1 - (1.0 / (gdouble) itvals.numtiles) + 0.01; - rnum = dh*itvals.numtiles/height; + rnum = dh * itvals.numtiles / height; for (x = 0; x < width; x ++) { diff --git a/plug-ins/common/whirlpinch.c b/plug-ins/common/whirlpinch.c index 30c3bdc706..c2ffb46799 100644 --- a/plug-ins/common/whirlpinch.c +++ b/plug-ins/common/whirlpinch.c @@ -340,17 +340,18 @@ run (const gchar *name, static void whirl_pinch (void) { - GimpPixelRgn dest_rgn; - gint progress, max_progress; - guchar *top_row, *bot_row; - guchar *top_p, *bot_p; - gint row, col; - guchar **pixel; - double whirl; - double cx, cy; - int ix, iy; - int i; + GimpPixelRgn dest_rgn; + gint progress, max_progress; + guchar *top_row, *bot_row; + guchar *top_p, *bot_p; + gint row, col; + guchar **pixel; + gdouble whirl; + gdouble cx, cy; + gint ix, iy; + gint i; GimpPixelFetcher *pft, *pfb; + GimpRGB background; /* Initialize rows */ top_row = g_malloc (img_bpp * sel_width); @@ -363,11 +364,12 @@ whirl_pinch (void) gimp_pixel_rgn_init (&dest_rgn, drawable, sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE); - pft = gimp_pixel_fetcher_new (drawable); - pfb = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); + pfb = gimp_pixel_fetcher_new (drawable, FALSE); - gimp_pixel_fetcher_set_bg_color (pft); - gimp_pixel_fetcher_set_bg_color (pfb); + gimp_palette_get_background (&background); + gimp_pixel_fetcher_set_bg_color (pft, &background); + gimp_pixel_fetcher_set_bg_color (pfb, &background); progress = 0; max_progress = sel_width * sel_height; @@ -573,7 +575,7 @@ build_preview_source_image (void) py = top; - pf = gimp_pixel_fetcher_new (drawable); + pf = gimp_pixel_fetcher_new (drawable, FALSE); p = wpint.image; diff --git a/plug-ins/gflare/gflare.c b/plug-ins/gflare/gflare.c index d56acce605..2039333eeb 100644 --- a/plug-ins/gflare/gflare.c +++ b/plug-ins/gflare/gflare.c @@ -1093,11 +1093,10 @@ plugin_do_non_asupsample (void) static void plugin_do_asupsample (void) { - tk_read = gimp_pixel_fetcher_new (drawable); + tk_read = gimp_pixel_fetcher_new (drawable, FALSE); gimp_pixel_fetcher_set_edge_mode (tk_read, GIMP_PIXEL_FETCHER_EDGE_BLACK); - tk_write = gimp_pixel_fetcher_new (drawable); - gimp_pixel_fetcher_set_shadow (tk_write, TRUE); + tk_write = gimp_pixel_fetcher_new (drawable, TRUE); gimp_adaptive_supersample_area (dinfo.x1, dinfo.y1, dinfo.x2 - 1, dinfo.y2 - 1, pvals.asupsample_max_depth, diff --git a/plug-ins/libgimpoldpreview/gimpoldpreview.c b/plug-ins/libgimpoldpreview/gimpoldpreview.c index 6d34b7524f..1a00c469c9 100644 --- a/plug-ins/libgimpoldpreview/gimpoldpreview.c +++ b/plug-ins/libgimpoldpreview/gimpoldpreview.c @@ -487,7 +487,7 @@ gimp_old_preview_fill_scaled (GimpOldPreview *preview, py = y1; - pft = gimp_pixel_fetcher_new (drawable); + pft = gimp_pixel_fetcher_new (drawable, FALSE); for (y = 0; y < height; y++) { @@ -502,6 +502,7 @@ gimp_old_preview_fill_scaled (GimpOldPreview *preview, gimp_old_preview_do_row (preview, y, width, dest); py += dy; } + gimp_pixel_fetcher_destroy (pft); preview->buffer = GTK_PREVIEW (preview->widget)->buffer;