INTEGRATION: CWS aw033 (1.5.6); FILE MERGED

2008/05/14 14:40:29 aw 1.5.6.11: RESYNC: (1.5-1.6); FILE MERGED
2008/05/14 09:16:32 aw 1.5.6.10: #i39532# aw033 progresses from git
2007/11/23 09:43:05 aw 1.5.6.9: #i39532# warning corrections
2007/11/22 14:56:58 aw 1.5.6.8: #i39532# polygon bezier changes
2007/11/19 10:17:02 aw 1.5.6.7: #i39532# Lot of changes to make polygon stuff bezier-able
2007/11/07 14:24:29 aw 1.5.6.6: #i39532# committing to have a base for HDU
2007/10/18 09:27:00 hdu 1.5.6.5: #i75669# fix typo
2007/10/18 09:23:10 hdu 1.5.6.4: #i75669# resegment polygon with curves before line->area conversion
2007/10/17 12:22:53 hdu 1.5.6.3: #i75669# fix createAreaGeometryForSimplePolygon() after resync changes
2007/08/13 15:28:43 aw 1.5.6.2: #i39532# changes after resync
2007/04/26 14:30:26 hdu 1.5.6.1: #i75669# added method createAreaGeometryForSimplePolygon()

1 files changed, 551 insertions, 295 deletions

diff --git a/basegfx/source/polygon/b2dlinegeometry.cxx b/basegfx/source/polygon/b2dlinegeometry.cxx
index d34d7acce99c..0cda1036e13b 100644
--- a/basegfx/source/polygon/b2dlinegeometry.cxx
+++ b/basegfx/source/polygon/b2dlinegeometry.cxx
@@ -7,7 +7,7 @@
  * OpenOffice.org - a multi-platform office productivity suite
  *
  * $RCSfile: b2dlinegeometry.cxx,v $
- * $Revision: 1.6 $
+ * $Revision: 1.7 $
  *
  * This file is part of OpenOffice.org.
  *
@@ -30,6 +30,7 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_basegfx.hxx"
+#include <cstdio>
 #include <osl/diagnose.h>
 #include <basegfx/polygon/b2dlinegeometry.hxx>
 #include <basegfx/point/b2dpoint.hxx>
@@ -38,6 +39,107 @@
 #include <basegfx/polygon/b2dpolypolygontools.hxx>
 #include <basegfx/range/b2drange.hxx>
 #include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/curve/b2dcubicbezier.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    namespace tools
