[gimp/goat-invasion: 402/608] app: s/GIMP_GEGL_RECT/GEGL_RECTANGLE/



commit 458c2c72cba363b6e6d8c818f8514bf3f44296b4
Author: Ãyvind KolÃs <pippin gimp org>
Date:   Mon Apr 2 14:19:47 2012 +0100

    app: s/GIMP_GEGL_RECT/GEGL_RECTANGLE/
    
    Defining GeglRectangle inline is so useful that it has been added to
    GEGL.

 app/core/gimp-apply-operation.c     |    2 +-
 app/core/gimp-edit.c                |    6 +++---
 app/core/gimpchannel-combine.c      |    4 ++--
 app/core/gimpchannel.c              |   18 +++++++++---------
 app/core/gimpdrawable-blend.c       |   22 +++++++++++-----------
 app/core/gimpdrawable-bucket-fill.c |    4 ++--
 app/core/gimpdrawable-combine.c     |    6 +++---
 app/core/gimpdrawable-convert.c     |    6 +++---
 app/core/gimpdrawable-offset.c      |   10 +++++-----
 app/core/gimpdrawable-shadow.c      |    4 ++--
 app/core/gimpdrawable-stroke.c      |    6 +++---
 app/core/gimpdrawable-transform.c   |    8 ++++----
 app/core/gimpdrawable.c             |   34 +++++++++++++++++-----------------
 app/core/gimpimage-convert.c        |   10 +++++-----
 app/core/gimpimage-merge.c          |    2 +-
 app/core/gimpimagemap.c             |   14 +++++++-------
 app/core/gimplayer-floating-sel.c   |    2 +-
 app/core/gimplayer.c                |   10 +++++-----
 app/core/gimpmaskundo.c             |   10 +++++-----
 app/core/gimppatternclipboard.c     |    2 +-
 app/core/gimpprojection-construct.c |    2 +-
 app/core/gimpselection.c            |    6 +++---
 app/gegl/gimp-gegl-utils.c          |    4 ++--
 app/gegl/gimp-gegl-utils.h          |    2 --
 app/gegl/gimpoperationborder.c      |   20 ++++++++++----------
 app/gegl/gimpoperationgrow.c        |    6 +++---
 app/gegl/gimpoperationshapeburst.c  |    4 ++--
 app/gegl/gimpoperationshrink.c      |    6 +++---
 app/paint/gimpclone.c               |    6 +++---
 app/paint/gimpconvolve.c            |    8 ++++----
 app/paint/gimpdodgeburn.c           |    2 +-
 app/paint/gimpheal.c                |   10 +++++-----
 app/paint/gimpink.c                 |    2 +-
 app/paint/gimppaintcore.c           |   16 ++++++++--------
 app/paint/gimpperspectiveclone.c    |    6 +++---
 app/paint/gimpsmudge.c              |    8 ++++----
 app/paint/gimpsourcecore.c          |    2 +-
 app/pdb/drawable-cmds.c             |    2 +-
 app/text/gimptextlayer.c            |    4 ++--
 tools/pdbgen/pdb/drawable.pdb       |    2 +-
 40 files changed, 148 insertions(+), 150 deletions(-)
---
diff --git a/app/core/gimp-apply-operation.c b/app/core/gimp-apply-operation.c
index 57f0574..7cfc770 100644
--- a/app/core/gimp-apply-operation.c
+++ b/app/core/gimp-apply-operation.c
@@ -59,7 +59,7 @@ gimp_apply_operation (GeglBuffer          *src_buffer,
     }
   else
     {
-      rect = *GIMP_GEGL_RECT (0, 0, gegl_buffer_get_width  (dest_buffer),
+      rect = *GEGL_RECTANGLE (0, 0, gegl_buffer_get_width  (dest_buffer),
                                     gegl_buffer_get_height (dest_buffer));
     }
 
diff --git a/app/core/gimp-edit.c b/app/core/gimp-edit.c
index 6eb4107..49863e8 100644
--- a/app/core/gimp-edit.c
+++ b/app/core/gimp-edit.c
@@ -480,7 +480,7 @@ gimp_edit_fill_full (GimpImage            *image,
         }
     }
 
-  dest_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+  dest_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                       format);
 
   if (pattern)
@@ -499,7 +499,7 @@ gimp_edit_fill_full (GimpImage            *image,
     }
 
   gimp_drawable_apply_buffer (drawable, dest_buffer,
-                              GIMP_GEGL_RECT (0, 0, width, height),
+                              GEGL_RECTANGLE (0, 0, width, height),
                               TRUE, undo_desc,
                               opacity, paint_mode,
                               NULL, x, y,
@@ -536,7 +536,7 @@ gimp_edit_fade (GimpImage   *image,
       gimp_image_undo (image);
 
       gimp_drawable_apply_buffer (drawable, buffer,
-                                  GIMP_GEGL_RECT (0, 0,
+                                  GEGL_RECTANGLE (0, 0,
                                                   gegl_buffer_get_width (undo->buffer),
                                                   gegl_buffer_get_height (undo->buffer)),
                                   TRUE,
diff --git a/app/core/gimpchannel-combine.c b/app/core/gimpchannel-combine.c
index 643971b..d208d42 100644
--- a/app/core/gimpchannel-combine.c
+++ b/app/core/gimpchannel-combine.c
@@ -57,7 +57,7 @@ gimp_channel_combine_rect (GimpChannel    *mask,
     color = gegl_color_new ("#000");
 
   gegl_buffer_set_color (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)),
-                         GIMP_GEGL_RECT (x, y, w, h), color);
+                         GEGL_RECTANGLE (x, y, w, h), color);
   g_object_unref (color);
 
   /*  Determine new boundary  */
@@ -237,7 +237,7 @@ gimp_channel_combine_ellipse_rect (GimpChannel    *mask,
   buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));
 
   iter = gegl_buffer_iterator_new (buffer,
-                                   GIMP_GEGL_RECT (x0, y0, width, height), 0,
+                                   GEGL_RECTANGLE (x0, y0, width, height), 0,
                                    babl_format ("Y u8"), GEGL_BUFFER_READWRITE,
                                    GEGL_ABYSS_NONE);
   roi = &iter->roi[0];
diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c
index 5378526..e2b491b 100644
--- a/app/core/gimpchannel.c
+++ b/app/core/gimpchannel.c
@@ -459,7 +459,7 @@ gimp_channel_convert (GimpItem  *item,
       format = gimp_drawable_get_format_without_alpha (drawable);
 
       new_buffer =
-        gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+        gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                               gimp_item_get_width (item),
                                               gimp_item_get_height (item)),
                               format);
@@ -538,9 +538,9 @@ gimp_channel_translate (GimpItem *item,
       tmp_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (tmp_mask));
 
       gegl_buffer_copy (gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
-                        GIMP_GEGL_RECT (x1 - off_x, y1 - off_y, width, height),
+                        GEGL_RECTANGLE (x1 - off_x, y1 - off_y, width, height),
                         tmp_buffer,
-                        GIMP_GEGL_RECT (0,0,0,0));
+                        GEGL_RECTANGLE (0,0,0,0));
     }
 
   /*  clear the mask  */
@@ -554,7 +554,7 @@ gimp_channel_translate (GimpItem *item,
       gegl_buffer_copy (tmp_buffer,
                         NULL,
                         gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
-                        GIMP_GEGL_RECT (x1, y1, 0, 0));
+                        GEGL_RECTANGLE (x1, y1, 0, 0));
 
       /*  free the temporary mask  */
       g_object_unref (tmp_mask);
@@ -608,7 +608,7 @@ gimp_channel_scale (GimpItem              *item,
       GeglBuffer   *new_buffer;
 
       new_buffer =
-        gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, new_width, new_height),
+        gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, new_width, new_height),
                               gimp_drawable_get_format (drawable));
 
       gimp_drawable_set_buffer_full (drawable,
@@ -1308,7 +1308,7 @@ gimp_channel_real_clear (GimpChannel *channel,
   if (channel->bounds_known && ! channel->empty)
     {
       gegl_buffer_clear (gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
-                         GIMP_GEGL_RECT (channel->x1, channel->y1,
+                         GEGL_RECTANGLE (channel->x1, channel->y1,
                                          channel->x2 - channel->x1,
                                          channel->y2 - channel->y1));
     }
@@ -1456,7 +1456,7 @@ gimp_channel_real_border (GimpChannel *channel,
                         NULL, NULL,
                         border,
                         gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
-                        GIMP_GEGL_RECT (x1, y1, x2 - x1, y2 - y1));
+                        GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1));
 
   g_object_unref (border);
 
@@ -1530,7 +1530,7 @@ gimp_channel_real_grow (GimpChannel *channel,
                         NULL, NULL,
                         grow,
                         gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
-                        GIMP_GEGL_RECT (x1, y1, x2 - x1, y2 - y1));
+                        GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1));
 
   g_object_unref (grow);
 
