[gimp] app: s/GIMP_GEGL_RECT/GEGL_RECTANGLE/
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] app: s/GIMP_GEGL_RECT/GEGL_RECTANGLE/
- Date: Wed, 2 May 2012 16:30:16 +0000 (UTC)
commit 6efd812d08cf9c6ca2d115c7c44c9f294fe4761e
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,
©_width,
©_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]