+    {
+        B2DPolyPolygon createAreaGeometryForLineStartEnd(
+            const B2DPolygon& rCandidate,
+            const B2DPolyPolygon& rArrow,
+            bool bStart,
+            double fWidth,
+            double fCandidateLength,
+            double fDockingPosition, // 0->top, 1->bottom
+            double* pConsumedLength)
+        {
+            B2DPolyPolygon aRetval;
+            OSL_ENSURE(rCandidate.count() > 1L, "createAreaGeometryForLineStartEnd: Line polygon has too less points (!)");
+            OSL_ENSURE(rArrow.count() > 0L, "createAreaGeometryForLineStartEnd: Empty arrow PolyPolygon (!)");
+            OSL_ENSURE(fWidth > 0.0, "createAreaGeometryForLineStartEnd: Width too small (!)");
+            OSL_ENSURE(fDockingPosition >= 0.0 && fDockingPosition <= 1.0,
+                "createAreaGeometryForLineStartEnd: fDockingPosition out of range [0.0 .. 1.0] (!)");
+
+            if(fWidth < 0.0)
+            {
+                fWidth = -fWidth;
+            }
+
+            if(rCandidate.count() > 1 && rArrow.count() && !fTools::equalZero(fWidth))
+            {
+                if(fDockingPosition < 0.0)
+                {
+                    fDockingPosition = 0.0;
+                }
+                else if(fDockingPosition > 1.0)
+                {
+                    fDockingPosition = 1.0;
+                }
+
+                // init return value from arrow
+                aRetval.append(rArrow);
+
+                // get size of the arrow
+                const B2DRange aArrowSize(getRange(rArrow));
+
+                // build ArrowTransform
+                B2DHomMatrix aArrowTransform;
+
+                // center in X, align with axis in Y
+                aArrowTransform.translate(-aArrowSize.getCenter().getX(), -aArrowSize.getMinimum().getY());
+
+                // scale to target size
+                const double fArrowScale(fWidth / (aArrowSize.getRange().getX()));
+                aArrowTransform.scale(fArrowScale, fArrowScale);
+
+                // get arrow size in Y
+                B2DPoint aUpperCenter(aArrowSize.getCenter().getX(), aArrowSize.getMaximum().getY());
+                aUpperCenter *= aArrowTransform;
+                const double fArrowYLength(B2DVector(aUpperCenter).getLength());
+
+                // move arrow to have docking position centered
+                aArrowTransform.translate(0.0, -fArrowYLength * fDockingPosition);
+
+                // prepare polygon length
+                if(fTools::equalZero(fCandidateLength))
+                {
+                    fCandidateLength = getLength(rCandidate);
+                }
+
+                // get the polygon vector we want to plant this arrow on
+                const double fConsumedLength(fArrowYLength * (1.0 - fDockingPosition));
+                const B2DVector aHead(rCandidate.getB2DPoint((bStart) ? 0L : rCandidate.count() - 1L));
+                const B2DVector aTail(getPositionAbsolute(rCandidate,
+                    (bStart) ? fConsumedLength : fCandidateLength - fConsumedLength, fCandidateLength));
+
+                // from that vector, take the needed rotation and add rotate for arrow to transformation
+                const B2DVector aTargetDirection(aHead - aTail);
+                const double fRotation(atan2(aTargetDirection.getY(), aTargetDirection.getX()) + (90.0 * F_PI180));
+
+                // rotate around docking position
+                aArrowTransform.rotate(fRotation);
+
+                // move arrow docking position to polygon head
+                aArrowTransform.translate(aHead.getX(), aHead.getY());
+
+                // transform retval and close
+                aRetval.transform(aArrowTransform);
+                aRetval.setClosed(true);
+
+                // if pConsumedLength is asked for, fill it
+                if(pConsumedLength)
+                {
+                    *pConsumedLength = fConsumedLength;
+                }
+            }
+
+            return aRetval;
+        }
+    } // end of namespace tools
+} // end of namespace basegfx
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -46,392 +148,546 @@ namespace basegfx
     // anonymus namespace for local helpers
     namespace
     {
-        // create area geometry for given edge. Edge is defined with the
-        // points rEdgeStart and rEdgeEnd. fHalfLineWidth defines the relative width.
-        // The created polygon will be positively oriented and free of
-        // self intersections.
-        // bCreateInBetweenPoints defines if EdgeStart and EdgeEnd themselves will
-        // be added (see comment in implementation).
-        B2DPolygon createAreaGeometryForEdge(
-            const B2DPoint& rEdgeStart,
-            const B2DPoint& rEdgeEnd,
-            double fHalfLineWidth,
-            bool bCreateInBetweenPoints)
+        bool impIsSimpleEdge(const B2DCubicBezier& rCandidate, double fMaxCosQuad, double fMaxPartOfEdgeQuad)
         {
-            OSL_ENSURE(fHalfLineWidth > 0.0, "createAreaGeometryForEdge: LineWidth too small (!)");
-            B2DPolygon aRetval;
+            // isBezier() is true, already tested by caller
+            const B2DVector aEdge(rCandidate.getEndPoint() - rCandidate.getStartPoint());
 
-            // get perpendicular vector for reaching the outer edges
-            const B2DVector aEdgeVector(rEdgeEnd - rEdgeStart);
-            B2DVector aPerpendEdgeVector(getNormalizedPerpendicular(aEdgeVector));
-            aPerpendEdgeVector *= fHalfLineWidth;
+            if(aEdge.equalZero())
+            {
+                // start and end point the same, but control vectors used -> baloon curve loop
+                // is not a simple edge
+                return false;
+            }
 
-            // create polygon for edge
-            // Unfortunately, while it would be geometrically correct to not add
-            // the in-between points rEdgeEnd and rEdgeStart, it leads to rounding
-            // errors when converting to integer polygon coordiates for painting.
-            aRetval.append(rEdgeStart - aPerpendEdgeVector);
-            aRetval.append(rEdgeEnd - aPerpendEdgeVector);
+            // get tangentA and scalar with edge
+            const B2DVector aTangentA(rCandidate.getTangent(0.0));
+            const double fScalarAE(aEdge.scalar(aTangentA));
 
-            if(bCreateInBetweenPoints)
+            if(fTools::lessOrEqual(fScalarAE, 0.0))
             {
-                aRetval.append(rEdgeEnd);
+                // angle between TangentA and Edge is bigger or equal 90 degrees
+                return false;
             }
 
-            aRetval.append(rEdgeEnd + aPerpendEdgeVector);
-            aRetval.append(rEdgeStart + aPerpendEdgeVector);
+            // get self-scalars for E and A
+            const double fScalarE(aEdge.scalar(aEdge));
+            const double fScalarA(aTangentA.scalar(aTangentA));
+            const double fLengthCompareE(fScalarE * fMaxPartOfEdgeQuad);
 
-            if(bCreateInBetweenPoints)
+            if(fTools::moreOrEqual(fScalarA, fLengthCompareE))
             {
-                aRetval.append(rEdgeStart);
+                // length of TangentA is more than fMaxPartOfEdge of length of edge
+                return false;
             }
 
-            aRetval.setClosed(true);
+            if(fTools::lessOrEqual(fScalarAE * fScalarAE, fScalarA * fScalarE * fMaxCosQuad))
+            {
+                // angle between TangentA and Edge is bigger or equal angle defined by fMaxCos
+                return false;
+            }
+
+            // get tangentB and scalar with edge
+            const B2DVector aTangentB(rCandidate.getTangent(1.0));
+            const double fScalarBE(aEdge.scalar(aTangentB));
 
-#ifdef DBG_UTIL
-            // check orientation (debug only)
-            if(tools::getOrientation(aRetval) == ORIENTATION_NEGATIVE)
+            if(fTools::lessOrEqual(fScalarBE, 0.0))
             {
-                OSL_ENSURE(false, "createAreaGeometryForEdge: orientation of return value is negative (!)");
+                // angle between TangentB and Edge is bigger or equal 90 degrees
+                return false;
             }
-#endif
 
-            return aRetval;
+            // get self-scalar for B
+            const double fScalarB(aTangentB.scalar(aTangentB));
+
+            if(fTools::moreOrEqual(fScalarB, fLengthCompareE))
+            {
+                // length of TangentB is more than fMaxPartOfEdge of length of edge
+                return false;
+            }
+
+            if(fTools::lessOrEqual(fScalarBE * fScalarBE, fScalarB * fScalarE * fMaxCosQuad))
+            {
+                // angle between TangentB and Edge is bigger or equal defined by fMaxCos
+                return false;
+            }
+
+            return true;
         }
 
-        // create join polygon for given angle. Angle is defined with the
-        // points rLeft, rCenter and rRight. The given join type defines how
-        // the join segment will be created. fHalfLineWidth defines the relative width.
-        // fDegreeStepWidth is used when rounding edges.
-        // fMiterMinimumAngle is used to define when miter is forced to bevel.
-        // The created polygon will be positively or neuteral oriented and free of
-        // self intersections.
-        B2DPolygon createAreaGeometryForJoin(
-            const B2DPoint& rLeft,
-            const B2DPoint& rCenter,
-            const B2DPoint& rRight,
-            double fHalfLineWidth,
-            tools::B2DLineJoin eJoin,
-            double fDegreeStepWidth,
-            double /*fMiterMinimumAngle*/)
+        void impSubdivideToSimple(const B2DCubicBezier& rCandidate, B2DPolygon& rTarget, double fMaxCosQuad, double fMaxPartOfEdgeQuad, sal_uInt32 nMaxRecursionDepth)
         {
-            OSL_ENSURE(fHalfLineWidth > 0.0, "createAreaGeometryForJoin: LineWidth too small (!)");
-            OSL_ENSURE(fDegreeStepWidth > 0.0, "createAreaGeometryForJoin: DegreeStepWidth too small (!)");
-            OSL_ENSURE(tools::B2DLINEJOIN_NONE != eJoin, "createAreaGeometryForJoin: B2DLINEJOIN_NONE not allowed (!)");
-            B2DPolygon aRetval;
+            if(!nMaxRecursionDepth || impIsSimpleEdge(rCandidate, fMaxCosQuad, fMaxPartOfEdgeQuad))
+            {
+                rTarget.appendBezierSegment(rCandidate.getControlPointA(), rCandidate.getControlPointB(), rCandidate.getEndPoint());
+            }
+            else
+            {
+                B2DCubicBezier aLeft, aRight;
+                rCandidate.split(0.5, &aLeft, &aRight);
 
-            // get perpendicular vector for left and right
-            const B2DVector aLeftVector(rCenter - rLeft);
-            B2DVector aPerpendLeftVector(getNormalizedPerpendicular(aLeftVector));
-            const B2DVector aRightVector(rRight - rCenter);
-            B2DVector aPerpendRightVector(getNormalizedPerpendicular(aRightVector));
+                impSubdivideToSimple(aLeft, rTarget, fMaxCosQuad, fMaxPartOfEdgeQuad, nMaxRecursionDepth - 1);
+                impSubdivideToSimple(aRight, rTarget, fMaxCosQuad, fMaxPartOfEdgeQuad, nMaxRecursionDepth - 1);
+            }
+        }
 
-            // get vector orientation
-            B2VectorOrientation aOrientation(getOrientation(aPerpendLeftVector, aPerpendRightVector));
+        B2DPolygon subdivideToSimple(const B2DPolygon& rCandidate, double fMaxCosQuad, double fMaxPartOfEdgeQuad)
+        {
+            const sal_uInt32 nPointCount(rCandidate.count());
 
-            if(ORIENTATION_NEUTRAL != aOrientation)
+            if(rCandidate.areControlPointsUsed() && nPointCount)
             {
-                // prepare perpend vectors to be able to go from left to right.
-                // also multiply with fHalfLineWidth to get geometric vectors with correct length
-                if(ORIENTATION_POSITIVE == aOrientation)
-                {
-                    // mirror to have them above the edge vectors
-                    const double fNegativeHalfLineWidth(-fHalfLineWidth);
-                    aPerpendLeftVector *= fNegativeHalfLineWidth;
-                    aPerpendRightVector *= fNegativeHalfLineWidth;
-                }
-                else
-                {
-                    // exchange left and right
-                    const B2DVector aTemp(aPerpendLeftVector.getX() * fHalfLineWidth, aPerpendLeftVector.getY() * fHalfLineWidth);
-                    aPerpendLeftVector.setX(aPerpendRightVector.getX() * fHalfLineWidth);
-                    aPerpendLeftVector.setY(aPerpendRightVector.getY() * fHalfLineWidth);
-                    aPerpendRightVector = aTemp;
-                }
+                const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1);
+                B2DPolygon aRetval;
+                B2DCubicBezier aEdge;
 
-                // test if for Miter, the angle is too small
-                if(tools::B2DLINEJOIN_MITER == eJoin)
+                // prepare edge for loop
+                aEdge.setStartPoint(rCandidate.getB2DPoint(0));
+                aRetval.append(aEdge.getStartPoint());
+
+                for(sal_uInt32 a(0); a < nEdgeCount; a++)
                 {
-                    const double fAngle(fabs(aPerpendLeftVector.angle(aPerpendRightVector)));
+                    // fill B2DCubicBezier
+                    const sal_uInt32 nNextIndex((a + 1) % nPointCount);
+                    aEdge.setControlPointA(rCandidate.getNextControlPoint(a));
+                    aEdge.setControlPointB(rCandidate.getPrevControlPoint(nNextIndex));
+                    aEdge.setEndPoint(rCandidate.getB2DPoint(nNextIndex));
 
-                    if((F_PI - fAngle) < (15.0 * F_PI180))
-                    {
-                        // force to bevel
-                        eJoin = tools::B2DLINEJOIN_BEVEL;
-                    }
-                }
+                    // get rid of unnecessary bezier segments
+                    aEdge.testAndSolveTrivialBezier();
 
-                // create specific edge polygon
-                switch(eJoin)
-                {
-                    case tools::B2DLINEJOIN_MIDDLE :
-                    case tools::B2DLINEJOIN_BEVEL :
+                    if(aEdge.isBezier())
                     {
-                        // create polygon for edge, go from left to right
-                        aRetval.append(rCenter);
-                        aRetval.append(rCenter + aPerpendLeftVector);
-                        aRetval.append(rCenter + aPerpendRightVector);
-                        aRetval.setClosed(true);
+                        // before splitting recursively with internal simple criteria, use
+                        // ExtremumPosFinder to remove those
+                        ::std::vector< double > aExtremumPositions;
 
-                        break;
-                    }
-                    case tools::B2DLINEJOIN_MITER :
-                    {
-                        // create first polygon part for edge, go from left to right
-                        aRetval.append(rCenter);
-                        aRetval.append(rCenter + aPerpendLeftVector);
+                        aExtremumPositions.reserve(4);
+                        aEdge.getAllExtremumPositions(aExtremumPositions);
 
-                        double fCutPos(0.0);
-                        const B2DPoint aLeftCutPoint(rCenter + aPerpendLeftVector);
-                        const B2DPoint aRightCutPoint(rCenter + aPerpendRightVector);
+                        const sal_uInt32 nCount(aExtremumPositions.size());
 
-                        if(ORIENTATION_POSITIVE == aOrientation)
+                        if(nCount)
                         {
-                            tools::findCut(aLeftCutPoint, aLeftVector, aRightCutPoint, -aRightVector, CUTFLAG_ALL, &fCutPos);
-
-                            if(0.0 != fCutPos)
+                            if(nCount > 1)
                             {
-                                const B2DPoint aCutPoint(
-                                    interpolate(aLeftCutPoint, aLeftCutPoint + aLeftVector, fCutPos));
-                                aRetval.append(aCutPoint);
+                                // create order from left to right
+                                ::std::sort(aExtremumPositions.begin(), aExtremumPositions.end());
                             }
-                        }
-                        else
-                        {
-                            // peroendiculars are exchanged, also use exchanged EdgeVectors
-                            tools::findCut(aLeftCutPoint, -aRightVector, aRightCutPoint, aLeftVector, CUTFLAG_ALL, &fCutPos);
 
-                            if(0.0 != fCutPos)
+                            for(sal_uInt32 b(0); b < nCount;)
                             {
-                                const B2DPoint aCutPoint(
-                                    interpolate(aLeftCutPoint, aLeftCutPoint - aRightVector, fCutPos));
-                                aRetval.append(aCutPoint);
+                                // split aEdge at next split pos
+                                B2DCubicBezier aLeft;
+                                const double fSplitPos(aExtremumPositions[b++]);
+
+                                aEdge.split(fSplitPos, &aLeft, &aEdge);
+                                aLeft.testAndSolveTrivialBezier();
+
+                                // consume left part
+                                if(aLeft.isBezier())
+                                {
+                                    impSubdivideToSimple(aLeft, aRetval, fMaxCosQuad, fMaxPartOfEdgeQuad, 6);
+                                }
+                                else
+                                {
+                                    aRetval.append(aLeft.getEndPoint());
+                                }
+
+                                if(b < nCount)
+                                {
+                                    // correct the remaining split positions to fit to shortened aEdge
+                                    const double fScaleFactor(1.0 / (1.0 - fSplitPos));
+
+                                    for(sal_uInt32 c(b); c < nCount; c++)
+                                    {
+                                        aExtremumPositions[c] = (aExtremumPositions[c] - fSplitPos) * fScaleFactor;
+                                    }
+                                }
                             }
-                        }
 
-                        // create last polygon part for edge
-                        aRetval.append(rCenter + aPerpendRightVector);
-                        aRetval.setClosed(true);
+                            // test the shortened rest of aEdge
+                            aEdge.testAndSolveTrivialBezier();
 
-                        break;
-                    }
-                    case tools::B2DLINEJOIN_ROUND :
-                    {
-                        // create first polygon part for edge, go from left to right
-                        aRetval.append(rCenter);
-                        aRetval.append(rCenter + aPerpendLeftVector);
-
-                        // get angle and prepare
-                        double fAngle(aPerpendLeftVector.angle(aPerpendRightVector));
-                        const bool bNegative(fAngle < 0.0);
-                        if(bNegative)
+                            // consume right part
+                            if(aEdge.isBezier())
+                            {
+                                impSubdivideToSimple(aEdge, aRetval, fMaxCosQuad, fMaxPartOfEdgeQuad, 6);
+                            }
+                            else
+                            {
+                                aRetval.append(aEdge.getEndPoint());
+                            }
+                        }
+                        else
                         {
-                            fAngle = fabs(fAngle);
+                            impSubdivideToSimple(aEdge, aRetval, fMaxCosQuad, fMaxPartOfEdgeQuad, 6);
                         }
+                    }
+                    else
+                    {
+                        // straight edge, add point
+                        aRetval.append(aEdge.getEndPoint());
+                    }
 
-                        // substract first step, first position is added to
-                        // the polygon yet
-                        fAngle -= fDegreeStepWidth;
+                    // prepare edge for next step
+                    aEdge.setStartPoint(aEdge.getEndPoint());
+                }
 
-                        // create points as long as angle is > 0.0
-                        if(fAngle > 0.0)
-                        {
-                            // get start angle
-                            double fAngleOfLeftPerpendVector(
-                                atan2(aPerpendLeftVector.getY(), aPerpendLeftVector.getX()));
+                // copy closed flag and check for double points
+                aRetval.setClosed(rCandidate.isClosed());
+                aRetval.removeDoublePoints();
 
-                            while(fAngle > 0.0)
-                            {
-                                // calculate rotated vector
-                                fAngleOfLeftPerpendVector += (bNegative ? -fDegreeStepWidth : fDegreeStepWidth);
-                                const B2DVector aRotatedVector(
-                                    rCenter.getX() + (cos(fAngleOfLeftPerpendVector) * fHalfLineWidth),
-                                    rCenter.getY() + (sin(fAngleOfLeftPerpendVector) * fHalfLineWidth));
+                return aRetval;
+            }
+            else
+            {
+                return rCandidate;
+            }
+        }
 
-                                // add point
-                                aRetval.append(aRotatedVector);
+        B2DPolygon createAreaGeometryForEdge(const B2DCubicBezier& rEdge, double fHalfLineWidth)
+        {
+            // create polygon for edge
+            // Unfortunately, while it would be geometrically correct to not add
+            // the in-between points EdgeEnd and EdgeStart, it leads to rounding
+            // errors when converting to integer polygon coordinates for painting
+            const B2DVector aEdgeVector(rEdge.getEndPoint() - rEdge.getStartPoint());
 
-                                // substract next step
-                                fAngle -= fDegreeStepWidth;
-                            }
-                        }
+            if(rEdge.isBezier())
+            {
+                // prepare target and data common for upper and lower
+                B2DPolygon aBezierPolygon;
+                const double fEdgeLength(aEdgeVector.getLength());
+                const bool bIsEdgeLengthZero(fTools::equalZero(fEdgeLength));
+                const B2DVector aTangentA(rEdge.getTangent(0.0));
+                const B2DVector aTangentB(rEdge.getTangent(1.0));
+
+                // create upper edge.
+                {
+                    // create displacement vectors and check if they cut
+                    const B2DVector aPerpendStart(getNormalizedPerpendicular(aTangentA) * -fHalfLineWidth);
+                    const B2DVector aPerpendEnd(getNormalizedPerpendicular(aTangentB) * -fHalfLineWidth);
+                    double fCut(0.0);
+                    const tools::CutFlagValue aCut(tools::findCut(
+                        rEdge.getStartPoint(), aPerpendStart,
+                        rEdge.getEndPoint(), aPerpendEnd,
+                        CUTFLAG_ALL, &fCut));
+
+                    if(CUTFLAG_NONE != aCut)
+                    {
+                        // calculate cut point and add
+                        const B2DPoint aCutPoint(rEdge.getStartPoint() + (aPerpendStart * fCut));
+                        aBezierPolygon.append(aCutPoint);
+                    }
+                    else
+                    {
+                        // create scaled bezier segment
+                        const B2DPoint aStart(rEdge.getStartPoint() + aPerpendStart);
+                        const B2DPoint aEnd(rEdge.getEndPoint() + aPerpendEnd);
+                        const B2DVector aEdge(aEnd - aStart);
+                        const double fLength(aEdge.getLength());
+                        const double fScale(bIsEdgeLengthZero ? 1.0 : fLength / fEdgeLength);
+                        const B2DVector fRelNext(rEdge.getControlPointA() - rEdge.getStartPoint());
+                        const B2DVector fRelPrev(rEdge.getControlPointB() - rEdge.getEndPoint());
+
+                        aBezierPolygon.append(aStart);
+                        aBezierPolygon.appendBezierSegment(aStart + (fRelNext * fScale), aEnd + (fRelPrev * fScale), aEnd);
+                    }
+                }
 
-                        // create last polygon part for edge
-                        aRetval.append(rCenter + aPerpendRightVector);
-                        aRetval.setClosed(true);
+                // append original in-between point
+                aBezierPolygon.append(rEdge.getEndPoint());
 
-                        break;
+                // create lower edge.
+                {
+                    // create displacement vectors and check if they cut
+                    const B2DVector aPerpendStart(getNormalizedPerpendicular(aTangentA) * fHalfLineWidth);
+                    const B2DVector aPerpendEnd(getNormalizedPerpendicular(aTangentB) * fHalfLineWidth);
+                    double fCut(0.0);
+                    const tools::CutFlagValue aCut(tools::findCut(
+                        rEdge.getEndPoint(), aPerpendEnd,
+                        rEdge.getStartPoint(), aPerpendStart,
+                        CUTFLAG_ALL, &fCut));
+
+                    if(CUTFLAG_NONE != aCut)
+                    {
+                        // calculate cut point and add
+                        const B2DPoint aCutPoint(rEdge.getEndPoint() + (aPerpendEnd * fCut));
+                        aBezierPolygon.append(aCutPoint);
+                    }
+                    else
+                    {
+                        // create scaled bezier segment
+                        const B2DPoint aStart(rEdge.getEndPoint() + aPerpendEnd);
+                        const B2DPoint aEnd(rEdge.getStartPoint() + aPerpendStart);
+                        const B2DVector aEdge(aEnd - aStart);
+                        const double fLength(aEdge.getLength());
+                        const double fScale(bIsEdgeLengthZero ? 1.0 : fLength / fEdgeLength);
+                        const B2DVector fRelNext(rEdge.getControlPointB() - rEdge.getEndPoint());
+                        const B2DVector fRelPrev(rEdge.getControlPointA() - rEdge.getStartPoint());
+
+                        aBezierPolygon.append(aStart);
+                        aBezierPolygon.appendBezierSegment(aStart + (fRelNext * fScale), aEnd + (fRelPrev * fScale), aEnd);
                     }
-                    case tools::B2DLINEJOIN_NONE:
-                        break; // nothing to add to aRetVal
-                    default:
-                        OSL_ENSURE(false,
-                                   "createAreaGeometryForJoin(): unexpected case.");
                 }
-            }
 
