Commit a779e748 authored by Michael Natterer's avatar Michael Natterer 😴 Committed by Michael Natterer

Cleaned up the remaining libgimp API issues:

2004-03-12  Michael Natterer  <mitch@gimp.org>

	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)
parent 5f9f60f4
2004-03-12 Michael Natterer <mitch@gimp.org>
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 <quinet@gamers.org>
* app/core/gimpdrawable-transform.c (RECURSION_LEVEL): Set to 0 in
......@@ -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
......
......@@ -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,
......
......@@ -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,
......
......@@ -27,12 +27,7 @@
#include "config.h"
#include <stdio.h>
#include <glib.h>
#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;
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);
pf = g_new (GimpPixelFetcher, 1);
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,104 +94,53 @@ 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)
{
pf->shadow = shadow;
}
static guchar *
gimp_pixel_fetcher_provide_tile (GimpPixelFetcher *pf,
gint x,
gint y)
{
gint col, row;
gint coloff, rowoff;
col = x / pf->tile_width;
coloff = x % pf->tile_width;
row = y / pf->tile_height;
rowoff = y % pf->tile_height;
if ((col != pf->col) || (row != pf->row) || (pf->tile == NULL))
{
if (pf->tile != NULL)
gimp_tile_unref (pf->tile, pf->tile_dirty);
pf->tile = gimp_drawable_get_tile (pf->drawable, pf->shadow, row, col);
pf->tile_dirty = FALSE;
gimp_tile_ref (pf->tile);
pf->col = col;
pf->row = row;
}
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,
......@@ -184,26 +150,34 @@ gimp_pixel_fetcher_get_pixel (GimpPixelFetcher *pf,
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;
}
else if (x < 0 || x >= pf->img_width ||
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;
}
......@@ -215,89 +189,90 @@ gimp_pixel_fetcher_get_pixel (GimpPixelFetcher *pf,
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;
case GIMP_PIXEL_FETCHER_EDGE_BACKGROUND:
for (i = 0; i < pf->img_bpp; i++)
pixel[i] = pf->bg_color[i];
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)
gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf,
gint x,
gint y,
const guchar *pixel)
{
if (pf->tile)
gimp_tile_unref (pf->tile, pf->tile_dirty);
guchar *p;
gint i;
g_free (pf);
}
g_return_if_fail (pf != NULL);
g_return_if_fail (pixel != NULL);
static void
gimp_get_color_guchar (GimpDrawable *drawable,
GimpRGB *color,
gboolean transparent,
guchar *bg)
{
switch (gimp_drawable_type (drawable->drawable_id))
if (x < pf->sel_x1 || x >= pf->sel_x2 ||
y < pf->sel_y1 || y >= pf->sel_y2)
{
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;
return;
}
case GIMP_GRAY_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = 255;
break;
p = gimp_pixel_fetcher_provide_tile (pf, x, y);
case GIMP_GRAYA_IMAGE:
bg[0] = gimp_rgb_intensity_uchar (color);
bg[1] = transparent ? 0 : 255;
break;
i = pf->img_bpp;
default:
break;
do
{
*p++ = *pixel++;
}
while (--i);
pf->tile_dirty = TRUE;
}
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);
}
/* private functions */
void
gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg)
static guchar *
gimp_pixel_fetcher_provide_tile (GimpPixelFetcher *pf,
gint x,
gint y)
{
GimpRGB foreground;
gint col, row;
gint coloff, rowoff;
gimp_palette_get_foreground (&foreground);
gimp_get_color_guchar (drawable, &foreground, transparent, fg);
}
col = x / pf->tile_width;
coloff = x % pf->tile_width;
row = y / pf->tile_height;
rowoff = y % pf->tile_height;
if ((col != pf->col) || (row != pf->row) || (pf->tile == NULL))
{
if (pf->tile != NULL)
gimp_tile_unref (pf->tile, pf->tile_dirty);
pf->tile = gimp_drawable_get_tile (pf->drawable, pf->shadow, row, col);
pf->tile_dirty = FALSE;
gimp_tile_ref (pf->tile);
pf->col = col;
pf->row = row;
}
return pf->tile->data + pf->img_bpp * (pf->tile->ewidth * rowoff + coloff);
}
......@@ -35,19 +35,23 @@ 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);
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_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,
......@@ -56,15 +60,6 @@ void gimp_pixel_fetcher_put_pixel (GimpPixelFetcher *pf,
gint x,
gint y,
const guchar *pixel);
void gimp_pixel_fetcher_destroy (GimpPixelFetcher *pf);
void gimp_get_bg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *bg);
void gimp_get_fg_guchar (GimpDrawable *drawable,
gboolean transparent,
guchar *fg);
G_END_DECLS
......
......@@ -530,11 +530,17 @@ dialog_update_preview (void)
{
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);
......@@ -623,15 +629,21 @@ apply_blinds (void)
GimpPixelRgn des_rgn;
GimpPixelRgn src_rgn;
guchar *src_rows, *des_rows;
gint x,y;
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);
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);
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);
......
......@@ -218,9 +218,13 @@ do_checkerboard_pattern (GimpDrawable *drawable)
{
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)
{
......
......@@ -330,12 +330,12 @@ cubism (GimpDrawable *drawable)
guchar col[4];
guchar *dest;
gint bytes;
gint has_alpha;
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))
......
......@@ -2558,7 +2558,7 @@ p_init_gdrw (t_GDRW *gdrw,
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 */
......
......@@ -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);
......
......@@ -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);
......@@ -301,17 +301,19 @@ edge (GimpDrawable *drawable)
{
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)
{
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 &&
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)
{
/*
......@@ -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