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

libgimp/gimpdrawablepreview.[ch] renamed gimp_drawable_preview_draw() to 

2004-09-15  Sven Neumann  <sven@gimp.org>

	* libgimp/gimpdrawablepreview.[ch]
	* libgimp/gimpui.def: renamed gimp_drawable_preview_draw() to
	gimp_drawable_preview_draw_buffer() and added a rowstride
	parameter. Added new functions gimp_drawable_preview_get_drawable()
	and gimp_drawable_preview_draw_region().

	* plug-ins/common/mblur.c: added a preview that uses the
	shadow tiles as the preview buffer and draws using the new
	gimp_drawable_preview_draw_region() API.

	* plug-ins/common/photocopy.c
	* plug-ins/common/softglow.c: use gimp_drawable_preview_draw_region().

	* plug-ins/common/cartoon.c
	* plug-ins/common/despeckle.c
	* plug-ins/common/edge.c
	* plug-ins/common/gauss.c
	* plug-ins/common/grid.c
	* plug-ins/common/neon.c
	* plug-ins/common/noisify.c
	* plug-ins/common/sel_gauss.c
	* plug-ins/common/sharpen.c
	* plug-ins/common/sobel.c
	* plug-ins/common/spread.c
	* plug-ins/common/struc.c
	* plug-ins/common/unsharp.c
	* plug-ins/common/wind.c: use gimp_drawable_preview_draw_buffer().
This commit is contained in:
Sven Neumann 2004-09-15 19:56:01 +00:00 committed by Sven Neumann
parent 186b590844
commit bfa352bae0
23 changed files with 539 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ChangeLog
View File

@ -1,3 +1,33 @@
2004-09-15 Sven Neumann <sven@gimp.org>
* libgimp/gimpdrawablepreview.[ch]
* libgimp/gimpui.def: renamed gimp_drawable_preview_draw() to
gimp_drawable_preview_draw_buffer() and added a rowstride
parameter. Added new functions gimp_drawable_preview_get_drawable()
and gimp_drawable_preview_draw_region().
* plug-ins/common/mblur.c: added a preview that uses the
shadow tiles as the preview buffer and draws using the new
gimp_drawable_preview_draw_region() API.
* plug-ins/common/photocopy.c
* plug-ins/common/softglow.c: use gimp_drawable_preview_draw_region().
* plug-ins/common/cartoon.c
* plug-ins/common/despeckle.c
* plug-ins/common/edge.c
* plug-ins/common/gauss.c
* plug-ins/common/grid.c
* plug-ins/common/neon.c
* plug-ins/common/noisify.c
* plug-ins/common/sel_gauss.c
* plug-ins/common/sharpen.c
* plug-ins/common/sobel.c
* plug-ins/common/spread.c
* plug-ins/common/struc.c
* plug-ins/common/unsharp.c
* plug-ins/common/wind.c: use gimp_drawable_preview_draw_buffer().
2004-09-15 Michael Natterer <mitch@gimp.org>
* app/widgets/gimphelp-ids.h: added help IDs for the drawable- and

4
devel-docs/libgimp/libgimp-sections.txt
View File

@ -690,7 +690,9 @@ gimp_drawable_get_thumbnail
<TITLE>GimpDrawablePreview</TITLE>
GimpDrawablePreview
gimp_drawable_preview_new
gimp_drawable_preview_draw
gimp_drawable_preview_get_drawable
gimp_drawable_preview_draw_buffer
gimp_drawable_preview_draw_region
<SUBSECTION Standard>
GimpDrawablePreviewClass
GIMP_DRAWABLE_PREVIEW

23
devel-docs/libgimp/tmpl/gimpdrawablepreview.sgml
View File

@ -30,12 +30,31 @@ GimpDrawablePreview
@Returns:
<!-- ##### FUNCTION gimp_drawable_preview_draw ##### -->
<!-- ##### FUNCTION gimp_drawable_preview_get_drawable ##### -->
<para>
</para>
@preview:
@buf:
@Returns:
<!-- ##### FUNCTION gimp_drawable_preview_draw_buffer ##### -->
<para>
</para>
@preview:
@buffer:
@rowstride:
<!-- ##### FUNCTION gimp_drawable_preview_draw_region ##### -->
<para>
</para>
@preview:
@region:

190
libgimp/gimpdrawablepreview.c
View File

