dnl Test for the presence of the required gpc.{c,h} files

dnl Test for the presence of the right polgyon clipping code

if test "$with_gpc" != "no" ; then

WITH_GPC=NO

WITH_LIBART=NO

if test -n "$enable_libart"; then

  PKG_CHECK_MODULES( LIBART, libart-2.0 >= 2.3.13 )

  AC_SUBST(LIBART_CFLAGS)

  AC_SUBST(LIBART_LIBS)

  WITH_LIBART=YES

elif test "$with_gpc" != "no" ; then

ToFile( "ENVCFLAGSCXX",      "@ENVCFLAGSCXX@",    "e" );

ToFile( "ENVCFLAGSCXX",      "@ENVCFLAGSCXX@",     "e" );

ToFile( "ENABLE_CRASHDUMP",  "@ENABLE_CRASHDUMP@","e" );

ToFile( "ENABLE_CRASHDUMP",  "@ENABLE_CRASHDUMP@", "e" );

ToFile( "WITH_GPC",          "@WITH_GPC@",      "e" );

ToFile( "WITH_GPC",          "@WITH_GPC@",         "e" );

ToFile( "GXX_INCLUDE_PATH",  "@GXX_INCLUDE_PATH@","e" );

ToFile( "WITH_LIBART",       "@WITH_LIBART@",      "e" );

ToFile( "COMMON_BUILD_TOOLS",$COMMON_BUILD_TOOLS, "e" );

ToFile( "LIBART_CFLAGS",     "@LIBART_CFLAGS@",    "e" );

ToFile( "LIBART_LIBS",       "@LIBART_LIBS@",      "e" );

ToFile( "GXX_INCLUDE_PATH",  "@GXX_INCLUDE_PATH@", "e" );

ToFile( "COMMON_BUILD_TOOLS",$COMMON_BUILD_TOOLS,  "e" );

SHL1STDLIBS+=   $(SALLIB) $(VOSLIB) $(GPC3RDLIB)

SHL1STDLIBS+=   $(SALLIB) $(VOSLIB)

.IF "$(WITH_LIBART)"="YES"

SHL1STDLIBS+=   $(LIBART_LIBS)

.ELSE

SHL1STDLIBS+=   $(GPC3RDLIB)

.ENDIF

    void *ImplCreateGPCPolygon() const;

	void*				ImplCreateGPCPolygon() const;

    void  ImplDoOperation( const PolyPolygon& rPolyPoly, PolyPolygon& rResult, ULONG nOperation ) const;

	void				ImplDoOperation( const PolyPolygon& rPolyPoly, PolyPolygon& rResult, ULONG nOperation ) const;

    void *ImplCreateArtVpath() const;

    void  ImplSetFromArtVpath( void *pVpath );

#ifdef HAVE_GPC_H

extern "C"

#ifndef __gpc_h

extern "C" 

	#include <external/gpc/gpc.h> 

#if defined (HAVE_GPC_H) && !defined (__gpc_h)

}

#  include <external/gpc/gpc.h> 

#endif

#  ifdef HAVE_LIBART_H

// No GPC

#    include <libart_lgpl/art_misc.h>

#define GPC_INT 0

#    include <libart_lgpl/art_vpath.h>

#define GPC_UNION 0

#    include <libart_lgpl/art_svp.h>

#define GPC_DIFF 0

#    include <libart_lgpl/art_svp_vpath.h>

#define GPC_XOR 0

#    include <libart_lgpl/art_vpath_svp.h>

#    include <libart_lgpl/art_svp_ops.h>

#    include <libart_lgpl/art_svp_intersect.h>

#  endif

#    define GPC_INT   0

#    define GPC_UNION 1

#    define GPC_DIFF  2

#    define GPC_XOR   3

// No GPC implementation

#ifdef HAVE_LIBART_H

void* PolyPolygon::ImplCreateGPCPolygon() const

/* Finds the index of the upper rightmost vertex of a polygon */

static int

upper_rightmost_vertex (const Polygon &poly)

{

	int n;

	int i;

	double x, y;

	int k;

	n = poly.GetSize ();

	k = 0;

	x = poly[0].X ();

	y = poly[0].Y ();

	for (i = 1; i < n; i++)

		if (poly[i].Y () < y || (poly[0].Y () == y && poly[i].X () > x)) {

			k = i;

			x = poly[i].X ();

			y = poly[i].Y ();

		}

	return k;

}

