You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by da...@apache.org on 2016/08/07 19:24:15 UTC
svn commit: r1755455 [3/18] - in /openoffice/trunk: ./
ext_libraries/apr-util/ ext_libraries/gtest/win/
ext_libraries/ratscan/scan/ ext_libraries/serf/win/ main/
main/UnoControls/prj/ main/accessibility/prj/ main/animations/prj/
main/basctl/source/dlge...
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontools.hxx Sun Aug 7 19:24:03 2016
@@ -32,6 +32,7 @@
#include <com/sun/star/drawing/PointSequence.hpp>
#include <com/sun/star/drawing/FlagSequence.hpp>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -46,8 +47,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.
@@ -58,20 +59,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
@@ -83,7 +84,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
@@ -96,53 +97,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;
@@ -159,7 +160,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,
@@ -167,7 +168,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,
@@ -175,7 +176,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,
@@ -184,7 +185,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,
@@ -223,24 +224,24 @@ 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,
- B2DPolyPolygon* pGapTarget = 0,
+ B2DPolyPolygon* pGapTarget = 0,
double fFullDashDotLen = 0.0);
// 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 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.
@@ -251,7 +252,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.
@@ -263,15 +264,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.
@@ -285,7 +286,7 @@ namespace basegfx
@param fRadius
Radius of the circle
*/
- B2DPolygon createPolygonFromCircle( const B2DPoint& rCenter, double fRadius );
+ BASEGFX_DLLPUBLIC B2DPolygon createPolygonFromCircle( const B2DPoint& rCenter, double fRadius );
/// create half circle centered on (0,0) from [0 .. F_PI]
B2DPolygon createHalfUnitCircle();
@@ -300,7 +301,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.
@@ -317,13 +318,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.
@@ -335,111 +336,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);
+ BASEGFX_DLLPUBLIC 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
@@ -469,7 +470,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
@@ -486,7 +487,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
@@ -508,12 +509,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
@@ -527,37 +528,37 @@ namespace basegfx
@return
The modified version of the source polygon
*/
- B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolygon& rCandidate);
/** returns true if the Polygon only contains horizontal or vertical edges
so that it could be represented by RegionBands
*/
- bool containsOnlyHorizontalAndVerticalEdges(const B2DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC bool containsOnlyHorizontalAndVerticalEdges(const B2DPolygon& rCandidate);
/// get the tangent with which the given point is entered seen from the previous
/// polygon path data. Take into account all stuff like closed state, zero-length edges and others.
- B2DVector getTangentEnteringPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
+ BASEGFX_DLLPUBLIC B2DVector getTangentEnteringPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
/// get the tangent with which the given point is left seen from the following
/// polygon path data. Take into account all stuff like closed state, zero-length edges and others.
- B2DVector getTangentLeavingPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
+ BASEGFX_DLLPUBLIC B2DVector getTangentLeavingPoint(const B2DPolygon& rCandidate, sal_uInt32 nIndex);
/// converters for com::sun::star::drawing::PointSequence
- B2DPolygon UnoPointSequenceToB2DPolygon(
+ BASEGFX_DLLPUBLIC B2DPolygon UnoPointSequenceToB2DPolygon(
const com::sun::star::drawing::PointSequence& rPointSequenceSource,
bool bCheckClosed = true);
- void B2DPolygonToUnoPointSequence(
+ BASEGFX_DLLPUBLIC void B2DPolygonToUnoPointSequence(
const B2DPolygon& rPolygon,
com::sun::star::drawing::PointSequence& rPointSequenceRetval);
/* converters for com::sun::star::drawing::PointSequence and
com::sun::star::drawing::FlagSequence to B2DPolygon (curved polygons)
*/
- B2DPolygon UnoPolygonBezierCoordsToB2DPolygon(
+ BASEGFX_DLLPUBLIC B2DPolygon UnoPolygonBezierCoordsToB2DPolygon(
const com::sun::star::drawing::PointSequence& rPointSequenceSource,
const com::sun::star::drawing::FlagSequence& rFlagSequenceSource,
bool bCheckClosed = true);
- void B2DPolygonToUnoPolygonBezierCoords(
+ BASEGFX_DLLPUBLIC void B2DPolygonToUnoPolygonBezierCoords(
const B2DPolygon& rPolyPolygon,
com::sun::star::drawing::PointSequence& rPointSequenceRetval,
com::sun::star::drawing::FlagSequence& rFlagSequenceRetval);
@@ -576,7 +577,7 @@ 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 );
/** Write poly-polygon to SVG.
@@ -592,7 +593,7 @@ namespace basegfx
@return true, if the string was successfully parsed
*/
- ::rtl::OUString exportToSvgPoints( const B2DPolygon& rPoly );
+ BASEGFX_DLLPUBLIC ::rtl::OUString exportToSvgPoints( const B2DPolygon& rPoly );
} // end of namespace tools
} // end of namespace basegfx
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolygontriangulator.hxx Sun Aug 7 19:24:03 2016
@@ -26,6 +26,7 @@
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -34,10 +35,10 @@ namespace basegfx
namespace triangulator
{
// triangulate given polygon
- ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolygon& rCandidate);
// triangulate given PolyPolygon
- ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC ::basegfx::B2DPolygon triangulate(const ::basegfx::B2DPolyPolygon& rCandidate);
} // end of namespace triangulator
} // end of namespace basegfx
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygon.hxx Sun Aug 7 19:24:03 2016
@@ -27,6 +27,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
#include <basegfx/range/b2drange.hxx>
+#include <basegfx/basegfxdllapi.h>
// predeclarations
class ImplB2DPolyPolygon;
@@ -41,7 +42,7 @@ namespace basegfx
namespace basegfx
{
- class B2DPolyPolygon
+ class BASEGFX_DLLPUBLIC B2DPolyPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB2DPolyPolygon > ImplType;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygoncutter.hxx Sun Aug 7 19:24:03 2016
@@ -25,6 +25,7 @@
#define _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -39,18 +40,18 @@ namespace basegfx
// Self crossovers of the contained sub-polygons are implicitely handled, but to not lose
// the topological information, it may be necessary to remove self-intersections of the
// contained sub-polygons in a preparing step and to explicitely correct their orientations.
- B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolyPolygon& rCandidate);
// Version for single polygons. This is for solving self-intersections. Result will be free of
// crossovers. When result contains multiple polygons, it may be necessary to rearrange their
// orientations since holes may have been created (use correctOrientations eventually).
- B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solveCrossovers(const B2DPolygon& rCandidate);
// Neutral polygons will be stripped. Neutral polygons are ones who's orientation is
// neutral, so normally they have no volume -> just closed paths. A polygon with the same
// positive and negative oriented volume is also neutral, so this may not be wanted. It is
// safe to call with crossover-free polygons, though (that's where it's mostly used).
- B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon stripNeutralPolygons(const B2DPolyPolygon& rCandidate);
// Remove not necessary polygons. Works only correct with crossover-free polygons. For each
// polygon, the depth for the PolyPolygon is calculated. The orientation is used to identify holes.
@@ -63,14 +64,14 @@ namespace basegfx
// one polygon to another and use this mode -> only parts where two polygons overlapped will be kept.
// In combination with correct orientation of the input orientations and the SolveCrossover calls this
// can be combined for logical polygon operations or polygon clipping.
- B2DPolyPolygon stripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon stripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false);
// geometrically convert PolyPolygons which are proposed to use nonzero fill rule
// to a representation where evenodd paint will give the same result. To do this
// all intersections and self-intersections get solved (the polygons will be rearranged
// if needed). Then all polygons which are inside another one with the same orientation
// get deleted
- B2DPolyPolygon createNonzeroConform(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon createNonzeroConform(const B2DPolyPolygon& rCandidate);
// For convenience: The four basic operations OR, XOR, AND and DIFF for
// two PolyPolygons. These are combinations of the above methods. To not be forced
@@ -89,20 +90,20 @@ namespace basegfx
// Preparations: solve self-intersections and intersections, remove neutral
// parts and correct orientations.
- B2DPolyPolygon prepareForPolygonOperation(const B2DPolygon& rCandidate);
- B2DPolyPolygon prepareForPolygonOperation(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon prepareForPolygonOperation(const B2DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon prepareForPolygonOperation(const B2DPolyPolygon& rCandidate);
// OR: Return all areas where CandidateA or CandidateB exist
- B2DPolyPolygon solvePolygonOperationOr(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationOr(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
// XOR: Return all areas where CandidateA or CandidateB exist, but not both
- B2DPolyPolygon solvePolygonOperationXor(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationXor(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
// AND: Return all areas where CandidateA and CandidateB exist
- B2DPolyPolygon solvePolygonOperationAnd(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationAnd(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
// DIFF: Return all areas where CandidateA is not covered by CandidateB (cut B out of A)
- B2DPolyPolygon solvePolygonOperationDiff(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon solvePolygonOperationDiff(const B2DPolyPolygon& rCandidateA, const B2DPolyPolygon& rCandidateB);
/** merge all single PolyPolygons to a single, OR-ed PolyPolygon
@@ -111,7 +112,7 @@ namespace basegfx
@return A single PolyPolygon containing the Or-merged result
*/
- B2DPolyPolygon mergeToSinglePolyPolygon(const B2DPolyPolygonVector& rInput);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon mergeToSinglePolyPolygon(const B2DPolyPolygonVector& rInput);
} // end of namespace tools
} // end of namespace basegfx
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygonrasterconverter.hxx Sun Aug 7 19:24:03 2016
@@ -30,6 +30,7 @@
#include <basegfx/polygon/b2dpolypolygonfillrule.hxx>
#include <vector>
#include <utility>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -44,7 +45,7 @@ namespace basegfx
@derive
Overwrite span() with the render output method of your choice.
*/
- class B2DPolyPolygonRasterConverter
+ class BASEGFX_DLLPUBLIC B2DPolyPolygonRasterConverter
{
public:
/** Create raster-converter for given poly-polygon
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dpolypolygontools.hxx Sun Aug 7 19:24:03 2016
@@ -30,6 +30,7 @@
#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
#include <vector>
#include <set>
+#include <basegfx/basegfxdllapi.h>
namespace rtl
{
@@ -51,27 +52,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.
@@ -84,7 +85,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
@@ -97,19 +98,19 @@ namespace basegfx
@return
The outer range of the polygon
*/
- B2DRange getRange(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DRange getRange(const B2DPolyPolygon& rCandidate);
// get signed area of polygon
- double getSignedArea(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getSignedArea(const B2DPolyPolygon& rCandidate);
// get area of polygon
- double getArea(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getArea(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,
@@ -119,12 +120,12 @@ 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);
/** Helper class to transport PointIndices to a PolyPolygon,
with an operator< for convenient sorting in a std::set usage
*/
- class PointIndex
+ class BASEGFX_DLLPUBLIC PointIndex
{
private:
sal_uInt32 mnPolygonIndex;
@@ -178,7 +179,7 @@ namespace basegfx
@return true, if the string was successfully parsed
*/
- bool importFromSvgD(
+ BASEGFX_DLLPUBLIC bool importFromSvgD(
B2DPolyPolygon& o_rPolyPoly,
const ::rtl::OUString& rSvgDAttribute,
bool bHandleRelativeNextPointCompatible,
@@ -186,47 +187,47 @@ namespace basegfx
// 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.
@@ -239,7 +240,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.
@@ -270,14 +271,14 @@ namespace basegfx
@return the generated SVG-D statement (the XML d attribute
value alone, without any "<path ...>" or "d="...")
*/
- ::rtl::OUString exportToSvgD(
+ BASEGFX_DLLPUBLIC ::rtl::OUString exportToSvgD(
const B2DPolyPolygon& rPolyPoly,
bool bUseRelativeCoordinates,
bool bDetectQuadraticBeziers,
bool bHandleRelativeNextPointCompatible);
// #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
@@ -291,12 +292,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
@@ -310,26 +311,26 @@ namespace basegfx
@return
The modified version of the source polygon
*/
- B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate);
/** returns true if the Polygon only contains horizontal or vertical edges
so that it could be represented by RegionBands
*/
- bool containsOnlyHorizontalAndVerticalEdges(const B2DPolyPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC bool containsOnlyHorizontalAndVerticalEdges(const B2DPolyPolygon& rCandidate);
/// converters for com::sun::star::drawing::PointSequence
- B2DPolyPolygon UnoPointSequenceSequenceToB2DPolyPolygon(
+ BASEGFX_DLLPUBLIC B2DPolyPolygon UnoPointSequenceSequenceToB2DPolyPolygon(
const com::sun::star::drawing::PointSequenceSequence& rPointSequenceSequenceSource,
bool bCheckClosed = true);
- void B2DPolyPolygonToUnoPointSequenceSequence(
+ BASEGFX_DLLPUBLIC void B2DPolyPolygonToUnoPointSequenceSequence(
const B2DPolyPolygon& rPolyPolygon,
com::sun::star::drawing::PointSequenceSequence& rPointSequenceSequenceRetval);
/// converters for com::sun::star::drawing::PolyPolygonBezierCoords (curved polygons)
- B2DPolyPolygon UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
+ BASEGFX_DLLPUBLIC B2DPolyPolygon UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
const com::sun::star::drawing::PolyPolygonBezierCoords& rPolyPolygonBezierCoordsSource,
bool bCheckClosed = true);
- void B2DPolyPolygonToUnoPolyPolygonBezierCoords(
+ BASEGFX_DLLPUBLIC void B2DPolyPolygonToUnoPolyPolygonBezierCoords(
const B2DPolyPolygon& rPolyPolygon,
com::sun::star::drawing::PolyPolygonBezierCoords& rPolyPolygonBezierCoordsRetval);
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b2dtrapezoid.hxx Sun Aug 7 19:24:03 2016
@@ -27,13 +27,14 @@
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
// class to hold a single trapezoid
- class B2DTrapezoid
+ class BASEGFX_DLLPUBLIC B2DTrapezoid
{
private:
// Geometry data. YValues are down-oriented, this means bottom should
@@ -89,13 +90,13 @@ namespace basegfx
// lines have to be parallel to the X-Axis, thus this subdivision is NOT simply usable
// for primitive decompositions. To use it, the shear and rotate parts of the
// involved transformations HAVE to be taken into account.
- void trapezoidSubdivide(
+ BASEGFX_DLLPUBLIC void trapezoidSubdivide(
B2DTrapezoidVector& ro_Result,
const B2DPolyPolygon& rSourcePolyPolygon);
// directly create trapezoids from given edge. Depending on the given geometry,
// none up to three trapezoids will be created
- void createLineTrapezoidFromEdge(
+ BASEGFX_DLLPUBLIC void createLineTrapezoidFromEdge(
B2DTrapezoidVector& ro_Result,
const B2DPoint& rPointA,
const B2DPoint& rPointB,
@@ -104,7 +105,7 @@ namespace basegfx
// create trapezoids for all edges of the given polygon. The closed state of
// the polygon is taken into account. If curves are contaned, the default
// AdaptiveSubdivision will be used.
- void createLineTrapezoidFromB2DPolygon(
+ BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolygon(
B2DTrapezoidVector& ro_Result,
const B2DPolygon& rPolygon,
double fLineWidth = 1.0);
@@ -112,7 +113,7 @@ namespace basegfx
// create trapezoids for all edges of the given polyPolygon. The closed state of
// the PolyPolygon is taken into account. If curves are contaned, the default
// AdaptiveSubdivision will be used.
- void createLineTrapezoidFromB2DPolyPolygon(
+ BASEGFX_DLLPUBLIC void createLineTrapezoidFromB2DPolyPolygon(
B2DTrapezoidVector& ro_Result,
const B2DPolyPolygon& rPolyPolygon,
double fLineWidth = 1.0);
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygon.hxx Sun Aug 7 19:24:03 2016
@@ -26,6 +26,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
// predeclarations
@@ -46,7 +47,7 @@ namespace basegfx
namespace basegfx
{
- class B3DPolygon
+ class BASEGFX_DLLPUBLIC B3DPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB3DPolygon > ImplType;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygonclipper.hxx Sun Aug 7 19:24:03 2016
@@ -26,6 +26,7 @@
#include <basegfx/polygon/b3dpolypolygon.hxx>
#include <basegfx/polygon/b3dpolygon.hxx>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -51,30 +52,30 @@ namespace basegfx
// of the plane from the center (0.0).
// The value bClipPositive defines on which side the return value will be (true -> on positive side of plane).
// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
- B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnOrthogonalPlane(const B3DPolyPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
// version for Polygons
- B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnOrthogonalPlane(const B3DPolygon& rCandidate, B3DOrientation ePlaneOrthogonal, bool bClipPositive, double fPlaneOffset, bool bStroke);
// Clip the given PolyPolygon against the given range. bInside defines if the result will contain the
// parts which are contained in the range or vice versa.
// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
- B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
// version for Polygons
- B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B3DRange& rRange, bool bInside, bool bStroke);
// versions for B2DRange, clips only against X,Y
- B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
- B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnRange(const B3DPolyPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnRange(const B3DPolygon& rCandidate, const B2DRange& rRange, bool bInside, bool bStroke);
// Clip the given PolyPolygon against given plane in 3D. The plane is defined by a plane normal and a point on the plane.
// The value bClipPositive defines on which side the return value will be (true -> on positive side of plane).
// The switch bStroke decides if the polygon is interpreted as area (false) or strokes (true).
- B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolyPolygonOnPlane(const B3DPolyPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
// version for Polygons
- B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
+ BASEGFX_DLLPUBLIC B3DPolyPolygon clipPolygonOnPlane(const B3DPolygon& rCandidate, const B3DPoint& rPointOnPlane, const B3DVector& rPlaneNormal, bool bClipPositive, bool bStroke);
} // end of namespace tools
} // end of namespace basegfx
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolygontools.hxx Sun Aug 7 19:24:03 2016
@@ -29,6 +29,7 @@
#include <basegfx/polygon/b3dpolypolygon.hxx>
#include <basegfx/vector/b2enums.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -49,58 +50,58 @@ namespace basegfx
method corrects this (removes double start/end points)
and sets the Closed()-state of the polygon correctly.
*/
- void checkClosed(B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC void checkClosed(B3DPolygon& rCandidate);
// Get successor and predecessor indices. Returning the same index means there
// is none. Same for successor.
- sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
- sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate);
// Get orientation of Polygon
- B2VectorOrientation getOrientation(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B2VectorOrientation getOrientation(const B3DPolygon& rCandidate);
// get size of polygon. Control vectors are included in that ranges.
- B3DRange getRange(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DRange getRange(const B3DPolygon& rCandidate);
// get normal vector of polygon
- B3DVector getNormal(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DVector getNormal(const B3DPolygon& rCandidate);
// get normal vector of positive oriented polygon
- B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DVector getPositiveOrientedNormal(const B3DPolygon& rCandidate);
// get signed area of polygon
- double getSignedArea(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getSignedArea(const B3DPolygon& rCandidate);
// get area of polygon
- double getArea(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getArea(const B3DPolygon& rCandidate);
// get signed area of polygon
- double getSignedArea(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getSignedArea(const B3DPolygon& rCandidate);
// get area of polygon
- double getArea(const ::basegfx::B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getArea(const ::basegfx::B3DPolygon& rCandidate);
// get length of polygon edge from point nIndex to nIndex + 1
- double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex);
+ BASEGFX_DLLPUBLIC double getEdgeLength(const B3DPolygon& rCandidate, sal_uInt32 nIndex);
// get length of polygon
- double getLength(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC double getLength(const B3DPolygon& rCandidate);
// get position on polygon for absolute given distance. If
// length is given, it is assumed the correct polygon length, if 0.0 it is calculated
// using getLength(...)
- B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+ BASEGFX_DLLPUBLIC B3DPoint getPositionAbsolute(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
// get position on polygon for relative given distance in range [0.0 .. 1.0]. If
// length is given, it is assumed the correct polygon length, if 0.0 it is calculated
// using getLength(...)
- B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
+ BASEGFX_DLLPUBLIC B3DPoint getPositionRelative(const B3DPolygon& rCandidate, double fDistance, double fLength = 0.0);
/** Apply given LineDashing to given polygon
For a description see applyLineDashing in b2dpolygontoos.hxx
*/
- void applyLineDashing(
+ BASEGFX_DLLPUBLIC void applyLineDashing(
const B3DPolygon& rCandidate,
const ::std::vector<double>& rDotDashArray,
B3DPolyPolygon* pLineTarget,
@@ -111,61 +112,61 @@ namespace basegfx
rCandidate: the 3d geometry to change
rCenter: the center of the 3d geometry
*/
- B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter);
+ BASEGFX_DLLPUBLIC B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter);
/** invert normals for given 3d geometry.
*/
- B3DPolygon invertNormals( const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DPolygon invertNormals( const B3DPolygon& rCandidate);
/** Create/replace texture coordinates for given 3d geometry with parallel projected one
rRange: the full range of the 3d geometry
If bChangeX, x texture coordinate will be recalculated.
If bChangeY, y texture coordinate will be recalculated.
*/
- B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true);
+ BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX = true, bool bChangeY = true);
/** Create/replace texture coordinates for given 3d geometry with spherical one
rCenter: the centre of the used 3d geometry
If bChangeX, x texture coordinate will be recalculated.
If bChangeY, y texture coordinate will be recalculated.
*/
- B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
+ BASEGFX_DLLPUBLIC B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX = true, bool bChangeY = true);
// test if point is inside epsilon-range around an edge defined
// by the two given points. Can be used for HitTesting. The epsilon-range
// is defined to be the cylinder centered to the given edge, using radius
// fDistance, and the sphere around both points with radius fDistance.
- bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance);
+ BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, const B3DPoint& rTestPosition, double fDistance);
// test if point is inside epsilon-range around the given Polygon. Can be used
// for HitTesting. The epsilon-range is defined to be the cylinder centered to
// the given edge, using radius fDistance, and the sphere around both points with radius fDistance.
- bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance);
+ BASEGFX_DLLPUBLIC bool isInEpsilonRange(const B3DPolygon& rCandidate, const B3DPoint& rTestPosition, double fDistance);
// isInside tests for B3DPoint and other B3DPolygon. On border is not inside as long as
// not true is given in bWithBorder flag.
- bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
- bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder = false);
+ BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder = false);
+ BASEGFX_DLLPUBLIC bool isInside(const B3DPolygon& rCandidate, const B3DPolygon& rPolygon, bool bWithBorder = false);
// calculates if given point is on given line, taking care of the numerical epsilon
- bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints = false);
+ BASEGFX_DLLPUBLIC bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints = false);
// calculates if given point is on given polygon, taking care of the numerical epsilon. Uses
// isPointOnLine internally
- bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints = true);
+ BASEGFX_DLLPUBLIC bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints = true);
// helper to get a fCut position between a plane (given with normal and a point)
// and a line given by start and end point
- bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
+ BASEGFX_DLLPUBLIC bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
// helper to get a fCut position between a 3d Polygon
// and a line given by start and end point
- bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
+ BASEGFX_DLLPUBLIC bool getCutBetweenLineAndPolygon(const B3DPolygon& rCandidate, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut);
//////////////////////////////////////////////////////////////////////
// comparators with tolerance for 3D Polygons
- bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue);
- bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB);
+ BASEGFX_DLLPUBLIC bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB, const double& rfSmallValue);
+ BASEGFX_DLLPUBLIC bool equal(const B3DPolygon& rCandidateA, const B3DPolygon& rCandidateB);
/** snap some polygon coordinates to discrete coordinates
@@ -179,7 +180,7 @@ namespace basegfx
@return
The modified version of the source polygon
*/
- B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate);
+ BASEGFX_DLLPUBLIC B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate);
} // end of namespace tools
} // end of namespace basegfx
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygon.hxx Sun Aug 7 19:24:03 2016
@@ -26,6 +26,7 @@
#include <sal/types.h>
#include <o3tl/cow_wrapper.hxx>
+#include <basegfx/basegfxdllapi.h>
// predeclarations
class ImplB3DPolyPolygon;
@@ -41,7 +42,7 @@ namespace basegfx
namespace basegfx
{
- class B3DPolyPolygon
+ class BASEGFX_DLLPUBLIC B3DPolyPolygon
{
public:
typedef o3tl::cow_wrapper< ImplB3DPolyPolygon > ImplType;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/polygon/b3dpolypolygontools.hxx Sun Aug 7 19:24:03 2016
@@ -30,6 +30,7 @@
#include <basegfx/point/b3dpoint.hxx>
#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
//////////////////////////////////////////////////////////////////////////////
@@ -44,13 +45,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,
@@ -59,26 +60,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);
@@ -87,7 +88,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,
@@ -96,7 +97,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,
@@ -105,7 +106,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,
@@ -116,40 +117,40 @@ 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);
/// converters for com::sun::star::drawing::PolyPolygonShape3D
- B3DPolyPolygon UnoPolyPolygonShape3DToB3DPolyPolygon(
+ BASEGFX_DLLPUBLIC B3DPolyPolygon UnoPolyPolygonShape3DToB3DPolyPolygon(
const com::sun::star::drawing::PolyPolygonShape3D& rPolyPolygonShape3DSource,
bool bCheckClosed = true);
- void B3DPolyPolygonToUnoPolyPolygonShape3D(
+ BASEGFX_DLLPUBLIC void B3DPolyPolygonToUnoPolyPolygonShape3D(
const B3DPolyPolygon& rPolyPolygonSource,
com::sun::star::drawing::PolyPolygonShape3D& rPolyPolygonShape3DRetval);
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b1drange.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b1drange.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b1drange.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b1drange.hxx Sun Aug 7 19:24:03 2016
@@ -25,13 +25,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;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b1ibox.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b1ibox.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b1ibox.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b1ibox.hxx Sun Aug 7 19:24:03 2016
@@ -25,11 +25,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;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b1irange.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b1irange.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b1irange.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b1irange.hxx Sun Aug 7 19:24:03 2016
@@ -25,11 +25,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;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b2dpolyrange.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b2dpolyrange.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b2dpolyrange.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b2dpolyrange.hxx Sun Aug 7 19:24:03 2016
@@ -27,6 +27,7 @@
#include <o3tl/cow_wrapper.hxx>
#include <boost/tuple/tuple.hpp>
#include <basegfx/vector/b2enums.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -51,7 +52,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 ;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b2drange.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b2drange.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b2drange.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b2drange.hxx Sun Aug 7 19:24:03 2016
@@ -29,6 +29,7 @@
#include <basegfx/tuple/b2dtuple.hxx>
#include <basegfx/range/basicrange.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
@@ -78,7 +79,7 @@ namespace basegfx
{
}
- explicit B2DRange(const B2IRange& rRange);
+ BASEGFX_DLLPUBLIC explicit B2DRange(const B2IRange& rRange);
bool isEmpty() const
{
@@ -247,7 +248,7 @@ namespace basegfx
maRangeY.grow(fValue);
}
- void transform(const B2DHomMatrix& rMatrix);
+ BASEGFX_DLLPUBLIC void transform(const B2DHomMatrix& rMatrix);
private:
typedef ::basegfx::BasicRange< ValueType, TraitsType > MyBasicRange;
@@ -260,7 +261,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
@@ -281,7 +282,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 );
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b2drangeclipper.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b2drangeclipper.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b2drangeclipper.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b2drangeclipper.hxx Sun Aug 7 19:24:03 2016
@@ -26,6 +26,7 @@
#include <basegfx/range/b2dpolyrange.hxx>
#include <vector>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -38,7 +39,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);
}
}
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b2ibox.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b2ibox.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b2ibox.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b2ibox.hxx Sun Aug 7 19:24:03 2016
@@ -30,11 +30,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;
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b2irange.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b2irange.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b2irange.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b2irange.hxx Sun Aug 7 19:24:03 2016
@@ -30,11 +30,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;
@@ -241,7 +242,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 );
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b3drange.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b3drange.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b3drange.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b3drange.hxx Sun Aug 7 19:24:03 2016
@@ -28,6 +28,7 @@
#include <basegfx/point/b3dpoint.hxx>
#include <basegfx/tuple/b3dtuple.hxx>
#include <basegfx/range/basicrange.hxx>
+#include <basegfx/basegfxdllapi.h>
namespace basegfx
{
@@ -35,7 +36,7 @@ namespace basegfx
class B3IRange;
class B3DHomMatrix;
- class B3DRange
+ class BASEGFX_DLLPUBLIC B3DRange
{
typedef ::basegfx::BasicRange< double, DoubleTraits > MyBasicRange;
@@ -291,7 +292,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
Modified: openoffice/trunk/main/basegfx/inc/basegfx/range/b3ibox.hxx
URL: http://svn.apache.org/viewvc/openoffice/trunk/main/basegfx/inc/basegfx/range/b3ibox.hxx?rev=1755455&r1=1755454&r2=1755455&view=diff
==============================================================================
--- openoffice/trunk/main/basegfx/inc/basegfx/range/b3ibox.hxx (original)
+++ openoffice/trunk/main/basegfx/inc/basegfx/range/b3ibox.hxx Sun Aug 7 19:24:03 2016
@@ -29,10 +29,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;