@ -205,6 +205,69 @@ gimp_drawable_preview_draw_thumb (GimpPreview *preview,
}
}
static void
gimp_drawable_preview_draw_area (GimpDrawablePreview *preview,
gint x,
gint y,
gint width,
gint height,
const guchar *buf,
gint rowstride)
{
GimpPreview *gimp_preview = GIMP_PREVIEW (preview);
GimpDrawable *drawable = preview->drawable;
gint32 image_id;
image_id = gimp_drawable_get_image (drawable->drawable_id);
if (gimp_selection_is_empty (image_id))
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (gimp_preview->area),
x - gimp_preview->xoff - gimp_preview->xmin,
y - gimp_preview->yoff - gimp_preview->ymin,
width,
height,
gimp_drawable_type (drawable->drawable_id),
buf, rowstride);
}
else
{
GimpPixelRgn selection_rgn;
GimpPixelRgn drawable_rgn;
guchar *sel;
guchar *src;
gint selection_id;
selection_id = gimp_image_get_selection (image_id);
gimp_pixel_rgn_init (&drawable_rgn, drawable,
x, y, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&selection_rgn, gimp_drawable_get (selection_id),
x, y, width, height,
FALSE, FALSE);
sel = g_new (guchar, width * height);
src = g_new (guchar, width * height * drawable->bpp);
gimp_pixel_rgn_get_rect (&drawable_rgn, src, x, y, width, height);
gimp_pixel_rgn_get_rect (&selection_rgn, sel, x, y, width, height);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (gimp_preview->area),
x - gimp_preview->xoff - gimp_preview->xmin,
y - gimp_preview->yoff - gimp_preview->ymin,
width,
height,
gimp_drawable_type (drawable->drawable_id),
src, width * drawable->bpp,
buf, rowstride,
sel, width);
g_free (sel);
g_free (src);
}
}
static void
gimp_drawable_preview_set_drawable (GimpDrawablePreview *drawable_preview,
GimpDrawable *drawable)
@ -288,78 +351,95 @@ gimp_drawable_preview_new (GimpDrawable *drawable,
}
/**
* gimp_drawable_preview_draw:
* @preview: a #GimpDrawablePreview widget
* @buf:
* gimp_drawable_preview_get_drawable:
* @preview: a #GimpDrawablePreview widget
*
* Return value: the #GimpDrawable that has been passed to
* gimp_drawable_preview_new().
*
* Since: GIMP 2.2
**/
GimpDrawable *
gimp_drawable_preview_get_drawable (GimpDrawablePreview *preview)
{
g_return_val_if_fail (GIMP_IS_DRAWABLE_PREVIEW (preview), NULL);
return preview->drawable;
}
/**
* gimp_drawable_preview_draw_buffer:
* @preview: a #GimpDrawablePreview widget
* @buffer:
* @rowstride:
*
* Since: GIMP 2.2
**/
void
gimp_drawable_preview_draw (GimpDrawablePreview *preview,
const guchar *buf)
gimp_drawable_preview_draw_buffer (GimpDrawablePreview *preview,
const guchar *buffer,
gint rowstride)
{
GimpPreview *gimp_preview;
GimpDrawable *drawable;
gint32 image_id;
gint width, height;
gint bytes;
GimpPreview *gimp_preview;
g_return_if_fail (GIMP_IS_DRAWABLE_PREVIEW (preview));
g_return_if_fail (preview->drawable != NULL);
g_return_if_fail (buf != NULL);
g_return_if_fail (buffer != NULL);
gimp_preview = GIMP_PREVIEW (preview);
drawable = preview->drawable;
width = gimp_preview->width;
height = gimp_preview->height;
bytes = drawable->bpp;
gimp_drawable_preview_draw_area (preview,
gimp_preview->xmin + gimp_preview->xoff,
gimp_preview->ymin + gimp_preview->yoff,
gimp_preview->width,
gimp_preview->height,
buffer, rowstride);
}
image_id = gimp_drawable_get_image (drawable->drawable_id);
/**
* gimp_drawable_preview_draw_region:
* @preview: a #GimpDrawablePreview widget
* @region: a #GimpPixelRgn
*
* Since: GIMP 2.2
**/
void
gimp_drawable_preview_draw_region (GimpDrawablePreview *preview,
const GimpPixelRgn *region)
{
g_return_if_fail (GIMP_IS_DRAWABLE_PREVIEW (preview));
g_return_if_fail (preview->drawable != NULL);
g_return_if_fail (region != NULL);
if (gimp_selection_is_empty (image_id))
/* If the data field is initialized, this region is currently being
* processed and we can access it directly.
*/
if (region->data)
{
gimp_preview_area_draw (GIMP_PREVIEW_AREA (gimp_preview->area),
0, 0, width, height,
gimp_drawable_type (drawable->drawable_id),
buf,
width * bytes);
gimp_drawable_preview_draw_area (preview,
region->x,
region->y,
region->w,
region->h,
region->data,
region->rowstride);
}
else
{
GimpPixelRgn selection_rgn;
GimpPixelRgn drawable_rgn;
guchar *sel;
guchar *src;
gint selection_id;
gint x1, y1;
GimpPixelRgn src = *region;
gpointer iter;
selection_id = gimp_image_get_selection (image_id);
x1 = gimp_preview->xoff + gimp_preview->xmin;
y1 = gimp_preview->yoff + gimp_preview->ymin;
gimp_pixel_rgn_init (&drawable_rgn, drawable,
x1, y1, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&selection_rgn, gimp_drawable_get (selection_id),
x1, y1, width, height,
FALSE, FALSE);
sel = g_new (guchar, width * height);
src = g_new (guchar, width * height * bytes);
gimp_pixel_rgn_get_rect (&drawable_rgn, src, x1, y1, width, height);
gimp_pixel_rgn_get_rect (&selection_rgn, sel, x1, y1, width, height);
gimp_preview_area_mask (GIMP_PREVIEW_AREA (gimp_preview->area),
0, 0, width, height,
gimp_drawable_type (drawable->drawable_id),
src, width * bytes,
buf, width * bytes,
sel, width);
g_free (sel);
g_free (src);
for (iter = gimp_pixel_rgns_register (1, &src);
iter != NULL;
iter = gimp_pixel_rgns_process (iter))
{
gimp_drawable_preview_draw_area (preview,
src.x,
src.y,
src.w,
src.h,
src.data,
src.rowstride);
}
}
}

14
libgimp/gimpdrawablepreview.h
View File

@ -53,13 +53,17 @@ struct _GimpDrawablePreviewClass
};
GType gimp_drawable_preview_get_type (void) G_GNUC_CONST;
GType gimp_drawable_preview_get_type (void) G_GNUC_CONST;
GtkWidget * gimp_drawable_preview_new (GimpDrawable *drawable,
gboolean *toggle);
GtkWidget * gimp_drawable_preview_new (GimpDrawable *drawable,
gboolean *toggle);
GimpDrawable * gimp_drawable_preview_get_drawable (GimpDrawablePreview *preview);
void gimp_drawable_preview_draw (GimpDrawablePreview *preview,
const guchar *buf);
void gimp_drawable_preview_draw_buffer (GimpDrawablePreview *preview,
const guchar *buffer,
gint rowstride);
void gimp_drawable_preview_draw_region (GimpDrawablePreview *preview,
const GimpPixelRgn *region);
G_END_DECLS

4
libgimp/gimpui.def
View File

@ -7,7 +7,9 @@ EXPORTS
gimp_drawable_combo_box_new
gimp_drawable_get_thumbnail
gimp_drawable_menu_new
gimp_drawable_preview_draw
gimp_drawable_preview_draw_buffer
gimp_drawable_preview_draw_region
gimp_drawable_preview_get_drawable
gimp_drawable_preview_get_type
gimp_drawable_preview_new
gimp_export_image

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