@@ -1595,7 +1595,7 @@ gimp_channel_real_shrink (GimpChannel *channel,
                         NULL, NULL,
                         shrink,
                         gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)),
-                        GIMP_GEGL_RECT (x1, y1, x2 - x1, y2 - y1));
+                        GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1));
 
   g_object_unref (shrink);
 
diff --git a/app/core/gimpdrawable-blend.c b/app/core/gimpdrawable-blend.c
index 8c723ec..f447462 100644
--- a/app/core/gimpdrawable-blend.c
+++ b/app/core/gimpdrawable-blend.c
@@ -206,7 +206,7 @@ gimp_drawable_blend (GimpDrawable         *drawable,
   gimp_set_busy (image->gimp);
 
   /*  Always create an alpha temp buf (for generality) */
-  buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+  buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                  gimp_drawable_get_format_with_alpha (drawable));
 
   pixel_region_init (&bufPR, gimp_gegl_buffer_get_tiles (buffer),
@@ -223,7 +223,7 @@ gimp_drawable_blend (GimpDrawable         *drawable,
   gimp_gegl_buffer_refetch_tiles (buffer);
 
   gimp_drawable_apply_buffer (drawable, buffer,
-                              GIMP_GEGL_RECT (0, 0, width, height),
+                              GEGL_RECTANGLE (0, 0, width, height),
                               TRUE, C_("undo-type", "Blend"),
                               opacity, paint_mode,
                               NULL, x, y,
@@ -494,7 +494,7 @@ gradient_calc_shapeburst_angular_factor (GeglBuffer *dist_buffer,
   gint   iy = CLAMP (y, 0.0, gegl_buffer_get_height (dist_buffer) - 0.7);
   gfloat value;
 
-  gegl_buffer_get (dist_buffer, GIMP_GEGL_RECT (ix, iy, 1, 1), 1.0,
+  gegl_buffer_get (dist_buffer, GEGL_RECTANGLE (ix, iy, 1, 1), 1.0,
                    NULL, &value,
                    GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
@@ -513,7 +513,7 @@ gradient_calc_shapeburst_spherical_factor (GeglBuffer *dist_buffer,
   gint   iy = CLAMP (y, 0.0, gegl_buffer_get_height (dist_buffer) - 0.7);
   gfloat value;
 
-  gegl_buffer_get (dist_buffer, GIMP_GEGL_RECT (ix, iy, 1, 1), 1.0,
+  gegl_buffer_get (dist_buffer, GEGL_RECTANGLE (ix, iy, 1, 1), 1.0,
                    NULL, &value,
                    GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
@@ -532,7 +532,7 @@ gradient_calc_shapeburst_dimpled_factor (GeglBuffer *dist_buffer,
   gint   iy = CLAMP (y, 0.0, gegl_buffer_get_height (dist_buffer) - 0.7);
   gfloat value;
 
-  gegl_buffer_get (dist_buffer, GIMP_GEGL_RECT (ix, iy, 1, 1), 1.0,
+  gegl_buffer_get (dist_buffer, GEGL_RECTANGLE (ix, iy, 1, 1), 1.0,
                    NULL, &value,
                    GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
@@ -558,11 +558,11 @@ gradient_precalc_shapeburst (GimpImage    *image,
   gimp_progress_set_text (progress, _("Calculating distance map"));
 
   /*  allocate the distance map  */
-  dist_buffer = gegl_buffer_new (GIMP_GEGL_RECT (0, 0, PR->w, PR->h),
+  dist_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, PR->w, PR->h),
                                  babl_format ("Y float"));
 
   /*  allocate the selection mask copy  */
-  temp_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, PR->w, PR->h),
+  temp_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, PR->w, PR->h),
                                       babl_format ("Y u8"));
 
   mask = gimp_image_get_mask (image);
@@ -578,9 +578,9 @@ gradient_precalc_shapeburst (GimpImage    *image,
 
       /*  copy the mask to the temp mask  */
       gegl_buffer_copy (gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)),
-                        GIMP_GEGL_RECT (x+off_x, y + off_y, width, height),
+                        GEGL_RECTANGLE (x+off_x, y + off_y, width, height),
                         temp_buffer,
-                        GIMP_GEGL_RECT (0,0,0,0));
+                        GEGL_RECTANGLE (0,0,0,0));
     }
   else
     {
@@ -590,9 +590,9 @@ gradient_precalc_shapeburst (GimpImage    *image,
           /*  extract the aplha into the temp mask  */
           gegl_buffer_set_format (temp_buffer, babl_format ("A u8"));
           gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                            GIMP_GEGL_RECT (PR->x, PR->y, PR->w, PR->h),
+                            GEGL_RECTANGLE (PR->x, PR->y, PR->w, PR->h),
                             temp_buffer,
-                            GIMP_GEGL_RECT (0, 0, 0, 0));
+                            GEGL_RECTANGLE (0, 0, 0, 0));
           gegl_buffer_set_format (temp_buffer, NULL);
         }
       else
diff --git a/app/core/gimpdrawable-bucket-fill.c b/app/core/gimpdrawable-bucket-fill.c
index 8f540b3..00e97c2 100644
--- a/app/core/gimpdrawable-bucket-fill.c
+++ b/app/core/gimpdrawable-bucket-fill.c
@@ -220,7 +220,7 @@ gimp_drawable_bucket_fill_internal (GimpDrawable        *drawable,
       mask_offset_y = y1;
     }
 
-  buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, x2 - x1, y2 - y1),
+  buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
                                  gimp_drawable_get_format_with_alpha (drawable));
 
   switch (fill_mode)
@@ -259,7 +259,7 @@ gimp_drawable_bucket_fill_internal (GimpDrawable        *drawable,
 
   /*  Apply it to the image  */
   gimp_drawable_apply_buffer (drawable, buffer,
-                              GIMP_GEGL_RECT (0, 0, x2 - x1, y2 - y1),
+                              GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
                               TRUE, C_("undo-type", "Bucket Fill"),
                               opacity, paint_mode,
                               NULL, x1, y1,
diff --git a/app/core/gimpdrawable-combine.c b/app/core/gimpdrawable-combine.c
index 3f4eb15..514e09b 100644
--- a/app/core/gimpdrawable-combine.c
+++ b/app/core/gimpdrawable-combine.c
@@ -140,15 +140,15 @@ gimp_drawable_real_apply_buffer (GimpDrawable         *drawable,
           undo->opacity    = opacity;
 
           undo->applied_buffer =
-            gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+            gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                   gegl_buffer_get_format (buffer));
 
           gegl_buffer_copy (buffer,
-                            GIMP_GEGL_RECT (buffer_region->x + (x - base_x),
+                            GEGL_RECTANGLE (buffer_region->x + (x - base_x),
                                             buffer_region->y + (y - base_y),
                                             width, height),
                             undo->applied_buffer,
-                            GIMP_GEGL_RECT (0, 0, width, height));
+                            GEGL_RECTANGLE (0, 0, width, height));
         }
     }
 
diff --git a/app/core/gimpdrawable-convert.c b/app/core/gimpdrawable-convert.c
index 31c4aac..073cbb7 100644
--- a/app/core/gimpdrawable-convert.c
+++ b/app/core/gimpdrawable-convert.c
@@ -51,7 +51,7 @@ gimp_drawable_convert_rgb (GimpDrawable *drawable,
     type = GIMP_IMAGE_TYPE_WITH_ALPHA (type);
 
   dest_buffer =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                           gimp_item_get_width  (GIMP_ITEM (drawable)),
                                           gimp_item_get_height (GIMP_ITEM (drawable))),
                           gimp_image_get_format (dest_image, type));
@@ -81,7 +81,7 @@ gimp_drawable_convert_grayscale (GimpDrawable *drawable,
     type = GIMP_IMAGE_TYPE_WITH_ALPHA (type);
 
   dest_buffer =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                           gimp_item_get_width  (GIMP_ITEM (drawable)),
                                           gimp_item_get_height (GIMP_ITEM (drawable))),
                           gimp_image_get_format (dest_image, type));
@@ -111,7 +111,7 @@ gimp_drawable_convert_indexed (GimpDrawable *drawable,
     format = gimp_image_colormap_get_rgb_format (dest_image);
 
   dest_buffer =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                           gimp_item_get_width  (GIMP_ITEM (drawable)),
                                           gimp_item_get_height (GIMP_ITEM (drawable))),
                           format);
