[gimp] app: BoundSeg -> GimpBoundSeg, boundary_foo() -> gimp_boundary_foo()
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] app: BoundSeg -> GimpBoundSeg, boundary_foo() -> gimp_boundary_foo()
- Date: Wed, 2 May 2012 16:08:59 +0000 (UTC)
commit 2c62644f940515333ec4c52a3b8b2f81b9402eb7
Author: Michael Natterer <mitch gimp org>
Date: Mon Mar 19 15:04:20 2012 +0100
app: BoundSeg -> GimpBoundSeg, boundary_foo() -> gimp_boundary_foo()
app/core/core-types.h | 2 +-
app/core/gimpbezierdesc.c | 6 +-
app/core/gimpbezierdesc.h | 4 +-
app/core/gimpboundary.c | 487 +++++++++++++++---------------
app/core/gimpboundary.h | 52 ++--
app/core/gimpbrush-boundary.c | 22 +-
app/core/gimpchannel.c | 236 +++++++-------
app/core/gimpchannel.h | 194 ++++++------
app/core/gimpdrawable-stroke.c | 73 +++---
app/core/gimpdrawable-stroke.h | 4 +-
app/core/gimplayer-floating-sel.c | 12 +-
app/core/gimplayer-floating-sel.h | 18 +-
app/core/gimplayer.c | 2 +-
app/core/gimplayer.h | 2 +-
app/core/gimpselection.c | 190 ++++++------
app/display/gimpcanvasboundary.c | 24 +-
app/display/gimpcanvasboundary.h | 12 +-
app/display/gimpdisplayshell-selection.c | 40 ++--
app/display/gimpdisplayshell-transform.c | 2 +-
app/display/gimpdisplayshell-transform.h | 2 +-
app/paint/gimppaintcore-stroke.c | 41 ++--
app/paint/gimppaintcore-stroke.h | 48 ++--
app/tools/gimpdrawtool.c | 12 +-
app/tools/gimpdrawtool.h | 2 +-
app/tools/gimpeditselectiontool.c | 12 +-
app/tools/gimprectangleselecttool.c | 2 +-
app/tools/gimpregionselecttool.c | 22 +-
app/tools/gimpregionselecttool.h | 2 +-
app/tools/gimptransformtool.c | 18 +-
29 files changed, 773 insertions(+), 770 deletions(-)
---
diff --git a/app/core/core-types.h b/app/core/core-types.h
index d03aae1..5bbee26 100644
--- a/app/core/core-types.h
+++ b/app/core/core-types.h
@@ -177,7 +177,7 @@ typedef struct _GimpTagged GimpTagged; /* dummy typedef */
/* non-object types */
typedef struct _GimpArea GimpArea;
-typedef struct _BoundSeg BoundSeg;
+typedef struct _GimpBoundSeg GimpBoundSeg;
typedef struct _GimpCoords GimpCoords;
typedef struct _GimpGradientSegment GimpGradientSegment;
typedef struct _GimpPaletteEntry GimpPaletteEntry;
diff --git a/app/core/gimpbezierdesc.c b/app/core/gimpbezierdesc.c
index 756b629..6b94042 100644
--- a/app/core/gimpbezierdesc.c
+++ b/app/core/gimpbezierdesc.c
@@ -101,9 +101,9 @@ add_polyline (GArray *path_data,
}
GimpBezierDesc *
-gimp_bezier_desc_new_from_bound_segs (BoundSeg *bound_segs,
- gint n_bound_segs,
- gint n_bound_groups)
+gimp_bezier_desc_new_from_bound_segs (GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint n_bound_groups)
{
GArray *path_data;
GimpVector2 *points;
diff --git a/app/core/gimpbezierdesc.h b/app/core/gimpbezierdesc.h
index c046d4c..ceccef3 100644
--- a/app/core/gimpbezierdesc.h
+++ b/app/core/gimpbezierdesc.h
@@ -31,8 +31,8 @@ GType gimp_bezier_desc_get_type (void) G_GNUC_CONST;
GimpBezierDesc * gimp_bezier_desc_new (cairo_path_data_t *data,
gint n_data);
-/* expects sorted BoundSegs */
-GimpBezierDesc * gimp_bezier_desc_new_from_bound_segs (BoundSeg *bound_segs,
+/* expects sorted GimpBoundSegs */
+GimpBezierDesc * gimp_bezier_desc_new_from_bound_segs (GimpBoundSeg *bound_segs,
gint n_bound_segs,
gint n_bound_groups);
diff --git a/app/core/gimpboundary.c b/app/core/gimpboundary.c
index 636da46..d6d04b5 100644
--- a/app/core/gimpboundary.c
+++ b/app/core/gimpboundary.c
@@ -33,106 +33,106 @@
#include "gimpboundary.h"
-/* BoundSeg array growth parameter */
+/* GimpBoundSeg array growth parameter */
#define MAX_SEGS_INC 2048
-typedef struct _Boundary Boundary;
+typedef struct _GimpBoundary GimpBoundary;
-struct _Boundary
+struct _GimpBoundary
{
/* The array of segments */
- BoundSeg *segs;
- gint num_segs;
- gint max_segs;
+ GimpBoundSeg *segs;
+ gint num_segs;
+ gint max_segs;
/* The array of vertical segments */
- gint *vert_segs;
+ gint *vert_segs;
/* The empty segment arrays */
- gint *empty_segs_n;
- gint *empty_segs_c;
- gint *empty_segs_l;
- gint max_empty_segs;
+ gint *empty_segs_n;
+ gint *empty_segs_c;
+ gint *empty_segs_l;
+ gint max_empty_segs;
};
/* local function prototypes */
-static Boundary * boundary_new (PixelRegion *PR);
-static BoundSeg * boundary_free (Boundary *boundary,
- gboolean free_segs);
-
-static void boundary_add_seg (Boundary *bounrady,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- gboolean open);
-
-static void find_empty_segs (PixelRegion *maskPR,
- gint scanline,
- gint empty_segs[],
- gint max_empty,
- gint *num_empty,
- BoundaryType type,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- guchar threshold);
-static void process_horiz_seg (Boundary *boundary,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- gboolean open);
-static void make_horiz_segs (Boundary *boundary,
- gint start,
- gint end,
- gint scanline,
- gint empty[],
- gint num_empty,
- gint top);
-static Boundary * generate_boundary (PixelRegion *PR,
- BoundaryType type,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- guchar threshold);
-
-static gint cmp_segptr_xy1_addr (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b);
-static gint cmp_segptr_xy2_addr (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b);
-
-static gint cmp_segptr_xy1 (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b);
-static gint cmp_segptr_xy2 (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b);
-
-static const BoundSeg * find_segment (const BoundSeg **segs_by_xy1,
- const BoundSeg **segs_by_xy2,
- gint num_segs,
- gint x,
- gint y);
-
-static const BoundSeg * find_segment_with_func (const BoundSeg **segs,
- gint num_segs,
- const BoundSeg *search_seg,
- GCompareFunc cmp_func);
-
-static void simplify_subdivide (const BoundSeg *segs,
- gint start_idx,
- gint end_idx,
- GArray **ret_points);
+static GimpBoundary * gimp_boundary_new (PixelRegion *PR);
+static GimpBoundSeg * gimp_boundary_free (GimpBoundary *boundary,
+ gboolean free_segs);
+
+static void gimp_boundary_add_seg (GimpBoundary *bounrady,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ gboolean open);
+
+static void find_empty_segs (PixelRegion *maskPR,
+ gint scanline,
+ gint empty_segs[],
+ gint max_empty,
+ gint *num_empty,
+ GimpBoundaryType type,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ guchar threshold);
+static void process_horiz_seg (GimpBoundary *boundary,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ gboolean open);
+static void make_horiz_segs (GimpBoundary *boundary,
+ gint start,
+ gint end,
+ gint scanline,
+ gint empty[],
+ gint num_empty,
+ gint top);
+static GimpBoundary * generate_boundary (PixelRegion *PR,
+ GimpBoundaryType type,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ guchar threshold);
+
+static gint cmp_segptr_xy1_addr (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b);
+static gint cmp_segptr_xy2_addr (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b);
+
+static gint cmp_segptr_xy1 (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b);
+static gint cmp_segptr_xy2 (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b);
+
+static const GimpBoundSeg * find_segment (const GimpBoundSeg **segs_by_xy1,
+ const GimpBoundSeg **segs_by_xy2,
+ gint num_segs,
+ gint x,
+ gint y);
+
+static const GimpBoundSeg * find_segment_with_func (const GimpBoundSeg **segs,
+ gint num_segs,
+ const GimpBoundSeg *search_seg,
+ GCompareFunc cmp_func);
+
+static void simplify_subdivide (const GimpBoundSeg *segs,
+ gint start_idx,
+ gint end_idx,
+ GArray **ret_points);
/* public functions */
/**
- * boundary_find:
+ * gimp_boundary_find:
* @maskPR: any PixelRegion
* @type: type of bounds
* @x1: left side of bounds
@@ -140,9 +140,9 @@ static void simplify_subdivide (const BoundSeg *segs,
* @x2: right side of bounds
* @y2: botton side of bounds
* @threshold: pixel value of boundary line
- * @num_segs: number of returned #BoundSeg's
+ * @num_segs: number of returned #GimpBoundSeg's
*
- * This function returns an array of #BoundSeg's which describe all
+ * This function returns an array of #GimpBoundSeg's which describe all
* outlines along pixel value @threahold, optionally within specified
* bounds instead of the whole region.
*
@@ -152,17 +152,17 @@ static void simplify_subdivide (const BoundSeg *segs,
*
* Return value: the boundary array.
**/
-BoundSeg *
-boundary_find (PixelRegion *maskPR,
- BoundaryType type,
- int x1,
- int y1,
- int x2,
- int y2,
- guchar threshold,
- int *num_segs)
+GimpBoundSeg *
+gimp_boundary_find (PixelRegion *maskPR,
+ GimpBoundaryType type,
+ int x1,
+ int y1,
+ int x2,
+ int y2,
+ guchar threshold,
+ int *num_segs)
{
- Boundary *boundary;
+ GimpBoundary *boundary;
g_return_val_if_fail (maskPR != NULL, NULL);
g_return_val_if_fail (num_segs != NULL, NULL);
@@ -171,33 +171,33 @@ boundary_find (PixelRegion *maskPR,
*num_segs = boundary->num_segs;
- return boundary_free (boundary, FALSE);
+ return gimp_boundary_free (boundary, FALSE);
}
/**
- * boundary_sort:
+ * gimp_boundary_sort:
* @segs: unsorted input segs.
* @num_segs: number of input segs
* @num_groups: number of groups in the sorted segs
*
- * This function takes an array of #BoundSeg's as returned by
- * boundary_find() and sorts it by contiguous groups. The returned
+ * This function takes an array of #GimpBoundSeg's as returned by
+ * gimp_boundary_find() and sorts it by contiguous groups. The returned
* array contains markers consisting of -1 coordinates and is
* @num_groups elements longer than @segs.
*
* Return value: the sorted segs
**/
-BoundSeg *
-boundary_sort (const BoundSeg *segs,
- gint num_segs,
- gint *num_groups)
+GimpBoundSeg *
+gimp_boundary_sort (const GimpBoundSeg *segs,
+ gint num_segs,
+ gint *num_groups)
{
- Boundary *boundary;
- const BoundSeg **segs_ptrs_by_xy1;
- const BoundSeg **segs_ptrs_by_xy2;
- gint index;
- gint x, y;
- gint startx, starty;
+ GimpBoundary *boundary;
+ const GimpBoundSeg **segs_ptrs_by_xy1;
+ const GimpBoundSeg **segs_ptrs_by_xy2;
+ gint index;
+ gint x, y;
+ gint startx, starty;
g_return_val_if_fail ((segs == NULL && num_segs == 0) ||
(segs != NULL && num_segs > 0), NULL);
@@ -208,9 +208,9 @@ boundary_sort (const BoundSeg *segs,
if (num_segs == 0)
return NULL;
- /* prepare arrays with BoundSeg pointers sorted by xy1 and xy2 accordingly */
- segs_ptrs_by_xy1 = g_new (const BoundSeg *, num_segs);
- segs_ptrs_by_xy2 = g_new (const BoundSeg *, num_segs);
+ /* prepare arrays with GimpBoundSeg pointers sorted by xy1 and xy2 accordingly */
+ segs_ptrs_by_xy1 = g_new (const GimpBoundSeg *, num_segs);
+ segs_ptrs_by_xy2 = g_new (const GimpBoundSeg *, num_segs);
for (index = 0; index < num_segs; index++)
{
@@ -218,29 +218,29 @@ boundary_sort (const BoundSeg *segs,
segs_ptrs_by_xy2[index] = segs + index;
}
- qsort (segs_ptrs_by_xy1, num_segs, sizeof (BoundSeg *),
+ qsort (segs_ptrs_by_xy1, num_segs, sizeof (GimpBoundSeg *),
(GCompareFunc) cmp_segptr_xy1_addr);
- qsort (segs_ptrs_by_xy2, num_segs, sizeof (BoundSeg *),
+ qsort (segs_ptrs_by_xy2, num_segs, sizeof (GimpBoundSeg *),
(GCompareFunc) cmp_segptr_xy2_addr);
for (index = 0; index < num_segs; index++)
- ((BoundSeg *) segs)[index].visited = FALSE;
+ ((GimpBoundSeg *) segs)[index].visited = FALSE;
- boundary = boundary_new (NULL);
+ boundary = gimp_boundary_new (NULL);
for (index = 0; index < num_segs; index++)
{
- const BoundSeg *cur_seg;
+ const GimpBoundSeg *cur_seg;
if (segs[index].visited)
continue;
- boundary_add_seg (boundary,
- segs[index].x1, segs[index].y1,
- segs[index].x2, segs[index].y2,
- segs[index].open);
+ gimp_boundary_add_seg (boundary,
+ segs[index].x1, segs[index].y1,
+ segs[index].x2, segs[index].y2,
+ segs[index].open);
- ((BoundSeg *) segs)[index].visited = TRUE;
+ ((GimpBoundSeg *) segs)[index].visited = TRUE;
startx = segs[index].x1;
starty = segs[index].y1;
@@ -253,24 +253,24 @@ boundary_sort (const BoundSeg *segs,
/* make sure ordering is correct */
if (x == cur_seg->x1 && y == cur_seg->y1)
{
- boundary_add_seg (boundary,
- cur_seg->x1, cur_seg->y1,
- cur_seg->x2, cur_seg->y2,
- cur_seg->open);
+ gimp_boundary_add_seg (boundary,
+ cur_seg->x1, cur_seg->y1,
+ cur_seg->x2, cur_seg->y2,
+ cur_seg->open);
x = cur_seg->x2;
y = cur_seg->y2;
}
else
{
- boundary_add_seg (boundary,
- cur_seg->x2, cur_seg->y2,
- cur_seg->x1, cur_seg->y1,
- cur_seg->open);
+ gimp_boundary_add_seg (boundary,
+ cur_seg->x2, cur_seg->y2,
+ cur_seg->x1, cur_seg->y1,
+ cur_seg->open);
x = cur_seg->x1;
y = cur_seg->y1;
}
- ((BoundSeg *) cur_seg)->visited = TRUE;
+ ((GimpBoundSeg *) cur_seg)->visited = TRUE;
}
if (G_UNLIKELY (x != startx || y != starty))
@@ -278,31 +278,31 @@ boundary_sort (const BoundSeg *segs,
/* Mark the end of a group */
*num_groups = *num_groups + 1;
- boundary_add_seg (boundary, -1, -1, -1, -1, 0);
+ gimp_boundary_add_seg (boundary, -1, -1, -1, -1, 0);
}
g_free (segs_ptrs_by_xy1);
g_free (segs_ptrs_by_xy2);
- return boundary_free (boundary, FALSE);
+ return gimp_boundary_free (boundary, FALSE);
}
/**
- * boundary_simplify:
+ * gimp_boundary_simplify:
* @sorted_segs: sorted input segs
* @num_groups: number of groups in the sorted segs
* @num_segs: number of returned segs.
*
- * This function takes an array of #BoundSeg's which has been sorted
- * with boundary_sort() and reduces the number of segments while
+ * This function takes an array of #GimpBoundSeg's which has been sorted
+ * with gimp_boundary_sort() and reduces the number of segments while
* preserving the general shape as close as possible.
*
* Return value: the simplified segs.
**/
-BoundSeg *
-boundary_simplify (BoundSeg *sorted_segs,
- gint num_groups,
- gint *num_segs)
+GimpBoundSeg *
+gimp_boundary_simplify (GimpBoundSeg *sorted_segs,
+ gint num_groups,
+ gint *num_segs)
{
GArray *new_bounds;
gint i, seg;
@@ -311,7 +311,7 @@ boundary_simplify (BoundSeg *sorted_segs,
(sorted_segs != NULL && num_groups > 0), NULL);
g_return_val_if_fail (num_segs != NULL, NULL);
- new_bounds = g_array_new (FALSE, FALSE, sizeof (BoundSeg));
+ new_bounds = g_array_new (FALSE, FALSE, sizeof (GimpBoundSeg));
seg = 0;
@@ -332,7 +332,7 @@ boundary_simplify (BoundSeg *sorted_segs,
if (n_points > 0)
{
GArray *tmp_points;
- BoundSeg tmp_seg;
+ GimpBoundSeg tmp_seg;
gint j;
tmp_points = g_array_new (FALSE, FALSE, sizeof (gint));
@@ -359,14 +359,14 @@ boundary_simplify (BoundSeg *sorted_segs,
*num_segs = new_bounds->len;
- return (BoundSeg *) g_array_free (new_bounds, FALSE);
+ return (GimpBoundSeg *) g_array_free (new_bounds, FALSE);
}
void
-boundary_offset (BoundSeg *segs,
- gint num_segs,
- gint off_x,
- gint off_y)
+gimp_boundary_offset (GimpBoundSeg *segs,
+ gint num_segs,
+ gint off_x,
+ gint off_y)
{
gint i;
@@ -389,10 +389,10 @@ boundary_offset (BoundSeg *segs,
/* private functions */
-static Boundary *
-boundary_new (PixelRegion *PR)
+static GimpBoundary *
+gimp_boundary_new (PixelRegion *PR)
{
- Boundary *boundary = g_slice_new0 (Boundary);
+ GimpBoundary *boundary = g_slice_new0 (GimpBoundary);
if (PR)
{
@@ -419,11 +419,11 @@ boundary_new (PixelRegion *PR)
return boundary;
}
-static BoundSeg *
-boundary_free (Boundary *boundary,
- gboolean free_segs)
+static GimpBoundSeg *
+gimp_boundary_free (GimpBoundary *boundary,
+ gboolean free_segs)
{
- BoundSeg *segs = NULL;
+ GimpBoundSeg *segs = NULL;
if (free_segs)
g_free (boundary->segs);
@@ -435,24 +435,24 @@ boundary_free (Boundary *boundary,
g_free (boundary->empty_segs_c);
g_free (boundary->empty_segs_l);
- g_slice_free (Boundary, boundary);
+ g_slice_free (GimpBoundary, boundary);
return segs;
}
static void
-boundary_add_seg (Boundary *boundary,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- gboolean open)
+gimp_boundary_add_seg (GimpBoundary *boundary,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ gboolean open)
{
if (boundary->num_segs >= boundary->max_segs)
{
boundary->max_segs += MAX_SEGS_INC;
- boundary->segs = g_renew (BoundSeg, boundary->segs, boundary->max_segs);
+ boundary->segs = g_renew (GimpBoundSeg, boundary->segs, boundary->max_segs);
}
boundary->segs[boundary->num_segs].x1 = x1;
@@ -465,17 +465,17 @@ boundary_add_seg (Boundary *boundary,
}
static void
-find_empty_segs (PixelRegion *maskPR,
- gint scanline,
- gint empty_segs[],
- gint max_empty,
- gint *num_empty,
- BoundaryType type,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- guchar threshold)
+find_empty_segs (PixelRegion *maskPR,
+ gint scanline,
+ gint empty_segs[],
+ gint max_empty,
+ gint *num_empty,
+ GimpBoundaryType type,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ guchar threshold)
{
const guchar *data = NULL;
Tile *tile = NULL;
@@ -497,7 +497,7 @@ find_empty_segs (PixelRegion *maskPR,
return;
}
- if (type == BOUNDARY_WITHIN_BOUNDS)
+ if (type == GIMP_BOUNDARY_WITHIN_BOUNDS)
{
if (scanline < y1 || scanline >= y2)
{
@@ -509,7 +509,7 @@ find_empty_segs (PixelRegion *maskPR,
start = x1;
end = x2;
}
- else if (type == BOUNDARY_IGNORE_BOUNDS)
+ else if (type == GIMP_BOUNDARY_IGNORE_BOUNDS)
{
start = maskPR->x;
end = maskPR->x + maskPR->w;
@@ -551,7 +551,7 @@ find_empty_segs (PixelRegion *maskPR,
endx = MIN (end, endx);
}
- if (type == BOUNDARY_IGNORE_BOUNDS && (endx > x1 || x < x2))
+ if (type == GIMP_BOUNDARY_IGNORE_BOUNDS && (endx > x1 || x < x2))
{
for (; x < endx; x++)
{
@@ -610,19 +610,19 @@ find_empty_segs (PixelRegion *maskPR,
}
static void
-process_horiz_seg (Boundary *boundary,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- gboolean open)
+process_horiz_seg (GimpBoundary *boundary,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ gboolean open)
{
/* This procedure accounts for any vertical segments that must be
drawn to close in the horizontal segments. */
if (boundary->vert_segs[x1] >= 0)
{
- boundary_add_seg (boundary, x1, boundary->vert_segs[x1], x1, y1, !open);
+ gimp_boundary_add_seg (boundary, x1, boundary->vert_segs[x1], x1, y1, !open);
boundary->vert_segs[x1] = -1;
}
else
@@ -630,23 +630,23 @@ process_horiz_seg (Boundary *boundary,
if (boundary->vert_segs[x2] >= 0)
{
- boundary_add_seg (boundary, x2, boundary->vert_segs[x2], x2, y2, open);
+ gimp_boundary_add_seg (boundary, x2, boundary->vert_segs[x2], x2, y2, open);
boundary->vert_segs[x2] = -1;
}
else
boundary->vert_segs[x2] = y2;
- boundary_add_seg (boundary, x1, y1, x2, y2, open);
+ gimp_boundary_add_seg (boundary, x1, y1, x2, y2, open);
}
static void
-make_horiz_segs (Boundary *boundary,
- gint start,
- gint end,
- gint scanline,
- gint empty[],
- gint num_empty,
- gint top)
+make_horiz_segs (GimpBoundary *boundary,
+ gint start,
+ gint end,
+ gint scanline,
+ gint empty[],
+ gint num_empty,
+ gint top)
{
gint empty_index;
gint e_s, e_e; /* empty segment start and end values */
@@ -671,36 +671,36 @@ make_horiz_segs (Boundary *boundary,
}
}
-static Boundary *
-generate_boundary (PixelRegion *PR,
- BoundaryType type,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- guchar threshold)
+static GimpBoundary *
+generate_boundary (PixelRegion *PR,
+ GimpBoundaryType type,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ guchar threshold)
{
- Boundary *boundary;
- gint scanline;
- gint i;
- gint start, end;
- gint *tmp_segs;
+ GimpBoundary *boundary;
+ gint scanline;
+ gint i;
+ gint start, end;
+ gint *tmp_segs;
- gint num_empty_n = 0;
- gint num_empty_c = 0;
- gint num_empty_l = 0;
+ gint num_empty_n = 0;
+ gint num_empty_c = 0;
+ gint num_empty_l = 0;
- boundary = boundary_new (PR);
+ boundary = gimp_boundary_new (PR);
start = 0;
end = 0;
- if (type == BOUNDARY_WITHIN_BOUNDS)
+ if (type == GIMP_BOUNDARY_WITHIN_BOUNDS)
{
start = y1;
end = y2;
}
- else if (type == BOUNDARY_IGNORE_BOUNDS)
+ else if (type == GIMP_BOUNDARY_IGNORE_BOUNDS)
{
start = PR->y;
end = PR->y + PR->h;
@@ -787,11 +787,11 @@ cmp_xy (const gint ax,
* (x1, y1) pairs are equal.
*/
static gint
-cmp_segptr_xy1_addr (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b)
+cmp_segptr_xy1_addr (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b)
{
- const BoundSeg *seg_a = *seg_ptr_a;
- const BoundSeg *seg_b = *seg_ptr_b;
+ const GimpBoundSeg *seg_a = *seg_ptr_a;
+ const GimpBoundSeg *seg_b = *seg_ptr_b;
gint result = cmp_xy (seg_a->x1, seg_a->y1, seg_b->x1, seg_b->y1);
@@ -811,11 +811,11 @@ cmp_segptr_xy1_addr (const BoundSeg **seg_ptr_a,
* (x2, y2) pairs are equal.
*/
static gint
-cmp_segptr_xy2_addr (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b)
+cmp_segptr_xy2_addr (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b)
{
- const BoundSeg *seg_a = *seg_ptr_a;
- const BoundSeg *seg_b = *seg_ptr_b;
+ const GimpBoundSeg *seg_a = *seg_ptr_a;
+ const GimpBoundSeg *seg_b = *seg_ptr_b;
gint result = cmp_xy (seg_a->x2, seg_a->y2, seg_b->x2, seg_b->y2);
@@ -835,9 +835,10 @@ cmp_segptr_xy2_addr (const BoundSeg **seg_ptr_a,
* Compares (x1, y1) pairs in specified segments.
*/
static gint
-cmp_segptr_xy1 (const BoundSeg **seg_ptr_a, const BoundSeg **seg_ptr_b)
+cmp_segptr_xy1 (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b)
{
- const BoundSeg *seg_a = *seg_ptr_a, *seg_b = *seg_ptr_b;
+ const GimpBoundSeg *seg_a = *seg_ptr_a, *seg_b = *seg_ptr_b;
return cmp_xy (seg_a->x1, seg_a->y1, seg_b->x1, seg_b->y1);
}
@@ -846,26 +847,26 @@ cmp_segptr_xy1 (const BoundSeg **seg_ptr_a, const BoundSeg **seg_ptr_b)
* Compares (x2, y2) pairs in specified segments.
*/
static gint
-cmp_segptr_xy2 (const BoundSeg **seg_ptr_a,
- const BoundSeg **seg_ptr_b)
+cmp_segptr_xy2 (const GimpBoundSeg **seg_ptr_a,
+ const GimpBoundSeg **seg_ptr_b)
{
- const BoundSeg *seg_a = *seg_ptr_a;
- const BoundSeg *seg_b = *seg_ptr_b;
+ const GimpBoundSeg *seg_a = *seg_ptr_a;
+ const GimpBoundSeg *seg_b = *seg_ptr_b;
return cmp_xy (seg_a->x2, seg_a->y2, seg_b->x2, seg_b->y2);
}
-static const BoundSeg *
-find_segment (const BoundSeg **segs_by_xy1,
- const BoundSeg **segs_by_xy2,
- gint num_segs,
- gint x,
- gint y)
+static const GimpBoundSeg *
+find_segment (const GimpBoundSeg **segs_by_xy1,
+ const GimpBoundSeg **segs_by_xy2,
+ gint num_segs,
+ gint x,
+ gint y)
{
- const BoundSeg *segptr_xy1;
- const BoundSeg *segptr_xy2;
- BoundSeg search_seg;
+ const GimpBoundSeg *segptr_xy1;
+ const GimpBoundSeg *segptr_xy2;
+ GimpBoundSeg search_seg;
search_seg.x1 = search_seg.x2 = x;
search_seg.y1 = search_seg.y2 = y;
@@ -887,16 +888,16 @@ find_segment (const BoundSeg **segs_by_xy1,
}
-static const BoundSeg *
-find_segment_with_func (const BoundSeg **segs,
- gint num_segs,
- const BoundSeg *search_seg,
- GCompareFunc cmp_func)
+static const GimpBoundSeg *
+find_segment_with_func (const GimpBoundSeg **segs,
+ gint num_segs,
+ const GimpBoundSeg *search_seg,
+ GCompareFunc cmp_func)
{
- const BoundSeg **seg;
- const BoundSeg *found_seg = NULL;
+ const GimpBoundSeg **seg;
+ const GimpBoundSeg *found_seg = NULL;
- seg = bsearch (&search_seg, segs, num_segs, sizeof (BoundSeg *), cmp_func);
+ seg = bsearch (&search_seg, segs, num_segs, sizeof (GimpBoundSeg *), cmp_func);
if (seg != NULL)
{
@@ -922,10 +923,10 @@ find_segment_with_func (const BoundSeg **segs,
/* simplifying utility functions */
static void
-simplify_subdivide (const BoundSeg *segs,
- gint start_idx,
- gint end_idx,
- GArray **ret_points)
+simplify_subdivide (const GimpBoundSeg *segs,
+ gint start_idx,
+ gint end_idx,
+ GArray **ret_points)
{
gint maxdist_idx;
gint maxdist;
diff --git a/app/core/gimpboundary.h b/app/core/gimpboundary.h
index 89c04f0..64d423a 100644
--- a/app/core/gimpboundary.h
+++ b/app/core/gimpboundary.h
@@ -15,22 +15,22 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#ifndef __BOUNDARY_H__
-#define __BOUNDARY_H__
+#ifndef __GIMP_BOUNDARY_H__
+#define __GIMP_BOUNDARY_H__
/* half intensity for mask */
-#define BOUNDARY_HALF_WAY 127
+#define GIMP_BOUNDARY_HALF_WAY 127
typedef enum
{
- BOUNDARY_WITHIN_BOUNDS,
- BOUNDARY_IGNORE_BOUNDS
-} BoundaryType;
+ GIMP_BOUNDARY_WITHIN_BOUNDS,
+ GIMP_BOUNDARY_IGNORE_BOUNDS
+} GimpBoundaryType;
-struct _BoundSeg
+struct _GimpBoundSeg
{
gint x1;
gint y1;
@@ -41,26 +41,26 @@ struct _BoundSeg
};
-BoundSeg * boundary_find (PixelRegion *maskPR,
- BoundaryType type,
- gint x1,
- gint y1,
- gint x2,
- gint y2,
- guchar threshold,
- gint *num_segs);
-BoundSeg * boundary_sort (const BoundSeg *segs,
- gint num_segs,
- gint *num_groups);
-BoundSeg * boundary_simplify (BoundSeg *sorted_segs,
- gint num_groups,
- gint *num_segs);
+GimpBoundSeg * gimp_boundary_find (PixelRegion *maskPR,
+ GimpBoundaryType type,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2,
+ guchar threshold,
+ gint *num_segs);
+GimpBoundSeg * gimp_boundary_sort (const GimpBoundSeg *segs,
+ gint num_segs,
+ gint *num_groups);
+GimpBoundSeg * gimp_boundary_simplify (GimpBoundSeg *sorted_segs,
+ gint num_groups,
+ gint *num_segs);
/* offsets in-place */
-void boundary_offset (BoundSeg *segs,
- gint num_segs,
- gint off_x,
- gint off_y);
+void gimp_boundary_offset (GimpBoundSeg *segs,
+ gint num_segs,
+ gint off_x,
+ gint off_y);
-#endif /* __BOUNDARY_H__ */
+#endif /* __GIMP_BOUNDARY_H__ */
diff --git a/app/core/gimpbrush-boundary.c b/app/core/gimpbrush-boundary.c
index 068f912..cc12225 100644
--- a/app/core/gimpbrush-boundary.c
+++ b/app/core/gimpbrush-boundary.c
@@ -45,25 +45,25 @@ gimp_brush_transform_boundary_exact (GimpBrush *brush,
if (mask)
{
- PixelRegion maskPR;
- BoundSeg *bound_segs;
- gint n_bound_segs;
+ PixelRegion maskPR;
+ GimpBoundSeg *bound_segs;
+ gint n_bound_segs;
pixel_region_init_temp_buf (&maskPR, (TempBuf *) mask,
0, 0, mask->width, mask->height);
- bound_segs = boundary_find (&maskPR, BOUNDARY_WITHIN_BOUNDS,
- 0, 0, maskPR.w, maskPR.h,
- 0,
- &n_bound_segs);
+ bound_segs = gimp_boundary_find (&maskPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+ 0, 0, maskPR.w, maskPR.h,
+ 0,
+ &n_bound_segs);
if (bound_segs)
{
- BoundSeg *stroke_segs;
- gint n_stroke_groups;
+ GimpBoundSeg *stroke_segs;
+ gint n_stroke_groups;
- stroke_segs = boundary_sort (bound_segs, n_bound_segs,
- &n_stroke_groups);
+ stroke_segs = gimp_boundary_sort (bound_segs, n_bound_segs,
+ &n_stroke_groups);
g_free (bound_segs);
diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c
index fff221f..4dafa63 100644
--- a/app/core/gimpchannel.c
+++ b/app/core/gimpchannel.c
@@ -138,90 +138,90 @@ static void gimp_channel_invalidate_boundary (GimpDrawable *drawable);
static void gimp_channel_get_active_components (const GimpDrawable *drawable,
gboolean *active);
-static void gimp_channel_apply_region (GimpDrawable *drawable,
- PixelRegion *src2PR,
- gboolean push_undo,
- const gchar *undo_desc,
- gdouble opacity,
+static void gimp_channel_apply_region (GimpDrawable *drawable,
+ PixelRegion *src2PR,
+ gboolean push_undo,
+ const gchar *undo_desc,
+ gdouble opacity,
GimpLayerModeEffects mode,
- TileManager *src1_tiles,
- PixelRegion *destPR,
- gint x,
- gint y);
-static void gimp_channel_replace_region (GimpDrawable *drawable,
- PixelRegion *src2PR,
- gboolean push_undo,
- const gchar *undo_desc,
- gdouble opacity,
- PixelRegion *maskPR,
- gint x,
- gint y);
-static void gimp_channel_set_tiles (GimpDrawable *drawable,
- gboolean push_undo,
- const gchar *undo_desc,
- TileManager *tiles,
- GimpImageType type,
- gint offset_x,
- gint offset_y);
-static GeglNode * gimp_channel_get_node (GimpItem *item);
-static void gimp_channel_swap_pixels (GimpDrawable *drawable,
- TileManager *tiles,
- gboolean sparse,
- gint x,
- gint y,
- gint width,
- gint height);
-
-static gint gimp_channel_get_opacity_at (GimpPickable *pickable,
- gint x,
- gint y);
-
-static gboolean gimp_channel_real_boundary (GimpChannel *channel,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint x1,
- gint y1,
- gint x2,
- gint y2);
-static gboolean gimp_channel_real_bounds (GimpChannel *channel,
- gint *x1,
- gint *y1,
- gint *x2,
- gint *y2);
-static gboolean gimp_channel_real_is_empty (GimpChannel *channel);
-static void gimp_channel_real_feather (GimpChannel *channel,
- gdouble radius_x,
- gdouble radius_y,
- gboolean push_undo);
-static void gimp_channel_real_sharpen (GimpChannel *channel,
- gboolean push_undo);
-static void gimp_channel_real_clear (GimpChannel *channel,
- const gchar *undo_desc,
- gboolean push_undo);
-static void gimp_channel_real_all (GimpChannel *channel,
- gboolean push_undo);
-static void gimp_channel_real_invert (GimpChannel *channel,
- gboolean push_undo);
-static void gimp_channel_real_border (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean feather,
- gboolean edge_lock,
- gboolean push_undo);
-static void gimp_channel_real_grow (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean push_undo);
-static void gimp_channel_real_shrink (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean edge_lock,
- gboolean push_undo);
-
-static void gimp_channel_validate_tile (TileManager *tm,
- Tile *tile);
+ TileManager *src1_tiles,
+ PixelRegion *destPR,
+ gint x,
+ gint y);
+static void gimp_channel_replace_region (GimpDrawable *drawable,
+ PixelRegion *src2PR,
+ gboolean push_undo,
+ const gchar *undo_desc,
+ gdouble opacity,
+ PixelRegion *maskPR,
+ gint x,
+ gint y);
+static void gimp_channel_set_tiles (GimpDrawable *drawable,
+ gboolean push_undo,
+ const gchar *undo_desc,
+ TileManager *tiles,
+ GimpImageType type,
+ gint offset_x,
+ gint offset_y);
+static GeglNode * gimp_channel_get_node (GimpItem *item);
+static void gimp_channel_swap_pixels (GimpDrawable *drawable,
+ TileManager *tiles,
+ gboolean sparse,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+static gint gimp_channel_get_opacity_at (GimpPickable *pickable,
+ gint x,
+ gint y);
+
+static gboolean gimp_channel_real_boundary (GimpChannel *channel,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2);
+static gboolean gimp_channel_real_bounds (GimpChannel *channel,
+ gint *x1,
+ gint *y1,
+ gint *x2,
+ gint *y2);
+static gboolean gimp_channel_real_is_empty (GimpChannel *channel);
+static void gimp_channel_real_feather (GimpChannel *channel,
+ gdouble radius_x,
+ gdouble radius_y,
+ gboolean push_undo);
+static void gimp_channel_real_sharpen (GimpChannel *channel,
+ gboolean push_undo);
+static void gimp_channel_real_clear (GimpChannel *channel,
+ const gchar *undo_desc,
+ gboolean push_undo);
+static void gimp_channel_real_all (GimpChannel *channel,
+ gboolean push_undo);
+static void gimp_channel_real_invert (GimpChannel *channel,
+ gboolean push_undo);
+static void gimp_channel_real_border (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean feather,
+ gboolean edge_lock,
+ gboolean push_undo);
+static void gimp_channel_real_grow (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean push_undo);
+static void gimp_channel_real_shrink (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean edge_lock,
+ gboolean push_undo);
+
+static void gimp_channel_validate_tile (TileManager *tm,
+ Tile *tile);
G_DEFINE_TYPE_WITH_CODE (GimpChannel, gimp_channel, GIMP_TYPE_DRAWABLE,
@@ -372,8 +372,8 @@ gimp_channel_get_memsize (GimpObject *object,
{
GimpChannel *channel = GIMP_CHANNEL (object);
- *gui_size += channel->num_segs_in * sizeof (BoundSeg);
- *gui_size += channel->num_segs_out * sizeof (BoundSeg);
+ *gui_size += channel->num_segs_in * sizeof (GimpBoundSeg);
+ *gui_size += channel->num_segs_out * sizeof (GimpBoundSeg);
return GIMP_OBJECT_CLASS (parent_class)->get_memsize (object, gui_size);
}
@@ -721,13 +721,13 @@ gimp_channel_stroke (GimpItem *item,
GimpProgress *progress,
GError **error)
{
- GimpChannel *channel = GIMP_CHANNEL (item);
- const BoundSeg *segs_in;
- const BoundSeg *segs_out;
- gint n_segs_in;
- gint n_segs_out;
- gboolean retval = FALSE;
- gint offset_x, offset_y;
+ GimpChannel *channel = GIMP_CHANNEL (item);
+ const GimpBoundSeg *segs_in;
+ const GimpBoundSeg *segs_out;
+ gint n_segs_in;
+ gint n_segs_out;
+ gboolean retval = FALSE;
+ gint offset_x, offset_y;
if (! gimp_channel_boundary (channel, &segs_in, &segs_out,
&n_segs_in, &n_segs_out,
@@ -1000,15 +1000,15 @@ gimp_channel_get_opacity_at (GimpPickable *pickable,
}
static gboolean
-gimp_channel_real_boundary (GimpChannel *channel,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint x1,
- gint y1,
- gint x2,
- gint y2)
+gimp_channel_real_boundary (GimpChannel *channel,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2)
{
gint x3, y3, x4, y4;
PixelRegion bPR;
@@ -1025,10 +1025,10 @@ gimp_channel_real_boundary (GimpChannel *channel,
gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)),
x3, y3, x4 - x3, y4 - y3, FALSE);
- channel->segs_out = boundary_find (&bPR, BOUNDARY_IGNORE_BOUNDS,
- x1, y1, x2, y2,
- BOUNDARY_HALF_WAY,
- &channel->num_segs_out);
+ channel->segs_out = gimp_boundary_find (&bPR, GIMP_BOUNDARY_IGNORE_BOUNDS,
+ x1, y1, x2, y2,
+ GIMP_BOUNDARY_HALF_WAY,
+ &channel->num_segs_out);
x1 = MAX (x1, x3);
y1 = MAX (y1, y3);
x2 = MIN (x2, x4);
@@ -1042,10 +1042,10 @@ gimp_channel_real_boundary (GimpChannel *channel,
gimp_item_get_width (GIMP_ITEM (channel)),
gimp_item_get_height (GIMP_ITEM (channel)), FALSE);
- channel->segs_in = boundary_find (&bPR, BOUNDARY_WITHIN_BOUNDS,
- x1, y1, x2, y2,
- BOUNDARY_HALF_WAY,
- &channel->num_segs_in);
+ channel->segs_in = gimp_boundary_find (&bPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+ x1, y1, x2, y2,
+ GIMP_BOUNDARY_HALF_WAY,
+ &channel->num_segs_in);
}
else
{
@@ -1929,15 +1929,15 @@ gimp_channel_new_mask (GimpImage *image,
}
gboolean
-gimp_channel_boundary (GimpChannel *channel,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint x1,
- gint y1,
- gint x2,
- gint y2)
+gimp_channel_boundary (GimpChannel *channel,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2)
{
g_return_val_if_fail (GIMP_IS_CHANNEL (channel), FALSE);
g_return_val_if_fail (segs_in != NULL, FALSE);
diff --git a/app/core/gimpchannel.h b/app/core/gimpchannel.h
index 5b1dd77..b0255c1 100644
--- a/app/core/gimpchannel.h
+++ b/app/core/gimpchannel.h
@@ -45,8 +45,8 @@ struct _GimpChannel
/* Selection mask variables */
gboolean boundary_known; /* is the current boundary valid */
- BoundSeg *segs_in; /* outline of selected region */
- BoundSeg *segs_out; /* outline of selected region */
+ GimpBoundSeg *segs_in; /* outline of selected region */
+ GimpBoundSeg *segs_out; /* outline of selected region */
gint num_segs_in; /* number of lines in boundary */
gint num_segs_out; /* number of lines in boundary */
gboolean empty; /* is the region empty? */
@@ -60,53 +60,53 @@ struct _GimpChannelClass
GimpDrawableClass parent_class;
/* signals */
- void (* color_changed) (GimpChannel *channel);
+ void (* color_changed) (GimpChannel *channel);
/* virtual functions */
- gboolean (* boundary) (GimpChannel *channel,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint x1,
- gint y1,
- gint x2,
- gint y2);
- gboolean (* bounds) (GimpChannel *channel,
- gint *x1,
- gint *y1,
- gint *x2,
- gint *y2);
- gboolean (* is_empty) (GimpChannel *channel);
-
- void (* feather) (GimpChannel *channel,
- gdouble radius_x,
- gdouble radius_y,
- gboolean push_undo);
- void (* sharpen) (GimpChannel *channel,
- gboolean push_undo);
- void (* clear) (GimpChannel *channel,
- const gchar *undo_desc,
- gboolean push_undo);
- void (* all) (GimpChannel *channel,
- gboolean push_undo);
- void (* invert) (GimpChannel *channel,
- gboolean push_undo);
- void (* border) (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean feather,
- gboolean edge_lock,
- gboolean push_undo);
- void (* grow) (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean push_undo);
- void (* shrink) (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean edge_lock,
- gboolean push_undo);
+ gboolean (* boundary) (GimpChannel *channel,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2);
+ gboolean (* bounds) (GimpChannel *channel,
+ gint *x1,
+ gint *y1,
+ gint *x2,
+ gint *y2);
+ gboolean (* is_empty) (GimpChannel *channel);
+
+ void (* feather) (GimpChannel *channel,
+ gdouble radius_x,
+ gdouble radius_y,
+ gboolean push_undo);
+ void (* sharpen) (GimpChannel *channel,
+ gboolean push_undo);
+ void (* clear) (GimpChannel *channel,
+ const gchar *undo_desc,
+ gboolean push_undo);
+ void (* all) (GimpChannel *channel,
+ gboolean push_undo);
+ void (* invert) (GimpChannel *channel,
+ gboolean push_undo);
+ void (* border) (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean feather,
+ gboolean edge_lock,
+ gboolean push_undo);
+ void (* grow) (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean push_undo);
+ void (* shrink) (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean edge_lock,
+ gboolean push_undo);
const gchar *feather_desc;
const gchar *sharpen_desc;
@@ -161,56 +161,56 @@ void gimp_channel_push_undo (GimpChannel *mask,
/* selection mask functions */
-GimpChannel * gimp_channel_new_mask (GimpImage *image,
- gint width,
- gint height);
-
-gboolean gimp_channel_boundary (GimpChannel *mask,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint x1,
- gint y1,
- gint x2,
- gint y2);
-gboolean gimp_channel_bounds (GimpChannel *mask,
- gint *x1,
- gint *y1,
- gint *x2,
- gint *y2);
-gboolean gimp_channel_is_empty (GimpChannel *mask);
-
-void gimp_channel_feather (GimpChannel *mask,
- gdouble radius_x,
- gdouble radius_y,
- gboolean push_undo);
-void gimp_channel_sharpen (GimpChannel *mask,
- gboolean push_undo);
-
-void gimp_channel_clear (GimpChannel *mask,
- const gchar *undo_desc,
- gboolean push_undo);
-void gimp_channel_all (GimpChannel *mask,
- gboolean push_undo);
-void gimp_channel_invert (GimpChannel *mask,
- gboolean push_undo);
-
-void gimp_channel_border (GimpChannel *mask,
- gint radius_x,
- gint radius_y,
- gboolean feather,
- gboolean edge_lock,
- gboolean push_undo);
-void gimp_channel_grow (GimpChannel *mask,
- gint radius_x,
- gint radius_y,
- gboolean push_undo);
-void gimp_channel_shrink (GimpChannel *mask,
- gint radius_x,
- gint radius_y,
- gboolean edge_lock,
- gboolean push_undo);
+GimpChannel * gimp_channel_new_mask (GimpImage *image,
+ gint width,
+ gint height);
+
+gboolean gimp_channel_boundary (GimpChannel *mask,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2);
+gboolean gimp_channel_bounds (GimpChannel *mask,
+ gint *x1,
+ gint *y1,
+ gint *x2,
+ gint *y2);
+gboolean gimp_channel_is_empty (GimpChannel *mask);
+
+void gimp_channel_feather (GimpChannel *mask,
+ gdouble radius_x,
+ gdouble radius_y,
+ gboolean push_undo);
+void gimp_channel_sharpen (GimpChannel *mask,
+ gboolean push_undo);
+
+void gimp_channel_clear (GimpChannel *mask,
+ const gchar *undo_desc,
+ gboolean push_undo);
+void gimp_channel_all (GimpChannel *mask,
+ gboolean push_undo);
+void gimp_channel_invert (GimpChannel *mask,
+ gboolean push_undo);
+
+void gimp_channel_border (GimpChannel *mask,
+ gint radius_x,
+ gint radius_y,
+ gboolean feather,
+ gboolean edge_lock,
+ gboolean push_undo);
+void gimp_channel_grow (GimpChannel *mask,
+ gint radius_x,
+ gint radius_y,
+ gboolean push_undo);
+void gimp_channel_shrink (GimpChannel *mask,
+ gint radius_x,
+ gint radius_y,
+ gboolean edge_lock,
+ gboolean push_undo);
#endif /* __GIMP_CHANNEL_H__ */
diff --git a/app/core/gimpdrawable-stroke.c b/app/core/gimpdrawable-stroke.c
index 801e94f..7ee618b 100644
--- a/app/core/gimpdrawable-stroke.c
+++ b/app/core/gimpdrawable-stroke.c
@@ -56,32 +56,32 @@
/* local function prototypes */
-static GimpScanConvert * gimp_drawable_render_boundary (GimpDrawable *drawable,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- gint offset_x,
- gint offset_y);
-static GimpScanConvert * gimp_drawable_render_vectors (GimpDrawable *drawable,
- GimpVectors *vectors,
- gboolean do_stroke,
- GError **error);
-static void gimp_drawable_stroke_scan_convert (GimpDrawable *drawable,
- GimpFillOptions *options,
- GimpScanConvert *scan_convert,
- gboolean do_stroke,
- gboolean push_undo);
+static GimpScanConvert * gimp_drawable_render_boundary (GimpDrawable *drawable,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint offset_x,
+ gint offset_y);
+static GimpScanConvert * gimp_drawable_render_vectors (GimpDrawable *drawable,
+ GimpVectors *vectors,
+ gboolean do_stroke,
+ GError **error);
+static void gimp_drawable_stroke_scan_convert (GimpDrawable *drawable,
+ GimpFillOptions *options,
+ GimpScanConvert *scan_convert,
+ gboolean do_stroke,
+ gboolean push_undo);
/* public functions */
void
-gimp_drawable_fill_boundary (GimpDrawable *drawable,
- GimpFillOptions *options,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- gint offset_x,
- gint offset_y,
- gboolean push_undo)
+gimp_drawable_fill_boundary (GimpDrawable *drawable,
+ GimpFillOptions *options,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint offset_x,
+ gint offset_y,
+ gboolean push_undo)
{
GimpScanConvert *scan_convert;
@@ -106,13 +106,13 @@ gimp_drawable_fill_boundary (GimpDrawable *drawable,
}
void
-gimp_drawable_stroke_boundary (GimpDrawable *drawable,
- GimpStrokeOptions *options,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- gint offset_x,
- gint offset_y,
- gboolean push_undo)
+gimp_drawable_stroke_boundary (GimpDrawable *drawable,
+ GimpStrokeOptions *options,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint offset_x,
+ gint offset_y,
+ gboolean push_undo)
{
GimpScanConvert *scan_convert;
@@ -206,18 +206,19 @@ gimp_drawable_stroke_vectors (GimpDrawable *drawable,
/* private functions */
static GimpScanConvert *
-gimp_drawable_render_boundary (GimpDrawable *drawable,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- gint offset_x,
- gint offset_y)
+gimp_drawable_render_boundary (GimpDrawable *drawable,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint offset_x,
+ gint offset_y)
{
if (bound_segs)
{
- BoundSeg *stroke_segs;
- gint n_stroke_segs;
+ GimpBoundSeg *stroke_segs;
+ gint n_stroke_segs;
- stroke_segs = boundary_sort (bound_segs, n_bound_segs, &n_stroke_segs);
+ stroke_segs = gimp_boundary_sort (bound_segs, n_bound_segs,
+ &n_stroke_segs);
if (stroke_segs)
{
diff --git a/app/core/gimpdrawable-stroke.h b/app/core/gimpdrawable-stroke.h
index 9096143..11a26ef 100644
--- a/app/core/gimpdrawable-stroke.h
+++ b/app/core/gimpdrawable-stroke.h
@@ -24,14 +24,14 @@
void gimp_drawable_fill_boundary (GimpDrawable *drawable,
GimpFillOptions *options,
- const BoundSeg *bound_segs,
+ const GimpBoundSeg *bound_segs,
gint n_bound_segs,
gint offset_x,
gint offset_y,
gboolean push_undo);
void gimp_drawable_stroke_boundary (GimpDrawable *drawable,
GimpStrokeOptions *options,
- const BoundSeg *bound_segs,
+ const GimpBoundSeg *bound_segs,
gint n_bound_segs,
gint offset_x,
gint offset_y,
diff --git a/app/core/gimplayer-floating-sel.c b/app/core/gimplayer-floating-sel.c
index 66605f8..2f7c795 100644
--- a/app/core/gimplayer-floating-sel.c
+++ b/app/core/gimplayer-floating-sel.c
@@ -186,7 +186,7 @@ floating_sel_activate_drawable (GimpLayer *layer)
}
}
-const BoundSeg *
+const GimpBoundSeg *
floating_sel_boundary (GimpLayer *layer,
gint *n_segs)
{
@@ -215,10 +215,10 @@ floating_sel_boundary (GimpLayer *layer,
pixel_region_init (&bPR,
gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
0, 0, width, height, FALSE);
- layer->fs.segs = boundary_find (&bPR, BOUNDARY_WITHIN_BOUNDS,
- 0, 0, width, height,
- BOUNDARY_HALF_WAY,
- &layer->fs.num_segs);
+ layer->fs.segs = gimp_boundary_find (&bPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+ 0, 0, width, height,
+ GIMP_BOUNDARY_HALF_WAY,
+ &layer->fs.num_segs);
/* offset the segments */
for (i = 0; i < layer->fs.num_segs; i++)
@@ -232,7 +232,7 @@ floating_sel_boundary (GimpLayer *layer,
else
{
layer->fs.num_segs = 4;
- layer->fs.segs = g_new0 (BoundSeg, 4);
+ layer->fs.segs = g_new0 (GimpBoundSeg, 4);
/* top */
layer->fs.segs[0].x1 = off_x;
diff --git a/app/core/gimplayer-floating-sel.h b/app/core/gimplayer-floating-sel.h
index 43ea914..d66114c 100644
--- a/app/core/gimplayer-floating-sel.h
+++ b/app/core/gimplayer-floating-sel.h
@@ -19,15 +19,15 @@
#define __GIMP_LAYER_FLOATING_SEL_H__
-void floating_sel_attach (GimpLayer *layer,
- GimpDrawable *drawable);
-void floating_sel_anchor (GimpLayer *layer);
-gboolean floating_sel_to_layer (GimpLayer *layer,
- GError **error);
-void floating_sel_activate_drawable (GimpLayer *layer);
-const BoundSeg * floating_sel_boundary (GimpLayer *layer,
- gint *n_segs);
-void floating_sel_invalidate (GimpLayer *layer);
+void floating_sel_attach (GimpLayer *layer,
+ GimpDrawable *drawable);
+void floating_sel_anchor (GimpLayer *layer);
+gboolean floating_sel_to_layer (GimpLayer *layer,
+ GError **error);
+void floating_sel_activate_drawable (GimpLayer *layer);
+const GimpBoundSeg * floating_sel_boundary (GimpLayer *layer,
+ gint *n_segs);
+void floating_sel_invalidate (GimpLayer *layer);
#endif /* __GIMP_LAYER_FLOATING_SEL_H__ */
diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c
index cd2974b..42f60dc 100644
--- a/app/core/gimplayer.c
+++ b/app/core/gimplayer.c
@@ -492,7 +492,7 @@ gimp_layer_get_memsize (GimpObject *object,
memsize += gimp_object_get_memsize (GIMP_OBJECT (layer->mask), gui_size);
- *gui_size += layer->fs.num_segs * sizeof (BoundSeg);
+ *gui_size += layer->fs.num_segs * sizeof (GimpBoundSeg);
return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
diff --git a/app/core/gimplayer.h b/app/core/gimplayer.h
index a01b97c..cf14eb0 100644
--- a/app/core/gimplayer.h
+++ b/app/core/gimplayer.h
@@ -52,7 +52,7 @@ struct _GimpLayer
{
GimpDrawable *drawable; /* floating sel is attached to */
gboolean boundary_known; /* is the current boundary valid */
- BoundSeg *segs; /* boundary of floating sel */
+ GimpBoundSeg *segs; /* boundary of floating sel */
gint num_segs; /* number of segs in boundary */
} fs;
};
diff --git a/app/core/gimpselection.c b/app/core/gimpselection.c
index d67dfcb..e70fcbf 100644
--- a/app/core/gimpselection.c
+++ b/app/core/gimpselection.c
@@ -45,87 +45,87 @@
#include "gimp-intl.h"
-static gboolean gimp_selection_is_attached (const GimpItem *item);
-static GimpItemTree * gimp_selection_get_tree (GimpItem *item);
-static void gimp_selection_translate (GimpItem *item,
- gint offset_x,
- gint offset_y,
- gboolean push_undo);
-static void gimp_selection_scale (GimpItem *item,
- gint new_width,
- gint new_height,
- gint new_offset_x,
- gint new_offset_y,
+static gboolean gimp_selection_is_attached (const GimpItem *item);
+static GimpItemTree * gimp_selection_get_tree (GimpItem *item);
+static void gimp_selection_translate (GimpItem *item,
+ gint offset_x,
+ gint offset_y,
+ gboolean push_undo);
+static void gimp_selection_scale (GimpItem *item,
+ gint new_width,
+ gint new_height,
+ gint new_offset_x,
+ gint new_offset_y,
GimpInterpolationType interp_type,
- GimpProgress *progress);
-static void gimp_selection_resize (GimpItem *item,
- GimpContext *context,
- gint new_width,
- gint new_height,
- gint offset_x,
- gint offset_y);
-static void gimp_selection_flip (GimpItem *item,
- GimpContext *context,
- GimpOrientationType flip_type,
- gdouble axis,
- gboolean clip_result);
-static void gimp_selection_rotate (GimpItem *item,
- GimpContext *context,
- GimpRotationType rotation_type,
- gdouble center_x,
- gdouble center_y,
- gboolean clip_result);
-static gboolean gimp_selection_stroke (GimpItem *item,
- GimpDrawable *drawable,
- GimpStrokeOptions *stroke_options,
- gboolean push_undo,
- GimpProgress *progress,
- GError **error);
-static void gimp_selection_invalidate_boundary (GimpDrawable *drawable);
-
-static gboolean gimp_selection_boundary (GimpChannel *channel,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint x1,
- gint y1,
- gint x2,
- gint y2);
-static gboolean gimp_selection_bounds (GimpChannel *channel,
- gint *x1,
- gint *y1,
- gint *x2,
- gint *y2);
-static gboolean gimp_selection_is_empty (GimpChannel *channel);
-static void gimp_selection_feather (GimpChannel *channel,
- gdouble radius_x,
- gdouble radius_y,
- gboolean push_undo);
-static void gimp_selection_sharpen (GimpChannel *channel,
- gboolean push_undo);
-static void gimp_selection_clear (GimpChannel *channel,
- const gchar *undo_desc,
- gboolean push_undo);
-static void gimp_selection_all (GimpChannel *channel,
- gboolean push_undo);
-static void gimp_selection_invert (GimpChannel *channel,
- gboolean push_undo);
-static void gimp_selection_border (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean feather,
- gboolean edge_lock,
- gboolean push_undo);
-static void gimp_selection_grow (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean push_undo);
-static void gimp_selection_shrink (GimpChannel *channel,
- gint radius_x,
- gint radius_y,
- gboolean edge_lock,
- gboolean push_undo);
+ GimpProgress *progress);
+static void gimp_selection_resize (GimpItem *item,
+ GimpContext *context,
+ gint new_width,
+ gint new_height,
+ gint offset_x,
+ gint offset_y);
+static void gimp_selection_flip (GimpItem *item,
+ GimpContext *context,
+ GimpOrientationType flip_type,
+ gdouble axis,
+ gboolean clip_result);
+static void gimp_selection_rotate (GimpItem *item,
+ GimpContext *context,
+ GimpRotationType rotation_type,
+ gdouble center_x,
+ gdouble center_y,
+ gboolean clip_result);
+static gboolean gimp_selection_stroke (GimpItem *item,
+ GimpDrawable *drawable,
+ GimpStrokeOptions *stroke_options,
+ gboolean push_undo,
+ GimpProgress *progress,
+ GError **error);
+static void gimp_selection_invalidate_boundary (GimpDrawable *drawable);
+
+static gboolean gimp_selection_boundary (GimpChannel *channel,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint x1,
+ gint y1,
+ gint x2,
+ gint y2);
+static gboolean gimp_selection_bounds (GimpChannel *channel,
+ gint *x1,
+ gint *y1,
+ gint *x2,
+ gint *y2);
+static gboolean gimp_selection_is_empty (GimpChannel *channel);
+static void gimp_selection_feather (GimpChannel *channel,
+ gdouble radius_x,
+ gdouble radius_y,
+ gboolean push_undo);
+static void gimp_selection_sharpen (GimpChannel *channel,
+ gboolean push_undo);
+static void gimp_selection_clear (GimpChannel *channel,
+ const gchar *undo_desc,
+ gboolean push_undo);
+static void gimp_selection_all (GimpChannel *channel,
+ gboolean push_undo);
+static void gimp_selection_invert (GimpChannel *channel,
+ gboolean push_undo);
+static void gimp_selection_border (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean feather,
+ gboolean edge_lock,
+ gboolean push_undo);
+static void gimp_selection_grow (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean push_undo);
+static void gimp_selection_shrink (GimpChannel *channel,
+ gint radius_x,
+ gint radius_y,
+ gboolean edge_lock,
+ gboolean push_undo);
G_DEFINE_TYPE (GimpSelection, gimp_selection, GIMP_TYPE_CHANNEL)
@@ -270,12 +270,12 @@ gimp_selection_stroke (GimpItem *item,
GimpProgress *progress,
GError **error)
{
- GimpSelection *selection = GIMP_SELECTION (item);
- const BoundSeg *dummy_in;
- const BoundSeg *dummy_out;
- gint num_dummy_in;
- gint num_dummy_out;
- gboolean retval;
+ GimpSelection *selection = GIMP_SELECTION (item);
+ const GimpBoundSeg *dummy_in;
+ const GimpBoundSeg *dummy_out;
+ gint num_dummy_in;
+ gint num_dummy_out;
+ gboolean retval;
if (! gimp_channel_boundary (GIMP_CHANNEL (selection),
&dummy_in, &dummy_out,
@@ -326,15 +326,15 @@ gimp_selection_invalidate_boundary (GimpDrawable *drawable)
}
static gboolean
-gimp_selection_boundary (GimpChannel *channel,
- const BoundSeg **segs_in,
- const BoundSeg **segs_out,
- gint *num_segs_in,
- gint *num_segs_out,
- gint unused1,
- gint unused2,
- gint unused3,
- gint unused4)
+gimp_selection_boundary (GimpChannel *channel,
+ const GimpBoundSeg **segs_in,
+ const GimpBoundSeg **segs_out,
+ gint *num_segs_in,
+ gint *num_segs_out,
+ gint unused1,
+ gint unused2,
+ gint unused3,
+ gint unused4)
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (channel));
GimpDrawable *drawable;
diff --git a/app/display/gimpcanvasboundary.c b/app/display/gimpcanvasboundary.c
index f87e58d..e3aa9e9 100644
--- a/app/display/gimpcanvasboundary.c
+++ b/app/display/gimpcanvasboundary.c
@@ -52,11 +52,11 @@ typedef struct _GimpCanvasBoundaryPrivate GimpCanvasBoundaryPrivate;
struct _GimpCanvasBoundaryPrivate
{
- BoundSeg *segs;
- gint n_segs;
- GimpMatrix3 *transform;
- gdouble offset_x;
- gdouble offset_y;
+ GimpBoundSeg *segs;
+ gint n_segs;
+ GimpMatrix3 *transform;
+ gdouble offset_x;
+ gdouble offset_y;
};
#define GET_PRIVATE(boundary) \
@@ -343,12 +343,12 @@ gimp_canvas_boundary_get_extents (GimpCanvasItem *item,
}
GimpCanvasItem *
-gimp_canvas_boundary_new (GimpDisplayShell *shell,
- const BoundSeg *segs,
- gint n_segs,
- GimpMatrix3 *transform,
- gdouble offset_x,
- gdouble offset_y)
+gimp_canvas_boundary_new (GimpDisplayShell *shell,
+ const GimpBoundSeg *segs,
+ gint n_segs,
+ GimpMatrix3 *transform,
+ gdouble offset_x,
+ gdouble offset_y)
{
GimpCanvasItem *item;
GimpCanvasBoundaryPrivate *private;
@@ -364,7 +364,7 @@ gimp_canvas_boundary_new (GimpDisplayShell *shell,
private = GET_PRIVATE (item);
/* puke */
- private->segs = g_memdup (segs, n_segs * sizeof (BoundSeg));
+ private->segs = g_memdup (segs, n_segs * sizeof (GimpBoundSeg));
private->n_segs = n_segs;
return item;
diff --git a/app/display/gimpcanvasboundary.h b/app/display/gimpcanvasboundary.h
index d45039e..47d37dd 100644
--- a/app/display/gimpcanvasboundary.h
+++ b/app/display/gimpcanvasboundary.h
@@ -49,12 +49,12 @@ struct _GimpCanvasBoundaryClass
GType gimp_canvas_boundary_get_type (void) G_GNUC_CONST;
-GimpCanvasItem * gimp_canvas_boundary_new (GimpDisplayShell *shell,
- const BoundSeg *segs,
- gint n_segs,
- GimpMatrix3 *transform,
- gdouble offset_x,
- gdouble offset_y);
+GimpCanvasItem * gimp_canvas_boundary_new (GimpDisplayShell *shell,
+ const GimpBoundSeg *segs,
+ gint n_segs,
+ GimpMatrix3 *transform,
+ gdouble offset_x,
+ gdouble offset_y);
#endif /* __GIMP_CANVAS_BOUNDARY_H__ */
diff --git a/app/display/gimpdisplayshell-selection.c b/app/display/gimpdisplayshell-selection.c
index a3521dc..d66211d 100644
--- a/app/display/gimpdisplayshell-selection.c
+++ b/app/display/gimpdisplayshell-selection.c
@@ -61,23 +61,23 @@ struct _Selection
/* local function prototypes */
-static void selection_start (Selection *selection);
-static void selection_stop (Selection *selection);
+static void selection_start (Selection *selection);
+static void selection_stop (Selection *selection);
-static void selection_draw (Selection *selection);
-static void selection_undraw (Selection *selection);
+static void selection_draw (Selection *selection);
+static void selection_undraw (Selection *selection);
-static void selection_render_mask (Selection *selection);
+static void selection_render_mask (Selection *selection);
-static void selection_transform_segs (Selection *selection,
- const BoundSeg *src_segs,
- GimpSegment *dest_segs,
- gint n_segs);
-static void selection_generate_segs (Selection *selection);
-static void selection_free_segs (Selection *selection);
+static void selection_transform_segs (Selection *selection,
+ const GimpBoundSeg *src_segs,
+ GimpSegment *dest_segs,
+ gint n_segs);
+static void selection_generate_segs (Selection *selection);
+static void selection_free_segs (Selection *selection);
-static gboolean selection_start_timeout (Selection *selection);
-static gboolean selection_timeout (Selection *selection);
+static gboolean selection_start_timeout (Selection *selection);
+static gboolean selection_timeout (Selection *selection);
static gboolean selection_window_state_event (GtkWidget *shell,
GdkEventWindowState *event,
@@ -305,10 +305,10 @@ selection_render_mask (Selection *selection)
}
static void
-selection_transform_segs (Selection *selection,
- const BoundSeg *src_segs,
- GimpSegment *dest_segs,
- gint n_segs)
+selection_transform_segs (Selection *selection,
+ const GimpBoundSeg *src_segs,
+ GimpSegment *dest_segs,
+ gint n_segs)
{
const gint xclamp = selection->shell->disp_width + 1;
const gint yclamp = selection->shell->disp_height + 1;
@@ -351,9 +351,9 @@ selection_transform_segs (Selection *selection,
static void
selection_generate_segs (Selection *selection)
{
- GimpImage *image = gimp_display_get_image (selection->shell->display);
- const BoundSeg *segs_in;
- const BoundSeg *segs_out;
+ GimpImage *image = gimp_display_get_image (selection->shell->display);
+ const GimpBoundSeg *segs_in;
+ const GimpBoundSeg *segs_out;
/* Ask the image for the boundary of its selected region...
* Then transform that information into a new buffer of GimpSegments
diff --git a/app/display/gimpdisplayshell-transform.c b/app/display/gimpdisplayshell-transform.c
index af6f1bd..14bb347 100644
--- a/app/display/gimpdisplayshell-transform.c
+++ b/app/display/gimpdisplayshell-transform.c
@@ -234,7 +234,7 @@ gimp_display_shell_untransform_xy_f (const GimpDisplayShell *shell,
**/
void
gimp_display_shell_transform_segments (const GimpDisplayShell *shell,
- const BoundSeg *src_segs,
+ const GimpBoundSeg *src_segs,
GimpSegment *dest_segs,
gint n_segs,
gdouble offset_x,
diff --git a/app/display/gimpdisplayshell-transform.h b/app/display/gimpdisplayshell-transform.h
index 50feb71..0f8b747 100644
--- a/app/display/gimpdisplayshell-transform.h
+++ b/app/display/gimpdisplayshell-transform.h
@@ -50,7 +50,7 @@ void gimp_display_shell_untransform_xy_f (const GimpDisplayShell *shell,
gdouble *ny);
void gimp_display_shell_transform_segments (const GimpDisplayShell *shell,
- const BoundSeg *src_segs,
+ const GimpBoundSeg *src_segs,
GimpSegment *dest_segs,
gint n_segs,
gdouble offset_x,
diff --git a/app/paint/gimppaintcore-stroke.c b/app/paint/gimppaintcore-stroke.c
index 2b88ffe..1a6dee7 100644
--- a/app/paint/gimppaintcore-stroke.c
+++ b/app/paint/gimppaintcore-stroke.c
@@ -96,26 +96,26 @@ gimp_paint_core_stroke (GimpPaintCore *core,
}
gboolean
-gimp_paint_core_stroke_boundary (GimpPaintCore *core,
- GimpDrawable *drawable,
- GimpPaintOptions *paint_options,
- gboolean emulate_dynamics,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- gint offset_x,
- gint offset_y,
- gboolean push_undo,
- GError **error)
+gimp_paint_core_stroke_boundary (GimpPaintCore *core,
+ GimpDrawable *drawable,
+ GimpPaintOptions *paint_options,
+ gboolean emulate_dynamics,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint offset_x,
+ gint offset_y,
+ gboolean push_undo,
+ GError **error)
{
- BoundSeg *stroke_segs;
- gint n_stroke_segs;
- gint off_x;
- gint off_y;
- GimpCoords *coords;
- gboolean initialized = FALSE;
- gint n_coords;
- gint seg;
- gint s;
+ GimpBoundSeg *stroke_segs;
+ gint n_stroke_segs;
+ gint off_x;
+ gint off_y;
+ GimpCoords *coords;
+ gboolean initialized = FALSE;
+ gint n_coords;
+ gint seg;
+ gint s;
g_return_val_if_fail (GIMP_IS_PAINT_CORE (core), FALSE);
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), FALSE);
@@ -124,7 +124,8 @@ gimp_paint_core_stroke_boundary (GimpPaintCore *core,
g_return_val_if_fail (bound_segs != NULL && n_bound_segs > 0, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
- stroke_segs = boundary_sort (bound_segs, n_bound_segs, &n_stroke_segs);
+ stroke_segs = gimp_boundary_sort (bound_segs, n_bound_segs,
+ &n_stroke_segs);
if (n_stroke_segs == 0)
return TRUE;
diff --git a/app/paint/gimppaintcore-stroke.h b/app/paint/gimppaintcore-stroke.h
index 06f7c69..a6e23c2 100644
--- a/app/paint/gimppaintcore-stroke.h
+++ b/app/paint/gimppaintcore-stroke.h
@@ -19,30 +19,30 @@
#define __GIMP_PAINT_CORE_STROKE_H__
-gboolean gimp_paint_core_stroke (GimpPaintCore *core,
- GimpDrawable *drawable,
- GimpPaintOptions *paint_options,
- GimpCoords *strokes,
- gint n_strokes,
- gboolean push_undo,
- GError **error);
-gboolean gimp_paint_core_stroke_boundary (GimpPaintCore *core,
- GimpDrawable *drawable,
- GimpPaintOptions *paint_options,
- gboolean emulate_dynamics,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- gint offset_x,
- gint offset_y,
- gboolean push_undo,
- GError **error);
-gboolean gimp_paint_core_stroke_vectors (GimpPaintCore *core,
- GimpDrawable *drawable,
- GimpPaintOptions *paint_options,
- gboolean emulate_dynamics,
- GimpVectors *vectors,
- gboolean push_undo,
- GError **error);
+gboolean gimp_paint_core_stroke (GimpPaintCore *core,
+ GimpDrawable *drawable,
+ GimpPaintOptions *paint_options,
+ GimpCoords *strokes,
+ gint n_strokes,
+ gboolean push_undo,
+ GError **error);
+gboolean gimp_paint_core_stroke_boundary (GimpPaintCore *core,
+ GimpDrawable *drawable,
+ GimpPaintOptions *paint_options,
+ gboolean emulate_dynamics,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ gint offset_x,
+ gint offset_y,
+ gboolean push_undo,
+ GError **error);
+gboolean gimp_paint_core_stroke_vectors (GimpPaintCore *core,
+ GimpDrawable *drawable,
+ GimpPaintOptions *paint_options,
+ gboolean emulate_dynamics,
+ GimpVectors *vectors,
+ gboolean push_undo,
+ GError **error);
#endif /* __GIMP_PAINT_CORE_STROKE_H__ */
diff --git a/app/tools/gimpdrawtool.c b/app/tools/gimpdrawtool.c
index 531e46c..94d315b 100644
--- a/app/tools/gimpdrawtool.c
+++ b/app/tools/gimpdrawtool.c
@@ -860,12 +860,12 @@ gimp_draw_tool_add_pen (GimpDrawTool *draw_tool,
* indicate the end of connected segment sequences (groups) .
*/
GimpCanvasItem *
-gimp_draw_tool_add_boundary (GimpDrawTool *draw_tool,
- const BoundSeg *bound_segs,
- gint n_bound_segs,
- GimpMatrix3 *transform,
- gdouble offset_x,
- gdouble offset_y)
+gimp_draw_tool_add_boundary (GimpDrawTool *draw_tool,
+ const GimpBoundSeg *bound_segs,
+ gint n_bound_segs,
+ GimpMatrix3 *transform,
+ gdouble offset_x,
+ gdouble offset_y)
{
GimpCanvasItem *item;
diff --git a/app/tools/gimpdrawtool.h b/app/tools/gimpdrawtool.h
index 705fae6..5b25892 100644
--- a/app/tools/gimpdrawtool.h
+++ b/app/tools/gimpdrawtool.h
@@ -199,7 +199,7 @@ GimpCanvasItem * gimp_draw_tool_add_pen (GimpDrawTool *draw_too
gint width);
GimpCanvasItem * gimp_draw_tool_add_boundary (GimpDrawTool *draw_tool,
- const BoundSeg *bound_segs,
+ const GimpBoundSeg *bound_segs,
gint n_bound_segs,
GimpMatrix3 *transform,
gdouble offset_x,
diff --git a/app/tools/gimpeditselectiontool.c b/app/tools/gimpeditselectiontool.c
index 3dce466..68bfcf8 100644
--- a/app/tools/gimpeditselectiontool.c
+++ b/app/tools/gimpeditselectiontool.c
@@ -76,8 +76,8 @@ struct _GimpEditSelectionTool
gint x, y; /* Current x and y coords */
gint num_segs_in; /* Num seg in selection boundary */
gint num_segs_out; /* Num seg in selection boundary */
- BoundSeg *segs_in; /* Pointer to the channel sel. segs */
- BoundSeg *segs_out; /* Pointer to the channel sel. segs */
+ GimpBoundSeg *segs_in; /* Pointer to the channel sel. segs */
+ GimpBoundSeg *segs_out; /* Pointer to the channel sel. segs */
gint x1, y1; /* Bounding box of selection mask */
gint x2, y2;
@@ -193,8 +193,8 @@ gimp_edit_selection_tool_start (GimpTool *parent_tool,
GimpItem *active_item;
GimpChannel *channel;
gint off_x, off_y;
- const BoundSeg *segs_in;
- const BoundSeg *segs_out;
+ const GimpBoundSeg *segs_in;
+ const GimpBoundSeg *segs_out;
const gchar *undo_desc;
edit_select = g_object_new (GIMP_TYPE_EDIT_SELECTION_TOOL,
@@ -282,10 +282,10 @@ gimp_edit_selection_tool_start (GimpTool *parent_tool,
0, 0, 0, 0);
edit_select->segs_in = g_memdup (segs_in,
- edit_select->num_segs_in * sizeof (BoundSeg));
+ edit_select->num_segs_in * sizeof (GimpBoundSeg));
edit_select->segs_out = g_memdup (segs_out,
- edit_select->num_segs_out * sizeof (BoundSeg));
+ edit_select->num_segs_out * sizeof (GimpBoundSeg));
if (edit_select->edit_mode == GIMP_TRANSLATE_MODE_VECTORS)
{
diff --git a/app/tools/gimprectangleselecttool.c b/app/tools/gimprectangleselecttool.c
index 62eeed8..6261bfa 100644
--- a/app/tools/gimprectangleselecttool.c
+++ b/app/tools/gimprectangleselecttool.c
@@ -758,7 +758,7 @@ gimp_rectangle_select_tool_execute (GimpRectangleTool *rectangle,
/* if the click was inside the marching ants */
if (gimp_pickable_get_opacity_at (GIMP_PICKABLE (selection),
- pressx, pressy) > BOUNDARY_HALF_WAY)
+ pressx, pressy) > GIMP_BOUNDARY_HALF_WAY)
{
gint x1, y1, x2, y2;
diff --git a/app/tools/gimpregionselecttool.c b/app/tools/gimpregionselecttool.c
index dabfdd5..495f18a 100644
--- a/app/tools/gimpregionselecttool.c
+++ b/app/tools/gimpregionselecttool.c
@@ -71,9 +71,9 @@ static void gimp_region_select_tool_cursor_update (GimpTool *too
static void gimp_region_select_tool_draw (GimpDrawTool *draw_tool);
-static BoundSeg * gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,
- GimpDisplay *display,
- gint *n_segs);
+static GimpBoundSeg * gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,
+ GimpDisplay *display,
+ gint *n_segs);
G_DEFINE_TYPE (GimpRegionSelectTool, gimp_region_select_tool,
@@ -339,13 +339,13 @@ gimp_region_select_tool_draw (GimpDrawTool *draw_tool)
}
}
-static BoundSeg *
+static GimpBoundSeg *
gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,
GimpDisplay *display,
gint *n_segs)
{
GimpDisplayShell *shell = gimp_display_get_shell (display);
- BoundSeg *segs;
+ GimpBoundSeg *segs;
PixelRegion maskPR;
gimp_display_shell_set_override_cursor (shell, GDK_WATCH);
@@ -375,12 +375,12 @@ gimp_region_select_tool_calculate (GimpRegionSelectTool *region_sel,
gimp_item_get_height (GIMP_ITEM (region_sel->region_mask)),
FALSE);
- segs = boundary_find (&maskPR, BOUNDARY_WITHIN_BOUNDS,
- 0, 0,
- gimp_item_get_width (GIMP_ITEM (region_sel->region_mask)),
- gimp_item_get_height (GIMP_ITEM (region_sel->region_mask)),
- BOUNDARY_HALF_WAY,
- n_segs);
+ segs = gimp_boundary_find (&maskPR, GIMP_BOUNDARY_WITHIN_BOUNDS,
+ 0, 0,
+ gimp_item_get_width (GIMP_ITEM (region_sel->region_mask)),
+ gimp_item_get_height (GIMP_ITEM (region_sel->region_mask)),
+ GIMP_BOUNDARY_HALF_WAY,
+ n_segs);
gimp_display_shell_unset_override_cursor (shell);
diff --git a/app/tools/gimpregionselecttool.h b/app/tools/gimpregionselecttool.h
index e905bbd..34de05e 100644
--- a/app/tools/gimpregionselecttool.h
+++ b/app/tools/gimpregionselecttool.h
@@ -45,7 +45,7 @@ struct _GimpRegionSelectTool
gdouble saved_threshold;
GimpChannel *region_mask;
- BoundSeg *segs;
+ GimpBoundSeg *segs;
gint n_segs;
};
diff --git a/app/tools/gimptransformtool.c b/app/tools/gimptransformtool.c
index 0fa2f76..497b80a 100644
--- a/app/tools/gimptransformtool.c
+++ b/app/tools/gimptransformtool.c
@@ -835,21 +835,21 @@ gimp_transform_tool_draw (GimpDrawTool *draw_tool)
if (options->type == GIMP_TRANSFORM_TYPE_SELECTION)
{
- GimpMatrix3 matrix = tr_tool->transform;
- const BoundSeg *orig_in;
- const BoundSeg *orig_out;
- BoundSeg *segs_in;
- BoundSeg *segs_out;
- gint num_segs_in;
- gint num_segs_out;
+ GimpMatrix3 matrix = tr_tool->transform;
+ const GimpBoundSeg *orig_in;
+ const GimpBoundSeg *orig_out;
+ GimpBoundSeg *segs_in;
+ GimpBoundSeg *segs_out;
+ gint num_segs_in;
+ gint num_segs_out;
gimp_channel_boundary (gimp_image_get_mask (image),
&orig_in, &orig_out,
&num_segs_in, &num_segs_out,
0, 0, 0, 0);
- segs_in = g_memdup (orig_in, num_segs_in * sizeof (BoundSeg));
- segs_out = g_memdup (orig_out, num_segs_out * sizeof (BoundSeg));
+ segs_in = g_memdup (orig_in, num_segs_in * sizeof (GimpBoundSeg));
+ segs_out = g_memdup (orig_out, num_segs_out * sizeof (GimpBoundSeg));
if (segs_in)
{
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