-#ifdef DBG_UTIL
-            // check orientation (debug only)
-            if(tools::getOrientation(aRetval) == ORIENTATION_NEGATIVE)
-            {
-                OSL_ENSURE(false, "createAreaGeometryForJoin: orientation of return value is negative (!)");
+                // append original in-between point
+                aBezierPolygon.append(rEdge.getStartPoint());
+
+                // close and return
+                aBezierPolygon.setClosed(true);
+                return aBezierPolygon;
             }
-#endif
+            else
+            {
+                const B2DVector aPerpendEdgeVector(getNormalizedPerpendicular(aEdgeVector) * fHalfLineWidth);
+                B2DPolygon aEdgePolygon;
 
-            return aRetval;
+                // create upper edge
+                aEdgePolygon.append(rEdge.getStartPoint() - aPerpendEdgeVector);
+                aEdgePolygon.append(rEdge.getEndPoint() - aPerpendEdgeVector);
+
+                // append original in-between point
+                aEdgePolygon.append(rEdge.getEndPoint());
+
+                // create lower edge
+                aEdgePolygon.append(rEdge.getEndPoint() + aPerpendEdgeVector);
+                aEdgePolygon.append(rEdge.getStartPoint() + aPerpendEdgeVector);
+
+                // append original in-between point
+                aEdgePolygon.append(rEdge.getStartPoint());
+
+                // close and return
+                aEdgePolygon.setClosed(true);
+                return aEdgePolygon;
+            }
         }