@ -586,7 +586,8 @@ cartoon (GimpDrawable *drawable,
if (preview)
{
gimp_drawable_preview_draw (preview, preview_buffer);
gimp_drawable_preview_draw_buffer (preview,
preview_buffer, width * bytes);
g_free (preview_buffer);
}
else

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

@ -855,7 +855,8 @@ preview_update (GtkWidget *widget)
* Update the screen...
*/
gimp_drawable_preview_draw (GIMP_DRAWABLE_PREVIEW (preview), rgba);
gimp_drawable_preview_draw_buffer (GIMP_DRAWABLE_PREVIEW (preview),
rgba, preview->width * img_bpp);
g_free (rgba);
g_free (preview_src);

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

@ -843,7 +843,7 @@ edge_preview_update (GimpDrawablePreview *preview)
/*
* Draw the preview image on the screen...
*/
gimp_drawable_preview_draw (preview, render_buffer);
gimp_drawable_preview_draw_buffer (preview, render_buffer, width * bytes);
g_free (render_buffer);
g_free (src);

6
plug-ins/common/gauss.c
View File

@ -294,7 +294,7 @@ run (const gchar *name,
{
bvals.horizontal = param[3].data.d_float;
bvals.vertical = param[4].data.d_float;
bvals.method = param[5].data.d_int32;
bvals.method = param[5].data.d_int32;
}
if (status == GIMP_PDB_SUCCESS &&
(bvals.horizontal <= 0.0 && bvals.vertical <= 0.0))
@ -1043,8 +1043,8 @@ gauss (GimpDrawable *drawable,
if (preview)
{
gimp_drawable_preview_draw (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer2);
gimp_drawable_preview_draw_buffer (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer2, width * bytes);
g_free (preview_buffer1);
g_free (preview_buffer2);
}

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

@ -482,7 +482,8 @@ grid (gint32 image_ID,
if (preview)
{
gimp_drawable_preview_draw (GIMP_DRAWABLE_PREVIEW (preview), buffer);
gimp_drawable_preview_draw_buffer (GIMP_DRAWABLE_PREVIEW (preview),
buffer, bytes * (sx2 - sx1));
g_free (buffer);
}
else

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

@ -76,11 +76,12 @@ typedef enum
typedef struct
{
gint32 mblur_type;
gint32 length;
gint32 angle;
gdouble center_x;
gdouble center_y;
gint32 mblur_type;
gint32 length;
gint32 angle;
gdouble center_x;
gdouble center_y;
gboolean preview;
} mblur_vals_t;
/***** Prototypes *****/
@ -92,12 +93,29 @@ static void run (const gchar *name,
gint *nreturn_vals,
GimpParam **return_vals);
static void mblur (GimpDrawable *drawable);
static void mblur_linear (GimpDrawable *drawable);
static void mblur_radial (GimpDrawable *drawable);
static void mblur_zoom (GimpDrawable *drawable);
static void mblur (GimpDrawable *drawable,
GimpPreview *preview);
static void mblur_linear (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height);
static void mblur_radial (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height);
static void mblur_zoom (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height);
static gboolean mblur_dialog (gint32 image_ID);
static gboolean mblur_dialog (gint32 image_ID,
GimpDrawable *drawable);
/***** Variables *****/
@ -115,17 +133,18 @@ static mblur_vals_t mbvals =
5, /* length */
45, /* radius */
100000.0, /* center_x */
100000.0 /* center_y */
100000.0, /* center_y */
FALSE /* preview */
};
static GtkObject *length = NULL;
static GtkObject *angle = NULL;
static GtkWidget *center = NULL;
static gint img_width, img_height, img_bpp;
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint has_alpha;
static GtkObject *length = NULL;
static GtkObject *angle = NULL;
static GtkWidget *center = NULL;
static GtkWidget *preview = NULL;
static gint img_width, img_height, img_bpp;
static gboolean has_alpha;
/***** Functions *****/
@ -175,6 +194,8 @@ run (const gchar *name,
GimpRunMode run_mode;
GimpPDBStatusType status;
GimpDrawable *drawable;
gint x1, y1, x2, y2;
INIT_I18N ();
status = GIMP_PDB_SUCCESS;
@ -194,16 +215,10 @@ run (const gchar *name,
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Calculate scaling parameters */
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
mbvals.center_x = (gdouble) (sel_x1 + sel_x2 - 1) / 2.0;
mbvals.center_y = (gdouble) (sel_y1 + sel_y2 - 1) / 2.0;
mbvals.center_x = (gdouble) (x1 + x2 - 1) / 2.0;
mbvals.center_y = (gdouble) (y1 + y2 - 1) / 2.0;
switch (run_mode)
{
@ -212,7 +227,7 @@ run (const gchar *name,
gimp_get_data (PLUG_IN_NAME, &mbvals);
/* Get information from the dialog */
if (!mblur_dialog (param[1].data.d_image))
if (! mblur_dialog (param[1].data.d_image, drawable))
return;
break;
@ -258,7 +273,7 @@ run (const gchar *name,
/* Run! */
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
mblur (drawable);
mblur (drawable, NULL);
/* If run mode is interactive, flush displays */
if (run_mode != GIMP_RUN_NONINTERACTIVE)
@ -277,7 +292,12 @@ run (const gchar *name,
}
static void
mblur_linear (GimpDrawable *drawable)
mblur_linear (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
@ -294,7 +314,7 @@ mblur_linear (GimpDrawable *drawable)
gint dx, dy, px, py, swapdir, err, e, s1, s2;
gimp_pixel_rgn_init (&dest_rgn, drawable,
sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE);
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
@ -302,7 +322,7 @@ mblur_linear (GimpDrawable *drawable)
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = sel_width * sel_height;
max_progress = width * height;
n = mbvals.length;
px = (gdouble) n * cos (mbvals.angle / 180.0 * G_PI);
@ -395,13 +415,16 @@ mblur_linear (GimpDrawable *drawable)
yy += s2;
e -= dx;
}
if (swapdir)
yy += s2;
else
xx += s1;
e += dy;
if ((xx < sel_x1) || (xx >= sel_x2) ||
(yy < sel_y1) || (yy >= sel_y2))
if ((xx < x1) || (xx >= x1 + width) ||
(yy < y1) || (yy >= y1 + height))
break;
}
@ -427,18 +450,35 @@ mblur_linear (GimpDrawable *drawable)
d[c] = sum[c] / i;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / max_progress);
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((gdouble) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
}
static void
mblur_radial (GimpDrawable *drawable)
mblur_radial (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
@ -467,7 +507,7 @@ mblur_radial (GimpDrawable *drawable)
center_y = mbvals.center_y;
gimp_pixel_rgn_init (&dest_rgn, drawable,
sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE);
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
@ -475,7 +515,7 @@ mblur_radial (GimpDrawable *drawable)
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = sel_width * sel_height;
max_progress = width * height;
angle = gimp_deg_to_rad (mbvals.angle);
@ -510,6 +550,7 @@ mblur_radial (GimpDrawable *drawable)
xr = x - center_x;
yr = y - center_y;
r = sqrt (xr * xr + yr * yr);
if (r == 0)
step = 1;
else if ((step = R / r) == 0)
@ -524,17 +565,20 @@ mblur_radial (GimpDrawable *drawable)
{
xx = center_x + xr * ct[i] - yr * st[i];
yy = center_y + xr * st[i] + yr * ct[i];
if ((yy < sel_y1) || (yy >= sel_y2) ||
(xx < sel_x1) || (xx >= sel_x2))
if ((yy < y1) || (yy >= y1 + height) ||
(xx < x1) || (xx >= x1 + width))
continue;
++count;
gimp_pixel_fetcher_get_pixel (pft, xx, yy, pixel);
if (has_alpha)
{
gint32 alpha = pixel[img_bpp-1];
sum[img_bpp-1] += alpha;
for (c = 0; c < img_bpp-1; c++)
sum[c] += pixel[c] * alpha;
}
@ -567,12 +611,23 @@ mblur_radial (GimpDrawable *drawable)
d[c] = sum[c] / count;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / max_progress);
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
@ -582,7 +637,12 @@ mblur_radial (GimpDrawable *drawable)
}
static void
mblur_zoom (GimpDrawable *drawable)
mblur_zoom (GimpDrawable *drawable,
GimpPreview *preview,
gint x1,
gint y1,
gint width,
gint height)
{
GimpPixelRgn dest_rgn;
GimpPixelFetcher *pft;
@ -607,7 +667,7 @@ mblur_zoom (GimpDrawable *drawable)
center_y = mbvals.center_y;
gimp_pixel_rgn_init (&dest_rgn, drawable,
sel_x1, sel_y1, sel_width, sel_height, TRUE, TRUE);
x1, y1, width, height, (preview == NULL), TRUE);
pft = gimp_pixel_fetcher_new (drawable, FALSE);
@ -615,7 +675,7 @@ mblur_zoom (GimpDrawable *drawable)
gimp_pixel_fetcher_set_bg_color (pft, &background);
progress = 0;
max_progress = sel_width * sel_height;
max_progress = width * height;
n = mbvals.length;
f = 0.02;
@ -640,8 +700,8 @@ mblur_zoom (GimpDrawable *drawable)
xx = center_x + (x - center_x) * (1.0 - f * i);
yy = center_y + (y - center_y) * (1.0 - f * i);
if ((yy < sel_y1) || (yy >= sel_y2) ||
(xx < sel_x1) || (xx >= sel_x2))
if ((yy < y1) || (yy >= y1 + height) ||
(xx < x1) || (xx >= x1 + width))
break;
gimp_pixel_fetcher_get_pixel (pft, xx, yy, pixel);
@ -650,6 +710,7 @@ mblur_zoom (GimpDrawable *drawable)
gint32 alpha = pixel[img_bpp-1];
sum[img_bpp-1] += alpha;
for (c = 0; c < img_bpp-1; c++)
sum[c] += pixel[c] * alpha;
}
@ -682,40 +743,78 @@ mblur_zoom (GimpDrawable *drawable)
d[c] = sum[c] / i;
}
}
d += dest_rgn.bpp;
}
dest += dest_rgn.rowstride;
}
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / max_progress);
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update ((double) progress / max_progress);
}
}
gimp_pixel_fetcher_destroy (pft);
}
static void
mblur (GimpDrawable *drawable)
mblur (GimpDrawable *drawable,
GimpPreview *preview)
{
gimp_progress_init (_("Motion Blurring..."));
gint x, y;
gint width, height;
if (preview)
{
gimp_preview_get_position (preview, &x, &y);
gimp_preview_get_size (preview, &width, &height);
}
else
{
gimp_drawable_mask_bounds (drawable->drawable_id,
&x, &y, &width, &height);
width -= x;
height -= y;
}
if (width < 1 || height < 1)
return;
if (! preview)
gimp_progress_init (_("Motion Blurring..."));
switch (mbvals.mblur_type)
{
case MBLUR_LINEAR:
mblur_linear (drawable);
mblur_linear (drawable, preview, x, y, width, height);
break;
case MBLUR_RADIAL:
mblur_radial (drawable);
mblur_radial (drawable, preview, x, y, width, height);
break;
case MBLUR_ZOOM:
mblur_zoom (drawable);
mblur_zoom (drawable, preview, x, y, width, height);
break;
default:
break;
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
if (! preview)
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x, y, width, height);
}
}
/****************************************
@ -735,30 +834,43 @@ mblur_set_sensitivity (void)
gimp_scale_entry_set_sensitive (angle, TRUE);
gtk_widget_set_sensitive (center, FALSE);
break;
case MBLUR_RADIAL:
gimp_scale_entry_set_sensitive (length, FALSE);
gimp_scale_entry_set_sensitive (angle, TRUE);
gtk_widget_set_sensitive (center, TRUE);
break;
case MBLUR_ZOOM:
gimp_scale_entry_set_sensitive (length, TRUE);
gimp_scale_entry_set_sensitive (angle, FALSE);
gtk_widget_set_sensitive (center, TRUE);
break;
default:
break;
}
}
static void
mblur_radio_button_update (GtkWidget *widget, gpointer data)
mblur_radio_button_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
mblur_set_sensitivity ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
mblur_center_update (GimpSizeEntry *entry)
{
mbvals.center_x = gimp_size_entry_get_refval (entry, 0);
mbvals.center_y = gimp_size_entry_get_refval (entry, 1);
}
static gboolean
mblur_dialog (gint32 image_ID)
mblur_dialog (gint32 image_ID,
GimpDrawable *drawable)
{
GtkWidget *dialog;
GtkWidget *vbox;
@ -788,6 +900,14 @@ mblur_dialog (gint32 image_ID)
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), vbox);
gtk_widget_show (vbox);
preview = gimp_drawable_preview_new (drawable, &mbvals.preview);
gtk_box_pack_start (GTK_BOX (vbox), preview, TRUE, TRUE, 0);
gtk_widget_show (preview);
g_signal_connect_swapped (preview, "invalidated",
G_CALLBACK (mblur),
drawable);
frame = gimp_int_radio_group_new (TRUE, _("Blur Type"),
G_CALLBACK (mblur_radio_button_update),
&mbvals.mblur_type, mbvals.mblur_type,
@ -801,7 +921,6 @@ mblur_dialog (gint32 image_ID)
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
frame = gimp_frame_new (_("Blur Parameters"));
@ -825,6 +944,9 @@ mblur_dialog (gint32 image_ID)
g_signal_connect (length, "value_changed",
G_CALLBACK (gimp_int_adjustment_update),
&mbvals.length);
g_signal_connect_swapped (length, "value_changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
angle = gimp_scale_entry_new (GTK_TABLE (table), 0, 1,
_("_Angle:"), 150, 3,
@ -836,8 +958,11 @@ mblur_dialog (gint32 image_ID)
g_signal_connect (angle, "value_changed",
G_CALLBACK (gimp_int_adjustment_update),
&mbvals.angle);
g_signal_connect_swapped (angle, "value_changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
center = gimp_frame_new (_("Center"));
center = gimp_frame_new (_("Blur Center"));
gtk_box_pack_start (GTK_BOX (vbox), center, FALSE, FALSE, 0);
gtk_widget_show (center);
@ -847,11 +972,19 @@ mblur_dialog (gint32 image_ID)
GIMP_UNIT_PIXEL, "%a",
TRUE, FALSE, FALSE, 5,
GIMP_SIZE_ENTRY_UPDATE_SIZE);
gtk_table_set_row_spacings (GTK_TABLE (entry), 4);
gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 4);
gtk_table_set_row_spacings (GTK_TABLE (entry), 2);
gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6);
gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6);
gtk_container_add (GTK_CONTAINER (center), entry);
gtk_widget_show (entry);
g_signal_connect (entry, "value_changed",
G_CALLBACK (mblur_center_update),
NULL);
g_signal_connect_swapped (entry, "value_changed",
G_CALLBACK (gimp_preview_invalidate),
preview);
spinbutton = gimp_spin_button_new (&adj, 1, 0, 1, 1, 10, 1, 1, 2);
gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry),
GTK_SPIN_BUTTON (spinbutton), NULL);
@ -870,16 +1003,12 @@ mblur_dialog (gint32 image_ID)
_("_Y:"), 1, 0, 0.0);
gtk_size_group_add_widget (group, label);
mblur_set_sensitivity ();
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
mbvals.center_x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0);
mbvals.center_y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1);
gtk_widget_destroy (dialog);
return run;

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

@ -466,8 +466,8 @@ neon (GimpDrawable *drawable,
if (preview)
{
gimp_drawable_preview_draw (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer2);
gimp_drawable_preview_draw_buffer (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer2, width * bytes);
g_free (preview_buffer1);
g_free (preview_buffer2);
}

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

@ -296,7 +296,7 @@ noisify (GimpDrawablePreview *preview)
for (i = 0; i < width * height; i++)
noisify_func (src + i * bpp, dst + i * bpp, bpp, gr);
gimp_drawable_preview_draw (preview, dst);
gimp_drawable_preview_draw_buffer (preview, dst, width * bpp);
g_free (src);
g_free (dst);

63
plug-ins/common/photocopy.c
View File

@ -286,7 +286,7 @@ photocopy (GimpDrawable *drawable,
gdouble bd_p2[5], bd_m2[5];
gdouble *val_p1, *val_m1, *vp1, *vm1;
gdouble *val_p2, *val_m2, *vp2, *vm2;
gint x1, y1, x2, y2;
gint x1, y1;
gint i, j;
gint row, col;
gint terms;
@ -301,7 +301,6 @@ photocopy (GimpDrawable *drawable,
gdouble std_dev2;
gdouble ramp_down;
gdouble ramp_up;
guchar *preview_buffer = NULL;
if (preview)
{
@ -310,11 +309,14 @@ photocopy (GimpDrawable *drawable,
}
else
{
gint x2, y2;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
width = x2 - x1;
height = y2 - y1;
}
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
@ -526,35 +528,20 @@ photocopy (GimpDrawable *drawable,
/* Initialize the pixel regions. */
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, width, height, FALSE, FALSE);
if (preview)
{
preview_buffer = g_new (guchar, width * height * bytes);
pr = gimp_pixel_rgns_register (1, &src_rgn);
}
else
{
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height,
TRUE, TRUE);
pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
}
gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, width, height,
(preview == NULL), TRUE);
pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
while (pr)
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr;
guchar *dest_ptr = dest_rgn.data;
guchar *blur_ptr = dest1 + (src_rgn.y - y1) * width + (src_rgn.x - x1);
guchar *avg_ptr = dest2 + (src_rgn.y - y1) * width + (src_rgn.x - x1);
gdouble diff, mult;
gdouble lightness = 0.0;
if (preview)
dest_ptr =
preview_buffer +
((src_rgn.y - y1) * width + (src_rgn.x - x1)) * bytes;
else
dest_ptr = dest_rgn.data;
for (row = 0; row < src_rgn.h; row++)
{
for (col = 0; col < src_rgn.w; col++)
@ -568,7 +555,8 @@ photocopy (GimpDrawable *drawable,
if (ramp_down == 0.0)
mult = 0.0;
else
mult = (ramp_down - MIN (ramp_down, (pvals.threshold - diff))) / ramp_down;
mult = (ramp_down - MIN (ramp_down,
(pvals.threshold - diff))) / ramp_down;
lightness = CLAMP (blur_ptr[col] * mult, 0, 255);
}
else
@ -576,14 +564,17 @@ photocopy (GimpDrawable *drawable,
if (ramp_up == 0.0)
mult = 1.0;
else
mult = MIN (ramp_up, (diff - pvals.threshold)) / ramp_up;
mult = MIN (ramp_up,
(diff - pvals.threshold)) / ramp_up;
lightness = 255 - (1.0 - mult) * (255 - blur_ptr[col]);
lightness = CLAMP (lightness, 0, 255);
}
}
else
lightness = 0;
{
lightness = 0;
}
if (bytes < 3)
{
@ -603,15 +594,16 @@ photocopy (GimpDrawable *drawable,
}
src_ptr += src_rgn.rowstride;
if (preview)
dest_ptr += width * bytes;
else
dest_ptr += dest_rgn.rowstride;
dest_ptr += dest_rgn.rowstride;
blur_ptr += width;
avg_ptr += width;
}
if (!preview)
if (preview)
{
gimp_drawable_preview_draw_region (preview, &dest_rgn);
}
else
{
progress += src_rgn.w * src_rgn.h;
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
@ -620,12 +612,7 @@ photocopy (GimpDrawable *drawable,
pr = gimp_pixel_rgns_process (pr);
}
if (preview)
{
gimp_drawable_preview_draw (preview, preview_buffer);
g_free (preview_buffer);
}
else
if (! preview)
{
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);

9
plug-ins/common/sel_gauss.c
View File

@ -451,6 +451,7 @@ sel_gauss (GimpDrawable *drawable,
static void
preview_update (GimpDrawablePreview *preview)
{
GimpDrawable *drawable = gimp_drawable_preview_get_drawable (preview);
glong bytes;
gint x1, y1;
guchar *render_buffer; /* Buffer to hold rendered image */
@ -465,7 +466,7 @@ preview_update (GimpDrawablePreview *preview)
gdouble radius;
/* Get drawable info */
bytes = preview->drawable->bpp;
bytes = drawable->bpp;
/*
* Setup for filter...
@ -474,7 +475,7 @@ preview_update (GimpDrawablePreview *preview)
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, &height);
/* initialize pixel regions */
gimp_pixel_rgn_init (&srcPR, preview->drawable,
gimp_pixel_rgn_init (&srcPR, drawable,
x1, y1, width, height,
FALSE, FALSE);
render_buffer = g_new (guchar, width * height * bytes);
@ -483,7 +484,7 @@ preview_update (GimpDrawablePreview *preview)
/* render image */
gimp_pixel_rgn_get_rect (&srcPR, src, x1, y1, width, height);
has_alpha = gimp_drawable_has_alpha(preview->drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
radius = fabs (bvals.radius) + 1.0;
numrad = (gint) (radius + 1.0);
@ -507,7 +508,7 @@ preview_update (GimpDrawablePreview *preview)
/*
* Draw the preview image on the screen...
*/
gimp_drawable_preview_draw (preview, render_buffer);
gimp_drawable_preview_draw_buffer (preview, render_buffer, width * bytes);
g_free (render_buffer);
}

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

@ -621,7 +621,8 @@ preview_update (GimpDrawablePreview *preview)
(*filter)(preview_width, src_ptr, dst_ptr, neg_ptr - width,
neg_ptr, neg_ptr + width);
gimp_drawable_preview_draw (preview, preview_dst);
gimp_drawable_preview_draw_buffer (preview,
preview_dst, preview_width * img_bpp);
g_free (preview_src);
g_free (preview_neg);

26
plug-ins/common/sobel.c
View File

@ -53,13 +53,13 @@ static void sobel (GimpDrawable *drawable,
gboolean horizontal,
gboolean vertical,
gboolean keep_sign,
GtkWidget *preview);
GimpPreview *preview);
/*
* Sobel interface
*/
static gboolean sobel_dialog (GimpDrawable *drawable);
static void sobel_preview_update (GtkWidget *preview);
static void sobel_preview_update (GimpPreview *preview);
/*
* Sobel helper functions
@ -293,9 +293,9 @@ sobel_dialog (GimpDrawable *drawable)
}
static void
sobel_preview_update (GtkWidget *preview)
sobel_preview_update (GimpPreview *preview)
{
sobel (GIMP_DRAWABLE_PREVIEW (preview)->drawable,
sobel (gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview)),
bvals.horizontal,
bvals.vertical,
bvals.keep_sign,
@ -304,10 +304,10 @@ sobel_preview_update (GtkWidget *preview)
static void
sobel_prepare_row (GimpPixelRgn *pixel_rgn,
guchar *data,
gint x,
gint y,
gint w)
guchar *data,
gint x,
gint y,
gint w)
{
gint b;
@ -329,7 +329,7 @@ sobel (GimpDrawable *drawable,
gboolean do_horizontal,
gboolean do_vertical,
gboolean keep_sign,
GtkWidget *preview)
GimpPreview *preview)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
@ -348,8 +348,8 @@ sobel (GimpDrawable *drawable,
if (preview)
{
gimp_preview_get_position (GIMP_PREVIEW (preview), &x1, &y1);
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, &height);
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
x2 = x1 + width;
y2 = y1 + height;
}
@ -453,8 +453,8 @@ sobel (GimpDrawable *drawable,
if (preview)
{
gimp_drawable_preview_draw (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer);
gimp_drawable_preview_draw_buffer (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer, width * bytes);
g_free (preview_buffer);
}
else

106
plug-ins/common/softglow.c
View File

@ -61,9 +61,9 @@ static void run (const gchar *name,
gint *nreturn_vals,
GimpParam **return_vals);
static void softglow (GimpDrawable *drawable,
GtkWidget *preview);
static gboolean softglow_dialog (GimpDrawable *drawable);
static void softglow (GimpDrawable *drawable,
GimpPreview *preview);
static gboolean softglow_dialog (GimpDrawable *drawable);
/*
* Gaussian blur helper functions
@ -229,7 +229,7 @@ run (const gchar *name,
static void
softglow (GimpDrawable *drawable,
GtkWidget *preview)
GimpPreview *preview)
{
GimpPixelRgn src_rgn, dest_rgn;
GimpPixelRgn *pr;
@ -256,8 +256,8 @@ softglow (GimpDrawable *drawable,
if (preview)
{
gimp_preview_get_position (GIMP_PREVIEW (preview), &x1, &y1);
gimp_preview_get_size (GIMP_PREVIEW (preview), &width, &height);
gimp_preview_get_position (preview, &x1, &y1);
gimp_preview_get_size (preview, &width, &height);
x2 = x1 + width;
y2 = y1 + height;
}
@ -430,84 +430,54 @@ softglow (GimpDrawable *drawable,
/* Initialize the pixel regions. */
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, width, height, (preview == NULL), TRUE);
if (preview)
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
{
guchar *preview_buffer;
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr = dest_rgn.data;
guchar *blur_ptr = dest + (src_rgn.y - y1) * width + (src_rgn.x - x1);
preview_buffer = g_new (guchar, width * height * bytes);
for (pr = gimp_pixel_rgns_register (1, &src_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
for (row = 0; row < src_rgn.h; row++)
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr = preview_buffer +
bytes *
((src_rgn.y - y1) * width + (src_rgn.x - x1));
guchar *blur_ptr = dest + (src_rgn.y - y1) * width + (src_rgn.x - x1);
for (row = 0; row < src_rgn.h; row++)
for (col = 0; col < src_rgn.w; col++)
{
for (col = 0; col < src_rgn.w; col++)
{
/* screen op */
for (b = 0; b < (has_alpha ? (bytes - 1) : bytes); b++)
dest_ptr[col * bytes + b] =
255 - INT_MULT((255 - src_ptr[col * bytes + b]),
(255 - blur_ptr[col]), tmp);
if (has_alpha)
dest_ptr[col * bytes + b] = src_ptr[col * bytes + b];
}
src_ptr += src_rgn.rowstride;
dest_ptr += width * bytes;
blur_ptr += width;
/* screen op */
for (b = 0; b < (has_alpha ? (bytes - 1) : bytes); b++)
dest_ptr[col * bytes + b] =
255 - INT_MULT((255 - src_ptr[col * bytes + b]),
(255 - blur_ptr[col]), tmp);
if (has_alpha)
dest_ptr[col * bytes + b] = src_ptr[col * bytes + b];
}
src_ptr += src_rgn.rowstride;
dest_ptr += dest_rgn.rowstride;
blur_ptr += width;
}
gimp_drawable_preview_draw (GIMP_DRAWABLE_PREVIEW (preview),
preview_buffer);
g_free (preview_buffer);
}
else
{
gimp_pixel_rgn_init (&dest_rgn,
drawable, x1, y1, width, height, TRUE, TRUE);
for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn);
pr != NULL;
pr = gimp_pixel_rgns_process (pr))
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&dest_rgn);
}
else
{
guchar *src_ptr = src_rgn.data;
guchar *dest_ptr = dest_rgn.data;
guchar *blur_ptr = dest + (src_rgn.y - y1) * width + (src_rgn.x - x1);
for (row = 0; row < src_rgn.h; row++)
{
for (col = 0; col < src_rgn.w; col++)
{
/* screen op */
for (b = 0; b < (has_alpha ? (bytes - 1) : bytes); b++)
dest_ptr[col * bytes + b] =
255 - INT_MULT((255 - src_ptr[col * bytes + b]),
(255 - blur_ptr[col]), tmp);
if (has_alpha)
dest_ptr[col * bytes + b] = src_ptr[col * bytes + b];
}
src_ptr += src_rgn.rowstride;
dest_ptr += dest_rgn.rowstride;
blur_ptr += width;
}
progress += src_rgn.w * src_rgn.h;
gimp_progress_update ((gdouble) progress / (gdouble) max_progress);
}
}
if (! preview)
{
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_update (drawable->drawable_id,
x1, y1, (x2 - x1), (y2 - y1));
}
/* free up buffers */

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

