diff --git a/srcpkgs/gimp/patches/fix-gegl.patch b/srcpkgs/gimp/patches/fix-gegl.patch new file mode 100644 index 00000000000..aba210c5ded --- /dev/null +++ b/srcpkgs/gimp/patches/fix-gegl.patch @@ -0,0 +1,2151 @@ +diff --git a/app/core/gimpdrawable-transform.c b/app/core/gimpdrawable-transform.c +index 350b1b8f4d..f26bbe3a58 100644 +--- app/core/gimpdrawable-transform.c ++++ app/core/gimpdrawable-transform.c +@@ -15,6 +15,8 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API ++ + #include "config.h" + + #include +@@ -271,33 +273,33 @@ gimp_drawable_transform_buffer_flip (GimpDrawable *drawable, + dest_rect.height = new_height; + + iter = gegl_buffer_iterator_new (new_buffer, &dest_rect, 0, NULL, +- GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE); ++ GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE, 1); + + switch (flip_type) + { + case GIMP_ORIENTATION_HORIZONTAL: + while (gegl_buffer_iterator_next (iter)) + { +- gint stride = iter->roi[0].width * bpp; ++ gint stride = iter->items[0].roi.width * bpp; + +- src_rect = iter->roi[0]; ++ src_rect = iter->items[0].roi; + + src_rect.x = (orig_x + orig_width) - +- (iter->roi[0].x - dest_rect.x) - +- iter->roi[0].width; ++ (iter->items[0].roi.x - dest_rect.x) - ++ iter->items[0].roi.width; + +- gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, iter->data[0], ++ gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, iter->items[0].data, + stride, GEGL_ABYSS_NONE); + +- for (y = 0; y < iter->roi[0].height; y++) ++ for (y = 0; y < iter->items[0].roi.height; y++) + { +- guint8 *left = iter->data[0]; +- guint8 *right = iter->data[0]; ++ guint8 *left = iter->items[0].data; ++ guint8 *right = iter->items[0].data; + + left += y * stride; +- right += y * stride + (iter->roi[0].width - 1) * bpp; ++ right += y * stride + (iter->items[0].roi.width - 1) * bpp; + +- for (x = 0; x < iter->roi[0].width / 2; x++) ++ for (x = 0; x < iter->items[0].roi.width / 2; x++) + { + guint8 temp[bpp]; + +@@ -315,26 +317,26 @@ gimp_drawable_transform_buffer_flip (GimpDrawable *drawable, + case GIMP_ORIENTATION_VERTICAL: + while (gegl_buffer_iterator_next (iter)) + { +- gint stride = iter->roi[0].width * bpp; ++ gint stride = iter->items[0].roi.width * bpp; + +- src_rect = iter->roi[0]; ++ src_rect = iter->items[0].roi; + + src_rect.y = (orig_y + orig_height) - +- (iter->roi[0].y - dest_rect.y) - +- iter->roi[0].height; ++ (iter->items[0].roi.y - dest_rect.y) - ++ iter->items[0].roi.height; + +- gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, iter->data[0], ++ gegl_buffer_get (orig_buffer, &src_rect, 1.0, NULL, iter->items[0].data, + stride, GEGL_ABYSS_NONE); + +- for (x = 0; x < iter->roi[0].width; x++) ++ for (x = 0; x < iter->items[0].roi.width; x++) + { +- guint8 *top = iter->data[0]; +- guint8 *bottom = iter->data[0]; ++ guint8 *top = iter->items[0].data; ++ guint8 *bottom = iter->items[0].data; + + top += x * bpp; +- bottom += x * bpp + (iter->roi[0].height - 1) * stride; ++ bottom += x * bpp + (iter->items[0].roi.height - 1) * stride; + +- for (y = 0; y < iter->roi[0].height / 2; y++) ++ for (y = 0; y < iter->items[0].roi.height / 2; y++) + { + guint8 temp[bpp]; + +diff --git a/app/core/gimphistogram.c b/app/core/gimphistogram.c +index 109dffa201..4188e5ce05 100644 +--- app/core/gimphistogram.c ++++ app/core/gimphistogram.c +@@ -17,6 +17,8 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API ++ + #include "config.h" + + #include +@@ -984,7 +986,7 @@ gimp_histogram_calculate_area (const GeglRectangle *area, + + iter = gegl_buffer_iterator_new (context->buffer, area, 0, + data->format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + if (context->mask) + { +@@ -1020,7 +1022,7 @@ gimp_histogram_calculate_area (const GeglRectangle *area, + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *data = iter->data[0]; ++ const gfloat *data = iter->items[0].data; + gint length = iter->length; + gfloat max; + gfloat luminance; +@@ -1029,7 +1031,7 @@ gimp_histogram_calculate_area (const GeglRectangle *area, + + if (context->mask) + { +- const gfloat *mask_data = iter->data[1]; ++ const gfloat *mask_data = iter->items[1].data; + + switch (n_components) + { +diff --git a/app/core/gimpimage-convert-indexed.c b/app/core/gimpimage-convert-indexed.c +index d41d20c150..476a35fa3e 100644 +--- app/core/gimpimage-convert-indexed.c ++++ app/core/gimpimage-convert-indexed.c +@@ -136,6 +136,7 @@ + + #include + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpcolor/gimpcolor.h" +@@ -699,11 +700,11 @@ remap_indexed_layer (GimpLayer *layer, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, NULL, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *data = iter->data[0]; ++ guchar *data = iter->items[0].data; + gint length = iter->length; + + if (has_alpha) +@@ -1125,11 +1126,11 @@ generate_histogram_gray (CFHistogram histogram, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *data = iter->data[0]; ++ const guchar *data = iter->items[0].data; + gint length = iter->length; + + if (has_alpha) +@@ -1192,15 +1193,15 @@ generate_histogram_rgb (CFHistogram histogram, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + if (progress) + gimp_progress_set_value (progress, 0.0); + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *data = iter->data[0]; ++ const guchar *data = iter->items[0].data; + gint length = iter->length; + + total_size += length; +@@ -2846,8 +2847,8 @@ median_cut_pass2_no_dither_gray (QuantizeObj *quantobj, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- src_roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); ++ src_roi = &iter->items[0].roi; + + gegl_buffer_iterator_add (iter, new_buffer, + NULL, 0, NULL, +@@ -2855,8 +2856,8 @@ median_cut_pass2_no_dither_gray (QuantizeObj *quantobj, + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src = iter->data[0]; +- guchar *dest = iter->data[1]; ++ const guchar *src = iter->items[0].data; ++ guchar *dest = iter->items[1].data; + gint row; + + for (row = 0; row < src_roi->height; row++) +@@ -2952,8 +2953,8 @@ median_cut_pass2_fixed_dither_gray (QuantizeObj *quantobj, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- src_roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); ++ src_roi = &iter->items[0].roi; + + gegl_buffer_iterator_add (iter, new_buffer, + NULL, 0, NULL, +@@ -2961,8 +2962,8 @@ median_cut_pass2_fixed_dither_gray (QuantizeObj *quantobj, + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src = iter->data[0]; +- guchar *dest = iter->data[1]; ++ const guchar *src = iter->items[0].data; ++ guchar *dest = iter->items[1].data; + gint row; + + for (row = 0; row < src_roi->height; row++) +@@ -3131,8 +3132,8 @@ median_cut_pass2_no_dither_rgb (QuantizeObj *quantobj, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- src_roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); ++ src_roi = &iter->items[0].roi; + + gegl_buffer_iterator_add (iter, new_buffer, + NULL, 0, NULL, +@@ -3143,8 +3144,8 @@ median_cut_pass2_no_dither_rgb (QuantizeObj *quantobj, + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src = iter->data[0]; +- guchar *dest = iter->data[1]; ++ const guchar *src = iter->items[0].data; ++ guchar *dest = iter->items[1].data; + gint row; + + total_size += src_roi->height * src_roi->width; +@@ -3264,8 +3265,8 @@ median_cut_pass2_fixed_dither_rgb (QuantizeObj *quantobj, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- src_roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); ++ src_roi = &iter->items[0].roi; + + gegl_buffer_iterator_add (iter, new_buffer, + NULL, 0, NULL, +@@ -3276,8 +3277,8 @@ median_cut_pass2_fixed_dither_rgb (QuantizeObj *quantobj, + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src = iter->data[0]; +- guchar *dest = iter->data[1]; ++ const guchar *src = iter->items[0].data; ++ guchar *dest = iter->items[1].data; + gint row; + + total_size += src_roi->height * src_roi->width; +@@ -3478,8 +3479,8 @@ median_cut_pass2_nodestruct_dither_rgb (QuantizeObj *quantobj, + + iter = gegl_buffer_iterator_new (gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), + NULL, 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- src_roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); ++ src_roi = &iter->items[0].roi; + + gegl_buffer_iterator_add (iter, new_buffer, + NULL, 0, NULL, +@@ -3487,8 +3488,8 @@ median_cut_pass2_nodestruct_dither_rgb (QuantizeObj *quantobj, + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src = iter->data[0]; +- guchar *dest = iter->data[1]; ++ const guchar *src = iter->items[0].data; ++ guchar *dest = iter->items[1].data; + gint row; + + for (row = 0; row < src_roi->height; row++) +diff --git a/app/core/gimppalette-import.c b/app/core/gimppalette-import.c +index 6cee2ccc33..23c107f3f8 100644 +--- app/core/gimppalette-import.c ++++ app/core/gimppalette-import.c +@@ -18,6 +18,7 @@ + #include "config.h" + + #include ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -291,7 +292,7 @@ gimp_palette_import_extract (GimpImage *image, + format = babl_format ("R'G'B'A u8"); + + iter = gegl_buffer_iterator_new (buffer, &rect, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + bpp = babl_format_get_bytes_per_pixel (format); + + if (selection_only && +@@ -307,18 +308,18 @@ gimp_palette_import_extract (GimpImage *image, + + gegl_buffer_iterator_add (iter, buffer, &rect, 0, format, + GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- mask_roi = &iter->roi[1]; ++ mask_roi = &iter->items[1].roi; + mask_bpp = babl_format_get_bytes_per_pixel (format); + } + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *data = iter->data[0]; ++ const guchar *data = iter->items[0].data; + const guchar *mask_data = NULL; + gint length = iter->length; + + if (mask_roi) +- mask_data = iter->data[1]; ++ mask_data = iter->items[1].data; + + while (length--) + { +diff --git a/app/core/gimppickable-contiguous-region.c b/app/core/gimppickable-contiguous-region.c +index 3d625b53db..27f071820c 100644 +--- app/core/gimppickable-contiguous-region.c ++++ app/core/gimppickable-contiguous-region.c +@@ -20,6 +20,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -218,7 +219,7 @@ gimp_pickable_contiguous_region_by_color (GimpPickable *pickable, + + iter = gegl_buffer_iterator_new (src_buffer, + NULL, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, mask_buffer, + NULL, 0, babl_format ("Y float"), +@@ -226,8 +227,8 @@ gimp_pickable_contiguous_region_by_color (GimpPickable *pickable, + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *src = iter->data[0]; +- gfloat *dest = iter->data[1]; ++ const gfloat *src = iter->items[0].data; ++ gfloat *dest = iter->items[1].data; + gint count = iter->length; + + while (count--) +diff --git a/app/core/gimpscanconvert.c b/app/core/gimpscanconvert.c +index 742bb0e27b..108c0e1a47 100644 +--- app/core/gimpscanconvert.c ++++ app/core/gimpscanconvert.c +@@ -20,6 +20,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + + #include +@@ -528,12 +529,12 @@ gimp_scan_convert_render_full (GimpScanConvert *sc, + bpp = babl_format_get_bytes_per_pixel (format); + + iter = gegl_buffer_iterator_new (buffer, NULL, 0, format, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *data = iter->data[0]; ++ guchar *data = iter->items[0].data; + guchar *tmp_buf = NULL; + const gint stride = cairo_format_stride_for_width (CAIRO_FORMAT_A8, + roi->width); +diff --git a/app/gegl/gimp-gegl-loops.cc b/app/gegl/gimp-gegl-loops.cc +index f123edc7a0..cdb8c5785a 100644 +--- app/gegl/gimp-gegl-loops.cc ++++ app/gegl/gimp-gegl-loops.cc +@@ -24,6 +24,7 @@ + + #include + #include ++#define GEGL_ITERATOR2_API + #include + + extern "C" +@@ -174,22 +175,22 @@ gimp_gegl_convolve (GeglBuffer *src_buffer, + + /* Set up dest iterator */ + dest_iter = gegl_buffer_iterator_new (dest_buffer, dest_area, 0, dest_format, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (dest_iter)) + { + /* Convolve the src image using the convolution kernel, writing + * to dest Convolve is not tile-enabled--use accordingly + */ +- gfloat *dest = (gfloat *) dest_iter->data[0]; ++ gfloat *dest = (gfloat *) dest_iter->items[0].data; + const gint x1 = 0; + const gint y1 = 0; + const gint x2 = src_rect->width - 1; + const gint y2 = src_rect->height - 1; +- const gint dest_x1 = dest_iter->roi[0].x; +- const gint dest_y1 = dest_iter->roi[0].y; +- const gint dest_x2 = dest_iter->roi[0].x + dest_iter->roi[0].width; +- const gint dest_y2 = dest_iter->roi[0].y + dest_iter->roi[0].height; ++ const gint dest_x1 = dest_iter->items[0].roi.x; ++ const gint dest_y1 = dest_iter->items[0].roi.y; ++ const gint dest_x2 = dest_iter->items[0].roi.x + dest_iter->items[0].roi.width; ++ const gint dest_y2 = dest_iter->items[0].roi.y + dest_iter->items[0].roi.height; + gint x, y; + + for (y = dest_y1; y < dest_y2; y++) +@@ -280,7 +281,7 @@ gimp_gegl_convolve (GeglBuffer *src_buffer, + } + } + +- dest += dest_iter->roi[0].width * dest_components; ++ dest += dest_iter->items[0].roi.width * dest_components; + } + } + }); +@@ -325,7 +326,7 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer, + + iter = gegl_buffer_iterator_new (src_buffer, src_area, 0, + babl_format ("R'G'B'A float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, dest_buffer, dest_area, 0, + babl_format ("R'G'B'A float"), +@@ -340,8 +341,8 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *src = (gfloat *) iter->data[0]; +- gfloat *dest = (gfloat *) iter->data[1]; ++ gfloat *src = (gfloat *) iter->items[0].data; ++ gfloat *dest = (gfloat *) iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -363,8 +364,8 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *src = (gfloat *) iter->data[0]; +- gfloat *dest = (gfloat *) iter->data[1]; ++ gfloat *src = (gfloat *) iter->items[0].data; ++ gfloat *dest = (gfloat *) iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -386,8 +387,8 @@ gimp_gegl_dodgeburn (GeglBuffer *src_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *src = (gfloat *) iter->data[0]; +- gfloat *dest = (gfloat *) iter->data[1]; ++ gfloat *src = (gfloat *) iter->items[0].data; ++ gfloat *dest = (gfloat *) iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -560,7 +561,7 @@ gimp_gegl_smudge_with_paint (GeglBuffer *accum_buffer, + + iter = gegl_buffer_iterator_new (accum_buffer, accum_area, 0, + babl_format ("RGBA float"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 3); + + gegl_buffer_iterator_add (iter, canvas_buffer, canvas_area, 0, + babl_format ("RGBA float"), +@@ -576,9 +577,9 @@ gimp_gegl_smudge_with_paint (GeglBuffer *accum_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *accum = (gfloat *) iter->data[0]; +- const gfloat *canvas = (const gfloat *) iter->data[1]; +- gfloat *paint = (gfloat *) iter->data[2]; ++ gfloat *accum = (gfloat *) iter->items[0].data; ++ const gfloat *canvas = (const gfloat *) iter->items[1].data; ++ gfloat *paint = (gfloat *) iter->items[2].data; + gint count = iter->length; + + #if COMPILE_SSE2_INTRINISICS +@@ -628,7 +629,7 @@ gimp_gegl_apply_mask (GeglBuffer *mask_buffer, + + iter = gegl_buffer_iterator_new (mask_buffer, mask_area, 0, + babl_format ("Y float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, dest_buffer, dest_area, 0, + babl_format ("RGBA float"), +@@ -636,8 +637,8 @@ gimp_gegl_apply_mask (GeglBuffer *mask_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *mask = (const gfloat *) iter->data[0]; +- gfloat *dest = (gfloat *) iter->data[1]; ++ const gfloat *mask = (const gfloat *) iter->items[0].data; ++ gfloat *dest = (gfloat *) iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -673,7 +674,7 @@ gimp_gegl_combine_mask (GeglBuffer *mask_buffer, + + iter = gegl_buffer_iterator_new (mask_buffer, mask_area, 0, + babl_format ("Y float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, dest_buffer, dest_area, 0, + babl_format ("Y float"), +@@ -681,8 +682,8 @@ gimp_gegl_combine_mask (GeglBuffer *mask_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *mask = (const gfloat *) iter->data[0]; +- gfloat *dest = (gfloat *) iter->data[1]; ++ const gfloat *mask = (const gfloat *) iter->items[0].data; ++ gfloat *dest = (gfloat *) iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -719,7 +720,7 @@ gimp_gegl_combine_mask_weird (GeglBuffer *mask_buffer, + + iter = gegl_buffer_iterator_new (mask_buffer, mask_area, 0, + babl_format ("Y float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, dest_buffer, dest_area, 0, + babl_format ("Y float"), +@@ -727,8 +728,8 @@ gimp_gegl_combine_mask_weird (GeglBuffer *mask_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *mask = (const gfloat *) iter->data[0]; +- gfloat *dest = (gfloat *) iter->data[1]; ++ const gfloat *mask = (const gfloat *) iter->items[0].data; ++ gfloat *dest = (gfloat *) iter->items[1].data; + gint count = iter->length; + + if (stipple) +@@ -791,7 +792,7 @@ gimp_gegl_replace (GeglBuffer *top_buffer, + + iter = gegl_buffer_iterator_new (top_buffer, top_area, 0, + babl_format ("RGBA float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 4); + + gegl_buffer_iterator_add (iter, bottom_buffer, bottom_area, 0, + babl_format ("RGBA float"), +@@ -807,10 +808,10 @@ gimp_gegl_replace (GeglBuffer *top_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *top = (const gfloat *) iter->data[0]; +- const gfloat *bottom = (const gfloat *) iter->data[1]; +- const gfloat *mask = (const gfloat *) iter->data[2]; +- gfloat *dest = (gfloat *) iter->data[3]; ++ const gfloat *top = (const gfloat *) iter->items[0].data; ++ const gfloat *bottom = (const gfloat *) iter->items[1].data; ++ const gfloat *mask = (const gfloat *) iter->items[2].data; ++ gfloat *dest = (gfloat *) iter->items[3].data; + gint count = iter->length; + + while (count--) +@@ -905,7 +906,7 @@ gimp_gegl_index_to_mask (GeglBuffer *indexed_buffer, + + iter = gegl_buffer_iterator_new (indexed_buffer, indexed_area, 0, + indexed_format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, mask_buffer, mask_area, 0, + babl_format ("Y float"), +@@ -913,8 +914,8 @@ gimp_gegl_index_to_mask (GeglBuffer *indexed_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *indexed = (const guchar *) iter->data[0]; +- gfloat *mask = (gfloat *) iter->data[1]; ++ const guchar *indexed = (const guchar *) iter->items[0].data; ++ gfloat *mask = (gfloat *) iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -1063,11 +1064,11 @@ gimp_gegl_average_color (GeglBuffer *buffer, + gint n = 0; + + iter = gegl_buffer_iterator_new (buffer, area, 0, average_format, +- GEGL_BUFFER_READ, abyss_policy); ++ GEGL_BUFFER_READ, abyss_policy, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- const gfloat *p = (const gfloat *) iter->data[0]; ++ const gfloat *p = (const gfloat *) iter->items[0].data; + gint i; + + for (i = 0; i < iter->length; i++) +diff --git a/app/gegl/gimp-gegl-mask-combine.c b/app/gegl/gimp-gegl-mask-combine.c +index abedf61de9..9ab093fe8c 100644 +--- app/gegl/gimp-gegl-mask-combine.c ++++ app/gegl/gimp-gegl-mask-combine.c +@@ -20,6 +20,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpbase/gimpbase.h" +@@ -205,12 +206,12 @@ gimp_gegl_mask_combine_ellipse_rect (GeglBuffer *mask, + iter = gegl_buffer_iterator_new (mask, + GEGL_RECTANGLE (x0, y0, width, height), 0, + babl_format ("Y float"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gint py; + + for (py = roi->y; +@@ -411,7 +412,7 @@ gimp_gegl_mask_combine_buffer (GeglBuffer *mask, + + iter = gegl_buffer_iterator_new (mask, &rect, 0, + mask_format, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 2); + + rect.x -= off_x; + rect.y -= off_y; +@@ -443,8 +444,8 @@ gimp_gegl_mask_combine_buffer (GeglBuffer *mask, + case GIMP_CHANNEL_OP_REPLACE: + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *mask_data = iter->data[0]; +- const gfloat *add_on_data = iter->data[1]; ++ gfloat *mask_data = iter->items[0].data; ++ const gfloat *add_on_data = iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -462,8 +463,8 @@ gimp_gegl_mask_combine_buffer (GeglBuffer *mask, + case GIMP_CHANNEL_OP_SUBTRACT: + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *mask_data = iter->data[0]; +- const gfloat *add_on_data = iter->data[1]; ++ gfloat *mask_data = iter->items[0].data; ++ const gfloat *add_on_data = iter->items[1].data; + gint count = iter->length; + + while (count--) +@@ -482,8 +483,8 @@ gimp_gegl_mask_combine_buffer (GeglBuffer *mask, + case GIMP_CHANNEL_OP_INTERSECT: + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *mask_data = iter->data[0]; +- const gfloat *add_on_data = iter->data[1]; ++ gfloat *mask_data = iter->items[0].data; ++ const gfloat *add_on_data = iter->items[1].data; + gint count = iter->length; + + while (count--) +diff --git a/app/gegl/gimp-gegl-mask.c b/app/gegl/gimp-gegl-mask.c +index f14638b264..4dad33315c 100644 +--- app/gegl/gimp-gegl-mask.c ++++ app/gegl/gimp-gegl-mask.c +@@ -17,6 +17,7 @@ + + #include "config.h" + ++#define GEGL_ITERATOR2_API + #include + + #include "gimp-gegl-types.h" +@@ -48,12 +49,12 @@ gimp_gegl_mask_bounds (GeglBuffer *buffer, + ty2 = 0; + + iter = gegl_buffer_iterator_new (buffer, NULL, 0, babl_format ("Y float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gfloat *data1 = data; + gint ex = roi->x + roi->width; + gint ey = roi->y + roi->height; +@@ -138,11 +139,11 @@ gimp_gegl_mask_is_empty (GeglBuffer *buffer) + g_return_val_if_fail (GEGL_IS_BUFFER (buffer), FALSE); + + iter = gegl_buffer_iterator_new (buffer, NULL, 0, babl_format ("Y float"), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gint i; + + for (i = 0; i < iter->length; i++) +diff --git a/app/operations/gimpoperationbuffersourcevalidate.c b/app/operations/gimpoperationbuffersourcevalidate.c +index 85a87ecd8b..40b16871e4 100644 +--- app/operations/gimpoperationbuffersourcevalidate.c ++++ app/operations/gimpoperationbuffersourcevalidate.c +@@ -18,6 +18,7 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -317,7 +318,7 @@ gimp_operation_buffer_source_validate_process (GeglOperation *operation, + rect.height), + level, NULL, + GEGL_BUFFER_READ, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)); + } +diff --git a/app/operations/gimpoperationcagecoefcalc.c b/app/operations/gimpoperationcagecoefcalc.c +index 30e7f49681..66e7527341 100644 +--- app/operations/gimpoperationcagecoefcalc.c ++++ app/operations/gimpoperationcagecoefcalc.c +@@ -20,6 +20,7 @@ + #include "config.h" + + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpmath/gimpmath.h" +@@ -212,17 +213,17 @@ gimp_operation_cage_coef_calc_process (GeglOperation *operation, + n_cage_vertices = gimp_cage_config_get_n_points (config); + + it = gegl_buffer_iterator_new (output, roi, 0, format, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (it)) + { + /* iterate inside the roi */ + gint n_pixels = it->length; +- gint x = it->roi->x; /* initial x */ +- gint y = it->roi->y; /* and y coordinates */ ++ gint x = it->items[0].roi.x; /* initial x */ ++ gint y = it->items[0].roi.y; /* and y coordinates */ + gint j; + +- gfloat *coef = it->data[0]; ++ gfloat *coef = it->items[0].data; + + while(n_pixels--) + { +@@ -282,9 +283,9 @@ gimp_operation_cage_coef_calc_process (GeglOperation *operation, + + /* update x and y coordinates */ + x++; +- if (x >= (it->roi->x + it->roi->width)) ++ if (x >= (it->items[0].roi.x + it->items[0].roi.width)) + { +- x = it->roi->x; ++ x = it->items[0].roi.x; + y++; + } + } +diff --git a/app/operations/gimpoperationcagetransform.c b/app/operations/gimpoperationcagetransform.c +index f0467d5088..d2267c8bfa 100644 +--- app/operations/gimpoperationcagetransform.c ++++ app/operations/gimpoperationcagetransform.c +@@ -20,6 +20,7 @@ + #include "config.h" + + #include ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -234,7 +235,7 @@ gimp_operation_cage_transform_process (GeglOperation *operation, + + /* pre-fill the out buffer with no-displacement coordinate */ + it = gegl_buffer_iterator_new (out_buf, roi, 0, NULL, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); + cage_bb = gimp_cage_config_get_bounding_box (config); + + point = &(g_array_index (config->cage_points, GimpCagePoint, 0)); +@@ -247,10 +248,10 @@ gimp_operation_cage_transform_process (GeglOperation *operation, + { + /* iterate inside the roi */ + gint n_pixels = it->length; +- gfloat *output = it->data[0]; ++ gfloat *output = it->items[0].data; + +- x = it->roi->x; /* initial x */ +- y = it->roi->y; /* and y coordinates */ ++ x = it->items[0].roi.x; /* initial x */ ++ y = it->items[0].roi.y; /* and y coordinates */ + + while (n_pixels--) + { +@@ -280,9 +281,9 @@ gimp_operation_cage_transform_process (GeglOperation *operation, + + /* update x and y coordinates */ + x++; +- if (x >= (it->roi->x + it->roi->width)) ++ if (x >= (it->items[0].roi.x + it->items[0].roi.width)) + { +- x = it->roi->x; ++ x = it->items[0].roi.x; + y++; + } + } +diff --git a/app/operations/gimpoperationgradient.c b/app/operations/gimpoperationgradient.c +index 889d8f8656..ec3a0164c7 100644 +--- app/operations/gimpoperationgradient.c ++++ app/operations/gimpoperationgradient.c +@@ -23,6 +23,7 @@ + #include "config.h" + + #include ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -1130,15 +1131,15 @@ gimp_operation_gradient_process (GeglOperation *operation, + + iter = gegl_buffer_iterator_new (output, result, 0, + babl_format ("R'G'B'A float"), +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + if (self->dither) + seed = g_rand_new (); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *dest = iter->data[0]; ++ gfloat *dest = iter->items[0].data; + gint endx = roi->x + roi->width; + gint endy = roi->y + roi->height; + gint x, y; +diff --git a/app/operations/gimpoperationmaskcomponents.c b/app/operations/gimpoperationmaskcomponents.c +index 1c9425c410..8a8756cb7a 100644 +--- app/operations/gimpoperationmaskcomponents.c ++++ app/operations/gimpoperationmaskcomponents.c +@@ -81,7 +81,7 @@ gimp_operation_mask_components_class_init (GimpOperationMaskComponentsClass *kla + NULL); + + operation_class->prepare = gimp_operation_mask_components_prepare; +- operation_class->process = gimp_operation_mask_components_parent_process; ++ //operation_class->process = gimp_operation_mask_components_parent_process; + + point_class->process = gimp_operation_mask_components_process; + +@@ -172,7 +172,7 @@ gimp_operation_mask_components_parent_process (GeglOperation *operation, + gint level) + { + GimpOperationMaskComponents *self = GIMP_OPERATION_MASK_COMPONENTS (operation); +- ++#if 0 + if (self->mask == 0) + { + GObject *input = gegl_operation_context_get_object (context, "input"); +@@ -189,7 +189,7 @@ gimp_operation_mask_components_parent_process (GeglOperation *operation, + + return TRUE; + } +- ++#endif + return GEGL_OPERATION_CLASS (parent_class)->process (operation, context, + output_prop, result, + level); +@@ -211,10 +211,24 @@ gimp_operation_mask_components_process (GeglOperation *operation, + GimpComponentMask mask = self->mask; + static const gfloat nothing[] = { 0.0, 0.0, 0.0, 1.0 }; + +- if (! aux) +- aux = (gfloat *) nothing; ++#if 0 ++ if (self->mask == 0) ++ { ++ if (in_buf != out_buf) ++ memcpy (out_buf, in_buf, sizeof (float) * 4 * samples); ++ } ++ else if (self->mask == GIMP_COMPONENT_MASK_ALL && aux_buf) ++ { ++ if (aux_buf != out_buf) ++ memcpy (out_buf, aux_buf, sizeof (float) * 4 * samples); ++ } ++ else ++#endif ++ { ++ if (! aux) ++ aux = (gfloat *) nothing; + +- while (samples--) ++ while (samples--) + { + dest[RED] = (mask & GIMP_COMPONENT_MASK_RED) ? aux[RED] : src[RED]; + dest[GREEN] = (mask & GIMP_COMPONENT_MASK_GREEN) ? aux[GREEN] : src[GREEN]; +@@ -228,6 +242,7 @@ gimp_operation_mask_components_process (GeglOperation *operation, + + dest += 4; + } ++ } + + return TRUE; + } +diff --git a/app/paint/gimpbrushcore.c b/app/paint/gimpbrushcore.c +index e5076f723a..d46ecba72a 100644 +--- app/paint/gimpbrushcore.c ++++ app/paint/gimpbrushcore.c +@@ -20,6 +20,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpmath/gimpmath.h" +@@ -1283,7 +1284,7 @@ gimp_brush_core_color_area_with_pixmap (GimpBrushCore *core, + pixmap_format = gimp_temp_buf_get_format (pixmap_mask); + + iter = gegl_buffer_iterator_new (area, NULL, 0, area_format, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); + + if (mode == GIMP_BRUSH_SOFT && brush_mask) + { +@@ -1306,11 +1307,11 @@ gimp_brush_core_color_area_with_pixmap (GimpBrushCore *core, + brush_mask = NULL; + } + +- roi = &iter->roi[0]; ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *d = iter->data[0]; ++ gfloat *d = iter->items[0].data; + gint y; + + for (y = 0; y < roi->height; y++) +diff --git a/app/paint/gimpheal.c b/app/paint/gimpheal.c +index 0c2a0f3c0a..140baf0504 100644 +--- app/paint/gimpheal.c ++++ app/paint/gimpheal.c +@@ -25,6 +25,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpbase/gimpbase.h" +@@ -205,7 +206,7 @@ gimp_heal_sub (GeglBuffer *top_buffer, + g_return_if_reached (); + + iter = gegl_buffer_iterator_new (top_buffer, top_rect, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 3); + + gegl_buffer_iterator_add (iter, bottom_buffer, bottom_rect, 0, format, + GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +@@ -216,9 +217,9 @@ gimp_heal_sub (GeglBuffer *top_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *t = iter->data[0]; +- gfloat *b = iter->data[1]; +- gfloat *r = iter->data[2]; ++ gfloat *t = iter->items[0].data; ++ gfloat *b = iter->items[1].data; ++ gfloat *r = iter->items[2].data; + gint length = iter->length * n_components; + + while (length--) +@@ -250,7 +251,7 @@ gimp_heal_add (GeglBuffer *first_buffer, + iter = gegl_buffer_iterator_new (first_buffer, first_rect, 0, + babl_format_n (babl_type ("float"), + n_components), +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 3); + + gegl_buffer_iterator_add (iter, second_buffer, second_rect, 0, format, + GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +@@ -260,9 +261,9 @@ gimp_heal_add (GeglBuffer *first_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *f = iter->data[0]; +- gfloat *s = iter->data[1]; +- gfloat *r = iter->data[2]; ++ gfloat *f = iter->items[0].data; ++ gfloat *s = iter->items[1].data; ++ gfloat *r = iter->items[2].data; + gint length = iter->length * n_components; + + while (length--) +diff --git a/app/paint/gimpink.c b/app/paint/gimpink.c +index ce4e018b21..7531ece643 100644 +--- app/paint/gimpink.c ++++ app/paint/gimpink.c +@@ -20,6 +20,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpmath/gimpmath.h" +@@ -748,12 +749,12 @@ render_blob (GeglBuffer *buffer, + GeglRectangle *roi; + + iter = gegl_buffer_iterator_new (buffer, rect, 0, babl_format ("Y float"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *d = iter->data[0]; ++ gfloat *d = iter->items[0].data; + gint h = roi->height; + gint y; + +diff --git a/app/paint/gimpmybrushsurface.c b/app/paint/gimpmybrushsurface.c +index b9970d4c6c..dece18ae1d 100644 +--- app/paint/gimpmybrushsurface.c ++++ app/paint/gimpmybrushsurface.c +@@ -16,7 +16,7 @@ + */ + + #include "config.h" +- ++#define GEGL_ITERATOR2_API + #include + + #include +@@ -266,7 +266,7 @@ gimp_mypaint_surface_get_color (MyPaintSurface *base_surface, + GeglBufferIterator *iter = gegl_buffer_iterator_new (surface->buffer, &dabRect, 0, + babl_format ("R'aG'aB'aA float"), + GEGL_BUFFER_READ, +- GEGL_ABYSS_CLAMP); ++ GEGL_ABYSS_CLAMP, 2); + if (surface->paint_mask) + { + GeglRectangle mask_roi = dabRect; +@@ -279,19 +279,19 @@ gimp_mypaint_surface_get_color (MyPaintSurface *base_surface, + + while (gegl_buffer_iterator_next (iter)) + { +- float *pixel = (float *)iter->data[0]; ++ float *pixel = (float *)iter->items[0].data; + float *mask; + int iy, ix; + + if (surface->paint_mask) +- mask = iter->data[1]; ++ mask = iter->items[1].data; + else + mask = NULL; + +- for (iy = iter->roi[0].y; iy < iter->roi[0].y + iter->roi[0].height; iy++) ++ for (iy = iter->items[0].roi.y; iy < iter->items[0].roi.y + iter->items[0].roi.height; iy++) + { + float yy = (iy + 0.5f - y); +- for (ix = iter->roi[0].x; ix < iter->roi[0].x + iter->roi[0].width; ix++) ++ for (ix = iter->items[0].roi.x; ix < iter->items[0].roi.x + iter->items[0].roi.width; ix++) + { + /* pixel_weight == a standard dab with hardness = 0.5, aspect_ratio = 1.0, and angle = 0.0 */ + float xx = (ix + 0.5f - x); +@@ -390,7 +390,7 @@ gimp_mypaint_surface_draw_dab (MyPaintSurface *base_surface, + iter = gegl_buffer_iterator_new (surface->buffer, &dabRect, 0, + babl_format ("R'G'B'A float"), + GEGL_BUFFER_READWRITE, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 2); + if (surface->paint_mask) + { + GeglRectangle mask_roi = dabRect; +@@ -403,18 +403,18 @@ gimp_mypaint_surface_draw_dab (MyPaintSurface *base_surface, + + while (gegl_buffer_iterator_next (iter)) + { +- float *pixel = (float *)iter->data[0]; ++ float *pixel = (float *)iter->items[0].data; + float *mask; + int iy, ix; + + if (surface->paint_mask) +- mask = iter->data[1]; ++ mask = iter->items[1].data; + else + mask = NULL; + +- for (iy = iter->roi[0].y; iy < iter->roi[0].y + iter->roi[0].height; iy++) ++ for (iy = iter->items[0].roi.y; iy < iter->items[0].roi.y + iter->items[0].roi.height; iy++) + { +- for (ix = iter->roi[0].x; ix < iter->roi[0].x + iter->roi[0].width; ix++) ++ for (ix = iter->items[0].roi.x; ix < iter->items[0].roi.x + iter->items[0].roi.width; ix++) + { + float rr, base_alpha, alpha, dst_alpha, r, g, b, a; + if (radius < 3.0f) +diff --git a/app/paint/gimppaintcore-loops.cc b/app/paint/gimppaintcore-loops.cc +index f7fdee0a4f..383a7e2ad8 100644 +--- app/paint/gimppaintcore-loops.cc ++++ app/paint/gimppaintcore-loops.cc +@@ -16,7 +16,7 @@ + */ + + #include "config.h" +- ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -641,7 +641,7 @@ struct CombinePaintMaskToCanvasMaskToPaintBufAlpha : + base_type::init_step (params, state, iter, roi, area); + + state->canvas_pixel = +- (gfloat *) iter->data[base_type::canvas_buffer_iterator]; ++ (gfloat *) iter->items[base_type::canvas_buffer_iterator].data; + } + + template +@@ -656,14 +656,14 @@ struct CombinePaintMaskToCanvasMaskToPaintBufAlpha : + base_type::process_row (params, state, iter, roi, area, y); + + gint mask_offset = (y - roi->y) * this->mask_stride + +- (iter->roi[0].x - roi->x); ++ (iter->items[0].roi.x - roi->x); + const mask_type *mask_pixel = &this->mask_data[mask_offset]; + gint paint_offset = (y - roi->y) * this->paint_stride + +- (iter->roi[0].x - roi->x) * 4; ++ (iter->items[0].roi.x - roi->x) * 4; + gfloat *paint_pixel = &this->paint_data[paint_offset]; + gint x; + +- for (x = 0; x < iter->roi[0].width; x++) ++ for (x = 0; x < iter->items[0].roi.width; x++) + { + if (base_type::stipple) + { +@@ -738,7 +738,7 @@ struct CombinePaintMaskToCanvasMask : + base_type::init_step (params, state, iter, roi, area); + + state->canvas_pixel = +- (gfloat *) iter->data[base_type::canvas_buffer_iterator]; ++ (gfloat *) iter->items[base_type::canvas_buffer_iterator].data; + } + + template +@@ -753,11 +753,11 @@ struct CombinePaintMaskToCanvasMask : + base_type::process_row (params, state, iter, roi, area, y); + + gint mask_offset = (y - roi->y) * this->mask_stride + +- (iter->roi[0].x - roi->x); ++ (iter->items[0].roi.x - roi->x); + const mask_type *mask_pixel = &this->mask_data[mask_offset]; + gint x; + +- for (x = 0; x < iter->roi[0].width; x++) ++ for (x = 0; x < iter->items[0].roi.width; x++) + { + if (base_type::stipple) + { +@@ -826,7 +826,7 @@ struct CanvasBufferToPaintBufAlpha : CanvasBufferIteratorcanvas_pixel = +- (const gfloat *) iter->data[base_type::canvas_buffer_iterator]; ++ (const gfloat *) iter->items[base_type::canvas_buffer_iterator].data; + } + + template +@@ -842,12 +842,12 @@ struct CanvasBufferToPaintBufAlpha : CanvasBufferIteratory) * this->paint_stride + +- (iter->roi[0].x - roi->x) * 4; ++ gint paint_offset = (y - roi->y) * this->paint_stride + ++ (iter->items[0].roi.x - roi->x) * 4; + gfloat *paint_pixel = &this->paint_data[paint_offset]; + gint x; + +- for (x = 0; x < iter->roi[0].width; x++) ++ for (x = 0; x < iter->items[0].roi.width; x++) + { + paint_pixel[3] *= *state->canvas_pixel; + +@@ -906,15 +906,15 @@ struct PaintMaskToPaintBuffer : Base + { + Base::process_row (params, state, iter, roi, area, y); + +- gint paint_offset = (y - roi->y) * this->paint_stride + +- (iter->roi[0].x - roi->x) * 4; ++ gint paint_offset = (y - roi->y) * this->paint_stride + ++ (iter->items[0].roi.x - roi->x) * 4; + gfloat *paint_pixel = &this->paint_data[paint_offset]; +- gint mask_offset = (y - roi->y) * this->mask_stride + +- (iter->roi[0].x - roi->x); ++ gint mask_offset = (y - roi->y) * this->mask_stride + ++ (iter->items[0].roi.x - roi->x); + const mask_type *mask_pixel = &this->mask_data[mask_offset]; + gint x; + +- for (x = 0; x < iter->roi[0].width; x++) ++ for (x = 0; x < iter->items[0].roi.width; x++) + { + paint_pixel[3] *= value_to_float (*mask_pixel) * params->paint_opacity; + +@@ -1024,19 +1024,19 @@ struct DoLayerBlend : Base + { + Base::init_step (params, state, iter, roi, area); + +- state->out_pixel = (gfloat *) iter->data[iterator_base + 0]; +- state->in_pixel = (gfloat *) iter->data[iterator_base + 1]; ++ state->out_pixel = (gfloat *) iter->items[iterator_base + 0].data; ++ state->in_pixel = (gfloat *) iter->items[iterator_base + 1].data; + state->mask_pixel = NULL; + + state->paint_pixel = this->paint_data + +- (iter->roi[0].y - roi->y) * this->paint_stride + +- (iter->roi[0].x - roi->x) * 4; ++ (iter->items[0].roi.y - roi->y) * this->paint_stride + ++ (iter->items[0].roi.x - roi->x) * 4; + + if (params->mask_buffer) +- state->mask_pixel = (gfloat *) iter->data[iterator_base + 2]; ++ state->mask_pixel = (gfloat *) iter->items[iterator_base + 2].data; + +- state->process_roi.x = iter->roi[0].x; +- state->process_roi.width = iter->roi[0].width; ++ state->process_roi.x = iter->items[0].roi.x; ++ state->process_roi.width = iter->items[0].roi.width; + state->process_roi.height = 1; + } + +@@ -1058,14 +1058,14 @@ struct DoLayerBlend : Base + state->paint_pixel, + state->mask_pixel, + state->out_pixel, +- iter->roi[0].width, ++ iter->items[0].roi.width, + &state->process_roi, + 0); + +- state->in_pixel += iter->roi[0].width * 4; +- state->out_pixel += iter->roi[0].width * 4; ++ state->in_pixel += iter->items[0].roi.width * 4; ++ state->out_pixel += iter->items[0].roi.width * 4; + if (params->mask_buffer) +- state->mask_pixel += iter->roi[0].width; ++ state->mask_pixel += iter->items[0].roi.width; + state->paint_pixel += this->paint_stride; + } + }; +@@ -1130,7 +1130,7 @@ gimp_paint_core_loops_process (const GimpPaintCoreLoopsParams *params, + { + GeglBufferIterator *iter; + +- iter = gegl_buffer_iterator_empty_new (); ++ iter = gegl_buffer_iterator_empty_new (4); + + algorithm.init (params, &state, iter, &roi, area); + +@@ -1138,28 +1138,28 @@ gimp_paint_core_loops_process (const GimpPaintCoreLoopsParams *params, + { + algorithm.init_step (params, &state, iter, &roi, area); + +- for (y = 0; y < iter->roi[0].height; y++) ++ for (y = 0; y < iter->items[0].roi.height; y++) + { + algorithm.process_row (params, &state, + iter, &roi, area, +- iter->roi[0].y + y); ++ iter->items[0].roi.y + y); + } + } + } + else + { +- GeglBufferIterator iter; ++ GeglBufferIterator iter[2]; + +- iter.roi[0] = *area; ++ iter[0].items[0].roi = *area; + +- algorithm.init (params, &state, &iter, &roi, area); +- algorithm.init_step (params, &state, &iter, &roi, area); ++ algorithm.init (params, &state, &iter[0], &roi, area); ++ algorithm.init_step (params, &state, &iter[0], &roi, area); + +- for (y = 0; y < iter.roi[0].height; y++) ++ for (y = 0; y < iter[0].items[0].roi.height; y++) + { + algorithm.process_row (params, &state, +- &iter, &roi, area, +- iter.roi[0].y + y); ++ &iter[0], &roi, area, ++ iter[0].items[0].roi.y + y); + } + } + }); +@@ -1346,7 +1346,7 @@ mask_components_onto (GeglBuffer *src_buffer, + + iter = gegl_buffer_iterator_new (dst_buffer, area, 0, + iterator_format, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 3); + + gegl_buffer_iterator_add (iter, src_buffer, area, 0, + iterator_format, +@@ -1358,9 +1358,9 @@ mask_components_onto (GeglBuffer *src_buffer, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *dest = (gfloat *)iter->data[0]; +- gfloat *src = (gfloat *)iter->data[1]; +- gfloat *aux = (gfloat *)iter->data[2]; ++ gfloat *dest = (gfloat *)iter->items[0].data; ++ gfloat *src = (gfloat *)iter->items[1].data; ++ gfloat *aux = (gfloat *)iter->items[2].data; + glong samples = iter->length; + + while (samples--) +diff --git a/app/tools/gimpiscissorstool.c b/app/tools/gimpiscissorstool.c +index abfec2aaf6..67fb62f7ee 100644 +--- app/tools/gimpiscissorstool.c ++++ app/tools/gimpiscissorstool.c +@@ -46,6 +46,7 @@ + + #include + ++#define GEGL_ITERATOR2_API + #include + #include + #include +@@ -1914,12 +1915,12 @@ find_max_gradient (GimpIscissorsTool *iscissors, + iter = gegl_buffer_iterator_new (iscissors->gradient_map, + GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1), + 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- guint8 *data = iter->data[0]; ++ guint8 *data = iter->items[0].data; + gint endx = roi->x + roi->width; + gint endy = roi->y + roi->height; + gint i, j; +diff --git a/libgimpcolor/gimpcolortransform.c b/libgimpcolor/gimpcolortransform.c +index 2ddc0f6563..b99c1f6e52 100644 +--- libgimpcolor/gimpcolortransform.c ++++ libgimpcolor/gimpcolortransform.c +@@ -28,6 +28,7 @@ + #include + + #include ++#define GEGL_ITERATOR2_API + #include + + #include "libgimpbase/gimpbase.h" +@@ -555,7 +556,7 @@ gimp_color_transform_process_buffer (GimpColorTransform *transform, + iter = gegl_buffer_iterator_new (src_buffer, src_rect, 0, + src_format, + GEGL_ACCESS_READ, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 2); + + gegl_buffer_iterator_add (iter, dest_buffer, dest_rect, 0, + dest_format, +@@ -567,15 +568,15 @@ gimp_color_transform_process_buffer (GimpColorTransform *transform, + if (priv->transform) + { + cmsDoTransform (priv->transform, +- iter->data[0], iter->data[1], iter->length); ++ iter->items[0].data, iter->items[1].data, iter->length); + } + else + { + babl_process (priv->fish, +- iter->data[0], iter->data[1], iter->length); ++ iter->items[0].data, iter->items[1].data, iter->length); + } + +- done_pixels += iter->roi[0].width * iter->roi[0].height; ++ done_pixels += iter->items[0].roi.width * iter->items[0].roi.height; + + g_signal_emit (transform, gimp_color_transform_signals[PROGRESS], 0, + (gdouble) done_pixels / +@@ -587,22 +588,22 @@ gimp_color_transform_process_buffer (GimpColorTransform *transform, + iter = gegl_buffer_iterator_new (src_buffer, src_rect, 0, + src_format, + GEGL_ACCESS_READWRITE, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { + if (priv->transform) + { + cmsDoTransform (priv->transform, +- iter->data[0], iter->data[0], iter->length); ++ iter->items[0].data, iter->items[0].data, iter->length); + } + else + { + babl_process (priv->fish, +- iter->data[0], iter->data[0], iter->length); ++ iter->items[0].data, iter->items[0].data, iter->length); + } + +- done_pixels += iter->roi[0].width * iter->roi[0].height; ++ done_pixels += iter->items[0].roi.width * iter->items[0].roi.height; + + g_signal_emit (transform, gimp_color_transform_signals[PROGRESS], 0, + (gdouble) done_pixels / +diff --git a/modules/display-filter-clip-warning.c b/modules/display-filter-clip-warning.c +index 0e140df15c..71e92736c2 100644 +--- modules/display-filter-clip-warning.c ++++ modules/display-filter-clip-warning.c +@@ -20,6 +20,7 @@ + + #include + ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -353,14 +354,14 @@ cdisplay_clip_warning_convert_buffer (GimpColorDisplay *display, + + iter = gegl_buffer_iterator_new (buffer, area, 0, + babl_format ("R'G'B'A float"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gint count = iter->length; +- gint x = iter->roi[0].x; +- gint y = iter->roi[0].y; ++ gint x = iter->items[0].roi.x; ++ gint y = iter->items[0].roi.y; + + while (count--) + { +@@ -406,9 +407,9 @@ cdisplay_clip_warning_convert_buffer (GimpColorDisplay *display, + + data += 4; + +- if (++x == iter->roi[0].x + iter->roi[0].width) ++ if (++x == iter->items[0].roi.x + iter->items[0].roi.width) + { +- x = iter->roi[0].x; ++ x = iter->items[0].roi.x; + y++; + } + } +diff --git a/modules/display-filter-color-blind.c b/modules/display-filter-color-blind.c +index aee9df704c..604f3f0d10 100644 +--- modules/display-filter-color-blind.c ++++ modules/display-filter-color-blind.c +@@ -29,6 +29,7 @@ + + #include + ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -330,11 +331,11 @@ cdisplay_colorblind_convert_buffer (GimpColorDisplay *display, + + iter = gegl_buffer_iterator_new (buffer, area, 0, + babl_format ("RGBA float") /* linear! */, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gint count = iter->length; + + while (count--) +diff --git a/modules/display-filter-gamma.c b/modules/display-filter-gamma.c +index d49e12f933..0813e47912 100644 +--- modules/display-filter-gamma.c ++++ modules/display-filter-gamma.c +@@ -17,6 +17,7 @@ + + #include "config.h" + ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -193,11 +194,11 @@ cdisplay_gamma_convert_buffer (GimpColorDisplay *display, + + iter = gegl_buffer_iterator_new (buffer, area, 0, + babl_format ("R'G'B'A float"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gint count = iter->length; + + while (count--) +diff --git a/modules/display-filter-high-contrast.c b/modules/display-filter-high-contrast.c +index e45c28955f..7c7c512738 100644 +--- modules/display-filter-high-contrast.c ++++ modules/display-filter-high-contrast.c +@@ -17,6 +17,7 @@ + + #include "config.h" + ++#define GEGL_ITERATOR2_API + #include + #include + +@@ -193,11 +194,11 @@ cdisplay_contrast_convert_buffer (GimpColorDisplay *display, + + iter = gegl_buffer_iterator_new (buffer, area, 0, + babl_format ("R'G'B'A float"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + gint count = iter->length; + + while (count--) +diff --git a/plug-ins/common/border-average.c b/plug-ins/common/border-average.c +index 55ff62c9f2..d8c157b964 100644 +--- plug-ins/common/border-average.c ++++ plug-ins/common/border-average.c +@@ -17,6 +17,7 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -271,14 +272,14 @@ borderaverage (GeglBuffer *buffer, + GeglBufferIterator *gi; + + gi = gegl_buffer_iterator_new (buffer, &border[i], 0, babl_format ("R'G'B' u8"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (gi)) + { + guint k; + guchar *data; + +- data = (guchar*) gi->data[0]; ++ data = (guchar*) gi->items[0].data; + + for (k = 0; k < gi->length; k++) + { +diff --git a/plug-ins/common/colormap-remap.c b/plug-ins/common/colormap-remap.c +index 168fb50bff..493bbeda22 100644 +--- plug-ins/common/colormap-remap.c ++++ plug-ins/common/colormap-remap.c +@@ -27,6 +27,7 @@ + * + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -363,19 +364,19 @@ remap (gint32 image_ID, + iter = gegl_buffer_iterator_new (buffer, + GEGL_RECTANGLE (0, 0, width, height), 0, + format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); +- src_roi = &iter->roi[0]; ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 2); ++ src_roi = &iter->items[0].roi; + + gegl_buffer_iterator_add (iter, shadow, + GEGL_RECTANGLE (0, 0, width, height), 0, + format, + GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); +- dest_roi = &iter->roi[1]; ++ dest_roi = &iter->items[1].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src_row = iter->data[0]; +- guchar *dest_row = iter->data[1]; ++ const guchar *src_row = iter->items[0].data; ++ guchar *dest_row = iter->items[1].data; + gint y; + + for (y = 0; y < src_roi->height; y++) +diff --git a/plug-ins/common/compose.c b/plug-ins/common/compose.c +index 59d2e971f4..705f4c24c1 100644 +--- plug-ins/common/compose.c ++++ plug-ins/common/compose.c +@@ -34,6 +34,7 @@ + * They can be dropped for GIMP 3.0 + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -658,11 +659,11 @@ cpn_affine_transform (GeglBuffer *buffer, + gegl_buffer_set_format (buffer, babl_format ("Y double")); + + gi = gegl_buffer_iterator_new (buffer, NULL, 0, NULL, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (gi)) + { +- gdouble *data = gi->data[0]; ++ gdouble *data = gi->items[0].data; + guint k; + + for (k = 0; k < gi->length; k++) +@@ -683,7 +684,7 @@ fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], + gint j; + + gi = gegl_buffer_iterator_new (dst, NULL, 0, NULL, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 10); + + for (j = 0; j < num_cpn; j++) + { +@@ -695,13 +696,13 @@ fill_buffer_from_components (GeglBuffer *temp[MAX_COMPOSE_IMAGES], + while (gegl_buffer_iterator_next (gi)) + { + gdouble *src_data[MAX_COMPOSE_IMAGES]; +- gdouble *dst_data = (gdouble*) gi->data[0]; ++ gdouble *dst_data = (gdouble*) gi->items[0].data; + gulong k, count; + + count = 1; + for (j = 0; j < num_cpn; j++) + if (inputs[j].is_ID) +- src_data[j] = (gdouble*) gi->data[count++]; ++ src_data[j] = (gdouble*) gi->items[count++].data; + + for (k = 0; k < gi->length; k++) + { +diff --git a/plug-ins/common/decompose.c b/plug-ins/common/decompose.c +index 2ad0441431..24c8f0ea57 100644 +--- plug-ins/common/decompose.c ++++ plug-ins/common/decompose.c +@@ -25,7 +25,7 @@ + * merged into the officical plug-in by Sven Neumann. + */ + +- ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -641,7 +641,7 @@ transfer_registration_color (GeglBuffer *src, + dst_bpp = babl_format_get_bytes_per_pixel (dst_format); + + gi = gegl_buffer_iterator_new (src, NULL, 0, NULL, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 10); + + for (i = 0; i < count; i++) + { +@@ -655,9 +655,9 @@ transfer_registration_color (GeglBuffer *src, + gpointer dst_data[MAX_EXTRACT_IMAGES]; + gint j, k; + +- src_data = gi->data[0]; ++ src_data = gi->items[0].data; + for (j = 0; j < count; j++) +- dst_data[j] = gi->data[j + 1]; ++ dst_data[j] = gi->items[j + 1].data; + + for (k = 0; k < gi->length; k++) + { +@@ -693,14 +693,14 @@ cpn_affine_transform_clamp (GeglBuffer *buffer, + gegl_buffer_set_format (buffer, babl_format ("Y double")); + + gi = gegl_buffer_iterator_new (buffer, NULL, 0, NULL, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (gi)) + { + guint k; + double *data; + +- data = (double*) gi->data[0]; ++ data = (double*) gi->items[0].data; + + if (clamp) + { +diff --git a/plug-ins/common/file-png.c b/plug-ins/common/file-png.c +index 4fdaefb045..6ac721b803 100644 +--- plug-ins/common/file-png.c ++++ plug-ins/common/file-png.c +@@ -38,6 +38,7 @@ + * see ChangeLog + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -1360,13 +1361,13 @@ load_image (const gchar *filename, + file_format = gegl_buffer_get_format (buffer); + + iter = gegl_buffer_iterator_new (buffer, NULL, 0, file_format, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + n_components = babl_format_get_n_components (file_format); + g_warn_if_fail (n_components == 2); + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *data = iter->data[0]; ++ guchar *data = iter->items[0].data; + gint length = iter->length; + + while (length--) +@@ -2118,13 +2119,13 @@ ia_has_transparent_pixels (GeglBuffer *buffer) + + format = gegl_buffer_get_format (buffer); + iter = gegl_buffer_iterator_new (buffer, NULL, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); + n_components = babl_format_get_n_components (format); + g_return_val_if_fail (n_components == 2, FALSE); + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *data = iter->data[0]; ++ const guchar *data = iter->items[0].data; + gint length = iter->length; + + while (length--) +@@ -2161,13 +2162,13 @@ find_unused_ia_color (GeglBuffer *buffer, + + format = gegl_buffer_get_format (buffer); + iter = gegl_buffer_iterator_new (buffer, NULL, 0, format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); + n_components = babl_format_get_n_components (format); + g_return_val_if_fail (n_components == 2, FALSE); + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *data = iter->data[0]; ++ const guchar *data = iter->items[0].data; + gint length = iter->length; + + while (length--) +diff --git a/plug-ins/common/gradient-map.c b/plug-ins/common/gradient-map.c +index c5ad659d5b..a3afdc7250 100644 +--- plug-ins/common/gradient-map.c ++++ plug-ins/common/gradient-map.c +@@ -18,6 +18,7 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + #include + +@@ -265,7 +266,7 @@ map (GeglBuffer *buffer, + } + + gi = gegl_buffer_iterator_new (shadow_buffer, NULL, 0, format_shadow, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 2); + + index_iter = gegl_buffer_iterator_add (gi, buffer, NULL, + 0, format_buffer, +@@ -277,8 +278,8 @@ map (GeglBuffer *buffer, + gfloat *data; + gfloat *data2; + +- data = (gfloat*) gi->data[0]; +- data2 = (gfloat*) gi->data[index_iter]; ++ data = (gfloat*) gi->items[0].data; ++ data2 = (gfloat*) gi->items[index_iter].data; + + if (interpolate) + { +diff --git a/plug-ins/common/qbist.c b/plug-ins/common/qbist.c +index b8fa2621c5..2cf6a34b40 100644 +--- plug-ins/common/qbist.c ++++ plug-ins/common/qbist.c +@@ -26,6 +26,7 @@ + * + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -501,7 +502,7 @@ run (const gchar *name, + img_width, img_height), + 0, babl_format ("R'G'B'A float"), + GEGL_ACCESS_READWRITE, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 1); + + optimize (&qbist_info.info); + +@@ -509,8 +510,8 @@ run (const gchar *name, + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; +- GeglRectangle roi = iter->roi[0]; ++ gfloat *data = iter->items[0].data; ++ GeglRectangle roi = iter->items[0].roi; + gint row; + + for (row = 0; row < roi.height; row++) +diff --git a/plug-ins/file-psd/psd-load.c b/plug-ins/file-psd/psd-load.c +index bab190a975..690321a145 100644 +--- plug-ins/file-psd/psd-load.c ++++ plug-ins/file-psd/psd-load.c +@@ -18,6 +18,7 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -1872,11 +1873,11 @@ add_merged_image (gint32 image_id, + iter = gegl_buffer_iterator_new (buffer, NULL, 0, + babl_format ("R'G'B'A float"), + GEGL_ACCESS_READWRITE, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- gfloat *data = iter->data[0]; ++ gfloat *data = iter->items[0].data; + + for (i = 0; i < iter->length; i++) + { +diff --git a/plug-ins/file-psd/psd-save.c b/plug-ins/file-psd/psd-save.c +index 1952d6cd5f..dc643ef96e 100644 +--- plug-ins/file-psd/psd-save.c ++++ plug-ins/file-psd/psd-save.c +@@ -63,6 +63,7 @@ + * BUGS: + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -1467,11 +1468,11 @@ create_merged_image (gint32 image_id) + GeglBufferIterator *iter; + + iter = gegl_buffer_iterator_new (buffer, NULL, 0, format, +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *d = iter->data[0]; ++ guchar *d = iter->items[0].data; + gint i; + + for (i = 0; i < iter->length; i++) +diff --git a/plug-ins/file-tiff/file-tiff-load.c b/plug-ins/file-tiff/file-tiff-load.c +index 6d68495385..1097c31342 100644 +--- plug-ins/file-tiff/file-tiff-load.c ++++ plug-ins/file-tiff/file-tiff-load.c +@@ -42,6 +42,7 @@ + * other special, indirect and consequential damages. + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -1469,7 +1470,7 @@ load_contiguous (TIFF *tif, + GEGL_RECTANGLE (0, 0, cols, rows), + 0, NULL, + GEGL_ACCESS_READ, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 2); + gegl_buffer_iterator_add (iter, channel[i].buffer, + GEGL_RECTANGLE (x, y, cols, rows), + 0, channel[i].format, +@@ -1477,8 +1478,8 @@ load_contiguous (TIFF *tif, + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *s = iter->data[0]; +- guchar *d = iter->data[1]; ++ guchar *s = iter->items[0].data; ++ guchar *d = iter->items[1].data; + gint length = iter->length; + + s += offset; +@@ -1619,7 +1620,7 @@ load_separate (TIFF *tif, + GEGL_RECTANGLE (0, 0, cols, rows), + 0, NULL, + GEGL_ACCESS_READ, +- GEGL_ABYSS_NONE); ++ GEGL_ABYSS_NONE, 2); + gegl_buffer_iterator_add (iter, channel[i].buffer, + GEGL_RECTANGLE (x, y, cols, rows), + 0, channel[i].format, +@@ -1628,8 +1629,8 @@ load_separate (TIFF *tif, + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *s = iter->data[0]; +- guchar *d = iter->data[1]; ++ guchar *s = iter->items[0].data; ++ guchar *d = iter->items[1].data; + gint length = iter->length; + + d += offset; +diff --git a/plug-ins/ifs-compose/ifs-compose.c b/plug-ins/ifs-compose/ifs-compose.c +index df3df2ed4c..372ef46f87 100644 +--- plug-ins/ifs-compose/ifs-compose.c ++++ plug-ins/ifs-compose/ifs-compose.c +@@ -27,6 +27,7 @@ + * 2. Figure out if we need multiple phases for supersampled brushes. + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -1313,12 +1314,12 @@ ifs_compose (gint32 drawable_id) + GEGL_RECTANGLE (0, band_y, + width, band_height), 0, + format, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { +- guchar *destrow = iter->data[0]; ++ guchar *destrow = iter->items[0].data; + + for (j = roi->y; j < (roi->y + roi->height); j++) + { +diff --git a/plug-ins/pagecurl/pagecurl.c b/plug-ins/pagecurl/pagecurl.c +index 1f6655c695..40442565c0 100644 +--- plug-ins/pagecurl/pagecurl.c ++++ plug-ins/pagecurl/pagecurl.c +@@ -39,7 +39,7 @@ + * 1.0: (July '04) + * - Code cleanup, added reverse gradient option. + */ +- ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -738,7 +738,7 @@ do_curl_effect (gint32 drawable_id) + iter = gegl_buffer_iterator_new (curl_buffer, + GEGL_RECTANGLE (0, 0, width, height), 0, + format, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1); + + /* Init shade_under */ + gimp_vector2_set (&dl, -sel_width, -sel_height); +@@ -770,8 +770,8 @@ do_curl_effect (gint32 drawable_id) + { + gfloat *dest; + +- roi = &iter->roi[0]; +- dest = (gfloat *) iter->data[0]; ++ roi = &iter->items[0].roi; ++ dest = (gfloat *) iter->items[0].data; + + for (y1 = roi->y; y1 < roi->y + roi->height; y1++) + { +@@ -905,16 +905,16 @@ clear_curled_region (gint32 drawable_id) + iter = gegl_buffer_iterator_new (shadow_buf, + GEGL_RECTANGLE (0, 0, width, height), 0, + format, +- GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 2); + buf_index = gegl_buffer_iterator_add (iter, buf, NULL, 0, + format, + GEGL_ACCESS_READ, GEGL_ABYSS_NONE); + + while (gegl_buffer_iterator_next (iter)) + { +- roi = &iter->roi[0]; +- dest = iter->data[0]; +- src = iter->data[buf_index]; ++ roi = &iter->items[0].roi; ++ dest = iter->items[0].data; ++ src = iter->items[buf_index].data; + + memcpy (dest, src, roi->width * roi->height * bpp); + +diff --git a/plug-ins/print/print-draw-page.c b/plug-ins/print/print-draw-page.c +index 250114f508..26a2ac96a8 100644 +--- plug-ins/print/print-draw-page.c ++++ plug-ins/print/print-draw-page.c +@@ -15,6 +15,7 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -140,23 +141,23 @@ print_surface_from_drawable (gint32 drawable_ID, + iter = gegl_buffer_iterator_new (buffer, + GEGL_RECTANGLE (0, 0, width, height), 0, + format, +- GEGL_ACCESS_READ, GEGL_ABYSS_NONE); ++ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); + + while (gegl_buffer_iterator_next (iter)) + { +- const guchar *src = iter->data[0]; +- guchar *dest = pixels + iter->roi->y * stride + iter->roi->x * 4; ++ const guchar *src = iter->items[0].data; ++ guchar *dest = pixels + iter->items[0].roi.y * stride + iter->items[0].roi.x * 4; + gint y; + +- for (y = 0; y < iter->roi->height; y++) ++ for (y = 0; y < iter->items[0].roi.height; y++) + { +- memcpy (dest, src, iter->roi->width * 4); ++ memcpy (dest, src, iter->items[0].roi.width * 4); + +- src += iter->roi->width * 4; ++ src += iter->items[0].roi.width * 4; + dest += stride; + } + +- done += iter->roi->height * iter->roi->width; ++ done += iter->items[0].roi.height * iter->items[0].roi.width; + + if (count++ % 16 == 0) + gimp_progress_update ((gdouble) done / (width * height)); +diff --git a/plug-ins/screenshot/screenshot-x11.c b/plug-ins/screenshot/screenshot-x11.c +index ac8dfd2740..61c9e535c2 100644 +--- plug-ins/screenshot/screenshot-x11.c ++++ plug-ins/screenshot/screenshot-x11.c +@@ -20,6 +20,7 @@ + * along with this program. If not, see . + */ + ++#define GEGL_ITERATOR2_API + #include "config.h" + + #include +@@ -478,13 +479,13 @@ add_cursor_image (gint32 image, + gimp_drawable_width (layer), + gimp_drawable_height (layer)), + 0, babl_format ("R'G'B'A u8"), +- GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE); +- roi = &iter->roi[0]; ++ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1); ++ roi = &iter->items[0].roi; + + while (gegl_buffer_iterator_next (iter)) + { + const gulong *src = cursor->pixels + roi->y * cursor->width + roi->x; +- guchar *dest = iter->data[0]; ++ guchar *dest = iter->items[0].data; + gint x, y; + + for (y = 0; y < roi->height; y++) +