diff --git a/app/core/gimpdrawable-offset.c b/app/core/gimpdrawable-offset.c
index 2033f74..1875c9f 100644
--- a/app/core/gimpdrawable-offset.c
+++ b/app/core/gimpdrawable-offset.c
@@ -85,7 +85,7 @@ gimp_drawable_offset (GimpDrawable   *drawable,
 
   src_buffer = gimp_drawable_get_buffer (drawable);
 
-  new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+  new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                      gimp_drawable_get_format (drawable));
 
   if (! wrap_around)
@@ -137,9 +137,9 @@ gimp_drawable_offset (GimpDrawable   *drawable,
   if (width && height)
     {
       gegl_buffer_copy (src_buffer,
-                        GIMP_GEGL_RECT (src_x,  src_y,  width, height),
+                        GEGL_RECTANGLE (src_x,  src_y,  width, height),
                         new_buffer,
-                        GIMP_GEGL_RECT (dest_x,dest_y,  width, height));
+                        GEGL_RECTANGLE (dest_x,dest_y,  width, height));
     }
 
   if (wrap_around)
@@ -179,10 +179,10 @@ gimp_drawable_offset (GimpDrawable   *drawable,
       if (offset_x != 0 && offset_y != 0)
         {
           gegl_buffer_copy (src_buffer,
-                            GIMP_GEGL_RECT (src_x, src_y,
+                            GEGL_RECTANGLE (src_x, src_y,
                                             ABS (offset_x), ABS (offset_y)),
                             new_buffer,
-                            GIMP_GEGL_RECT (dest_x, dest_y, 0, 0));
+                            GEGL_RECTANGLE (dest_x, dest_y, 0, 0));
         }
 
       /*  X offset  */
diff --git a/app/core/gimpdrawable-shadow.c b/app/core/gimpdrawable-shadow.c
index bb89e3f..2d349e8 100644
--- a/app/core/gimpdrawable-shadow.c
+++ b/app/core/gimpdrawable-shadow.c
@@ -62,7 +62,7 @@ gimp_drawable_get_shadow_buffer (GimpDrawable *drawable)
     }
 
   drawable->private->shadow =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height), format);
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height), format);
 
   return drawable->private->shadow;
 }
@@ -100,7 +100,7 @@ gimp_drawable_merge_shadow_buffer (GimpDrawable *drawable,
       GeglBuffer *buffer = g_object_ref (drawable->private->shadow);
 
       gimp_drawable_apply_buffer (drawable, buffer,
-                                  GIMP_GEGL_RECT (x, y, width, height),
+                                  GEGL_RECTANGLE (x, y, width, height),
                                   push_undo, undo_desc,
                                   GIMP_OPACITY_OPAQUE, GIMP_REPLACE_MODE,
                                   NULL, x, y,
diff --git a/app/core/gimpdrawable-stroke.c b/app/core/gimpdrawable-stroke.c
index 0972b09..5d89a5f 100644
--- a/app/core/gimpdrawable-stroke.c
+++ b/app/core/gimpdrawable-stroke.c
@@ -338,7 +338,7 @@ gimp_drawable_stroke_scan_convert (GimpDrawable    *drawable,
   /* fill a 1-bpp GeglBuffer with black, this will describe the shape
    * of the stroke.
    */
-  mask_buffer = gegl_buffer_new (GIMP_GEGL_RECT (0, 0, w, h),
+  mask_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, w, h),
                                  babl_format ("Y u8"));
 
   gegl_buffer_clear (mask_buffer, NULL);
@@ -350,7 +350,7 @@ gimp_drawable_stroke_scan_convert (GimpDrawable    *drawable,
                             x + off_x, y + off_y,
                             gimp_fill_options_get_antialias (options));
 
-  base_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, w, h),
+  base_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, w, h),
                                       gimp_drawable_get_format_with_alpha (drawable));
 
   switch (gimp_fill_options_get_style (options))
@@ -392,7 +392,7 @@ gimp_drawable_stroke_scan_convert (GimpDrawable    *drawable,
 
   /* Apply to drawable */
   gimp_drawable_apply_buffer (drawable, base_buffer,
-                              GIMP_GEGL_RECT (0, 0, w, h),
+                              GEGL_RECTANGLE (0, 0, w, h),
                               push_undo, C_("undo-type", "Render Stroke"),
                               gimp_context_get_opacity (context),
                               gimp_context_get_paint_mode (context),
diff --git a/app/core/gimpdrawable-transform.c b/app/core/gimpdrawable-transform.c
index 9867aad..c62cc30 100644
--- a/app/core/gimpdrawable-transform.c
+++ b/app/core/gimpdrawable-transform.c
@@ -127,7 +127,7 @@ gimp_drawable_transform_buffer_affine (GimpDrawable           *drawable,
                                   &x1, &y1, &x2, &y2);
 
   /*  Get the new temporary buffer for the transformed result  */
-  new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, x2 - x1, y2 - y1),
+  new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
                                      gegl_buffer_get_format (orig_buffer));
 
   gimp_matrix3_identity (&gegl_matrix);
@@ -208,7 +208,7 @@ gimp_drawable_transform_buffer_flip (GimpDrawable        *drawable,
       break;
     }
 
-  new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+  new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                      new_width, new_height),
                                      gegl_buffer_get_format (orig_buffer));
 
@@ -419,7 +419,7 @@ gimp_drawable_transform_buffer_rotate (GimpDrawable     *drawable,
       gint       clip_x, clip_y;
       gint       clip_width, clip_height;
 
-      new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+      new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                          orig_width, orig_height),
                                          gegl_buffer_get_format (orig_buffer));
 
@@ -496,7 +496,7 @@ gimp_drawable_transform_buffer_rotate (GimpDrawable     *drawable,
     }
   else
     {
-      new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+      new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                          new_width, new_height),
                                          gegl_buffer_get_format (orig_buffer));
 
diff --git a/app/core/gimpdrawable.c b/app/core/gimpdrawable.c
index 9ae5014..92d6d73 100644
--- a/app/core/gimpdrawable.c
+++ b/app/core/gimpdrawable.c
@@ -430,7 +430,7 @@ gimp_drawable_scale (GimpItem              *item,
   GeglBuffer   *new_buffer;
   GeglNode     *scale;
 
-  new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+  new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                      new_width, new_height),
                                      gimp_drawable_get_format (drawable));
 
@@ -498,7 +498,7 @@ gimp_drawable_resize (GimpItem    *item,
                             &copy_width,
                             &copy_height);
 
-  new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+  new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                      new_width, new_height),
                                      gimp_drawable_get_format (drawable));
 
@@ -525,12 +525,12 @@ gimp_drawable_resize (GimpItem    *item,
     {
       /*  Copy the pixels in the intersection  */
       gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                        GIMP_GEGL_RECT (copy_x - gimp_item_get_offset_x (item),
+                        GEGL_RECTANGLE (copy_x - gimp_item_get_offset_x (item),
                                         copy_y - gimp_item_get_offset_y (item),
                                         copy_width,
                                         copy_height),
                         new_buffer,
-                        GIMP_GEGL_RECT (copy_x - new_offset_x,
+                        GEGL_RECTANGLE (copy_x - new_offset_x,
                                         copy_y - new_offset_y, 0, 0));
     }
 
@@ -673,7 +673,7 @@ gimp_drawable_real_update (GimpDrawable *drawable,
       if (operation)
         {
           gegl_operation_invalidate (GEGL_OPERATION (operation),
-                                     GIMP_GEGL_RECT (x,y,width,height), FALSE);
+                                     GEGL_RECTANGLE (x,y,width,height), FALSE);
           g_object_unref (operation);
         }
     }
@@ -812,13 +812,13 @@ gimp_drawable_real_push_undo (GimpDrawable *drawable,
 {
   if (! buffer)
     {
-      buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+      buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                      gimp_drawable_get_format (drawable));
 
       gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                        GIMP_GEGL_RECT (x, y, width, height),
+                        GEGL_RECTANGLE (x, y, width, height),
                         buffer,
-                        GIMP_GEGL_RECT (0, 0, 0, 0));
+                        GEGL_RECTANGLE (0, 0, 0, 0));
     }
   else
     {
@@ -845,13 +845,13 @@ gimp_drawable_real_swap_pixels (GimpDrawable *drawable,
   tmp = gimp_gegl_buffer_dup (buffer);
 
   gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                    GIMP_GEGL_RECT (x, y, width, height),
+                    GEGL_RECTANGLE (x, y, width, height),
                     buffer,
-                    GIMP_GEGL_RECT (0, 0, 0, 0));
+                    GEGL_RECTANGLE (0, 0, 0, 0));
   gegl_buffer_copy (tmp,
-                    GIMP_GEGL_RECT (0, 0, width, height),
+                    GEGL_RECTANGLE (0, 0, width, height),
                     gimp_drawable_get_buffer (drawable),
-                    GIMP_GEGL_RECT (x, y, 0, 0));
+                    GEGL_RECTANGLE (x, y, 0, 0));
 
   g_object_unref (tmp);
 
