dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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)
This commit is contained in:
Michael Natterer 2004-03-12 22:46:25 +00:00 committed by Michael Natterer
parent 5f9f60f408
commit a779e74817
24 changed files with 556 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
ChangeLog
View File

@ -1,3 +1,51 @@
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

4
libgimp/gimp.def
View File

@ -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

37
libgimp/gimpdrawable.c
View File

@ -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,

4
libgimp/gimpdrawable.h
View File

@ -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,

325
libgimp/gimppixelfetcher.c
View File

@ -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;
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);
}

23
libgimp/gimppixelfetcher.h
View File

@ -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

28
plug-ins/common/blinds.c
View File

@ -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);
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);

8
plug-ins/common/checkerboard.c
View File

@ -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)
{

11
plug-ins/common/cubism.c
View File

@ -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))

4
plug-ins/common/curve_bend.c
View File

@ -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 */

2
plug-ins/common/displace.c
View File

@ -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);

11
plug-ins/common/edge.c
View File

@ -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
dest[chan] = edge_detect(kernel);
}
}

3
plug-ins/common/illusion.c
View File

@ -264,8 +264,9 @@ filter (GimpDrawable *drawable)
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;

18
plug-ins/common/mblur.c
View File

@ -267,6 +267,7 @@ mblur_linear (void)
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
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;
@ -426,6 +428,7 @@ mblur_radial (void)
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
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;
@ -562,6 +566,7 @@ mblur_zoom (void)
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
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;

15
plug-ins/common/mosaic.c
View File

@ -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);

3
plug-ins/common/plasma.c
View File

@ -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;

17
plug-ins/common/polar.c
View File

@ -343,15 +343,19 @@ polarize (void)
{
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);
}
@ -388,7 +392,7 @@ calc_undistorted_coords (gdouble wx,
ym = ydiff / 2.0;
circle = pcvals.circle;
angle = pcvals.angle;
angl = (double)angle / 180.0 * G_PI;
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;

2
plug-ins/common/ripple.c
View File

@ -382,7 +382,7 @@ ripple (GimpDrawable *drawable)
GimpRgnIterator *iter;
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;

5
plug-ins/common/shift.c
View File

@ -222,12 +222,11 @@ shift (GimpDrawable *drawable)
gint progress, max_progress;
gint amount;
gint xdist, ydist;
GRand *gr; /* The random number generator we're using */
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);

4
plug-ins/common/spread.c
View File

@ -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 <time.h>
@ -227,12 +228,11 @@ spread (GimpDrawable *drawable)
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);

68
plug-ins/common/tileit.c
View File

@ -982,36 +982,39 @@ do_tiles(void)
gint row, col;
gint bpp;
guchar pixel[4];
int nc,nr;
int i;
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)) {
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++) {
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;
gint an_action;
an_action =
tiles_xy(sel_width,
an_action = tiles_xy (sel_width,
sel_height,
col-sel_x1,row-sel_y1,
&nc,&nr);
@ -1023,29 +1026,28 @@ do_tiles(void)
*dest++ = pixel[i];
if (has_alpha)
{
*dest++ = (pixel[bpp]*opacity)/100;
}
*dest++ = (pixel[bpp] * opacity) / 100;
}
dest_row += dest_rgn.rowstride;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update((double) progress / max_progress);
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,
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,
tiles_xy (gint width,
gint height,
gint x,
gint y,
@ -1055,28 +1057,30 @@ tiles_xy(gint width,
gint px,py;
gint rnum,cnum;
gint actiontype;
gdouble rnd = 1 - (1.0/(gdouble)itvals.numtiles) +0.01;
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,7 +1093,7 @@ tiles_xy(gint width,
/* Given a row then srink it down a bit */
static void
do_tiles_preview(guchar *dest_row,
do_tiles_preview (guchar *dest_row,
guchar *src_rows,
gint width,
gint dh,
@ -1098,12 +1102,12 @@ do_tiles_preview(guchar *dest_row,
{
gint x;
gint i;
gint px,py;
gint px, py;
gint rnum,cnum;
gint actiontype;
gdouble rnd = 1 - (1.0/(gdouble)itvals.numtiles) +0.01;
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 ++)
{

20
plug-ins/common/whirlpinch.c
View File

@ -346,11 +346,12 @@ whirl_pinch (void)
guchar *top_p, *bot_p;
gint row, col;
guchar **pixel;
double whirl;
double cx, cy;
int ix, iy;
int i;
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;

5
plug-ins/gflare/gflare.c
View File

@ -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,

3
plug-ins/libgimpoldpreview/gimpoldpreview.c
View File

@ -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;