/* Returns whether a polygon is specified in counterclockwise order */

static BOOL

poly_is_ccw (const Polygon &poly)

{

	int n;

	int k;

	double cross;

	n = poly.GetSize ();

	if (n == 0)

		return TRUE;

	k = upper_rightmost_vertex (poly);

	const Point &a = poly[(k + n - 1) % n];

	const Point &b = poly[k];

	const Point &c = poly[(k + 1) % n];

	cross = -(a.X () * b.Y () - a.Y () * b.X () +

		  a.Y () * c.X () - a.X () * c.Y () +

		  b.X () * c.Y () - c.X () * b.Y ());

  	return (cross > 0);

}

void *

PolyPolygon::ImplCreateArtVpath () const

{

	ArtVpath *vpath;

	int n_contours;

	int n_vertices;

	int i, v;

	n_contours = Count ();

	n_vertices = 0;

	for (i = 0; i < n_contours; i++) {

		const Polygon &poly = GetObject (i);

		n_vertices += poly.GetSize () + 1; /* plus 1 for if we have to close the path */

	}

	n_vertices++; /* for the ART_END terminator */

	vpath = art_new (ArtVpath, n_vertices);

	v = 0;

	for (i = 0; i < n_contours; i++) {

		int j, k;

		int n;

		const Polygon &poly = GetObject (i);

		BOOL ccw;

		n = poly.GetSize ();

		ccw = poly_is_ccw (poly);

		/* Holes or inside contours need to be listed out in reverse

		 * clockwise direction to the main outwards contour, but OO.o

		 * does not seem to handle holes at all.  So we'll just list all

		 * the contours as non-holes, e.g. in normal counterclockwise

		 * order.

		 */

		if (ccw)

			k = 0;

		else

			k = n - 1;

		for (j = 0; j < n; j++) {

			const Point &point = poly[k];

			vpath[v].code = (j == 0) ? ART_MOVETO : ART_LINETO;

			vpath[v].x = point.X ();

			vpath[v].y = point.Y ();

			if (ccw)

				k++;

			else

				k--;

			v++;

		}

		/* Close the path if needed */

		if (n > 0 &&

		    (vpath[v - 1].x != vpath[v - n].x ||

		     vpath[v - 1].y != vpath[v - n].y)) {

			vpath[v].code = ART_LINETO;

			vpath[v].x = vpath[v - n].x;

			vpath[v].y = vpath[v - n].y;

			v++;

		}

	}

	vpath[v].code = ART_END;

	return vpath;

}

void

PolyPolygon::ImplSetFromArtVpath (void *_vpath)

{

	ArtVpath *vpath;

	vpath = (ArtVpath *) _vpath;

	Clear ();

	while (vpath->code != ART_END) {

		ArtVpath *p;

		int n, n_vertices;

		n = 0;

		for (p = vpath; n == 0 || p->code == ART_LINETO; p++)

			n++;

		/* Remove the last duplicated point from closed subpaths */

		if (n > 0 &&

		    vpath[n - 1].x == vpath[0].x &&

		    vpath[n - 1].y == vpath[0].y)

			n_vertices = n - 1;

		else

			n_vertices = n;

		if (n_vertices != 0) {

			int i;

			Polygon poly (n_vertices);

			p = vpath;

			for (i = 0; i < n_vertices; i++) {

				Point &point = poly[i];

				point.X () = FRound (p->x);

				point.Y () = FRound (p->y);

				p++;

			}

			Insert (poly);

		}

		vpath += n;

	}

}

/* Converts an arbitrary SVP to an even-odd SVP */

static ArtSVP *

svp_to_even_odd (ArtSVP *pSvp)

	return NULL;

	ArtSVP *pResult;

	ArtSvpWriter *pSvw;

	pSvw = art_svp_writer_rewind_new( ART_WIND_RULE_ODDEVEN );

	art_svp_intersector( pSvp, pSvw);

 	pResult = art_svp_writer_rewind_reap( pSvw );

	/* Shallow free because the result contains shared segments */

	art_free( pSvp );

	return pResult;