incubator-ooo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ar...@apache.org
Subject svn commit: r1394326 [2/15] - in /incubator/ooo/branches/buildsys/main: ./ basebmp/inc/basebmp/ basebmp/prj/ basebmp/test/ basegfx/inc/basegfx/color/ basegfx/inc/basegfx/curve/ basegfx/inc/basegfx/matrix/ basegfx/inc/basegfx/numeric/ basegfx/inc/basegf...
Date Thu, 04 Oct 2012 23:16:58 GMT
Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/numeric/ftools.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/numeric/ftools.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/numeric/ftools.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/numeric/ftools.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_NUMERIC_FTOOLS_HXX
 
 #include <rtl/math.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 // standard PI defines from solar.h, but we do not want to link against tools
@@ -170,7 +171,7 @@ namespace basegfx
 #endif
 	}
 
-    class fTools
+	class BASEGFX_DLLPUBLIC fTools
 	{
         /// Threshold value for equalZero()
 		static double									mfSmallValue;

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/pixel/bpixel.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/pixel/bpixel.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/pixel/bpixel.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/pixel/bpixel.hxx Thu Oct  4 23:16:35 2012
@@ -27,6 +27,7 @@
 #include <sal/types.h>
 #include <basegfx/numeric/ftools.hxx>
 #include <basegfx/color/bcolor.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 // predeclarations
@@ -35,7 +36,7 @@
 
 namespace basegfx
 {
-	class BPixel
+	class BASEGFX_DLLPUBLIC BPixel
 	{
 	protected:
 		union

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dhompoint.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dhompoint.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dhompoint.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dhompoint.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_POINT_B2DHOMPOINT_HXX
 
 #include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 namespace basegfx
 {
@@ -41,7 +42,7 @@ namespace basegfx
 
 		@see B2DTuple
 	*/
-	class B2DHomPoint
+	class BASEGFX_DLLPUBLIC B2DHomPoint
 	{
 	protected:
 		/// This member contains the coordinate part of the point
@@ -201,31 +202,31 @@ namespace basegfx
 	// external operators
 	//////////////////////////////////////////////////////////////////////////
 
-	B2DHomPoint minimum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+	BASEGFX_DLLPUBLIC B2DHomPoint minimum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-	B2DHomPoint maximum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+	BASEGFX_DLLPUBLIC B2DHomPoint maximum(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-	B2DHomPoint absolute(const B2DHomPoint& rVec);
+	BASEGFX_DLLPUBLIC B2DHomPoint absolute(const B2DHomPoint& rVec);
 
-	B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t);
+	BASEGFX_DLLPUBLIC B2DHomPoint interpolate(B2DHomPoint& rOld1, B2DHomPoint& rOld2, double t);
 
-	B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2);
+	BASEGFX_DLLPUBLIC B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2);
 	
-	B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3);
+	BASEGFX_DLLPUBLIC B2DHomPoint average(B2DHomPoint& rOld1, B2DHomPoint& rOld2, B2DHomPoint& rOld3);
 
-	B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+	BASEGFX_DLLPUBLIC B2DHomPoint operator+(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-	B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
+	BASEGFX_DLLPUBLIC B2DHomPoint operator-(const B2DHomPoint& rVecA, const B2DHomPoint& rVecB);
 
-	B2DHomPoint operator*(const B2DHomPoint& rVec, double t);
+	BASEGFX_DLLPUBLIC B2DHomPoint operator*(const B2DHomPoint& rVec, double t);
 
-	B2DHomPoint operator*(double t, const B2DHomPoint& rVec);
+	BASEGFX_DLLPUBLIC B2DHomPoint operator*(double t, const B2DHomPoint& rVec);
 
-	B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint );
+	BASEGFX_DLLPUBLIC B2DHomPoint operator*( const B2DHomMatrix& rMat, const B2DHomPoint& rPoint );
 
-	B2DHomPoint operator/(const B2DHomPoint& rVec, double t);
+	BASEGFX_DLLPUBLIC B2DHomPoint operator/(const B2DHomPoint& rVec, double t);
 
-	B2DHomPoint operator/(double t, const B2DHomPoint& rVec);
+	BASEGFX_DLLPUBLIC B2DHomPoint operator/(double t, const B2DHomPoint& rVec);
 } // end of namespace basegfx
 
 #endif /* _BGFX_POINT_B2DHOMPOINT_HXX */

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dpoint.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dpoint.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dpoint.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2dpoint.hxx Thu Oct  4 23:16:35 2012
@@ -26,6 +26,7 @@
 
 #include <basegfx/tuple/b2dtuple.hxx>
 #include <basegfx/point/b2ipoint.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -116,14 +117,14 @@ namespace basegfx
 		/** assignment operator to allow assigning the results
 			of B2DTuple calculations
 		*/
-		B2DPoint& operator=( const ::basegfx::B2DTuple& rPoint );
+		BASEGFX_DLLPUBLIC B2DPoint& operator=( const ::basegfx::B2DTuple& rPoint );
 
 		/** Transform point by given transformation matrix.
 
         	The translational components of the matrix are, in
         	contrast to B2DVector, applied.
 		*/
-		B2DPoint& operator*=( const ::basegfx::B2DHomMatrix& rMat );
+		BASEGFX_DLLPUBLIC B2DPoint& operator*=( const ::basegfx::B2DHomMatrix& rMat );
 
 		static const B2DPoint& getEmptyPoint()
 		{
@@ -139,7 +140,7 @@ namespace basegfx
 		Since this is a Point, translational components of the
     	matrix are used.
 	*/
-	B2DPoint operator*( const B2DHomMatrix& rMat, const B2DPoint& rPoint );
+	BASEGFX_DLLPUBLIC B2DPoint operator*( const B2DHomMatrix& rMat, const B2DPoint& rPoint );
 } // end of namespace basegfx
 
 //////////////////////////////////////////////////////////////////////////////

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2ipoint.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2ipoint.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2ipoint.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b2ipoint.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_POINT_B2IPOINT_HXX
 
 #include <basegfx/tuple/b2ituple.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 namespace basegfx
 {
@@ -39,7 +40,7 @@ namespace basegfx
 
 		@see B2ITuple
 	*/
-	class B2IPoint : public ::basegfx::B2ITuple
+	class BASEGFX_DLLPUBLIC B2IPoint : public ::basegfx::B2ITuple
 	{
 	public:					
 		/**	Create a 2D Point

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dhompoint.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dhompoint.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dhompoint.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dhompoint.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_POINT_B3DHOMPOINT_HXX
 
 #include <basegfx/point/b3dpoint.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 namespace basegfx
 {
@@ -41,7 +42,7 @@ namespace basegfx
 
 		@see B3DTuple
 	*/
-	class B3DHomPoint
+	class BASEGFX_DLLPUBLIC B3DHomPoint
 	{
 	protected:
 		/// This member contains the coordinate part of the point

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dpoint.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dpoint.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dpoint.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3dpoint.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_POINT_B3DPOINT_HXX
 
 #include <basegfx/tuple/b3dtuple.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 namespace basegfx
 {
@@ -39,7 +40,7 @@ namespace basegfx
 
 		@see B3DTuple
 	*/
-	class B3DPoint : public ::basegfx::B3DTuple
+	class BASEGFX_DLLPUBLIC B3DPoint : public ::basegfx::B3DTuple
 	{
 	public:					
 		/**	Create a 3D Point
@@ -139,7 +140,7 @@ namespace basegfx
 		Since this is a Point, translational components of the
     	matrix are used.
 	*/
-	B3DPoint operator*( const B3DHomMatrix& rMat, const B3DPoint& rPoint );
+	BASEGFX_DLLPUBLIC B3DPoint operator*( const B3DHomMatrix& rMat, const B3DPoint& rPoint );
 
 } // end of namespace basegfx
 

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3ipoint.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3ipoint.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3ipoint.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/point/b3ipoint.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_POINT_B3IPOINT_HXX
 
 #include <basegfx/tuple/b3ituple.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 namespace basegfx
 {
@@ -39,7 +40,7 @@ namespace basegfx
 
 		@see B3ITuple
 	*/
-	class B3IPoint : public ::basegfx::B3ITuple
+	class BASEGFX_DLLPUBLIC B3IPoint : public ::basegfx::B3ITuple
 	{
 	public:					
 		/**	Create a 3D Point

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx Thu Oct  4 23:16:35 2012
@@ -29,6 +29,7 @@
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <com/sun/star/drawing/LineCap.hpp>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -69,7 +70,7 @@ namespace basegfx
             @return
             The Line start and end polygon, correctly rotated and scaled
         */
-		B2DPolyPolygon createAreaGeometryForLineStartEnd(
+		BASEGFX_DLLPUBLIC B2DPolyPolygon createAreaGeometryForLineStartEnd(
 			const B2DPolygon& rCandidate, 
 			const B2DPolyPolygon& rArrow, 
 			bool bStart,
@@ -128,7 +129,7 @@ namespace basegfx
             it's line width. Contains bezier segments and edge roundings as
             needed and defined.
         */
-        B2DPolyPolygon createAreaGeometry(
+        BASEGFX_DLLPUBLIC B2DPolyPolygon createAreaGeometry(
             const B2DPolygon& rCandidate, 
             double fHalfLineWidth, 
             B2DLineJoin eJoin = B2DLINEJOIN_ROUND, 

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygon.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygon.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygon.hxx Thu Oct  4 23:16:35 2012
@@ -28,6 +28,7 @@
 #include <o3tl/cow_wrapper.hxx>
 #include <basegfx/vector/b2enums.hxx>
 #include <basegfx/range/b2drange.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 // predeclarations
@@ -46,7 +47,7 @@ namespace basegfx
 
 namespace basegfx
 {
-	class B2DPolygon
+	class BASEGFX_DLLPUBLIC B2DPolygon
 	{
     public:
         typedef o3tl::cow_wrapper< ImplB2DPolygon > ImplType;

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx Thu Oct  4 23:16:35 2012
@@ -26,6 +26,7 @@
 
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -42,21 +43,21 @@ namespace basegfx
 		// a clip axis parallel to X.Axis and 100 above it, use bParallelToXAxis = true and fValueOnOtherAxis = 100.
 		// The value bAboveAxis defines on which side the return value will be (true -> above X, right of Y).
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
-		B2DPolyPolygon clipPolyPolygonOnParallelAxis(const B2DPolyPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke);
-		B2DPolyPolygon clipPolygonOnParallelAxis(const B2DPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnParallelAxis(const B2DPolyPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnParallelAxis(const B2DPolygon& rCandidate, bool bParallelToXAxis, bool bAboveAxis, double fValueOnOtherAxis, bool bStroke);
 
 		// Clip the given PolyPolygon against the given range. bInside defines if the result will contain the
 		// parts which are contained in the range or vice versa.
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
-		B2DPolyPolygon clipPolyPolygonOnRange(const B2DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
-		B2DPolyPolygon clipPolygonOnRange(const B2DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnRange(const B2DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnRange(const B2DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
 
 		// Clip given PolyPolygon against the endless edge (ray) defined by the given two points. bAbove defines on which side
 		// of the edge the result will be together with the definition of the edge. If the edge is seen as a vector
 		// from A to B and bAbove is true, the result will contain the geometry left of the vector.
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
-		B2DPolyPolygon clipPolyPolygonOnEdge(const B2DPolyPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke);
-		B2DPolyPolygon clipPolygonOnEdge(const B2DPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnEdge(const B2DPolyPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnEdge(const B2DPolygon& rCandidate, const B2DPoint& rPointA, const B2DPoint& rPointB, bool bAbove, bool bStroke);
 
 		// Clip given PolyPolygon against given clipping polygon.
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
@@ -64,13 +65,13 @@ namespace basegfx
 		// With filled polygons, You get all PolyPolygon parts which were inside rClip.
 		// The switch bInside decides if the parts inside the clip polygon or outside shall be created.
         // The clip polygon is always assumed closed, even when it's isClosed() is false.
-		B2DPolyPolygon clipPolyPolygonOnPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke);
-		B2DPolyPolygon clipPolygonOnPolyPolygon(const B2DPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolyPolygonOnPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon clipPolygonOnPolyPolygon(const B2DPolygon& rCandidate, const B2DPolyPolygon& rClip, bool bInside, bool bStroke);
 
 		// clip the given polygon against the given range. the resulting polygon will always contain
 		// the inside parts which will always be interpreted as areas. the incoming polygon is expected
 		// to be a simple triangle list. the result is also a simple triangle list.
-		B2DPolygon clipTriangleListOnRange( const B2DPolygon& rCandidate, const B2DRange& rRange );
+		BASEGFX_DLLPUBLIC B2DPolygon clipTriangleListOnRange( const B2DPolygon& rCandidate, const B2DRange& rRange );
 
 	} // end of namespace tools
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx Thu Oct  4 23:16:35 2012
@@ -26,6 +26,7 @@
 
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -35,39 +36,39 @@ namespace basegfx
 	{
 		// look for self-intersections and self-touches (points on an edge) in given polygon and add
 		// extra points there. Result will have no touches or intersections on an edge, only on points
-		B2DPolygon addPointsAtCutsAndTouches(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCutsAndTouches(const B2DPolygon& rCandidate);
 
 		// look for polypolygon-intersections and polypolygon-touches (point of poly A on an edge of poly B) in given PolyPolygon and add
 		// extra points there. Result will have no touches or intersections between contained polygons on an edge, only on points. For
 		// convenience, the correction for self-intersections for each member polygon will be used, too.
 		// Changed: Self intersections are searched by default, but may be switched off by 2nd parameter.
-		B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true);
 
 		// look for intersections of rCandidate with all polygons from rMask and add extra points there. Do
 		// not change or add points to rMask.
-		B2DPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolygon& rCandidate);
 
 		// look for intersections of rCandidate with all polygons from rMask and add extra points there. Do
 		// not change or add points to rMask.
-		B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCutsAndTouches(const B2DPolyPolygon& rMask, const B2DPolyPolygon& rCandidate);
 
 		// look for intersections of rCandidate with the edge from rStart to rEnd and add extra points there.
         // Points are only added in the range of the edge, not on the endless vector.
-        B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd);
-        B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd);
+        BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPoint& rStart, const B2DPoint& rEnd);
 
 		// look for intersections of rCandidate with the mask Polygon and add extra points there.
         // The mask polygon is assumed to be closed, even when it's not explicitely.
-        B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPolyPolygon& rMask);
-        B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rMask);
+        BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate, const B2DPolyPolygon& rMask);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, const B2DPolyPolygon& rMask);
 
 		// look for self-intersections in given polygon and add extra points there. Result will have no 
         // intersections on an edge
-		B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon addPointsAtCuts(const B2DPolygon& rCandidate);
 
         // add points at all self-intersections of single polygons (depends on bSelfIntersections)
         // and at polygon-polygon intersections
-		B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon addPointsAtCuts(const B2DPolyPolygon& rCandidate, bool bSelfIntersections = true);
 
     } // end of namespace tools
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx Thu Oct  4 23:16:35 2012
@@ -30,6 +30,7 @@
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <basegfx/polygon/b3dpolygon.hxx>
 #include <vector>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -44,8 +45,8 @@ namespace basegfx
 		// B2DPolygon tools
 
 		// open/close with point add/remove and control point corrections
-		void openWithGeometryChange(B2DPolygon& rCandidate);
-		void closeWithGeometryChange(B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC void openWithGeometryChange(B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC void closeWithGeometryChange(B2DPolygon& rCandidate);
 
 		/**	Check if given polygon is closed. 
 
@@ -56,20 +57,20 @@ namespace basegfx
         	start/end points) and sets the Closed()-state of the
         	polygon correctly.
 		*/
-		void checkClosed(B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC void checkClosed(B2DPolygon& rCandidate);
 
 		// Get successor and predecessor indices. Returning the same index means there
 		// is none. Same for successor.
-		sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate);
-		sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B2DPolygon& rCandidate);
 
 		// Get orientation of Polygon
-		B2VectorOrientation getOrientation(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation(const B2DPolygon& rCandidate);
 
 		// isInside tests for B2dPoint and other B2dPolygon. On border is not inside as long as
 		// not true is given in bWithBorder flag.
-		bool isInside(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false);
-		bool isInside(const B2DPolygon& rCandidate, const B2DPolygon& rPolygon, bool bWithBorder = false);
+		BASEGFX_DLLPUBLIC bool isInside(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false);
+		BASEGFX_DLLPUBLIC bool isInside(const B2DPolygon& rCandidate, const B2DPolygon& rPolygon, bool bWithBorder = false);
 
 		/** Get the range of a polygon including bezier control points
 
@@ -81,7 +82,7 @@ namespace basegfx
 			@return
 			The outer range of the bezier curve containing bezier control points
 		*/
-		B2DRange getRangeWithControlPoints(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DRange getRangeWithControlPoints(const B2DPolygon& rCandidate);
 
 		/** Get the range of a polygon
 			
@@ -94,53 +95,53 @@ namespace basegfx
 			@return
 			The outer range of the bezier curve
 		*/
-		B2DRange getRange(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DRange getRange(const B2DPolygon& rCandidate);
 
 		// get signed area of polygon
-		double getSignedArea(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getSignedArea(const B2DPolygon& rCandidate);
 
 		// get area of polygon
-		double getArea(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getArea(const B2DPolygon& rCandidate);
 
 		/** get length of polygon edge from point nIndex to nIndex + 1 */
-		double getEdgeLength(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
+		BASEGFX_DLLPUBLIC double getEdgeLength(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
 
 		/** get length of polygon */
-		double getLength(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getLength(const B2DPolygon& rCandidate);
 
 		// get position on polygon for absolute given distance. If
 		// length is given, it is assumed the correct polygon length, if 0.0 it is calculated
 		// using getLength(...)
-		B2DPoint getPositionAbsolute(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+		BASEGFX_DLLPUBLIC B2DPoint getPositionAbsolute(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
 
 		// get position on polygon for relative given distance in range [0.0 .. 1.0]. If
 		// length is given, it is assumed the correct polygon length, if 0.0 it is calculated
 		// using getLength(...)
-		B2DPoint getPositionRelative(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+		BASEGFX_DLLPUBLIC B2DPoint getPositionRelative(const B2DPolygon& rCandidate, double fDistance, double fLength = 0.0);
 
 		// get a snippet from given polygon for absolute distances. The polygon is assumed
 		// to be opened (not closed). fFrom and fTo need to be in range [0.0 .. fLength], where
 		// fTo >= fFrom. If length is given, it is assumed the correct polygon length, 
 		// if 0.0 it is calculated using getLength(...)
-		B2DPolygon getSnippetAbsolute(const B2DPolygon& rCandidate, double fFrom, double fTo, double fLength = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolygon getSnippetAbsolute(const B2DPolygon& rCandidate, double fFrom, double fTo, double fLength = 0.0);
 
 		// get a snippet from given polygon for relative distances. The polygon is assumed
 		// to be opened (not closed). fFrom and fTo need to be in range [0.0 .. 1.0], where
 		// fTo >= fFrom. If length is given, it is assumed the correct polygon length, 
 		// if 0.0 it is calculated using getLength(...)
-		B2DPolygon getSnippetRelative(const B2DPolygon& rCandidate, double fFrom = 0.0, double fTo = 1.0, double fLength = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolygon getSnippetRelative(const B2DPolygon& rCandidate, double fFrom = 0.0, double fTo = 1.0, double fLength = 0.0);
 
 		// Continuity check for point with given index
-		B2VectorContinuity getContinuityInPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
+		BASEGFX_DLLPUBLIC B2VectorContinuity getContinuityInPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
 
 		// Subdivide all contained curves. Use distanceBound value if given.
-		B2DPolygon adaptiveSubdivideByDistance(const B2DPolygon& rCandidate, double fDistanceBound = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolygon adaptiveSubdivideByDistance(const B2DPolygon& rCandidate, double fDistanceBound = 0.0);
 
 		// Subdivide all contained curves. Use angleBound value if given.
-		B2DPolygon adaptiveSubdivideByAngle(const B2DPolygon& rCandidate, double fAngleBound = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolygon adaptiveSubdivideByAngle(const B2DPolygon& rCandidate, double fAngleBound = 0.0);
 
 		// #i37443# Subdivide all contained curves.
-		B2DPolygon adaptiveSubdivideByCount(const B2DPolygon& rCandidate, sal_uInt32 nCount = 0L);
+		BASEGFX_DLLPUBLIC B2DPolygon adaptiveSubdivideByCount(const B2DPolygon& rCandidate, sal_uInt32 nCount = 0L);
 
         // Definitions for the cut flags used from the findCut methods
 		typedef sal_uInt16 CutFlagValue;
@@ -157,7 +158,7 @@ namespace basegfx
 		// Calculate cut between the points given by the two indices. pCut1
 		// and pCut2 will contain the cut coordinate on each edge in ]0.0, 1.0]
 		// (if given) and the return value will contain a cut description.
-		CutFlagValue findCut(
+		BASEGFX_DLLPUBLIC CutFlagValue findCut(
 			const B2DPolygon& rCandidate,
 			sal_uInt32 nIndex1, sal_uInt32 nIndex2, 
 			CutFlagValue aCutFlags = CUTFLAG_DEFAULT, 
@@ -165,7 +166,7 @@ namespace basegfx
 
 		// This version is working with two indexed edges from different
 		// polygons.
-		CutFlagValue findCut(
+		BASEGFX_DLLPUBLIC CutFlagValue findCut(
 			const B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
 			const B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
 			CutFlagValue aCutFlags = CUTFLAG_DEFAULT, 
@@ -173,7 +174,7 @@ namespace basegfx
 
 		// This version works with two points and vectors to define the
 		// edges for the cut test.
-		CutFlagValue findCut(
+		BASEGFX_DLLPUBLIC CutFlagValue findCut(
 			const B2DPoint& rEdge1Start, const B2DVector& rEdge1Delta,
 			const B2DPoint& rEdge2Start, const B2DVector& rEdge2Delta,
 			CutFlagValue aCutFlags = CUTFLAG_DEFAULT,
@@ -182,7 +183,7 @@ namespace basegfx
 		// test if point is on the given edge in range ]0.0..1.0[ without
 		// the start/end points. If so, return true and put the parameter
 		// value in pCut (if provided)
-		bool isPointOnEdge(
+		BASEGFX_DLLPUBLIC bool isPointOnEdge(
 			const B2DPoint& rPoint,
 			const B2DPoint& rEdgeStart, 
 			const B2DVector& rEdgeDelta, 
@@ -221,7 +222,7 @@ namespace basegfx
 			The sumed-up length of the rDotDashArray. If zero, it will
 			be calculated internally.
 		*/
-		void applyLineDashing(
+		BASEGFX_DLLPUBLIC void applyLineDashing(
 			const B2DPolygon& rCandidate, 
 			const ::std::vector<double>& rDotDashArray, 
 			B2DPolyPolygon* pLineTarget,
@@ -232,13 +233,13 @@ namespace basegfx
 		// by the two given points. Can be used for HitTesting. The epsilon-range
 		// is defined to be the rectangle centered to the given edge, using height
 		// 2 x fDistance, and the circle around both points with radius fDistance.
-		bool isInEpsilonRange(const B2DPoint& rEdgeStart, const B2DPoint& rEdgeEnd, const B2DPoint& rTestPosition, double fDistance);
+		BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B2DPoint& rEdgeStart, const B2DPoint& rEdgeEnd, const B2DPoint& rTestPosition, double fDistance);
 
 		// test if point is inside epsilon-range around the given Polygon. Can be used 
 		// for HitTesting. The epsilon-range is defined to be the rectangle centered 
         // to the given edge, using height 2 x fDistance, and the circle around both points 
         // with radius fDistance.
-		bool isInEpsilonRange(const B2DPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance);
+		BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B2DPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance);
 
         /** Create a polygon from a rectangle.
 
@@ -249,7 +250,7 @@ namespace basegfx
             Radius of the edge rounding, relative to the rectangle size. 0.0 means no
 			rounding, 1.0 will lead to an ellipse
          */
-        B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadius );
+        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadius );
 
         /** Create a polygon from a rectangle.
 
@@ -261,15 +262,15 @@ namespace basegfx
             Radius of the edge rounding, relative to the rectangle size. 0.0 means no
 			rounding, 1.0 will lead to an ellipse
          */
-		B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadiusX, double fRadiusY );
+		BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect, double fRadiusX, double fRadiusY );
 
         /** Create a polygon from a rectangle.
          */
-		B2DPolygon createPolygonFromRect( const B2DRectangle& rRect );
+		BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromRect( const B2DRectangle& rRect );
 
         /** Create the unit polygon
          */
-		B2DPolygon createUnitPolygon();
+		BASEGFX_DLLPUBLIC B2DPolygon createUnitPolygon();
 
         /** Create a circle polygon with given radius.
 
@@ -283,7 +284,7 @@ namespace basegfx
             @param fRadius
             Radius of the circle
          */
-        B2DPolygon createPolygonFromCircle( const B2DPoint& rCenter, double fRadius );
+        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromCircle( const B2DPoint& rCenter, double fRadius );
 
         /// create half circle centered on (0,0) from [0 .. F_PI]
         B2DPolygon createHalfUnitCircle();
@@ -298,7 +299,7 @@ namespace basegfx
 			this is the lowest one). This is needed since when lines are dashed, toe old
 			geometry started at bottom point, else it would look different.
 		 */
-        B2DPolygon createPolygonFromUnitCircle(sal_uInt32 nStartQuadrant = 0);
+        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromUnitCircle(sal_uInt32 nStartQuadrant = 0);
 
 		/** Create an ellipse polygon with given radii.
 
@@ -315,13 +316,13 @@ namespace basegfx
             @param fRadiusY
             Radius of the ellipse in Y direction
          */
-        B2DPolygon createPolygonFromEllipse( const B2DPoint& rCenter, double fRadiusX, double fRadiusY );
+        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromEllipse( const B2DPoint& rCenter, double fRadiusX, double fRadiusY );
 
 		/** Create an unit ellipse polygon with the given angles, from start to end
          */
-        B2DPolygon createPolygonFromEllipseSegment( const B2DPoint& rCenter, double fRadiusX, double fRadiusY, double	fStart, double fEnd );
+        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromEllipseSegment( const B2DPoint& rCenter, double fRadiusX, double fRadiusY, double	fStart, double fEnd );
 
-        B2DPolygon createPolygonFromUnitEllipseSegment( double fStart, double fEnd );
+        BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromUnitEllipseSegment( double fStart, double fEnd );
 
         /** Predicate whether a given polygon is a rectangle.
 
@@ -333,111 +334,111 @@ namespace basegfx
             enumerations of a rectangle's vertices). Note that
             intermediate points and duplicate points are ignored.
          */
-        bool isRectangle( const B2DPolygon& rPoly );
+        BASEGFX_DLLPUBLIC bool isRectangle( const B2DPolygon& rPoly );
 
 		// create 3d polygon from given 2d polygon. The given fZCoordinate is used to expand the
 		// third coordinate.
-		B3DPolygon createB3DPolygonFromB2DPolygon(const B2DPolygon& rCandidate, double fZCoordinate = 0.0);
+		BASEGFX_DLLPUBLIC B3DPolygon createB3DPolygonFromB2DPolygon(const B2DPolygon& rCandidate, double fZCoordinate = 0.0);
 
 		// create 2d PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given
 		// matrix and the resulting x,y is used to form the new polygon.
-		B2DPolygon createB2DPolygonFromB3DPolygon(const B3DPolygon& rCandidate, const B3DHomMatrix& rMat);
+		BASEGFX_DLLPUBLIC B2DPolygon createB2DPolygonFromB3DPolygon(const B3DPolygon& rCandidate, const B3DHomMatrix& rMat);
 
 		// create simplified version of the original polygon by
 		// replacing segments with spikes/loops and self intersections
 		// by several trivial sub-segments
-		B2DPolygon createSimplifiedPolygon(const B2DPolygon&);
+		BASEGFX_DLLPUBLIC B2DPolygon createSimplifiedPolygon(const B2DPolygon&);
 
 		// calculate the distance to the given endless ray and return. The relative position on the edge is returned in Cut.
         // That position may be less than 0.0 or more than 1.0
-		double getDistancePointToEndlessRay(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut);
+		BASEGFX_DLLPUBLIC double getDistancePointToEndlessRay(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut);
 
 		// calculate the smallest distance to given edge and return. The relative position on the edge is returned in Cut.
         // That position is in the range [0.0 .. 1.0] and the returned distance is adapted accordingly to the start or end
         // point of the edge
-		double getSmallestDistancePointToEdge(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut);
+		BASEGFX_DLLPUBLIC double getSmallestDistancePointToEdge(const B2DPoint& rPointA, const B2DPoint& rPointB, const B2DPoint& rTestPoint, double& rCut);
 
 		// for each contained edge calculate the smallest distance. Return the index to the smallest
 		// edge in rEdgeIndex. The relative position on the edge is returned in rCut.
 		// If nothing was found (e.g. empty input plygon), DBL_MAX is returned.
-		double getSmallestDistancePointToPolygon(const B2DPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rEdgeIndex, double& rCut);
+		BASEGFX_DLLPUBLIC double getSmallestDistancePointToPolygon(const B2DPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rEdgeIndex, double& rCut);
 
 		// distort single point. rOriginal describes the original range, where the given points describe the distorted corresponding points.
-		B2DPoint distort(const B2DPoint& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
+		BASEGFX_DLLPUBLIC B2DPoint distort(const B2DPoint& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
 
 		// distort polygon. rOriginal describes the original range, where the given points describe the distorted corresponding points.
-		B2DPolygon distort(const B2DPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
+		BASEGFX_DLLPUBLIC B2DPolygon distort(const B2DPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
 
 		// rotate polygon around given point with given angle.
-		B2DPolygon rotateAroundPoint(const B2DPolygon& rCandidate, const B2DPoint& rCenter, double fAngle);
+		BASEGFX_DLLPUBLIC B2DPolygon rotateAroundPoint(const B2DPolygon& rCandidate, const B2DPoint& rCenter, double fAngle);
 
 		// expand all segments (which are not yet) to curve segments. This is done with setting the control
 		// vectors on the 1/3 resp. 2/3 distances on each segment.
-		B2DPolygon expandToCurve(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon expandToCurve(const B2DPolygon& rCandidate);
 
 		// expand given segment to curve segment. This is done with setting the control
 		// vectors on the 1/3 resp. 2/3 distances. The return value describes if a change took place.
-		bool expandToCurveInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex);
+		BASEGFX_DLLPUBLIC bool expandToCurveInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex);
 
 		// set continuity for the whole curve. If not a curve, nothing will change. Non-curve points are not changed, too.
 		B2DPolygon setContinuity(const B2DPolygon& rCandidate, B2VectorContinuity eContinuity);
 
 		// set continuity for given index. If not a curve, nothing will change. Non-curve points are not changed, too.
 		// The return value describes if a change took place.
-		bool setContinuityInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex, B2VectorContinuity eContinuity);
+		BASEGFX_DLLPUBLIC bool setContinuityInPoint(B2DPolygon& rCandidate, sal_uInt32 nIndex, B2VectorContinuity eContinuity);
 
 		// test if polygon contains neutral points. A neutral point is one whos orientation is neutral
 		// e.g. positioned on the edge of it's predecessor and successor
-		bool hasNeutralPoints(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC bool hasNeutralPoints(const B2DPolygon& rCandidate);
 
 		// remove neutral points. A neutral point is one whos orientation is neutral
 		// e.g. positioned on the edge of it's predecessor and successor
-		B2DPolygon removeNeutralPoints(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon removeNeutralPoints(const B2DPolygon& rCandidate);
 
 		// tests if polygon is convex
-		bool isConvex(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC bool isConvex(const B2DPolygon& rCandidate);
 
 		// calculates the orientation at edge nIndex
-		B2VectorOrientation getOrientationForIndex(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
+		BASEGFX_DLLPUBLIC B2VectorOrientation getOrientationForIndex(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
 
 		// calculates if given point is on given line, taking care of the numerical epsilon
-		bool isPointOnLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidate, bool bWithPoints = false);
+		BASEGFX_DLLPUBLIC bool isPointOnLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidate, bool bWithPoints = false);
 
 		// calculates if given point is on given polygon, taking care of the numerical epsilon. Uses 
 		// isPointOnLine internally
-		bool isPointOnPolygon(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithPoints = true);
+		BASEGFX_DLLPUBLIC bool isPointOnPolygon(const B2DPolygon& rCandidate, const B2DPoint& rPoint, bool bWithPoints = true);
 
 		// test if candidate is inside triangle
-		bool isPointInTriangle(const B2DPoint& rA, const B2DPoint& rB, const B2DPoint& rC, const B2DPoint& rCandidate, bool bWithBorder = false);
+		BASEGFX_DLLPUBLIC bool isPointInTriangle(const B2DPoint& rA, const B2DPoint& rB, const B2DPoint& rC, const B2DPoint& rCandidate, bool bWithBorder = false);
 
 		// test if candidateA and candidateB are on the same side of the given line
-		bool arePointsOnSameSideOfLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidateA, const B2DPoint& rCandidateB, bool bWithLine = false);
+		BASEGFX_DLLPUBLIC bool arePointsOnSameSideOfLine(const B2DPoint& rStart, const B2DPoint& rEnd, const B2DPoint& rCandidateA, const B2DPoint& rCandidateB, bool bWithLine = false);
 
 		// add triangles for given rCandidate to rTarget. For each triangle, 3 points will be added to rCandidate.
 		// All triangles will go from the start point of rCandidate to two consecutive points, building (rCandidate.count() - 2)
 		// triangles.
-		void addTriangleFan(const B2DPolygon& rCandidate, B2DPolygon& rTarget);
+		BASEGFX_DLLPUBLIC void addTriangleFan(const B2DPolygon& rCandidate, B2DPolygon& rTarget);
 
 		// grow for polygon. Move all geometry in each point in the direction of the normal in that point
 		// with the given amount. Value may be negative.
-		B2DPolygon growInNormalDirection(const B2DPolygon& rCandidate, double fValue);
+		BASEGFX_DLLPUBLIC B2DPolygon growInNormalDirection(const B2DPolygon& rCandidate, double fValue);
 
 		// force all sub-polygons to a point count of nSegments
-		B2DPolygon reSegmentPolygon(const B2DPolygon& rCandidate, sal_uInt32 nSegments);
+		BASEGFX_DLLPUBLIC B2DPolygon reSegmentPolygon(const B2DPolygon& rCandidate, sal_uInt32 nSegments);
 
 		// create polygon state at t from 0.0 to 1.0 between the two polygons. Both polygons must have the same
 		// organisation, e.g. same amount of points
-		B2DPolygon interpolate(const B2DPolygon& rOld1, const B2DPolygon& rOld2, double t);
+		BASEGFX_DLLPUBLIC B2DPolygon interpolate(const B2DPolygon& rOld1, const B2DPolygon& rOld2, double t);
 
-		bool isPolyPolygonEqualRectangle( const B2DPolyPolygon& rPolyPoly, const B2DRange& rRect );
+		BASEGFX_DLLPUBLIC bool isPolyPolygonEqualRectangle( const B2DPolyPolygon& rPolyPoly, const B2DRange& rRect );
 
 		// #i76891# Try to remove existing curve segments if they are simply edges
-		B2DPolygon simplifyCurveSegments(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon simplifyCurveSegments(const B2DPolygon& rCandidate);
 
 		// makes the given indexed point the new polygon start point. To do that, the points in the
 		// polygon will be rotated. This is only valid for closed polygons, for non-closed ones
 		// an assertion will be triggered
-		B2DPolygon makeStartPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndexOfNewStatPoint);
+		BASEGFX_DLLPUBLIC B2DPolygon makeStartPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndexOfNewStatPoint);
 
         /** create edges of given length along given B2DPolygon
 
@@ -467,7 +468,7 @@ namespace basegfx
 			@return
 			The newly created polygon
          */
-		B2DPolygon createEdgesOfGivenLength(const B2DPolygon& rCandidate, double fLength, double fStart = 0.0, double fEnd = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolygon createEdgesOfGivenLength(const B2DPolygon& rCandidate, double fLength, double fStart = 0.0, double fEnd = 0.0);
 
 		/** Create Waveline along given polygon 
             The implementation is based on createEdgesOfGivenLength and creates a curve
@@ -484,7 +485,7 @@ namespace basegfx
             @param fgWaveHeight
             The height of the waveline (amplitude)
         */
-		B2DPolygon createWaveline(const B2DPolygon& rCandidate, double fWaveWidth, double fWaveHeight);
+		BASEGFX_DLLPUBLIC B2DPolygon createWaveline(const B2DPolygon& rCandidate, double fWaveWidth, double fWaveHeight);
 
         /** split each edge of a polygon in exactly nSubEdges equidistant edges
             
@@ -506,12 +507,12 @@ namespace basegfx
             into nSubEdges part curved edges of equidistant length. If not,
             straight edges will just be copied.
         */
-		B2DPolygon reSegmentPolygonEdges(const B2DPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges);
+		BASEGFX_DLLPUBLIC B2DPolygon reSegmentPolygonEdges(const B2DPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges);
 
 		//////////////////////////////////////////////////////////////////////
 		// comparators with tolerance for 2D Polygons
-		bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB, const double& rfSmallValue);
-		bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB);
+		BASEGFX_DLLPUBLIC bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB, const double& rfSmallValue);
+		BASEGFX_DLLPUBLIC bool equal(const B2DPolygon& rCandidateA, const B2DPolygon& rCandidateB);
 
 		/** snap some polygon coordinates to discrete coordinates
 
@@ -525,7 +526,7 @@ namespace basegfx
 			@return
 			The modified version of the source polygon
 		*/
-		B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate);
 
     } // end of namespace tools
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx Thu Oct  4 23:16:35 2012
@@ -26,6 +26,7 @@
 
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <vector>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -34,10 +35,10 @@ namespace basegfx
 	namespace triangulator
 	{
 		// triangulate given polygon
-		::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolygon& rCandidate);
 
 		// triangulate given PolyPolygon
-		::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolyPolygon& rCandidate);
 
 	} // end of namespace triangulator
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx Thu Oct  4 23:16:35 2012
@@ -27,6 +27,7 @@
 #include <sal/types.h>
 #include <o3tl/cow_wrapper.hxx>
 #include <basegfx/range/b2drange.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 // predeclarations
 class ImplB2DPolyPolygon;
@@ -41,7 +42,7 @@ namespace basegfx
 
 namespace basegfx
 {
-	class B2DPolyPolygon
+	class BASEGFX_DLLPUBLIC B2DPolyPolygon
 	{
     public:
         typedef o3tl::cow_wrapper< ImplB2DPolyPolygon > ImplType;

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx Thu Oct  4 23:16:35 2012
@@ -25,6 +25,7 @@
 #define _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
 
 #include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -39,18 +40,18 @@ namespace basegfx
 		// Self crossovers of the contained sub-polygons are implicitely handled, but to not lose
 		// the topological information, it may be necessary to remove self-intersections of the
 		// contained sub-polygons in a preparing step and to explicitely correct their orientations.
-		B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate);
 
 		// Version for single polygons. This is for solving self-intersections. Result will be free of
 		// crossovers. When result contains multiple polygons, it may be necessary to rearrange their
 		// orientations since holes may have been created (use correctOrientations eventually).
-		B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate);
 
 		// Neutral polygons will be stripped. Neutral polygons are ones who's orientation is
 		// neutral, so normally they have no volume -> just closed paths. A polygon with the same
 		// positive and negative oriented volume is also neutral, so this may not be wanted. It is
 		// safe to call with crossover-free polygons, though (that's where it's mostly used).
-		B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate);
 
 		// Remove not necessary polygons. Works only correct with crossover-free polygons. For each
 		// polygon, the depth for the PolyPolygon is calculated. The orientation is used to identify holes.
@@ -63,14 +64,14 @@ namespace basegfx
 		// one polygon to another and use this mode -> only parts where two polygons overlapped will be kept.
 		// In combination with correct orientation of the input orientations and the SolveCrossover calls this
 		// can be combined for logical polygon operations or polygon clipping.
-		B2DPolyPolygon stripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon stripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false);
 
         // geometrically convert PolyPolygons which are proposed to use nonzero fill rule
         // to a representation where evenodd paint will give the same result. To do this
         // all intersections and self-intersections get solved (the polygons will be rearranged
         // if needed). Then all polygons which are inside another one with the same orientation
         // get deleted
-        B2DPolyPolygon createNonzeroConform(const B2DPolyPolygon& rCandidate);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon createNonzeroConform(const B2DPolyPolygon& rCandidate);
 
         // For convenience: The four basic operations OR, XOR, AND and DIFF for
         // two PolyPolygons. These are combinations of the above methods. To not be forced
@@ -89,20 +90,20 @@ namespace basegfx
 
         // Preparations: solve self-intersections and intersections, remove neutral
         // parts and correct orientations.
-        B2DPolyPolygon prepareForPolygonOperation(const B2DPolygon& rCandidate);
-        B2DPolyPolygon prepareForPolygonOperation(const B2DPolyPolygon& rCandidate);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon prepareForPolygonOperation(const B2DPolygon& rCandidate);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon prepareForPolygonOperation(const B2DPolyPolygon& rCandidate);
 
         // OR: Return all areas where CandidateA or CandidateB exist
-        B2DPolyPolygon solvePolygonOperationOr(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationOr(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
 
         // XOR: Return all areas where CandidateA or CandidateB exist, but not both
-        B2DPolyPolygon solvePolygonOperationXor(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationXor(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
 
         // AND: Return all areas where CandidateA and CandidateB exist
-        B2DPolyPolygon solvePolygonOperationAnd(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationAnd(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
 
         // DIFF: Return all areas where CandidateA is not covered by CandidateB (cut B out of A)
-        B2DPolyPolygon solvePolygonOperationDiff(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+        BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationDiff(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
 
 		/** merge all single PolyPolygons to a single, OR-ed PolyPolygon
 
@@ -111,7 +112,7 @@ namespace basegfx
 
 			@return A single PolyPolygon containing the Or-merged result
 		*/
-		B2DPolyPolygon mergeToSinglePolyPolygon(const B2DPolyPolygonVector& rInput);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon mergeToSinglePolyPolygon(const B2DPolyPolygonVector& rInput);
 
 	} // end of namespace tools
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx Thu Oct  4 23:16:35 2012
@@ -30,6 +30,7 @@
 #include <basegfx/polygon/b2dpolypolygonfillrule.hxx>
 #include <vector>
 #include <utility>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -44,7 +45,7 @@ namespace basegfx
         @derive 
         Overwrite span() with the render output method of your choice.
      */
-    class B2DPolyPolygonRasterConverter
+    class BASEGFX_DLLPUBLIC B2DPolyPolygonRasterConverter
     {
     public:
         /** Create raster-converter for given poly-polygon

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx Thu Oct  4 23:16:35 2012
@@ -29,6 +29,7 @@
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b3dpolypolygon.hxx>
 #include <vector>
+#include <basegfx/basegfxdllapi.h>
 
 namespace rtl
 {
@@ -50,27 +51,27 @@ namespace basegfx
 		// Check and evtl. correct orientations of all contained Polygons so that
 		// the orientations of contained polygons will variate to express areas and
 		// holes
-		B2DPolyPolygon correctOrientations(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon correctOrientations(const B2DPolyPolygon& rCandidate);
 
 		// make sure polygon with index 0L is not a hole. This may evtl. change the
 		// sequence of polygons, but allows to use polygon with index 0L to
 		// get the correct normal for the whole polyPolygon
-		B2DPolyPolygon correctOutmostPolygon(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon correctOutmostPolygon(const B2DPolyPolygon& rCandidate);
 
 		// Subdivide all contained curves. Use distanceBound value if given.
-		B2DPolyPolygon adaptiveSubdivideByDistance(const B2DPolyPolygon& rCandidate, double fDistanceBound = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon adaptiveSubdivideByDistance(const B2DPolyPolygon& rCandidate, double fDistanceBound = 0.0);
 
 		// Subdivide all contained curves. Use distanceBound value if given. Else, a convenient one
 		// is created.
-		B2DPolyPolygon adaptiveSubdivideByAngle(const B2DPolyPolygon& rCandidate, double fAngleBound = 0.0);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon adaptiveSubdivideByAngle(const B2DPolyPolygon& rCandidate, double fAngleBound = 0.0);
 
 		// Subdivide all contained curves. Use nCount divisions if given. Else, a convenient one
 		// is created.
-		B2DPolyPolygon adaptiveSubdivideByCount(const B2DPolyPolygon& rCandidate, sal_uInt32 nCount = 0L);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon adaptiveSubdivideByCount(const B2DPolyPolygon& rCandidate, sal_uInt32 nCount = 0L);
 
         // isInside test for B2dPoint. On border is not inside as long as not true is given 
 		// in bWithBorder flag. It is assumed that the orientations of the given polygon are correct.
-		bool isInside(const B2DPolyPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false);
+		BASEGFX_DLLPUBLIC bool isInside(const B2DPolyPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder = false);
 
 		/** get range of PolyPolygon. Control points are included.
 
@@ -83,7 +84,7 @@ namespace basegfx
 			@return
 			The outer range including control points
 		*/
-		B2DRange getRangeWithControlPoints(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DRange getRangeWithControlPoints(const B2DPolyPolygon& rCandidate);
 
 		/** Get the range of a polyPolygon
 
@@ -96,13 +97,13 @@ namespace basegfx
 			@return
 			The outer range of the polygon
 		*/
-		B2DRange getRange(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DRange getRange(const B2DPolyPolygon& rCandidate);
 			
 		/** Apply given LineDashing to given polyPolygon
 
 			For a description see applyLineDashing in b2dpolygontoos.hxx
 		*/
-		void applyLineDashing(
+		BASEGFX_DLLPUBLIC void applyLineDashing(
 			const B2DPolyPolygon& rCandidate, 
 			const ::std::vector<double>& rDotDashArray, 
 			B2DPolyPolygon* pLineTarget,
@@ -112,7 +113,7 @@ namespace basegfx
 		// test if point is inside epsilon-range around the given PolyPolygon. Can be used 
 		// for HitTesting. The epsilon-range is defined to be the tube around the PolyPolygon
 		// with distance fDistance and rounded edges (start and end point).
-		bool isInEpsilonRange(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance);
+		BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance);
 
         /** Read poly-polygon from SVG.
 
@@ -128,7 +129,7 @@ namespace basegfx
 
             @return true, if the string was successfully parsed
          */
-        bool importFromSvgD( B2DPolyPolygon&        o_rPolyPoly,
+        BASEGFX_DLLPUBLIC bool importFromSvgD( B2DPolyPolygon&        o_rPolyPoly,
                              const ::rtl::OUString& rSvgDAttribute );
 
         /** Read poly-polygon from SVG.
@@ -145,53 +146,53 @@ namespace basegfx
 
             @return true, if the string was successfully parsed
          */
-        bool importFromSvgPoints( B2DPolygon&            o_rPoly,
+        BASEGFX_DLLPUBLIC bool importFromSvgPoints( B2DPolygon&            o_rPoly,
                                   const ::rtl::OUString& rSvgPointsAttribute );
 
 
 		// grow for polyPolygon. Move all geometry in each point in the direction of the normal in that point
 		// with the given amount. Value may be negative.
-		B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue);
 
 		// This method will correct a pair of polyPolygons where the goal is to keep same point count
 		// to allow direct point association and also to remove self-intersections produced by shrinks.
 		// This method will eventually change both polyPolygons to reach that goal because there are cases
 		// where it is necessary to add new cut points to the original
-		void correctGrowShrinkPolygonPair(B2DPolyPolygon& rOriginal, B2DPolyPolygon& rGrown);
+		BASEGFX_DLLPUBLIC void correctGrowShrinkPolygonPair(B2DPolyPolygon& rOriginal, B2DPolyPolygon& rGrown);
 
 		// force all sub-polygons to a point count of nSegments
-		B2DPolyPolygon reSegmentPolyPolygon(const B2DPolyPolygon& rCandidate, sal_uInt32 nSegments);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon reSegmentPolyPolygon(const B2DPolyPolygon& rCandidate, sal_uInt32 nSegments);
 
 		// create polygon state at t from 0.0 to 1.0 between the two polygons. Both polygons must have the same
 		// organisation, e.g. same amount of polygons
-		B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t);
 
 		// create 3d PolyPolygon from given 2d PolyPolygon. The given fZCoordinate is used to expand the
 		// third coordinate.
-		B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate = 0.0);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate = 0.0);
 
 		// create 2d PolyPolygon from given 3d PolyPolygon. All coordinates are transformed using the given
 		// matrix and the resulting x,y is used to form the new polygon.
-		B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat);
 
 		// for each contained edge in each contained polygon calculate the smallest distance. Return the index to the smallest
 		// edge in rEdgeIndex and the index to the polygon in rPolygonIndex. The relative position on the edge is returned in rCut. 
 		// If nothing was found (e.g. empty input plygon), DBL_MAX is returned.
-		double getSmallestDistancePointToPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rPolygonIndex, sal_uInt32& rEdgeIndex, double& rCut);
+		BASEGFX_DLLPUBLIC double getSmallestDistancePointToPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rPolygonIndex, sal_uInt32& rEdgeIndex, double& rCut);
 
 		// distort PolyPolygon. rOriginal describes the original range, where the given points describe the distorted
 		// corresponding points.
-		B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight);
 
 		// rotate PolyPolygon around given point with given angle.
-		B2DPolyPolygon rotateAroundPoint(const B2DPolyPolygon& rCandidate, const B2DPoint& rCenter, double fAngle);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon rotateAroundPoint(const B2DPolyPolygon& rCandidate, const B2DPoint& rCenter, double fAngle);
 
 		// expand all segments (which are not yet) to curve segments. This is done with setting the control
 		// vectors on the 1/3 resp. 2/3 distances on each segment.
-		B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate);
 
 		// set continuity for the whole curve. If not a curve, nothing will change. Non-curve points are not changed, too.
-		B2DPolyPolygon setContinuity(const B2DPolyPolygon& rCandidate, B2VectorContinuity eContinuity);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon setContinuity(const B2DPolyPolygon& rCandidate, B2VectorContinuity eContinuity);
 
         /** Predicate whether a given poly-polygon is a rectangle.
 
@@ -204,7 +205,7 @@ namespace basegfx
             vertices). Note that intermediate points and duplicate
             points are ignored.
          */
-        bool isRectangle( const B2DPolyPolygon& rPoly );
+        BASEGFX_DLLPUBLIC bool isRectangle( const B2DPolyPolygon& rPoly );
 
         /** Export poly-polygon to SVG.
 
@@ -229,12 +230,12 @@ namespace basegfx
             @return the generated SVG-D statement (the XML d attribute
             value alone, without any "<path ...>" or "d="...")
          */
-        ::rtl::OUString exportToSvgD( const B2DPolyPolygon& rPolyPoly,
+        BASEGFX_DLLPUBLIC ::rtl::OUString exportToSvgD( const B2DPolyPolygon& rPolyPoly,
                                       bool 					bUseRelativeCoordinates=true,
                                       bool 					bDetectQuadraticBeziers=true );
 
 		// #i76891# Try to remove existing curve segments if they are simply edges
-		B2DPolyPolygon simplifyCurveSegments(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon simplifyCurveSegments(const B2DPolyPolygon& rCandidate);
 
         /** split each edge of a polyPolygon in exactly nSubEdges equidistant edges
             
@@ -248,12 +249,12 @@ namespace basegfx
             @param bHandleStraightEdges
             Please take a look at reSegmentPolygonEdges description, these are the same.
         */
-		B2DPolyPolygon reSegmentPolyPolygonEdges(const B2DPolyPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon reSegmentPolyPolygonEdges(const B2DPolyPolygon& rCandidate, sal_uInt32 nSubEdges, bool bHandleCurvedEdges, bool bHandleStraightEdges);
 
 		//////////////////////////////////////////////////////////////////////
 		// comparators with tolerance for 2D PolyPolygons
-		bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB, const double& rfSmallValue);
-		bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+		BASEGFX_DLLPUBLIC bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB, const double& rfSmallValue);
+		BASEGFX_DLLPUBLIC bool equal(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
 
 		/** snap some polygon coordinates to discrete coordinates
 
@@ -267,7 +268,7 @@ namespace basegfx
 			@return
 			The modified version of the source polygon
 		*/
-		B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate);
 
 	} // end of namespace tools
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx Thu Oct  4 23:16:35 2012
@@ -27,13 +27,14 @@
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <vector>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
 namespace basegfx
 {
     // class to hold a single trapezoid
-	class B2DTrapezoid
+	class BASEGFX_DLLPUBLIC B2DTrapezoid
 	{
 	private:
         // Geometry data. YValues are down-oriented, this means bottom should
@@ -89,13 +90,13 @@ namespace basegfx
         // lines have to be parallel to the X-Axis, thus this subdivision is NOT simply usable
         // for primitive decompositions. To use it, the shear and rotate parts of the
         // involved transformations HAVE to be taken into account.
-		void trapezoidSubdivide(
+		BASEGFX_DLLPUBLIC void trapezoidSubdivide(
             B2DTrapezoidVector& ro_Result, 
             const B2DPolyPolygon& rSourcePolyPolygon);
 
         // directly create trapezoids from given edge. Depending on the given geometry,
         // none up to three trapezoids will be created
-        void createLineTrapezoidFromEdge(
+        BASEGFX_DLLPUBLIC void createLineTrapezoidFromEdge(
             B2DTrapezoidVector& ro_Result, 
             const B2DPoint& rPointA, 
             const B2DPoint& rPointB, 
@@ -104,7 +105,7 @@ namespace basegfx
         // create trapezoids for all edges of the given polygon. The closed state of
         // the polygon is taken into account. If curves are contaned, the default
         // AdaptiveSubdivision will be used.
-        void createLineTrapezoidFromB2DPolygon(
+        BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolygon(
             B2DTrapezoidVector& ro_Result, 
             const B2DPolygon& rPolygon,
             double fLineWidth = 1.0);
@@ -112,7 +113,7 @@ namespace basegfx
         // create trapezoids for all edges of the given polyPolygon. The closed state of
         // the PolyPolygon is taken into account. If curves are contaned, the default
         // AdaptiveSubdivision will be used.
-        void createLineTrapezoidFromB2DPolyPolygon(
+        BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolyPolygon(
             B2DTrapezoidVector& ro_Result, 
             const B2DPolyPolygon& rPolyPolygon,
             double fLineWidth = 1.0);

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx Thu Oct  4 23:16:35 2012
@@ -26,6 +26,7 @@
 
 #include <sal/types.h>
 #include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 // predeclarations
@@ -46,7 +47,7 @@ namespace basegfx
 
 namespace basegfx
 {
-	class B3DPolygon
+	class BASEGFX_DLLPUBLIC B3DPolygon
 	{
     public:
         typedef o3tl::cow_wrapper< ImplB3DPolygon > ImplType;

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx Thu Oct  4 23:16:35 2012
@@ -26,6 +26,7 @@
 
 #include <basegfx/polygon/b3dpolypolygon.hxx>
 #include <basegfx/polygon/b3dpolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -51,30 +52,30 @@ namespace basegfx
 		// of the plane from the center (0.0).
 		// The value bClipPositive defines on which side the return value will be (true -> on positive side of plane).
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
-		B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
 
 		// version for Polygons
-		B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
 
 		// Clip the given PolyPolygon against the given range. bInside defines if the result will contain the
 		// parts which are contained in the range or vice versa.
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
-		B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
 
 		// version for Polygons
-		B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
 
 		// versions for B2DRange, clips only against X,Y
-		B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
-		B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
 
 		// Clip the given PolyPolygon against given plane in 3D. The plane is defined by a plane normal and a point on the plane.
 		// The value bClipPositive defines on which side the return value will be (true -> on positive side of plane).
 		// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
-		B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
 
 		// version for Polygons
-		B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
+		BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
 
 	} // end of namespace tools
 } // end of namespace basegfx

Modified: incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
URL: http://svn.apache.org/viewvc/incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx?rev=1394326&r1=1394325&r2=1394326&view=diff
==============================================================================
--- incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx (original)
+++ incubator/ooo/branches/buildsys/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx Thu Oct  4 23:16:35 2012
@@ -29,6 +29,7 @@
 #include <basegfx/polygon/b3dpolypolygon.hxx>
 #include <basegfx/vector/b2enums.hxx>
 #include <vector>
+#include <basegfx/basegfxdllapi.h>
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -49,58 +50,58 @@ namespace basegfx
 			method corrects this (removes double start/end points)
 			and sets the Closed()-state of the polygon correctly.
 		*/
-		void checkClosed(B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC void checkClosed(B3DPolygon& rCandidate);
 
 		// Get successor and predecessor indices. Returning the same index means there
 		// is none. Same for successor.
-		sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
-		sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
 
 		// Get orientation of Polygon
-		B2VectorOrientation getOrientation(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation(const B3DPolygon& rCandidate);
 
 		// get size of polygon. Control vectors are included in that ranges.
-		B3DRange getRange(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolygon& rCandidate);
 
 		// get normal vector of polygon
-		B3DVector getNormal(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B3DVector getNormal(const B3DPolygon& rCandidate);
 
 		// get normal vector of positive oriented polygon
-		B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate);
 
 		// get signed area of polygon
-		double getSignedArea(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getSignedArea(const B3DPolygon& rCandidate);
 
 		// get area of polygon
-		double getArea(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getArea(const B3DPolygon& rCandidate);
 
 		// get signed area of polygon
-		double getSignedArea(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getSignedArea(const B3DPolygon& rCandidate);
 
 		// get area of polygon
-		double getArea(const ::basegfx::B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getArea(const ::basegfx::B3DPolygon& rCandidate);
 
 		// get length of polygon edge from point nIndex to nIndex + 1
-		double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex);
+		BASEGFX_DLLPUBLIC double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex);
 
 		// get length of polygon
-		double getLength(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC double getLength(const B3DPolygon& rCandidate);
 
 		// get position on polygon for absolute given distance. If
 		// length is given, it is assumed the correct polygon length, if 0.0 it is calculated
 		// using getLength(...)
-		B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+		BASEGFX_DLLPUBLIC B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
 
 		// get position on polygon for relative given distance in range [0.0 .. 1.0]. If
 		// length is given, it is assumed the correct polygon length, if 0.0 it is calculated
 		// using getLength(...)
-		B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+		BASEGFX_DLLPUBLIC B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
 
 		/** Apply given LineDashing to given polygon
 
 			For a description see applyLineDashing in b2dpolygontoos.hxx
 		*/
-		void applyLineDashing(
+		BASEGFX_DLLPUBLIC void applyLineDashing(
 			const B3DPolygon& rCandidate, 
 			const ::std::vector<double>& rDotDashArray, 
 			B3DPolyPolygon* pLineTarget,
@@ -111,61 +112,61 @@ namespace basegfx
 			rCandidate:	the 3d geometry to change
 			rCenter:	the center of the 3d geometry
          */
-		B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter);
+		BASEGFX_DLLPUBLIC B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter);
 
 		/** invert normals for given 3d geometry.
          */
-		B3DPolygon invertNormals( const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B3DPolygon invertNormals( const B3DPolygon& rCandidate);
 
 		/** Create/replace texture coordinates for given 3d geometry with parallel projected one
 			rRange: the full range of the 3d geometry
 			If bChangeX, x texture coordinate will be recalculated.
 			If bChangeY, y texture coordinate will be recalculated.
          */
-		B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true);
+		BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true);
 
 		/** Create/replace texture coordinates for given 3d geometry with spherical one
 			rCenter: the centre of the used 3d geometry
 			If bChangeX, x texture coordinate will be recalculated.
 			If bChangeY, y texture coordinate will be recalculated.
          */
-		B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
+		BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
 
 		// test if point is inside epsilon-range around an edge defined
 		// by the two given points. Can be used for HitTesting. The epsilon-range
 		// is defined to be the cylinder centered to the given edge, using radius
 		// fDistance, and the sphere around both points with radius fDistance.
-		bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance);
+		BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance);
 
 		// test if point is inside epsilon-range around the given Polygon. Can be used 
 		// for HitTesting. The epsilon-range is defined to be the cylinder centered to 
         // the given edge, using radius fDistance, and the sphere around both points with radius fDistance.
-		bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance);
+		BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance);
 
 		// isInside tests for B3DPoint and other B3DPolygon. On border is not inside as long as
 		// not true is given in bWithBorder flag.
-		bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
-		bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder = false);
+		BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
+		BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder = false);
 
 		// calculates if given point is on given line, taking care of the numerical epsilon
-		bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints = false);
+		BASEGFX_DLLPUBLIC bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints = false);
 
         // calculates if given point is on given polygon, taking care of the numerical epsilon. Uses 
 		// isPointOnLine internally
-		bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints = true);
+		BASEGFX_DLLPUBLIC bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints = true);
 
         // helper to get a fCut position between a plane (given with normal and a point)
         // and a line given by start and end point
-        bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
+        BASEGFX_DLLPUBLIC bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
 
         // helper to get a fCut position between a 3d Polygon
         // and a line given by start and end point
-        bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
+        BASEGFX_DLLPUBLIC bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
 
 		//////////////////////////////////////////////////////////////////////
 		// comparators with tolerance for 3D Polygons
-		bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue);
-		bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB);
+		BASEGFX_DLLPUBLIC bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue);
+		BASEGFX_DLLPUBLIC bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB);
 
 		/** snap some polygon coordinates to discrete coordinates
 
@@ -179,7 +180,7 @@ namespace basegfx
 			@return
 			The modified version of the source polygon
 		*/
-		B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate);
+		BASEGFX_DLLPUBLIC B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate);
 
 	} // end of namespace tools
 } // end of namespace basegfx



Mime
View raw message