summaryrefslogtreecommitdiff
path: root/basegfx/inc
diff options
context:
space:
mode:
Diffstat (limited to 'basegfx/inc')
-rw-r--r--basegfx/inc/basegfx/basegfxdllapi.h37
-rw-r--r--basegfx/inc/basegfx/color/bcolor.hxx3
-rw-r--r--basegfx/inc/basegfx/color/bcolormodifier.hxx5
-rw-r--r--basegfx/inc/basegfx/color/bcolortools.hxx21
-rw-r--r--basegfx/inc/basegfx/curve/b2dbeziertools.hxx3
-rw-r--r--basegfx/inc/basegfx/curve/b2dcubicbezier.hxx3
-rw-r--r--basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx3
-rw-r--r--basegfx/inc/basegfx/matrix/b2dhommatrix.hxx3
-rw-r--r--basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx25
-rw-r--r--basegfx/inc/basegfx/matrix/b3dhommatrix.hxx3
-rw-r--r--basegfx/inc/basegfx/numeric/ftools.hxx3
-rw-r--r--basegfx/inc/basegfx/pixel/bpixel.hxx3
-rw-r--r--basegfx/inc/basegfx/point/b2dhompoint.hxx29
-rw-r--r--basegfx/inc/basegfx/point/b2dpoint.hxx5
-rw-r--r--basegfx/inc/basegfx/point/b2ipoint.hxx3
-rw-r--r--basegfx/inc/basegfx/point/b3dhompoint.hxx3
-rw-r--r--basegfx/inc/basegfx/point/b3dpoint.hxx5
-rw-r--r--basegfx/inc/basegfx/point/b3ipoint.hxx3
-rw-r--r--basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx5
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygon.hxx3
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx19
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx21
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygontools.hxx145
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx5
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx3
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx23
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx3
-rw-r--r--basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx61
-rw-r--r--basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx11
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolygon.hxx3
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx17
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolygontools.hxx63
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx3
-rw-r--r--basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx35
-rw-r--r--basegfx/inc/basegfx/range/b1drange.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b1ibox.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b1irange.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b2dpolyrange.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b2drange.hxx7
-rw-r--r--basegfx/inc/basegfx/range/b2drangeclipper.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b2ibox.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b2irange.hxx5
-rw-r--r--basegfx/inc/basegfx/range/b3drange.hxx5
-rw-r--r--basegfx/inc/basegfx/range/b3ibox.hxx3
-rw-r--r--basegfx/inc/basegfx/range/b3irange.hxx3
-rw-r--r--basegfx/inc/basegfx/range/basicbox.hxx3
-rw-r--r--basegfx/inc/basegfx/raster/bpixelraster.hxx3
-rw-r--r--basegfx/inc/basegfx/raster/bzpixelraster.hxx3
-rw-r--r--basegfx/inc/basegfx/raster/rasterconvert3d.hxx13
-rw-r--r--basegfx/inc/basegfx/tools/b2dclipstate.hxx3
-rwxr-xr-xbasegfx/inc/basegfx/tools/canvastools.hxx99
-rw-r--r--basegfx/inc/basegfx/tools/debugplotter.hxx3
-rw-r--r--basegfx/inc/basegfx/tools/gradienttools.hxx15
-rw-r--r--basegfx/inc/basegfx/tools/keystoplerp.hxx3
-rw-r--r--basegfx/inc/basegfx/tools/tools.hxx5
-rwxr-xr-xbasegfx/inc/basegfx/tools/unopolypolygon.hxx3
-rw-r--r--basegfx/inc/basegfx/tuple/b2dtuple.hxx5
-rw-r--r--basegfx/inc/basegfx/tuple/b2i64tuple.hxx3
-rw-r--r--basegfx/inc/basegfx/tuple/b2ituple.hxx32
-rw-r--r--basegfx/inc/basegfx/tuple/b3dtuple.hxx5
-rw-r--r--basegfx/inc/basegfx/tuple/b3i64tuple.hxx3
-rw-r--r--basegfx/inc/basegfx/tuple/b3ituple.hxx4
-rw-r--r--basegfx/inc/basegfx/vector/b2dvector.hxx15
-rw-r--r--basegfx/inc/basegfx/vector/b2ivector.hxx13
-rw-r--r--basegfx/inc/basegfx/vector/b3dvector.hxx7
-rw-r--r--basegfx/inc/basegfx/vector/b3ivector.hxx5
66 files changed, 483 insertions, 383 deletions
diff --git a/basegfx/inc/basegfx/basegfxdllapi.h b/basegfx/inc/basegfx/basegfxdllapi.h
new file mode 100644
index 000000000000..2088ea293e92
--- /dev/null
+++ b/basegfx/inc/basegfx/basegfxdllapi.h
@@ -0,0 +1,37 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+#ifndef INCLUDED_BASEGFXDLLAPI_H
+#define INCLUDED_BASEGFXDLLAPI_H
+
+#if defined BASEGFX_DLLIMPLEMENTATION
+#define BASEGFX_DLLPUBLIC SAL_DLLPUBLIC_EXPORT
+#else
+#define BASEGFX_DLLPUBLIC SAL_DLLPUBLIC_IMPORT
+#endif
+#define BASEGFX_DLLPRIVATE SAL_DLLPRIVATE
+
+#endif
diff --git a/basegfx/inc/basegfx/color/bcolor.hxx b/basegfx/inc/basegfx/color/bcolor.hxx
index db66dd8dbdee..496b381b1322 100644
--- a/basegfx/inc/basegfx/color/bcolor.hxx
+++ b/basegfx/inc/basegfx/color/bcolor.hxx
@@ -32,6 +32,7 @@
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -52,7 +53,7 @@ namespace basegfx
@see B3DTuple
*/
- class BColor : public B3DTuple
+ class BASEGFX_DLLPUBLIC BColor : public B3DTuple
{
public:
/** Create a Color with red, green and blue components from [0.0 to 1.0]
diff --git a/basegfx/inc/basegfx/color/bcolormodifier.hxx b/basegfx/inc/basegfx/color/bcolormodifier.hxx
index 962da760f850..0804eb635a87 100644
--- a/basegfx/inc/basegfx/color/bcolormodifier.hxx
+++ b/basegfx/inc/basegfx/color/bcolormodifier.hxx
@@ -30,6 +30,7 @@
#include <basegfx/color/bcolor.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -48,7 +49,7 @@ namespace basegfx
/** Class to hold a color, value and mode for a color modification. Color modification is
done calling the getModifiedColor() method
*/
- class BColorModifier
+ class BASEGFX_DLLPUBLIC BColorModifier
{
protected:
::basegfx::BColor maBColor;
@@ -88,7 +89,7 @@ namespace basegfx
/** Class to hold a stack of BColorModifiers and to get the modified color with
applying all existing entry changes
*/
- class BColorModifierStack
+ class BASEGFX_DLLPUBLIC BColorModifierStack
{
protected:
::std::vector< BColorModifier > maBColorModifiers;
diff --git a/basegfx/inc/basegfx/color/bcolortools.hxx b/basegfx/inc/basegfx/color/bcolortools.hxx
index 9121b145afa7..e5b54e6829fd 100644
--- a/basegfx/inc/basegfx/color/bcolortools.hxx
+++ b/basegfx/inc/basegfx/color/bcolortools.hxx
@@ -29,6 +29,7 @@
#define _BGFX_COLOR_BCOLORTOOLS_HXX
#include <sal/types.h>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -39,29 +40,29 @@ namespace basegfx
namespace tools
{
/// Transform from RGB to HSL
- BColor rgb2hsl(const BColor& rRGBColor);
+ BASEGFX_DLLPUBLIC BColor rgb2hsl(const BColor& rRGBColor);
/// Transform from HSL to RGB
- BColor hsl2rgb(const BColor& rHSLColor);
+ BASEGFX_DLLPUBLIC BColor hsl2rgb(const BColor& rHSLColor);
/// Transform from RGB to HSV
- BColor rgb2hsv(const BColor& rRGBColor);
+ BASEGFX_DLLPUBLIC BColor rgb2hsv(const BColor& rRGBColor);
/// Transform from HSV to RGB
- BColor hsv2rgb(const BColor& rHSVColor);
+ BASEGFX_DLLPUBLIC BColor hsv2rgb(const BColor& rHSVColor);
/// Transform from R'G'B' to YIQ (NTSC color model - Y is used in monochrome mode)
- BColor rgb2yiq(const BColor& rRGBColor);
+ BASEGFX_DLLPUBLIC BColor rgb2yiq(const BColor& rRGBColor);
/// Transform from YIQ to R'G'B' (NTSC color model - Y is used in monochrome mode)
- BColor yiq2rgb(const BColor& rYIQColor);
+ BASEGFX_DLLPUBLIC BColor yiq2rgb(const BColor& rYIQColor);
/// Transform from R'G'B' to Y'PbPr (the [0,1]x[-.5,.5]x[-.5,.5] equivalent of Y'CbCr (which is scaled into 8bit))
- BColor rgb2ypbpr(const BColor& rRGBColor);
+ BASEGFX_DLLPUBLIC BColor rgb2ypbpr(const BColor& rRGBColor);
/// Transform from Y'PbPr (the [0,1]x[-.5,.5]x[-.5,.5] equivalent of Y'CbCr (which is scaled into 8bit)) into R'G'B'
- BColor ypbpr2rgb(const BColor& rYPbPrColor);
+ BASEGFX_DLLPUBLIC BColor ypbpr2rgb(const BColor& rYPbPrColor);
/// Transform from CIE XYZ into Rec. 709 RGB (D65 white point)
- BColor ciexyz2rgb( const BColor& rXYZColor );
+ BASEGFX_DLLPUBLIC BColor ciexyz2rgb( const BColor& rXYZColor );
/// Transform from Rec. 709 RGB (D65 white point) into CIE XYZ
- BColor rgb2ciexyz( const BColor& rRGBColor );
+ BASEGFX_DLLPUBLIC BColor rgb2ciexyz( const BColor& rRGBColor );
}
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/curve/b2dbeziertools.hxx b/basegfx/inc/basegfx/curve/b2dbeziertools.hxx
index 3cc34fec5482..fa06ebcdbd05 100644
--- a/basegfx/inc/basegfx/curve/b2dbeziertools.hxx
+++ b/basegfx/inc/basegfx/curve/b2dbeziertools.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predefines
@@ -43,7 +44,7 @@ namespace basegfx
namespace basegfx
{
- class B2DCubicBezierHelper
+ class BASEGFX_DLLPUBLIC B2DCubicBezierHelper
{
private:
::std::vector< double > maLengthArray;
diff --git a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
index ea58a0a50b80..9603a423b224 100644
--- a/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
+++ b/basegfx/inc/basegfx/curve/b2dcubicbezier.hxx
@@ -30,6 +30,7 @@
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/range/b2drange.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -43,7 +44,7 @@ namespace basegfx
namespace basegfx
{
- class B2DCubicBezier
+ class BASEGFX_DLLPUBLIC B2DCubicBezier
{
B2DPoint maStartPoint;
B2DPoint maEndPoint;
diff --git a/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx b/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx
index 08cd6be59c78..4f3ee7169a1e 100644
--- a/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx
+++ b/basegfx/inc/basegfx/curve/b2dquadraticbezier.hxx
@@ -29,12 +29,13 @@
#define _BGFX_CURVE_B2DQUADRATICBEZIER_HXX
#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
- class B2DQuadraticBezier
+ class BASEGFX_DLLPUBLIC B2DQuadraticBezier
{
::basegfx::B2DPoint maStartPoint;
::basegfx::B2DPoint maEndPoint;
diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
index 910224897301..3a8d9fea2390 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrix.hxx
@@ -30,13 +30,14 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
class B2DTuple;
class Impl2DHomMatrix;
- class B2DHomMatrix
+ class BASEGFX_DLLPUBLIC B2DHomMatrix
{
public:
typedef o3tl::cow_wrapper< Impl2DHomMatrix > ImplType;
diff --git a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
index 7ce9e75c3058..047480a818dc 100644
--- a/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
+++ b/basegfx/inc/basegfx/matrix/b2dhommatrixtools.hxx
@@ -31,6 +31,7 @@
#include <sal/types.h>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/vector/b2dvector.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace rtl { class OUString; }
@@ -48,16 +49,16 @@ namespace basegfx
would introduce slight roundoff errors, instead of exactly
mirroring the coordinate system)
*/
- void createSinCosOrthogonal(double& o_rSin, double& rCos, double fRadiant);
+ BASEGFX_DLLPUBLIC void createSinCosOrthogonal(double& o_rSin, double& rCos, double fRadiant);
/** Tooling methods for on-the-fly matrix generation e.g. for inline
multiplications
*/
- B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY);
- B2DHomMatrix createShearXB2DHomMatrix(double fShearX);
- B2DHomMatrix createShearYB2DHomMatrix(double fShearY);
- B2DHomMatrix createRotateB2DHomMatrix(double fRadiant);
- B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY);
+ BASEGFX_DLLPUBLIC B2DHomMatrix createScaleB2DHomMatrix(double fScaleX, double fScaleY);
+ BASEGFX_DLLPUBLIC B2DHomMatrix createShearXB2DHomMatrix(double fShearX);
+ BASEGFX_DLLPUBLIC B2DHomMatrix createShearYB2DHomMatrix(double fShearY);
+ BASEGFX_DLLPUBLIC B2DHomMatrix createRotateB2DHomMatrix(double fRadiant);
+ BASEGFX_DLLPUBLIC B2DHomMatrix createTranslateB2DHomMatrix(double fTranslateX, double fTranslateY);
/// inline versions for parameters as tuples
inline B2DHomMatrix createScaleB2DHomMatrix(const B2DTuple& rScale)
@@ -77,7 +78,7 @@ namespace basegfx
matrix multiplications.
Inline versions for parameters as tuples added, too.
*/
- B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix(
+ BASEGFX_DLLPUBLIC B2DHomMatrix createScaleShearXRotateTranslateB2DHomMatrix(
double fScaleX, double fScaleY,
double fShearX,
double fRadiant,
@@ -95,7 +96,7 @@ namespace basegfx
rTranslate.getX(), rTranslate.getY());
}
- B2DHomMatrix createShearXRotateTranslateB2DHomMatrix(
+ BASEGFX_DLLPUBLIC B2DHomMatrix createShearXRotateTranslateB2DHomMatrix(
double fShearX,
double fRadiant,
double fTranslateX, double fTranslateY);
@@ -110,7 +111,7 @@ namespace basegfx
rTranslate.getX(), rTranslate.getY());
}
- B2DHomMatrix createScaleTranslateB2DHomMatrix(
+ BASEGFX_DLLPUBLIC B2DHomMatrix createScaleTranslateB2DHomMatrix(
double fScaleX, double fScaleY,
double fTranslateX, double fTranslateY);
inline B2DHomMatrix createScaleTranslateB2DHomMatrix(
@@ -123,7 +124,7 @@ namespace basegfx
}
/// special for the often used case of rotation around a point
- B2DHomMatrix createRotateAroundPoint(
+ BASEGFX_DLLPUBLIC B2DHomMatrix createRotateAroundPoint(
double fPointX, double fPointY,
double fRadiant);
inline B2DHomMatrix createRotateAroundPoint(
@@ -144,7 +145,7 @@ namespace basegfx
{
namespace tools
{
- class B2DHomMatrixBufferedDecompose
+ class BASEGFX_DLLPUBLIC B2DHomMatrixBufferedDecompose
{
private:
B2DVector maScale;
@@ -183,7 +184,7 @@ namespace basegfx
{
namespace tools
{
- class B2DHomMatrixBufferedOnDemandDecompose
+ class BASEGFX_DLLPUBLIC B2DHomMatrixBufferedOnDemandDecompose
{
private:
B2DHomMatrix maB2DHomMatrix;
diff --git a/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx b/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx
index bc35fcde321e..4391d7b8d8e6 100644
--- a/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx
+++ b/basegfx/inc/basegfx/matrix/b3dhommatrix.hxx
@@ -32,13 +32,14 @@
#include <basegfx/point/b3dpoint.hxx>
#include <basegfx/vector/b3dvector.hxx>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
class B3DTuple;
class Impl3DHomMatrix;
- class B3DHomMatrix
+ class BASEGFX_DLLPUBLIC B3DHomMatrix
{
public:
typedef o3tl::cow_wrapper< Impl3DHomMatrix > ImplType;
diff --git a/basegfx/inc/basegfx/numeric/ftools.hxx b/basegfx/inc/basegfx/numeric/ftools.hxx
index 65a6566dae25..10ebd89f610c 100644
--- a/basegfx/inc/basegfx/numeric/ftools.hxx
+++ b/basegfx/inc/basegfx/numeric/ftools.hxx
@@ -29,6 +29,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
@@ -144,7 +145,7 @@ namespace basegfx
}
- class fTools
+ class BASEGFX_DLLPUBLIC fTools
{
/// Threshold value for equalZero()
static double mfSmallValue;
diff --git a/basegfx/inc/basegfx/pixel/bpixel.hxx b/basegfx/inc/basegfx/pixel/bpixel.hxx
index 2684ff44e5d6..b40a05f8b082 100644
--- a/basegfx/inc/basegfx/pixel/bpixel.hxx
+++ b/basegfx/inc/basegfx/pixel/bpixel.hxx
@@ -31,6 +31,7 @@
#include <sal/types.h>
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/color/bcolor.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -39,7 +40,7 @@
namespace basegfx
{
- class BPixel
+ class BASEGFX_DLLPUBLIC BPixel
{
protected:
union
diff --git a/basegfx/inc/basegfx/point/b2dhompoint.hxx b/basegfx/inc/basegfx/point/b2dhompoint.hxx
index 254ee9251dd3..07815e3feabe 100644
--- a/basegfx/inc/basegfx/point/b2dhompoint.hxx
+++ b/basegfx/inc/basegfx/point/b2dhompoint.hxx
@@ -29,6 +29,7 @@
#define _BGFX_POINT_B2DHOMPOINT_HXX
#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -45,7 +46,7 @@ namespace basegfx
@see B2DTuple
*/
- class B2DHomPoint
+ class BASEGFX_DLLPUBLIC B2DHomPoint
{
protected:
/// This member contains the coordinate part of the point
@@ -205,31 +206,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 */
diff --git a/basegfx/inc/basegfx/point/b2dpoint.hxx b/basegfx/inc/basegfx/point/b2dpoint.hxx
index 273a1c54e3ba..dd169a549d7c 100644
--- a/basegfx/inc/basegfx/point/b2dpoint.hxx
+++ b/basegfx/inc/basegfx/point/b2dpoint.hxx
@@ -30,6 +30,7 @@
#include <basegfx/tuple/b2dtuple.hxx>
#include <basegfx/point/b2ipoint.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -46,7 +47,7 @@ namespace basegfx
@see B2DTuple
*/
- class B2DPoint : public ::basegfx::B2DTuple
+ class BASEGFX_DLLPUBLIC B2DPoint : public ::basegfx::B2DTuple
{
public:
/** Create a 2D Point
@@ -143,7 +144,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
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/inc/basegfx/point/b2ipoint.hxx b/basegfx/inc/basegfx/point/b2ipoint.hxx
index dec51735de7c..accd5938574e 100644
--- a/basegfx/inc/basegfx/point/b2ipoint.hxx
+++ b/basegfx/inc/basegfx/point/b2ipoint.hxx
@@ -29,6 +29,7 @@
#define _BGFX_POINT_B2IPOINT_HXX
#include <basegfx/tuple/b2ituple.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -43,7 +44,7 @@ namespace basegfx
@see B2ITuple
*/
- class B2IPoint : public ::basegfx::B2ITuple
+ class BASEGFX_DLLPUBLIC B2IPoint : public ::basegfx::B2ITuple
{
public:
/** Create a 2D Point
diff --git a/basegfx/inc/basegfx/point/b3dhompoint.hxx b/basegfx/inc/basegfx/point/b3dhompoint.hxx
index 7417d7528d16..64ea6415a0e8 100644
--- a/basegfx/inc/basegfx/point/b3dhompoint.hxx
+++ b/basegfx/inc/basegfx/point/b3dhompoint.hxx
@@ -29,6 +29,7 @@
#define _BGFX_POINT_B3DHOMPOINT_HXX
#include <basegfx/point/b3dpoint.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -45,7 +46,7 @@ namespace basegfx
@see B3DTuple
*/
- class B3DHomPoint
+ class BASEGFX_DLLPUBLIC B3DHomPoint
{
protected:
/// This member contains the coordinate part of the point
diff --git a/basegfx/inc/basegfx/point/b3dpoint.hxx b/basegfx/inc/basegfx/point/b3dpoint.hxx
index 943f74c1352d..3a0724f217de 100644
--- a/basegfx/inc/basegfx/point/b3dpoint.hxx
+++ b/basegfx/inc/basegfx/point/b3dpoint.hxx
@@ -29,6 +29,7 @@
#define _BGFX_POINT_B3DPOINT_HXX
#include <basegfx/tuple/b3dtuple.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -43,7 +44,7 @@ namespace basegfx
@see B3DTuple
*/
- class B3DPoint : public ::basegfx::B3DTuple
+ class BASEGFX_DLLPUBLIC B3DPoint : public ::basegfx::B3DTuple
{
public:
/** Create a 3D Point
@@ -143,7 +144,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
diff --git a/basegfx/inc/basegfx/point/b3ipoint.hxx b/basegfx/inc/basegfx/point/b3ipoint.hxx
index f20fe3d99c79..5c80937ef77f 100644
--- a/basegfx/inc/basegfx/point/b3ipoint.hxx
+++ b/basegfx/inc/basegfx/point/b3ipoint.hxx
@@ -29,6 +29,7 @@
#define _BGFX_POINT_B3IPOINT_HXX
#include <basegfx/tuple/b3ituple.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -43,7 +44,7 @@ namespace basegfx
@see B3ITuple
*/
- class B3IPoint : public ::basegfx::B3ITuple
+ class BASEGFX_DLLPUBLIC B3IPoint : public ::basegfx::B3ITuple
{
public:
/** Create a 3D Point
diff --git a/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx b/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx
index fd8997fcda4d..23017a4de210 100644
--- a/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dlinegeometry.hxx
@@ -32,6 +32,7 @@
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -72,7 +73,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,
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
index a12120b5f441..db807f38e7ff 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygon.hxx
@@ -32,6 +32,7 @@
#include <o3tl/cow_wrapper.hxx>
#include <basegfx/vector/b2enums.hxx>
#include <basegfx/range/b2drange.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -50,7 +51,7 @@ namespace basegfx
namespace basegfx
{
- class B2DPolygon
+ class BASEGFX_DLLPUBLIC B2DPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB2DPolygon > ImplType;
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx b/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx
index d13d3d0a862c..83fa106dac72 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygonclipper.hxx
@@ -30,6 +30,7 @@
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -46,21 +47,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).
@@ -68,13 +69,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
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx b/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
index a9d6e0a1b6fe..5f47b3c9f8c3 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygoncutandtouch.hxx
@@ -30,6 +30,7 @@
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -39,39 +40,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
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
index 7d1d0bc9660c..977b498a9e1f 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
@@ -34,6 +34,7 @@
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b3dpolygon.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -48,8 +49,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.
@@ -60,20 +61,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
@@ -85,7 +86,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
@@ -98,53 +99,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;
@@ -161,7 +162,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,
@@ -169,7 +170,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,
@@ -177,7 +178,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,
@@ -186,7 +187,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,
@@ -225,7 +226,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,
@@ -236,13 +237,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.
@@ -253,7 +254,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.
@@ -265,15 +266,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.
@@ -287,7 +288,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 a polygon which describes the unit circle and close it
@@ -299,7 +300,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.
@@ -316,13 +317,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.
@@ -334,111 +335,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
@@ -468,7 +469,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
@@ -485,7 +486,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
@@ -507,12 +508,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
@@ -526,7 +527,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
diff --git a/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx b/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx
index e23d640b8833..191997bc01cb 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx
@@ -30,6 +30,7 @@
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -38,10 +39,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
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
index 0032cc47ce4e..51837be9d3c7 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
@@ -31,6 +31,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
#include <basegfx/range/b2drange.hxx>
+#include <basegfx/basegfxdllapi.h>
// predeclarations
class ImplB2DPolyPolygon;
@@ -45,7 +46,7 @@ namespace basegfx
namespace basegfx
{
- class B2DPolyPolygon
+ class BASEGFX_DLLPUBLIC B2DPolyPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB2DPolyPolygon > ImplType;
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
index 7e648302c5e5..df84e57edf1a 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
@@ -29,6 +29,7 @@
#define _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -43,18 +44,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.
@@ -67,7 +68,7 @@ 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);
// 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
@@ -86,20 +87,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
@@ -108,7 +109,7 @@ namespace basegfx
@return A single PolyPolygon containing the Or-merged result
*/
- B2DPolyPolygon mergeToSinglePolyPolygon(const std::vector< basegfx::B2DPolyPolygon >& rInput);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon mergeToSinglePolyPolygon(const std::vector< basegfx::B2DPolyPolygon >& rInput);
} // end of namespace tools
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx
index a77f1a371a8a..899d6ab7a32f 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx
@@ -34,6 +34,7 @@
#include <basegfx/polygon/b2dpolypolygonfillrule.hxx>
#include <vector>
#include <utility>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -48,7 +49,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
diff --git a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
index 1115a96ef8da..666b04478a43 100644
--- a/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
@@ -33,6 +33,7 @@
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b3dpolypolygon.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace rtl
{
@@ -54,27 +55,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.
@@ -87,7 +88,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
@@ -100,13 +101,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,
@@ -116,7 +117,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.
@@ -132,7 +133,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.
@@ -149,53 +150,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.
@@ -208,7 +209,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.
@@ -233,12 +234,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
@@ -252,12 +253,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
@@ -271,7 +272,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
diff --git a/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx b/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx
index 70ffdf2b7339..c3954f3024aa 100644
--- a/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx
+++ b/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx
@@ -34,13 +34,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
@@ -96,13 +97,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,
@@ -111,7 +112,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);
@@ -119,7 +120,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);
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
index 1732c1338042..1d6bf295cdec 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -50,7 +51,7 @@ namespace basegfx
namespace basegfx
{
- class B3DPolygon
+ class BASEGFX_DLLPUBLIC B3DPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB3DPolygon > ImplType;
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx b/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
index 71c7f36d50d8..dd785240c7f2 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
@@ -30,6 +30,7 @@
#include <basegfx/polygon/b3dpolypolygon.hxx>
#include <basegfx/polygon/b3dpolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -55,30 +56,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
diff --git a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
index 7945fc1bde00..6af99ef18a4a 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
@@ -33,6 +33,7 @@
#include <basegfx/polygon/b3dpolypolygon.hxx>
#include <basegfx/vector/b2enums.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -53,58 +54,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,
@@ -115,61 +116,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
@@ -183,7 +184,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
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
index 76e0c2f844c0..1561354d820f 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
// predeclarations
class ImplB3DPolyPolygon;
@@ -45,7 +46,7 @@ namespace basegfx
namespace basegfx
{
- class B3DPolyPolygon
+ class BASEGFX_DLLPUBLIC B3DPolyPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB3DPolyPolygon > ImplType;
diff --git a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
index 813be9839a9a..6278986ddc1e 100644
--- a/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
+++ b/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
@@ -33,6 +33,7 @@
#include <vector>
#include <basegfx/numeric/ftools.hxx>
#include <basegfx/point/b3dpoint.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -47,13 +48,13 @@ namespace basegfx
// B3DPolyPolygon tools
// get size of PolyPolygon. Control vectors are included in that ranges.
- B3DRange getRange(const B3DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolyPolygon& rCandidate);
/** Apply given LineDashing to given polyPolygon
For a description see applyLineDashing in b2dpolygontoos.hxx
*/
- void applyLineDashing(
+ BASEGFX_DLLPUBLIC void applyLineDashing(
const B3DPolyPolygon& rCandidate,
const ::std::vector<double>& rDotDashArray,
B3DPolyPolygon* pLineTarget,
@@ -62,26 +63,26 @@ namespace basegfx
/** Create a unit 3D line polyPolygon which defines a cube.
*/
- B3DPolyPolygon createUnitCubePolyPolygon();
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitCubePolyPolygon();
/** Create a unit 3D fill polyPolygon which defines a cube.
*/
- B3DPolyPolygon createUnitCubeFillPolyPolygon();
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitCubeFillPolyPolygon();
/** Create a 3D line polyPolygon from a B3DRange which defines a cube.
*/
- B3DPolyPolygon createCubePolyPolygonFromB3DRange( const B3DRange& rRange);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createCubePolyPolygonFromB3DRange( const B3DRange& rRange);
/** Create a 3D fill polyPolygon from a B3DRange which defines a cube.
*/
- B3DPolyPolygon createCubeFillPolyPolygonFromB3DRange( const B3DRange& rRange);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createCubeFillPolyPolygonFromB3DRange( const B3DRange& rRange);
/** Create a unit 3D line polyPolygon which defines a sphere with the given count of hor and ver segments.
Result will be centered at (0.0, 0.0, 0.0) and sized [-1.0 .. 1.0] in all dimensions.
If nHorSeg == 0 and/or nVerSeg == 0, a default will be calculated to have a step at least each 15 degrees.
With VerStart, VerStop and hor range in cartesian may be specified to create a partial sphere only.
*/
- B3DPolyPolygon createUnitSpherePolyPolygon(
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitSpherePolyPolygon(
sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L,
double fVerStart = F_PI2, double fVerStop = -F_PI2,
double fHorStart = 0.0, double fHorStop = F_2PI);
@@ -90,7 +91,7 @@ namespace basegfx
If nHorSeg == 0 and/or nVerSeg == 0, a default will be calculated to have a step at least each 15 degrees.
With VerStart, VerStop and hor range in cartesian may be specified to create a partial sphere only.
*/
- B3DPolyPolygon createSpherePolyPolygonFromB3DRange(
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createSpherePolyPolygonFromB3DRange(
const B3DRange& rRange,
sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L,
double fVerStart = F_PI2, double fVerStop = -F_PI2,
@@ -99,7 +100,7 @@ namespace basegfx
/** same as createUnitSpherePolyPolygon, but creates filled polygons (closed and oriented)
There is one extra, the bool bNormals defines if normals will be set, default is false
*/
- B3DPolyPolygon createUnitSphereFillPolyPolygon(
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createUnitSphereFillPolyPolygon(
sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L,
bool bNormals = false,
double fVerStart = F_PI2, double fVerStop = -F_PI2,
@@ -108,7 +109,7 @@ namespace basegfx
/** same as createSpherePolyPolygonFromB3DRange, but creates filled polygons (closed and oriented)
There is one extra, the bool bNormals defines if normals will be set, default is false
*/
- B3DPolyPolygon createSphereFillPolyPolygonFromB3DRange(
+ BASEGFX_DLLPUBLIC B3DPolyPolygon createSphereFillPolyPolygonFromB3DRange(
const B3DRange& rRange,
sal_uInt32 nHorSeg = 0L, sal_uInt32 nVerSeg = 0L,
bool bNormals = false,
@@ -119,34 +120,34 @@ namespace basegfx
rCandidate: the 3d geometry to change
rCenter: the center of the 3d geometry
*/
- B3DPolyPolygon applyDefaultNormalsSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon applyDefaultNormalsSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter);
/** invert normals for given 3d geometry.
*/
- B3DPolyPolygon invertNormals( const B3DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon invertNormals( const B3DPolyPolygon& 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.
*/
- B3DPolyPolygon applyDefaultTextureCoordinatesParallel( const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon applyDefaultTextureCoordinatesParallel( const B3DPolyPolygon& 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.
*/
- B3DPolyPolygon applyDefaultTextureCoordinatesSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon applyDefaultTextureCoordinatesSphere( const B3DPolyPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
// isInside test for B3DPoint. 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 B3DPolyPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
+ BASEGFX_DLLPUBLIC bool isInside(const B3DPolyPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
//////////////////////////////////////////////////////////////////////
// comparators with tolerance for 3D PolyPolygons
- bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB, const double& rfSmallValue);
- bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB);
+ BASEGFX_DLLPUBLIC bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB, const double& rfSmallValue);
+ BASEGFX_DLLPUBLIC bool equal(const B3DPolyPolygon& rCandidateA, const B3DPolyPolygon& rCandidateB);
} // end of namespace tools
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/range/b1drange.hxx b/basegfx/inc/basegfx/range/b1drange.hxx
index eba1536f4ee6..995f2e95777f 100644
--- a/basegfx/inc/basegfx/range/b1drange.hxx
+++ b/basegfx/inc/basegfx/range/b1drange.hxx
@@ -29,13 +29,14 @@
#define _BGFX_RANGE_B1DRANGE_HXX
#include <basegfx/range/basicrange.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
class B1IRange;
- class B1DRange
+ class BASEGFX_DLLPUBLIC B1DRange
{
::basegfx::BasicRange< double, DoubleTraits > maRange;
diff --git a/basegfx/inc/basegfx/range/b1ibox.hxx b/basegfx/inc/basegfx/range/b1ibox.hxx
index cb4ab8770a49..9535f0346a04 100644
--- a/basegfx/inc/basegfx/range/b1ibox.hxx
+++ b/basegfx/inc/basegfx/range/b1ibox.hxx
@@ -29,11 +29,12 @@
#define _BGFX_RANGE_B1IBOX_HXX
#include <basegfx/range/basicbox.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
- class B1IBox
+ class BASEGFX_DLLPUBLIC B1IBox
{
::basegfx::BasicBox maRange;
diff --git a/basegfx/inc/basegfx/range/b1irange.hxx b/basegfx/inc/basegfx/range/b1irange.hxx
index 6c65fbaebff4..45db9d3fbecf 100644
--- a/basegfx/inc/basegfx/range/b1irange.hxx
+++ b/basegfx/inc/basegfx/range/b1irange.hxx
@@ -29,11 +29,12 @@
#define _BGFX_RANGE_B1IRANGE_HXX
#include <basegfx/range/basicrange.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
- class B1IRange
+ class BASEGFX_DLLPUBLIC B1IRange
{
::basegfx::BasicRange< sal_Int32, Int32Traits > maRange;
diff --git a/basegfx/inc/basegfx/range/b2dpolyrange.hxx b/basegfx/inc/basegfx/range/b2dpolyrange.hxx
index 2202869dc921..256a17845e5f 100644
--- a/basegfx/inc/basegfx/range/b2dpolyrange.hxx
+++ b/basegfx/inc/basegfx/range/b2dpolyrange.hxx
@@ -34,6 +34,7 @@
#include <o3tl/cow_wrapper.hxx>
#include <boost/tuple/tuple.hpp>
#include <basegfx/vector/b2enums.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -58,7 +59,7 @@ namespace basegfx
contain 'holes' - this is encoded via polygon orientation at
the poly-polygon, and via explicit flags for the poly-range.
*/
- class B2DPolyRange
+ class BASEGFX_DLLPUBLIC B2DPolyRange
{
public:
typedef boost::tuple<B2DRange,B2VectorOrientation> ElementType ;
diff --git a/basegfx/inc/basegfx/range/b2drange.hxx b/basegfx/inc/basegfx/range/b2drange.hxx
index fc3a6fe53659..7d00f9bc0ee7 100644
--- a/basegfx/inc/basegfx/range/b2drange.hxx
+++ b/basegfx/inc/basegfx/range/b2drange.hxx
@@ -33,6 +33,7 @@
#include <basegfx/tuple/b2dtuple.hxx>
#include <basegfx/range/basicrange.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -41,7 +42,7 @@ namespace basegfx
class B2IRange;
class B2DHomMatrix;
- class B2DRange
+ class BASEGFX_DLLPUBLIC B2DRange
{
public:
typedef double ValueType;
@@ -264,7 +265,7 @@ namespace basegfx
@return the nearest integer for this range
*/
- B2IRange fround(const B2DRange& rRange);
+ BASEGFX_DLLPUBLIC B2IRange fround(const B2DRange& rRange);
/** Compute the set difference of the two given ranges
@@ -285,7 +286,7 @@ namespace basegfx
@return the input vector
*/
- ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >& o_rResult,
+ BASEGFX_DLLPUBLIC ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >& o_rResult,
const B2DRange& rFirst,
const B2DRange& rSecond );
diff --git a/basegfx/inc/basegfx/range/b2drangeclipper.hxx b/basegfx/inc/basegfx/range/b2drangeclipper.hxx
index 3285ffeaffe1..10c095afceec 100644
--- a/basegfx/inc/basegfx/range/b2drangeclipper.hxx
+++ b/basegfx/inc/basegfx/range/b2drangeclipper.hxx
@@ -33,6 +33,7 @@
#include <basegfx/range/b2dpolyrange.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -45,7 +46,7 @@ namespace basegfx
poly-polygon with the same topology, and encoding
inside/outsidedness via polygon orientation and layering.
*/
- B2DPolyPolygon solveCrossovers(const std::vector<B2DRange>& rRanges,
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const std::vector<B2DRange>& rRanges,
const std::vector<B2VectorOrientation>& rOrientations);
}
}
diff --git a/basegfx/inc/basegfx/range/b2ibox.hxx b/basegfx/inc/basegfx/range/b2ibox.hxx
index a188c7e8abe6..11a320c8c419 100644
--- a/basegfx/inc/basegfx/range/b2ibox.hxx
+++ b/basegfx/inc/basegfx/range/b2ibox.hxx
@@ -34,11 +34,12 @@
#include <basegfx/tuple/b2i64tuple.hxx>
#include <basegfx/range/basicbox.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
- class B2IBox
+ class BASEGFX_DLLPUBLIC B2IBox
{
public:
typedef sal_Int32 ValueType;
diff --git a/basegfx/inc/basegfx/range/b2irange.hxx b/basegfx/inc/basegfx/range/b2irange.hxx
index 8d4690283da0..92ce097df27b 100644
--- a/basegfx/inc/basegfx/range/b2irange.hxx
+++ b/basegfx/inc/basegfx/range/b2irange.hxx
@@ -34,11 +34,12 @@
#include <basegfx/tuple/b2i64tuple.hxx>
#include <basegfx/range/basicrange.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
- class B2IRange
+ class BASEGFX_DLLPUBLIC B2IRange
{
public:
typedef sal_Int32 ValueType;
@@ -245,7 +246,7 @@ namespace basegfx
@return the input vector
*/
- ::std::vector< B2IRange >& computeSetDifference( ::std::vector< B2IRange >& o_rResult,
+ BASEGFX_DLLPUBLIC ::std::vector< B2IRange >& computeSetDifference( ::std::vector< B2IRange >& o_rResult,
const B2IRange& rFirst,
const B2IRange& rSecond );
diff --git a/basegfx/inc/basegfx/range/b3drange.hxx b/basegfx/inc/basegfx/range/b3drange.hxx
index 2a2a42aa0718..9474f55fc2a9 100644
--- a/basegfx/inc/basegfx/range/b3drange.hxx
+++ b/basegfx/inc/basegfx/range/b3drange.hxx
@@ -32,6 +32,7 @@
#include <basegfx/point/b3dpoint.hxx>
#include <basegfx/tuple/b3dtuple.hxx>
#include <basegfx/range/basicrange.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -39,7 +40,7 @@ namespace basegfx
class B3IRange;
class B3DHomMatrix;
- class B3DRange
+ class BASEGFX_DLLPUBLIC B3DRange
{
typedef ::basegfx::BasicRange< double, DoubleTraits > MyBasicRange;
@@ -295,7 +296,7 @@ namespace basegfx
@return the nearest integer for this range
*/
- B3IRange fround(const B3DRange& rRange);
+ BASEGFX_DLLPUBLIC B3IRange fround(const B3DRange& rRange);
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/range/b3ibox.hxx b/basegfx/inc/basegfx/range/b3ibox.hxx
index f9693465a2bb..7aa9e9c82b64 100644
--- a/basegfx/inc/basegfx/range/b3ibox.hxx
+++ b/basegfx/inc/basegfx/range/b3ibox.hxx
@@ -33,10 +33,11 @@
#include <basegfx/tuple/b3ituple.hxx>
#include <basegfx/tuple/b3i64tuple.hxx>
#include <basegfx/range/basicbox.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
- class B3IBox
+ class BASEGFX_DLLPUBLIC B3IBox
{
BasicBox maRangeX;
BasicBox maRangeY;
diff --git a/basegfx/inc/basegfx/range/b3irange.hxx b/basegfx/inc/basegfx/range/b3irange.hxx
index e2b9a08c3093..a35f16dcd3ea 100644
--- a/basegfx/inc/basegfx/range/b3irange.hxx
+++ b/basegfx/inc/basegfx/range/b3irange.hxx
@@ -33,10 +33,11 @@
#include <basegfx/tuple/b3ituple.hxx>
#include <basegfx/tuple/b3i64tuple.hxx>
#include <basegfx/range/basicrange.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
- class B3IRange
+ class BASEGFX_DLLPUBLIC B3IRange
{
typedef ::basegfx::BasicRange< sal_Int32, Int32Traits > MyBasicRange;
diff --git a/basegfx/inc/basegfx/range/basicbox.hxx b/basegfx/inc/basegfx/range/basicbox.hxx
index 0a5274bc9bc9..9cf56e89bb55 100644
--- a/basegfx/inc/basegfx/range/basicbox.hxx
+++ b/basegfx/inc/basegfx/range/basicbox.hxx
@@ -29,6 +29,7 @@
#define _BGFX_RANGE_BASICBOX_HXX
#include <basegfx/range/basicrange.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -40,7 +41,7 @@ namespace basegfx
<em>outside</em> of the range, in contrast to BasicRange,
which considers them inside.
*/
- class BasicBox : public BasicRange< sal_Int32, Int32Traits >
+ class BASEGFX_DLLPUBLIC BasicBox : public BasicRange< sal_Int32, Int32Traits >
{
typedef BasicRange< sal_Int32, Int32Traits > Base;
public:
diff --git a/basegfx/inc/basegfx/raster/bpixelraster.hxx b/basegfx/inc/basegfx/raster/bpixelraster.hxx
index c28adcdb2ef7..0805db5b5e6d 100644
--- a/basegfx/inc/basegfx/raster/bpixelraster.hxx
+++ b/basegfx/inc/basegfx/raster/bpixelraster.hxx
@@ -32,6 +32,7 @@
#include <sal/types.h>
#include <basegfx/pixel/bpixel.hxx>
#include <rtl/memory.h>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -40,7 +41,7 @@
namespace basegfx
{
- class BPixelRaster
+ class BASEGFX_DLLPUBLIC BPixelRaster
{
private:
// do not allow copy constructor and assignment operator
diff --git a/basegfx/inc/basegfx/raster/bzpixelraster.hxx b/basegfx/inc/basegfx/raster/bzpixelraster.hxx
index 2c0905a78397..61a21c40dda7 100644
--- a/basegfx/inc/basegfx/raster/bzpixelraster.hxx
+++ b/basegfx/inc/basegfx/raster/bzpixelraster.hxx
@@ -30,6 +30,7 @@
#include <basegfx/raster/bpixelraster.hxx>
#include <rtl/memory.h>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -38,7 +39,7 @@
namespace basegfx
{
- class BZPixelRaster : public BPixelRaster
+ class BASEGFX_DLLPUBLIC BZPixelRaster : public BPixelRaster
{
protected:
// additionally, host a ZBuffer
diff --git a/basegfx/inc/basegfx/raster/rasterconvert3d.hxx b/basegfx/inc/basegfx/raster/rasterconvert3d.hxx
index fb777482246d..fde93a4710dd 100644
--- a/basegfx/inc/basegfx/raster/rasterconvert3d.hxx
+++ b/basegfx/inc/basegfx/raster/rasterconvert3d.hxx
@@ -34,6 +34,7 @@
#include <basegfx/vector/b3dvector.hxx>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/vector/b2dvector.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -49,7 +50,7 @@ namespace basegfx
namespace basegfx
{
- class ip_single
+ class BASEGFX_DLLPUBLIC ip_single
{
private:
double mfVal;
@@ -75,7 +76,7 @@ namespace basegfx
namespace basegfx
{
- class ip_double
+ class BASEGFX_DLLPUBLIC ip_double
{
private:
ip_single maX;
@@ -101,7 +102,7 @@ namespace basegfx
namespace basegfx
{
- class ip_triple
+ class BASEGFX_DLLPUBLIC ip_triple
{
private:
ip_single maX;
@@ -137,7 +138,7 @@ namespace basegfx
{
#define SCANLINE_EMPTY_INDEX (0xffffffff)
- class InterpolatorProvider3D
+ class BASEGFX_DLLPUBLIC InterpolatorProvider3D
{
private:
::std::vector< ip_triple > maColorInterpolators;
@@ -209,7 +210,7 @@ namespace basegfx
namespace basegfx
{
- class RasterConversionLineEntry3D
+ class BASEGFX_DLLPUBLIC RasterConversionLineEntry3D
{
private:
ip_single maX;
@@ -307,7 +308,7 @@ namespace basegfx
namespace basegfx
{
- class RasterConverter3D : public InterpolatorProvider3D
+ class BASEGFX_DLLPUBLIC RasterConverter3D : public InterpolatorProvider3D
{
private:
// the line entries for an area conversion run
diff --git a/basegfx/inc/basegfx/tools/b2dclipstate.hxx b/basegfx/inc/basegfx/tools/b2dclipstate.hxx
index 7d336d8cb48e..db972a2f5850 100644
--- a/basegfx/inc/basegfx/tools/b2dclipstate.hxx
+++ b/basegfx/inc/basegfx/tools/b2dclipstate.hxx
@@ -33,6 +33,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -57,7 +58,7 @@ namespace basegfx
a clip representation is requested, and using faster code
paths for common special cases (like all-rectangle clips)
*/
- class B2DClipState
+ class BASEGFX_DLLPUBLIC B2DClipState
{
public:
typedef o3tl::cow_wrapper< ImplB2DClipState > ImplType;
diff --git a/basegfx/inc/basegfx/tools/canvastools.hxx b/basegfx/inc/basegfx/tools/canvastools.hxx
index 1903518d991b..3b160a4242d5 100755
--- a/basegfx/inc/basegfx/tools/canvastools.hxx
+++ b/basegfx/inc/basegfx/tools/canvastools.hxx
@@ -30,6 +30,7 @@
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/uno/Sequence.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace com { namespace sun { namespace star { namespace geometry
@@ -79,118 +80,118 @@ namespace basegfx
// Polygon conversions
// ===================================================================
- ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D >
+ BASEGFX_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D >
xPolyPolygonFromB2DPolygon( const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XGraphicDevice >& xGraphicDevice,
const ::basegfx::B2DPolygon& rPoly );
- ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D >
+ BASEGFX_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XPolyPolygon2D >
xPolyPolygonFromB2DPolyPolygon( const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XGraphicDevice >& xGraphicDevice,
const ::basegfx::B2DPolyPolygon& rPolyPoly );
- ::com::sun::star::uno::Sequence<
+ BASEGFX_DLLPUBLIC ::com::sun::star::uno::Sequence<
::com::sun::star::uno::Sequence<
::com::sun::star::geometry::RealBezierSegment2D > >
bezierSequenceSequenceFromB2DPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPoly );
- ::com::sun::star::uno::Sequence<
+ BASEGFX_DLLPUBLIC ::com::sun::star::uno::Sequence<
::com::sun::star::uno::Sequence<
::com::sun::star::geometry::RealPoint2D > >
pointSequenceSequenceFromB2DPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPoly );
- ::basegfx::B2DPolygon polygonFromPoint2DSequence(
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon polygonFromPoint2DSequence(
const ::com::sun::star::uno::Sequence<
::com::sun::star::geometry::RealPoint2D >& rPoints );
- ::basegfx::B2DPolyPolygon polyPolygonFromPoint2DSequenceSequence(
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolyPolygon polyPolygonFromPoint2DSequenceSequence(
const ::com::sun::star::uno::Sequence<
::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealPoint2D > >& rPoints );
- ::basegfx::B2DPolygon polygonFromBezier2DSequence(
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon polygonFromBezier2DSequence(
const ::com::sun::star::uno::Sequence<
::com::sun::star::geometry::RealBezierSegment2D >& rPoints );
- ::basegfx::B2DPolyPolygon polyPolygonFromBezier2DSequenceSequence(
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolyPolygon polyPolygonFromBezier2DSequenceSequence(
const ::com::sun::star::uno::Sequence<
::com::sun::star::uno::Sequence< ::com::sun::star::geometry::RealBezierSegment2D > >& rPoints );
- ::basegfx::B2DPolyPolygon b2DPolyPolygonFromXPolyPolygon2D(
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolyPolygon b2DPolyPolygonFromXPolyPolygon2D(
const ::com::sun::star::uno::Reference<
::com::sun::star::rendering::XPolyPolygon2D >& rPoly );
// Matrix conversions
// ===================================================================
- ::com::sun::star::geometry::AffineMatrix2D&
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::AffineMatrix2D&
affineMatrixFromHomMatrix( ::com::sun::star::geometry::AffineMatrix2D& matrix,
const ::basegfx::B2DHomMatrix& transform);
- ::com::sun::star::geometry::AffineMatrix3D& affineMatrixFromHomMatrix3D(
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::AffineMatrix3D& affineMatrixFromHomMatrix3D(
::com::sun::star::geometry::AffineMatrix3D& matrix,
const ::basegfx::B3DHomMatrix& transform);
- ::basegfx::B2DHomMatrix&
+ BASEGFX_DLLPUBLIC ::basegfx::B2DHomMatrix&
homMatrixFromAffineMatrix( ::basegfx::B2DHomMatrix& transform,
const ::com::sun::star::geometry::AffineMatrix2D& matrix );
- ::basegfx::B2DHomMatrix homMatrixFromAffineMatrix( const ::com::sun::star::geometry::AffineMatrix2D& matrix );
- ::basegfx::B3DHomMatrix homMatrixFromAffineMatrix3D( const ::com::sun::star::geometry::AffineMatrix3D& matrix );
+ BASEGFX_DLLPUBLIC ::basegfx::B2DHomMatrix homMatrixFromAffineMatrix( const ::com::sun::star::geometry::AffineMatrix2D& matrix );
+ BASEGFX_DLLPUBLIC ::basegfx::B3DHomMatrix homMatrixFromAffineMatrix3D( const ::com::sun::star::geometry::AffineMatrix3D& matrix );
- ::com::sun::star::geometry::Matrix2D&
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::Matrix2D&
matrixFromHomMatrix( ::com::sun::star::geometry::Matrix2D& matrix,
const ::basegfx::B2DHomMatrix& transform);
- ::basegfx::B2DHomMatrix&
+ BASEGFX_DLLPUBLIC ::basegfx::B2DHomMatrix&
homMatrixFromMatrix( ::basegfx::B2DHomMatrix& transform,
const ::com::sun::star::geometry::Matrix2D& matrix );
// Geometry conversions
// ===================================================================
- ::com::sun::star::geometry::RealSize2D size2DFromB2DSize( const ::basegfx::B2DVector& );
- ::com::sun::star::geometry::RealPoint2D point2DFromB2DPoint( const ::basegfx::B2DPoint& );
- ::com::sun::star::geometry::RealRectangle2D rectangle2DFromB2DRectangle( const ::basegfx::B2DRange& );
- ::com::sun::star::geometry::RealRectangle3D rectangle3DFromB3DRectangle( const ::basegfx::B3DRange& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealSize2D size2DFromB2DSize( const ::basegfx::B2DVector& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealPoint2D point2DFromB2DPoint( const ::basegfx::B2DPoint& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealRectangle2D rectangle2DFromB2DRectangle( const ::basegfx::B2DRange& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::RealRectangle3D rectangle3DFromB3DRectangle( const ::basegfx::B3DRange& );
- ::basegfx::B2DVector b2DSizeFromRealSize2D( const ::com::sun::star::geometry::RealSize2D& );
- ::basegfx::B2DPoint b2DPointFromRealPoint2D( const ::com::sun::star::geometry::RealPoint2D& );
- ::basegfx::B2DRange b2DRectangleFromRealRectangle2D( const ::com::sun::star::geometry::RealRectangle2D& );
- ::basegfx::B3DRange b3DRectangleFromRealRectangle3D( const ::com::sun::star::geometry::RealRectangle3D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2DVector b2DSizeFromRealSize2D( const ::com::sun::star::geometry::RealSize2D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPoint b2DPointFromRealPoint2D( const ::com::sun::star::geometry::RealPoint2D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2DRange b2DRectangleFromRealRectangle2D( const ::com::sun::star::geometry::RealRectangle2D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B3DRange b3DRectangleFromRealRectangle3D( const ::com::sun::star::geometry::RealRectangle3D& );
- ::com::sun::star::geometry::IntegerSize2D integerSize2DFromB2ISize( const ::basegfx::B2IVector& );
- ::com::sun::star::geometry::IntegerPoint2D integerPoint2DFromB2IPoint( const ::basegfx::B2IPoint& );
- ::com::sun::star::geometry::IntegerRectangle2D integerRectangle2DFromB2IRectangle( const ::basegfx::B2IRange& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::IntegerSize2D integerSize2DFromB2ISize( const ::basegfx::B2IVector& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::IntegerPoint2D integerPoint2DFromB2IPoint( const ::basegfx::B2IPoint& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::geometry::IntegerRectangle2D integerRectangle2DFromB2IRectangle( const ::basegfx::B2IRange& );
- ::basegfx::B2IVector b2ISizeFromIntegerSize2D( const ::com::sun::star::geometry::IntegerSize2D& );
- ::basegfx::B2IPoint b2IPointFromIntegerPoint2D( const ::com::sun::star::geometry::IntegerPoint2D& );
- ::basegfx::B2IRange b2IRectangleFromIntegerRectangle2D( const ::com::sun::star::geometry::IntegerRectangle2D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IVector b2ISizeFromIntegerSize2D( const ::com::sun::star::geometry::IntegerSize2D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IPoint b2IPointFromIntegerPoint2D( const ::com::sun::star::geometry::IntegerPoint2D& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IRange b2IRectangleFromIntegerRectangle2D( const ::com::sun::star::geometry::IntegerRectangle2D& );
- ::com::sun::star::awt::Size awtSizeFromB2ISize( const ::basegfx::B2IVector& );
- ::com::sun::star::awt::Point awtPointFromB2IPoint( const ::basegfx::B2IPoint& );
- ::com::sun::star::awt::Rectangle awtRectangleFromB2IRectangle( const ::basegfx::B2IRange& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::awt::Size awtSizeFromB2ISize( const ::basegfx::B2IVector& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::awt::Point awtPointFromB2IPoint( const ::basegfx::B2IPoint& );
+ BASEGFX_DLLPUBLIC ::com::sun::star::awt::Rectangle awtRectangleFromB2IRectangle( const ::basegfx::B2IRange& );
- ::basegfx::B2IVector b2ISizeFromAwtSize( const ::com::sun::star::awt::Size& );
- ::basegfx::B2IPoint b2IPointFromAwtPoint( const ::com::sun::star::awt::Point& );
- ::basegfx::B2IRange b2IRectangleFromAwtRectangle( const ::com::sun::star::awt::Rectangle& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IVector b2ISizeFromAwtSize( const ::com::sun::star::awt::Size& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IPoint b2IPointFromAwtPoint( const ::com::sun::star::awt::Point& );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IRange b2IRectangleFromAwtRectangle( const ::com::sun::star::awt::Rectangle& );
// Geometry comparisons
// ===================================================================
- bool RealSize2DAreEqual( const ::com::sun::star::geometry::RealSize2D& rA, const ::com::sun::star::geometry::RealSize2D& rB );
- bool RealPoint2DAreEqual( const ::com::sun::star::geometry::RealPoint2D& rA, const ::com::sun::star::geometry::RealPoint2D& rB );
- bool RealRectangle2DAreEqual( const ::com::sun::star::geometry::RealRectangle2D& rA, const ::com::sun::star::geometry::RealRectangle2D& rB );
- bool RealRectangle3DAreEqual( const ::com::sun::star::geometry::RealRectangle3D& rA, const ::com::sun::star::geometry::RealRectangle3D& rB );
- bool AffineMatrix2DAreEqual( const ::com::sun::star::geometry::AffineMatrix2D& rA, const ::com::sun::star::geometry::AffineMatrix2D& rB );
+ BASEGFX_DLLPUBLIC bool RealSize2DAreEqual( const ::com::sun::star::geometry::RealSize2D& rA, const ::com::sun::star::geometry::RealSize2D& rB );
+ BASEGFX_DLLPUBLIC bool RealPoint2DAreEqual( const ::com::sun::star::geometry::RealPoint2D& rA, const ::com::sun::star::geometry::RealPoint2D& rB );
+ BASEGFX_DLLPUBLIC bool RealRectangle2DAreEqual( const ::com::sun::star::geometry::RealRectangle2D& rA, const ::com::sun::star::geometry::RealRectangle2D& rB );
+ BASEGFX_DLLPUBLIC bool RealRectangle3DAreEqual( const ::com::sun::star::geometry::RealRectangle3D& rA, const ::com::sun::star::geometry::RealRectangle3D& rB );
+ BASEGFX_DLLPUBLIC bool AffineMatrix2DAreEqual( const ::com::sun::star::geometry::AffineMatrix2D& rA, const ::com::sun::star::geometry::AffineMatrix2D& rB );
- bool IntegerSize2DAreEqual( const ::com::sun::star::geometry::IntegerSize2D& rA, const ::com::sun::star::geometry::IntegerSize2D& rB );
- bool IntegerPoint2DAreEqual( const ::com::sun::star::geometry::IntegerPoint2D& rA, const ::com::sun::star::geometry::IntegerPoint2D& rB );
- bool IntegerRectangle2DAreEqual( const ::com::sun::star::geometry::IntegerRectangle2D& rA, const ::com::sun::star::geometry::IntegerRectangle2D& rB );
+ BASEGFX_DLLPUBLIC bool IntegerSize2DAreEqual( const ::com::sun::star::geometry::IntegerSize2D& rA, const ::com::sun::star::geometry::IntegerSize2D& rB );
+ BASEGFX_DLLPUBLIC bool IntegerPoint2DAreEqual( const ::com::sun::star::geometry::IntegerPoint2D& rA, const ::com::sun::star::geometry::IntegerPoint2D& rB );
+ BASEGFX_DLLPUBLIC bool IntegerRectangle2DAreEqual( const ::com::sun::star::geometry::IntegerRectangle2D& rA, const ::com::sun::star::geometry::IntegerRectangle2D& rB );
- bool awtSizeAreEqual( const ::com::sun::star::awt::Size& rA, const ::com::sun::star::awt::Size& rB );
- bool awtPointAreEqual( const ::com::sun::star::awt::Point& rA, const ::com::sun::star::awt::Point& rB );
- bool awtRectangleAreEqual( const ::com::sun::star::awt::Rectangle& rA, const ::com::sun::star::awt::Rectangle& rB );
+ BASEGFX_DLLPUBLIC bool awtSizeAreEqual( const ::com::sun::star::awt::Size& rA, const ::com::sun::star::awt::Size& rB );
+ BASEGFX_DLLPUBLIC bool awtPointAreEqual( const ::com::sun::star::awt::Point& rA, const ::com::sun::star::awt::Point& rB );
+ BASEGFX_DLLPUBLIC bool awtRectangleAreEqual( const ::com::sun::star::awt::Rectangle& rA, const ::com::sun::star::awt::Rectangle& rB );
/** Return smalltest integer range, which completely contains
given floating point range.
@@ -202,7 +203,7 @@ namespace basegfx
@return the closest integer range, which completely
contains rRange.
*/
- ::basegfx::B2IRange b2ISurroundingRangeFromB2DRange( const ::basegfx::B2DRange& rRange );
+ BASEGFX_DLLPUBLIC ::basegfx::B2IRange b2ISurroundingRangeFromB2DRange( const ::basegfx::B2DRange& rRange );
/** Return smalltest B2DRange with integer values, which
completely contains given floating point range.
@@ -213,7 +214,7 @@ namespace basegfx
@return the closest B2DRange with integer coordinates,
which completely contains rRange.
*/
- ::basegfx::B2DRange b2DSurroundingIntegerRangeFromB2DRange( const ::basegfx::B2DRange& rRange );
+ BASEGFX_DLLPUBLIC ::basegfx::B2DRange b2DSurroundingIntegerRangeFromB2DRange( const ::basegfx::B2DRange& rRange );
}
}
diff --git a/basegfx/inc/basegfx/tools/debugplotter.hxx b/basegfx/inc/basegfx/tools/debugplotter.hxx
index ece104af3553..9070efd1d9f2 100644
--- a/basegfx/inc/basegfx/tools/debugplotter.hxx
+++ b/basegfx/inc/basegfx/tools/debugplotter.hxx
@@ -38,6 +38,7 @@
#include <vector>
#include <utility>
#include <iostream>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -54,7 +55,7 @@ namespace basegfx
To be able to generate one coherent block of output, this
class delays actual writing to its destructor
*/
- class DebugPlotter : private ::boost::noncopyable
+ class BASEGFX_DLLPUBLIC DebugPlotter : private ::boost::noncopyable
{
public:
/** Create new debug output object
diff --git a/basegfx/inc/basegfx/tools/gradienttools.hxx b/basegfx/inc/basegfx/tools/gradienttools.hxx
index 2f436fa1d717..6894aa2ff3ce 100644
--- a/basegfx/inc/basegfx/tools/gradienttools.hxx
+++ b/basegfx/inc/basegfx/tools/gradienttools.hxx
@@ -33,6 +33,7 @@
#include <basegfx/vector/b2dvector.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/basegfxdllapi.h>
#include <vector>
#include <algorithm>
@@ -45,7 +46,7 @@ namespace basegfx
1.2-compatible gradients. Use the createXXXODFGradientInfo()
methods below for initializing from ODF attributes.
*/
- struct ODFGradientInfo
+ struct BASEGFX_DLLPUBLIC ODFGradientInfo
{
/** transformation mapping from [0,1]^2 texture coordinate
space to [0,1]^2 shape coordinate space
@@ -97,7 +98,7 @@ namespace basegfx
@param fAngle
Gradient angle (from ODF)
*/
- ODFGradientInfo& createLinearODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
+ BASEGFX_DLLPUBLIC ODFGradientInfo& createLinearODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
const B2DRange& rTargetArea,
sal_uInt32 nSteps,
double fBorder,
@@ -156,7 +157,7 @@ namespace basegfx
@param fAngle
Gradient angle (from ODF)
*/
- ODFGradientInfo& createAxialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
+ BASEGFX_DLLPUBLIC ODFGradientInfo& createAxialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
const B2DRange& rTargetArea,
sal_uInt32 nSteps,
double fBorder,
@@ -211,7 +212,7 @@ namespace basegfx
@param fAngle
Gradient angle (from ODF)
*/
- ODFGradientInfo& createRadialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
+ BASEGFX_DLLPUBLIC ODFGradientInfo& createRadialODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
const B2DRange& rTargetArea,
const B2DVector& rOffset,
sal_uInt32 nSteps,
@@ -270,7 +271,7 @@ namespace basegfx
@param fAngle
Gradient angle (from ODF)
*/
- ODFGradientInfo& createEllipticalODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
+ BASEGFX_DLLPUBLIC ODFGradientInfo& createEllipticalODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
const B2DRange& rTargetArea,
const B2DVector& rOffset,
sal_uInt32 nSteps,
@@ -318,7 +319,7 @@ namespace basegfx
@param fAngle
Gradient angle (from ODF)
*/
- ODFGradientInfo& createSquareODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
+ BASEGFX_DLLPUBLIC ODFGradientInfo& createSquareODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
const B2DRange& rTargetArea,
const B2DVector& rOffset,
sal_uInt32 nSteps,
@@ -379,7 +380,7 @@ namespace basegfx
@param fAngle
Gradient angle (from ODF)
*/
- ODFGradientInfo& createRectangularODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
+ BASEGFX_DLLPUBLIC ODFGradientInfo& createRectangularODFGradientInfo(ODFGradientInfo& o_rGradientInfo,
const B2DRange& rTargetArea,
const B2DVector& rOffset,
sal_uInt32 nSteps,
diff --git a/basegfx/inc/basegfx/tools/keystoplerp.hxx b/basegfx/inc/basegfx/tools/keystoplerp.hxx
index a54b3485b1a1..e1cd1fe12f5d 100644
--- a/basegfx/inc/basegfx/tools/keystoplerp.hxx
+++ b/basegfx/inc/basegfx/tools/keystoplerp.hxx
@@ -33,6 +33,7 @@
#include <basegfx/numeric/ftools.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace com{ namespace sun{ namespace star{ namespace uno {
template<typename T> class Sequence;
@@ -53,7 +54,7 @@ namespace basegfx
then calculate the relative alpha between the two buckets
found.
*/
- class KeyStopLerp
+ class BASEGFX_DLLPUBLIC KeyStopLerp
{
public:
typedef std::pair<std::ptrdiff_t,double> ResultType;
diff --git a/basegfx/inc/basegfx/tools/tools.hxx b/basegfx/inc/basegfx/tools/tools.hxx
index 896fd22c162d..d7c10b4bf9ac 100644
--- a/basegfx/inc/basegfx/tools/tools.hxx
+++ b/basegfx/inc/basegfx/tools/tools.hxx
@@ -29,6 +29,7 @@
#define _BGFX_TOOLS_TOOLS_HXX
#include <sal/types.h>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -57,7 +58,7 @@ namespace basegfx
@return true, when at least part of the line is visible
after the clip, false otherwise
*/
- bool liangBarskyClip2D( ::basegfx::B2DPoint& io_rStart,
+ BASEGFX_DLLPUBLIC bool liangBarskyClip2D( ::basegfx::B2DPoint& io_rStart,
::basegfx::B2DPoint& io_rEnd,
const ::basegfx::B2DRange& rClipRect );
@@ -119,7 +120,7 @@ namespace basegfx
@param rFitTarget
The rectangle to fit the parallelogram into.
*/
- void infiniteLineFromParallelogram( ::basegfx::B2DPoint& io_rLeftTop,
+ BASEGFX_DLLPUBLIC void infiniteLineFromParallelogram( ::basegfx::B2DPoint& io_rLeftTop,
::basegfx::B2DPoint& io_rLeftBottom,
::basegfx::B2DPoint& io_rRightTop,
::basegfx::B2DPoint& io_rRightBottom,
diff --git a/basegfx/inc/basegfx/tools/unopolypolygon.hxx b/basegfx/inc/basegfx/tools/unopolypolygon.hxx
index 8a4044e1ca4b..ab7afe42b135 100755
--- a/basegfx/inc/basegfx/tools/unopolypolygon.hxx
+++ b/basegfx/inc/basegfx/tools/unopolypolygon.hxx
@@ -35,6 +35,7 @@
#include <com/sun/star/rendering/XLinePolyPolygon2D.hpp>
#include <com/sun/star/rendering/XBezierPolyPolygon2D.hpp>
#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -46,7 +47,7 @@ namespace unotools
::com::sun::star::rendering::XBezierPolyPolygon2D,
::com::sun::star::lang::XServiceInfo > UnoPolyPolygonBase;
- class UnoPolyPolygon : private cppu::BaseMutex,
+ class BASEGFX_DLLPUBLIC UnoPolyPolygon : private cppu::BaseMutex,
public UnoPolyPolygonBase
{
public:
diff --git a/basegfx/inc/basegfx/tuple/b2dtuple.hxx b/basegfx/inc/basegfx/tuple/b2dtuple.hxx
index 71dd227ac736..18e3f5c7117a 100644
--- a/basegfx/inc/basegfx/tuple/b2dtuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b2dtuple.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -44,7 +45,7 @@ namespace basegfx
@derive Use this class to implement Points or Vectors
which are based on two double values
*/
- class B2DTuple
+ class BASEGFX_DLLPUBLIC B2DTuple
{
protected:
double mfX;
@@ -353,7 +354,7 @@ namespace basegfx
@return the nearest integer for this tuple
*/
- B2ITuple fround(const B2DTuple& rTup);
+ BASEGFX_DLLPUBLIC B2ITuple fround(const B2DTuple& rTup);
} // end of namespace basegfx
#endif /* _BGFX_TUPLE_B2DTUPLE_HXX */
diff --git a/basegfx/inc/basegfx/tuple/b2i64tuple.hxx b/basegfx/inc/basegfx/tuple/b2i64tuple.hxx
index 9c813c07a994..12830b175a36 100644
--- a/basegfx/inc/basegfx/tuple/b2i64tuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b2i64tuple.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <basegfx/tuple/b2dtuple.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -42,7 +43,7 @@ namespace basegfx
@derive Use this class to implement Points or Vectors
which are based on two sal_Int64 values
*/
- class B2I64Tuple
+ class BASEGFX_DLLPUBLIC B2I64Tuple
{
protected:
sal_Int64 mnX;
diff --git a/basegfx/inc/basegfx/tuple/b2ituple.hxx b/basegfx/inc/basegfx/tuple/b2ituple.hxx
index da29b5509dec..1e5f1969ff92 100644
--- a/basegfx/inc/basegfx/tuple/b2ituple.hxx
+++ b/basegfx/inc/basegfx/tuple/b2ituple.hxx
@@ -29,7 +29,7 @@
#define _BGFX_TUPLE_B2ITUPLE_HXX
#include <sal/types.h>
-
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -41,7 +41,7 @@ namespace basegfx
@derive Use this class to implement Points or Vectors
which are based on two sal_Int32 values
*/
- class B2ITuple
+ class BASEGFX_DLLPUBLIC B2ITuple
{
protected:
sal_Int32 mnX;
@@ -204,33 +204,33 @@ namespace basegfx
class B2DTuple;
- B2ITuple minimum(const B2ITuple& rTupA, const B2ITuple& rTupB);
+ BASEGFX_DLLPUBLIC B2ITuple minimum(const B2ITuple& rTupA, const B2ITuple& rTupB);
- B2ITuple maximum(const B2ITuple& rTupA, const B2ITuple& rTupB);
+ BASEGFX_DLLPUBLIC B2ITuple maximum(const B2ITuple& rTupA, const B2ITuple& rTupB);
- B2ITuple absolute(const B2ITuple& rTup);
+ BASEGFX_DLLPUBLIC B2ITuple absolute(const B2ITuple& rTup);
- B2DTuple interpolate(const B2ITuple& rOld1, const B2ITuple& rOld2, double t);
+ BASEGFX_DLLPUBLIC B2DTuple interpolate(const B2ITuple& rOld1, const B2ITuple& rOld2, double t);
- B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2);
+ BASEGFX_DLLPUBLIC B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2);
- B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2, const B2ITuple& rOld3);
+ BASEGFX_DLLPUBLIC B2DTuple average(const B2ITuple& rOld1, const B2ITuple& rOld2, const B2ITuple& rOld3);
- B2ITuple operator+(const B2ITuple& rTupA, const B2ITuple& rTupB);
+ BASEGFX_DLLPUBLIC B2ITuple operator+(const B2ITuple& rTupA, const B2ITuple& rTupB);
- B2ITuple operator-(const B2ITuple& rTupA, const B2ITuple& rTupB);
+ BASEGFX_DLLPUBLIC B2ITuple operator-(const B2ITuple& rTupA, const B2ITuple& rTupB);
- B2ITuple operator/(const B2ITuple& rTupA, const B2ITuple& rTupB);
+ BASEGFX_DLLPUBLIC B2ITuple operator/(const B2ITuple& rTupA, const B2ITuple& rTupB);
- B2ITuple operator*(const B2ITuple& rTupA, const B2ITuple& rTupB);
+ BASEGFX_DLLPUBLIC B2ITuple operator*(const B2ITuple& rTupA, const B2ITuple& rTupB);
- B2ITuple operator*(const B2ITuple& rTup, sal_Int32 t);
+ BASEGFX_DLLPUBLIC B2ITuple operator*(const B2ITuple& rTup, sal_Int32 t);
- B2ITuple operator*(sal_Int32 t, const B2ITuple& rTup);
+ BASEGFX_DLLPUBLIC B2ITuple operator*(sal_Int32 t, const B2ITuple& rTup);
- B2ITuple operator/(const B2ITuple& rTup, sal_Int32 t);
+ BASEGFX_DLLPUBLIC B2ITuple operator/(const B2ITuple& rTup, sal_Int32 t);
- B2ITuple operator/(sal_Int32 t, const B2ITuple& rTup);
+ BASEGFX_DLLPUBLIC B2ITuple operator/(sal_Int32 t, const B2ITuple& rTup);
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/tuple/b3dtuple.hxx b/basegfx/inc/basegfx/tuple/b3dtuple.hxx
index 11fb797ff0ff..f0947c227612 100644
--- a/basegfx/inc/basegfx/tuple/b3dtuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3dtuple.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -44,7 +45,7 @@ namespace basegfx
@derive Use this class to implement Points or Vectors
which are based on three double values
*/
- class B3DTuple
+ class BASEGFX_DLLPUBLIC B3DTuple
{
protected:
double mfX;
@@ -427,7 +428,7 @@ namespace basegfx
@return the nearest integer for this tuple
*/
- B3ITuple fround(const B3DTuple& rTup);
+ BASEGFX_DLLPUBLIC B3ITuple fround(const B3DTuple& rTup);
} // end of namespace basegfx
#endif /* _BGFX_TUPLE_B3DTUPLE_HXX */
diff --git a/basegfx/inc/basegfx/tuple/b3i64tuple.hxx b/basegfx/inc/basegfx/tuple/b3i64tuple.hxx
index a2d754fe4f79..a4e6de8e02f7 100644
--- a/basegfx/inc/basegfx/tuple/b3i64tuple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3i64tuple.hxx
@@ -30,6 +30,7 @@
#include <sal/types.h>
#include <basegfx/tuple/b3dtuple.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -42,7 +43,7 @@ namespace basegfx
@derive Use this class to implement Points or Vectors
which are based on three sal_Int64 values
*/
- class B3I64Tuple
+ class BASEGFX_DLLPUBLIC B3I64Tuple
{
protected:
sal_Int64 mnX;
diff --git a/basegfx/inc/basegfx/tuple/b3ituple.hxx b/basegfx/inc/basegfx/tuple/b3ituple.hxx
index 644ae07b6545..4de03f5f1227 100644
--- a/basegfx/inc/basegfx/tuple/b3ituple.hxx
+++ b/basegfx/inc/basegfx/tuple/b3ituple.hxx
@@ -30,7 +30,7 @@
#include <sal/types.h>
#include <basegfx/tuple/b3dtuple.hxx>
-
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -42,7 +42,7 @@ namespace basegfx
@derive Use this class to implement Points or Vectors
which are based on three sal_Int32 values
*/
- class B3ITuple
+ class BASEGFX_DLLPUBLIC B3ITuple
{
protected:
sal_Int32 mnX;
diff --git a/basegfx/inc/basegfx/vector/b2dvector.hxx b/basegfx/inc/basegfx/vector/b2dvector.hxx
index e4cd8f3f179a..60c600d3f9f5 100644
--- a/basegfx/inc/basegfx/vector/b2dvector.hxx
+++ b/basegfx/inc/basegfx/vector/b2dvector.hxx
@@ -31,6 +31,7 @@
#include <basegfx/tuple/b2dtuple.hxx>
#include <basegfx/vector/b2ivector.hxx>
#include <basegfx/vector/b2enums.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -45,7 +46,7 @@ namespace basegfx
@see B2DTuple
*/
- class B2DVector : public ::basegfx::B2DTuple
+ class BASEGFX_DLLPUBLIC B2DVector : public ::basegfx::B2DTuple
{
public:
/** Create a 2D Vector
@@ -209,7 +210,7 @@ namespace basegfx
@return
The mathematical Orientation of the two involved 2D Vectors
*/
- B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB );
+ BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation( const B2DVector& rVecA, const B2DVector& rVecB );
/** Calculate a perpendicular 2D Vector to the given one
@@ -221,7 +222,7 @@ namespace basegfx
@return
A 2D Vector perpendicular to the one given in parameter rVec
*/
- B2DVector getPerpendicular( const B2DVector& rNormalizedVec );
+ BASEGFX_DLLPUBLIC B2DVector getPerpendicular( const B2DVector& rNormalizedVec );
/** Calculate a perpendicular 2D Vector to the given one,
normalize the given one as preparation
@@ -232,7 +233,7 @@ namespace basegfx
@return
A normalized 2D Vector perpendicular to the one given in parameter rVec
*/
- B2DVector getNormalizedPerpendicular( const B2DVector& rVec );
+ BASEGFX_DLLPUBLIC B2DVector getNormalizedPerpendicular( const B2DVector& rVec );
/** Test two vectors which need not to be normalized for parallelism
@@ -246,21 +247,21 @@ namespace basegfx
bool if the two values are parallel. Also true if
one of the vectors is empty.
*/
- bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB );
+ BASEGFX_DLLPUBLIC bool areParallel( const B2DVector& rVecA, const B2DVector& rVecB );
/** Transform vector by given transformation matrix.
Since this is a vector, translational components of the
matrix are disregarded.
*/
- B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec );
+ BASEGFX_DLLPUBLIC B2DVector operator*( const B2DHomMatrix& rMat, const B2DVector& rVec );
/** Test continuity between given vectors.
The two given vectors are assumed to describe control points on a
common point. Calculate if there is a continuity between them.
*/
- B2VectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector );
+ BASEGFX_DLLPUBLIC B2VectorContinuity getContinuity( const B2DVector& rBackVector, const B2DVector& rForwardVector );
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/vector/b2ivector.hxx b/basegfx/inc/basegfx/vector/b2ivector.hxx
index 9e2fe1009841..ebc81f83b51a 100644
--- a/basegfx/inc/basegfx/vector/b2ivector.hxx
+++ b/basegfx/inc/basegfx/vector/b2ivector.hxx
@@ -30,6 +30,7 @@
#include <basegfx/tuple/b2ituple.hxx>
#include <basegfx/vector/b2enums.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -44,7 +45,7 @@ namespace basegfx
@see B2ITuple
*/
- class B2IVector : public ::basegfx::B2ITuple
+ class BASEGFX_DLLPUBLIC B2IVector : public ::basegfx::B2ITuple
{
public:
/** Create a 2D Vector
@@ -185,7 +186,7 @@ namespace basegfx
@return
The mathematical Orientation of the two involved 2D Vectors
*/
- B2VectorOrientation getOrientation( const B2IVector& rVecA, const B2IVector& rVecB );
+ BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation( const B2IVector& rVecA, const B2IVector& rVecB );
/** Calculate a perpendicular 2D Vector to the given one
@@ -195,7 +196,7 @@ namespace basegfx
@return
A 2D Vector perpendicular to the one given in parameter rVec
*/
- B2IVector getPerpendicular( const B2IVector& rVec );
+ BASEGFX_DLLPUBLIC B2IVector getPerpendicular( const B2IVector& rVec );
/** Test two vectors which need not to be normalized for parallelism
@@ -209,21 +210,21 @@ namespace basegfx
bool if the two values are parallel. Also true if
one of the vectors is empty.
*/
- bool areParallel( const B2IVector& rVecA, const B2IVector& rVecB );
+ BASEGFX_DLLPUBLIC bool areParallel( const B2IVector& rVecA, const B2IVector& rVecB );
/** Transform vector by given transformation matrix.
Since this is a vector, translational components of the
matrix are disregarded.
*/
- B2IVector operator*( const B2DHomMatrix& rMat, const B2IVector& rVec );
+ BASEGFX_DLLPUBLIC B2IVector operator*( const B2DHomMatrix& rMat, const B2IVector& rVec );
/** Test continuity between given vectors.
The two given vectors are assumed to describe control points on a
common point. Calculate if there is a continuity between them.
*/
- B2VectorContinuity getContinuity( const B2IVector& rBackVector, const B2IVector& rForwardVector );
+ BASEGFX_DLLPUBLIC B2VectorContinuity getContinuity( const B2IVector& rBackVector, const B2IVector& rForwardVector );
} // end of namespace basegfx
diff --git a/basegfx/inc/basegfx/vector/b3dvector.hxx b/basegfx/inc/basegfx/vector/b3dvector.hxx
index c4c329881170..790343c14032 100644
--- a/basegfx/inc/basegfx/vector/b3dvector.hxx
+++ b/basegfx/inc/basegfx/vector/b3dvector.hxx
@@ -29,6 +29,7 @@
#define _BGFX_VECTOR_B3DVECTOR_HXX
#include <basegfx/tuple/b3dtuple.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -45,7 +46,7 @@ namespace basegfx
@see B3DTuple
*/
- class B3DVector : public ::basegfx::B3DTuple
+ class BASEGFX_DLLPUBLIC B3DVector : public ::basegfx::B3DTuple
{
public:
/** Create a 3D Vector
@@ -305,14 +306,14 @@ namespace basegfx
bool if the two values are parallel. Also true if
one of the vectors is empty.
*/
- bool areParallel( const B3DVector& rVecA, const B3DVector& rVecB );
+ BASEGFX_DLLPUBLIC bool areParallel( const B3DVector& rVecA, const B3DVector& rVecB );
/** Transform vector by given transformation matrix.
Since this is a vector, translational components of the
matrix are disregarded.
*/
- B3DVector operator*( const B3DHomMatrix& rMat, const B3DVector& rVec );
+ BASEGFX_DLLPUBLIC B3DVector operator*( const B3DHomMatrix& rMat, const B3DVector& rVec );
/** Calculate the Cross Product of two 3D Vectors
diff --git a/basegfx/inc/basegfx/vector/b3ivector.hxx b/basegfx/inc/basegfx/vector/b3ivector.hxx
index b4900989cc06..367da44ac3e9 100644
--- a/basegfx/inc/basegfx/vector/b3ivector.hxx
+++ b/basegfx/inc/basegfx/vector/b3ivector.hxx
@@ -29,6 +29,7 @@
#define _BGFX_VECTOR_B3IVECTOR_HXX
#include <basegfx/tuple/b3ituple.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -43,7 +44,7 @@ namespace basegfx
@see B3ITuple
*/
- class B3IVector : public ::basegfx::B3ITuple
+ class BASEGFX_DLLPUBLIC B3IVector : public ::basegfx::B3ITuple
{
public:
/** Create a 3D Vector
@@ -233,7 +234,7 @@ namespace basegfx
Since this is a vector, translational components of the
matrix are disregarded.
*/
- B3IVector operator*( const B3DHomMatrix& rMat, const B3IVector& rVec );
+ BASEGFX_DLLPUBLIC B3IVector operator*( const B3DHomMatrix& rMat, const B3IVector& rVec );
/** Calculate the Cross Product of two 3D Vectors