-    } // end of anonymus namespace
 
-    namespace tools
-    {
-        B2DPolyPolygon createAreaGeometryForPolygon(const B2DPolygon& rCandidate,
+        B2DPolygon createAreaGeometryForJoin(
+            const B2DVector& rTangentPrev,
+            const B2DVector& rTangentEdge,
+            const B2DVector& rPerpendPrev,
+            const B2DVector& rPerpendEdge,
+            const B2DPoint& rPoint,
             double fHalfLineWidth,
             B2DLineJoin eJoin,
-            double fDegreeStepWidth,
             double fMiterMinimumAngle)
         {
-            OSL_ENSURE(fHalfLineWidth > 0.0, "createAreaGeometryForPolygon: LineWidth too small (!)");
-            OSL_ENSURE(fDegreeStepWidth > 0.0, "createAreaGeometryForPolygon: DegreeStepWidth too small (!)");
-            B2DPolyPolygon aRetval;
-            const sal_uInt32 nCount(rCandidate.count());
+            OSL_ENSURE(fHalfLineWidth > 0.0, "createAreaGeometryForJoin: LineWidth too small (!)");
+            OSL_ENSURE(B2DLINEJOIN_NONE != eJoin, "createAreaGeometryForJoin: B2DLINEJOIN_NONE not allowed (!)");
 
-            if(rCandidate.isClosed())
+            // LineJoin from tangent rPerpendPrev to tangent rPerpendEdge in rPoint
+            B2DPolygon aEdgePolygon;
+            const B2DPoint aStartPoint(rPoint + rPerpendPrev);
+            const B2DPoint aEndPoint(rPoint + rPerpendEdge);
+
+            // test if for Miter, the angle is too small and the fallback
+            // to bevel needs to be used
+            if(B2DLINEJOIN_MITER == eJoin)
             {
-                const bool bNeedToCreateJoinPolygon(B2DLINEJOIN_NONE != eJoin);
-                bool bLastNeededToCreateJoinPolygon(false);
+                const double fAngle(fabs(rPerpendPrev.angle(rPerpendEdge)));
 
-                for(sal_uInt32 a(0L); a < nCount; a++)
+                if((F_PI - fAngle) < fMiterMinimumAngle)
                 {
-                    // get left, right, prev and next positions for edge
-                    B2DPoint aEdgeStart(rCandidate.getB2DPoint(a));
-                    B2DPoint aEdgeEnd(rCandidate.getB2DPoint((a + 1L) % nCount));
-
-                    // create geometry for edge and add to result
-                    B2DPolygon aEdgePolygon(createAreaGeometryForEdge(
-                        aEdgeStart, aEdgeEnd, fHalfLineWidth,
-                        bNeedToCreateJoinPolygon || bLastNeededToCreateJoinPolygon));
-                    aRetval.append(aEdgePolygon);
-
-                    if(bNeedToCreateJoinPolygon)
-                    {
-                        // create fill polygon for linejoin and add to result
-                        B2DPoint aNextEdge(rCandidate.getB2DPoint((a + 2L) % nCount));
-                        B2DPolygon aJoinPolygon(createAreaGeometryForJoin(
-                            aEdgeStart, aEdgeEnd, aNextEdge, fHalfLineWidth, eJoin, fDegreeStepWidth, fMiterMinimumAngle));
+                    // fallback to bevel
+                    eJoin = B2DLINEJOIN_BEVEL;
+                }
+            }
 
-                        if(aRetval.count())
-                        {
-                            aRetval.append(aJoinPolygon);
-                        }
-                    }
+            // create first polygon part for edge
+            aEdgePolygon.append(aEndPoint);
+            aEdgePolygon.append(rPoint);
+            aEdgePolygon.append(aStartPoint);
 
-                    bLastNeededToCreateJoinPolygon = bNeedToCreateJoinPolygon;
+            if(B2DLINEJOIN_MITER == eJoin)
+            {
+                // Look for the cut point between start point along rTangentPrev and
+                // end point along rTangentEdge. -rTangentEdge should be used, but since
+                // the cut value is used for interpolating along the first edge, the negation
+                // is not needed since the same fCut will be found on the first edge.
+                // If it exists, insert it to complete the mitered fill polygon.
+                double fCutPos(0.0);
+                tools::findCut(aStartPoint, rTangentPrev, aEndPoint, rTangentEdge, CUTFLAG_ALL, &fCutPos);
+
+                if(0.0 != fCutPos)
+                {
+                    const B2DPoint aCutPoint(interpolate(aStartPoint, aStartPoint + rTangentPrev, fCutPos));
+                    aEdgePolygon.append(aCutPoint);
                 }
             }
-            else if(nCount > 1L)
+            else if(B2DLINEJOIN_ROUND == eJoin)
             {
-                bool bLastNeededToCreateJoinPolygon(false);
+                // use tooling to add needed EllipseSegment
+                double fAngleStart(atan2(rPerpendPrev.getY(), rPerpendPrev.getX()));
+                double fAngleEnd(atan2(rPerpendEdge.getY(), rPerpendEdge.getX()));
 
-                for(sal_uInt32 a(0L); a < nCount - 1L; a++)
+                // atan2 results are [-PI .. PI], consolidate to [0.0 .. 2PI]
+                if(fAngleStart < 0.0)
                 {
-                    // get left, right positions for edge
-                    B2DPoint aEdgeStart(rCandidate.getB2DPoint(a));
-                    B2DPoint aEdgeEnd(rCandidate.getB2DPoint(a + 1L));
-                    const bool bNeedToCreateJoinPolygon((a + 2L < nCount) && B2DLINEJOIN_NONE != eJoin);
-
-                    // create geometry for edge and add to result
-                    B2DPolygon aEdgePolygon(
-                        createAreaGeometryForEdge(aEdgeStart, aEdgeEnd, fHalfLineWidth,
-                        bNeedToCreateJoinPolygon || bLastNeededToCreateJoinPolygon));
-                    aRetval.append(aEdgePolygon);
-
-                    // test if next exists
-                    if(bNeedToCreateJoinPolygon)
-                    {
-                        // create fill polygon for linejoin and add to result
-                        B2DPoint aNextEdge(rCandidate.getB2DPoint((a + 2L)));
-                        B2DPolygon aJoinPolygon(createAreaGeometryForJoin(
-                            aEdgeStart, aEdgeEnd, aNextEdge, fHalfLineWidth, eJoin, fDegreeStepWidth, fMiterMinimumAngle));
-
-                        if(aRetval.count())
-                        {
-                            aRetval.append(aJoinPolygon);
-                        }
-                    }
+                    fAngleStart += F_2PI;
+                }
 
-                    bLastNeededToCreateJoinPolygon = bNeedToCreateJoinPolygon;
+                if(fAngleEnd < 0.0)
+                {
+                    fAngleEnd += F_2PI;
                 }
+
+                aEdgePolygon.append(tools::createPolygonFromEllipseSegment(rPoint, fHalfLineWidth, fHalfLineWidth, fAngleStart, fAngleEnd));
             }
 
-            return aRetval;
+            // create last polygon part for edge
+            aEdgePolygon.setClosed(true);
+
+            return aEdgePolygon;
         }
+    } // end of anonymus namespace
 
-        B2DPolyPolygon createAreaGeometryForLineStartEnd(
+    namespace tools
+    {
+        B2DPolyPolygon createAreaGeometry(
             const B2DPolygon& rCandidate,
-            const B2DPolyPolygon& rArrow,
-            bool bStart,
-            double fWidth,
-            double fDockingPosition, // 0->top, 1->bottom
-            double* pConsumedLength)
+            double fHalfLineWidth,
+            B2DLineJoin eJoin,
+            double fMaxAllowedAngle,
+            double fMaxPartOfEdge,
+            double fMiterMinimumAngle)
         {
-            OSL_ENSURE(rCandidate.count() > 1L, "createAreaGeometryForLineStartEnd: Line polygon has too less points too small (!)");
-            OSL_ENSURE(rArrow.count() > 0L, "createAreaGeometryForLineStartEnd: No arrow PolyPolygon (!)");
-            OSL_ENSURE(fWidth > 0.0, "createAreaGeometryForLineStartEnd: Width too small (!)");
-            OSL_ENSURE(fDockingPosition >= 0.0 && fDockingPosition <= 1.0,
-                "createAreaGeometryForLineStartEnd: fDockingPosition out of range [0.0 .. 1.0] (!)");
+            if(fMaxAllowedAngle > F_PI2)
+            {
+                fMaxAllowedAngle = F_PI2;
+            }
+            else if(fMaxAllowedAngle < 0.01 * F_PI2)
+            {
+                fMaxAllowedAngle = 0.01 * F_PI2;
+            }
 
-            // init return value from arrow
-            B2DPolyPolygon aRetval(rArrow);
+            if(fMaxPartOfEdge > 1.0)
+            {
+                fMaxPartOfEdge = 1.0;
+            }
+            else if(fMaxPartOfEdge < 0.01)
+            {
+                fMaxPartOfEdge = 0.01;
+            }
 
-            // get size of the arrow
-            const B2DRange aArrowSize(getRange(rArrow));
+            if(fMiterMinimumAngle > F_PI)
+            {
+                fMiterMinimumAngle = F_PI;
+            }
+            else if(fMiterMinimumAngle < 0.01 * F_PI)
+            {
+                fMiterMinimumAngle = 0.01 * F_PI;
+            }
 
-            // build ArrowTransform
-            B2DHomMatrix aArrowTransform;
+            B2DPolygon aCandidate(rCandidate);
+            const double fMaxCos(cos(fMaxAllowedAngle));
 
-            // center in X, align with axis in Y
-            aArrowTransform.translate(-aArrowSize.getCenter().getX(), -aArrowSize.getMinimum().getY());
+            aCandidate.removeDoublePoints();
+            aCandidate = subdivideToSimple(aCandidate, fMaxCos * fMaxCos, fMaxPartOfEdge * fMaxPartOfEdge);
 
-            // scale to target size
-            const double fArrowScale(fWidth / (aArrowSize.getRange().getX()));
-            aArrowTransform.scale(fArrowScale, fArrowScale);
+            const sal_uInt32 nPointCount(aCandidate.count());
 
-            // get arrow size in Y
-            B2DPoint aUpperCenter(aArrowSize.getCenter().getX(), aArrowSize.getMaximum().getY());
-            aUpperCenter *= aArrowTransform;
-            const double fArrowYLength(B2DVector(aUpperCenter).getLength());
+            if(nPointCount)
+            {
+                B2DPolyPolygon aRetval;
+                const bool bEventuallyCreateLineJoin(B2DLINEJOIN_NONE != eJoin);
+                const bool bIsClosed(aCandidate.isClosed());
+                const sal_uInt32 nEdgeCount(bIsClosed ? nPointCount : nPointCount - 1);
 
-            // move arrow to have docking position centered
-            aArrowTransform.translate(0.0, -fArrowYLength * fDockingPosition);
+                if(nEdgeCount)
+                {
+                    B2DCubicBezier aEdge;
+                    B2DCubicBezier aPrev;
+
+                    // prepare edge
+                    aEdge.setStartPoint(aCandidate.getB2DPoint(0));
 
-            // get the polygon vector we want to plant this arrow on
-            const double fCandidateLength(getLength(rCandidate));
-            const double fConsumedLength(fArrowYLength * (1.0 - fDockingPosition));
-            const B2DVector aHead(rCandidate.getB2DPoint((bStart) ? 0L : rCandidate.count() - 1L));
-            const B2DVector aTail(getPositionAbsolute(rCandidate,
-                (bStart) ? fConsumedLength : fCandidateLength - fConsumedLength, fCandidateLength));
+                    if(bIsClosed && bEventuallyCreateLineJoin)
+                    {
+                        // prepare previous edge
+                        const sal_uInt32 nPrevIndex(nPointCount - 1);
+                        aPrev.setStartPoint(aCandidate.getB2DPoint(nPrevIndex));
+                        aPrev.setControlPointA(aCandidate.getNextControlPoint(nPrevIndex));
+                        aPrev.setControlPointB(aCandidate.getPrevControlPoint(0));
+                        aPrev.setEndPoint(aEdge.getStartPoint());
+                    }
+
+                    for(sal_uInt32 a(0); a < nEdgeCount; a++)
+                    {
+                        // fill current Edge
+                        const sal_uInt32 nNextIndex((a + 1) % nPointCount);
+                        aEdge.setControlPointA(aCandidate.getNextControlPoint(a));
+                        aEdge.setControlPointB(aCandidate.getPrevControlPoint(nNextIndex));
+                        aEdge.setEndPoint(aCandidate.getB2DPoint(nNextIndex));
+
+                        // check and create linejoin
+                        if(bEventuallyCreateLineJoin && (bIsClosed || 0 != a))
+                        {
+                            const B2DVector aTangentPrev(aPrev.getTangent(1.0));
+                            const B2DVector aTangentEdge(aEdge.getTangent(0.0));
+                            B2VectorOrientation aOrientation(getOrientation(aTangentPrev, aTangentEdge));
+
+                            if(ORIENTATION_NEUTRAL == aOrientation)
+                            {
+                                // they are parallell or empty; if they are both not zero and point
+                                // in opposite direction, a half-circle is needed
+                                if(!aTangentPrev.equalZero() && !aTangentEdge.equalZero())
+                                {
+                                    const double fAngle(fabs(aTangentPrev.angle(aTangentEdge)));
+
+                                    if(fTools::equal(fAngle, F_PI))
+                                    {
+                                        // for half-circle production, fallback to positive
+                                        // orientation
+                                        aOrientation = ORIENTATION_POSITIVE;
+                                    }
+                                }
+                            }
 
-            // from that vector, take the needed rotation and add rotate for arrow to transformation
-            const B2DVector aTargetDirection(aHead - aTail);
-            const double fRotation(atan2(aTargetDirection.getY(), aTargetDirection.getX()) + (90.0 * F_PI180));
+                            if(ORIENTATION_POSITIVE == aOrientation)
+                            {
+                                const B2DVector aPerpendPrev(getNormalizedPerpendicular(aTangentPrev) * -fHalfLineWidth);
+                                const B2DVector aPerpendEdge(getNormalizedPerpendicular(aTangentEdge) * -fHalfLineWidth);
+
+                                aRetval.append(createAreaGeometryForJoin(
+                                    aTangentPrev, aTangentEdge,
+                                    aPerpendPrev, aPerpendEdge,
+                                    aEdge.getStartPoint(), fHalfLineWidth,
+                                    eJoin, fMiterMinimumAngle));
+                            }
+                            else if(ORIENTATION_NEGATIVE == aOrientation)
+                            {
+                                const B2DVector aPerpendPrev(getNormalizedPerpendicular(aTangentPrev) * fHalfLineWidth);
+                                const B2DVector aPerpendEdge(getNormalizedPerpendicular(aTangentEdge) * fHalfLineWidth);
+
+                                aRetval.append(createAreaGeometryForJoin(
+                                    aTangentEdge, aTangentPrev,
+                                    aPerpendEdge, aPerpendPrev,
+                                    aEdge.getStartPoint(), fHalfLineWidth,
+                                    eJoin, fMiterMinimumAngle));
+                            }
+                        }
 
-            // rotate around docking position
-            aArrowTransform.rotate(fRotation);
+                        // create geometry for edge
+                        aRetval.append(createAreaGeometryForEdge(aEdge, fHalfLineWidth));
 
-            // move arrow docking position to polygon head
-            aArrowTransform.translate(aHead.getX(), aHead.getY());
+                        // prepare next step
+                        if(bEventuallyCreateLineJoin)
+                        {
+                            aPrev = aEdge;
+                        }
 
-            // transform retval and close
-            aRetval.transform(aArrowTransform);
-            aRetval.setClosed(true);
+                        aEdge.setStartPoint(aEdge.getEndPoint());
+                    }
+                }
 
-            // if pConsumedLength is asked for, fill it
-            if(pConsumedLength)
+                return aRetval;
+            }
+            else
             {
-                *pConsumedLength = fConsumedLength;
+                return B2DPolyPolygon(rCandidate);
             }
-
-            return aRetval;
         }
     } // end of namespace tools
 } // end of namespace basegfx