From 593043a1b6c1906f7ff6a15c21c59cdee7907149 Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Thu, 14 Jun 2001 20:07:38 +0000 Subject: [PATCH] fixed a FIXME: set the sensitivity of the color tools' menu entries again. 2001-06-14 Michael Natterer * 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. --- ChangeLog | 15 ++++++ app/core/gimpprojection.c | 10 +--- app/display/gimpdisplay.c | 10 +--- app/gdisplay.c | 10 +--- libgimp/gimpcolorselector.h | 2 +- libgimp/gimpdrawable.c | 8 +-- libgimp/gimpdrawable.h | 2 +- libgimp/gimpmenu.h | 2 +- libgimp/gimptile.c | 6 +-- plug-ins/FractalExplorer/FractalExplorer.c | 17 +++--- plug-ins/Lighting/lighting_apply.c | 10 ++-- plug-ins/Lighting/lighting_image.c | 4 +- plug-ins/Lighting/lighting_main.c | 4 +- plug-ins/MapObject/mapobject_apply.c | 4 +- plug-ins/MapObject/mapobject_image.c | 8 +-- plug-ins/MapObject/mapobject_main.c | 16 +++--- plug-ins/common/AlienMap.c | 17 +++--- plug-ins/common/AlienMap2.c | 17 +++--- plug-ins/common/CML_explorer.c | 4 +- plug-ins/common/animationplay.c | 32 +++++------ plug-ins/common/animoptimize.c | 12 ++--- plug-ins/common/apply_lens.c | 10 ++-- plug-ins/common/autocrop.c | 6 +-- plug-ins/common/autostretch_hsv.c | 14 ++--- plug-ins/common/blinds.c | 18 +++---- plug-ins/common/blur.c | 12 ++--- plug-ins/common/borderaverage.c | 4 +- plug-ins/common/bumpmap.c | 37 +++++++------ plug-ins/common/c_astretch.c | 14 ++--- plug-ins/common/checkerboard.c | 12 ++--- plug-ins/common/color_enhance.c | 14 ++--- plug-ins/common/colorify.c | 10 ++-- plug-ins/common/colortoalpha.c | 14 ++--- plug-ins/common/convmatrix.c | 20 +++---- plug-ins/common/cubism.c | 18 +++---- plug-ins/common/curve_bend.c | 62 +++++++++++----------- plug-ins/common/deinterlace.c | 10 ++-- plug-ins/common/depthmerge.c | 18 +++---- plug-ins/common/despeckle.c | 14 ++--- plug-ins/common/destripe.c | 14 ++--- plug-ins/common/diffraction.c | 10 ++-- plug-ins/common/displace.c | 14 ++--- plug-ins/common/edge.c | 24 ++++----- plug-ins/common/emboss.c | 4 +- plug-ins/common/engrave.c | 16 +++--- plug-ins/common/exchange.c | 11 ++-- plug-ins/common/film.c | 6 +-- plug-ins/common/flarefx.c | 20 +++---- plug-ins/common/fp.c | 12 ++--- plug-ins/common/fractaltrace.c | 18 +++---- plug-ins/common/gauss_iir.c | 12 ++--- plug-ins/common/gauss_rle.c | 12 ++--- plug-ins/common/gee.c | 4 +- plug-ins/common/gee_zoom.c | 4 +- plug-ins/common/glasstile.c | 12 ++--- plug-ins/common/gqbist.c | 17 +++--- plug-ins/common/gradmap.c | 24 ++++----- plug-ins/common/grid.c | 16 +++--- plug-ins/common/hot.c | 4 +- plug-ins/common/illusion.c | 20 +++---- plug-ins/common/iwarp.c | 16 +++--- plug-ins/common/jigsaw.c | 6 +-- plug-ins/common/laplace.c | 12 ++--- plug-ins/common/lic.c | 16 +++--- plug-ins/common/mapcolor.c | 10 ++-- plug-ins/common/max_rgb.c | 12 ++--- plug-ins/common/mblur.c | 26 ++++----- plug-ins/common/mosaic.c | 28 +++++----- plug-ins/common/newsprint.c | 20 +++---- plug-ins/common/nlfilt.c | 4 +- plug-ins/common/noisify.c | 14 ++--- plug-ins/common/normalize.c | 12 ++--- plug-ins/common/nova.c | 25 ++++----- plug-ins/common/oilify.c | 18 +++---- plug-ins/common/papertile.c | 10 ++-- plug-ins/common/pixelize.c | 18 +++---- plug-ins/common/plasma.c | 12 +++-- plug-ins/common/polar.c | 28 +++++----- plug-ins/common/psd.c | 2 +- plug-ins/common/randomize.c | 14 ++--- plug-ins/common/ripple.c | 10 ++-- plug-ins/common/rotate.c | 36 ++++++------- plug-ins/common/sample_colorize.c | 26 ++++----- plug-ins/common/scatter_hsv.c | 4 +- plug-ins/common/sel_gauss.c | 12 ++--- plug-ins/common/semiflatten.c | 8 +-- plug-ins/common/sharpen.c | 14 ++--- plug-ins/common/shift.c | 10 ++-- plug-ins/common/sinus.c | 12 ++--- plug-ins/common/smooth_palette.c | 8 +-- plug-ins/common/snoise.c | 17 +++--- plug-ins/common/sobel.c | 12 ++--- plug-ins/common/sparkle.c | 22 ++++---- plug-ins/common/spread.c | 10 ++-- plug-ins/common/struc.c | 10 ++-- plug-ins/common/threshold_alpha.c | 4 +- plug-ins/common/tileit.c | 24 +++++---- plug-ins/common/tiler.c | 10 ++-- plug-ins/common/unsharp.c | 6 +-- plug-ins/common/video.c | 8 +-- plug-ins/common/vinvert.c | 10 ++-- plug-ins/common/vpropagate.c | 6 +-- plug-ins/common/warp.c | 42 +++++++-------- plug-ins/common/waves.c | 4 +- plug-ins/common/whirlpinch.c | 28 +++++----- plug-ins/common/wind.c | 16 +++--- plug-ins/common/zealouscrop.c | 8 +-- plug-ins/flame/flame.c | 6 +-- plug-ins/fp/fp.c | 12 ++--- plug-ins/fp/fp_misc.c | 2 +- plug-ins/gap/gap_filter_pdb.c | 2 +- plug-ins/gap/gap_lib.c | 4 +- plug-ins/gap/gap_mov_dialog.c | 10 ++-- plug-ins/gfig/gfig.c | 19 +++---- plug-ins/gflare/gflare.c | 18 +++---- plug-ins/gimpressionist/brush.c | 6 +-- plug-ins/gimpressionist/gimp.c | 29 +++++----- plug-ins/ifscompose/ifscompose.c | 14 ++--- plug-ins/imagemap/imap_main.c | 2 +- plug-ins/imagemap/imap_preview.c | 12 ++--- plug-ins/maze/handy.c | 2 +- plug-ins/maze/maze.c | 31 ++++++----- plug-ins/mosaic/mosaic.c | 28 +++++----- plug-ins/pagecurl/pagecurl.c | 42 ++++++++------- plug-ins/rcm/rcm.c | 12 ++--- plug-ins/rcm/rcm_misc.c | 2 +- 126 files changed, 876 insertions(+), 848 deletions(-) diff --git a/ChangeLog b/ChangeLog index 9faec4a5e1..df80e46149 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,18 @@ +2001-06-14 Michael Natterer + + * 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 * app/tools/gimpmeasuretool.c: fixed typo, closes bug #56200. diff --git a/app/core/gimpprojection.c b/app/core/gimpprojection.c index 86761fee47..3b92185670 100644 --- a/app/core/gimpprojection.c +++ b/app/core/gimpprojection.c @@ -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)); diff --git a/app/display/gimpdisplay.c b/app/display/gimpdisplay.c index 86761fee47..3b92185670 100644 --- a/app/display/gimpdisplay.c +++ b/app/display/gimpdisplay.c @@ -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)); diff --git a/app/gdisplay.c b/app/gdisplay.c index 86761fee47..3b92185670 100644 --- a/app/gdisplay.c +++ b/app/gdisplay.c @@ -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)); diff --git a/libgimp/gimpcolorselector.h b/libgimp/gimpcolorselector.h index 526d67c303..cdc98e94dd 100644 --- a/libgimp/gimpcolorselector.h +++ b/libgimp/gimpcolorselector.h @@ -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); diff --git a/libgimp/gimpdrawable.c b/libgimp/gimpdrawable.c index dbf39c86ff..9e694c4048 100644 --- a/libgimp/gimpdrawable.c +++ b/libgimp/gimpdrawable.c @@ -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); } } diff --git a/libgimp/gimpdrawable.h b/libgimp/gimpdrawable.h index f76894fad9..0a63bebe70 100644 --- a/libgimp/gimpdrawable.h +++ b/libgimp/gimpdrawable.h @@ -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 */ diff --git a/libgimp/gimpmenu.h b/libgimp/gimpmenu.h index 73f50e2983..d66bebac0b 100644 --- a/libgimp/gimpmenu.h +++ b/libgimp/gimpmenu.h @@ -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); diff --git a/libgimp/gimptile.c b/libgimp/gimptile.c index 51ce875eb5..42f49d97f5 100644 --- a/libgimp/gimptile.c +++ b/libgimp/gimptile.c @@ -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; diff --git a/plug-ins/FractalExplorer/FractalExplorer.c b/plug-ins/FractalExplorer/FractalExplorer.c index 61b067846b..ddbcf095b8 100644 --- a/plug-ins/FractalExplorer/FractalExplorer.c +++ b/plug-ins/FractalExplorer/FractalExplorer.c @@ -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); diff --git a/plug-ins/Lighting/lighting_apply.c b/plug-ins/Lighting/lighting_apply.c index 6ab1696348..0765ef0b34 100644 --- a/plug-ins/Lighting/lighting_apply.c +++ b/plug-ins/Lighting/lighting_apply.c @@ -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) { diff --git a/plug-ins/Lighting/lighting_image.c b/plug-ins/Lighting/lighting_image.c index b3f8aacc37..b74d6a18b9 100644 --- a/plug-ins/Lighting/lighting_image.c +++ b/plug-ins/Lighting/lighting_image.c @@ -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) diff --git a/plug-ins/Lighting/lighting_main.c b/plug-ins/Lighting/lighting_main.c index b0f2237191..f38792ed5d 100644 --- a/plug-ins/Lighting/lighting_main.c +++ b/plug-ins/Lighting/lighting_main.c @@ -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 */ /* ======================= */ diff --git a/plug-ins/MapObject/mapobject_apply.c b/plug-ins/MapObject/mapobject_apply.c index 579ca06a90..6e7e5a2baf 100644 --- a/plug-ins/MapObject/mapobject_apply.c +++ b/plug-ins/MapObject/mapobject_apply.c @@ -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) { diff --git a/plug-ins/MapObject/mapobject_image.c b/plug-ins/MapObject/mapobject_image.c index 583b60eb00..6e9c49e33e 100644 --- a/plug-ins/MapObject/mapobject_image.c +++ b/plug-ins/MapObject/mapobject_image.c @@ -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) diff --git a/plug-ins/MapObject/mapobject_main.c b/plug-ins/MapObject/mapobject_main.c index 4aaaa7b89e..b75983cb7d 100644 --- a/plug-ins/MapObject/mapobject_main.c +++ b/plug-ins/MapObject/mapobject_main.c @@ -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); diff --git a/plug-ins/common/AlienMap.c b/plug-ins/common/AlienMap.c index 69eb8b2787..3cf0feef4f 100644 --- a/plug-ins/common/AlienMap.c +++ b/plug-ins/common/AlienMap.c @@ -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); diff --git a/plug-ins/common/AlienMap2.c b/plug-ins/common/AlienMap2.c index 4cf78fb5e7..6553e3d26c 100644 --- a/plug-ins/common/AlienMap2.c +++ b/plug-ins/common/AlienMap2.c @@ -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); diff --git a/plug-ins/common/CML_explorer.c b/plug-ins/common/CML_explorer.c index b97c7d345e..474c56367f 100644 --- a/plug-ins/common/CML_explorer.c +++ b/plug-ins/common/CML_explorer.c @@ -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); } diff --git a/plug-ins/common/animationplay.c b/plug-ins/common/animationplay.c index cee156ecde..4e3e9f420a 100644 --- a/plug-ins/common/animationplay.c +++ b/plug-ins/common/animationplay.c @@ -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; diff --git a/plug-ins/common/animoptimize.c b/plug-ins/common/animoptimize.c index 3f10d85c1a..c125f0a920 100644 --- a/plug-ins/common/animoptimize.c +++ b/plug-ins/common/animoptimize.c @@ -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 (); } diff --git a/plug-ins/common/apply_lens.c b/plug-ins/common/apply_lens.c index 46a548354e..07e7daa0d1 100644 --- a/plug-ins/common/apply_lens.c +++ b/plug-ins/common/apply_lens.c @@ -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); diff --git a/plug-ins/common/autocrop.c b/plug-ins/common/autocrop.c index 156b50867f..d4c5d4d084 100644 --- a/plug-ins/common/autocrop.c +++ b/plug-ins/common/autocrop.c @@ -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...")); diff --git a/plug-ins/common/autostretch_hsv.c b/plug-ins/common/autostretch_hsv.c index d4ccf85858..b3d65855b6 100644 --- a/plug-ins/common/autostretch_hsv.c +++ b/plug-ins/common/autostretch_hsv.c @@ -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)); } diff --git a/plug-ins/common/blinds.c b/plug-ins/common/blinds.c index 8f2ad1af30..3b419d34c0 100644 --- a/plug-ins/common/blinds.c +++ b/plug-ins/common/blinds.c @@ -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); } diff --git a/plug-ins/common/blur.c b/plug-ins/common/blur.c index 35626fbbbf..77c0de4dfa 100644 --- a/plug-ins/common/blur.c +++ b/plug-ins/common/blur.c @@ -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. */ diff --git a/plug-ins/common/borderaverage.c b/plug-ins/common/borderaverage.c index bfa6593287..f3146af822 100644 --- a/plug-ins/common/borderaverage.c +++ b/plug-ins/common/borderaverage.c @@ -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. diff --git a/plug-ins/common/bumpmap.c b/plug-ins/common/bumpmap.c index 9d582b759d..58fbdbd21e 100644 --- a/plug-ins/common/bumpmap.c +++ b/plug-ins/common/bumpmap.c @@ -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; diff --git a/plug-ins/common/c_astretch.c b/plug-ins/common/c_astretch.c index 2b3f19db59..47d08cdf0d 100644 --- a/plug-ins/common/c_astretch.c +++ b/plug-ins/common/c_astretch.c @@ -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)); } diff --git a/plug-ins/common/checkerboard.c b/plug-ins/common/checkerboard.c index 612b0b4f3a..e9033245d1 100644 --- a/plug-ins/common/checkerboard.c +++ b/plug-ins/common/checkerboard.c @@ -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 diff --git a/plug-ins/common/color_enhance.c b/plug-ins/common/color_enhance.c index 1602164989..d08bfc3d8c 100644 --- a/plug-ins/common/color_enhance.c +++ b/plug-ins/common/color_enhance.c @@ -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)); } diff --git a/plug-ins/common/colorify.c b/plug-ins/common/colorify.c index 42c311dd26..007c70f491 100644 --- a/plug-ins/common/colorify.c +++ b/plug-ins/common/colorify.c @@ -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 diff --git a/plug-ins/common/colortoalpha.c b/plug-ins/common/colortoalpha.c index 549466c8d8..ba5a524615 100644 --- a/plug-ins/common/colortoalpha.c +++ b/plug-ins/common/colortoalpha.c @@ -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 diff --git a/plug-ins/common/convmatrix.c b/plug-ins/common/convmatrix.c index 1361ccd860..33dc15ff1c 100644 --- a/plug-ins/common/convmatrix.c +++ b/plug-ins/common/convmatrix.c @@ -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; diff --git a/plug-ins/common/cubism.c b/plug-ins/common/cubism.c index f6d7498220..b4a237247a 100644 --- a/plug-ins/common/cubism.c +++ b/plug-ins/common/cubism.c @@ -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); diff --git a/plug-ins/common/curve_bend.c b/plug-ins/common/curve_bend.c index 31d6b1322a..2c0ac0ad2f 100644 --- a/plug-ins/common/curve_bend.c +++ b/plug-ins/common/curve_bend.c @@ -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 */ diff --git a/plug-ins/common/deinterlace.c b/plug-ins/common/deinterlace.c index 3f2251a29f..c04b1610da 100644 --- a/plug-ins/common/deinterlace.c +++ b/plug-ins/common/deinterlace.c @@ -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); diff --git a/plug-ins/common/depthmerge.c b/plug-ins/common/depthmerge.c index be525cd749..b8b5d8007f 100644 --- a/plug-ins/common/depthmerge.c +++ b/plug-ins/common/depthmerge.c @@ -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; diff --git a/plug-ins/common/despeckle.c b/plug-ins/common/despeckle.c index 20aefb73ed..7041223211 100644 --- a/plug-ins/common/despeckle.c +++ b/plug-ins/common/despeckle.c @@ -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); } diff --git a/plug-ins/common/destripe.c b/plug-ins/common/destripe.c index 6c73e1747a..787fdaa484 100644 --- a/plug-ins/common/destripe.c +++ b/plug-ins/common/destripe.c @@ -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); diff --git a/plug-ins/common/diffraction.c b/plug-ins/common/diffraction.c index a6c2fbbc95..c8c8654cd0 100644 --- a/plug-ins/common/diffraction.c +++ b/plug-ins/common/diffraction.c @@ -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 diff --git a/plug-ins/common/displace.c b/plug-ins/common/displace.c index c7c0dc35a3..47a6a53b49 100644 --- a/plug-ins/common/displace.c +++ b/plug-ins/common/displace.c @@ -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 */ diff --git a/plug-ins/common/edge.c b/plug-ins/common/edge.c index be5c4da643..c62dbdf7e2 100644 --- a/plug-ins/common/edge.c +++ b/plug-ins/common/edge.c @@ -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)); } /*******************************************************/ diff --git a/plug-ins/common/emboss.c b/plug-ins/common/emboss.c index 2a949ebcd0..8ea5ec5958 100644 --- a/plug-ins/common/emboss.c +++ b/plug-ins/common/emboss.c @@ -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; diff --git a/plug-ins/common/engrave.c b/plug-ins/common/engrave.c index f6e13be8a2..31a0c4c2b5 100644 --- a/plug-ins/common/engrave.c +++ b/plug-ins/common/engrave.c @@ -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 diff --git a/plug-ins/common/exchange.c b/plug-ins/common/exchange.c index 641c41d189..7594358b09 100644 --- a/plug-ins/common/exchange.c +++ b/plug-ins/common/exchange.c @@ -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); } } diff --git a/plug-ins/common/film.c b/plug-ins/common/film.c index 31adfec706..e7eba67a96 100644 --- a/plug-ins/common/film.c +++ b/plug-ins/common/film.c @@ -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)) diff --git a/plug-ins/common/flarefx.c b/plug-ins/common/flarefx.c index 0192fb656f..3fdfecba46 100644 --- a/plug-ins/common/flarefx.c +++ b/plug-ins/common/flarefx.c @@ -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); diff --git a/plug-ins/common/fp.c b/plug-ins/common/fp.c index d12494a669..97f4f933f0 100644 --- a/plug-ins/common/fp.c +++ b/plug-ins/common/fp.c @@ -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); diff --git a/plug-ins/common/fractaltrace.c b/plug-ins/common/fractaltrace.c index 8ce420de5d..3846dd20e9 100644 --- a/plug-ins/common/fractaltrace.c +++ b/plug-ins/common/fractaltrace.c @@ -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); } diff --git a/plug-ins/common/gauss_iir.c b/plug-ins/common/gauss_iir.c index 25862cd901..0a00d5b3c3 100644 --- a/plug-ins/common/gauss_iir.c +++ b/plug-ins/common/gauss_iir.c @@ -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); diff --git a/plug-ins/common/gauss_rle.c b/plug-ins/common/gauss_rle.c index 12c06ae828..8536f7cd86 100644 --- a/plug-ins/common/gauss_rle.c +++ b/plug-ins/common/gauss_rle.c @@ -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); diff --git a/plug-ins/common/gee.c b/plug-ins/common/gee.c index de0306ac8b..e650053f08 100644 --- a/plug-ins/common/gee.c +++ b/plug-ins/common/gee.c @@ -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, diff --git a/plug-ins/common/gee_zoom.c b/plug-ins/common/gee_zoom.c index 2848f2959f..1fa3507eec 100644 --- a/plug-ins/common/gee_zoom.c +++ b/plug-ins/common/gee_zoom.c @@ -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, diff --git a/plug-ins/common/glasstile.c b/plug-ins/common/glasstile.c index bf20188505..74a23c6cf5 100644 --- a/plug-ins/common/glasstile.c +++ b/plug-ins/common/glasstile.c @@ -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); diff --git a/plug-ins/common/gqbist.c b/plug-ins/common/gqbist.c index 6eb8bc37d5..a0032d0686 100644 --- a/plug-ins/common/gqbist.c +++ b/plug-ins/common/gqbist.c @@ -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)); diff --git a/plug-ins/common/gradmap.c b/plug-ins/common/gradmap.c index 3689c92b3c..8173364533 100644 --- a/plug-ins/common/gradmap.c +++ b/plug-ins/common/gradmap.c @@ -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); diff --git a/plug-ins/common/grid.c b/plug-ins/common/grid.c index a0a286cd26..53bffa249d 100644 --- a/plug-ins/common/grid.c +++ b/plug-ins/common/grid.c @@ -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; diff --git a/plug-ins/common/hot.c b/plug-ins/common/hot.c index 339a9d686b..54e77e36ae 100644 --- a/plug-ins/common/hot.c +++ b/plug-ins/common/hot.c @@ -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 (); diff --git a/plug-ins/common/illusion.c b/plug-ins/common/illusion.c index 5feb377731..f18094c024 100644 --- a/plug-ins/common/illusion.c +++ b/plug-ins/common/illusion.c @@ -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; } diff --git a/plug-ins/common/iwarp.c b/plug-ins/common/iwarp.c index 975025dc12..6f84284abe 100644 --- a/plug-ins/common/iwarp.c +++ b/plug-ins/common/iwarp.c @@ -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; diff --git a/plug-ins/common/jigsaw.c b/plug-ins/common/jigsaw.c index 311b928903..0f6e530ef5 100644 --- a/plug-ins/common/jigsaw.c +++ b/plug-ins/common/jigsaw.c @@ -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); diff --git a/plug-ins/common/laplace.c b/plug-ins/common/laplace.c index 436320e1c1..d6ee0c42e8 100644 --- a/plug-ins/common/laplace.c +++ b/plug-ins/common/laplace.c @@ -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); diff --git a/plug-ins/common/lic.c b/plug-ins/common/lic.c index c520b358aa..7b11b3315b 100644 --- a/plug-ins/common/lic.c +++ b/plug-ins/common/lic.c @@ -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 (®ion, 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 (®ion, 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 (®ion, 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 */ /* ======================= */ diff --git a/plug-ins/common/mapcolor.c b/plug-ins/common/mapcolor.c index c362b5de6b..d59c7aa0c3 100644 --- a/plug-ins/common/mapcolor.c +++ b/plug-ins/common/mapcolor.c @@ -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)); } diff --git a/plug-ins/common/max_rgb.c b/plug-ins/common/max_rgb.c index 839cf3b34e..463473c0ed 100644 --- a/plug-ins/common/max_rgb.c +++ b/plug-ins/common/max_rgb.c @@ -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); diff --git a/plug-ins/common/mblur.c b/plug-ins/common/mblur.c index a218df0769..70c66ad665 100644 --- a/plug-ins/common/mblur.c +++ b/plug-ins/common/mblur.c @@ -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; diff --git a/plug-ins/common/mosaic.c b/plug-ins/common/mosaic.c index f40046b36d..0c0fcd62cc 100644 --- a/plug-ins/common/mosaic.c +++ b/plug-ins/common/mosaic.c @@ -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++) { diff --git a/plug-ins/common/newsprint.c b/plug-ins/common/newsprint.c index 05a521734c..d20a309183 100644 --- a/plug-ins/common/newsprint.c +++ b/plug-ins/common/newsprint.c @@ -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)); } diff --git a/plug-ins/common/nlfilt.c b/plug-ins/common/nlfilt.c index d434a35b4c..1fd6939b71 100644 --- a/plug-ins/common/nlfilt.c +++ b/plug-ins/common/nlfilt.c @@ -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; diff --git a/plug-ins/common/noisify.c b/plug-ins/common/noisify.c index ec5b5b15e5..1f76e199c4 100644 --- a/plug-ins/common/noisify.c +++ b/plug-ins/common/noisify.c @@ -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; diff --git a/plug-ins/common/normalize.c b/plug-ins/common/normalize.c index cceff9abf5..99b3094e2d 100644 --- a/plug-ins/common/normalize.c +++ b/plug-ins/common/normalize.c @@ -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)); } diff --git a/plug-ins/common/nova.c b/plug-ins/common/nova.c index e6d83b53e6..1d173fe6ed 100644 --- a/plug-ins/common/nova.c +++ b/plug-ins/common/nova.c @@ -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" diff --git a/plug-ins/common/oilify.c b/plug-ins/common/oilify.c index 88ad1ff01b..2e7cf50686 100644 --- a/plug-ins/common/oilify.c +++ b/plug-ins/common/oilify.c @@ -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 diff --git a/plug-ins/common/papertile.c b/plug-ins/common/papertile.c index eb87667bb2..154d917239 100644 --- a/plug-ins/common/papertile.c +++ b/plug-ins/common/papertile.c @@ -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) { diff --git a/plug-ins/common/pixelize.c b/plug-ins/common/pixelize.c index 4051ea57ca..1f37723b67 100644 --- a/plug-ins/common/pixelize.c +++ b/plug-ins/common/pixelize.c @@ -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)); } /* diff --git a/plug-ins/common/plasma.c b/plug-ins/common/plasma.c index 3604566ed6..7ec210af8a 100644 --- a/plug-ins/common/plasma.c +++ b/plug-ins/common/plasma.c @@ -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)); } } diff --git a/plug-ins/common/polar.c b/plug-ins/common/polar.c index 3490738f4e..cde9b7ccbc 100644 --- a/plug-ins/common/polar.c +++ b/plug-ins/common/polar.c @@ -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; diff --git a/plug-ins/common/psd.c b/plug-ins/common/psd.c index 554de002b6..cb04a3dafb 100644 --- a/plug-ins/common/psd.c +++ b/plug-ins/common/psd.c @@ -2155,7 +2155,7 @@ load_image(char *name) } else { - channels = gimp_drawable_bpp(drawable->id); + channels = gimp_drawable_bpp(drawable->drawable_id); } diff --git a/plug-ins/common/randomize.c b/plug-ins/common/randomize.c index 3657beda75..901003d75d 100644 --- a/plug-ins/common/randomize.c +++ b/plug-ins/common/randomize.c @@ -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. */ diff --git a/plug-ins/common/ripple.c b/plug-ins/common/ripple.c index ca24f86ef9..119195dadc 100644 --- a/plug-ins/common/ripple.c +++ b/plug-ins/common/ripple.c @@ -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 diff --git a/plug-ins/common/rotate.c b/plug-ins/common/rotate.c index 74f026247e..0825e2fe67 100644 --- a/plug-ins/common/rotate.c +++ b/plug-ins/common/rotate.c @@ -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); diff --git a/plug-ins/common/sample_colorize.c b/plug-ins/common/sample_colorize.c index e8f5abc7a3..74f5abd791 100644 --- a/plug-ins/common/sample_colorize.c +++ b/plug-ins/common/sample_colorize.c @@ -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) diff --git a/plug-ins/common/scatter_hsv.c b/plug-ins/common/scatter_hsv.c index ea14441226..2e3c024853 100644 --- a/plug-ins/common/scatter_hsv.c +++ b/plug-ins/common/scatter_hsv.c @@ -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; diff --git a/plug-ins/common/sel_gauss.c b/plug-ins/common/sel_gauss.c index 31287efc0a..c9de781ca2 100644 --- a/plug-ins/common/sel_gauss.c +++ b/plug-ins/common/sel_gauss.c @@ -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); diff --git a/plug-ins/common/semiflatten.c b/plug-ins/common/semiflatten.c index 2b54fd9ef4..9889c9936d 100644 --- a/plug-ins/common/semiflatten.c +++ b/plug-ins/common/semiflatten.c @@ -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); diff --git a/plug-ins/common/sharpen.c b/plug-ins/common/sharpen.c index f8541c0c07..00624b5848 100644 --- a/plug-ins/common/sharpen.c +++ b/plug-ins/common/sharpen.c @@ -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); } diff --git a/plug-ins/common/shift.c b/plug-ins/common/shift.c index 124c158287..3ad079ed93 100644 --- a/plug-ins/common/shift.c +++ b/plug-ins/common/shift.c @@ -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)); } diff --git a/plug-ins/common/sinus.c b/plug-ins/common/sinus.c index 1f18a253c6..743d96c656 100644 --- a/plug-ins/common/sinus.c +++ b/plug-ins/common/sinus.c @@ -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 diff --git a/plug-ins/common/smooth_palette.c b/plug-ins/common/smooth_palette.c index f35b533686..3ef821c36d 100644 --- a/plug-ins/common/smooth_palette.c +++ b/plug-ins/common/smooth_palette.c @@ -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; diff --git a/plug-ins/common/snoise.c b/plug-ins/common/snoise.c index 18b61ad71a..65e38689e5 100644 --- a/plug-ins/common/snoise.c +++ b/plug-ins/common/snoise.c @@ -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); } diff --git a/plug-ins/common/sobel.c b/plug-ins/common/sobel.c index 6bff81c3c7..4d36d97314 100644 --- a/plug-ins/common/sobel.c +++ b/plug-ins/common/sobel.c @@ -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); diff --git a/plug-ins/common/sparkle.c b/plug-ins/common/sparkle.c index 3e56d09230..fbe64c0b4c 100644 --- a/plug-ins/common/sparkle.c +++ b/plug-ins/common/sparkle.c @@ -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 * diff --git a/plug-ins/common/spread.c b/plug-ins/common/spread.c index 8e05ddba17..3907573d2f 100644 --- a/plug-ins/common/spread.c +++ b/plug-ins/common/spread.c @@ -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 */ diff --git a/plug-ins/common/struc.c b/plug-ins/common/struc.c index 4e29d37abe..a34bc35c6d 100644 --- a/plug-ins/common/struc.c +++ b/plug-ins/common/struc.c @@ -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); diff --git a/plug-ins/common/threshold_alpha.c b/plug-ins/common/threshold_alpha.c index b95d109665..003ff26d50 100644 --- a/plug-ins/common/threshold_alpha.c +++ b/plug-ins/common/threshold_alpha.c @@ -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; diff --git a/plug-ins/common/tileit.c b/plug-ins/common/tileit.c index 737e16f633..37033b48c2 100644 --- a/plug-ins/common/tileit.c +++ b/plug-ins/common/tileit.c @@ -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); } diff --git a/plug-ins/common/tiler.c b/plug-ins/common/tiler.c index 664a3eafda..ced1be981e 100644 --- a/plug-ins/common/tiler.c +++ b/plug-ins/common/tiler.c @@ -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)); } diff --git a/plug-ins/common/unsharp.c b/plug-ins/common/unsharp.c index 67eb643311..7d10b11111 100644 --- a/plug-ins/common/unsharp.c +++ b/plug-ins/common/unsharp.c @@ -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. diff --git a/plug-ins/common/video.c b/plug-ins/common/video.c index cb996ce607..549a680ad5 100644 --- a/plug-ins/common/video.c +++ b/plug-ins/common/video.c @@ -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); diff --git a/plug-ins/common/vinvert.c b/plug-ins/common/vinvert.c index e93ffe9062..129c64522c 100644 --- a/plug-ins/common/vinvert.c +++ b/plug-ins/common/vinvert.c @@ -123,7 +123,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)) { if (run_mode != GIMP_RUN_NONINTERACTIVE) { @@ -136,7 +136,7 @@ run (char *name, gimp_displays_flush (); } else - if (gimp_drawable_is_indexed (drawable->id)) + if (gimp_drawable_is_indexed (drawable->drawable_id)) { indexed_vinvert (image_ID); if (run_mode != GIMP_RUN_NONINTERACTIVE) @@ -248,7 +248,7 @@ vinvert (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; @@ -276,6 +276,6 @@ vinvert (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)); } diff --git a/plug-ins/common/vpropagate.c b/plug-ins/common/vpropagate.c index 15cfb5b851..0a0bec38a0 100644 --- a/plug-ins/common/vpropagate.c +++ b/plug-ins/common/vpropagate.c @@ -340,7 +340,7 @@ value_propagate_body (gint drawable_id) dtype = gimp_drawable_type (drawable_id); /* Here I use the algorithm of blur.c . */ - gimp_drawable_mask_bounds (drawable->id, &begx, &begy, &endx, &endy); + gimp_drawable_mask_bounds (drawable->drawable_id, &begx, &begy, &endx, &endy); width = drawable->width; height = drawable->height; @@ -408,8 +408,8 @@ value_propagate_body (gint drawable_id) /* update the region */ gimp_progress_update(1.0); gimp_drawable_flush (drawable); - gimp_drawable_merge_shadow (drawable->id, TRUE); - gimp_drawable_update (drawable->id, begx, begy, endx-begx, endy-begy); + gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); + gimp_drawable_update (drawable->drawable_id, begx, begy, endx-begx, endy-begy); } static void diff --git a/plug-ins/common/warp.c b/plug-ins/common/warp.c index 7757f9a3bd..62a4c806f4 100644 --- a/plug-ins/common/warp.c +++ b/plug-ins/common/warp.c @@ -384,7 +384,7 @@ run (gchar *name, values[0].data.d_status = status; - image_ID = gimp_layer_get_image_id (map_x->id); + image_ID = gimp_layer_get_image_id (map_x->drawable_id); gimp_drawable_detach (map_x); gimp_drawable_detach (map_y); @@ -733,7 +733,7 @@ blur16 (GimpDrawable *drawable) /* --------------------------------------- */ - gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2); + gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); width = drawable->width; /* size of input drawable*/ height = drawable->height; @@ -802,8 +802,8 @@ blur16 (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)); free (prev_row); /* row buffers allocated at top of fn. */ free (cur_row); @@ -904,7 +904,7 @@ diff (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. @@ -912,14 +912,14 @@ diff (GimpDrawable *drawable, width = drawable->width; height = drawable->height; src_bytes = drawable->bpp; /* bytes per pixel in SOURCE drawable */ - has_alpha = gimp_drawable_has_alpha(drawable->id); + has_alpha = gimp_drawable_has_alpha(drawable->drawable_id); /* -- Add two layers: X and Y Displacement vectors -- */ /* -- I'm using a RGB drawable and using the first two bytes for a 16-bit pixel value. This is either clever, or a kluge, depending on your point of view. */ - image_id = gimp_layer_get_image_id(drawable->id); + image_id = gimp_layer_get_image_id(drawable->drawable_id); layer_active = gimp_image_get_active_layer(image_id); new_image_id = gimp_image_new(width, height, GIMP_RGB); /* create new image for X,Y diff */ @@ -1141,8 +1141,8 @@ diff (GimpDrawable *drawable, gimp_drawable_flush (draw_xd); gimp_drawable_flush (draw_yd); - gimp_drawable_update (draw_xd->id, x1, y1, (x2 - x1), (y2 - y1)); - gimp_drawable_update (draw_yd->id, x1, y1, (x2 - x1), (y2 - y1)); + gimp_drawable_update (draw_xd->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); + gimp_drawable_update (draw_yd->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); /* if (display_diff_map) { @@ -1214,17 +1214,17 @@ warp (GimpDrawable *orig_draw, diff(disp_map, &xdlayer, &ydlayer); /* generate x,y differential images (arrays) */ /* Get selection area */ - gimp_drawable_mask_bounds (orig_draw->id, &x1, &y1, &x2, &y2); + gimp_drawable_mask_bounds (orig_draw->drawable_id, &x1, &y1, &x2, &y2); width = orig_draw->width; height = orig_draw->height; bytes = orig_draw->bpp; - image_type = gimp_drawable_type(orig_draw->id); + image_type = gimp_drawable_type(orig_draw->drawable_id); *map_x = gimp_drawable_get(xdlayer); *map_y = gimp_drawable_get(ydlayer); - orig_image_id = gimp_layer_get_image_id(orig_draw->id); + orig_image_id = gimp_layer_get_image_id(orig_draw->drawable_id); /* gimp_image_lower_layer(orig_image_id, new_layer_id); */ /* hide it! */ @@ -1241,7 +1241,7 @@ warp (GimpDrawable *orig_draw, } warp_one(orig_draw, orig_draw, *map_x, *map_y, mag_draw, first_time, warp_iter); - gimp_drawable_update (orig_draw->id, x1, y1, (x2 - x1), (y2 - y1)); + gimp_drawable_update (orig_draw->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); if (run_mode != GIMP_RUN_NONINTERACTIVE) gimp_displays_flush(); @@ -1329,7 +1329,7 @@ warp_one (GimpDrawable *draw, /* Get selection area */ - gimp_drawable_mask_bounds (draw->id, &x1, &y1, &x2, &y2); + gimp_drawable_mask_bounds (draw->drawable_id, &x1, &y1, &x2, &y2); width = draw->width; height = draw->height; dest_bytes = draw->bpp; @@ -1352,21 +1352,21 @@ warp_one (GimpDrawable *draw, 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); 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); if (dvals.mag_use == TRUE) { gimp_pixel_rgn_init (&mag_rgn, mag_draw, x1, y1, (x2 - x1), (y2 - y1), FALSE, FALSE); - if (gimp_drawable_has_alpha(mag_draw->id)) + if (gimp_drawable_has_alpha(mag_draw->drawable_id)) mmag_alpha = 1; - mmag_bytes = gimp_drawable_bpp(mag_draw->id); + mmag_bytes = gimp_drawable_bpp(mag_draw->drawable_id); pr = gimp_pixel_rgns_register (5, &src_rgn, &dest_rgn, &map_x_rgn, &map_y_rgn, &mag_rgn); } else { @@ -1529,7 +1529,7 @@ warp_one (GimpDrawable *draw, /* update the region */ gimp_drawable_flush (new); - gimp_drawable_merge_shadow(draw->id, (first_time == TRUE)); + gimp_drawable_merge_shadow(draw->drawable_id, (first_time == TRUE)); } /* warp_one */ diff --git a/plug-ins/common/waves.c b/plug-ins/common/waves.c index f2066bfd92..31fcacbc3b 100644 --- a/plug-ins/common/waves.c +++ b/plug-ins/common/waves.c @@ -274,8 +274,8 @@ pluginCore (struct piArgs *argp, g_free (dst); 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 (); diff --git a/plug-ins/common/whirlpinch.c b/plug-ins/common/whirlpinch.c index 8cd10084cc..abcb692108 100644 --- a/plug-ins/common/whirlpinch.c +++ b/plug-ins/common/whirlpinch.c @@ -234,12 +234,13 @@ run (gchar *name, /* Get the active drawable info */ 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 */ @@ -329,8 +330,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) / @@ -510,8 +511,9 @@ whirl_pinch (void) g_free (bot_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 gint @@ -606,10 +608,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; diff --git a/plug-ins/common/wind.c b/plug-ins/common/wind.c index 7187936ac7..0169178afe 100644 --- a/plug-ins/common/wind.c +++ b/plug-ins/common/wind.c @@ -415,7 +415,7 @@ render_blast (GimpDrawable *drawable, else { gimp_progress_init( _("Rendering Blast...")); - 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; @@ -501,8 +501,8 @@ render_blast (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); } return; @@ -546,7 +546,7 @@ render_wind (GimpDrawable *drawable, else { gimp_progress_init( _("Rendering Wind...")); - gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2); + gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); bytes = drawable->bpp; width = x2 - x1; @@ -605,8 +605,8 @@ render_wind (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); } return; @@ -1199,7 +1199,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; @@ -1209,7 +1209,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; diff --git a/plug-ins/common/zealouscrop.c b/plug-ins/common/zealouscrop.c index d4743c291f..0509731774 100644 --- a/plug-ins/common/zealouscrop.c +++ b/plug-ins/common/zealouscrop.c @@ -111,9 +111,9 @@ run (gchar *name, image_id = param[1].data.d_image; /* Make sure that the drawable is gray or RGB or indexed */ - 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)) { gimp_progress_init (_("ZealousCropping(tm)...")); @@ -264,7 +264,7 @@ do_zcrop (GimpDrawable *drawable, gimp_progress_update(1.00); gimp_undo_push_group_start (image_id); gimp_drawable_flush (drawable); - gimp_drawable_merge_shadow (drawable->id, TRUE); + gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_crop (image_id, livingcols, livingrows, 0, 0); gimp_undo_push_group_end (image_id); } diff --git a/plug-ins/flame/flame.c b/plug-ins/flame/flame.c index 161325f1ec..011168a22b 100644 --- a/plug-ins/flame/flame.c +++ b/plug-ins/flame/flame.c @@ -220,7 +220,7 @@ run (gchar *name, if (status == GIMP_PDB_SUCCESS) { - if (gimp_drawable_is_rgb (drawable->id)) + if (gimp_drawable_is_rgb (drawable->drawable_id)) { gimp_progress_init (_("Drawing Flame...")); gimp_tile_cache_ntiles (2 * (drawable->width / @@ -365,8 +365,8 @@ doit (GimpDrawable *drawable) g_free (tmp); 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); } diff --git a/plug-ins/fp/fp.c b/plug-ins/fp/fp.c index d12494a669..97f4f933f0 100644 --- a/plug-ins/fp/fp.c +++ b/plug-ins/fp/fp.c @@ -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); diff --git a/plug-ins/fp/fp_misc.c b/plug-ins/fp/fp_misc.c index ced6725261..61db67feb0 100644 --- a/plug-ins/fp/fp_misc.c +++ b/plug-ins/fp/fp_misc.c @@ -49,7 +49,7 @@ ReducedImage *Reduce_The_Image(GimpDrawable *drawable, gint NoSelectionMade=TRUE; hsv *tempHSV, H, S, V; - 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; diff --git a/plug-ins/gap/gap_filter_pdb.c b/plug-ins/gap/gap_filter_pdb.c index 5b05c37158..d64cd76359 100644 --- a/plug-ins/gap/gap_filter_pdb.c +++ b/plug-ins/gap/gap_filter_pdb.c @@ -151,7 +151,7 @@ gint p_call_plugin(char *plugin_name, gint32 image_id, gint32 layer_id, GimpRunM /* init the standard parameters, that should be common to all plugins */ l_argv[0].data.d_int32 = run_mode; l_argv[1].data.d_image = image_id; - l_argv[2].data.d_drawable = l_drawable->id; + l_argv[2].data.d_drawable = l_drawable->drawable_id; /* run the plug-in procedure */ l_ret_params = gimp_run_procedure2 (plugin_name, &l_retvals, l_nparams, l_argv); diff --git a/plug-ins/gap/gap_lib.c b/plug-ins/gap/gap_lib.c index 67479897f8..2092267492 100644 --- a/plug-ins/gap/gap_lib.c +++ b/plug-ins/gap/gap_lib.c @@ -1088,12 +1088,12 @@ gint32 p_save_named_image(gint32 image_id, char *sav_name, GimpRunModeType run_m &l_retvals, GIMP_PDB_INT32, run_mode, GIMP_PDB_IMAGE, image_id, - GIMP_PDB_DRAWABLE, l_drawable->id, + GIMP_PDB_DRAWABLE, l_drawable->drawable_id, GIMP_PDB_STRING, sav_name, GIMP_PDB_STRING, sav_name, /* raw name ? */ GIMP_PDB_END); - if(gap_debug) fprintf(stderr, "DEBUG: after p_save_named_image: '%s' nlayers=%d image=%d drw=%d run_mode=%d\n", sav_name, (int)l_nlayers, (int)image_id, (int)l_drawable->id, (int)run_mode); + if(gap_debug) fprintf(stderr, "DEBUG: after p_save_named_image: '%s' nlayers=%d image=%d drw=%d run_mode=%d\n", sav_name, (int)l_nlayers, (int)image_id, (int)l_drawable->drawable_id, (int)run_mode); p_gimp_file_save_thumbnail(image_id, sav_name); diff --git a/plug-ins/gap/gap_mov_dialog.c b/plug-ins/gap/gap_mov_dialog.c index 1fc7e08f48..df159678c4 100644 --- a/plug-ins/gap/gap_mov_dialog.c +++ b/plug-ins/gap/gap_mov_dialog.c @@ -1798,10 +1798,10 @@ mov_path_prevw_create ( GimpDrawable *drawable, t_mov_path_preview *path_ptr) gint row; path_ptr->drawable = drawable; - path_ptr->dwidth = gimp_drawable_width(drawable->id ); - path_ptr->dheight = gimp_drawable_height(drawable->id ); - path_ptr->bpp = gimp_drawable_bpp(drawable->id); - if ( gimp_drawable_has_alpha(drawable->id) ) + path_ptr->dwidth = gimp_drawable_width(drawable->drawable_id ); + path_ptr->dheight = gimp_drawable_height(drawable->drawable_id ); + path_ptr->bpp = gimp_drawable_bpp(drawable->drawable_id); + if ( gimp_drawable_has_alpha(drawable->drawable_id) ) path_ptr->bpp--; path_ptr->cursor = FALSE; path_ptr->curx = 0; @@ -2297,7 +2297,7 @@ render_preview ( GtkWidget *preview, GimpPixelRgn *srcrgn ) bpp = srcrgn->bpp; alpha = bpp; - has_alpha = gimp_drawable_has_alpha( srcrgn->drawable->id ); + has_alpha = gimp_drawable_has_alpha( srcrgn->drawable->drawable_id ); if( has_alpha ) alpha--; /* printf("render_preview: %d %d %d", bpp, alpha, has_alpha); printf(" (%d %d %d %d)\n", dwidth, dheight, pwidth, pheight); */ diff --git a/plug-ins/gfig/gfig.c b/plug-ins/gfig/gfig.c index 242b3c47ff..0d8c4f4467 100644 --- a/plug-ins/gfig/gfig.c +++ b/plug-ins/gfig/gfig.c @@ -712,7 +712,8 @@ run (gchar *name, /* TMP Hack - clear any selections */ gimp_selection_clear (gfig_image); - 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; @@ -762,8 +763,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 */ gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width () - 1) / @@ -1637,9 +1638,9 @@ cache_preview (void) src_rows = g_new (guchar , sel_width * 4); p = pv_cache = g_new (guchar , preview_width * preview_height * 4); - real_img_bpp = gimp_drawable_bpp (gfig_select_drawable->id); + real_img_bpp = gimp_drawable_bpp (gfig_select_drawable->drawable_id); - has_alpha = gimp_drawable_has_alpha (gfig_select_drawable->id); + has_alpha = gimp_drawable_has_alpha (gfig_select_drawable->drawable_id); if (real_img_bpp < 3) { @@ -1650,7 +1651,7 @@ cache_preview (void) img_bpp = real_img_bpp; } - switch (gimp_drawable_type (gfig_select_drawable->id)) + switch (gimp_drawable_type (gfig_select_drawable->drawable_id)) { case GIMP_GRAYA_IMAGE: case GIMP_GRAY_IMAGE: @@ -3917,8 +3918,8 @@ gfig_dialog (void) /*cache_preview (); Get the preview image and store it also set has_alpha */ - img_width = gimp_drawable_width (gfig_select_drawable->id); - img_height = gimp_drawable_height (gfig_select_drawable->id); + img_width = gimp_drawable_width (gfig_select_drawable->drawable_id); + img_height = gimp_drawable_height (gfig_select_drawable->drawable_id); /* Start buildng the dialog up */ top_level_dlg = gimp_dialog_new (_("GFig"), "gfig", @@ -4643,7 +4644,7 @@ paint_layer_new (gchar *new_name) gint32 fill_type; int isgrey = 0; - switch (gimp_drawable_type (gfig_select_drawable->id)) + switch (gimp_drawable_type (gfig_select_drawable->drawable_id)) { case GIMP_GRAYA_IMAGE: case GIMP_GRAY_IMAGE: diff --git a/plug-ins/gflare/gflare.c b/plug-ins/gflare/gflare.c index 5c0b3baf6d..6cffd55518 100644 --- a/plug-ins/gflare/gflare.c +++ b/plug-ins/gflare/gflare.c @@ -858,9 +858,9 @@ plugin_run (gchar *name, image_ID = param[1].data.d_image; drawable = gimp_drawable_get (param[2].data.d_drawable); - dinfo.is_color = gimp_drawable_is_rgb (drawable->id); - dinfo.has_alpha = gimp_drawable_has_alpha (drawable->id); - gimp_drawable_mask_bounds (drawable->id, &dinfo.x1, &dinfo.y1, + dinfo.is_color = gimp_drawable_is_rgb (drawable->drawable_id); + dinfo.has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); + gimp_drawable_mask_bounds (drawable->drawable_id, &dinfo.x1, &dinfo.y1, &dinfo.x2, &dinfo.y2); dinfo.tile_width = gimp_tile_width (); dinfo.tile_height = gimp_tile_height (); @@ -938,8 +938,8 @@ plugin_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 (_("Gradient Flare...")); plugin_do (); @@ -1055,8 +1055,8 @@ plugin_do (void) /* Clean up */ calc_deinit (); gimp_drawable_flush (drawable); - gimp_drawable_merge_shadow (drawable->id, TRUE); - gimp_drawable_update (drawable->id, dinfo.x1, dinfo.y1, + gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); + gimp_drawable_update (drawable->drawable_id, dinfo.x1, dinfo.y1, (dinfo.x2 - dinfo.x1), (dinfo.y2 - dinfo.y1)); } @@ -2877,11 +2877,11 @@ dlg_make_page_settings (GFlareDialog *dlg, _("X:"), pvals.xcenter, xres, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, - 0, gimp_drawable_width (drawable->id), + 0, gimp_drawable_width (drawable->drawable_id), _("Y:"), pvals.ycenter, yres, -GIMP_MAX_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE, - 0, gimp_drawable_height (drawable->id)); + 0, gimp_drawable_height (drawable->drawable_id)); chain = GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (center)); diff --git a/plug-ins/gimpressionist/brush.c b/plug-ins/gimpressionist/brush.c index 89aa48c2a6..090c56ee79 100644 --- a/plug-ins/gimpressionist/brush.c +++ b/plug-ins/gimpressionist/brush.c @@ -69,10 +69,10 @@ void brushdmenuselect(gint32 id, gpointer data) drawable = gimp_drawable_get(id); - 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); alpha = (has_alpha) ? bpp - 1 : bpp; if(brushppm.col) diff --git a/plug-ins/gimpressionist/gimp.c b/plug-ins/gimpressionist/gimp.c index 1cfe182700..f3671c15a9 100644 --- a/plug-ins/gimpressionist/gimp.c +++ b/plug-ins/gimpressionist/gimp.c @@ -140,12 +140,13 @@ run(char *name, int nparams, GimpParam *param, int *nreturn_vals, GimpParam **re 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); switch (run_mode) { case GIMP_RUN_INTERACTIVE: @@ -168,7 +169,7 @@ run(char *name, int nparams, GimpParam *param, int *nreturn_vals, GimpParam **re status = GIMP_PDB_EXECUTION_ERROR; break; } - 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))) { gimpressionist_main(); gimp_displays_flush (); @@ -200,10 +201,10 @@ void grabarea(void) return; } - 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); alpha = (has_alpha) ? bpp - 1 : bpp; newppm(&infile, x2-x1, y2-y1); @@ -283,10 +284,10 @@ void gimpressionist_main(void) gint row, col; int rowstride; - 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); alpha = (has_alpha) ? bpp - 1 : bpp; dest_row = g_new (guchar, (x2 - x1) * bpp); @@ -373,6 +374,6 @@ void gimpressionist_main(void) g_free (dest_row); 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)); } diff --git a/plug-ins/ifscompose/ifscompose.c b/plug-ins/ifscompose/ifscompose.c index 6f5a140179..ea1ee7061b 100644 --- a/plug-ins/ifscompose/ifscompose.c +++ b/plug-ins/ifscompose/ifscompose.c @@ -401,7 +401,7 @@ run (gchar *name, /* Possibly retrieve data; first look for a parasite - * if not found, fall back to global values */ - parasite = gimp_drawable_parasite_find (active_drawable->id, + parasite = gimp_drawable_parasite_find (active_drawable->drawable_id, IFSCOMPOSE_PARASITE); found_parasite = FALSE; if (parasite) @@ -465,8 +465,8 @@ run (gchar *name, /* Render the fractal */ 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 operation works well */ gimp_tile_cache_ntiles (2 * (MAX (active_drawable->width, active_drawable->height) / @@ -492,7 +492,7 @@ run (gchar *name, GIMP_PARASITE_PERSISTENT | GIMP_PARASITE_UNDOABLE, strlen(str)+1, str); - gimp_drawable_parasite_attach (active_drawable->id, parasite); + gimp_drawable_parasite_attach (active_drawable->drawable_id, parasite); gimp_parasite_free (parasite); g_free (str); @@ -1326,7 +1326,7 @@ ifs_options_dialog (void) static void ifs_compose (GimpDrawable *drawable) { - GimpImageType type = gimp_drawable_type (drawable->id); + GimpImageType type = gimp_drawable_type (drawable->drawable_id); gchar *buffer; gint width = drawable->width; gint height = drawable->height; @@ -1479,8 +1479,8 @@ ifs_compose (GimpDrawable *drawable) g_free(nhits); 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); } static void diff --git a/plug-ins/imagemap/imap_main.c b/plug-ins/imagemap/imap_main.c index 8ac04579ce..19cdef5025 100644 --- a/plug-ins/imagemap/imap_main.c +++ b/plug-ins/imagemap/imap_main.c @@ -169,7 +169,7 @@ run(char *name, int n_params, GimpParam *param, int *nreturn_vals, _image_width = gimp_image_width(param[1].data.d_image); _image_height = gimp_image_height(param[1].data.d_image); - _map_info.color = gimp_drawable_is_rgb(drawable->id); + _map_info.color = gimp_drawable_is_rgb(drawable->drawable_id); run_mode = (GimpRunModeType) param[0].data.d_int32; diff --git a/plug-ins/imagemap/imap_preview.c b/plug-ins/imagemap/imap_preview.c index 489c0e38cf..9775865737 100644 --- a/plug-ins/imagemap/imap_preview.c +++ b/plug-ins/imagemap/imap_preview.c @@ -141,11 +141,11 @@ render_indexed_image(GtkWidget *preview, GimpPixelRgn *srcrgn) } bpp = srcrgn->bpp; alpha = bpp; - has_alpha = gimp_drawable_has_alpha(srcrgn->drawable->id); + has_alpha = gimp_drawable_has_alpha(srcrgn->drawable->drawable_id); if (has_alpha) alpha--; - cmap = gimp_image_get_cmap(gimp_drawable_image_id(srcrgn->drawable->id), + cmap = gimp_image_get_cmap(gimp_drawable_image_id(srcrgn->drawable->drawable_id), &ncols); src_row = g_new(guchar, dwidth * bpp); @@ -204,7 +204,7 @@ render_rgb_image(GtkWidget *preview, GimpPixelRgn *srcrgn) } bpp = srcrgn->bpp; alpha = bpp; - has_alpha = gimp_drawable_has_alpha(srcrgn->drawable->id); + has_alpha = gimp_drawable_has_alpha(srcrgn->drawable->drawable_id); if (has_alpha) alpha--; @@ -262,7 +262,7 @@ render_rgb_image(GtkWidget *preview, GimpPixelRgn *srcrgn) static void render_preview(GtkWidget *preview, GimpPixelRgn *srcrgn) { - switch (gimp_drawable_type(srcrgn->drawable->id)) { + switch (gimp_drawable_type(srcrgn->drawable->drawable_id)) { case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE: render_rgb_image(preview, srcrgn); @@ -414,8 +414,8 @@ make_preview(GimpDrawable *drawable) gtk_signal_connect(GTK_OBJECT(preview), "drag_data_received", GTK_SIGNAL_FUNC(handle_drop), NULL); - data->width = gimp_drawable_width(drawable->id); - data->height = gimp_drawable_height(drawable->id); + data->width = gimp_drawable_width(drawable->drawable_id); + data->height = gimp_drawable_height(drawable->drawable_id); gtk_preview_size(GTK_PREVIEW(preview), data->width, data->height); data->window = window = gtk_scrolled_window_new(NULL, NULL); diff --git a/plug-ins/maze/handy.c b/plug-ins/maze/handy.c index f2d2c8b0b8..615c17f13c 100644 --- a/plug-ins/maze/handy.c +++ b/plug-ins/maze/handy.c @@ -59,7 +59,7 @@ get_colors (GimpDrawable *drawable, fg[0] = fg[1] = fg[2] = fg[3] = 255; bg[0] = bg[1] = bg[2] = bg[3] = 255; - switch ( gimp_drawable_type (drawable->id) ) + switch ( gimp_drawable_type (drawable->drawable_id) ) { case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE: diff --git a/plug-ins/maze/maze.c b/plug-ins/maze/maze.c index 8a006a60c2..9f1c55690d 100644 --- a/plug-ins/maze/maze.c +++ b/plug-ins/maze/maze.c @@ -201,7 +201,7 @@ run (gchar *name, gimp_get_data ("plug_in_maze", &mvals); /* The interface needs to know the dimensions of the image... */ - gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2); + gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); sel_w=x2-x1; sel_h=y2-y1; /* Acquire info with a dialog */ @@ -237,19 +237,23 @@ run (gchar *name, } /* color, gray, or indexed... hmm, miss anything? ;) */ - 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)) + { maze (drawable); - + if (run_mode != GIMP_RUN_NONINTERACTIVE) - gimp_displays_flush (); - + gimp_displays_flush (); + if (run_mode == GIMP_RUN_INTERACTIVE || (mvals.timeseed && run_mode == GIMP_RUN_WITH_LAST_VALS)) - gimp_set_data ("plug_in_maze", &mvals, sizeof (MazeValues)); - } else { + gimp_set_data ("plug_in_maze", &mvals, sizeof (MazeValues)); + } + else + { status = GIMP_PDB_EXECUTION_ERROR; - } + } values[0].data.d_status = status; @@ -302,7 +306,8 @@ maze( GimpDrawable * drawable) guint pos; /* Gets the input area... */ - active_selection = gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2); + active_selection = gimp_drawable_mask_bounds (drawable->drawable_id, + &x1, &y1, &x2, &y2); /***************** Maze Stuff Happens Here ***************/ @@ -356,7 +361,7 @@ maze( GimpDrawable * drawable) } else { /* not tileable */ if (active_selection) { /* Mask and draw mazes until there's no * more room left. */ - mask_maze(drawable->id, + mask_maze(drawable->drawable_id, maz, mw, mh, x1, x2, y1, y2, deadx, deady); for(maz_yy=mw; maz_yy < (mh*mw); maz_yy += 2*mw) { for(maz_xx=1; maz_xx < mw; maz_xx += 2) { @@ -451,8 +456,8 @@ maze( GimpDrawable * drawable) /* Indicate progress in drawing. */ } 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)); } /* Shaped mazes: */ diff --git a/plug-ins/mosaic/mosaic.c b/plug-ins/mosaic/mosaic.c index f40046b36d..0c0fcd62cc 100644 --- a/plug-ins/mosaic/mosaic.c +++ b/plug-ins/mosaic/mosaic.c @@ -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++) { diff --git a/plug-ins/pagecurl/pagecurl.c b/plug-ins/pagecurl/pagecurl.c index 8122c04502..82c0bb9964 100644 --- a/plug-ins/pagecurl/pagecurl.c +++ b/plug-ins/pagecurl/pagecurl.c @@ -252,9 +252,9 @@ run (gchar *name, drawable = gimp_drawable_get (param[2].data.d_drawable); image_id = param[1].data.d_image; - if ((gimp_drawable_is_rgb (drawable->id) - || gimp_drawable_is_gray (drawable->id)) - && gimp_drawable_has_alpha (drawable->id)) + if ((gimp_drawable_is_rgb (drawable->drawable_id) + || gimp_drawable_is_gray (drawable->drawable_id)) + && gimp_drawable_has_alpha (drawable->drawable_id)) { switch (run_mode) { @@ -735,7 +735,7 @@ init_calculation (void) gint32 nlayers; GimpRGB color; - gimp_layer_add_alpha (drawable->id); + gimp_layer_add_alpha (drawable->drawable_id); /* Image parameters */ @@ -744,7 +744,7 @@ init_calculation (void) image_layers = gimp_image_get_layers (image_id, &nlayers); drawable_position = 0; while (drawable_position < nlayers && - image_layers[drawable_position] != drawable->id) + image_layers[drawable_position] != drawable->drawable_id) drawable_position++; if (drawable_position >= nlayers) { @@ -752,7 +752,8 @@ init_calculation (void) drawable_position = 0; } /* Get the bounds of the active selection */ - 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); true_sel_width = sel_x2 - sel_x1; true_sel_height = sel_y2 - sel_y1; @@ -822,7 +823,7 @@ do_curl_effect (void) gpointer pr; guchar *grad_samples = NULL; - color_image = gimp_drawable_is_rgb (drawable->id); + color_image = gimp_drawable_is_rgb (drawable->drawable_id); curl_layer = gimp_drawable_get (gimp_layer_new (image_id, _("Curl Layer"), @@ -830,11 +831,11 @@ do_curl_effect (void) true_sel_height, color_image ? GIMP_RGBA_IMAGE : GIMP_GRAYA_IMAGE, 100, GIMP_NORMAL_MODE)); - gimp_image_add_layer (image_id, curl_layer->id, drawable_position); - curl_layer_ID = curl_layer->id; + gimp_image_add_layer (image_id, curl_layer->drawable_id, drawable_position); + curl_layer_ID = curl_layer->drawable_id; - gimp_drawable_offsets (drawable->id, &x1, &y1); - gimp_layer_set_offsets (curl_layer->id, sel_x1 + x1, sel_y1 + y1); + gimp_drawable_offsets (drawable->drawable_id, &x1, &y1); + gimp_layer_set_offsets (curl_layer->drawable_id, sel_x1 + x1, sel_y1 + y1); gimp_tile_cache_ntiles (2 * (curl_layer->width / gimp_tile_width () + 1)); /* Clear the newly created layer */ @@ -859,7 +860,7 @@ do_curl_effect (void) } gimp_drawable_flush (curl_layer); - gimp_drawable_update (curl_layer->id, + gimp_drawable_update (curl_layer->drawable_id, 0, 0, curl_layer->width, curl_layer->height); gimp_pixel_rgn_init (&dest_rgn, curl_layer, @@ -985,8 +986,8 @@ do_curl_effect (void) } gimp_drawable_flush (curl_layer); - gimp_drawable_merge_shadow (curl_layer->id, FALSE); - gimp_drawable_update (curl_layer->id, + gimp_drawable_merge_shadow (curl_layer->drawable_id, FALSE); + gimp_drawable_update (curl_layer->drawable_id, 0, 0, curl_layer->width, curl_layer->height); gimp_drawable_detach (curl_layer); @@ -1066,8 +1067,9 @@ clear_curled_region (void) gimp_progress_update ((double) progress / (double) max_progress); } gimp_drawable_flush (drawable); - gimp_drawable_merge_shadow (drawable->id, TRUE); - gimp_drawable_update (drawable->id, sel_x1, sel_y1, true_sel_width, true_sel_height); + gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); + gimp_drawable_update (drawable->drawable_id, + sel_x1, sel_y1, true_sel_width, true_sel_height); gimp_drawable_detach (drawable); } @@ -1084,7 +1086,7 @@ page_curl (void) /* Returns NGRADSAMPLES samples of active gradient. - Each sample has (gimp_drawable_bpp (drawable->id)) bytes. + Each sample has (gimp_drawable_bpp (drawable->drawable_id)) bytes. "ripped" from gradmap.c. */ static guchar * @@ -1097,9 +1099,9 @@ get_samples (GimpDrawable *drawable) f_samples = gimp_gradients_sample_uniform (NGRADSAMPLES); - 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, NGRADSAMPLES * bpp); diff --git a/plug-ins/rcm/rcm.c b/plug-ins/rcm/rcm.c index 0004da52a9..c60454ab64 100644 --- a/plug-ins/rcm/rcm.c +++ b/plug-ins/rcm/rcm.c @@ -206,7 +206,7 @@ rcm (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; @@ -233,8 +233,8 @@ rcm (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); @@ -265,8 +265,8 @@ run (char *name, /* works not on INDEXED images */ - if (gimp_drawable_is_indexed (Current.drawable->id) || - gimp_drawable_is_gray (Current.drawable->id) ) + if (gimp_drawable_is_indexed (Current.drawable->drawable_id) || + gimp_drawable_is_gray (Current.drawable->drawable_id) ) { status = GIMP_PDB_EXECUTION_ERROR; } @@ -276,7 +276,7 @@ run (char *name, INIT_I18N_UI(); - if (gimp_drawable_is_rgb(Current.drawable->id) && rcm_dialog()) + if (gimp_drawable_is_rgb(Current.drawable->drawable_id) && rcm_dialog()) { gimp_progress_init(_("Rotating the colormap...")); diff --git a/plug-ins/rcm/rcm_misc.c b/plug-ins/rcm/rcm_misc.c index 052a807f0c..8e0d4b4dc5 100644 --- a/plug-ins/rcm/rcm_misc.c +++ b/plug-ins/rcm/rcm_misc.c @@ -199,7 +199,7 @@ rcm_reduce_image (GimpDrawable *drawable, /* get bounds of image or selection */ - gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2); + gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2); if ( ((x2-x1) != drawable->width) && ((y2-y1) != drawable->height)) NoSelectionMade = FALSE;