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

39
libgimp/gimppixelfetcher.h
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;

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

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

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

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

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

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

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

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

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

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

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

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;