@@ -1081,7 +1081,7 @@ gimp_drawable_new (GType          type,
                                            offset_x, offset_y,
                                            width, height));
 
-  drawable->private->buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+  drawable->private->buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                                     width, height),
                                                     format);
 
@@ -1292,14 +1292,14 @@ gimp_drawable_init_src_region (GimpDrawable  *drawable,
           /*  a temporary buffer for the compisition of the drawable and
            *  its floating selection
            */
-          *temp_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+          *temp_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                                width, height),
                                                gimp_drawable_get_format (drawable));
 
           gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                            GIMP_GEGL_RECT (x, y, width, height),
+                            GEGL_RECTANGLE (x, y, width, height),
                             *temp_buffer,
-                            GIMP_GEGL_RECT (0, 0, 0, 0));
+                            GEGL_RECTANGLE (0, 0, 0, 0));
 
           /*  then, apply the floating selection onto the buffer just as
            *  we apply it onto the drawable when anchoring the floating
@@ -1314,7 +1314,7 @@ gimp_drawable_init_src_region (GimpDrawable  *drawable,
 
           gimp_drawable_apply_buffer (drawable,
                                       gimp_drawable_get_buffer (GIMP_DRAWABLE (fs)),
-                                      GIMP_GEGL_RECT (combine_x - fs_off_x,
+                                      GEGL_RECTANGLE (combine_x - fs_off_x,
                                                       combine_y - fs_off_y,
                                                       combine_width,
                                                       combine_height),
diff --git a/app/core/gimpimage-convert.c b/app/core/gimpimage-convert.c
index 152c80f..5c59733 100644
--- a/app/core/gimpimage-convert.c
+++ b/app/core/gimpimage-convert.c
@@ -1011,7 +1011,7 @@ gimp_image_convert (GimpImage               *image,
                         babl_format_has_alpha (new_format));
 
             new_buffer =
-              gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+              gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                     gimp_item_get_width  (GIMP_ITEM (layer)),
                                                     gimp_item_get_height (GIMP_ITEM (layer))),
                                     new_format);
@@ -3735,7 +3735,7 @@ median_cut_pass2_fs_dither_gray (QuantizeObj *quantobj,
       const guchar *src;
       guchar       *dest;
 
-      gegl_buffer_get (src_buffer, GIMP_GEGL_RECT (0, row, width, 1),
+      gegl_buffer_get (src_buffer, GEGL_RECTANGLE (0, row, width, 1),
                        1.0, NULL, src_buf,
                        GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
@@ -3875,7 +3875,7 @@ median_cut_pass2_fs_dither_gray (QuantizeObj *quantobj,
 
       odd_row = !odd_row;
 
-      gegl_buffer_set (new_buffer, GIMP_GEGL_RECT (0, row, width, 1),
+      gegl_buffer_set (new_buffer, GEGL_RECTANGLE (0, row, width, 1),
                        0, NULL, dest_buf,
                        GEGL_AUTO_ROWSTRIDE);
     }
@@ -4023,7 +4023,7 @@ median_cut_pass2_fs_dither_rgb (QuantizeObj *quantobj,
       const guchar *src;
       guchar       *dest;
 
-      gegl_buffer_get (src_buffer, GIMP_GEGL_RECT (0, row, width, 1),
+      gegl_buffer_get (src_buffer, GEGL_RECTANGLE (0, row, width, 1),
                        1.0, NULL, src_buf,
                        GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
@@ -4272,7 +4272,7 @@ median_cut_pass2_fs_dither_rgb (QuantizeObj *quantobj,
 
       odd_row = !odd_row;
 
-      gegl_buffer_set (new_buffer, GIMP_GEGL_RECT (0, row, width, 1),
+      gegl_buffer_set (new_buffer, GEGL_RECTANGLE (0, row, width, 1),
                        0, NULL, dest_buf,
                        GEGL_AUTO_ROWSTRIDE);
 
diff --git a/app/core/gimpimage-merge.c b/app/core/gimpimage-merge.c
index 10067f7..9fe0ccc 100644
--- a/app/core/gimpimage-merge.c
+++ b/app/core/gimpimage-merge.c
@@ -543,7 +543,7 @@ gimp_image_merge_layers (GimpImage     *image,
 
       color = gimp_gegl_color_new (&bg);
       gegl_buffer_set_color (gimp_drawable_get_buffer (GIMP_DRAWABLE (merge_layer)),
-                             GIMP_GEGL_RECT(0,0,x2-x1,y2-y1), color);
+                             GEGL_RECTANGLE(0,0,x2-x1,y2-y1), color);
       g_object_unref (color);
 
       position = 0;
diff --git a/app/core/gimpimagemap.c b/app/core/gimpimagemap.c
index 1d85d06..3e1c4dd 100644
--- a/app/core/gimpimagemap.c
+++ b/app/core/gimpimagemap.c
@@ -530,9 +530,9 @@ gimp_image_map_clear (GimpImageMap *image_map)
           gint height = gegl_buffer_get_height (image_map->undo_buffer);
 
           gegl_buffer_copy (image_map->undo_buffer,
-                            GIMP_GEGL_RECT (0, 0, width, height),
+                            GEGL_RECTANGLE (0, 0, width, height),
                             gimp_drawable_get_buffer (image_map->drawable),
-                            GIMP_GEGL_RECT (x, y, width, height));
+                            GEGL_RECTANGLE (x, y, width, height));
 
           gimp_drawable_update (image_map->drawable, x, y, width, height);
         }
@@ -601,7 +601,7 @@ gimp_image_map_update_undo_buffer (GimpImageMap        *image_map,
 
           /*  Allocate new tiles  */
           image_map->undo_buffer =
-            gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+            gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                   rect->width, rect->height),
                                   gimp_drawable_get_format (image_map->drawable));
         }
@@ -610,7 +610,7 @@ gimp_image_map_update_undo_buffer (GimpImageMap        *image_map,
       gegl_buffer_copy (gimp_drawable_get_buffer (image_map->drawable),
                         rect,
                         image_map->undo_buffer,
-                        GIMP_GEGL_RECT (0, 0, 0, 0));
+                        GEGL_RECTANGLE (0, 0, 0, 0));
 
       /*  Set the offsets  */
       image_map->undo_offset_x = rect->x;
