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;