@ -317,7 +317,7 @@ spread_preview_update (GimpPreview *preview,
dest += bpp;
}
gimp_drawable_preview_draw (drawable_preview, buffer);
gimp_drawable_preview_draw_buffer (drawable_preview, buffer, width * bpp);
g_free (buffer);
g_rand_free (param.gr);

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

@ -1494,8 +1494,9 @@ strucpi (GimpDrawable *drawable,
if (preview)
{
gimp_drawable_preview_draw (preview, preview_buffer);
g_free (preview_buffer);
gimp_drawable_preview_draw_buffer (preview,
preview_buffer, width * bytes);
g_free (preview_buffer);
}
else
{

64
plug-ins/common/unsharp.c
View File

@ -94,8 +94,9 @@ static void unsharp_mask (GimpDrawable *drawable,
gdouble radius,
gdouble amount);
static gboolean unsharp_mask_dialog (GimpDrawable *drawable);
static void preview_update (GimpPreview *preview);
static gboolean unsharp_mask_dialog (GimpDrawable *drawable);
static void preview_update (GimpDrawablePreview *preview);
/* create a few globals, set default values */
static UnsharpMaskParams unsharp_params =
@ -735,26 +736,26 @@ unsharp_mask_dialog (GimpDrawable *drawable)
}
static void
preview_update (GimpPreview *preview)
preview_update (GimpDrawablePreview *preview)
{
/* drawable */
glong bytes;
gint x1, y1, x2, y2;
/* preview */
GimpDrawablePreview *drawable_preview;
guchar *render_buffer = NULL; /* Buffer to hold rendered image */
gint preview_x1; /* Upper-left X of preview */
gint preview_y1; /* Upper-left Y of preview */
gint preview_x2; /* Lower-right X of preview */
gint preview_y2; /* Lower-right Y of preview */
GimpDrawable *drawable;
guchar *render_buffer = NULL; /* Buffer to hold rendered image */
gint preview_x1; /* Upper-left X of preview */
gint preview_y1; /* Upper-left Y of preview */
gint preview_x2; /* Lower-right X of preview */
gint preview_y2; /* Lower-right Y of preview */
/* preview buffer */
gint preview_buf_width; /* Width of preview widget */
gint preview_buf_height; /* Height of preview widget */
gint preview_buf_x1; /* Upper-left X of preview */
gint preview_buf_y1; /* Upper-left Y of preview */
gint preview_buf_x2; /* Lower-right X of preview */
gint preview_buf_y2; /* Lower-right Y of preview */
gint preview_buf_width; /* Width of preview widget */
gint preview_buf_height; /* Height of preview widget */
gint preview_buf_x1; /* Upper-left X of preview */
gint preview_buf_y1; /* Upper-left Y of preview */
gint preview_buf_x2; /* Lower-right X of preview */
gint preview_buf_y2; /* Lower-right Y of preview */
GimpPixelRgn srcPR, destPR; /* Pixel regions */
gint x, y; /* Current location in image */
@ -764,18 +765,19 @@ preview_update (GimpPreview *preview)
if (!unsharp_params.update_preview)
return;
drawable_preview = GIMP_DRAWABLE_PREVIEW (preview);
drawable = gimp_drawable_preview_get_drawable (preview);
/* Get drawable info */
gimp_drawable_mask_bounds (drawable_preview->drawable->drawable_id,
&x1, &y1, &x2, &y2);
bytes = drawable_preview->drawable->bpp;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
/*
* Setup for filter...
*/
gimp_preview_get_position (preview, &preview_x1, &preview_y1);
preview_x2 = preview_x1 + preview->width;
preview_y2 = preview_y1 + preview->height;
gimp_preview_get_position (GIMP_PREVIEW (preview), &preview_x1, &preview_y1);
gimp_preview_get_size (GIMP_PREVIEW (preview), &preview_x2, &preview_y2);
preview_x2 += preview_x1;
preview_y2 += preview_y1;
/* Make buffer large enough to minimize disturbence */
preview_buf_x1 = MAX (0, preview_x1 - unsharp_params.radius);
@ -786,14 +788,14 @@ preview_update (GimpPreview *preview)
preview_buf_height = preview_buf_y2 - preview_buf_y1;
/* initialize pixel regions */
gimp_pixel_rgn_init (&srcPR, drawable_preview->drawable,
preview_buf_x1,preview_buf_y1,
gimp_pixel_rgn_init (&srcPR, drawable,
preview_buf_x1, preview_buf_y1,
preview_buf_width, preview_buf_height, FALSE, FALSE);
render_buffer = g_new (guchar,
preview_buf_width * preview_buf_height * bytes);
/* render image */
gimp_pixel_rgn_init (&destPR, drawable_preview->drawable,
gimp_pixel_rgn_init (&destPR, drawable,
preview_buf_x1,preview_buf_y1,
preview_buf_width, preview_buf_height, TRUE, TRUE);
@ -811,16 +813,14 @@ preview_update (GimpPreview *preview)
/*
* Draw the preview image on the screen...
*/
y = preview_y1 - preview_buf_y1;
x = preview_x1 - preview_buf_x1;
y = preview_y1 - preview_buf_y1;
x = preview_x1 - preview_buf_x1;
offset = (x * bytes) + (y * preview_buf_width * bytes);
gimp_preview_area_draw (GIMP_PREVIEW_AREA (preview->area),
0, 0, preview->width, preview->height,
gimp_drawable_type (drawable_preview->drawable->drawable_id),
render_buffer + offset,
preview_buf_width * bytes);
gimp_drawable_preview_draw_buffer (preview,
render_buffer + offset,
preview_buf_width * bytes);
g_free (render_buffer);
}

14
plug-ins/common/wind.c
View File

@ -391,8 +391,8 @@ render_blast (GimpDrawable *drawable,
/* update the region */
if (preview)
{
gimp_drawable_preview_draw (preview, preview_buffer);
gimp_drawable_preview_draw_buffer (preview,
preview_buffer, width * bytes);
g_free (preview_buffer);
}
else
@ -441,10 +441,12 @@ render_wind (GimpDrawable *drawable,
width = x2 - x1;
height = y2 - y1;
gimp_pixel_rgn_init (&dest_region, drawable, x1, y1, width, height, TRUE, TRUE);
gimp_pixel_rgn_init (&dest_region, drawable,
x1, y1, width, height, TRUE, TRUE);
}
gimp_pixel_rgn_init (&src_region, drawable, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&src_region, drawable,
x1, y1, width, height, FALSE, FALSE);
row_stride = width * bytes;
comp_stride = bytes * COMPARE_WIDTH;
lpi = row_stride - comp_stride;
@ -479,8 +481,8 @@ render_wind (GimpDrawable *drawable,
/* update the region */
if (preview)
{
gimp_drawable_preview_draw (preview, preview_buffer);
gimp_drawable_preview_draw_buffer (preview,
preview_buffer, width * bytes);
g_free (preview_buffer);
}
else