dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fixed a FIXME: set the sensitivity of the color tools' menu entries again.

Browse source 
2001-06-14  Michael Natterer  <mitch@gimp.org>

	* app/gdisplay.c: fixed a FIXME: set the sensitivity of the
	color tools' menu entries again.

	* libgimp/gimpcolorselector.h
	* libgimp/gimpdrawable.h
	* libgimp/gimpmenu.h: removed the usage of "id" from the public
	interface because it's a reserved keyword of Objective C.

	* libgimp/gimpdrawable.c
	* libgimp/gimptile.c

	* plug-ins/[lotsa plugins].c: changed accordingly.
This commit is contained in:
Michael Natterer 2001-06-14 20:07:38 +00:00 committed by Michael Natterer
parent 1564c5fd83
commit 593043a1b6
126 changed files with 876 additions and 848 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
ChangeLog
View file

@ -1,3 +1,18 @@
2001-06-14 Michael Natterer <mitch@gimp.org>
* app/gdisplay.c: fixed a FIXME: set the sensitivity of the
color tools' menu entries again.
* libgimp/gimpcolorselector.h
* libgimp/gimpdrawable.h
* libgimp/gimpmenu.h: removed the usage of "id" from the public
interface because it's a reserved keyword of Objective C.
* libgimp/gimpdrawable.c
* libgimp/gimptile.c
* plug-ins/[lotsa plugins].c: changed accordingly.
2001-06-14 Sven Neumann <sven@gimp.org>
* app/tools/gimpmeasuretool.c: fixed typo, closes bug #56200.

10
app/core/gimpprojection.c
View file