@@ -680,17 +680,17 @@ gimp_image_map_data_written (GObject             *operation,
       /* Reset to initial drawable conditions. */
 
       gegl_buffer_copy (image_map->undo_buffer,
-                        GIMP_GEGL_RECT (extent->x - image_map->undo_offset_x,
+                        GEGL_RECTANGLE (extent->x - image_map->undo_offset_x,
                                         extent->y - image_map->undo_offset_y,
                                         extent->width, extent->height),
                         gimp_drawable_get_buffer (image_map->drawable),
-                        GIMP_GEGL_RECT (extent->x, extent->y, 0, 0));
+                        GEGL_RECTANGLE (extent->x, extent->y, 0, 0));
     }
 
   /* Apply the result of the gegl graph. */
   gimp_drawable_apply_buffer (image_map->drawable,
                               gimp_drawable_get_shadow_buffer (image_map->drawable),
-                              GIMP_GEGL_RECT (extent->x, extent->y,
+                              GEGL_RECTANGLE (extent->x, extent->y,
                                               extent->width, extent->height),
                               FALSE, NULL,
                               GIMP_OPACITY_OPAQUE, GIMP_REPLACE_MODE,
diff --git a/app/core/gimplayer-floating-sel.c b/app/core/gimplayer-floating-sel.c
index c883d1b..ab3f4d9 100644
--- a/app/core/gimplayer-floating-sel.c
+++ b/app/core/gimplayer-floating-sel.c
@@ -329,7 +329,7 @@ floating_sel_composite (GimpLayer *layer)
       fs_buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (layer));
 
       gimp_drawable_apply_buffer (drawable, fs_buffer,
-                                  GIMP_GEGL_RECT (combine_x - off_x,
+                                  GEGL_RECTANGLE (combine_x - off_x,
                                                   combine_y - off_y,
                                                   combine_width,
                                                   combine_height),
diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c
index 76c5125..921256c 100644
--- a/app/core/gimplayer.c
+++ b/app/core/gimplayer.c
@@ -1368,10 +1368,10 @@ gimp_layer_create_mask (const GimpLayer *layer,
             dest = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask));
 
             gegl_buffer_copy (src,
-                              GIMP_GEGL_RECT (copy_x, copy_y,
+                              GEGL_RECTANGLE (copy_x, copy_y,
                                               copy_width, copy_height),
                               dest,
-                              GIMP_GEGL_RECT (copy_x - offset_x, copy_y - offset_y,
+                              GEGL_RECTANGLE (copy_x - offset_x, copy_y - offset_y,
                                               0, 0));
 
             GIMP_CHANNEL (mask)->bounds_known = FALSE;
@@ -1392,7 +1392,7 @@ gimp_layer_create_mask (const GimpLayer *layer,
                                      GIMP_GRAYA_IMAGE : GIMP_GRAY_IMAGE);
 
             src_buffer =
-              gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+              gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                                     gimp_item_get_width  (item),
                                                     gimp_item_get_height (item)),
                                     copy_format);
@@ -1725,7 +1725,7 @@ gimp_layer_add_alpha (GimpLayer *layer)
   drawable = GIMP_DRAWABLE (layer);
 
   new_buffer =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                           gimp_item_get_width  (item),
                                           gimp_item_get_height (item)),
                           gimp_drawable_get_format_with_alpha (drawable));
@@ -1755,7 +1755,7 @@ gimp_layer_flatten (GimpLayer   *layer,
     return;
 
   new_buffer =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                           gimp_item_get_width  (GIMP_ITEM (layer)),
                                           gimp_item_get_height (GIMP_ITEM (layer))),
                           gimp_drawable_get_format_without_alpha (GIMP_DRAWABLE (layer)));
diff --git a/app/core/gimpmaskundo.c b/app/core/gimpmaskundo.c
index fd80ff9..737ac01 100644
--- a/app/core/gimpmaskundo.c
+++ b/app/core/gimpmaskundo.c
@@ -83,13 +83,13 @@ gimp_mask_undo_constructed (GObject *object)
     {
       GimpDrawable  *drawable    = GIMP_DRAWABLE (channel);
 
-      mask_undo->buffer = gegl_buffer_new (GIMP_GEGL_RECT(0,0,x2-x1, y2-y1),
+      mask_undo->buffer = gegl_buffer_new (GEGL_RECTANGLE(0,0,x2-x1, y2-y1),
                                            babl_format ("Y float"));
 
       gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                        GIMP_GEGL_RECT (x1, y1, x2 - x1, y2 - y1),
+                        GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1),
                         mask_undo->buffer,
-                        GIMP_GEGL_RECT (0, 0, 0, 0));
+                        GEGL_RECTANGLE (0, 0, 0, 0));
 
       mask_undo->x = x1;
       mask_undo->y = y1;
@@ -128,11 +128,11 @@ gimp_mask_undo_pop (GimpUndo            *undo,
     {
       GeglRectangle  src_rect    = { x1, y1, x2 - x1, y2 - y1 };
 
-      new_buffer = gegl_buffer_new (GIMP_GEGL_RECT (0, 0, x2 - x1, y2 - y1),
+      new_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
                                     babl_format ("Y float"));
 
       gegl_buffer_copy (gimp_drawable_get_buffer (drawable), &src_rect,
-                        new_buffer, GIMP_GEGL_RECT (0,0,0,0));
+                        new_buffer, GEGL_RECTANGLE (0,0,0,0));
 
       gegl_buffer_clear (gimp_drawable_get_buffer (drawable), &src_rect);
     }
diff --git a/app/core/gimppatternclipboard.c b/app/core/gimppatternclipboard.c
index 5d155d8..54e6cd9 100644
--- a/app/core/gimppatternclipboard.c
+++ b/app/core/gimppatternclipboard.c
@@ -201,7 +201,7 @@ gimp_pattern_clipboard_buffer_changed (Gimp        *gimp,
       pattern->mask = temp_buf_new (width, height, bytes, 0, 0, NULL);
 
       gegl_buffer_get (gimp_buffer_get_buffer (buffer),
-                       GIMP_GEGL_RECT (0, 0, width, height), 1.0,
+                       GEGL_RECTANGLE (0, 0, width, height), 1.0,
                        NULL,
                        temp_buf_get_data (pattern->mask),
                        GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
diff --git a/app/core/gimpprojection-construct.c b/app/core/gimpprojection-construct.c
index 99cb60f..d669683 100644
--- a/app/core/gimpprojection-construct.c
+++ b/app/core/gimpprojection-construct.c
@@ -266,7 +266,7 @@ gimp_projection_initialize (GimpProjection *proj,
           buffer = gimp_tile_manager_create_buffer (tiles, NULL);
         }
 
-      gegl_buffer_clear (buffer, GIMP_GEGL_RECT (x, y, w, h));
+      gegl_buffer_clear (buffer, GEGL_RECTANGLE (x, y, w, h));
       g_object_unref (buffer);
     }
 }
diff --git a/app/core/gimpselection.c b/app/core/gimpselection.c
index 81e16d9..6aa02fc 100644
--- a/app/core/gimpselection.c
+++ b/app/core/gimpselection.c
@@ -701,12 +701,12 @@ gimp_selection_extract (GimpSelection *selection,
   src_buffer = gimp_pickable_get_buffer (pickable);
 
   /*  Allocate the temp buffer  */
-  dest_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, x2 - x1, y2 - y1),
+  dest_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2 - x1, y2 - y1),
                                       dest_format);
 
   /*  First, copy the pixels, possibly doing INDEXED->RGB and adding alpha  */