@ -2040,26 +2040,18 @@ gdisplay_set_menu_sensitivity (GDisplay *gdisp)
SET_SENSITIVE ("Image/Mode/RGB", (base_type != RGB));
SET_SENSITIVE ("Image/Mode/Grayscale", (base_type != GRAY));
SET_SENSITIVE ("Image/Mode/Indexed...", (base_type != INDEXED));
#ifdef __GNUC__
#warning FIXME (set_menu_sensitivity)
#endif
#if 0
SET_SENSITIVE ("Image/Histogram...", lp);
#endif
SET_SENSITIVE ("Image/Colors", lp);
#if 0
SET_SENSITIVE ("Image/Colors/Color Balance...", (base_type == RGB));
SET_SENSITIVE ("Image/Colors/Hue-Saturation...", (base_type == RGB));
SET_SENSITIVE ("Image/Colors/Brightness-Contrast...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Threshold...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Levels...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Curves...", (base_type != INDEXED));
#endif
SET_SENSITIVE ("Image/Colors/Desaturate", (base_type == RGB));
#if 0
SET_SENSITIVE ("Image/Colors/Posterize...", (base_type != INDEXED));
#endif
SET_SENSITIVE ("Image/Colors/Invert", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Auto/Equalize", (base_type != INDEXED));

10
app/display/gimpdisplay.c
View file

@ -2040,26 +2040,18 @@ gdisplay_set_menu_sensitivity (GDisplay *gdisp)
SET_SENSITIVE ("Image/Mode/RGB", (base_type != RGB));
SET_SENSITIVE ("Image/Mode/Grayscale", (base_type != GRAY));
SET_SENSITIVE ("Image/Mode/Indexed...", (base_type != INDEXED));
#ifdef __GNUC__
#warning FIXME (set_menu_sensitivity)
#endif
#if 0
SET_SENSITIVE ("Image/Histogram...", lp);
#endif
SET_SENSITIVE ("Image/Colors", lp);
#if 0
SET_SENSITIVE ("Image/Colors/Color Balance...", (base_type == RGB));
SET_SENSITIVE ("Image/Colors/Hue-Saturation...", (base_type == RGB));
SET_SENSITIVE ("Image/Colors/Brightness-Contrast...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Threshold...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Levels...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Curves...", (base_type != INDEXED));
#endif
SET_SENSITIVE ("Image/Colors/Desaturate", (base_type == RGB));
#if 0
SET_SENSITIVE ("Image/Colors/Posterize...", (base_type != INDEXED));
#endif
SET_SENSITIVE ("Image/Colors/Invert", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Auto/Equalize", (base_type != INDEXED));

10
app/gdisplay.c
View file

@ -2040,26 +2040,18 @@ gdisplay_set_menu_sensitivity (GDisplay *gdisp)
SET_SENSITIVE ("Image/Mode/RGB", (base_type != RGB));
SET_SENSITIVE ("Image/Mode/Grayscale", (base_type != GRAY));
SET_SENSITIVE ("Image/Mode/Indexed...", (base_type != INDEXED));
#ifdef __GNUC__
#warning FIXME (set_menu_sensitivity)
#endif
#if 0
SET_SENSITIVE ("Image/Histogram...", lp);
#endif
SET_SENSITIVE ("Image/Colors", lp);
#if 0
SET_SENSITIVE ("Image/Colors/Color Balance...", (base_type == RGB));
SET_SENSITIVE ("Image/Colors/Hue-Saturation...", (base_type == RGB));
SET_SENSITIVE ("Image/Colors/Brightness-Contrast...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Threshold...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Levels...", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Curves...", (base_type != INDEXED));
#endif
SET_SENSITIVE ("Image/Colors/Desaturate", (base_type == RGB));
#if 0
SET_SENSITIVE ("Image/Colors/Posterize...", (base_type != INDEXED));
#endif
SET_SENSITIVE ("Image/Colors/Invert", (base_type != INDEXED));
SET_SENSITIVE ("Image/Colors/Auto/Equalize", (base_type != INDEXED));

2
libgimp/gimpcolorselector.h
View file

@ -92,7 +92,7 @@ gimp_color_selector_register (const gchar *name,
G_MODULE_EXPORT
gboolean
gimp_color_selector_unregister (GimpColorSelectorID id,
gimp_color_selector_unregister (GimpColorSelectorID selector_id,
GimpColorSelectorFinishedCB finished_cb,
gpointer finished_data);

8
libgimp/gimpdrawable.c
View file

@ -38,7 +38,7 @@ gimp_drawable_get (gint32 drawable_ID)
GimpDrawable *drawable;
drawable = g_new (GimpDrawable, 1);
drawable->id = drawable_ID;
drawable->drawable_id = drawable_ID;
drawable->width = gimp_drawable_width (drawable_ID);
drawable->height = gimp_drawable_height (drawable_ID);
drawable->bpp = gimp_drawable_bpp (drawable_ID);
@ -100,10 +100,10 @@ gimp_drawable_delete (GimpDrawable *drawable)
{
if (drawable)
{
if (gimp_drawable_is_layer (drawable->id))
gimp_layer_delete (drawable->id);
if (gimp_drawable_is_layer (drawable->drawable_id))
gimp_layer_delete (drawable->drawable_id);
else
gimp_channel_delete (drawable->id);
gimp_channel_delete (drawable->drawable_id);
}
}

2
libgimp/gimpdrawable.h
View file

@ -34,7 +34,7 @@ extern "C" {
struct _GimpDrawable
{
gint32 id; /* drawable ID */
gint32 drawable_id; /* drawable ID */
guint width; /* width of drawble */
guint height; /* height of drawble */
guint bpp; /* bytes per pixel of drawable */

2
libgimp/gimpmenu.h
View file

@ -30,7 +30,7 @@ extern "C" {
typedef gint (* GimpConstraintFunc) (gint32 image_id,
gint32 drawable_id,
gpointer data);
typedef void (* GimpMenuCallback) (gint32 id,
typedef void (* GimpMenuCallback) (gint32 any_id,
gpointer data);

6
libgimp/gimptile.c
View file

@ -155,7 +155,7 @@ gimp_tile_get (GimpTile *tile)
GPTileData *tile_data;
WireMessage msg;
tile_req.drawable_ID = tile->drawable->id;
tile_req.drawable_ID = tile->drawable->drawable_id;
tile_req.tile_num = tile->tile_num;
tile_req.shadow = tile->shadow;
if (!gp_tile_req_write (_writechannel, &tile_req))
@ -164,7 +164,7 @@ gimp_tile_get (GimpTile *tile)
gimp_read_expect_msg(&msg,GP_TILE_DATA);
tile_data = msg.data;
if ((tile_data->drawable_ID != tile->drawable->id) ||
if ((tile_data->drawable_ID != tile->drawable->drawable_id) ||
(tile_data->tile_num != tile->tile_num) ||
(tile_data->shadow != tile->shadow) ||
(tile_data->width != tile->ewidth) ||
@ -213,7 +213,7 @@ gimp_tile_put (GimpTile *tile)
tile_info = msg.data;
tile_data.drawable_ID = tile->drawable->id;
tile_data.drawable_ID = tile->drawable->drawable_id;
tile_data.tile_num = tile->tile_num;
tile_data.shadow = tile->shadow;
tile_data.bpp = tile->bpp;

17
plug-ins/FractalExplorer/FractalExplorer.c
View file

@ -252,11 +252,12 @@ run (gchar *name,
tile_width = gimp_tile_width ();
tile_height = gimp_tile_height ();
img_width = gimp_drawable_width (drawable->id);
img_height = gimp_drawable_height (drawable->id);
img_bpp = gimp_drawable_bpp(drawable->id);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -346,7 +347,7 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is indexed or RGB color */
if (gimp_drawable_is_rgb(drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init (_("Rendering Fractal..."));
@ -399,7 +400,7 @@ explorer (GimpDrawable * drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -440,8 +441,8 @@ explorer (GimpDrawable * drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
g_free (src_row);
g_free (dest_row);

10
plug-ins/Lighting/lighting_apply.c
View file

@ -66,7 +66,7 @@ compute_image (void)
if (mapvals.create_new_image == TRUE ||
(mapvals.transparent_background == TRUE &&
! gimp_drawable_has_alpha (input_drawable->id)))
! gimp_drawable_has_alpha (input_drawable->drawable_id)))
{
/* Create a new image */
/* ================== */
@ -124,8 +124,8 @@ compute_image (void)
gimp_pixel_rgn_init (&dest_region, output_drawable,
0, 0, width, height, TRUE, TRUE);
obpp = gimp_drawable_bpp (output_drawable->id);
has_alpha = gimp_drawable_has_alpha (output_drawable->id);
obpp = gimp_drawable_bpp (output_drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (output_drawable->drawable_id);
row = g_new (guchar, obpp * width);
@ -172,8 +172,8 @@ compute_image (void)
/* ============ */
gimp_drawable_flush (output_drawable);
gimp_drawable_merge_shadow (output_drawable->id, TRUE);
gimp_drawable_update (output_drawable->id, 0, 0, width, height);
gimp_drawable_merge_shadow (output_drawable->drawable_id, TRUE);
gimp_drawable_update (output_drawable->drawable_id, 0, 0, width, height);
if (new_image_id!=-1)
{

4
plug-ins/Lighting/lighting_image.c
View file

@ -345,7 +345,7 @@ image_setup (GimpDrawable *drawable,
input_drawable = drawable;
output_drawable = drawable;
gimp_drawable_mask_bounds (drawable->id,
gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2);
width = input_drawable->width;
@ -360,7 +360,7 @@ image_setup (GimpDrawable *drawable,
/* =================== */
in_channels = 3;
if (gimp_drawable_has_alpha (input_drawable->id) == TRUE)
if (gimp_drawable_has_alpha (input_drawable->drawable_id) == TRUE)
in_channels++;
if (interactive == TRUE)

4
plug-ins/Lighting/lighting_main.c
View file

@ -214,7 +214,7 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
mapvals.drawable_id = drawable->id;
mapvals.drawable_id = drawable->drawable_id;
check_drawables ();
@ -223,7 +223,7 @@ run (gchar *name,
/* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
/* Set the tile cache size */
/* ======================= */

4
plug-ins/MapObject/mapobject_apply.c
View file

@ -316,8 +316,8 @@ compute_image (void)
/* ================= */
gimp_drawable_flush (output_drawable);
gimp_drawable_merge_shadow (output_drawable->id, TRUE);
gimp_drawable_update (output_drawable->id, 0, 0, width, height);
gimp_drawable_merge_shadow (output_drawable->drawable_id, TRUE);
gimp_drawable_update (output_drawable->drawable_id, 0, 0, width, height);
if (new_image_id != -1)
{

8
plug-ins/MapObject/mapobject_image.c
View file

@ -90,7 +90,7 @@ peek_box_image (gint image,
if (box_drawables[image]->bpp == 4)
{
if (gimp_drawable_has_alpha (box_drawables[image]->id))
if (gimp_drawable_has_alpha (box_drawables[image]->drawable_id))
color.a = (gdouble) (data[3]) / 255.0;
else
color.a = 1.0;
@ -120,7 +120,7 @@ peek_cylinder_image (gint image,
if (cylinder_drawables[image]->bpp == 4)
{
if (gimp_drawable_has_alpha (cylinder_drawables[image]->id))
if (gimp_drawable_has_alpha (cylinder_drawables[image]->drawable_id))
color.a = (gdouble) (data[3]) / 255.0;
else
color.a = 1.0;
@ -360,7 +360,7 @@ image_setup (GimpDrawable *drawable,
input_drawable = drawable;
output_drawable = drawable;
gimp_drawable_mask_bounds (drawable->id,
gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2);
width = input_drawable->width;
@ -385,7 +385,7 @@ image_setup (GimpDrawable *drawable,
/* =================== */
in_channels = 3;
if (gimp_drawable_has_alpha (input_drawable->id) == TRUE)
if (gimp_drawable_has_alpha (input_drawable->drawable_id) == TRUE)
in_channels++;
if (interactive == TRUE)

16
plug-ins/MapObject/mapobject_main.c
View file

@ -115,12 +115,12 @@ check_drawables (GimpDrawable *drawable)
for (i = 0; i < 6; i++)
{
if (mapvals.boxmap_id[i] == -1)
mapvals.boxmap_id[i] = drawable->id;
mapvals.boxmap_id[i] = drawable->drawable_id;
else if (mapvals.boxmap_id[i] != -1 &&
gimp_drawable_image_id (mapvals.boxmap_id[i]) == -1)
mapvals.boxmap_id[i] = drawable->id;
mapvals.boxmap_id[i] = drawable->drawable_id;
else if (gimp_drawable_is_gray (mapvals.boxmap_id[i]))
mapvals.boxmap_id[i] = drawable->id;
mapvals.boxmap_id[i] = drawable->drawable_id;
}
/* Check that cylindermap images are valid */
@ -129,12 +129,12 @@ check_drawables (GimpDrawable *drawable)
for (i = 0; i < 2; i++)
{
if (mapvals.cylindermap_id[i] == -1)
mapvals.cylindermap_id[i] = drawable->id;
mapvals.cylindermap_id[i] = drawable->drawable_id;
else if (mapvals.cylindermap_id[i]!=-1 &&
gimp_drawable_image_id (mapvals.cylindermap_id[i]) == -1)
mapvals.cylindermap_id[i] = drawable->id;
mapvals.cylindermap_id[i] = drawable->drawable_id;
else if (gimp_drawable_is_gray (mapvals.cylindermap_id[i]))
mapvals.cylindermap_id[i] = drawable->id;
mapvals.cylindermap_id[i] = drawable->drawable_id;
}
}
@ -322,11 +322,11 @@ run (gchar *name,
for (i = 0; i < 6; i++)
mapvals.boxmap_id[i] =
gimp_drawable_get (param[41+i].data.d_drawable)->id;
gimp_drawable_get (param[41+i].data.d_drawable)->drawable_id;
for (i = 0; i < 2; i++)
mapvals.cylindermap_id[i] =
gimp_drawable_get (param[47+i].data.d_drawable)->id;
gimp_drawable_get (param[47+i].data.d_drawable)->drawable_id;
check_drawables (drawable);
image_setup (drawable, FALSE);

17
plug-ins/common/AlienMap.c
View file

@ -1069,11 +1069,12 @@ run (char *name,
tile_width = gimp_tile_width();
tile_height = gimp_tile_height();
img_width = gimp_drawable_width(drawable->id);
img_height = gimp_drawable_height(drawable->id);
img_bpp = gimp_drawable_bpp(drawable->id);
img_width = gimp_drawable_width(drawable->drawable_id);
img_height = gimp_drawable_height(drawable->drawable_id);
img_bpp = gimp_drawable_bpp(drawable->drawable_id);
gimp_drawable_mask_bounds(drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds(drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -1157,7 +1158,7 @@ run (char *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is indexed or RGB color */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init (_("AlienMap: Transforming..."));
@ -1280,7 +1281,7 @@ alienmap (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -1321,8 +1322,8 @@ alienmap (GimpDrawable *drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (src_row);
free (dest_row);

17
plug-ins/common/AlienMap2.c
View file

@ -1064,11 +1064,12 @@ run (char *name,
tile_width = gimp_tile_width();
tile_height = gimp_tile_height();
img_width = gimp_drawable_width(drawable->id);
img_height = gimp_drawable_height(drawable->id);
img_bpp = gimp_drawable_bpp(drawable->id);
img_width = gimp_drawable_width(drawable->drawable_id);
img_height = gimp_drawable_height(drawable->drawable_id);
img_bpp = gimp_drawable_bpp(drawable->drawable_id);
gimp_drawable_mask_bounds(drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds(drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -1156,7 +1157,7 @@ run (char *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is indexed or RGB_MODEL color */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init (_("AlienMap2: Transforming..."));
@ -1277,7 +1278,7 @@ alienmap2 (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -1313,8 +1314,8 @@ alienmap2 (GimpDrawable *drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (src_row);
free (dest_row);

4
plug-ins/common/CML_explorer.c
View file

@ -861,8 +861,8 @@ CML_main_function (gint preview_p)
{
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_detach (drawable);
}

32
plug-ins/common/animationplay.c
View file

@ -977,11 +977,11 @@ render_frame (gint32 whichframe)
/* Image has been closed/etc since we got the layer list? */
/* FIXME - How do we tell if a gimp_drawable_get() fails? */
if (gimp_drawable_width(drawable->id)==0)
if (gimp_drawable_width(drawable->drawable_id)==0)
window_close_callback (NULL, NULL);
if (((dispose==DISPOSE_REPLACE)||(whichframe==0)) &&
gimp_drawable_has_alpha(drawable->id))
gimp_drawable_has_alpha(drawable->drawable_id))
{
total_alpha_preview(preview_data);
}
@ -992,19 +992,19 @@ render_frame (gint32 whichframe)
if ((rawwidth*rawheight*rawbpp)
!=
((gimp_drawable_width(drawable->id)*
gimp_drawable_height(drawable->id)*
gimp_drawable_bpp(drawable->id))))
((gimp_drawable_width(drawable->drawable_id)*
gimp_drawable_height(drawable->drawable_id)*
gimp_drawable_bpp(drawable->drawable_id))))
{
if (rawframe != NULL) g_free(rawframe);
rawframe = g_malloc((gimp_drawable_width(drawable->id)) *
(gimp_drawable_height(drawable->id)) *
(gimp_drawable_bpp(drawable->id)));
rawframe = g_malloc((gimp_drawable_width(drawable->drawable_id)) *
(gimp_drawable_height(drawable->drawable_id)) *
(gimp_drawable_bpp(drawable->drawable_id)));
}
rawwidth = gimp_drawable_width(drawable->id);
rawheight = gimp_drawable_height(drawable->id);
rawbpp = gimp_drawable_bpp(drawable->id);
rawwidth = gimp_drawable_width(drawable->drawable_id);
rawheight = gimp_drawable_height(drawable->drawable_id);
rawbpp = gimp_drawable_bpp(drawable->drawable_id);
/* Initialise and fetch the whole raw new frame */
@ -1021,7 +1021,7 @@ render_frame (gint32 whichframe)
drawable->width, drawable->height);
/* gimp_pixel_rgns_register (1, &pixel_rgn);*/
gimp_drawable_offsets (drawable->id,
gimp_drawable_offsets (drawable->drawable_id,
&rawx,
&rawy);
@ -1040,7 +1040,7 @@ render_frame (gint32 whichframe)
/* --- which this frame is the same size and position --- */
/* --- as the preview buffer itself --- */
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
destptr = preview_data;
srcptr = rawframe;
@ -1138,7 +1138,7 @@ render_frame (gint32 whichframe)
/* --- this frame is bigger/smaller than the preview --- */
/* --- buffer, and/or offset within it. --- */
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
srcptr = rawframe;
@ -1313,7 +1313,7 @@ render_frame (gint32 whichframe)
/* --- which this frame is the same size and position --- */
/* --- as the preview buffer itself --- */
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
destptr = preview_data;
srcptr = rawframe;
@ -1417,7 +1417,7 @@ render_frame (gint32 whichframe)
/* --- this frame is bigger/smaller than the preview --- */
/* --- buffer, and/or offset within it. --- */
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
srcptr = rawframe;

12
plug-ins/common/animoptimize.c
View file

@ -328,20 +328,20 @@ compose_row(int frame_num,
total_alpha (dest, dest_width, pixelstep);
}
gimp_drawable_offsets (drawable->id,
gimp_drawable_offsets (drawable->drawable_id,
&rawx,
&rawy);
rawheight = gimp_drawable_height (drawable->id);
rawheight = gimp_drawable_height (drawable->drawable_id);
/* this frame has nothing to give us for this row; return */
if (row_num >= rawheight + rawy ||
row_num < rawy)
return;
rawbpp = gimp_drawable_bpp (drawable->id);
rawwidth = gimp_drawable_width (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->id);
rawbpp = gimp_drawable_bpp (drawable->drawable_id);
rawwidth = gimp_drawable_width (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (line_buf)
{
@ -685,7 +685,7 @@ g_warning("stat fun");
/* Image has been closed/etc since we got the layer list? */
/* FIXME - How do we tell if a gimp_drawable_get() fails? */
if (gimp_drawable_width (drawable->id) == 0)
if (gimp_drawable_width (drawable->drawable_id) == 0)
{
gimp_quit ();
}

10
plug-ins/common/apply_lens.c
View file

@ -246,7 +246,7 @@ find_projected_pos (gfloat a,
static void
drawlens (GimpDrawable *drawable)
{
GimpImageType drawtype = gimp_drawable_type (drawable->id);
GimpImageType drawtype = gimp_drawable_type (drawable->drawable_id);
GimpPixelRgn srcPR, destPR;
gint width, height;
gint bytes;
@ -265,7 +265,7 @@ drawlens (GimpDrawable *drawable)
gimp_rgb_get_uchar (&background,
&bgr_red, &bgr_green, &bgr_blue);
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
regionwidth = x2 - x1;
a = regionwidth / 2;
regionheight = y2 - y1;
@ -356,8 +356,8 @@ drawlens (GimpDrawable *drawable)
g_free (dest);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static void
@ -384,7 +384,7 @@ lens_dialog (GimpDrawable *drawable)
GSList *group = NULL;
GimpImageType drawtype;
drawtype = gimp_drawable_type (drawable->id);
drawtype = gimp_drawable_type (drawable->drawable_id);
gimp_ui_init ("apply_lens", FALSE);

6
plug-ins/common/autocrop.c
View file

@ -111,9 +111,9 @@ run (gchar *name,
image_id = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id) ||
gimp_drawable_is_indexed (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id) ||
gimp_drawable_is_indexed (drawable->drawable_id))
{
if (interactive)
gimp_progress_init (_("Cropping..."));

14
plug-ins/common/autostretch_hsv.c
View file

@ -118,8 +118,8 @@ run (gchar *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Auto-Stretching HSV..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -128,7 +128,7 @@ run (gchar *name,
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_is_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->drawable_id))
{
indexed_autostretch_hsv (image_ID);
@ -206,8 +206,8 @@ autostretch_hsv (GimpDrawable *drawable)
gpointer pr;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
/* Initialize progress */
@ -298,6 +298,6 @@ autostretch_hsv (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}

18
plug-ins/common/blinds.c
View file

@ -220,7 +220,7 @@ run (gchar *name,
blindsdrawable = drawable =
gimp_drawable_get (param[2].data.d_drawable);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -272,8 +272,8 @@ run (gchar *name,
break;
}
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("Adding Blinds..."));
@ -498,16 +498,16 @@ cache_preview (void)
src_rows = g_new (guchar, sel_width * 4);
p = bint.pv_cache = g_new (guchar, preview_width * preview_height * 4);
bint.img_bpp = gimp_drawable_bpp (blindsdrawable->id);
bint.img_bpp = gimp_drawable_bpp (blindsdrawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (blindsdrawable->id);
has_alpha = gimp_drawable_has_alpha (blindsdrawable->drawable_id);
if (bint.img_bpp < 3)
{
bint.img_bpp = 3 + has_alpha;
}
switch (gimp_drawable_type (blindsdrawable->id))
switch (gimp_drawable_type (blindsdrawable->drawable_id))
{
case GIMP_GRAYA_IMAGE:
case GIMP_GRAY_IMAGE:
@ -654,7 +654,7 @@ blinds_get_bg (guchar *bg)
gimp_palette_get_background (&background);
switch (gimp_drawable_type (blindsdrawable->id))
switch (gimp_drawable_type (blindsdrawable->drawable_id))
{
case GIMP_RGB_IMAGE :
gimp_rgb_get_uchar (&background, &bg[0], &bg[1], &bg[2]);
@ -999,8 +999,8 @@ apply_blinds (void)
g_free (des_rows);
gimp_drawable_flush (blindsdrawable);
gimp_drawable_merge_shadow (blindsdrawable->id, TRUE);
gimp_drawable_update (blindsdrawable->id,
gimp_drawable_merge_shadow (blindsdrawable->drawable_id, TRUE);
gimp_drawable_update (blindsdrawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}

12
plug-ins/common/blur.c
View file

@ -255,8 +255,8 @@ run (gchar *name,
/*
* Make sure the drawable type is appropriate.
*/
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
switch (run_mode)
{
@ -438,7 +438,7 @@ blur (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
/*
* Get the size of the input image. (This will/must be the same
* as the size of the output image. Also get alpha info.
@ -446,7 +446,7 @@ blur (GimpDrawable *drawable)
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
/*
* allocate row buffers
*/
@ -579,8 +579,8 @@ blur (GimpDrawable *drawable)
* update the blurred region
*/
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow(drawable->drawable_id, TRUE);
gimp_drawable_update(drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
/*
* clean up after ourselves.
*/

4
plug-ins/common/borderaverage.c
View file

@ -160,7 +160,7 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is RGB color */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init ( _("Border Average..."));
borderaverage (drawable, &result_color);
@ -235,7 +235,7 @@ borderaverage (GimpDrawable *drawable,
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.

37
plug-ins/common/bumpmap.c
View file

@ -415,12 +415,13 @@ run (gchar *name,
/* Get drawable information */
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
img_bpp = gimp_drawable_bpp (drawable->id);
img_has_alpha = gimp_drawable_has_alpha (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
/* See how we will run */
switch (run_mode)
@ -472,8 +473,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
if ((gimp_drawable_is_rgb(drawable->id) ||
gimp_drawable_is_gray(drawable->id)))
if ((gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id)))
{
/* Run! */
bumpmap ();
@ -527,10 +528,10 @@ bumpmap (void)
return;
/* Get image information */
bm_width = gimp_drawable_width (bm_drawable->id);
bm_height = gimp_drawable_height (bm_drawable->id);
bm_bpp = gimp_drawable_bpp (bm_drawable->id);
bm_has_alpha = gimp_drawable_has_alpha (bm_drawable->id);
bm_width = gimp_drawable_width (bm_drawable->drawable_id);
bm_height = gimp_drawable_height (bm_drawable->drawable_id);
bm_bpp = gimp_drawable_bpp (bm_drawable->drawable_id);
bm_has_alpha = gimp_drawable_has_alpha (bm_drawable->drawable_id);
/* Set the tile cache size */
/* Compute number of tiles needed for one row of the drawable */
@ -623,8 +624,8 @@ bumpmap (void)
gimp_drawable_detach (bm_drawable);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, sel_x1, sel_y1, sel_width, sel_height);
}
static void
@ -1306,15 +1307,17 @@ dialog_new_bumpmap (gboolean init_offsets)
return;
/* Get sizes */
bmint.bm_width = gimp_drawable_width (bmint.bm_drawable->id);
bmint.bm_height = gimp_drawable_height (bmint.bm_drawable->id);
bmint.bm_bpp = gimp_drawable_bpp (bmint.bm_drawable->id);
bmint.bm_has_alpha = gimp_drawable_has_alpha (bmint.bm_drawable->id);
bmint.bm_width = gimp_drawable_width (bmint.bm_drawable->drawable_id);
bmint.bm_height = gimp_drawable_height (bmint.bm_drawable->drawable_id);
bmint.bm_bpp = gimp_drawable_bpp (bmint.bm_drawable->drawable_id);
bmint.bm_has_alpha = gimp_drawable_has_alpha (bmint.bm_drawable->drawable_id);
if (init_offsets)
{
gimp_drawable_offsets (bmint.bm_drawable->id, &bump_offset_x, &bump_offset_y);
gimp_drawable_offsets (drawable->id, &draw_offset_x, &draw_offset_y);
gimp_drawable_offsets (bmint.bm_drawable->drawable_id,
&bump_offset_x, &bump_offset_y);
gimp_drawable_offsets (drawable->drawable_id,
&draw_offset_x, &draw_offset_y);
bmvals.xofs = draw_offset_x - bump_offset_x;
bmvals.yofs = draw_offset_y - bump_offset_y;

14
plug-ins/common/c_astretch.c
View file

@ -115,8 +115,8 @@ run (gchar *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Auto-Stretching Contrast..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -125,7 +125,7 @@ run (gchar *name,
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_is_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->drawable_id))
{
indexed_c_astretch (image_ID);
@ -203,8 +203,8 @@ c_astretch (GimpDrawable *drawable)
gpointer pr;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
/* Initialize progress */
@ -307,6 +307,6 @@ c_astretch (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}

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

@ -159,8 +159,8 @@ run (gchar *name,
break;
}
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Adding Checkerboard..."));
@ -199,7 +199,7 @@ check (GimpDrawable *drawable)
gint bp;
gpointer pr;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init (&dest_rgn, drawable,
x1, y1, (x2 - x1), (y2 - y1), TRUE, TRUE);
@ -211,7 +211,7 @@ check (GimpDrawable *drawable)
gimp_palette_get_foreground (&foreground);
gimp_palette_get_background (&background);
switch (gimp_drawable_type (drawable->id))
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGBA_IMAGE:
fg[3] = 255;
@ -282,8 +282,8 @@ check (GimpDrawable *drawable)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static gint

14
plug-ins/common/color_enhance.c
View file

@ -118,8 +118,8 @@ run (gchar *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Color Enhance..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -128,7 +128,7 @@ run (gchar *name,
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_is_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->drawable_id))
{
indexed_Color_Enhance (image_ID);
@ -239,8 +239,8 @@ Color_Enhance (GimpDrawable *drawable)
gpointer pr;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
/* Initialize progress */
@ -365,6 +365,6 @@ Color_Enhance (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}

10
plug-ins/common/colorify.c
View file

@ -169,7 +169,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -238,7 +239,7 @@ colorify (GimpDrawable *drawable)
final_blue_lookup[i] = i * cvals.color.b;
}
bpp = gimp_drawable_bpp (drawable->id);
bpp = gimp_drawable_bpp (drawable->drawable_id);
row = g_new (guchar, sel_width * bpp);
gimp_tile_cache_ntiles (2 * (sel_width / gimp_tile_width()) + 1);
@ -261,8 +262,9 @@ colorify (GimpDrawable *drawable)
g_free (row);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}
static void

14
plug-ins/common/colortoalpha.c
View file

@ -186,12 +186,12 @@ run (gchar *name,
{
gimp_undo_push_group_start (image_ID);
/* Add alpha if not present */
gimp_layer_add_alpha (drawable->id);
drawable = gimp_drawable_get (drawable->id);
gimp_layer_add_alpha (drawable->drawable_id);
drawable = gimp_drawable_get (drawable->drawable_id);
/* Make sure that the drawable is RGB color */
if (gimp_drawable_is_rgb (drawable->id) &&
gimp_drawable_is_layer (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) &&
gimp_drawable_is_layer (drawable->drawable_id))
{
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_progress_init (_("Removing color..."));
@ -367,7 +367,7 @@ toalpha (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
total_area = (x2 - x1) * (y2 - y1);
area_so_far = 0;
@ -398,8 +398,8 @@ toalpha (GimpDrawable *drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static gboolean

20
plug-ins/common/convmatrix.c
View file

@ -286,8 +286,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb(drawable->id) ||
gimp_drawable_is_gray(drawable->id))
if (gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id))
{
gimp_progress_init (_("Applying convolution"));
gimp_tile_cache_ntiles (2 * (drawable->width /
@ -517,7 +517,7 @@ doit (void)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &sx1, &sy1, &sx2, &sy2);
gimp_drawable_mask_bounds (drawable->drawable_id, &sx1, &sy1, &sx2, &sy2);
w = sx2 - sx1;
h = sy2 - sy1;
@ -528,13 +528,13 @@ doit (void)
height = drawable->height;
bytes = drawable->bpp;
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
for (i = 0; i <3; i++)
chanmask[i] = my_config.channels[i + 1];
else /* Grayscale */
chanmask[0] = my_config.channels[0];
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
chanmask[bytes - 1] = my_config.channels[4];
for (i = 0; i < 5; i++)
@ -595,8 +595,8 @@ doit (void)
/* update the timred region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sx1, sy1, sx2 - sx1, sy2 - sy1);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, sx1, sy1, sx2 - sx1, sy2 - sy1);
}
/***************************************************
@ -753,13 +753,13 @@ check_config (void)
if (my_config.channels[i] < 0)
my_config.channels[i] = 0;
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
my_config.channels[0] = -1;
else if (gimp_drawable_is_gray (drawable->id))
else if (gimp_drawable_is_gray (drawable->drawable_id))
for (i = 1; i < 4; i++)
my_config.channels[i] = -1;
if (!gimp_drawable_has_alpha (drawable->id))
if (!gimp_drawable_has_alpha (drawable->drawable_id))
{
my_config.channels[4] = -1;
my_config.alpha_alg = -1;

18
plug-ins/common/cubism.c
View file

@ -229,8 +229,8 @@ run (gchar *name,
/* Render the cubism effect */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (active_drawable->id) ||
gimp_drawable_is_gray (active_drawable->id)))
(gimp_drawable_is_rgb (active_drawable->drawable_id) ||
gimp_drawable_is_gray (active_drawable->drawable_id)))
{
/* set cache size */
gimp_tile_cache_ntiles (SQR (4 * cvals.tile_size * cvals.tile_saturation) / SQR (gimp_tile_width ()));
@ -263,7 +263,7 @@ cubism (GimpDrawable *drawable)
gint x1, y1, x2, y2;
/* find the drawable mask bounds */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* determine the background color */
if (cvals.bg_color == BLACK)
@ -273,7 +273,7 @@ cubism (GimpDrawable *drawable)
else
{
gimp_palette_get_background (&background);
switch (gimp_drawable_type (drawable->id))
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGBA_IMAGE:
bg_col[3] = 0;
@ -298,8 +298,8 @@ cubism (GimpDrawable *drawable)
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static gint
@ -412,9 +412,9 @@ render_cubism (GimpDrawable *drawable)
gint *random_indices;
gpointer pr;
has_alpha = gimp_drawable_has_alpha (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
bytes = drawable->bpp;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
img_area = (x2 - x1) * (y2 - y1);
tile_area = SQR (cvals.tile_size);
@ -558,7 +558,7 @@ fill_poly_color (Polygon *poly,
else
one_over_dist = 0.0;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
polygon_extents (poly, &dmin_x, &dmin_y, &dmax_x, &dmax_y);

62
plug-ins/common/curve_bend.c
View file

@ -1319,7 +1319,7 @@ bender_new_dialog (GimpDrawable *drawable)
cd->rotation = 0.0; /* vertical bend */
cd->drawable = drawable;
cd->color = gimp_drawable_is_rgb (cd->drawable->id);
cd->color = gimp_drawable_is_rgb (cd->drawable->drawable_id);
cd->run = FALSE;
cd->bval_from = NULL;
@ -2735,7 +2735,7 @@ p_end_gdrw (t_GDRW *gdrw)
{
if(gb_debug)
printf ("\np_end_gdrw: drawable %x ID: %d\n",
(int)gdrw->drawable, (int)gdrw->drawable->id);
(int)gdrw->drawable, (int)gdrw->drawable->drawable_id);
if(gdrw->tile)
{
@ -2760,7 +2760,7 @@ p_init_gdrw (t_GDRW *gdrw,
gint32 l_sel_channel_id;
gint l_offsetx, l_offsety;
if(gb_debug) printf("\np_init_gdrw: drawable %x ID: %d\n", (int)drawable, (int)drawable->id);
if(gb_debug) printf("\np_init_gdrw: drawable %x ID: %d\n", (int)drawable, (int)drawable->drawable_id);
gdrw->drawable = drawable;
gdrw->tile = NULL;
@ -2771,9 +2771,9 @@ p_init_gdrw (t_GDRW *gdrw,
gdrw->tile_swapcount = 0;
gdrw->seldeltax = 0;
gdrw->seldeltay = 0;
gimp_drawable_offsets (drawable->id, &l_offsetx, &l_offsety); /* get offsets within the image */
gimp_drawable_offsets (drawable->drawable_id, &l_offsetx, &l_offsety); /* get offsets within the image */
gimp_drawable_mask_bounds (drawable->id, &gdrw->x1, &gdrw->y1, &gdrw->x2, &gdrw->y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &gdrw->x1, &gdrw->y1, &gdrw->x2, &gdrw->y2);
/*
* gimp_pixel_rgn_init (&gdrw->pr, drawable,
@ -2783,7 +2783,7 @@ p_init_gdrw (t_GDRW *gdrw,
gdrw->bpp = drawable->bpp;
if (gimp_drawable_has_alpha(drawable->id))
if (gimp_drawable_has_alpha(drawable->drawable_id))
{
/* index of the alpha channelbyte {1|3} */
gdrw->index_alpha = gdrw->bpp -1;
@ -2795,7 +2795,7 @@ p_init_gdrw (t_GDRW *gdrw,
if(gb_debug) printf("\np_init_gdrw: bpp %d index_alpha: %d\n", (int)gdrw->bpp, (int)gdrw->index_alpha);
l_image_id = gimp_layer_get_image_id(drawable->id);
l_image_id = gimp_layer_get_image_id(drawable->drawable_id);
/* check and see if we have a selection mask */
l_sel_channel_id = gimp_image_get_selection(l_image_id);
@ -3041,10 +3041,10 @@ p_create_pv_image (GimpDrawable *src_drawable,
t_GDRW l_dst_gdrw;
l_new_image_id = gimp_image_new(PREVIEW_SIZE_X, PREVIEW_SIZE_Y,
gimp_image_base_type(gimp_layer_get_image_id(src_drawable->id)));
gimp_image_base_type(gimp_layer_get_image_id(src_drawable->drawable_id)));
gimp_image_undo_disable (l_new_image_id);
l_type = gimp_drawable_type(src_drawable->id);
l_type = gimp_drawable_type(src_drawable->drawable_id);
if(src_drawable->height > src_drawable->width)
{
l_new_height = PV_IMG_HEIGHT;
@ -3113,28 +3113,28 @@ p_add_layer (gint width,
gint stack_position;
image_id = gimp_layer_get_image_id(src_drawable->id);
image_id = gimp_layer_get_image_id(src_drawable->drawable_id);
stack_position = 0; /* TODO: should be same as src_layer */
/* copy type, name, opacity and mode from src_drawable */
l_type = gimp_drawable_type(src_drawable->id);
l_visible = gimp_layer_get_visible(src_drawable->id);
l_type = gimp_drawable_type(src_drawable->drawable_id);
l_visible = gimp_layer_get_visible(src_drawable->drawable_id);
if (TRUE != TRUE)
{
l_name = gimp_layer_get_name(src_drawable->id);
l_name = gimp_layer_get_name(src_drawable->drawable_id);
}
else
{
l_name2 = gimp_layer_get_name(src_drawable->id);
l_name2 = gimp_layer_get_name(src_drawable->drawable_id);
l_name = g_malloc(strlen(l_name2) + 10);
if(l_name == NULL)
return (NULL);
sprintf(l_name, "%s_b", l_name2);
g_free(l_name2);
}
l_mode = gimp_layer_get_mode(src_drawable->id);
l_opacity = gimp_layer_get_opacity(src_drawable->id); /* full opacity */
l_mode = gimp_layer_get_mode(src_drawable->drawable_id);
l_opacity = gimp_layer_get_opacity(src_drawable->drawable_id); /* full opacity */
l_new_layer_id = gimp_layer_new(image_id, l_name,
width, height,
@ -3437,7 +3437,7 @@ p_vertical_bend (BenderDialog *cd,
if(l_alias_dir != 0)
{
l_alpha_lo = 20;
if (gimp_drawable_has_alpha(src_gdrw->drawable->id))
if (gimp_drawable_has_alpha(src_gdrw->drawable->drawable_id))
{
l_alpha_lo = MIN(20, mixcolor[src_gdrw->index_alpha]);
}
@ -3565,14 +3565,14 @@ p_main_bend (BenderDialog *cd,
gint32 xmax, ymax;
l_interpolation = cd->smoothing;
l_image_id = gimp_layer_get_image_id(original_drawable->id);
gimp_drawable_offsets(original_drawable->id, &l_offset_x, &l_offset_y);
l_image_id = gimp_layer_get_image_id(original_drawable->drawable_id);
gimp_drawable_offsets(original_drawable->drawable_id, &l_offset_x, &l_offset_y);
l_center_x = l_offset_x + (gimp_drawable_width (original_drawable->id) / 2 );
l_center_y = l_offset_y + (gimp_drawable_height (original_drawable->id) / 2 );
l_center_x = l_offset_x + (gimp_drawable_width (original_drawable->drawable_id) / 2 );
l_center_y = l_offset_y + (gimp_drawable_height (original_drawable->drawable_id) / 2 );
/* always copy original_drawable to a tmp src_layer */
l_tmp_layer_id = gimp_layer_copy(original_drawable->id);
l_tmp_layer_id = gimp_layer_copy(original_drawable->drawable_id);
/* set layer invisible and dummyname and
* add at top of the image while working
* (for the case of undo the gimp must know,
@ -3612,17 +3612,17 @@ p_main_bend (BenderDialog *cd,
else
{
/* work on the original */
gimp_layer_resize(original_drawable->id,
gimp_layer_resize(original_drawable->drawable_id,
src_drawable->width,
l_dst_height,
l_offset_x, l_offset_y);
if(gb_debug) printf("p_main_bend: DONE layer resize\n");
if(!gimp_drawable_has_alpha(original_drawable->id))
if(!gimp_drawable_has_alpha(original_drawable->drawable_id))
{
/* always add alpha channel */
gimp_layer_add_alpha(original_drawable->id);
gimp_layer_add_alpha(original_drawable->drawable_id);
}
dst_drawable = gimp_drawable_get (original_drawable->id);
dst_drawable = gimp_drawable_get (original_drawable->drawable_id);
}
p_clear_drawable(dst_drawable);
@ -3638,7 +3638,7 @@ p_main_bend (BenderDialog *cd,
if(cd->rotation != 0.0)
{
p_gimp_rotate(l_image_id, dst_drawable->id, l_interpolation, (gdouble)(360.0 - cd->rotation));
p_gimp_rotate(l_image_id, dst_drawable->drawable_id, l_interpolation, (gdouble)(360.0 - cd->rotation));
/* TODO: here we should crop dst_drawable to cut off full transparent borderpixels */
@ -3647,9 +3647,9 @@ p_main_bend (BenderDialog *cd,
/* set offsets of the resulting new layer
*(center == center of original_drawable)
*/
l_offset_x = l_center_x - (gimp_drawable_width (dst_drawable->id) / 2 );
l_offset_y = l_center_y - (gimp_drawable_height (dst_drawable->id) / 2 );
gimp_layer_set_offsets (dst_drawable->id, l_offset_x, l_offset_y);
l_offset_x = l_center_x - (gimp_drawable_width (dst_drawable->drawable_id) / 2 );
l_offset_y = l_center_y - (gimp_drawable_height (dst_drawable->drawable_id) / 2 );
gimp_layer_set_offsets (dst_drawable->drawable_id, l_offset_x, l_offset_y);
/* delete the temp layer */
gimp_image_remove_layer(l_image_id, l_tmp_layer_id);
@ -3659,5 +3659,5 @@ p_main_bend (BenderDialog *cd,
if(gb_debug) printf("p_main_bend: DONE bend main\n");
return dst_drawable->id;
return dst_drawable->drawable_id;
} /* end p_main_bend */

10
plug-ins/common/deinterlace.c
View file

@ -142,8 +142,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Deinterlace..."));
gimp_tile_cache_ntiles (2 * (drawable->width /
@ -190,7 +190,7 @@ deinterlace (GimpDrawable *drawable)
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -235,8 +235,8 @@ deinterlace (GimpDrawable *drawable)
/* update the deinterlaced region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
g_free (lower);
g_free (upper);

18
plug-ins/common/depthmerge.c
View file

@ -309,12 +309,12 @@ DepthMerge_construct (DepthMerge *dm)
dm->interface = NULL;
dm->resultDrawable = gimp_drawable_get (dm->params.result);
gimp_drawable_mask_bounds (dm->resultDrawable->id,
gimp_drawable_mask_bounds (dm->resultDrawable->drawable_id,
&(dm->selectionX0), &(dm->selectionY0),
&(dm->selectionX1), &(dm->selectionY1));
dm->selectionWidth = dm->selectionX1 - dm->selectionX0;
dm->selectionHeight = dm->selectionY1 - dm->selectionY0;
dm->resultHasAlpha = gimp_drawable_has_alpha (dm->resultDrawable->id);
dm->resultHasAlpha = gimp_drawable_has_alpha (dm->resultDrawable->drawable_id);
dm->source1Drawable =
(dm->params.source1 == -1) ? NULL : gimp_drawable_get (dm->params.source1);
@ -395,7 +395,7 @@ DepthMerge_execute (DepthMerge *dm)
if (dm->source1Drawable != NULL)
{
source1HasAlpha = gimp_drawable_has_alpha(dm->source1Drawable->id);
source1HasAlpha = gimp_drawable_has_alpha(dm->source1Drawable->drawable_id);
gimp_pixel_rgn_init(&source1Rgn, dm->source1Drawable,
dm->selectionX0, dm->selectionY0,
dm->selectionWidth, dm->selectionHeight,
@ -411,7 +411,7 @@ DepthMerge_execute (DepthMerge *dm)
}
if (dm->source2Drawable != NULL)
{
source2HasAlpha = gimp_drawable_has_alpha(dm->source2Drawable->id);
source2HasAlpha = gimp_drawable_has_alpha(dm->source2Drawable->drawable_id);
gimp_pixel_rgn_init(&source2Rgn, dm->source2Drawable,
dm->selectionX0, dm->selectionY0,
dm->selectionWidth, dm->selectionHeight,
@ -427,7 +427,7 @@ DepthMerge_execute (DepthMerge *dm)
}
if (dm->depthMap1Drawable != NULL)
{
depthMap1HasAlpha = gimp_drawable_has_alpha(dm->depthMap1Drawable->id);
depthMap1HasAlpha = gimp_drawable_has_alpha(dm->depthMap1Drawable->drawable_id);
gimp_pixel_rgn_init(&depthMap1Rgn, dm->depthMap1Drawable,
dm->selectionX0, dm->selectionY0,
dm->selectionWidth, dm->selectionHeight,
@ -440,7 +440,7 @@ DepthMerge_execute (DepthMerge *dm)
}
if (dm->depthMap2Drawable != NULL)
{
depthMap2HasAlpha = gimp_drawable_has_alpha(dm->depthMap2Drawable->id);
depthMap2HasAlpha = gimp_drawable_has_alpha(dm->depthMap2Drawable->drawable_id);
gimp_pixel_rgn_init(&depthMap2Rgn, dm->depthMap2Drawable,
dm->selectionX0, dm->selectionY0,
dm->selectionWidth, dm->selectionHeight,
@ -522,8 +522,8 @@ DepthMerge_execute (DepthMerge *dm)
g_free (tempRow);
gimp_drawable_flush (dm->resultDrawable);
gimp_drawable_merge_shadow (dm->resultDrawable->id, TRUE);
gimp_drawable_update (dm->resultDrawable->id,
gimp_drawable_merge_shadow (dm->resultDrawable->drawable_id, TRUE);
gimp_drawable_update (dm->resultDrawable->drawable_id,
dm->selectionX0, dm->selectionY0,
dm->selectionWidth, dm->selectionHeight);
return TRUE;
@ -1123,7 +1123,7 @@ util_fillReducedBuffer (guchar *dest,
sourceRowOffsetLookup = (int *)g_malloc(destWidth * sizeof(int));
gimp_pixel_rgn_init(&rgn, sourceDrawable, x0, y0, sourceWidth, sourceHeight,
FALSE, FALSE);
sourceHasAlpha = gimp_drawable_has_alpha(sourceDrawable->id);
sourceHasAlpha = gimp_drawable_has_alpha(sourceDrawable->drawable_id);
for (x = 0; x < destWidth; x++)
sourceRowOffsetLookup[x] = (x*(sourceWidth-1)/(destWidth-1))*sourceBpp;

14
plug-ins/common/despeckle.c
View file

@ -223,11 +223,12 @@ run (gchar *name, /* I - Name of filter program. */
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
img_bpp = gimp_drawable_bpp (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
/*
* See how we will run
@ -309,8 +310,8 @@ run (gchar *name, /* I - Name of filter program. */
if (status == GIMP_PDB_SUCCESS)
{
if ((gimp_drawable_is_rgb(drawable->id) ||
gimp_drawable_is_gray(drawable->id)))
if ((gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id)))
{
/*
* Set the tile cache size...
@ -584,8 +585,9 @@ despeckle (void)
*/
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}

14
plug-ins/common/destripe.c
View file

@ -183,9 +183,10 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
img_bpp = gimp_drawable_bpp (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
/*
* See how we will run
@ -234,8 +235,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
if ((gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id)))
if ((gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
/*
* Set the tile cache size...
@ -509,8 +510,9 @@ destripe_rect (gint sel_x1,
else
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}
g_free (hist);
g_free (corr);

10
plug-ins/common/diffraction.c
View file

@ -269,7 +269,7 @@ run (gchar *name,
active_drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Create the diffraction pattern */
if ((status == GIMP_PDB_SUCCESS) && gimp_drawable_is_rgb(active_drawable->id))
if ((status == GIMP_PDB_SUCCESS) && gimp_drawable_is_rgb(active_drawable->drawable_id))
{
/* Set the tile cache size */
gimp_tile_cache_ntiles ((active_drawable->width + gimp_tile_width() - 1) /
@ -314,12 +314,12 @@ diffraction (GimpDrawable *drawable)
/* Get the mask bounds and image size */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = x2 - x1;
height = y2 - y1;
has_alpha = gimp_drawable_has_alpha (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
/* Initialize pixel regions */
@ -379,8 +379,8 @@ diffraction (GimpDrawable *drawable)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, width, height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
}
static void

14
plug-ins/common/displace.c
View file

@ -492,7 +492,7 @@ displace (GimpDrawable *drawable)
myrow = NULL;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
@ -512,9 +512,9 @@ displace (GimpDrawable *drawable)
map_x = gimp_drawable_get (dvals.displace_map_x);
gimp_pixel_rgn_init (&map_x_rgn, map_x,
x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
if (gimp_drawable_has_alpha(map_x->id))
if (gimp_drawable_has_alpha(map_x->drawable_id))
xm_alpha = 1;
xm_bytes = gimp_drawable_bpp(map_x->id);
xm_bytes = gimp_drawable_bpp(map_x->drawable_id);
}
else
map_x = NULL;
@ -524,9 +524,9 @@ displace (GimpDrawable *drawable)
map_y = gimp_drawable_get (dvals.displace_map_y);
gimp_pixel_rgn_init (&map_y_rgn, map_y,
x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
if (gimp_drawable_has_alpha(map_y->id))
if (gimp_drawable_has_alpha(map_y->drawable_id))
ym_alpha = 1;
ym_bytes = gimp_drawable_bpp(map_y->id);
ym_bytes = gimp_drawable_bpp(map_y->drawable_id);
}
else
map_y = NULL;
@ -638,8 +638,8 @@ displace (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
} /* displace */

24
plug-ins/common/edge.c
View file

@ -230,8 +230,8 @@ run (gchar *name,
}
/* make sure the drawable exist and is not indexed */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Edge Detection..."));
@ -273,15 +273,15 @@ init_tile_buf (TileBuf *buf,
buf->tile = NULL;
buf->col = 0;
buf->row = 0;
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
buf->bpp = 3;
else
buf->bpp = 1;
buf->tile_width = gimp_tile_width();
buf->tile_height = gimp_tile_height();
buf->drawable = drawable;
buf->drawable_width = gimp_drawable_width(drawable->id);
buf->drawable_height = gimp_drawable_height(drawable->id);
buf->drawable_width = gimp_drawable_width(drawable->drawable_id);
buf->drawable_height = gimp_drawable_height(drawable->drawable_id);
}
static void
@ -489,12 +489,12 @@ edge (GimpDrawable *drawable)
init_tile_buf (&buf, drawable);
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = gimp_drawable_width (drawable->id);
height = gimp_drawable_height (drawable->id);
alpha = gimp_drawable_bpp (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->id);
width = gimp_drawable_width (drawable->drawable_id);
height = gimp_drawable_height (drawable->drawable_id);
alpha = gimp_drawable_bpp (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (has_alpha)
alpha--;
@ -608,8 +608,8 @@ edge (GimpDrawable *drawable)
end_tile_buf (&buf);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
/*******************************************************/

4
plug-ins/common/emboss.c
View file

@ -445,8 +445,8 @@ pluginCore (struct piArgs *argp)
g_free (dstbuf);
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->id, TRUE);
gimp_drawable_update (drw->id, x1, y1, width, height);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, x1, y1, width, height);
gimp_displays_flush ();
return 0;

16
plug-ins/common/engrave.c
View file

@ -314,9 +314,9 @@ engrave_large (GimpDrawable *drawable,
gint progress, max_progress;
gpointer pr;
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
if (gimp_drawable_is_rgb(drawable->id))
if (gimp_drawable_is_rgb(drawable->drawable_id))
bpp = 3;
else
bpp = 1;
@ -403,8 +403,8 @@ engrave_large (GimpDrawable *drawable,
/* update the engraved region */
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow(drawable->drawable_id, TRUE);
gimp_drawable_update(drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
typedef struct
@ -435,7 +435,7 @@ engrave_small (GimpDrawable *drawable,
x1%height != 0 etc.), operates on the remainder pixels.
*/
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init(&src_rgn, drawable,
x1, y1, x2 - x1, y2 - y1, FALSE, FALSE);
gimp_pixel_rgn_init(&dest_rgn, drawable,
@ -446,7 +446,7 @@ engrave_small (GimpDrawable *drawable,
max_progress = (x2 - x1) * (y2 - y1);
bpp = drawable->bpp;
if (gimp_drawable_is_rgb(drawable->id))
if (gimp_drawable_is_rgb(drawable->drawable_id))
color_n = 3;
else
color_n = 1;
@ -477,8 +477,8 @@ engrave_small (GimpDrawable *drawable,
/* update the engraved region */
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow(drawable->drawable_id, TRUE);
gimp_drawable_update(drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static void

11
plug-ins/common/exchange.c
View file

@ -164,7 +164,8 @@ run (gchar *name,
drw = gimp_drawable_get (xargs.drawable);
/* initialize misc. things */
gimp_drawable_mask_bounds (drw->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drw->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -178,7 +179,7 @@ run (gchar *name,
else
prev_height = sel_height;
has_alpha = gimp_drawable_has_alpha (drw->id);
has_alpha = gimp_drawable_has_alpha (drw->drawable_id);
switch (runmode)
{
@ -233,7 +234,7 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
if (gimp_drawable_is_rgb (drw->id))
if (gimp_drawable_is_rgb (drw->drawable_id))
{
gimp_progress_init (_("Color Exchange..."));
gimp_tile_cache_ntiles (2 * (drw->width / gimp_tile_width () + 1));
@ -760,7 +761,7 @@ real_exchange (gint x1,
{
/* update the processed region */
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->id, TRUE);
gimp_drawable_update (drw->id, x1, y1, width, height);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, x1, y1, width, height);
}
}

6
plug-ins/common/film.c
View file

@ -605,7 +605,7 @@ convert_to_rgb (GimpDrawable *srcdrawable,
register guchar *cmap, *colour;
gint ncols;
switch (gimp_drawable_type (srcdrawable->id))
switch (gimp_drawable_type (srcdrawable->drawable_id))
{
case GIMP_RGB_IMAGE:
memcpy ((char *)dst, (char *)src, numpix*3);
@ -647,7 +647,7 @@ convert_to_rgb (GimpDrawable *srcdrawable,
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
cmap = gimp_image_get_cmap (gimp_drawable_image_id (srcdrawable->id),
cmap = gimp_image_get_cmap (gimp_drawable_image_id (srcdrawable->drawable_id),
&ncols);
if (cmap)
{
@ -849,7 +849,7 @@ draw_hole_rgb (GimpDrawable *drw,
GimpPixelRgn rgn;
guchar *data;
gint tile_height = gimp_tile_height ();
gint i, j, scan_lines, d_width = gimp_drawable_width (drw->id);
gint i, j, scan_lines, d_width = gimp_drawable_width (drw->drawable_id);
gint length;
if ((width <= 0) || (height <= 0))

20
plug-ins/common/flarefx.c
View file

@ -287,8 +287,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Render Flare..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -404,7 +404,7 @@ FlareFX (GimpDrawable *drawable,
}
else
{
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
@ -508,8 +508,8 @@ FlareFX (GimpDrawable *drawable,
{
/* update the textured region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
g_free (cur_row);
@ -759,10 +759,10 @@ flare_center_create (GimpDrawable *drawable)
center = g_new (FlareCenter, 1);
center->drawable = drawable;
center->dwidth = gimp_drawable_width(drawable->id );
center->dheight = gimp_drawable_height(drawable->id );
center->bpp = gimp_drawable_bpp(drawable->id);
if (gimp_drawable_has_alpha (drawable->id))
center->dwidth = gimp_drawable_width(drawable->drawable_id );
center->dheight = gimp_drawable_height(drawable->drawable_id );
center->bpp = gimp_drawable_bpp(drawable->drawable_id);
if (gimp_drawable_has_alpha (drawable->drawable_id))
center->bpp--;
center->cursor = FALSE;
center->curx = 0;
@ -890,7 +890,7 @@ preview_widget (GimpDrawable *drawable)
gint size;
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview_with_thumb (preview, drawable->id);
fill_preview_with_thumb (preview, drawable->drawable_id);
size = GTK_PREVIEW (preview)->rowstride * GTK_PREVIEW (preview)->buffer_height;
preview_bits = g_malloc (size);
memcpy (preview_bits, GTK_PREVIEW (preview)->buffer, size);

12
plug-ins/common/fp.c
View file

@ -122,13 +122,13 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
mask = gimp_drawable_get (gimp_image_get_selection (param[1].data.d_image));
if (gimp_drawable_is_indexed (drawable->id) ||
gimp_drawable_is_gray (drawable->id) )
if (gimp_drawable_is_indexed (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id) )
{
gimp_message (_("Convert the image to RGB first!"));
status = GIMP_PDB_EXECUTION_ERROR;
}
else if (gimp_drawable_is_rgb (drawable->id) && fp_dialog())
else if (gimp_drawable_is_rgb (drawable->drawable_id) && fp_dialog())
{
gimp_progress_init (_("Applying the Filter Pack..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -230,7 +230,7 @@ void fp (GimpDrawable *drawable)
gint row;
gint x1, y1, x2, y2;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
@ -263,8 +263,8 @@ void fp (GimpDrawable *drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (src_row);
free (dest_row);

18
plug-ins/common/fractaltrace.c
View file

@ -173,11 +173,11 @@ run (gchar *name,
status = GIMP_PDB_SUCCESS;
drawable = gimp_drawable_get (args[2].data.d_drawable);
image.width = gimp_drawable_width( drawable->id);
image.height = gimp_drawable_height (drawable->id);
image.bpp = gimp_drawable_bpp (drawable->id);
image.alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->id, &selection.x1, &selection.y1,
image.width = gimp_drawable_width( drawable->drawable_id);
image.height = gimp_drawable_height (drawable->drawable_id);
image.bpp = gimp_drawable_bpp (drawable->drawable_id);
image.alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id, &selection.x1, &selection.y1,
&selection.x2, &selection.y2);
selection.width = selection.x2 - selection.y1;
selection.height = selection.y2 - selection.y1;
@ -186,8 +186,8 @@ run (gchar *name,
pixels_init (drawable);
if (!gimp_drawable_is_rgb(drawable->id) &&
!gimp_drawable_is_gray(drawable->id))
if (!gimp_drawable_is_rgb(drawable->drawable_id) &&
!gimp_drawable_is_gray(drawable->drawable_id))
{
status = GIMP_PDB_EXECUTION_ERROR;
}
@ -499,8 +499,8 @@ filter (GimpDrawable *drawable)
pixels_store ();
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id,
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
selection.x1, selection.y1,
selection.width, selection.height);
}

12
plug-ins/common/gauss_iir.c
View file

@ -301,8 +301,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("IIR Gaussian Blur"));
@ -580,7 +580,7 @@ gauss_iir (GimpDrawable *drawable,
gint *gi_tmp1, *gi_tmp2;
gdouble std_dev;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
if (horz < 1.0 && vert < 1.0)
return;
@ -588,7 +588,7 @@ gauss_iir (GimpDrawable *drawable,
width = (x2 - x1);
height = (y2 - y1);
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
val_p = g_new (gdouble, MAX (width, height) * bytes);
val_m = g_new (gdouble, MAX (width, height) * bytes);
@ -776,8 +776,8 @@ gauss_iir (GimpDrawable *drawable,
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
/* free up buffers */
g_free (val_p);

12
plug-ins/common/gauss_rle.c
View file

@ -296,8 +296,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("RLE Gaussian Blur"));
@ -576,12 +576,12 @@ gauss_rle (GimpDrawable *drawable,
if (horz < 1.0 && vert < 1.0)
return;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
buf = g_new (gint, MAX (width, height) * 2);
@ -755,8 +755,8 @@ gauss_rle (GimpDrawable *drawable,
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
/* free buffers */
g_free (buf);

4
plug-ins/common/gee.c
View file

@ -635,7 +635,7 @@ init_preview_misc (void)
gint i;
gboolean has_alpha;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
env = g_malloc (4 * IWIDTH * IHEIGHT * 2);
disp = g_malloc ((IWIDTH + 2 + IWIDTH * IHEIGHT) * 4);
@ -677,7 +677,7 @@ init_preview_misc (void)
) * 256
)) *
gimp_drawable_bpp
(drawable->id)
(drawable->drawable_id)
],
drawable->width>256?
(drawable->width/2-128):0,

4
plug-ins/common/gee_zoom.c
View file

@ -686,7 +686,7 @@ init_preview_misc (void)
else
rgb_mode = FALSE;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
seed_data = g_malloc(width*height*4);
preview_data1 = g_malloc(width*height*(rgb_mode?3:1));
@ -724,7 +724,7 @@ init_preview_misc (void)
) * 256
)) *
gimp_drawable_bpp
(drawable->id)
(drawable->drawable_id)
],
drawable->width>256?
(drawable->width/2-128):0,

12
plug-ins/common/glasstile.c
View file

@ -209,8 +209,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("Glass Tile..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -356,7 +356,7 @@ preview_widget (GimpDrawable *drawable)
GtkWidget *preview;
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview_with_thumb (preview, drawable->id);
fill_preview_with_thumb (preview, drawable->drawable_id);
size = GTK_PREVIEW (preview)->rowstride * GTK_PREVIEW (preview)->buffer_height;
preview_bits = g_malloc (size);
memcpy (preview_bits, GTK_PREVIEW (preview)->buffer, size);
@ -572,7 +572,7 @@ glasstile (GimpDrawable *drawable,
}
else
{
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
@ -704,8 +704,8 @@ glasstile (GimpDrawable *drawable,
else
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
g_free (cur_row);

17
plug-ins/common/gqbist.c
View file

@ -465,13 +465,14 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->id);
img_height = gimp_drawable_height (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->id);
img_has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
if (!gimp_drawable_is_rgb (drawable->id))
if (!gimp_drawable_is_rgb (drawable->drawable_id))
status = GIMP_PDB_CALLING_ERROR;
if (status == GIMP_PDB_SUCCESS)
@ -549,8 +550,8 @@ run (gchar *name,
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id,
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1,
(sel_x2 - sel_x1), (sel_y2 - sel_y1));

24
plug-ins/common/gradmap.c
View file

@ -148,8 +148,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("Gradient Map..."));
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
@ -185,11 +185,11 @@ gradmap (GimpDrawable *drawable)
gint lum; /* luminosity */
gint b;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = alpha = gimp_drawable_bpp( drawable->id );
color = gimp_drawable_is_rgb( drawable->id );
has_alpha = gimp_drawable_has_alpha( drawable->id );
bpp = alpha = gimp_drawable_bpp( drawable->drawable_id );
color = gimp_drawable_is_rgb( drawable->drawable_id );
has_alpha = gimp_drawable_has_alpha( drawable->drawable_id );
if( has_alpha )
alpha--;
@ -241,13 +241,13 @@ gradmap (GimpDrawable *drawable)
g_free (samples);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
/*
Returns 256 samples of active gradient.
Each sample has (gimp_drawable_bpp (drawable->id)) bytes.
Each sample has (gimp_drawable_bpp (drawable->drawable_id)) bytes.
*/
static guchar *
get_samples (GimpDrawable *drawable)
@ -259,9 +259,9 @@ get_samples (GimpDrawable *drawable)
f_samples = gimp_gradients_sample_uniform (NSAMPLES);
bpp = gimp_drawable_bpp (drawable->id);
color = gimp_drawable_is_rgb (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->id);
bpp = gimp_drawable_bpp (drawable->drawable_id);
color = gimp_drawable_is_rgb (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
alpha = (has_alpha ? bpp - 1 : bpp);
b_samples = g_new (guchar, NSAMPLES * bpp);

16
plug-ins/common/grid.c
View file

@ -402,10 +402,10 @@ doit (gint32 image_ID,
/* Get the input area. This is the bounding box of the selection in
* the image (or the entire image if there is no selection).
*/
gimp_drawable_mask_bounds (drawable->id, &sx1, &sy1, &sx2, &sy2);
width = gimp_drawable_width (drawable->id);
height = gimp_drawable_height (drawable->id);
alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &sx1, &sy1, &sx2, &sy2);
width = gimp_drawable_width (drawable->drawable_id);
height = gimp_drawable_height (drawable->drawable_id);
alpha = gimp_drawable_has_alpha (drawable->drawable_id);
bytes = drawable->bpp;
/* initialize the pixel regions */
@ -502,8 +502,8 @@ doit (gint32 image_ID,
else
{
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sx1, sy1, sx2 - sx1, sy2 - sy1);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, sx1, sy1, sx2 - sx1, sy2 - sy1);
}
}
@ -1008,7 +1008,7 @@ fill_preview (GtkWidget *widget,
guchar *p0, *p1;
guchar *even, *odd;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
if (x2 - x1 > PREVIEW_SIZE)
x2 = x1 + PREVIEW_SIZE;
@ -1018,7 +1018,7 @@ fill_preview (GtkWidget *widget,
width = x2 - x1;
height = y2 - y1;
bpp = gimp_drawable_bpp (drawable->id);
bpp = gimp_drawable_bpp (drawable->drawable_id);
if (width < 1 || height < 1)
return;

4
plug-ins/common/hot.c
View file

@ -550,8 +550,8 @@ pluginCore (struct piArgs *argp)
else
{
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->id, TRUE);
gimp_drawable_update (drw->id, 0, 0, width, height);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, 0, 0, width, height);
}
gimp_displays_flush ();

20
plug-ins/common/illusion.c
View file

@ -174,8 +174,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width() + 1));
gimp_progress_init (_("Illusion..."));
@ -222,11 +222,11 @@ filter (GimpDrawable *drawable)
gint yy = 0;
gdouble scale, radius, cx, cy, angle, offset;
image_width = gimp_drawable_width (drawable->id);
image_height = gimp_drawable_height (drawable->id);
image_bpp = gimp_drawable_bpp (drawable->id);
image_has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->id,&x1, &y1, &x2, &y2);
image_width = gimp_drawable_width (drawable->drawable_id);
image_height = gimp_drawable_height (drawable->drawable_id);
image_bpp = gimp_drawable_bpp (drawable->drawable_id);
image_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->drawable_id,&x1, &y1, &x2, &y2);
select_width = x2 - x1;
select_height = y2 - y1;
center_x = x1 + (gdouble)select_width / 2;
@ -292,8 +292,8 @@ filter (GimpDrawable *drawable)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id,
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1, select_width, select_height);
for (y = y1; y < y2; y++) g_free (pixels[y-y1]);
@ -479,7 +479,7 @@ static GtkWidget *
preview_widget (GimpDrawable *drawable)
{
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview_with_thumb (preview, drawable->id);
fill_preview_with_thumb (preview, drawable->drawable_id);
return preview;
}

16
plug-ins/common/iwarp.c
View file

@ -277,8 +277,8 @@ run (gchar *name,
imageID = param[1].data.d_int32;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
switch (run_mode)
{
@ -704,8 +704,8 @@ iwarp_frame (void)
}
gimp_drawable_flush (destdrawable);
gimp_drawable_merge_shadow (destdrawable->id, TRUE);
gimp_drawable_update (destdrawable->id, xl, yl, (xh - xl), (yh - yl));
gimp_drawable_merge_shadow (destdrawable->drawable_id, TRUE);
gimp_drawable_update (destdrawable->drawable_id, xl, yl, (xh - xl), (yh - yl));
}
static void
@ -841,14 +841,14 @@ iwarp_init (void)
guchar *linebuffer = NULL;
gdouble dx, dy;
gimp_drawable_mask_bounds (drawable->id, &xl, &yl, &xh, &yh);
gimp_drawable_mask_bounds (drawable->drawable_id, &xl, &yl, &xh, &yh);
sel_width = xh - xl;
sel_height = yh - yl;
image_bpp = gimp_drawable_bpp (drawable->id);
image_bpp = gimp_drawable_bpp (drawable->drawable_id);
if (gimp_drawable_is_layer (drawable->id))
preserve_trans = (gimp_layer_get_preserve_transparency (drawable->id));
if (gimp_drawable_is_layer (drawable->drawable_id))
preserve_trans = (gimp_layer_get_preserve_transparency (drawable->drawable_id));
else
preserve_trans = FALSE;

6
plug-ins/common/jigsaw.c
View file

@ -546,8 +546,8 @@ jigsaw (gboolean preview_mode)
{
gimp_pixel_rgn_set_rect (&dest_pr, buffer, 0, 0, width, height);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, 0, 0, width, height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, width, height);
}
g_free(buffer);
@ -2703,7 +2703,7 @@ preview_widget (GimpDrawable *drawable)
GtkWidget *preview;
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview_with_thumb (preview, drawable->id);
fill_preview_with_thumb (preview, drawable->drawable_id);
size = GTK_PREVIEW (preview)->rowstride * GTK_PREVIEW (preview)->buffer_height;
preview_bits = g_malloc (size);
memcpy (preview_bits, GTK_PREVIEW (preview)->buffer, size);

12
plug-ins/common/laplace.c
View file

@ -115,8 +115,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
laplace (drawable);
@ -217,7 +217,7 @@ laplace (GimpDrawable *drawable)
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_progress_init ( _("Laplace..."));
/* Get the size of the input image. (This will/must be the same
@ -226,7 +226,7 @@ laplace (GimpDrawable *drawable)
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
alpha = gimp_drawable_has_alpha (drawable -> id);
alpha = gimp_drawable_has_alpha (drawable->drawable_id);
/* allocate row buffers */
prev_row = (guchar *) malloc ((x2 - x1 + 2) * bytes);
cur_row = (guchar *) malloc ((x2 - x1 + 2) * bytes);
@ -341,8 +341,8 @@ laplace (GimpDrawable *drawable)
/* update the laplaced region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (prev_row);
free (cur_row);

16
plug-ins/common/lic.c
View file

@ -202,7 +202,7 @@ image_setup (GimpDrawable *drawable,
input_drawable = drawable;
output_drawable = drawable;
gimp_drawable_mask_bounds (drawable->id,
gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2);
width = input_drawable->width;
@ -217,7 +217,7 @@ image_setup (GimpDrawable *drawable,
/* =================== */
in_channels = 3;
if (gimp_drawable_has_alpha (input_drawable->id))
if (gimp_drawable_has_alpha (input_drawable->drawable_id))
in_channels++;
if (interactive)
@ -678,7 +678,7 @@ rgb_to_hue (GimpDrawable *image,
h = image->height;
maxc = (glong) w * (glong) h;
/* gimp_drawable_mask_bounds (drawable->id,
/* gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2); */
gimp_pixel_rgn_init (&region, image, 0, 0, w, h, FALSE, FALSE);
@ -719,7 +719,7 @@ rgb_to_saturation (GimpDrawable *image,
h = image->height;
maxc = (glong) w * (glong) h;
/* gimp_drawable_mask_bounds (drawable->id,
/* gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2); */
gimp_pixel_rgn_init (&region, image, 0, 0, w, h, FALSE, FALSE);
@ -760,7 +760,7 @@ rgb_to_brightness (GimpDrawable *image,
h = image->height;
maxc = (glong) w * (glong) h;
/* gimp_drawable_mask_bounds (drawable->id,
/* gimp_drawable_mask_bounds (drawable->drawable_id,
&border_x1, &border_y1, &border_x2, &border_y2); */
gimp_pixel_rgn_init (&region, image, 0, 0, w, h, FALSE, FALSE);
@ -954,8 +954,8 @@ compute_image (void)
/* ============ */
gimp_drawable_flush (output_drawable);
gimp_drawable_merge_shadow (output_drawable->id, TRUE);
gimp_drawable_update (output_drawable->id, 0, 0, width, height);
gimp_drawable_merge_shadow (output_drawable->drawable_id, TRUE);
gimp_drawable_update (output_drawable->drawable_id, 0, 0, width, height);
if (new_image_id != -1)
{
@ -1273,7 +1273,7 @@ run (gchar *name,
/* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
/* Set the tile cache size */
/* ======================= */

10
plug-ins/common/mapcolor.c
View file

@ -410,7 +410,7 @@ run (gchar *name,
/* Make sure the drawable is RGB color */
drawable = gimp_drawable_get (param[2].data.d_drawable);
if (!gimp_drawable_is_rgb (drawable->id))
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Color Mapping / Adjust FG/BG:\nCannot operate on gray/indexed images"));
status = GIMP_PDB_EXECUTION_ERROR;
@ -743,13 +743,13 @@ color_mapping (GimpDrawable *drawable)
if (gimp_rgb_distance (&plvals.colors[0], &plvals.colors[1]) < 0.0001)
return;
if (!gimp_drawable_is_rgb (drawable->id))
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Color Mapping / Adjust FG/BG:\nCannot operate on gray/indexed images"));
return;
}
gimp_drawable_mask_bounds (drawable->id, &xmin, &ymin, &xmax, &ymax);
gimp_drawable_mask_bounds (drawable->drawable_id, &xmin, &ymin, &xmax, &ymax);
if ((ymin == ymax) || (xmin == xmax)) return;
total = (xmax - xmin) * (ymax - ymin);
@ -801,7 +801,7 @@ color_mapping (GimpDrawable *drawable)
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id,
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
xmin, ymin, (xmax - xmin), (ymax - ymin));
}

12
plug-ins/common/max_rgb.c
View file

@ -160,7 +160,7 @@ run (gchar *name,
INIT_I18N_UI();
gimp_get_data (PLUG_IN_NAME, &pvals);
/* Since a channel might be selected, we must check wheter RGB or not. */
if (!gimp_drawable_is_rgb (drawable->id))
if (!gimp_drawable_is_rgb (drawable->drawable_id))
{
g_message (_("Max RGB: Can only operate on RGB drawables."));
return;
@ -215,8 +215,8 @@ main_function (GimpDrawable *drawable,
}
else
{
gap = (gimp_drawable_has_alpha (drawable->id)) ? 1 : 0;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gap = (gimp_drawable_has_alpha (drawable->drawable_id)) ? 1 : 0;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
@ -318,8 +318,8 @@ main_function (GimpDrawable *drawable,
}
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_detach (drawable);
}
@ -434,7 +434,7 @@ preview_widget (GimpDrawable *drawable)
GtkWidget *preview;
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview_with_thumb (preview, drawable->id);
fill_preview_with_thumb (preview, drawable->drawable_id);
size = GTK_PREVIEW (preview)->rowstride * GTK_PREVIEW (preview)->buffer_height;
preview_bits = g_malloc (size);
memcpy (preview_bits, GTK_PREVIEW (preview)->buffer, size);

26
plug-ins/common/mblur.c
View file

@ -193,11 +193,12 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->id);
img_height = gimp_drawable_height (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->id);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
/* Calculate scaling parameters */
@ -252,8 +253,8 @@ run (gchar *name,
/* Blur the image */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb(drawable->id) ||
gimp_drawable_is_gray(drawable->id)))
(gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id)))
{
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * (drawable->width +
@ -627,8 +628,9 @@ mblur (void)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}
/*****************************************
@ -644,10 +646,10 @@ pixel_fetcher_new (GimpDrawable *drawable)
pf->col = -1;
pf->row = -1;
pf->img_width = gimp_drawable_width (drawable->id);
pf->img_height = gimp_drawable_height (drawable->id);
pf->img_bpp = gimp_drawable_bpp (drawable->id);
pf->img_has_alpha = gimp_drawable_has_alpha (drawable->id);
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_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
pf->tile_width = gimp_tile_width ();
pf->tile_height = gimp_tile_height ();
pf->bg_color[0] = 0;

28
plug-ins/common/mosaic.c
View file

@ -408,8 +408,8 @@ run (gchar *name,
/* Create the mosaic */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (active_drawable->id) ||
gimp_drawable_is_gray (active_drawable->id)))
(gimp_drawable_is_rgb (active_drawable->drawable_id) ||
gimp_drawable_is_gray (active_drawable->drawable_id)))
{
/* set the tile cache size so that the gaussian blur works well */
gimp_tile_cache_ntiles (2 * (MAX (active_drawable->width,
@ -447,7 +447,7 @@ mosaic (GimpDrawable *drawable)
GimpRGB background;
/* Find the mask bounds */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* progress bar for gradient finding */
gimp_progress_init ( _("Finding Edges..."));
@ -483,7 +483,7 @@ mosaic (GimpDrawable *drawable)
case FG_BG:
gimp_palette_get_foreground (&foreground);
gimp_palette_get_background (&background);
switch (gimp_drawable_type (drawable->id))
switch (gimp_drawable_type (drawable->drawable_id))
{
case GIMP_RGB_IMAGE:
case GIMP_RGBA_IMAGE:
@ -502,7 +502,7 @@ mosaic (GimpDrawable *drawable)
}
alpha = drawable->bpp - 1;
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
fore[alpha] = OPAQUE;
back[alpha] = OPAQUE;
@ -521,8 +521,8 @@ mosaic (GimpDrawable *drawable)
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static gint
@ -775,7 +775,7 @@ find_gradients (GimpDrawable *drawable,
gint x1, y1, x2, y2;
/* find the mask bounds */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
bytes = drawable->bpp;
@ -931,7 +931,7 @@ gaussian_deriv (GimpPixelRgn *src_rgn,
gint x1, y1, x2, y2;
/* get the mask bounds */
gimp_drawable_mask_bounds (src_rgn->drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (src_rgn->drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = src_rgn->bpp;
/* allocate buffers for get/set pixel region rows/cols */
@ -1453,7 +1453,7 @@ grid_render (GimpDrawable *drawable)
Polygon poly;
gpointer pr;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
/* Fill the image with the background color */
@ -1639,7 +1639,7 @@ process_poly (Polygon *poly,
gint x1, y1, x2, y2;
/* find mask bounds */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* determine the variation of tile color based on tile number */
color_vary = (vary) ? fp_rand (mvals.color_variation) : 0;
@ -1965,7 +1965,7 @@ find_poly_color (Polygon *poly,
count = 0;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
polygon_extents (poly, &dmin_x, &dmin_y, &dmax_x, &dmax_y);
@ -2088,7 +2088,7 @@ fill_poly_color (Polygon *poly,
supersample = supersample2 = 1;
}
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
/* begin loop */
@ -2266,7 +2266,7 @@ fill_poly_image (Polygon *poly,
supersample = supersample2 = 1;
}
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bytes = drawable->bpp;
for (i = 0; i < poly->npts; i++)
{

20
plug-ins/common/newsprint.c
View file

@ -660,8 +660,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Newsprintifing..."));
@ -1189,8 +1189,8 @@ newsprint_dialog (GimpDrawable *drawable)
/* need to know the bpp, so we can tell if we're doing
* RGB/CMYK or grey style of dialog box */
bpp = gimp_drawable_bpp (drawable->id);
if (gimp_drawable_has_alpha (drawable->id))
bpp = gimp_drawable_bpp (drawable->drawable_id);
if (gimp_drawable_has_alpha (drawable->drawable_id))
bpp--;
/* force greyscale if it's the only thing we can do */
@ -1237,7 +1237,7 @@ newsprint_dialog (GimpDrawable *drawable)
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_container_add (GTK_CONTAINER (frame), table);
gimp_image_get_resolution (gimp_drawable_image_id( drawable->id),
gimp_image_get_resolution (gimp_drawable_image_id( drawable->drawable_id),
&xres, &yres);
/* XXX hack: should really note both resolutions, and use
* rectangular cells, not square cells. But I'm being lazy,
@ -1774,10 +1774,10 @@ newsprint (GimpDrawable *drawable)
tile_width = gimp_tile_width ();
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->id);
bpp = gimp_drawable_bpp (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
colour_bpp = has_alpha ? bpp-1 : bpp;
colourspace= pvals.colourspace;
if (bpp == 1)
@ -2023,6 +2023,6 @@ do { \
/* update the affected region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}

4
plug-ins/common/nlfilt.c
View file

@ -308,8 +308,8 @@ pluginCore (struct piArgs *argp)
g_free (dstbuf);
gimp_drawable_flush (drw);
gimp_drawable_merge_shadow (drw->id, TRUE);
gimp_drawable_update (drw->id, 0, 0, width, height);
gimp_drawable_merge_shadow (drw->drawable_id, TRUE);
gimp_drawable_update (drw->drawable_id, 0, 0, width, height);
gimp_displays_flush ();
return 0;

14
plug-ins/common/noisify.c
View file

@ -211,8 +211,8 @@ run (gchar *name,
}
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Adding Noise..."));
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
@ -346,7 +346,7 @@ noisify (GimpDrawable *drawable,
}
else
{
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable,
@ -459,8 +459,8 @@ noisify (GimpDrawable *drawable,
/* update the blurred region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
} /* endif normal mode */
}
@ -770,7 +770,7 @@ fill_preview (GtkWidget *widget,
guchar *src;
guchar *even, *odd;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
if (x2 - x1 > PREVIEW_SIZE)
x2 = x1 + PREVIEW_SIZE;
@ -780,7 +780,7 @@ fill_preview (GtkWidget *widget,
width = x2 - x1;
height = y2 - y1;
bpp = gimp_drawable_bpp (drawable->id);
bpp = gimp_drawable_bpp (drawable->drawable_id);
if (width < 1 || height < 1)
return;

12
plug-ins/common/normalize.c
View file

@ -116,7 +116,7 @@ run (gchar *name,
image_ID = param[1].data.d_image;
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) || gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Normalizing..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -125,7 +125,7 @@ run (gchar *name,
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else if (gimp_drawable_is_indexed (drawable->id))
else if (gimp_drawable_is_indexed (drawable->drawable_id))
{
indexed_norma (image_ID);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
@ -200,8 +200,8 @@ norma (GimpDrawable *drawable)
gpointer pr;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
/* Initialize progress */
@ -303,6 +303,6 @@ norma (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}

25
plug-ins/common/nova.c
View file

@ -303,8 +303,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Rendering SuperNova..."));
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
@ -338,7 +338,7 @@ preview_widget (GimpDrawable *drawable)
GtkWidget *preview;
preview = gtk_preview_new (GTK_PREVIEW_COLOR);
fill_preview_with_thumb (preview, drawable->id);
fill_preview_with_thumb (preview, drawable->drawable_id);
size = GTK_PREVIEW (preview)->rowstride *
GTK_PREVIEW (preview)->buffer_height;
@ -600,11 +600,11 @@ nova_center_create (GimpDrawable *drawable)
center = g_new (NovaCenter, 1);
center->drawable = drawable;
center->dwidth = gimp_drawable_width (drawable->id);
center->dheight = gimp_drawable_height (drawable->id);
center->bpp = gimp_drawable_bpp (drawable->id);
center->dwidth = gimp_drawable_width (drawable->drawable_id);
center->dheight = gimp_drawable_height (drawable->drawable_id);
center->bpp = gimp_drawable_bpp (drawable->drawable_id);
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
center->bpp--;
center->cursor = FALSE;
@ -935,7 +935,7 @@ nova (GimpDrawable *drawable,
gint i;
/* initialize */
has_alpha = gimp_drawable_has_alpha (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
srand (time (NULL));
spoke = g_new (gdouble, pvals.nspoke);
@ -972,8 +972,8 @@ nova (GimpDrawable *drawable,
}
else
{
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp (drawable->drawable_id);
alpha = (has_alpha) ? bpp - 1 : bpp;
xc = pvals.xcenter;
yc = pvals.ycenter;
@ -1156,8 +1156,9 @@ nova (GimpDrawable *drawable,
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
x1, y1, (x2 - x1), (y2 - y1));
#else
gimp_message ("Sorry, the SuperNova effect\n"
"is broken at the moment and\n"

18
plug-ins/common/oilify.c
View file

@ -188,13 +188,13 @@ run (gchar *name,
/* Make sure that the drawable is gray or RGB color */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id)))
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
gimp_progress_init (_("Oil Painting..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
if (gimp_drawable_is_rgb (drawable->id) && (ovals.mode == MODE_INTEN))
if (gimp_drawable_is_rgb (drawable->drawable_id) && (ovals.mode == MODE_INTEN))
oilify_intensity (drawable);
else
oilify_rgb (drawable);
@ -242,7 +242,7 @@ oilify_rgb (GimpDrawable *drawable)
guchar *guc_tmp1;
/* get the selection bounds */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
progress = 0;
max_progress = (x2 - x1) * (y2 - y1);
@ -325,8 +325,8 @@ oilify_rgb (GimpDrawable *drawable)
/* update the oil-painted region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
/*
@ -354,7 +354,7 @@ oilify_intensity (GimpDrawable *drawable)
guchar *guc_tmp1;
/* get the selection bounds */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
progress = 0;
max_progress = (x2 - x1) * (y2 - y1);
@ -435,8 +435,8 @@ oilify_intensity (GimpDrawable *drawable)
/* update the oil-painted region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static gint

10
plug-ins/common/papertile.c
View file

@ -801,8 +801,8 @@ filter (void)
}
gimp_drawable_flush (p.drawable);
gimp_drawable_merge_shadow (p.drawable->id, TRUE);
gimp_drawable_update (p.drawable->id, p.selection.x0, p.selection.y0,
gimp_drawable_merge_shadow (p.drawable->drawable_id, TRUE);
gimp_drawable_update (p.drawable->drawable_id, p.selection.x0, p.selection.y0,
p.selection.width, p.selection.height);
/* FREE */
@ -865,15 +865,15 @@ plugin_run (gchar *name,
p.run_mode = params[0].data.d_int32;
p.image = params[1].data.d_image;
p.drawable = gimp_drawable_get(params[2].data.d_drawable);
p.drawable_has_alpha = gimp_drawable_has_alpha(p.drawable->id);
p.drawable_has_alpha = gimp_drawable_has_alpha(p.drawable->drawable_id);
gimp_drawable_mask_bounds (p.drawable->id,
gimp_drawable_mask_bounds (p.drawable->drawable_id,
&p.selection.x0, &p.selection.y0,
&p.selection.x1, &p.selection.y1);
p.selection.width = p.selection.x1 - p.selection.x0;
p.selection.height = p.selection.y1 - p.selection.y0;
if (gimp_drawable_is_rgb (p.drawable->id))
if (gimp_drawable_is_rgb (p.drawable->drawable_id))
{
switch (p.run_mode)
{

18
plug-ins/common/pixelize.c
View file

@ -232,8 +232,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Pixelizing..."));
@ -373,9 +373,9 @@ pixelize_large (GimpDrawable *drawable,
gint progress, max_progress;
gpointer pr;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp(drawable->id);
bpp = gimp_drawable_bpp(drawable->drawable_id);
average = g_new(gulong, bpp);
/* Initialize progress */
@ -455,8 +455,8 @@ pixelize_large (GimpDrawable *drawable,
/* update the blurred region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
@ -479,7 +479,7 @@ pixelize_small (GimpDrawable *drawable,
gint x1, y1, x2, y2;
gint progress, max_progress;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, x2-x1, y2-y1, FALSE, FALSE);
gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2-x1, y2-y1, TRUE, TRUE);
@ -521,8 +521,8 @@ pixelize_small (GimpDrawable *drawable,
/* update the pixelized region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
/*

12
plug-ins/common/plasma.c
View file

@ -262,7 +262,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) || gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Plasma..."));
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
@ -473,9 +474,9 @@ init_plasma (GimpDrawable *drawable,
}
else
{
gimp_drawable_mask_bounds (drawable->id, &ix1, &iy1, &ix2, &iy2);
gimp_drawable_mask_bounds (drawable->drawable_id, &ix1, &iy1, &ix2, &iy2);
bpp = drawable->bpp;
has_alpha = gimp_drawable_has_alpha (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
if (has_alpha)
alpha = bpp-1;
else
@ -527,8 +528,9 @@ end_plasma (GimpDrawable *drawable,
tile = NULL;
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, ix1, iy1, (ix2 - ix1), (iy2 - iy1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
ix1, iy1, (ix2 - ix1), (iy2 - iy1));
}
}

28
plug-ins/common/polar.c
View file

@ -246,12 +246,12 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
img_width = gimp_drawable_width (drawable->id);
img_height = gimp_drawable_height (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->id);
img_has_alpha = gimp_drawable_has_alpha (drawable->id);
img_width = gimp_drawable_width (drawable->drawable_id);
img_height = gimp_drawable_height (drawable->drawable_id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
/* Calculate scaling parameters */
@ -343,8 +343,8 @@ run (gchar *name,
/* Distort the image */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id)))
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
/* Set the tile cache size */
gimp_tile_cache_ntiles (2 * (drawable->width + gimp_tile_width() - 1) /
@ -386,7 +386,7 @@ polarize (void)
pixel_fetcher_t *pft;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Initialize pixel region */
gimp_pixel_rgn_init (&dest_rgn, drawable,
@ -450,8 +450,8 @@ polarize (void)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static gint
@ -719,10 +719,10 @@ pixel_fetcher_new (GimpDrawable *drawable)
pf->col = -1;
pf->row = -1;
pf->img_width = gimp_drawable_width (drawable->id);
pf->img_height = gimp_drawable_height (drawable->id);
pf->img_bpp = gimp_drawable_bpp (drawable->id);
pf->img_has_alpha = gimp_drawable_has_alpha (drawable->id);
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_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
pf->tile_width = gimp_tile_width ();
pf->tile_height = gimp_tile_height ();
pf->bg_color[0] = 0;

2
plug-ins/common/psd.c
View file

@ -2155,7 +2155,7 @@ load_image(char *name)
}
else
{
channels = gimp_drawable_bpp(drawable->id);
channels = gimp_drawable_bpp(drawable->drawable_id);
}

14
plug-ins/common/randomize.c
View file

@ -310,9 +310,9 @@ run (gchar *name,
/*
* Make sure the drawable type is appropriate.
*/
if (gimp_drawable_is_rgb(drawable->id) ||
gimp_drawable_is_gray(drawable->id) ||
gimp_drawable_is_indexed(drawable->id))
if (gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id) ||
gimp_drawable_is_indexed(drawable->drawable_id))
{
switch (run_mode)
{
@ -493,7 +493,7 @@ randomize (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
/*
* Get the size of the input image. (This will/must be the same
* as the size of the output image. Also get alpha info.
@ -501,7 +501,7 @@ randomize (GimpDrawable *drawable)
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
/*
* allocate row buffers
*/
@ -659,8 +659,8 @@ randomize (GimpDrawable *drawable)
* update the randomized region
*/
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow(drawable->drawable_id, TRUE);
gimp_drawable_update(drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
/*
* clean up after ourselves.
*/

10
plug-ins/common/ripple.c
View file

@ -230,8 +230,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("Rippling..."));
@ -289,7 +289,7 @@ ripple (GimpDrawable *drawable)
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
@ -555,8 +555,8 @@ ripple (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
} /* ripple */
static gint

36
plug-ins/common/rotate.c
View file

@ -389,10 +389,10 @@ rotate_drawable (GimpDrawable *drawable)
height = drawable->height;
bytes = drawable->bpp;
if (gimp_layer_get_preserve_transparency (drawable->id))
if (gimp_layer_get_preserve_transparency (drawable->drawable_id))
{
was_preserve_transparency = TRUE;
gimp_layer_set_preserve_transparency (drawable->id, FALSE);
gimp_layer_set_preserve_transparency (drawable->drawable_id, FALSE);
}
if (rotvals.angle == 2) /* we're rotating by 180° */
@ -427,16 +427,16 @@ rotate_drawable (GimpDrawable *drawable)
g_free (dest_row);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, 0, 0, width, height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, width, height);
}
else /* we're rotating by 90° or 270° */
{
(width > height) ? (longside = width) : (longside = height);
gimp_layer_resize (drawable->id, longside, longside, 0, 0);
drawable = gimp_drawable_get (drawable->id);
gimp_layer_resize (drawable->drawable_id, longside, longside, 0, 0);
drawable = gimp_drawable_get (drawable->drawable_id);
gimp_drawable_flush (drawable);
gimp_tile_cache_ntiles ( (longside / gimp_tile_width () + 1) +
@ -479,24 +479,24 @@ rotate_drawable (GimpDrawable *drawable)
gimp_progress_update ( 1.0 );
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, 0, 0, height, width);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, 0, 0, height, width);
gimp_layer_resize (drawable->id, height, width, 0, 0);
drawable = gimp_drawable_get (drawable->id);
gimp_layer_resize (drawable->drawable_id, height, width, 0, 0);
drawable = gimp_drawable_get (drawable->drawable_id);
gimp_drawable_flush (drawable);
gimp_drawable_update (drawable->id, 0, 0, height, width);
gimp_drawable_update (drawable->drawable_id, 0, 0, height, width);
}
gimp_drawable_offsets (drawable->id, &offsetx, &offsety);
gimp_drawable_offsets (drawable->drawable_id, &offsetx, &offsety);
rotate_compute_offsets (&offsetx, &offsety,
gimp_image_width (image_ID),
gimp_image_height (image_ID),
width, height);
gimp_layer_set_offsets (drawable->id, offsetx, offsety);
gimp_layer_set_offsets (drawable->drawable_id, offsetx, offsety);
if (was_preserve_transparency)
gimp_layer_set_preserve_transparency ( drawable->id, TRUE );
gimp_layer_set_preserve_transparency ( drawable->drawable_id, TRUE );
return;
}
@ -527,7 +527,7 @@ rotate (void)
gimp_drawable_detach (active_drawable);
return;
}
if ( gimp_layer_is_floating_selection (active_drawable->id) )
if ( gimp_layer_is_floating_selection (active_drawable->drawable_id) )
{
gimp_message (_("You can not rotate the whole image if there's a floating selection."));
gimp_drawable_detach (active_drawable);
@ -537,7 +537,7 @@ rotate (void)
else
/* if we are trying to rotate a chennel or a mask, create an error message and exit */
{
if ( !gimp_drawable_is_layer (active_drawable->id) )
if ( !gimp_drawable_is_layer (active_drawable->drawable_id) )
{
gimp_message (_("Sorry, channels and masks can not be rotated."));
gimp_drawable_detach (active_drawable);
@ -635,10 +635,10 @@ rotate (void)
/* check for active selection and float it */
if ( !gimp_selection_is_empty (image_ID) &&
!gimp_layer_is_floating_selection (active_drawable->id) )
!gimp_layer_is_floating_selection (active_drawable->drawable_id) )
active_drawable =
gimp_drawable_get (gimp_selection_float (image_ID,
active_drawable->id,
active_drawable->drawable_id,
0, 0));
rotate_drawable (active_drawable);

26
plug-ins/common/sample_colorize.c
View file

@ -359,8 +359,8 @@ run (gchar *name,
p_clear_tables();
/* Make sure that the dst_drawable is gray or RGB color */
if (gimp_drawable_is_rgb (dst_drawable->id) ||
gimp_drawable_is_gray (dst_drawable->id))
if (gimp_drawable_is_rgb (dst_drawable->drawable_id) ||
gimp_drawable_is_gray (dst_drawable->drawable_id))
{
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
@ -2577,7 +2577,7 @@ p_end_gdrw(t_GDRW *gdrw)
{
t_GDRW *l_sel_gdrw;
if(g_Sdebug) printf("\np_end_gdrw: drawable %x ID: %d\n", (int)gdrw->drawable, (int)gdrw->drawable->id);
if(g_Sdebug) printf("\np_end_gdrw: drawable %x ID: %d\n", (int)gdrw->drawable, (int)gdrw->drawable->drawable_id);
if(gdrw->tile)
{
@ -2615,7 +2615,7 @@ p_init_gdrw(t_GDRW *gdrw, GimpDrawable *drawable, gint dirty, gint shadow)
t_GDRW *l_sel_gdrw;
gint32 non_empty;
if(g_Sdebug) printf("\np_init_gdrw: drawable %x ID: %d\n", (int)drawable, (int)drawable->id);
if(g_Sdebug) printf("\np_init_gdrw: drawable %x ID: %d\n", (int)drawable, (int)drawable->drawable_id);
gdrw->drawable = drawable;
gdrw->tile = NULL;
@ -2626,9 +2626,9 @@ p_init_gdrw(t_GDRW *gdrw, GimpDrawable *drawable, gint dirty, gint shadow)
gdrw->tile_swapcount = 0;
gdrw->seldeltax = 0;
gdrw->seldeltay = 0;
gimp_drawable_offsets (drawable->id, &l_offsetx, &l_offsety); /* get offsets within the image */
gimp_drawable_offsets (drawable->drawable_id, &l_offsetx, &l_offsety); /* get offsets within the image */
gimp_drawable_mask_bounds (drawable->id, &gdrw->x1, &gdrw->y1, &gdrw->x2, &gdrw->y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &gdrw->x1, &gdrw->y1, &gdrw->x2, &gdrw->y2);
/*
* gimp_pixel_rgn_init (&gdrw->pr, drawable,
@ -2638,7 +2638,7 @@ p_init_gdrw(t_GDRW *gdrw, GimpDrawable *drawable, gint dirty, gint shadow)
gdrw->bpp = drawable->bpp;
if (gimp_drawable_has_alpha(drawable->id))
if (gimp_drawable_has_alpha(drawable->drawable_id))
{
/* index of the alpha channelbyte {1|3} */
gdrw->index_alpha = gdrw->bpp -1;
@ -2649,7 +2649,7 @@ p_init_gdrw(t_GDRW *gdrw, GimpDrawable *drawable, gint dirty, gint shadow)
}
l_image_id = gimp_layer_get_image_id(drawable->id);
l_image_id = gimp_layer_get_image_id(drawable->drawable_id);
/* check and see if we have a selection mask */
l_sel_channel_id = gimp_image_get_selection(l_image_id);
@ -3084,7 +3084,7 @@ p_colorize_drawable(gint32 drawable_id)
drawable = gimp_drawable_get (drawable_id);
if(drawable == NULL) return;
gimp_drawable_mask_bounds (drawable->id, &l_x1, &l_y1, &l_x2, &l_y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &l_x1, &l_y1, &l_x2, &l_y2);
gimp_pixel_rgn_init (&pixel_rgn, drawable,
l_x1, l_y1, l_x2 - l_x1, l_y2 - l_y1,
FALSE, /* dirty */
@ -3102,7 +3102,7 @@ p_colorize_drawable(gint32 drawable_id)
l_bpp2 = pixel_rgn.bpp;
l_idx_alpha = pixel_rgn.bpp -1;
l_has_alpha = gimp_drawable_has_alpha(drawable->id);
l_has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
if(l_has_alpha)
{
l_bpp2--; /* do not remap the alpha channel bytes */
@ -3143,8 +3143,8 @@ p_colorize_drawable(gint32 drawable_id)
gimp_progress_update (0.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, l_x1, l_y1, l_x2 - l_x1, l_y2 - l_y1);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, l_x1, l_y1, l_x2 - l_x1, l_y2 - l_y1);
} /* end p_colorize_drawable */
@ -3199,7 +3199,7 @@ p_main_colorize(gint mc_flags)
gimp_convert_rgb(gimp_layer_get_image_id(g_values.dst_id));
}
}
p_colorize_drawable(dst_drawable->id);
p_colorize_drawable(dst_drawable->drawable_id);
}
if(sample_drawable)

4
plug-ins/common/scatter_hsv.c
View file

@ -270,8 +270,8 @@ scatter_hsv (gint32 drawable_id)
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_detach (drawable);
return GIMP_PDB_SUCCESS;

12
plug-ins/common/sel_gauss.c
View file

@ -195,8 +195,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Selective Gaussian Blur"));
@ -407,12 +407,12 @@ sel_gauss (GimpDrawable *drawable,
gdouble **mat;
gint numrad;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = (x2 - x1);
height = (y2 - y1);
bytes = drawable->bpp;
has_alpha = gimp_drawable_has_alpha(drawable->id);
has_alpha = gimp_drawable_has_alpha(drawable->drawable_id);
if ((width < 1) || (height < 1) || (bytes < 1))
return;
@ -440,8 +440,8 @@ sel_gauss (GimpDrawable *drawable,
/* merge the shadow, update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, width, height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, width, height);
/* free up buffers */
g_free (src);

8
plug-ins/common/semiflatten.c
View file

@ -121,7 +121,7 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is indexed or RGB color */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init ( _("Semi-Flatten..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width ()
@ -191,7 +191,7 @@ semiflatten (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -227,8 +227,8 @@ semiflatten (GimpDrawable *drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (src_row);
free (dest_row);

14
plug-ins/common/sharpen.c
View file

@ -203,11 +203,12 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
img_bpp = gimp_drawable_bpp (drawable->id);
img_bpp = gimp_drawable_bpp (drawable->drawable_id);
/*
* See how we will run
@ -259,8 +260,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
if ((gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id)))
if ((gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
/*
* Set the tile cache size...
@ -491,8 +492,9 @@ sharpen (void)
*/
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}

10
plug-ins/common/shift.c
View file

@ -200,8 +200,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init ( _("Shifting..."));
@ -260,7 +260,7 @@ shift (GimpDrawable *drawable)
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
@ -351,8 +351,8 @@ shift (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}

12
plug-ins/common/sinus.c
View file

@ -1191,7 +1191,7 @@ run (gchar *name,
/* In order to prepare the dialog I need to know wether it's grayscale or not */
drawable = gimp_drawable_get (param[2].data.d_drawable);
thePreview = mw_preview_build_virgin(drawable);
if (gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_gray (drawable->drawable_id))
drawable_is_grayscale = TRUE;
else
drawable_is_grayscale = FALSE;
@ -1239,8 +1239,8 @@ run (gchar *name,
/* Make sure that the drawable is gray or RGB */
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id)))
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
gimp_progress_init (_("Sinus: rendering..."));
gimp_tile_cache_ntiles (1);
@ -1370,7 +1370,7 @@ sinus (void)
prepare_coef(&p);
gimp_drawable_mask_bounds(drawable->id, &ix1, &iy1, &ix2, &iy2);
gimp_drawable_mask_bounds(drawable->drawable_id, &ix1, &iy1, &ix2, &iy2);
p.width = drawable->width;
p.height = drawable->height;
@ -1409,8 +1409,8 @@ sinus (void)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, ix1, iy1, (ix2-ix1), (iy2-iy1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, ix1, iy1, (ix2-ix1), (iy2-iy1));
}
static gdouble

8
plug-ins/common/smooth_palette.c
View file

@ -168,7 +168,7 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
drawable = gimp_drawable_get (param[2].data.d_drawable);
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init (_("Deriving smooth palette..."));
gimp_tile_cache_ntiles (2 * (drawable->width + 1) /
@ -240,7 +240,7 @@ doit (GimpDrawable *drawable,
new_image_id = gimp_image_new (config.width, config.height, GIMP_RGB);
*layer_id = gimp_layer_new (new_image_id, _("Background"),
config.width, config.height,
gimp_drawable_type (drawable->id),
gimp_drawable_type (drawable->drawable_id),
100, GIMP_NORMAL_MODE);
gimp_image_add_layer (new_image_id, *layer_id, 0);
new_layer = gimp_drawable_get (*layer_id);
@ -367,8 +367,8 @@ doit (GimpDrawable *drawable,
g_free (pal);
gimp_drawable_flush (new_layer);
gimp_drawable_merge_shadow (new_layer->id, TRUE);
gimp_drawable_update(new_layer->id, 0, 0,
gimp_drawable_merge_shadow (new_layer->drawable_id, TRUE);
gimp_drawable_update(new_layer->drawable_id, 0, 0,
config.width, config.height);
return new_image_id;

17
plug-ins/common/snoise.c
View file

@ -259,8 +259,9 @@ run (gchar *name,
}
/* Create texture */
if ((status == GIMP_PDB_SUCCESS) && (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id)))
if ((status == GIMP_PDB_SUCCESS) &&
(gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id)))
{
/* Set the tile cache size */
gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width () - 1) /
@ -303,7 +304,8 @@ solid_noise (GimpDrawable *drawable)
guchar val;
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -312,9 +314,9 @@ solid_noise (GimpDrawable *drawable)
gimp_progress_init ( _("Solid Noise..."));
progress = 0;
max_progress = sel_width * sel_height;
chns = gimp_drawable_bpp (drawable->id);
chns = gimp_drawable_bpp (drawable->drawable_id);
has_alpha = 0;
if (gimp_drawable_has_alpha (drawable->id))
if (gimp_drawable_has_alpha (drawable->drawable_id))
{
chns--;
has_alpha = 1;
@ -351,8 +353,9 @@ solid_noise (GimpDrawable *drawable)
/* Update the drawable */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}

12
plug-ins/common/sobel.c
View file

@ -208,8 +208,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
sobel (drawable, bvals.horizontal, bvals.vertical, bvals.keep_sign);
@ -357,7 +357,7 @@ sobel (GimpDrawable *drawable,
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_progress_init (_("Sobel Edge Detecting..."));
/* Get the size of the input image. (This will/must be the same
@ -366,7 +366,7 @@ sobel (GimpDrawable *drawable,
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
alpha = gimp_drawable_has_alpha (drawable -> id);
alpha = gimp_drawable_has_alpha (drawable->drawable_id);
/* allocate row buffers */
prev_row = g_new (guchar, (x2 - x1 + 2) * bytes);
@ -433,8 +433,8 @@ sobel (GimpDrawable *drawable,
/* update the sobeled region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
g_free (prev_row);
g_free (cur_row);

22
plug-ins/common/sparkle.c
View file

@ -290,8 +290,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Sparkling..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -301,7 +301,7 @@ run (gchar *name,
threshold = compute_lum_threshold (drawable, svals.lum_threshold);
else
{
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
num_sparkles = 2 * (x2 - x1 + y2 - y1);
threshold = 255;
}
@ -606,9 +606,9 @@ compute_lum_threshold (GimpDrawable *drawable,
memset (values, 0, sizeof (gint) * 256);
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gray = gimp_drawable_is_gray (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gray = gimp_drawable_is_gray (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
gimp_pixel_rgn_init (&src_rgn, drawable,
x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE);
@ -659,9 +659,9 @@ sparkle (GimpDrawable *drawable,
guchar *tmp1;
gint tile_width, tile_height;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gray = gimp_drawable_is_gray (drawable->id);
has_alpha = gimp_drawable_has_alpha (drawable->id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gray = gimp_drawable_is_gray (drawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (drawable->drawable_id);
alpha = (has_alpha) ? drawable->bpp - 1 : drawable->bpp;
tile_width = gimp_tile_width();
tile_height = gimp_tile_height();
@ -773,8 +773,8 @@ sparkle (GimpDrawable *drawable,
/* update the blurred region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
}
static inline GimpTile *

10
plug-ins/common/spread.c
View file

@ -206,8 +206,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Spreading..."));
@ -267,7 +267,7 @@ spread (GimpDrawable *drawable)
/* Get selection area */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
@ -356,8 +356,8 @@ spread (GimpDrawable *drawable)
/* update the region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
} /* spread */

10
plug-ins/common/struc.c
View file

@ -1236,8 +1236,8 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_progress_init (_("Applying Canvas..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
@ -1366,7 +1366,7 @@ strucpi (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -1471,8 +1471,8 @@ strucpi (GimpDrawable *drawable)
/* update the textured region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (cur_row);
free (dest);

4
plug-ins/common/threshold_alpha.c
View file

@ -245,8 +245,8 @@ threshold_alpha (gint32 drawable_id)
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_detach (drawable);
return GIMP_PDB_SUCCESS;

24
plug-ins/common/tileit.c
View file

@ -268,7 +268,8 @@ run (gchar *name,
tile_width = gimp_tile_width ();
tile_height = gimp_tile_height ();
gimp_drawable_mask_bounds (drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
gimp_drawable_mask_bounds (drawable->drawable_id,
&sel_x1, &sel_y1, &sel_x2, &sel_y2);
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
@ -322,8 +323,8 @@ run (gchar *name,
break;
}
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
/* Set the tile cache size */
@ -932,19 +933,19 @@ cache_preview (void)
src_rows = g_new (guchar, sel_width * 4);
p = tint.pv_cache = g_new (guchar, preview_width * preview_height * 4);
img_width = gimp_drawable_width (tileitdrawable->id);
img_height = gimp_drawable_height (tileitdrawable->id);
img_width = gimp_drawable_width (tileitdrawable->drawable_id);
img_height = gimp_drawable_height (tileitdrawable->drawable_id);
tint.img_bpp = gimp_drawable_bpp (tileitdrawable->id);
tint.img_bpp = gimp_drawable_bpp (tileitdrawable->drawable_id);
has_alpha = gimp_drawable_has_alpha (tileitdrawable->id);
has_alpha = gimp_drawable_has_alpha (tileitdrawable->drawable_id);
if (tint.img_bpp < 3)
{
tint.img_bpp = 3 + has_alpha;
}
switch (gimp_drawable_type (tileitdrawable->id))
switch (gimp_drawable_type (tileitdrawable->drawable_id))
{
case GIMP_GRAYA_IMAGE:
case GIMP_GRAY_IMAGE:
@ -1046,7 +1047,7 @@ do_tiles(void)
progress = 0;
max_progress = sel_width * sel_height;
img_bpp = gimp_drawable_bpp(tileitdrawable->id);
img_bpp = gimp_drawable_bpp(tileitdrawable->drawable_id);
for (pr = gimp_pixel_rgns_register(1, &dest_rgn);
pr != NULL; pr = gimp_pixel_rgns_process(pr)) {
@ -1088,8 +1089,9 @@ do_tiles(void)
}
gimp_drawable_flush(tileitdrawable);
gimp_drawable_merge_shadow(tileitdrawable->id, TRUE);
gimp_drawable_update(tileitdrawable->id, sel_x1, sel_y1, sel_width, sel_height);
gimp_drawable_merge_shadow(tileitdrawable->drawable_id, TRUE);
gimp_drawable_update(tileitdrawable->drawable_id,
sel_x1, sel_y1, sel_width, sel_height);
}

10
plug-ins/common/tiler.c
View file

@ -98,8 +98,8 @@ run (gchar *name,
drawable = gimp_drawable_get (param[2].data.d_drawable);
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id) ||
gimp_drawable_is_gray (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id) ||
gimp_drawable_is_gray (drawable->drawable_id))
{
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width () + 1));
tile(drawable);
@ -181,7 +181,7 @@ tile (GimpDrawable *drawable)
/* Get the input */
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_progress_init (_("Tiler..."));
width = drawable->width;
@ -257,6 +257,6 @@ tile (GimpDrawable *drawable)
}
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2-x1), (y2-y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2-x1), (y2-y1));
}

6
plug-ins/common/unsharp.c
View file

@ -286,7 +286,7 @@ unsharp_mask (GimpDrawable *drawable,
gint x1, y1, x2, y2;
/* Get the input */
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_progress_init(_("Blurring..."));
width = drawable->width;
@ -301,8 +301,8 @@ unsharp_mask (GimpDrawable *drawable,
x1, x2, y1, y2);
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2-x1), (y2-y1));
gimp_drawable_merge_shadow(drawable->drawable_id, TRUE);
gimp_drawable_update(drawable->drawable_id, x1, y1, (x2-x1), (y2-y1));
}
/* perform an unsharp mask on the region, given a source region, dest.

8
plug-ins/common/video.c
View file

@ -1902,7 +1902,7 @@ run (gchar *name,
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is gray or RGB color */
if (gimp_drawable_is_rgb (drawable->id))
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
gimp_progress_init ( _("Video/RGB..."));
gimp_tile_cache_ntiles (2 * (drawable->width / gimp_tile_width ()
@ -2033,7 +2033,7 @@ video (GimpDrawable *drawable)
* need to be done for correct operation. (It simply makes it go
* faster, since fewer pixels need to be operated on).
*/
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
/* Get the size of the input image. (This will/must be the same
* as the size of the output image.
@ -2075,8 +2075,8 @@ video (GimpDrawable *drawable)
/* update the processed region */
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->id, TRUE);
gimp_drawable_update (drawable->id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
free (src_row);
free (dest_row);

Some files were not shown because too many files have changed in this diff Show more