-  gegl_buffer_copy (src_buffer, GIMP_GEGL_RECT (x1, y1, x2 - x1, y2 - y1),
-                    dest_buffer, GIMP_GEGL_RECT (0, 0,0 ,0 ));
+  gegl_buffer_copy (src_buffer, GEGL_RECTANGLE (x1, y1, x2 - x1, y2 - y1),
+                    dest_buffer, GEGL_RECTANGLE (0, 0,0 ,0 ));
 
   if (non_empty)
     {
diff --git a/app/gegl/gimp-gegl-utils.c b/app/gegl/gimp-gegl-utils.c
index 8c237fa..ab4ff9a 100644
--- a/app/gegl/gimp-gegl-utils.c
+++ b/app/gegl/gimp-gegl-utils.c
@@ -122,7 +122,7 @@ gimp_pixbuf_create_buffer (GdkPixbuf *pixbuf)
 
   return gegl_buffer_linear_new_from_data (gdk_pixbuf_get_pixels (pixbuf),
                                            gimp_bpp_to_babl_format (channels),
-                                           GIMP_GEGL_RECT (0,0,width,height),
+                                           GEGL_RECTANGLE (0,0,width,height),
                                            rowstride,
                                            (GDestroyNotify) g_object_unref,
                                            g_object_ref (pixbuf));
@@ -221,7 +221,7 @@ gimp_temp_buf_create_buffer (TempBuf    *temp_buf,
   buffer =
     gegl_buffer_linear_new_from_data (temp_buf_get_data (temp_buf),
                                       format,
-                                      GIMP_GEGL_RECT (0, 0, width, height),
+                                      GEGL_RECTANGLE (0, 0, width, height),
                                       width * bytes,
                                       take_ownership ?
                                       (GDestroyNotify) temp_buf_free : NULL,
diff --git a/app/gegl/gimp-gegl-utils.h b/app/gegl/gimp-gegl-utils.h
index 2ff9058..ca3a8a7 100644
--- a/app/gegl/gimp-gegl-utils.h
+++ b/app/gegl/gimp-gegl-utils.h
@@ -53,6 +53,4 @@ void          gimp_gegl_progress_connect         (GeglNode              *node,
                                                   GimpProgress          *progress,
                                                   const gchar           *text);
 
-#define       GIMP_GEGL_RECT(x,y,w,h)            (&((GeglRectangle){(x), (y), (w), (h)}))
-
 #endif /* __GIMP_GEGL_UTILS_H__ */
diff --git a/app/gegl/gimpoperationborder.c b/app/gegl/gimpoperationborder.c
index 16a4981..0789cee 100644
--- a/app/gegl/gimpoperationborder.c
+++ b/app/gegl/gimpoperationborder.c
@@ -380,14 +380,14 @@ gimp_operation_border_process (GeglOperation       *operation,
       memset (source[0], self->edge_lock ? 255 : 0, roi->width);
 
       gegl_buffer_get (input,
-                       GIMP_GEGL_RECT (roi->x, roi->y + 0,
+                       GEGL_RECTANGLE (roi->x, roi->y + 0,
                                        roi->width, 1),
                        1.0, input_format, source[1],
                        GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
       if (roi->height > 1)
         gegl_buffer_get (input,
-                         GIMP_GEGL_RECT (roi->x, roi->y + 1,
+                         GEGL_RECTANGLE (roi->x, roi->y + 1,
                                          roi->width, 1),
                          1.0, input_format, source[2],
                          GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -396,7 +396,7 @@ gimp_operation_border_process (GeglOperation       *operation,
 
       compute_transition (transition, source, roi->width, self->edge_lock);
       gegl_buffer_set (output,
-                       GIMP_GEGL_RECT (roi->x, roi->y,
+                       GEGL_RECTANGLE (roi->x, roi->y,
                                        roi->width, 1),
                        1.0, output_format, transition,
                        GEGL_AUTO_ROWSTRIDE);
@@ -408,7 +408,7 @@ gimp_operation_border_process (GeglOperation       *operation,
           if (y + 1 < roi->height)
             {
               gegl_buffer_get (input,
-                               GIMP_GEGL_RECT (roi->x, roi->y + y + 1,
+                               GEGL_RECTANGLE (roi->x, roi->y + y + 1,
                                                roi->width, 1),
                                1.0, input_format, source[2],
                                GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -423,7 +423,7 @@ gimp_operation_border_process (GeglOperation       *operation,
 
           compute_transition (transition, source, roi->width, self->edge_lock);
           gegl_buffer_set (output,
-                           GIMP_GEGL_RECT (roi->x, roi->y + y,
+                           GEGL_RECTANGLE (roi->x, roi->y + y,
                                            roi->width, 1),
                            1.0, output_format, transition,
                            GEGL_AUTO_ROWSTRIDE);
@@ -522,14 +522,14 @@ gimp_operation_border_process (GeglOperation       *operation,
    */
   memset (buf[0], self->edge_lock ? 255 : 0, roi->width);
   gegl_buffer_get (input,
-                   GIMP_GEGL_RECT (roi->x, roi->y + 0,
+                   GEGL_RECTANGLE (roi->x, roi->y + 0,
                                    roi->width, 1),
                    1.0, input_format, buf[1],
                    GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 
   if (roi->height > 1)
     gegl_buffer_get (input,
-                     GIMP_GEGL_RECT (roi->x, roi->y + 1,
+                     GEGL_RECTANGLE (roi->x, roi->y + 1,
                                      roi->width, 1),
                      1.0, input_format, buf[2],
                      GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -543,7 +543,7 @@ gimp_operation_border_process (GeglOperation       *operation,
     {
       rotate_pointers (buf, 3);
       gegl_buffer_get (input,
-                       GIMP_GEGL_RECT (roi->x, roi->y + y + 1,
+                       GEGL_RECTANGLE (roi->x, roi->y + y + 1,
                                        roi->width, 1),
                        1.0, input_format, buf[2],
                        GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -572,7 +572,7 @@ gimp_operation_border_process (GeglOperation       *operation,
       if (y < roi->height - (self->radius_y + 1))
         {
           gegl_buffer_get (input,
-                           GIMP_GEGL_RECT (roi->x,
+                           GEGL_RECTANGLE (roi->x,
                                            roi->y + y + self->radius_y + 1,
                                            roi->width, 1),
                            1.0, input_format, buf[2],
@@ -685,7 +685,7 @@ gimp_operation_border_process (GeglOperation       *operation,
         }
 
       gegl_buffer_set (output,
-                       GIMP_GEGL_RECT (roi->x, roi->y + y,
+                       GEGL_RECTANGLE (roi->x, roi->y + y,
                                        roi->width, 1),
                        1.0, output_format, out,
                        GEGL_AUTO_ROWSTRIDE);
diff --git a/app/gegl/gimpoperationgrow.c b/app/gegl/gimpoperationgrow.c
index 58c8c46..40f692c 100644
--- a/app/gegl/gimpoperationgrow.c
+++ b/app/gegl/gimpoperationgrow.c
@@ -283,7 +283,7 @@ gimp_operation_grow_process (GeglOperation       *operation,
 
   for (i = 0; i < self->radius_y && i < roi->height; i++) /* load top of image */
     gegl_buffer_get (input,
-                     GIMP_GEGL_RECT (roi->x, roi->y + i,
+                     GEGL_RECTANGLE (roi->x, roi->y + i,
                                      roi->width, 1),
                      1.0, input_format, buf[i + 1],
                      GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -303,7 +303,7 @@ gimp_operation_grow_process (GeglOperation       *operation,
 
       if (y < roi->height - (self->radius_y))
         gegl_buffer_get (input,
-                         GIMP_GEGL_RECT (roi->x,  roi->y + y + self->radius_y,
+                         GEGL_RECTANGLE (roi->x,  roi->y + y + self->radius_y,
                                          roi->width, 1),
                          1.0, input_format, buf[self->radius_y],
                          GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -362,7 +362,7 @@ gimp_operation_grow_process (GeglOperation       *operation,
         }
 
       gegl_buffer_set (output,
-                       GIMP_GEGL_RECT (roi->x, roi->y + y,
+                       GEGL_RECTANGLE (roi->x, roi->y + y,
                                        roi->width, 1),
                        1.0, output_format, out,
                        GEGL_AUTO_ROWSTRIDE);
diff --git a/app/gegl/gimpoperationshapeburst.c b/app/gegl/gimpoperationshapeburst.c
index 364891d..ff43564 100644
--- a/app/gegl/gimpoperationshapeburst.c
+++ b/app/gegl/gimpoperationshapeburst.c
@@ -247,7 +247,7 @@ gimp_operation_shapeburst_process (GeglOperation       *operation,
                                       input_format,
                                       GEGL_SAMPLER_NEAREST, GEGL_ABYSS_NONE);
 #else
-                  gegl_buffer_get (input, GIMP_GEGL_RECT (x, y, 1, 1), 1.0,
+                  gegl_buffer_get (input, GEGL_RECTANGLE (x, y, 1, 1), 1.0,
                                    input_format, &src_uchar,
                                    GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
 #endif
@@ -295,7 +295,7 @@ gimp_operation_shapeburst_process (GeglOperation       *operation,
 
       /*  set the dist row  */
       gegl_buffer_set (output,
-                       GIMP_GEGL_RECT (roi->x, roi->y + i,
+                       GEGL_RECTANGLE (roi->x, roi->y + i,
                                        roi->width, 1),
                        1.0, output_format, distp_cur,
                        GEGL_AUTO_ROWSTRIDE);
diff --git a/app/gegl/gimpoperationshrink.c b/app/gegl/gimpoperationshrink.c
index 0bbfe18..fe82d1a 100644
--- a/app/gegl/gimpoperationshrink.c
+++ b/app/gegl/gimpoperationshrink.c
@@ -322,7 +322,7 @@ gimp_operation_shrink_process (GeglOperation       *operation,
 
   for (i = 0; i < self->radius_y && i < roi->height; i++) /* load top of image */
     gegl_buffer_get (input,
-                     GIMP_GEGL_RECT (roi->x, roi->y + i,
+                     GEGL_RECTANGLE (roi->x, roi->y + i,
                                      roi->width, 1),
                      1.0, input_format, buf[i + 1],
                      GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -347,7 +347,7 @@ gimp_operation_shrink_process (GeglOperation       *operation,
 
       if (y < roi->height - self->radius_y)
         gegl_buffer_get (input,
-                         GIMP_GEGL_RECT (roi->x,  roi->y + y + self->radius_y,
+                         GEGL_RECTANGLE (roi->x,  roi->y + y + self->radius_y,
                                          roi->width, 1),
                          1.0, input_format, buf[self->radius_y],
                          GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
@@ -408,7 +408,7 @@ gimp_operation_shrink_process (GeglOperation       *operation,
         }
 
       gegl_buffer_set (output,
-                       GIMP_GEGL_RECT (roi->x, roi->y + y,
+                       GEGL_RECTANGLE (roi->x, roi->y + y,
                                        roi->width, 1),
                        1.0, output_format, out,
                        GEGL_AUTO_ROWSTRIDE);
diff --git a/app/paint/gimpclone.c b/app/paint/gimpclone.c
index 078ae20..3afd5ed 100644
--- a/app/paint/gimpclone.c
+++ b/app/paint/gimpclone.c
@@ -165,12 +165,12 @@ gimp_clone_motion (GimpSourceCore   *source_core,
     case GIMP_IMAGE_CLONE:
       {
         gegl_buffer_copy (src_buffer,
-                          GIMP_GEGL_RECT (src_rect->x,
+                          GEGL_RECTANGLE (src_rect->x,
                                           src_rect->y,
                                           paint_area_width,
                                           paint_area_height),
                           paint_buffer,
-                          GIMP_GEGL_RECT (paint_area_offset_x,
+                          GEGL_RECTANGLE (paint_area_offset_x,
                                           paint_area_offset_y,
                                           0, 0));
       }
@@ -183,7 +183,7 @@ gimp_clone_motion (GimpSourceCore   *source_core,
         GeglBuffer  *src_buffer = gimp_pattern_create_buffer (pattern);
 
         gegl_buffer_set_pattern (paint_buffer,
-                                 GIMP_GEGL_RECT (paint_area_offset_x,
+                                 GEGL_RECTANGLE (paint_area_offset_x,
                                                  paint_area_offset_y,
                                                  paint_area_width,
                                                  paint_area_height),
diff --git a/app/paint/gimpconvolve.c b/app/paint/gimpconvolve.c
index 4416383..571aa4d 100644
--- a/app/paint/gimpconvolve.c
+++ b/app/paint/gimpconvolve.c
@@ -192,19 +192,19 @@ gimp_convolve_motion (GimpPaintCore    *paint_core,
   convolve_buffer = gimp_temp_buf_create_buffer (convolve_temp, format, TRUE);
 
   gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                    GIMP_GEGL_RECT (paint_buffer_x,
+                    GEGL_RECTANGLE (paint_buffer_x,
                                     paint_buffer_y,
                                     gegl_buffer_get_width  (paint_buffer),
                                     gegl_buffer_get_height (paint_buffer)),
                     convolve_buffer,
-                    GIMP_GEGL_RECT (0, 0, 0, 0));
+                    GEGL_RECTANGLE (0, 0, 0, 0));
 
   gimp_gegl_convolve (convolve_buffer,
-                      GIMP_GEGL_RECT (0, 0,
+                      GEGL_RECTANGLE (0, 0,
                                       convolve_temp->width,
                                       convolve_temp->height),
                       paint_buffer,
-                      GIMP_GEGL_RECT (0, 0,
+                      GEGL_RECTANGLE (0, 0,
                                       gegl_buffer_get_width  (paint_buffer),
                                       gegl_buffer_get_height (paint_buffer)),
                       convolve->matrix, 3, convolve->matrix_divisor,
diff --git a/app/paint/gimpdodgeburn.c b/app/paint/gimpdodgeburn.c
index fae0aff..c0f8497 100644
--- a/app/paint/gimpdodgeburn.c
+++ b/app/paint/gimpdodgeburn.c
@@ -243,7 +243,7 @@ gimp_dodge_burn_motion (GimpPaintCore    *paint_core,
   gegl_buffer_copy (gimp_paint_core_get_orig_image (paint_core),
                     &orig_rect,
                     orig_buffer,
-                    GIMP_GEGL_RECT (0, 0, 0, 0));
+                    GEGL_RECTANGLE (0, 0, 0, 0));
 
   pixel_region_init_temp_buf (&srcPR, orig_temp,
                               0, 0, orig_rect.width, orig_rect.height);
diff --git a/app/paint/gimpheal.c b/app/paint/gimpheal.c
index a098994..8fc1894 100644
--- a/app/paint/gimpheal.c
+++ b/app/paint/gimpheal.c
@@ -498,7 +498,7 @@ gimp_heal_motion (GimpSourceCore   *source_core,
                                        FALSE);
 
     gegl_buffer_copy (src_buffer, src_rect,
-                      tmp, GIMP_GEGL_RECT (0, 0, 0, 0));
+                      tmp, GEGL_RECTANGLE (0, 0, 0, 0));
     g_object_unref (tmp);
   }
 
@@ -513,11 +513,11 @@ gimp_heal_motion (GimpSourceCore   *source_core,
                                  TRUE);
 
   gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                    GIMP_GEGL_RECT (paint_buffer_x, paint_buffer_y,
+                    GEGL_RECTANGLE (paint_buffer_x, paint_buffer_y,
                                     gegl_buffer_get_width  (paint_buffer),
                                     gegl_buffer_get_height (paint_buffer)),
                     dest_buffer,
-                    GIMP_GEGL_RECT (0, 0, 0, 0));
+                    GEGL_RECTANGLE (0, 0, 0, 0));
 
   /* check that srcPR, tempPR, destPR, and mask_buf are the same size */
   if (src_temp_buf->width  != dest_temp_buf->width ||
@@ -544,9 +544,9 @@ gimp_heal_motion (GimpSourceCore   *source_core,
   gimp_heal_region (&destPR, &srcPR, mask_buf);
 
   gegl_buffer_copy (dest_buffer,
-                    GIMP_GEGL_RECT (0, 0, mask_buf->width, mask_buf->height),
+                    GEGL_RECTANGLE (0, 0, mask_buf->width, mask_buf->height),
                     paint_buffer,
-                    GIMP_GEGL_RECT (paint_area_offset_x,
+                    GEGL_RECTANGLE (paint_area_offset_x,
                                     paint_area_offset_y,
                                     paint_area_width,
                                     paint_area_height));
diff --git a/app/paint/gimpink.c b/app/paint/gimpink.c
index 5263e93..36c7187 100644
--- a/app/paint/gimpink.c
+++ b/app/paint/gimpink.c
@@ -328,7 +328,7 @@ gimp_ink_motion (GimpPaintCore    *paint_core,
 
   /*  draw the blob directly to the canvas_buffer  */
   render_blob (paint_core->canvas_buffer,
-               GIMP_GEGL_RECT (paint_core->paint_buffer_x,
+               GEGL_RECTANGLE (paint_core->paint_buffer_x,
                                paint_core->paint_buffer_y,
                                gegl_buffer_get_width  (paint_core->paint_buffer),
                                gegl_buffer_get_height (paint_core->paint_buffer)),
diff --git a/app/paint/gimppaintcore.c b/app/paint/gimppaintcore.c
index 71734d6..73fc186 100644
--- a/app/paint/gimppaintcore.c
+++ b/app/paint/gimppaintcore.c
@@ -392,7 +392,7 @@ gimp_paint_core_start (GimpPaintCore     *core,
     g_object_unref (core->canvas_buffer);
 
   core->canvas_buffer =
-    gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0,
+    gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0,
                                           gimp_item_get_width  (item),
                                           gimp_item_get_height (item)),
                           babl_format ("Y u8"));
@@ -457,13 +457,13 @@ gimp_paint_core_finish (GimpPaintCore *core,
 
       GIMP_PAINT_CORE_GET_CLASS (core)->push_undo (core, image, NULL);
 
-      buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+      buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                      gimp_drawable_get_format (drawable));
 
       gegl_buffer_copy (core->undo_buffer,
-                        GIMP_GEGL_RECT (x, y, width, height),
+                        GEGL_RECTANGLE (x, y, width, height),
                         buffer,
-                        GIMP_GEGL_RECT (0, 0, 0, 0));
+                        GEGL_RECTANGLE (0, 0, 0, 0));
 
       gimp_drawable_push_undo (drawable, NULL,
                                buffer, x, y, width, height);
@@ -511,9 +511,9 @@ gimp_paint_core_cancel (GimpPaintCore *core,
                                 &x, &y, &width, &height))
     {
       gegl_buffer_copy (core->undo_buffer,
-                        GIMP_GEGL_RECT (x, y, width, height),
+                        GEGL_RECTANGLE (x, y, width, height),
                         gimp_drawable_get_buffer (drawable),
-                        GIMP_GEGL_RECT (x, y, width, height));
+                        GEGL_RECTANGLE (x, y, width, height));
     }
 
   g_object_unref (core->undo_buffer);
@@ -752,7 +752,7 @@ gimp_paint_core_paste (GimpPaintCore            *core,
   /*  apply the paint area to the image  */
   gimp_drawable_apply_buffer (drawable,
                               core->paint_buffer,
-                              GIMP_GEGL_RECT (0, 0, width, height),
+                              GEGL_RECTANGLE (0, 0, width, height),
                               FALSE, NULL,
                               image_opacity, paint_mode,
                               base_buffer, /*  specify an alternative src1  */
@@ -832,7 +832,7 @@ gimp_paint_core_replace (GimpPaintCore            *core,
 
   /*  apply the paint area to the image  */
   gimp_drawable_replace_buffer (drawable, core->paint_buffer,
-                                GIMP_GEGL_RECT (0, 0, width, height),
+                                GEGL_RECTANGLE (0, 0, width, height),
                                 FALSE, NULL,
                                 image_opacity,
                                 paint_maskPR,
diff --git a/app/paint/gimpperspectiveclone.c b/app/paint/gimpperspectiveclone.c
index 37bb3d5..d8b4d78 100644
--- a/app/paint/gimpperspectiveclone.c
+++ b/app/paint/gimpperspectiveclone.c
@@ -392,7 +392,7 @@ gimp_perspective_clone_get_source (GimpSourceCore   *source_core,
       return FALSE;
     }
 
-  dest_buffer = gegl_buffer_new (GIMP_GEGL_RECT (0, 0, x2d - x1d, y2d - y1d),
+  dest_buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, x2d - x1d, y2d - y1d),
                                  src_format_alpha);
   gegl_buffer_clear (dest_buffer, NULL);
 
@@ -409,11 +409,11 @@ gimp_perspective_clone_get_source (GimpSourceCore   *source_core,
                  NULL);
 
   gegl_processor_set_rectangle (clone->processor,
-                                GIMP_GEGL_RECT (0, 0,
+                                GEGL_RECTANGLE (0, 0,
                                                 x2d - x1d, y2d - y1d));
   while (gegl_processor_work (clone->processor, NULL));
 
-  *src_rect = *GIMP_GEGL_RECT (0, 0, x2d - x1d, y2d - y1d);
+  *src_rect = *GEGL_RECTANGLE (0, 0, x2d - x1d, y2d - y1d);
 
   return dest_buffer;
 }
diff --git a/app/paint/gimpsmudge.c b/app/paint/gimpsmudge.c
index 4eaa9c8..e7943e7 100644
--- a/app/paint/gimpsmudge.c
+++ b/app/paint/gimpsmudge.c
@@ -226,12 +226,12 @@ gimp_smudge_start (GimpPaintCore    *paint_core,
 
   /* copy the region under the original painthit. */
   gegl_buffer_copy (gimp_drawable_get_buffer (drawable),
-                    GIMP_GEGL_RECT (paint_buffer_x,
+                    GEGL_RECTANGLE (paint_buffer_x,
                                     paint_buffer_y,
                                     gegl_buffer_get_width  (paint_buffer),
                                     gegl_buffer_get_height (paint_buffer)),
                     smudge->accum_buffer,
-                    GIMP_GEGL_RECT (paint_buffer_x - x,
+                    GEGL_RECTANGLE (paint_buffer_x - x,
                                     paint_buffer_y - y,
                                     0, 0));
 
@@ -328,12 +328,12 @@ gimp_smudge_motion (GimpPaintCore    *paint_core,
   blend_region (&srcPR, &tempPR, &tempPR, ROUND (rate * 255.0));
 
   gegl_buffer_copy (smudge->accum_buffer,
-                    GIMP_GEGL_RECT (paint_buffer_x - x,
+                    GEGL_RECTANGLE (paint_buffer_x - x,
                                     paint_buffer_y - y,
                                     gegl_buffer_get_width  (paint_buffer),
                                     gegl_buffer_get_height (paint_buffer)),
                     paint_buffer,
-                    GIMP_GEGL_RECT (0, 0, 0, 0));
+                    GEGL_RECTANGLE (0, 0, 0, 0));
 
   hardness_output = gimp_dynamics_get_output (dynamics,
                                               GIMP_DYNAMICS_OUTPUT_HARDNESS);
diff --git a/app/paint/gimpsourcecore.c b/app/paint/gimpsourcecore.c
index 4124d4d..0e396e7 100644
--- a/app/paint/gimpsourcecore.c
+++ b/app/paint/gimpsourcecore.c
@@ -525,7 +525,7 @@ gimp_source_core_real_get_source (GimpSourceCore   *source_core,
   *paint_area_width    = width;
   *paint_area_height   = height;
 
-  *src_rect = *GIMP_GEGL_RECT (x, y, width, height);
+  *src_rect = *GEGL_RECTANGLE (x, y, width, height);
 
   return g_object_ref (dest_buffer);
 }
diff --git a/app/pdb/drawable-cmds.c b/app/pdb/drawable-cmds.c
index 5803b6e..958d161 100644
--- a/app/pdb/drawable-cmds.c
+++ b/app/pdb/drawable-cmds.c
@@ -617,7 +617,7 @@ drawable_set_pixel_invoker (GimpProcedure      *procedure,
           num_channels == gimp_drawable_bytes (drawable))
         {
           gegl_buffer_set (gimp_drawable_get_buffer (drawable),
-                           GIMP_GEGL_RECT (x_coord, y_coord, 1, 1),
+                           GEGL_RECTANGLE (x_coord, y_coord, 1, 1),
                            1.0, gimp_drawable_get_format (drawable),
                            pixel, GEGL_AUTO_ROWSTRIDE);
         }
diff --git a/app/text/gimptextlayer.c b/app/text/gimptextlayer.c
index 72d103e..756eeff 100644
--- a/app/text/gimptextlayer.c
+++ b/app/text/gimptextlayer.c
@@ -589,7 +589,7 @@ gimp_text_layer_render (GimpTextLayer *layer)
     {
       GeglBuffer *new_buffer;
 
-      new_buffer = gimp_gegl_buffer_new (GIMP_GEGL_RECT (0, 0, width, height),
+      new_buffer = gimp_gegl_buffer_new (GEGL_RECTANGLE (0, 0, width, height),
                                          gimp_drawable_get_format (drawable));
       gimp_drawable_set_buffer (drawable, FALSE, NULL, new_buffer);
       g_object_unref (new_buffer);
@@ -675,7 +675,7 @@ gimp_text_layer_render_layout (GimpTextLayer  *layer,
   buffer =
     gegl_buffer_linear_new_from_data (cairo_image_surface_get_data (surface),
                                       babl_format ("cairo-ARGB32"),
-                                      GIMP_GEGL_RECT (0, 0, width, height),
+                                      GEGL_RECTANGLE (0, 0, width, height),
                                       cairo_image_surface_get_stride (surface),
                                       (GDestroyNotify) cairo_surface_destroy,
                                       surface);
diff --git a/tools/pdbgen/pdb/drawable.pdb b/tools/pdbgen/pdb/drawable.pdb
index c09cb2b..1c905db 100644
--- a/tools/pdbgen/pdb/drawable.pdb
+++ b/tools/pdbgen/pdb/drawable.pdb
@@ -633,7 +633,7 @@ HELP
       num_channels == gimp_drawable_bytes (drawable))
     {
       gegl_buffer_set (gimp_drawable_get_buffer (drawable),
-                       GIMP_GEGL_RECT (x_coord, y_coord, 1, 1),
+                       GEGL_RECTANGLE (x_coord, y_coord, 1, 1),
                        1.0, gimp_drawable_get_format (drawable),
                        pixel, GEGL_AUTO_ROWSTRIDE);
     }



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]