summaryrefslogtreecommitdiff
path: root/basegfx/source/polygon
diff options
context:
space:
mode:
Diffstat (limited to 'basegfx/source/polygon')
-rw-r--r--basegfx/source/polygon/b2dpolygon.cxx495
-rw-r--r--basegfx/source/polygon/b2dpolygontools.cxx1410
-rw-r--r--basegfx/source/polygon/b2dpolypolygon.cxx349
-rw-r--r--basegfx/source/polygon/b2dpolypolygoncutter.cxx1542
-rw-r--r--basegfx/source/polygon/b2dpolypolygontools.cxx221
-rw-r--r--basegfx/source/polygon/b3dpolygon.cxx373
-rw-r--r--basegfx/source/polygon/b3dpolygontools.cxx453
-rw-r--r--basegfx/source/polygon/b3dpolypolygon.cxx331
-rw-r--r--basegfx/source/polygon/b3dpolypolygontools.cxx43
9 files changed, 2678 insertions, 2539 deletions
diff --git a/basegfx/source/polygon/b2dpolygon.cxx b/basegfx/source/polygon/b2dpolygon.cxx
index 7a9b477081f5..0dcbeaa7a3a2 100644
--- a/basegfx/source/polygon/b2dpolygon.cxx
+++ b/basegfx/source/polygon/b2dpolygon.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolygon.cxx,v $
*
- * $Revision: 1.6 $
+ * $Revision: 1.7 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:10 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:05 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -86,17 +86,17 @@
class CoordinateData2D
{
- ::basegfx::point::B2DPoint maPoint;
+ ::basegfx::B2DPoint maPoint;
public:
CoordinateData2D() {}
- CoordinateData2D(const ::basegfx::point::B2DPoint& rData) : maPoint(rData) {}
+ CoordinateData2D(const ::basegfx::B2DPoint& rData) : maPoint(rData) {}
~CoordinateData2D() {}
- const ::basegfx::point::B2DPoint& getCoordinate() const { return maPoint; }
- void setCoordinate(const ::basegfx::point::B2DPoint& rValue) { if(rValue != maPoint) maPoint = rValue; }
+ const ::basegfx::B2DPoint& getCoordinate() const { return maPoint; }
+ void setCoordinate(const ::basegfx::B2DPoint& rValue) { if(rValue != maPoint) maPoint = rValue; }
sal_Bool operator==(const CoordinateData2D& rData ) const { return (maPoint == rData.getCoordinate()); }
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix) { maPoint *= rMatrix; }
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix) { maPoint *= rMatrix; }
};
//////////////////////////////////////////////////////////////////////////////
@@ -137,12 +137,12 @@ public:
return (maVector == rCandidate.maVector);
}
- const ::basegfx::point::B2DPoint& getCoordinate(sal_uInt32 nIndex) const
+ const ::basegfx::B2DPoint& getCoordinate(sal_uInt32 nIndex) const
{
return maVector[nIndex].getCoordinate();
}
- void setCoordinate(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue)
+ void setCoordinate(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
{
maVector[nIndex].setCoordinate(rValue);
}
@@ -233,7 +233,7 @@ public:
}
}
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix)
{
CoordinateData2DVector::iterator aStart(maVector.begin());
CoordinateData2DVector::iterator aEnd(maVector.end());
@@ -249,18 +249,18 @@ public:
class ControlVectorPair2D
{
- ::basegfx::vector::B2DVector maVectorA;
- ::basegfx::vector::B2DVector maVectorB;
+ ::basegfx::B2DVector maVectorA;
+ ::basegfx::B2DVector maVectorB;
public:
ControlVectorPair2D() {}
~ControlVectorPair2D() {}
- const ::basegfx::vector::B2DVector& getVectorA() const { return maVectorA; }
- void setVectorA(const ::basegfx::vector::B2DVector& rValue) { if(rValue != maVectorA) maVectorA = rValue; }
+ const ::basegfx::B2DVector& getVectorA() const { return maVectorA; }
+ void setVectorA(const ::basegfx::B2DVector& rValue) { if(rValue != maVectorA) maVectorA = rValue; }
- const ::basegfx::vector::B2DVector& getVectorB() const { return maVectorB; }
- void setVectorB(const ::basegfx::vector::B2DVector& rValue) { if(rValue != maVectorB) maVectorB = rValue; }
+ const ::basegfx::B2DVector& getVectorB() const { return maVectorB; }
+ void setVectorB(const ::basegfx::B2DVector& rValue) { if(rValue != maVectorB) maVectorB = rValue; }
sal_Bool operator==(const ControlVectorPair2D& rData ) const
{ return (maVectorA == rData.getVectorA() && maVectorB == rData.getVectorB()); }
@@ -329,12 +329,12 @@ public:
return (0L != mnUsedVectors);
}
- const ::basegfx::vector::B2DVector& getVectorA(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getVectorA(sal_uInt32 nIndex) const
{
return maVector[nIndex].getVectorA();
}
- void setVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
sal_Bool bWasUsed(mnUsedVectors && !maVector[nIndex].getVectorA().equalZero());
sal_Bool bIsUsed(!rValue.equalZero());
@@ -347,7 +347,7 @@ public:
}
else
{
- maVector[nIndex].setVectorA(::basegfx::vector::B2DVector::getEmptyVector());
+ maVector[nIndex].setVectorA(::basegfx::B2DVector::getEmptyVector());
mnUsedVectors--;
}
}
@@ -361,12 +361,12 @@ public:
}
}
- const ::basegfx::vector::B2DVector& getVectorB(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getVectorB(sal_uInt32 nIndex) const
{
return maVector[nIndex].getVectorB();
}
- void setVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
sal_Bool bWasUsed(mnUsedVectors && !maVector[nIndex].getVectorB().equalZero());
sal_Bool bIsUsed(!rValue.equalZero());
@@ -379,7 +379,7 @@ public:
}
else
{
- maVector[nIndex].setVectorB(::basegfx::vector::B2DVector::getEmptyVector());
+ maVector[nIndex].setVectorB(::basegfx::B2DVector::getEmptyVector());
mnUsedVectors--;
}
}
@@ -601,17 +601,17 @@ public:
return sal_False;
}
- const ::basegfx::point::B2DPoint& getPoint(sal_uInt32 nIndex) const
+ const ::basegfx::B2DPoint& getPoint(sal_uInt32 nIndex) const
{
return maPoints.getCoordinate(nIndex);
}
- void setPoint(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue)
+ void setPoint(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
{
maPoints.setCoordinate(nIndex, rValue);
}
- void insert(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
{
if(nCount)
{
@@ -626,7 +626,7 @@ public:
}
}
- const ::basegfx::vector::B2DVector& getControlVectorA(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getControlVectorA(sal_uInt32 nIndex) const
{
if(mpControlVector)
{
@@ -634,11 +634,11 @@ public:
}
else
{
- return ::basegfx::vector::B2DVector::getEmptyVector();
+ return ::basegfx::B2DVector::getEmptyVector();
}
}
- void setControlVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setControlVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
if(!mpControlVector)
{
@@ -665,7 +665,7 @@ public:
return (mpControlVector && mpControlVector->isUsed());
}
- const ::basegfx::vector::B2DVector& getControlVectorB(sal_uInt32 nIndex) const
+ const ::basegfx::B2DVector& getControlVectorB(sal_uInt32 nIndex) const
{
if(mpControlVector)
{
@@ -673,11 +673,11 @@ public:
}
else
{
- return ::basegfx::vector::B2DVector::getEmptyVector();
+ return ::basegfx::B2DVector::getEmptyVector();
}
}
- void setControlVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
+ void setControlVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
{
if(!mpControlVector)
{
@@ -775,10 +775,10 @@ public:
const sal_uInt32 nVectorSource(nCoorSource ? nCoorSource - 1L : nCount - 1L);
// get source data
- const ::basegfx::point::B2DPoint& rSourceCoor = pCoordinateCopy->getCoordinate(nCoorSource);
- const ::basegfx::point::B2DPoint& rVectorSourceCoor = pCoordinateCopy->getCoordinate(nVectorSource);
- const ::basegfx::vector::B2DVector& rVectorSourceA = pVectorCopy->getVectorA(nVectorSource);
- const ::basegfx::vector::B2DVector& rVectorSourceB = pVectorCopy->getVectorB(nVectorSource);
+ const ::basegfx::B2DPoint& rSourceCoor = pCoordinateCopy->getCoordinate(nCoorSource);
+ const ::basegfx::B2DPoint& rVectorSourceCoor = pCoordinateCopy->getCoordinate(nVectorSource);
+ const ::basegfx::B2DVector& rVectorSourceA = pVectorCopy->getVectorA(nVectorSource);
+ const ::basegfx::B2DVector& rVectorSourceB = pVectorCopy->getVectorB(nVectorSource);
// copy point data
maPoints.setCoordinate(a, rSourceCoor);
@@ -787,12 +787,12 @@ public:
if(rVectorSourceA.equalZero())
{
// unused, use zero vector
- mpControlVector->setVectorB(a, ::basegfx::vector::B2DVector::getEmptyVector());
+ mpControlVector->setVectorB(a, ::basegfx::B2DVector::getEmptyVector());
}
else
{
// calculate new vector relative to new point
- ::basegfx::vector::B2DVector aNewVectorB((rVectorSourceA + rVectorSourceCoor) - rSourceCoor);
+ ::basegfx::B2DVector aNewVectorB((rVectorSourceA + rVectorSourceCoor) - rSourceCoor);
mpControlVector->setVectorB(a, aNewVectorB);
}
@@ -800,12 +800,12 @@ public:
if(rVectorSourceB.equalZero())
{
// unused, use zero vector
- mpControlVector->setVectorA(a, ::basegfx::vector::B2DVector::getEmptyVector());
+ mpControlVector->setVectorA(a, ::basegfx::B2DVector::getEmptyVector());
}
else
{
// calculate new vector relative to new point
- ::basegfx::vector::B2DVector aNewVectorA((rVectorSourceB + rVectorSourceCoor) - rSourceCoor);
+ ::basegfx::B2DVector aNewVectorA((rVectorSourceB + rVectorSourceCoor) - rSourceCoor);
mpControlVector->setVectorA(a, aNewVectorA);
}
}
@@ -939,28 +939,28 @@ public:
}
}
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix)
{
if(mpControlVector)
{
for(sal_uInt32 a(0L); a < maPoints.count(); a++)
{
- ::basegfx::point::B2DPoint aCandidate = maPoints.getCoordinate(a);
+ ::basegfx::B2DPoint aCandidate = maPoints.getCoordinate(a);
if(mpControlVector->isUsed())
{
- const ::basegfx::vector::B2DVector& rVectorA(mpControlVector->getVectorA(a));
- const ::basegfx::vector::B2DVector& rVectorB(mpControlVector->getVectorB(a));
+ const ::basegfx::B2DVector& rVectorA(mpControlVector->getVectorA(a));
+ const ::basegfx::B2DVector& rVectorB(mpControlVector->getVectorB(a));
if(!rVectorA.equalZero())
{
- ::basegfx::vector::B2DVector aVectorA(rMatrix * rVectorA);
+ ::basegfx::B2DVector aVectorA(rMatrix * rVectorA);
mpControlVector->setVectorA(a, aVectorA);
}
if(!rVectorB.equalZero())
{
- ::basegfx::vector::B2DVector aVectorB(rMatrix * rVectorB);
+ ::basegfx::B2DVector aVectorB(rMatrix * rVectorB);
mpControlVector->setVectorB(a, aVectorB);
}
}
@@ -986,294 +986,291 @@ public:
namespace basegfx
{
- namespace polygon
- {
- // init static default Polygon
- static ImplB2DPolygon maStaticDefaultPolygon;
+ // init static default Polygon
+ static ImplB2DPolygon maStaticDefaultPolygon;
- void B2DPolygon::implForceUniqueCopy()
+ void B2DPolygon::implForceUniqueCopy()
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- mpPolygon = new ImplB2DPolygon(*mpPolygon);
- }
+ mpPolygon->decRefCount();
+ mpPolygon = new ImplB2DPolygon(*mpPolygon);
}
+ }
- B2DPolygon::B2DPolygon()
- : mpPolygon(&maStaticDefaultPolygon)
- {
- mpPolygon->incRefCount();
- }
+ B2DPolygon::B2DPolygon()
+ : mpPolygon(&maStaticDefaultPolygon)
+ {
+ mpPolygon->incRefCount();
+ }
+
+ B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon)
+ : mpPolygon(rPolygon.mpPolygon)
+ {
+ mpPolygon->incRefCount();
+ }
+
+ B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
+ : mpPolygon(new ImplB2DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
+ {
+ OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B2DPolygon constructor outside range (!)");
+ }
- B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon)
- : mpPolygon(rPolygon.mpPolygon)
+ B2DPolygon::~B2DPolygon()
+ {
+ if(mpPolygon->getRefCount())
{
- mpPolygon->incRefCount();
+ mpPolygon->decRefCount();
}
-
- B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
- : mpPolygon(new ImplB2DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
+ else
{
- OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B2DPolygon constructor outside range (!)");
+ delete mpPolygon;
}
+ }
- B2DPolygon::~B2DPolygon()
+ B2DPolygon& B2DPolygon::operator=(const B2DPolygon& rPolygon)
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- }
- else
- {
- delete mpPolygon;
- }
+ mpPolygon->decRefCount();
}
-
- B2DPolygon& B2DPolygon::operator=(const B2DPolygon& rPolygon)
+ else
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- }
- else
- {
- delete mpPolygon;
- }
-
- mpPolygon = rPolygon.mpPolygon;
- mpPolygon->incRefCount();
-
- return *this;
+ delete mpPolygon;
}
- sal_Bool B2DPolygon::operator==(const B2DPolygon& rPolygon) const
- {
- if(mpPolygon == rPolygon.mpPolygon)
- {
- return sal_True;
- }
+ mpPolygon = rPolygon.mpPolygon;
+ mpPolygon->incRefCount();
- return mpPolygon->isEqual(*(rPolygon.mpPolygon));
- }
+ return *this;
+ }
- sal_Bool B2DPolygon::operator!=(const B2DPolygon& rPolygon) const
+ sal_Bool B2DPolygon::operator==(const B2DPolygon& rPolygon) const
+ {
+ if(mpPolygon == rPolygon.mpPolygon)
{
- if(mpPolygon == rPolygon.mpPolygon)
- {
- return sal_False;
- }
-
- return !mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ return sal_True;
}
- sal_uInt32 B2DPolygon::count() const
+ return mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ }
+
+ sal_Bool B2DPolygon::operator!=(const B2DPolygon& rPolygon) const
+ {
+ if(mpPolygon == rPolygon.mpPolygon)
{
- return mpPolygon->count();
+ return sal_False;
}
- ::basegfx::point::B2DPoint B2DPolygon::getB2DPoint(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ return !mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ }
- return mpPolygon->getPoint(nIndex);
- }
+ sal_uInt32 B2DPolygon::count() const
+ {
+ return mpPolygon->count();
+ }
- void B2DPolygon::setB2DPoint(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rValue)
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ ::basegfx::B2DPoint B2DPolygon::getB2DPoint(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(mpPolygon->getPoint(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setPoint(nIndex, rValue);
- }
- }
+ return mpPolygon->getPoint(nIndex);
+ }
- void B2DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount)
- {
- OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
+ void B2DPolygon::setB2DPoint(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolygon->insert(nIndex, rPoint, nCount);
- }
+ if(mpPolygon->getPoint(nIndex) != rValue)
+ {
+ implForceUniqueCopy();
+ mpPolygon->setPoint(nIndex, rValue);
}
+ }
+
+ void B2DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
- void B2DPolygon::append(const ::basegfx::point::B2DPoint& rPoint, sal_uInt32 nCount)
+ if(nCount)
{
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
- }
+ implForceUniqueCopy();
+ mpPolygon->insert(nIndex, rPoint, nCount);
}
+ }
- ::basegfx::vector::B2DVector B2DPolygon::getControlVectorA(sal_uInt32 nIndex) const
+ void B2DPolygon::append(const ::basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
+ {
+ if(nCount)
{
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
-
- return mpPolygon->getControlVectorA(nIndex);
+ implForceUniqueCopy();
+ mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
}
+ }
- void B2DPolygon::setControlVectorA(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ ::basegfx::B2DVector B2DPolygon::getControlVectorA(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(mpPolygon->getControlVectorA(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setControlVectorA(nIndex, rValue);
- }
- }
+ return mpPolygon->getControlVectorA(nIndex);
+ }
- ::basegfx::vector::B2DVector B2DPolygon::getControlVectorB(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ void B2DPolygon::setControlVectorA(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- return mpPolygon->getControlVectorB(nIndex);
+ if(mpPolygon->getControlVectorA(nIndex) != rValue)
+ {
+ implForceUniqueCopy();
+ mpPolygon->setControlVectorA(nIndex, rValue);
}
+ }
- void B2DPolygon::setControlVectorB(sal_uInt32 nIndex, const ::basegfx::vector::B2DVector& rValue)
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+ ::basegfx::B2DVector B2DPolygon::getControlVectorB(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
- if(mpPolygon->getControlVectorB(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setControlVectorB(nIndex, rValue);
- }
- }
+ return mpPolygon->getControlVectorB(nIndex);
+ }
- sal_Bool B2DPolygon::areControlPointsUsed() const
+ void B2DPolygon::setControlVectorB(sal_uInt32 nIndex, const ::basegfx::B2DVector& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
+
+ if(mpPolygon->getControlVectorB(nIndex) != rValue)
{
- return mpPolygon->areControlPointsUsed();
+ implForceUniqueCopy();
+ mpPolygon->setControlVectorB(nIndex, rValue);
}
+ }
- void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
- {
- OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
+ sal_Bool B2DPolygon::areControlPointsUsed() const
+ {
+ return mpPolygon->areControlPointsUsed();
+ }
- if(rPoly.count())
- {
- implForceUniqueCopy();
+ void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
- if(!nCount)
- {
- nCount = rPoly.count();
- }
+ if(rPoly.count())
+ {
+ implForceUniqueCopy();
- if(0L == nIndex2 && nCount == rPoly.count())
- {
- mpPolygon->insert(nIndex, *rPoly.mpPolygon);
- }
- else
- {
- OSL_ENSURE(nIndex2 + nCount > rPoly.mpPolygon->count(), "B2DPolygon Insert outside range (!)");
- ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
- mpPolygon->insert(nIndex, aTempPoly);
- }
+ if(!nCount)
+ {
+ nCount = rPoly.count();
}
- }
- void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
- {
- if(rPoly.count())
+ if(0L == nIndex2 && nCount == rPoly.count())
{
- implForceUniqueCopy();
-
- if(!nCount)
- {
- nCount = rPoly.count();
- }
-
- if(0L == nIndex && nCount == rPoly.count())
- {
- mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
- }
- else
- {
- OSL_ENSURE(nIndex + nCount > rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
- ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
- mpPolygon->insert(mpPolygon->count(), aTempPoly);
- }
+ mpPolygon->insert(nIndex, *rPoly.mpPolygon);
+ }
+ else
+ {
+ OSL_ENSURE(nIndex2 + nCount > rPoly.mpPolygon->count(), "B2DPolygon Insert outside range (!)");
+ ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
+ mpPolygon->insert(nIndex, aTempPoly);
}
}
+ }
- void B2DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ if(rPoly.count())
{
- OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B2DPolygon Remove outside range (!)");
+ implForceUniqueCopy();
- if(nCount)
+ if(!nCount)
{
- implForceUniqueCopy();
- mpPolygon->remove(nIndex, nCount);
+ nCount = rPoly.count();
}
- }
- void B2DPolygon::clear()
- {
- if(mpPolygon->getRefCount())
+ if(0L == nIndex && nCount == rPoly.count())
{
- mpPolygon->decRefCount();
+ mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
}
else
{
- delete mpPolygon;
+ OSL_ENSURE(nIndex + nCount > rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
+ ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
+ mpPolygon->insert(mpPolygon->count(), aTempPoly);
}
-
- mpPolygon = &maStaticDefaultPolygon;
- mpPolygon->incRefCount();
}
+ }
- sal_Bool B2DPolygon::isClosed() const
+ void B2DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B2DPolygon Remove outside range (!)");
+
+ if(nCount)
{
- return mpPolygon->isClosed();
+ implForceUniqueCopy();
+ mpPolygon->remove(nIndex, nCount);
}
+ }
- void B2DPolygon::setClosed(sal_Bool bNew)
+ void B2DPolygon::clear()
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->isClosed() != bNew)
- {
- implForceUniqueCopy();
- mpPolygon->setClosed(bNew);
- }
+ mpPolygon->decRefCount();
+ }
+ else
+ {
+ delete mpPolygon;
}
- void B2DPolygon::flip()
+ mpPolygon = &maStaticDefaultPolygon;
+ mpPolygon->incRefCount();
+ }
+
+ sal_Bool B2DPolygon::isClosed() const
+ {
+ return mpPolygon->isClosed();
+ }
+
+ void B2DPolygon::setClosed(sal_Bool bNew)
+ {
+ if(mpPolygon->isClosed() != bNew)
{
- if(mpPolygon->count() > 1)
- {
- implForceUniqueCopy();
- mpPolygon->flip();
- }
+ implForceUniqueCopy();
+ mpPolygon->setClosed(bNew);
}
+ }
- sal_Bool B2DPolygon::hasDoublePoints() const
+ void B2DPolygon::flip()
+ {
+ if(mpPolygon->count() > 1)
{
- return mpPolygon->hasDoublePoints();
+ implForceUniqueCopy();
+ mpPolygon->flip();
}
+ }
- void B2DPolygon::removeDoublePoints()
+ sal_Bool B2DPolygon::hasDoublePoints() const
+ {
+ return mpPolygon->hasDoublePoints();
+ }
+
+ void B2DPolygon::removeDoublePoints()
+ {
+ if(mpPolygon->count() > 1)
{
- if(mpPolygon->count() > 1)
- {
- implForceUniqueCopy();
- mpPolygon->removeDoublePointsAtBeginEnd();
- mpPolygon->removeDoublePointsWholeTrack();
- }
+ implForceUniqueCopy();
+ mpPolygon->removeDoublePointsAtBeginEnd();
+ mpPolygon->removeDoublePointsWholeTrack();
}
+ }
- void B2DPolygon::transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void B2DPolygon::transform(const ::basegfx::B2DHomMatrix& rMatrix)
+ {
+ if(mpPolygon->count())
{
- if(mpPolygon->count())
- {
- implForceUniqueCopy();
- mpPolygon->transform(rMatrix);
- }
+ implForceUniqueCopy();
+ mpPolygon->transform(rMatrix);
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index c2a6faf8909a..6f5ef6e89fba 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolygontools.cxx,v $
*
- * $Revision: 1.8 $
+ * $Revision: 1.9 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:11 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:05 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -71,6 +71,10 @@
#include <basegfx/polygon/b2dpolygon.hxx>
#endif
+#ifndef _BGFX_POLYGON_B2DPOLYPOLYGON_HXX
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#endif
+
#ifndef _BGFX_NUMERIC_FTOOLS_HXX
#include <basegfx/numeric/ftools.hxx>
#endif
@@ -91,925 +95,993 @@
namespace basegfx
{
- namespace polygon
+ namespace tools
{
- namespace tools
+ // B2DPolygon tools
+ void checkClosed(B2DPolygon& rCandidate)
{
- // B2DPolygon tools
- void checkClosed(polygon::B2DPolygon& rCandidate)
+ while(rCandidate.count() > 1L
+ && rCandidate.getB2DPoint(0L).equal(rCandidate.getB2DPoint(rCandidate.count() - 1L)))
{
- while(rCandidate.count() > 1L
- && rCandidate.getB2DPoint(0L).equal(rCandidate.getB2DPoint(rCandidate.count() - 1L)))
- {
- rCandidate.setClosed(sal_True);
- rCandidate.remove(rCandidate.count() - 1L);
- }
+ rCandidate.setClosed(sal_True);
+ rCandidate.remove(rCandidate.count() - 1L);
}
+ }
+
+ // Get index of outmost point (e.g. biggest X and biggest Y)
+ sal_uInt32 getIndexOfOutmostPoint(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ sal_uInt32 nRetval(0L);
- // Get index of outmost point (e.g. biggest X and biggest Y)
- sal_uInt32 getIndexOfOutmostPoint(const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(rCandidate.count())
{
- sal_uInt32 nRetval(0L);
+ ::basegfx::B2DPoint aOutmostPoint(rCandidate.getB2DPoint(0L));
- if(rCandidate.count())
+ for(sal_uInt32 a(1L); a < rCandidate.count(); a++)
{
- ::basegfx::point::B2DPoint aOutmostPoint(rCandidate.getB2DPoint(0L));
+ ::basegfx::B2DPoint rPoint(rCandidate.getB2DPoint(a));
- for(sal_uInt32 a(1L); a < rCandidate.count(); a++)
+ if(::basegfx::fTools::more(rPoint.getX(), aOutmostPoint.getX()))
{
- ::basegfx::point::B2DPoint rPoint(rCandidate.getB2DPoint(a));
-
- if(::basegfx::numeric::fTools::more(rPoint.getX(), aOutmostPoint.getX()))
+ nRetval = a;
+ aOutmostPoint = rPoint;
+ }
+ else
+ {
+ if(::basegfx::fTools::more(rPoint.getY(), aOutmostPoint.getY()))
{
nRetval = a;
aOutmostPoint = rPoint;
}
- else
- {
- if(::basegfx::numeric::fTools::more(rPoint.getY(), aOutmostPoint.getY()))
- {
- nRetval = a;
- aOutmostPoint = rPoint;
- }
- }
}
}
-
- return nRetval;
}
- // Get successor and predecessor indices. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
- {
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ return nRetval;
+ }
- if(nIndex)
- {
- return nIndex - 1L;
- }
- else if(rCandidate.count())
- {
- return rCandidate.count() - 1L;
- }
- else
- {
- return nIndex;
- }
- }
+ // Get successor and predecessor indices. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(nIndex)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
-
- if(nIndex + 1L < rCandidate.count())
- {
- return nIndex + 1L;
- }
- else
- {
- return 0L;
- }
+ return nIndex - 1L;
}
-
- sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
+ else if(rCandidate.count())
{
- sal_uInt32 nNewIndex(nIndex);
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
-
- if(rCandidate.count() > 1)
- {
- nNewIndex = getIndexOfPredecessor(nIndex, rCandidate);
- ::basegfx::point::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
+ return rCandidate.count() - 1L;
+ }
+ else
+ {
+ return nIndex;
+ }
+ }
- while(nNewIndex != nIndex
- && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
- {
- nNewIndex = getIndexOfPredecessor(nNewIndex, rCandidate);
- }
- }
+ sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- return nNewIndex;
+ if(nIndex + 1L < rCandidate.count())
+ {
+ return nIndex + 1L;
}
+ else
+ {
+ return 0L;
+ }
+ }
+
+ sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ sal_uInt32 nNewIndex(nIndex);
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(rCandidate.count() > 1)
{
- sal_uInt32 nNewIndex(nIndex);
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ nNewIndex = getIndexOfPredecessor(nIndex, rCandidate);
+ ::basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
- if(rCandidate.count() > 1)
+ while(nNewIndex != nIndex
+ && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
{
- nNewIndex = getIndexOfSuccessor(nIndex, rCandidate);
- ::basegfx::point::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
-
- while(nNewIndex != nIndex
- && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
- {
- nNewIndex = getIndexOfSuccessor(nNewIndex, rCandidate);
- }
+ nNewIndex = getIndexOfPredecessor(nNewIndex, rCandidate);
}
-
- return nNewIndex;
}
- ::basegfx::vector::B2DVectorOrientation getOrientation(const ::basegfx::polygon::B2DPolygon& rCandidate)
+ return nNewIndex;
+ }
+
+ sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rCandidate)
+ {
+ sal_uInt32 nNewIndex(nIndex);
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+
+ if(rCandidate.count() > 1)
{
- ::basegfx::vector::B2DVectorOrientation eRetval(::basegfx::vector::ORIENTATION_NEUTRAL);
+ nNewIndex = getIndexOfSuccessor(nIndex, rCandidate);
+ ::basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
- if(rCandidate.count() > 2)
+ while(nNewIndex != nIndex
+ && aPoint.equal(rCandidate.getB2DPoint(nNewIndex)))
{
- sal_uInt32 nIndex = getIndexOfOutmostPoint(rCandidate);
- eRetval = getPointOrientation(rCandidate, nIndex);
+ nNewIndex = getIndexOfSuccessor(nNewIndex, rCandidate);
}
-
- return eRetval;
}
- ::basegfx::vector::B2DVectorContinuity getContinuityInPoint(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ return nNewIndex;
+ }
+
+ ::basegfx::B2DVectorOrientation getOrientation(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ ::basegfx::B2DVectorOrientation eRetval(::basegfx::ORIENTATION_NEUTRAL);
+
+ if(rCandidate.count() > 2)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- ::basegfx::vector::B2DVectorContinuity eRetval(::basegfx::vector::CONTINUITY_NONE);
+ sal_uInt32 nIndex = getIndexOfOutmostPoint(rCandidate);
+ eRetval = getPointOrientation(rCandidate, nIndex);
+ }
- if(rCandidate.count() > 1L && rCandidate.areControlPointsUsed())
- {
- sal_uInt32 nPrevInd(getIndexOfPredecessor(nIndex, rCandidate));
- const ::basegfx::vector::B2DVector aForwardVector(rCandidate.getControlVectorA(nIndex));
- const ::basegfx::vector::B2DVector aBackVector(rCandidate.getControlVectorB(nPrevInd));
+ return eRetval;
+ }
- eRetval = ::basegfx::vector::getContinuity(aBackVector, aForwardVector);
- }
+ ::basegfx::B2DVectorContinuity getContinuityInPoint(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ ::basegfx::B2DVectorContinuity eRetval(::basegfx::CONTINUITY_NONE);
+
+ if(rCandidate.count() > 1L && rCandidate.areControlPointsUsed())
+ {
+ sal_uInt32 nPrevInd(getIndexOfPredecessor(nIndex, rCandidate));
+ const ::basegfx::B2DVector aForwardVector(rCandidate.getControlVectorA(nIndex));
+ const ::basegfx::B2DVector aBackVector(rCandidate.getControlVectorB(nPrevInd));
- return eRetval;
+ eRetval = ::basegfx::getContinuity(aBackVector, aForwardVector);
}
- ::basegfx::polygon::B2DPolygon adaptiveSubdivideByDistance(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistanceBound)
+ return eRetval;
+ }
+
+ ::basegfx::B2DPolygon adaptiveSubdivideByDistance(const ::basegfx::B2DPolygon& rCandidate, double fDistanceBound)
+ {
+ ::basegfx::B2DPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aRetval(rCandidate);
+ const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ aRetval.clear();
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
- aRetval.clear();
+ const ::basegfx::B2DVector aVectorA(rCandidate.getControlVectorA(a));
+ const ::basegfx::B2DVector aVectorB(rCandidate.getControlVectorB(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(!aVectorA.equalZero() || !aVectorB.equalZero())
{
- const ::basegfx::vector::B2DVector aVectorA(rCandidate.getControlVectorA(a));
- const ::basegfx::vector::B2DVector aVectorB(rCandidate.getControlVectorB(a));
-
- if(!aVectorA.equalZero() || !aVectorB.equalZero())
- {
- // vectors are used, get points
- const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
- ::basegfx::point::B2DPoint aPointA(rCandidate.getB2DPoint(a));
- ::basegfx::point::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
-
- // build CubicBezier segment
- ::basegfx::curve::B2DCubicBezier aBezier(
- aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
-
- // generate DistanceBound
- double fBound;
+ // vectors are used, get points
+ const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
+ ::basegfx::B2DPoint aPointA(rCandidate.getB2DPoint(a));
+ ::basegfx::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
- if(0.0 == fDistanceBound)
- {
- // If not set, calculate rough length of bezier segment by taking
- // half of the sum of the edge and the control polygon
- ::basegfx::vector::B2DVector aSimpleDistance(aPointB - aPointA);
- ::basegfx::vector::B2DVector aTripleDistanceTop((aPointB + aVectorB) - (aPointA + aVectorA));
- const double fRoughLength(
- (aSimpleDistance.getLength()
- + (aVectorA.getLength() + aVectorB.getLength() + aTripleDistanceTop.getLength())) / 2.0);
-
- // take 1/100th of the rouch curve length
- fBound = fRoughLength * 0.01;
- }
- else
- {
- // use given bound value
- fBound = fDistanceBound;
- }
+ // build CubicBezier segment
+ ::basegfx::B2DCubicBezier aBezier(
+ aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
- // make sure bound value is not too small. The base units are 1/100th mm, thus
- // just make sure it's not smaller then 1/100th of that
- if(fBound < 0.01)
- {
- fBound = 0.01;
- }
+ // generate DistanceBound
+ double fBound;
- // call adaptive subdivide
- ::basegfx::curve::adaptiveSubdivideByDistance(aRetval, aBezier, fBound);
+ if(0.0 == fDistanceBound)
+ {
+ // If not set, calculate rough length of bezier segment by taking
+ // half of the sum of the edge and the control polygon
+ ::basegfx::B2DVector aSimpleDistance(aPointB - aPointA);
+ ::basegfx::B2DVector aTripleDistanceTop((aPointB + aVectorB) - (aPointA + aVectorA));
+ const double fRoughLength(
+ (aSimpleDistance.getLength()
+ + (aVectorA.getLength() + aVectorB.getLength() + aTripleDistanceTop.getLength())) / 2.0);
+
+ // take 1/100th of the rouch curve length
+ fBound = fRoughLength * 0.01;
}
else
{
- // no vectors used, add point
- aRetval.append(rCandidate.getB2DPoint(a));
+ // use given bound value
+ fBound = fDistanceBound;
+ }
+
+ // make sure bound value is not too small. The base units are 1/100th mm, thus
+ // just make sure it's not smaller then 1/100th of that
+ if(fBound < 0.01)
+ {
+ fBound = 0.01;
}
- }
- // check closed flag, aRetval was cleared and thus it may be invalid.
- if(aRetval.isClosed() != rCandidate.isClosed())
+ // call adaptive subdivide
+ ::basegfx::adaptiveSubdivideByDistance(aRetval, aBezier, fBound);
+ }
+ else
{
- aRetval.setClosed(rCandidate.isClosed());
+ // no vectors used, add point
+ aRetval.append(rCandidate.getB2DPoint(a));
}
}
- return aRetval;
+ // check closed flag, aRetval was cleared and thus it may be invalid.
+ if(aRetval.isClosed() != rCandidate.isClosed())
+ {
+ aRetval.setClosed(rCandidate.isClosed());
+ }
}
- ::basegfx::polygon::B2DPolygon adaptiveSubdivideByAngle(const ::basegfx::polygon::B2DPolygon& rCandidate, double fAngleBound)
+ return aRetval;
+ }
+
+ ::basegfx::B2DPolygon adaptiveSubdivideByAngle(const ::basegfx::B2DPolygon& rCandidate, double fAngleBound)
+ {
+ ::basegfx::B2DPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aRetval(rCandidate);
+ const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ aRetval.clear();
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- const sal_uInt32 nPointCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
- aRetval.clear();
+ const ::basegfx::B2DVector aVectorA(rCandidate.getControlVectorA(a));
+ const ::basegfx::B2DVector aVectorB(rCandidate.getControlVectorB(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(!aVectorA.equalZero() || !aVectorB.equalZero())
{
- const ::basegfx::vector::B2DVector aVectorA(rCandidate.getControlVectorA(a));
- const ::basegfx::vector::B2DVector aVectorB(rCandidate.getControlVectorB(a));
-
- if(!aVectorA.equalZero() || !aVectorB.equalZero())
- {
- // vectors are used, get points
- const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
- ::basegfx::point::B2DPoint aPointA(rCandidate.getB2DPoint(a));
- ::basegfx::point::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
+ // vectors are used, get points
+ const sal_uInt32 nNext(getIndexOfSuccessor(a, rCandidate));
+ ::basegfx::B2DPoint aPointA(rCandidate.getB2DPoint(a));
+ ::basegfx::B2DPoint aPointB(rCandidate.getB2DPoint(nNext));
- // build CubicBezier segment
- ::basegfx::curve::B2DCubicBezier aBezier(
- aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
+ // build CubicBezier segment
+ ::basegfx::B2DCubicBezier aBezier(
+ aPointA, aPointA + aVectorA, aPointB + aVectorB, aPointB);
- // generate AngleBound
- double fBound(fAngleBound);
+ // generate AngleBound
+ double fBound(fAngleBound);
- // make sure angle bound is not too small
- if(::basegfx::numeric::fTools::less(fAngleBound, 0.1))
- {
- fAngleBound = 0.1;
- }
-
- // call adaptive subdivide
- ::basegfx::curve::adaptiveSubdivideByAngle(aRetval, aBezier, fBound);
- }
- else
+ // make sure angle bound is not too small
+ if(::basegfx::fTools::less(fAngleBound, 0.1))
{
- // no vectors used, add point
- aRetval.append(rCandidate.getB2DPoint(a));
+ fAngleBound = 0.1;
}
- }
- // check closed flag, aRetval was cleared and thus it may be invalid.
- if(aRetval.isClosed() != rCandidate.isClosed())
+ // call adaptive subdivide
+ ::basegfx::adaptiveSubdivideByAngle(aRetval, aBezier, fBound);
+ }
+ else
{
- aRetval.setClosed(rCandidate.isClosed());
+ // no vectors used, add point
+ aRetval.append(rCandidate.getB2DPoint(a));
}
}
- return aRetval;
+ // check closed flag, aRetval was cleared and thus it may be invalid.
+ if(aRetval.isClosed() != rCandidate.isClosed())
+ {
+ aRetval.setClosed(rCandidate.isClosed());
+ }
}
- sal_Bool isInside(const ::basegfx::polygon::B2DPolygon& rCandidate, const ::basegfx::point::B2DPoint& rPoint, sal_Bool bWithBorder)
+ return aRetval;
+ }
+
+ sal_Bool isInside(const ::basegfx::B2DPolygon& rCandidate, const ::basegfx::B2DPoint& rPoint, sal_Bool bWithBorder)
+ {
+ sal_Bool bRetval(sal_False);
+ const sal_uInt32 nPointCount(rCandidate.count());
+
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- sal_Bool bRetval(sal_False);
- const sal_uInt32 nPointCount(rCandidate.count());
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(bWithBorder && aCurrentPoint.equal(rPoint))
{
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
+ return sal_True;
+ }
- if(bWithBorder && aCurrentPoint.equal(rPoint))
- {
- return sal_True;
- }
+ // cross-over in Y?
+ const ::basegfx::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
+ const sal_Bool bCompYA(::basegfx::fTools::more(aPreviousPoint.getY(), rPoint.getY()));
+ const sal_Bool bCompYB(::basegfx::fTools::more(aCurrentPoint.getY(), rPoint.getY()));
- // cross-over in Y?
- const ::basegfx::point::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
- const sal_Bool bCompYA(::basegfx::numeric::fTools::more(aPreviousPoint.getY(), rPoint.getY()));
- const sal_Bool bCompYB(::basegfx::numeric::fTools::more(aCurrentPoint.getY(), rPoint.getY()));
+ if(bCompYA != bCompYB)
+ {
+ const sal_Bool bCompXA(::basegfx::fTools::more(aPreviousPoint.getX(), rPoint.getX()));
+ const sal_Bool bCompXB(::basegfx::fTools::more(aCurrentPoint.getX(), rPoint.getX()));
- if(bCompYA != bCompYB)
+ if(bCompXA == bCompXB)
{
- const sal_Bool bCompXA(::basegfx::numeric::fTools::more(aPreviousPoint.getX(), rPoint.getX()));
- const sal_Bool bCompXB(::basegfx::numeric::fTools::more(aCurrentPoint.getX(), rPoint.getX()));
+ if(bCompXA)
+ {
+ bRetval = !bRetval;
+ }
+ }
+ else
+ {
+ const double fCompare =
+ aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) *
+ (aPreviousPoint.getX() - aCurrentPoint.getX()) /
+ (aPreviousPoint.getY() - aCurrentPoint.getY());
- if(bCompXA == bCompXB)
+ if(bWithBorder && ::basegfx::fTools::more(fCompare, rPoint.getX()))
{
- if(bCompXA)
- {
- bRetval = !bRetval;
- }
+ bRetval = !bRetval;
}
- else
+ else if(::basegfx::fTools::moreOrEqual(fCompare, rPoint.getX()))
{
- const double fCompare =
- aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) *
- (aPreviousPoint.getX() - aCurrentPoint.getX()) /
- (aPreviousPoint.getY() - aCurrentPoint.getY());
-
- if(bWithBorder && ::basegfx::numeric::fTools::more(fCompare, rPoint.getX()))
- {
- bRetval = !bRetval;
- }
- else if(::basegfx::numeric::fTools::moreOrEqual(fCompare, rPoint.getX()))
- {
- bRetval = !bRetval;
- }
+ bRetval = !bRetval;
}
}
}
-
- return bRetval;
}
- sal_Bool isInside(const ::basegfx::polygon::B2DPolygon& rCandidate, const ::basegfx::polygon::B2DPolygon& rPolygon, sal_Bool bWithBorder)
+ return bRetval;
+ }
+
+ sal_Bool isInside(const ::basegfx::B2DPolygon& rCandidate, const ::basegfx::B2DPolygon& rPolygon, sal_Bool bWithBorder)
+ {
+ const sal_uInt32 nPointCount(rPolygon.count());
+
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- const sal_uInt32 nPointCount(rPolygon.count());
+ const ::basegfx::B2DPoint aTestPoint(rPolygon.getB2DPoint(a));
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(!isInside(rCandidate, aTestPoint, bWithBorder))
{
- const ::basegfx::point::B2DPoint aTestPoint(rPolygon.getB2DPoint(a));
-
- if(!isInside(rCandidate, aTestPoint, bWithBorder))
- {
- return sal_False;
- }
+ return sal_False;
}
-
- return sal_True;
}
- ::basegfx::range::B2DRange getRange(const ::basegfx::polygon::B2DPolygon& rCandidate)
- {
- ::basegfx::range::B2DRange aRetval;
- const sal_uInt32 nPointCount(rCandidate.count());
+ return sal_True;
+ }
+
+ ::basegfx::B2DRange getRange(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ ::basegfx::B2DRange aRetval;
+ const sal_uInt32 nPointCount(rCandidate.count());
- if(rCandidate.areControlPointsUsed())
+ if(rCandidate.areControlPointsUsed())
+ {
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- for(sal_uInt32 a(0L); a < nPointCount; a++)
- {
- const ::basegfx::point::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
- const ::basegfx::vector::B2DVector aVectorA(rCandidate.getControlVectorA(a));
- const ::basegfx::vector::B2DVector aVectorB(rCandidate.getControlVectorB(a));
- aRetval.expand(aTestPoint);
+ const ::basegfx::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DVector aVectorA(rCandidate.getControlVectorA(a));
+ const ::basegfx::B2DVector aVectorB(rCandidate.getControlVectorB(a));
+ aRetval.expand(aTestPoint);
- if(!aVectorA.equalZero())
- {
- aRetval.expand(aTestPoint + aVectorA);
- }
+ if(!aVectorA.equalZero())
+ {
+ aRetval.expand(aTestPoint + aVectorA);
+ }
- if(!aVectorB.equalZero())
- {
- const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- aRetval.expand(aNextPoint + aVectorB);
- }
+ if(!aVectorB.equalZero())
+ {
+ const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ aRetval.expand(aNextPoint + aVectorB);
}
}
- else
+ }
+ else
+ {
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- for(sal_uInt32 a(0L); a < nPointCount; a++)
- {
- const ::basegfx::point::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
- aRetval.expand(aTestPoint);
- }
+ const ::basegfx::B2DPoint aTestPoint(rCandidate.getB2DPoint(a));
+ aRetval.expand(aTestPoint);
}
-
- return aRetval;
}
- double getArea(const ::basegfx::polygon::B2DPolygon& rCandidate)
- {
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
+ return aRetval;
+ }
- if(nPointCount > 2)
+ double getArea(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
+
+ if(nPointCount > 2)
+ {
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
{
- for(sal_uInt32 a(0L); a < nPointCount; a++)
- {
- const ::basegfx::point::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DPoint aPreviousPoint(rCandidate.getB2DPoint((!a) ? nPointCount - 1L : a - 1L));
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
- fRetval += aPreviousPoint.getX() * aCurrentPoint.getY();
- fRetval -= aPreviousPoint.getY() * aCurrentPoint.getX();
- }
+ fRetval += aPreviousPoint.getX() * aCurrentPoint.getY();
+ fRetval -= aPreviousPoint.getY() * aCurrentPoint.getX();
+ }
- fRetval /= 2.0;
+ fRetval /= 2.0;
- const double fZero(0.0);
+ const double fZero(0.0);
- if(::basegfx::numeric::fTools::less(fRetval, fZero))
- {
- fRetval = -fRetval;
- }
+ if(::basegfx::fTools::less(fRetval, fZero))
+ {
+ fRetval = -fRetval;
}
-
- return fRetval;
}
- double getEdgeLength(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex)
- {
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
+ return fRetval;
+ }
+
+ double getEdgeLength(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
- if(nIndex < nPointCount)
+ if(nIndex < nPointCount)
+ {
+ if(rCandidate.isClosed() || nIndex + 1 != nPointCount)
{
- if(rCandidate.isClosed() || nIndex + 1 != nPointCount)
- {
- const sal_uInt32 nNextIndex(nIndex + 1 == nPointCount ? 0L : nIndex + 1L);
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(nIndex));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- const ::basegfx::vector::B2DVector aVector(aNextPoint - aCurrentPoint);
- fRetval = aVector.getLength();
- }
+ const sal_uInt32 nNextIndex(nIndex + 1 == nPointCount ? 0L : nIndex + 1L);
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(nIndex));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ const ::basegfx::B2DVector aVector(aNextPoint - aCurrentPoint);
+ fRetval = aVector.getLength();
}
+ }
+
+ return fRetval;
+ }
- return fRetval;
+ double getLength(const ::basegfx::B2DPolygon& rCandidate)
+ {
+ // This method may also be implemented using a loop over getEdgeLength, but
+ // since this would cause a lot of sqare roots to be solved it is much better
+ // to sum up the quadrats first and then use a singe suare root (if necessary)
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
+ const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
+
+ for(sal_uInt32 a(0L); a < nLoopCount; a++)
+ {
+ const sal_uInt32 nNextIndex(a + 1 == nPointCount ? 0L : a + 1L);
+ const ::basegfx::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ const ::basegfx::B2DVector aVector(aNextPoint - aCurrentPoint);
+ fRetval += aVector.scalar(aVector);
}
- double getLength(const ::basegfx::polygon::B2DPolygon& rCandidate)
+ if(!::basegfx::fTools::equalZero(fRetval))
{
- // This method may also be implemented using a loop over getEdgeLength, but
- // since this would cause a lot of sqare roots to be solved it is much better
- // to sum up the quadrats first and then use a singe suare root (if necessary)
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
- const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
+ const double fOne(1.0);
- for(sal_uInt32 a(0L); a < nLoopCount; a++)
+ if(!::basegfx::fTools::equal(fOne, fRetval))
{
- const sal_uInt32 nNextIndex(a + 1 == nPointCount ? 0L : a + 1L);
- const ::basegfx::point::B2DPoint aCurrentPoint(rCandidate.getB2DPoint(a));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- const ::basegfx::vector::B2DVector aVector(aNextPoint - aCurrentPoint);
- fRetval += aVector.scalar(aVector);
+ fRetval = sqrt(fRetval);
}
+ }
- if(!::basegfx::numeric::fTools::equalZero(fRetval))
- {
- const double fOne(1.0);
+ return fRetval;
+ }
- if(!::basegfx::numeric::fTools::equal(fOne, fRetval))
- {
- fRetval = sqrt(fRetval);
- }
- }
-
- return fRetval;
- }
+ ::basegfx::B2DPoint getPositionAbsolute(const ::basegfx::B2DPolygon& rCandidate, double fDistance, double fLength)
+ {
+ ::basegfx::B2DPoint aRetval;
+ const sal_uInt32 nPointCount(rCandidate.count());
- ::basegfx::point::B2DPoint getPositionAbsolute(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistance, double fLength)
+ if(nPointCount > 1L)
{
- ::basegfx::point::B2DPoint aRetval;
- const sal_uInt32 nPointCount(rCandidate.count());
+ sal_uInt32 nIndex(0L);
+ sal_Bool bIndexDone(sal_False);
+ const double fZero(0.0);
+ double fEdgeLength(fZero);
- if(nPointCount > 1L)
+ // get length if not given
+ if(::basegfx::fTools::equalZero(fLength))
{
- sal_uInt32 nIndex(0L);
- sal_Bool bIndexDone(sal_False);
- const double fZero(0.0);
- double fEdgeLength(fZero);
+ fLength = getLength(rCandidate);
+ }
- // get length if not given
- if(::basegfx::numeric::fTools::equalZero(fLength))
+ // handle fDistance < 0.0
+ if(::basegfx::fTools::less(fDistance, fZero))
+ {
+ if(rCandidate.isClosed())
{
- fLength = getLength(rCandidate);
+ // if fDistance < 0.0 increment with multiple of fLength
+ sal_uInt32 nCount(sal_uInt32(-fDistance / fLength));
+ fDistance += double(nCount + 1L) * fLength;
}
+ else
+ {
+ // crop to polygon start
+ fDistance = fZero;
+ bIndexDone = sal_True;
+ }
+ }
- // handle fDistance < 0.0
- if(::basegfx::numeric::fTools::less(fDistance, fZero))
+ // handle fDistance >= fLength
+ if(::basegfx::fTools::moreOrEqual(fDistance, fLength))
+ {
+ if(rCandidate.isClosed())
{
- if(rCandidate.isClosed())
- {
- // if fDistance < 0.0 increment with multiple of fLength
- sal_uInt32 nCount(sal_uInt32(-fDistance / fLength));
- fDistance += double(nCount + 1L) * fLength;
- }
- else
- {
- // crop to polygon start
- fDistance = fZero;
- bIndexDone = sal_True;
- }
+ // if fDistance >= fLength decrement with multiple of fLength
+ sal_uInt32 nCount(sal_uInt32(fDistance / fLength));
+ fDistance -= (double)(nCount) * fLength;
+ }
+ else
+ {
+ // crop to polygon end
+ fDistance = fZero;
+ nIndex = nPointCount - 1L;
+ bIndexDone = sal_True;
}
+ }
- // handle fDistance >= fLength
- if(::basegfx::numeric::fTools::moreOrEqual(fDistance, fLength))
+ // look for correct index. fDistance is now [0.0 .. fLength[
+ if(!bIndexDone)
+ {
+ do
{
- if(rCandidate.isClosed())
+ // get length of next edge
+ fEdgeLength = getEdgeLength(rCandidate, nIndex);
+
+ if(::basegfx::fTools::moreOrEqual(fDistance, fEdgeLength))
{
- // if fDistance >= fLength decrement with multiple of fLength
- sal_uInt32 nCount(sal_uInt32(fDistance / fLength));
- fDistance -= (double)(nCount) * fLength;
+ // go to next edge
+ fDistance -= fEdgeLength;
+ nIndex++;
}
else
{
- // crop to polygon end
- fDistance = fZero;
- nIndex = nPointCount - 1L;
+ // it's on this edge, stop
bIndexDone = sal_True;
}
- }
-
- // look for correct index. fDistance is now [0.0 .. fLength[
- if(!bIndexDone)
- {
- do
- {
- // get length of next edge
- fEdgeLength = getEdgeLength(rCandidate, nIndex);
+ } while (!bIndexDone);
+ }
- if(::basegfx::numeric::fTools::moreOrEqual(fDistance, fEdgeLength))
- {
- // go to next edge
- fDistance -= fEdgeLength;
- nIndex++;
- }
- else
- {
- // it's on this edge, stop
- bIndexDone = sal_True;
- }
- } while (!bIndexDone);
- }
+ // get the point using nIndex
+ aRetval = rCandidate.getB2DPoint(nIndex);
- // get the point using nIndex
- aRetval = rCandidate.getB2DPoint(nIndex);
+ // if fDistance != 0.0, move that length on the edge. The edge
+ // length is in fEdgeLength.
+ if(!::basegfx::fTools::equalZero(fDistance))
+ {
+ sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
+ const ::basegfx::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
+ double fRelative(fZero);
- // if fDistance != 0.0, move that length on the edge. The edge
- // length is in fEdgeLength.
- if(!::basegfx::numeric::fTools::equalZero(fDistance))
+ if(!::basegfx::fTools::equalZero(fEdgeLength))
{
- sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
- const ::basegfx::point::B2DPoint aNextPoint(rCandidate.getB2DPoint(nNextIndex));
- double fRelative(fZero);
-
- if(!::basegfx::numeric::fTools::equalZero(fEdgeLength))
- {
- fRelative = fDistance / fEdgeLength;
- }
-
- // add calculated average value to the return value
- aRetval += ::basegfx::tuple::average(aRetval, aNextPoint, fRelative);
+ fRelative = fDistance / fEdgeLength;
}
- }
- return aRetval;
+ // add calculated average value to the return value
+ aRetval = ::basegfx::interpolate(aRetval, aNextPoint, fRelative);
+ }
}
- ::basegfx::point::B2DPoint getPositionRelative(const ::basegfx::polygon::B2DPolygon& rCandidate, double fDistance, double fLength)
- {
- // get length if not given
- if(::basegfx::numeric::fTools::equalZero(fLength))
- {
- fLength = getLength(rCandidate);
- }
+ return aRetval;
+ }
- // multiply fDistance with real length to get absolute position and
- // use getPositionAbsolute
- return getPositionAbsolute(rCandidate, fDistance * fLength, fLength);
+ ::basegfx::B2DPoint getPositionRelative(const ::basegfx::B2DPolygon& rCandidate, double fDistance, double fLength)
+ {
+ // get length if not given
+ if(::basegfx::fTools::equalZero(fLength))
+ {
+ fLength = getLength(rCandidate);
}
- ::basegfx::vector::B2DVectorOrientation getPointOrientation(const ::basegfx::polygon::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ // multiply fDistance with real length to get absolute position and
+ // use getPositionAbsolute
+ return getPositionAbsolute(rCandidate, fDistance * fLength, fLength);
+ }
+
+ ::basegfx::B2DVectorOrientation getPointOrientation(const ::basegfx::B2DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ ::basegfx::B2DVectorOrientation eRetval(::basegfx::ORIENTATION_NEUTRAL);
+
+ if(rCandidate.count() > 2)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- ::basegfx::vector::B2DVectorOrientation eRetval(::basegfx::vector::ORIENTATION_NEUTRAL);
+ sal_uInt32 nIndPrev = getIndexOfDifferentPredecessor(nIndex, rCandidate);
- if(rCandidate.count() > 2)
+ if(nIndPrev != nIndex)
{
- sal_uInt32 nIndPrev = getIndexOfDifferentPredecessor(nIndex, rCandidate);
+ sal_uInt32 nIndNext = getIndexOfDifferentSuccessor(nIndex, rCandidate);
- if(nIndPrev != nIndex)
+ if(nIndNext != nIndex && nIndNext != nIndPrev)
{
- sal_uInt32 nIndNext = getIndexOfDifferentSuccessor(nIndex, rCandidate);
-
- if(nIndNext != nIndex && nIndNext != nIndPrev)
- {
- ::basegfx::point::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
- ::basegfx::vector::B2DVector aVecPrev(rCandidate.getB2DPoint(nIndPrev) - aPoint);
- ::basegfx::vector::B2DVector aVecNext(rCandidate.getB2DPoint(nIndNext) - aPoint);
- eRetval = ::basegfx::vector::getOrientation(aVecPrev, aVecNext);
- }
+ ::basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex));
+ ::basegfx::B2DVector aVecPrev(rCandidate.getB2DPoint(nIndPrev) - aPoint);
+ ::basegfx::B2DVector aVecNext(rCandidate.getB2DPoint(nIndNext) - aPoint);
+ eRetval = ::basegfx::getOrientation(aVecPrev, aVecNext);
}
}
-
- return eRetval;
}
- CutFlagValue findCut(
- const ::basegfx::polygon::B2DPolygon& rCandidate,
- sal_uInt32 nIndex1, sal_uInt32 nIndex2,
- CutFlagValue aCutFlags,
- double* pCut1, double* pCut2)
- {
- CutFlagValue aRetval(CUTFLAG_NONE);
- const sal_uInt32 nPointCount(rCandidate.count());
+ return eRetval;
+ }
- if(nIndex1 < nPointCount && nIndex2 < nPointCount && nIndex1 != nIndex2)
- {
- sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate));
- sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate));
+ CutFlagValue findCut(
+ const ::basegfx::B2DPolygon& rCandidate,
+ sal_uInt32 nIndex1, sal_uInt32 nIndex2,
+ CutFlagValue aCutFlags,
+ double* pCut1, double* pCut2)
+ {
+ CutFlagValue aRetval(CUTFLAG_NONE);
+ const sal_uInt32 nPointCount(rCandidate.count());
- const ::basegfx::point::B2DPoint aStart1(rCandidate.getB2DPoint(nIndex1));
- const ::basegfx::point::B2DPoint aEnd1(rCandidate.getB2DPoint(nEnd1));
- const ::basegfx::vector::B2DVector aVector1(aEnd1 - aStart1);
+ if(nIndex1 < nPointCount && nIndex2 < nPointCount && nIndex1 != nIndex2)
+ {
+ sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate));
+ sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate));
- const ::basegfx::point::B2DPoint aStart2(rCandidate.getB2DPoint(nIndex2));
- const ::basegfx::point::B2DPoint aEnd2(rCandidate.getB2DPoint(nEnd2));
- const ::basegfx::vector::B2DVector aVector2(aEnd2 - aStart2);
+ const ::basegfx::B2DPoint aStart1(rCandidate.getB2DPoint(nIndex1));
+ const ::basegfx::B2DPoint aEnd1(rCandidate.getB2DPoint(nEnd1));
+ const ::basegfx::B2DVector aVector1(aEnd1 - aStart1);
- aRetval = findCut(
- aStart1, aVector1, aStart2, aVector2,
- aCutFlags, pCut1, pCut2);
- }
+ const ::basegfx::B2DPoint aStart2(rCandidate.getB2DPoint(nIndex2));
+ const ::basegfx::B2DPoint aEnd2(rCandidate.getB2DPoint(nEnd2));
+ const ::basegfx::B2DVector aVector2(aEnd2 - aStart2);
- return aRetval;
+ aRetval = findCut(
+ aStart1, aVector1, aStart2, aVector2,
+ aCutFlags, pCut1, pCut2);
}
- CutFlagValue findCut(
- const ::basegfx::polygon::B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
- const ::basegfx::polygon::B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
- CutFlagValue aCutFlags,
- double* pCut1, double* pCut2)
- {
- CutFlagValue aRetval(CUTFLAG_NONE);
- const sal_uInt32 nPointCount1(rCandidate1.count());
- const sal_uInt32 nPointCount2(rCandidate2.count());
+ return aRetval;
+ }
- if(nIndex1 < nPointCount1 && nIndex2 < nPointCount2)
- {
- sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate1));
- sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate2));
+ CutFlagValue findCut(
+ const ::basegfx::B2DPolygon& rCandidate1, sal_uInt32 nIndex1,
+ const ::basegfx::B2DPolygon& rCandidate2, sal_uInt32 nIndex2,
+ CutFlagValue aCutFlags,
+ double* pCut1, double* pCut2)
+ {
+ CutFlagValue aRetval(CUTFLAG_NONE);
+ const sal_uInt32 nPointCount1(rCandidate1.count());
+ const sal_uInt32 nPointCount2(rCandidate2.count());
- const ::basegfx::point::B2DPoint aStart1(rCandidate1.getB2DPoint(nIndex1));
- const ::basegfx::point::B2DPoint aEnd1(rCandidate1.getB2DPoint(nEnd1));
- const ::basegfx::vector::B2DVector aVector1(aEnd1 - aStart1);
+ if(nIndex1 < nPointCount1 && nIndex2 < nPointCount2)
+ {
+ sal_uInt32 nEnd1(getIndexOfSuccessor(nIndex1, rCandidate1));
+ sal_uInt32 nEnd2(getIndexOfSuccessor(nIndex2, rCandidate2));
- const ::basegfx::point::B2DPoint aStart2(rCandidate2.getB2DPoint(nIndex2));
- const ::basegfx::point::B2DPoint aEnd2(rCandidate2.getB2DPoint(nEnd2));
- const ::basegfx::vector::B2DVector aVector2(aEnd2 - aStart2);
+ const ::basegfx::B2DPoint aStart1(rCandidate1.getB2DPoint(nIndex1));
+ const ::basegfx::B2DPoint aEnd1(rCandidate1.getB2DPoint(nEnd1));
+ const ::basegfx::B2DVector aVector1(aEnd1 - aStart1);
- aRetval = findCut(
- aStart1, aVector1, aStart2, aVector2,
- aCutFlags, pCut1, pCut2);
- }
+ const ::basegfx::B2DPoint aStart2(rCandidate2.getB2DPoint(nIndex2));
+ const ::basegfx::B2DPoint aEnd2(rCandidate2.getB2DPoint(nEnd2));
+ const ::basegfx::B2DVector aVector2(aEnd2 - aStart2);
- return aRetval;
+ aRetval = findCut(
+ aStart1, aVector1, aStart2, aVector2,
+ aCutFlags, pCut1, pCut2);
}
- CutFlagValue findCut(
- const ::basegfx::point::B2DPoint& rEdge1Start, const ::basegfx::vector::B2DVector& rEdge1Delta,
- const ::basegfx::point::B2DPoint& rEdge2Start, const ::basegfx::vector::B2DVector& rEdge2Delta,
- CutFlagValue aCutFlags,
- double* pCut1, double* pCut2)
- {
- CutFlagValue aRetval(CUTFLAG_NONE);
- double fCut1(0.0);
- double fCut2(0.0);
- sal_Bool bFinished(!((sal_Bool)(aCutFlags & CUTFLAG_ALL)));
+ return aRetval;
+ }
- // test for same points?
- if(!bFinished
- && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END1))
- && (aCutFlags & (CUTFLAG_START2|CUTFLAG_END2)))
+ CutFlagValue findCut(
+ const ::basegfx::B2DPoint& rEdge1Start, const ::basegfx::B2DVector& rEdge1Delta,
+ const ::basegfx::B2DPoint& rEdge2Start, const ::basegfx::B2DVector& rEdge2Delta,
+ CutFlagValue aCutFlags,
+ double* pCut1, double* pCut2)
+ {
+ CutFlagValue aRetval(CUTFLAG_NONE);
+ double fCut1(0.0);
+ double fCut2(0.0);
+ sal_Bool bFinished(!((sal_Bool)(aCutFlags & CUTFLAG_ALL)));
+
+ // test for same points?
+ if(!bFinished
+ && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END1))
+ && (aCutFlags & (CUTFLAG_START2|CUTFLAG_END2)))
+ {
+ // same startpoint?
+ if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_START2)) == (CUTFLAG_START1|CUTFLAG_START2))
{
- // same startpoint?
- if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_START2)) == (CUTFLAG_START1|CUTFLAG_START2))
+ if(rEdge1Start.equal(rEdge2Start))
{
- if(rEdge1Start.equal(rEdge2Start))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_START1|CUTFLAG_START2);
- }
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_START1|CUTFLAG_START2);
}
+ }
- // same endpoint?
- if(!bFinished && (aCutFlags & (CUTFLAG_END1|CUTFLAG_END2)) == (CUTFLAG_END1|CUTFLAG_END2))
- {
- const ::basegfx::point::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
- const ::basegfx::point::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
+ // same endpoint?
+ if(!bFinished && (aCutFlags & (CUTFLAG_END1|CUTFLAG_END2)) == (CUTFLAG_END1|CUTFLAG_END2))
+ {
+ const ::basegfx::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
+ const ::basegfx::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
- if(aEnd1.equal(aEnd2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_END1|CUTFLAG_END2);
- fCut1 = fCut2 = 1.0;
- }
+ if(aEnd1.equal(aEnd2))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_END1|CUTFLAG_END2);
+ fCut1 = fCut2 = 1.0;
}
+ }
- // startpoint1 == endpoint2?
- if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END2)) == (CUTFLAG_START1|CUTFLAG_END2))
- {
- const ::basegfx::point::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
+ // startpoint1 == endpoint2?
+ if(!bFinished && (aCutFlags & (CUTFLAG_START1|CUTFLAG_END2)) == (CUTFLAG_START1|CUTFLAG_END2))
+ {
+ const ::basegfx::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
- if(rEdge1Start.equal(aEnd2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_START1|CUTFLAG_END2);
- fCut1 = 0.0;
- fCut2 = 1.0;
- }
+ if(rEdge1Start.equal(aEnd2))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_START1|CUTFLAG_END2);
+ fCut1 = 0.0;
+ fCut2 = 1.0;
}
+ }
- // startpoint2 == endpoint1?
- if(!bFinished&& (aCutFlags & (CUTFLAG_START2|CUTFLAG_END1)) == (CUTFLAG_START2|CUTFLAG_END1))
- {
- const ::basegfx::point::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
+ // startpoint2 == endpoint1?
+ if(!bFinished&& (aCutFlags & (CUTFLAG_START2|CUTFLAG_END1)) == (CUTFLAG_START2|CUTFLAG_END1))
+ {
+ const ::basegfx::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
- if(rEdge2Start.equal(aEnd1))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_START2|CUTFLAG_END1);
- fCut1 = 1.0;
- fCut2 = 0.0;
- }
+ if(rEdge2Start.equal(aEnd1))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_START2|CUTFLAG_END1);
+ fCut1 = 1.0;
+ fCut2 = 0.0;
}
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_LINE))
+ if(!bFinished && (aCutFlags & CUTFLAG_LINE))
+ {
+ if(!bFinished && (aCutFlags & CUTFLAG_START1))
{
- if(!bFinished && (aCutFlags & CUTFLAG_START1))
+ // start1 on line 2 ?
+ if(isPointOnEdge(rEdge1Start, rEdge2Start, rEdge2Delta, &fCut2))
{
- // start1 on line 2 ?
- if(isPointOnEdge(rEdge1Start, rEdge2Start, rEdge2Delta, &fCut2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_START1);
- }
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_START1);
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_START2))
+ if(!bFinished && (aCutFlags & CUTFLAG_START2))
+ {
+ // start2 on line 1 ?
+ if(isPointOnEdge(rEdge2Start, rEdge1Start, rEdge1Delta, &fCut1))
{
- // start2 on line 1 ?
- if(isPointOnEdge(rEdge2Start, rEdge1Start, rEdge1Delta, &fCut1))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_START2);
- }
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_START2);
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_END1))
- {
- // end1 on line 2 ?
- const ::basegfx::point::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
+ if(!bFinished && (aCutFlags & CUTFLAG_END1))
+ {
+ // end1 on line 2 ?
+ const ::basegfx::B2DPoint aEnd1(rEdge1Start + rEdge1Delta);
- if(isPointOnEdge(aEnd1, rEdge2Start, rEdge2Delta, &fCut2))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_END1);
- }
+ if(isPointOnEdge(aEnd1, rEdge2Start, rEdge2Delta, &fCut2))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_END1);
}
+ }
- if(!bFinished && (aCutFlags & CUTFLAG_END2))
- {
- // end2 on line 1 ?
- const ::basegfx::point::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
+ if(!bFinished && (aCutFlags & CUTFLAG_END2))
+ {
+ // end2 on line 1 ?
+ const ::basegfx::B2DPoint aEnd2(rEdge2Start + rEdge2Delta);
- if(isPointOnEdge(aEnd2, rEdge1Start, rEdge1Delta, &fCut1))
- {
- bFinished = sal_True;
- aRetval = (CUTFLAG_LINE|CUTFLAG_END2);
- }
+ if(isPointOnEdge(aEnd2, rEdge1Start, rEdge1Delta, &fCut1))
+ {
+ bFinished = sal_True;
+ aRetval = (CUTFLAG_LINE|CUTFLAG_END2);
}
+ }
+
+ if(!bFinished)
+ {
+ // cut in line1, line2 ?
+ fCut1 = (rEdge1Delta.getX() * rEdge2Delta.getY()) - (rEdge1Delta.getY() * rEdge2Delta.getX());
- if(!bFinished)
+ if(!::basegfx::fTools::equalZero(fCut1))
{
- // cut in line1, line2 ?
- fCut1 = (rEdge1Delta.getX() * rEdge2Delta.getY()) - (rEdge1Delta.getY() * rEdge2Delta.getX());
+ fCut1 = (rEdge2Delta.getY() * (rEdge2Start.getX() - rEdge1Start.getX())
+ + rEdge2Delta.getX() * (rEdge1Start.getY() - rEdge2Start.getY())) / fCut1;
- if(!::basegfx::numeric::fTools::equalZero(fCut1))
- {
- fCut1 = (rEdge2Delta.getY() * (rEdge2Start.getX() - rEdge1Start.getX())
- + rEdge2Delta.getX() * (rEdge1Start.getY() - rEdge2Start.getY())) / fCut1;
+ const double fZero(0.0);
+ const double fOne(1.0);
- const double fZero(0.0);
- const double fOne(1.0);
+ // inside parameter range edge1 AND fCut2 is calcable
+ if(::basegfx::fTools::more(fCut1, fZero) && ::basegfx::fTools::less(fCut1, fOne)
+ && (!::basegfx::fTools::equalZero(rEdge2Delta.getX()) || !::basegfx::fTools::equalZero(rEdge2Delta.getY())))
+ {
+ // take the mopre precise calculation of the two possible
+ if(fabs(rEdge2Delta.getX()) > fabs(rEdge2Delta.getY()))
+ {
+ fCut2 = (rEdge1Start.getX() + fCut1
+ * rEdge1Delta.getX() - rEdge2Start.getX()) / rEdge2Delta.getX();
+ }
+ else
+ {
+ fCut2 = (rEdge1Start.getY() + fCut1
+ * rEdge1Delta.getY() - rEdge2Start.getY()) / rEdge2Delta.getY();
+ }
- // inside parameter range edge1 AND fCut2 is calcable
- if(::basegfx::numeric::fTools::more(fCut1, fZero) && ::basegfx::numeric::fTools::less(fCut1, fOne)
- && (!::basegfx::numeric::fTools::equalZero(rEdge2Delta.getX()) || !::basegfx::numeric::fTools::equalZero(rEdge2Delta.getY())))
+ // inside parameter range edge2, too
+ if(::basegfx::fTools::more(fCut2, fZero) && ::basegfx::fTools::less(fCut2, fOne))
{
- // take the mopre precise calculation of the two possible
- if(fabs(rEdge2Delta.getX()) > fabs(rEdge2Delta.getY()))
- {
- fCut2 = (rEdge1Start.getX() + fCut1
- * rEdge1Delta.getX() - rEdge2Start.getX()) / rEdge2Delta.getX();
- }
- else
- {
- fCut2 = (rEdge1Start.getY() + fCut1
- * rEdge1Delta.getY() - rEdge2Start.getY()) / rEdge2Delta.getY();
- }
-
- // inside parameter range edge2, too
- if(::basegfx::numeric::fTools::more(fCut2, fZero) && ::basegfx::numeric::fTools::less(fCut2, fOne))
- {
- bFinished = sal_True;
- aRetval = CUTFLAG_LINE;
- }
+ bFinished = sal_True;
+ aRetval = CUTFLAG_LINE;
}
}
}
}
+ }
- // copy values if wanted
- if(pCut1)
- {
- *pCut1 = fCut1;
- }
-
- if(pCut2)
- {
- *pCut2 = fCut2;
- }
-
- return aRetval;
+ // copy values if wanted
+ if(pCut1)
+ {
+ *pCut1 = fCut1;
}
- sal_Bool isPointOnEdge(
- const ::basegfx::point::B2DPoint& rPoint,
- const ::basegfx::point::B2DPoint& rEdgeStart,
- const ::basegfx::vector::B2DVector& rEdgeDelta,
- double* pCut)
+ if(pCut2)
{
- sal_Bool bDeltaXIsZero(::basegfx::numeric::fTools::equalZero(rEdgeDelta.getX()));
- sal_Bool bDeltaYIsZero(::basegfx::numeric::fTools::equalZero(rEdgeDelta.getY()));
- const double fZero(0.0);
- const double fOne(1.0);
+ *pCut2 = fCut2;
+ }
- if(bDeltaXIsZero && bDeltaYIsZero)
- {
- // no line, just a point
- return sal_False;
- }
- else if(bDeltaXIsZero)
+ return aRetval;
+ }
+
+ sal_Bool isPointOnEdge(
+ const ::basegfx::B2DPoint& rPoint,
+ const ::basegfx::B2DPoint& rEdgeStart,
+ const ::basegfx::B2DVector& rEdgeDelta,
+ double* pCut)
+ {
+ sal_Bool bDeltaXIsZero(::basegfx::fTools::equalZero(rEdgeDelta.getX()));
+ sal_Bool bDeltaYIsZero(::basegfx::fTools::equalZero(rEdgeDelta.getY()));
+ const double fZero(0.0);
+ const double fOne(1.0);
+
+ if(bDeltaXIsZero && bDeltaYIsZero)
+ {
+ // no line, just a point
+ return sal_False;
+ }
+ else if(bDeltaXIsZero)
+ {
+ // vertical line
+ if(::basegfx::fTools::equal(rPoint.getX(), rEdgeStart.getX()))
{
- // vertical line
- if(::basegfx::numeric::fTools::equal(rPoint.getX(), rEdgeStart.getX()))
- {
- double fValue = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
+ double fValue = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
- if(::basegfx::numeric::fTools::more(fValue, fZero) && ::basegfx::numeric::fTools::less(fValue, fOne))
+ if(::basegfx::fTools::more(fValue, fZero) && ::basegfx::fTools::less(fValue, fOne))
+ {
+ if(pCut)
{
- if(pCut)
- {
- *pCut = fValue;
- }
-
- return sal_True;
+ *pCut = fValue;
}
+
+ return sal_True;
}
}
- else if(bDeltaYIsZero)
+ }
+ else if(bDeltaYIsZero)
+ {
+ // horizontal line
+ if(::basegfx::fTools::equal(rPoint.getY(), rEdgeStart.getY()))
{
- // horizontal line
- if(::basegfx::numeric::fTools::equal(rPoint.getY(), rEdgeStart.getY()))
- {
- double fValue = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
+ double fValue = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
- if(::basegfx::numeric::fTools::more(fValue, fZero)
- && ::basegfx::numeric::fTools::less(fValue, fOne))
+ if(::basegfx::fTools::more(fValue, fZero)
+ && ::basegfx::fTools::less(fValue, fOne))
+ {
+ if(pCut)
{
- if(pCut)
- {
- *pCut = fValue;
- }
-
- return sal_True;
+ *pCut = fValue;
}
+
+ return sal_True;
}
}
- else
+ }
+ else
+ {
+ // any angle line
+ double fTOne = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
+ double fTTwo = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
+
+ if(::basegfx::fTools::equal(fTOne, fTTwo))
{
- // any angle line
- double fTOne = (rPoint.getX() - rEdgeStart.getX()) / rEdgeDelta.getX();
- double fTTwo = (rPoint.getY() - rEdgeStart.getY()) / rEdgeDelta.getY();
+ // same parameter representation, point is on line. Take
+ // middle value for better results
+ double fValue = (fTOne + fTTwo) / 2.0;
- if(::basegfx::numeric::fTools::equal(fTOne, fTTwo))
+ if(::basegfx::fTools::more(fValue, fZero) && ::basegfx::fTools::less(fValue, fOne))
{
- // same parameter representation, point is on line. Take
- // middle value for better results
- double fValue = (fTOne + fTTwo) / 2.0;
+ // point is inside line bounds, too
+ if(pCut)
+ {
+ *pCut = fValue;
+ }
+
+ return sal_True;
+ }
+ }
+ }
- if(::basegfx::numeric::fTools::more(fValue, fZero) && ::basegfx::numeric::fTools::less(fValue, fOne))
+ return sal_False;
+ }
+
+ ::basegfx::B2DPolyPolygon applyLineDashing(const ::basegfx::B2DPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen)
+ {
+ ::basegfx::B2DPolyPolygon aRetval;
+
+ if(rCandidate.count() && fFullDashDotLen > 0.0)
+ {
+ const sal_uInt32 nCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ sal_uInt32 nDashDotIndex(0L);
+ double fDashDotLength(raDashDotArray[nDashDotIndex]);
+
+ for(sal_uInt32 a(0L); a < nCount; a++)
+ {
+ const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
+ const ::basegfx::B2DPoint aStart(rCandidate.getB2DPoint(a));
+ const ::basegfx::B2DPoint aEnd(rCandidate.getB2DPoint(nNextIndex));
+ const ::basegfx::B2DVector aVector(aEnd - aStart);
+ double fLength(aVector.getLength());
+ double fPosOnVector(0.0);
+
+ while(fLength >= fDashDotLength)
+ {
+ // handle [fPosOnVector .. fPosOnVector+fDashDotLength]
+ if(nDashDotIndex % 2)
{
- // point is inside line bounds, too
- if(pCut)
+ ::basegfx::B2DPolygon aResult;
+
+ // add start point
+ if(fPosOnVector == 0.0)
+ {
+ aResult.append(aStart);
+ }
+ else
{
- *pCut = fValue;
+ aResult.append(aStart + (aVector * fPosOnVector));
}
- return sal_True;
+ // add end point
+ aResult.append(aStart + (aVector * (fPosOnVector + fDashDotLength)));
+
+ // add line to PolyPolygon
+ aRetval.append(aResult);
}
+
+ // consume from fDashDotLength
+ fPosOnVector += fDashDotLength;
+ fLength -= fDashDotLength;
+ nDashDotIndex = (nDashDotIndex + 1L) % raDashDotArray.size();
+ fDashDotLength = raDashDotArray[nDashDotIndex];
}
- }
- return sal_False;
+ // handle [fPosOnVector .. fPosOnVector+fLength (bzw. end)]
+ if((fLength > 0.0) && (nDashDotIndex % 2))
+ {
+ ::basegfx::B2DPolygon aResult;
+
+ // add start and end point
+ const ::basegfx::B2DPoint aPosA(aStart + (aVector * fPosOnVector));
+ aResult.append(aPosA);
+
+ // add line to PolyPolygon
+ aRetval.append(aResult);
+ }
+
+ // consume from fDashDotLength
+ fDashDotLength -= fLength;
+ }
}
- } // end of namespace tools
- } // end of namespace polygon
+
+ return aRetval;
+ }
+ } // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dpolypolygon.cxx b/basegfx/source/polygon/b2dpolypolygon.cxx
index 301d5a68edd8..f6fcbd9c0e55 100644
--- a/basegfx/source/polygon/b2dpolypolygon.cxx
+++ b/basegfx/source/polygon/b2dpolypolygon.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygon.cxx,v $
*
- * $Revision: 1.6 $
+ * $Revision: 1.7 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:11 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -81,7 +81,7 @@
class ImplB2DPolyPolygon
{
- typedef ::std::vector< ::basegfx::polygon::B2DPolygon > PolygonVector;
+ typedef ::std::vector< ::basegfx::B2DPolygon > PolygonVector;
PolygonVector maPolygons;
sal_uInt32 mnRefCount;
@@ -127,17 +127,17 @@ public:
return sal_True;
}
- const ::basegfx::polygon::B2DPolygon& getB2DPolygon(sal_uInt32 nIndex) const
+ const ::basegfx::B2DPolygon& getB2DPolygon(sal_uInt32 nIndex) const
{
return maPolygons[nIndex];
}
- void setB2DPolygon(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rPolygon)
+ void setB2DPolygon(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rPolygon)
{
maPolygons[nIndex] = rPolygon;
}
- void insert(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolygon& rPolygon, sal_uInt32 nCount)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPolygon& rPolygon, sal_uInt32 nCount)
{
if(nCount)
{
@@ -148,7 +148,7 @@ public:
}
}
- void insert(sal_uInt32 nIndex, const ::basegfx::polygon::B2DPolyPolygon& rPolyPolygon)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B2DPolyPolygon& rPolyPolygon)
{
const sal_uInt32 nCount = rPolyPolygon.count();
@@ -209,7 +209,7 @@ public:
}
}
- void transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B2DHomMatrix& rMatrix)
{
for(sal_uInt32 a(0L); a < maPolygons.size(); a++)
{
@@ -222,247 +222,244 @@ public:
namespace basegfx
{
- namespace polygon
- {
- // init static default Polygon
- static ImplB2DPolyPolygon maStaticDefaultPolyPolygon;
+ // init static default Polygon
+ static ImplB2DPolyPolygon maStaticDefaultPolyPolygon;
- void B2DPolyPolygon::implForceUniqueCopy()
+ void B2DPolyPolygon::implForceUniqueCopy()
+ {
+ if(mpPolyPolygon->getRefCount())
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- mpPolyPolygon = new ImplB2DPolyPolygon(*mpPolyPolygon);
- }
+ mpPolyPolygon->decRefCount();
+ mpPolyPolygon = new ImplB2DPolyPolygon(*mpPolyPolygon);
}
+ }
- B2DPolyPolygon::B2DPolyPolygon()
- : mpPolyPolygon(&maStaticDefaultPolyPolygon)
- {
- mpPolyPolygon->incRefCount();
- }
+ B2DPolyPolygon::B2DPolyPolygon()
+ : mpPolyPolygon(&maStaticDefaultPolyPolygon)
+ {
+ mpPolyPolygon->incRefCount();
+ }
- B2DPolyPolygon::B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon)
- : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
+ B2DPolyPolygon::B2DPolyPolygon(const B2DPolyPolygon& rPolyPolygon)
+ : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
+ {
+ mpPolyPolygon->incRefCount();
+ }
+
+ B2DPolyPolygon::~B2DPolyPolygon()
+ {
+ if(mpPolyPolygon->getRefCount())
{
- mpPolyPolygon->incRefCount();
+ mpPolyPolygon->decRefCount();
}
-
- B2DPolyPolygon::~B2DPolyPolygon()
+ else
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
+ delete mpPolyPolygon;
}
+ }
- B2DPolyPolygon& B2DPolyPolygon::operator=(const B2DPolyPolygon& rPolyPolygon)
+ B2DPolyPolygon& B2DPolyPolygon::operator=(const B2DPolyPolygon& rPolyPolygon)
+ {
+ if(mpPolyPolygon->getRefCount())
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
-
- mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
- mpPolyPolygon->incRefCount();
-
- return *this;
+ mpPolyPolygon->decRefCount();
}
-
- sal_Bool B2DPolyPolygon::operator==(const B2DPolyPolygon& rPolyPolygon) const
+ else
{
- if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
- {
- return sal_True;
- }
-
- return mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ delete mpPolyPolygon;
}
- sal_Bool B2DPolyPolygon::operator!=(const B2DPolyPolygon& rPolyPolygon) const
- {
- if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
- {
- return sal_False;
- }
+ mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
+ mpPolyPolygon->incRefCount();
- return !mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
- }
+ return *this;
+ }
- sal_uInt32 B2DPolyPolygon::count() const
+ sal_Bool B2DPolyPolygon::operator==(const B2DPolyPolygon& rPolyPolygon) const
+ {
+ if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
{
- return mpPolyPolygon->count();
+ return sal_True;
}
- B2DPolygon B2DPolyPolygon::getB2DPolygon(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
+ return mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ }
- return mpPolyPolygon->getB2DPolygon(nIndex);
+ sal_Bool B2DPolyPolygon::operator!=(const B2DPolyPolygon& rPolyPolygon) const
+ {
+ if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
+ {
+ return sal_False;
}
- void B2DPolyPolygon::setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon)
- {
- OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
+ return !mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ }
- if(mpPolyPolygon->getB2DPolygon(nIndex) != rPolygon)
- {
- implForceUniqueCopy();
- mpPolyPolygon->setB2DPolygon(nIndex, rPolygon);
- }
- }
+ sal_uInt32 B2DPolyPolygon::count() const
+ {
+ return mpPolyPolygon->count();
+ }
- sal_Bool B2DPolyPolygon::areControlPointsUsed() const
- {
- for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
- {
- const ::basegfx::polygon::B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
+ B2DPolygon B2DPolyPolygon::getB2DPolygon(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
- if(rPolygon.areControlPointsUsed())
- {
- return sal_True;
- }
- }
+ return mpPolyPolygon->getB2DPolygon(nIndex);
+ }
- return sal_False;
+ void B2DPolyPolygon::setB2DPolygon(sal_uInt32 nIndex, const B2DPolygon& rPolygon)
+ {
+ OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B2DPolyPolygon access outside range (!)");
+
+ if(mpPolyPolygon->getB2DPolygon(nIndex) != rPolygon)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->setB2DPolygon(nIndex, rPolygon);
}
+ }
- void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ sal_Bool B2DPolyPolygon::areControlPointsUsed() const
+ {
+ for(sal_uInt32 a(0L); a < mpPolyPolygon->count(); a++)
{
- OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
+ const ::basegfx::B2DPolygon& rPolygon = mpPolyPolygon->getB2DPolygon(a);
- if(nCount)
+ if(rPolygon.areControlPointsUsed())
{
- implForceUniqueCopy();
- mpPolyPolygon->insert(nIndex, rPolygon, nCount);
+ return sal_True;
}
}
- void B2DPolyPolygon::append(const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ return sal_False;
+ }
+
+ void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
+
+ if(nCount)
{
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(nIndex, rPolygon, nCount);
}
+ }
- void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon)
+ void B2DPolyPolygon::append(const B2DPolygon& rPolygon, sal_uInt32 nCount)
+ {
+ if(nCount)
{
- OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
-
- if(rPolyPolygon.count())
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(nIndex, rPolyPolygon);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
}
+ }
+
+ void B2DPolyPolygon::insert(sal_uInt32 nIndex, const B2DPolyPolygon& rPolyPolygon)
+ {
+ OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B2DPolyPolygon Insert outside range (!)");
- void B2DPolyPolygon::append(const B2DPolyPolygon& rPolyPolygon)
+ if(rPolyPolygon.count())
{
- if(rPolyPolygon.count())
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(nIndex, rPolyPolygon);
}
+ }
- void B2DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ void B2DPolyPolygon::append(const B2DPolyPolygon& rPolyPolygon)
+ {
+ if(rPolyPolygon.count())
{
- OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B2DPolyPolygon Remove outside range (!)");
-
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->remove(nIndex, nCount);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
}
+ }
- void B2DPolyPolygon::clear()
- {
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
+ void B2DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B2DPolyPolygon Remove outside range (!)");
- mpPolyPolygon = &maStaticDefaultPolyPolygon;
- mpPolyPolygon->incRefCount();
+ if(nCount)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->remove(nIndex, nCount);
}
+ }
- sal_Bool B2DPolyPolygon::isClosed() const
+ void B2DPolyPolygon::clear()
+ {
+ if(mpPolyPolygon->getRefCount())
+ {
+ mpPolyPolygon->decRefCount();
+ }
+ else
{
- sal_Bool bRetval(sal_True);
+ delete mpPolyPolygon;
+ }
- // PolyPOlygon is closed when all contained Polygons are closed or
- // no Polygon exists.
- for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
- {
- if(!(mpPolyPolygon->getB2DPolygon(a)).isClosed())
- {
- bRetval = sal_False;
- }
- }
+ mpPolyPolygon = &maStaticDefaultPolyPolygon;
+ mpPolyPolygon->incRefCount();
+ }
- return bRetval;
- }
+ sal_Bool B2DPolyPolygon::isClosed() const
+ {
+ sal_Bool bRetval(sal_True);
- void B2DPolyPolygon::setClosed(sal_Bool bNew)
+ // PolyPOlygon is closed when all contained Polygons are closed or
+ // no Polygon exists.
+ for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
{
- if(bNew != isClosed())
+ if(!(mpPolyPolygon->getB2DPolygon(a)).isClosed())
{
- implForceUniqueCopy();
- mpPolyPolygon->setClosed(bNew);
+ bRetval = sal_False;
}
}
- void B2DPolyPolygon::flip()
+ return bRetval;
+ }
+
+ void B2DPolyPolygon::setClosed(sal_Bool bNew)
+ {
+ if(bNew != isClosed())
{
implForceUniqueCopy();
- mpPolyPolygon->flip();
+ mpPolyPolygon->setClosed(bNew);
}
+ }
- sal_Bool B2DPolyPolygon::hasDoublePoints() const
- {
- sal_Bool bRetval(sal_False);
-
- for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
- {
- if((mpPolyPolygon->getB2DPolygon(a)).hasDoublePoints())
- {
- bRetval = sal_True;
- }
- }
+ void B2DPolyPolygon::flip()
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->flip();
+ }
- return bRetval;
- }
+ sal_Bool B2DPolyPolygon::hasDoublePoints() const
+ {
+ sal_Bool bRetval(sal_False);
- void B2DPolyPolygon::removeDoublePoints()
+ for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
{
- if(hasDoublePoints())
+ if((mpPolyPolygon->getB2DPolygon(a)).hasDoublePoints())
{
- implForceUniqueCopy();
- mpPolyPolygon->removeDoublePoints();
+ bRetval = sal_True;
}
}
- void B2DPolyPolygon::transform(const ::basegfx::matrix::B2DHomMatrix& rMatrix)
+ return bRetval;
+ }
+
+ void B2DPolyPolygon::removeDoublePoints()
+ {
+ if(hasDoublePoints())
{
implForceUniqueCopy();
- mpPolyPolygon->transform(rMatrix);
+ mpPolyPolygon->removeDoublePoints();
}
- } // end of namespace polygon
+ }
+
+ void B2DPolyPolygon::transform(const ::basegfx::B2DHomMatrix& rMatrix)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->transform(rMatrix);
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/polygon/b2dpolypolygoncutter.cxx b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
index a86bfce3d937..17d1c476acbf 100644
--- a/basegfx/source/polygon/b2dpolypolygoncutter.cxx
+++ b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygoncutter.cxx,v $
*
- * $Revision: 1.3 $
+ * $Revision: 1.4 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:12 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -88,231 +88,228 @@
namespace basegfx
{
- namespace polygon
+ B2DPolygonNode::B2DPolygonNode(const ::basegfx::B2DPoint& rPosition, B2DPolygonNode* pPrevious)
+ : maPosition(rPosition)
{
- B2DPolygonNode::B2DPolygonNode(const ::basegfx::point::B2DPoint& rPosition, B2DPolygonNode* pPrevious)
- : maPosition(rPosition)
- {
- mpListPrevious = this;
- mpListNext = this;
+ mpListPrevious = this;
+ mpListNext = this;
- if(pPrevious)
- {
- mpNext = pPrevious->getNext();
- mpPrevious = pPrevious;
- mpNext->mpPrevious = this;
- mpPrevious->mpNext = this;
- }
- else
- {
- mpPrevious = mpNext = this;
- }
+ if(pPrevious)
+ {
+ mpNext = pPrevious->getNext();
+ mpPrevious = pPrevious;
+ mpNext->mpPrevious = this;
+ mpPrevious->mpNext = this;
}
-
- B2DPolygonNode::~B2DPolygonNode()
+ else
{
- if(mpNext != this)
- {
- mpPrevious->mpNext = mpNext;
- mpNext->mpPrevious = mpPrevious;
- }
+ mpPrevious = mpNext = this;
}
+ }
- void B2DPolygonNode::calcMinMaxX(double& fMaxAX, double& fMinAX) const
+ B2DPolygonNode::~B2DPolygonNode()
+ {
+ if(mpNext != this)
{
- if(maPosition.getX() > mpNext->maPosition.getX())
- {
- fMaxAX = maPosition.getX();
- fMinAX = mpNext->maPosition.getX();
- }
- else
- {
- fMaxAX = mpNext->maPosition.getX();
- fMinAX = maPosition.getX();
- }
+ mpPrevious->mpNext = mpNext;
+ mpNext->mpPrevious = mpPrevious;
}
+ }
- void B2DPolygonNode::calcMinMaxY(double& fMaxAY, double& fMinAY) const
+ void B2DPolygonNode::calcMinMaxX(double& fMaxAX, double& fMinAX) const
+ {
+ if(maPosition.getX() > mpNext->maPosition.getX())
{
- if(maPosition.getY() > mpNext->maPosition.getY())
- {
- fMaxAY = maPosition.getY();
- fMinAY = mpNext->maPosition.getY();
- }
- else
- {
- fMaxAY = mpNext->maPosition.getY();
- fMinAY = maPosition.getY();
- }
+ fMaxAX = maPosition.getX();
+ fMinAX = mpNext->maPosition.getX();
+ }
+ else
+ {
+ fMaxAX = mpNext->maPosition.getX();
+ fMinAX = maPosition.getX();
}
+ }
- void B2DPolygonNode::swapNextPointers(B2DPolygonNode* pCand)
+ void B2DPolygonNode::calcMinMaxY(double& fMaxAY, double& fMinAY) const
+ {
+ if(maPosition.getY() > mpNext->maPosition.getY())
{
- B2DPolygonNode* pTemporary = mpNext;
- mpNext = pCand->mpNext;
- pCand->mpNext = pTemporary;
- mpNext->mpPrevious = this;
- pCand->mpNext->mpPrevious = pCand;
+ fMaxAY = maPosition.getY();
+ fMinAY = mpNext->maPosition.getY();
+ }
+ else
+ {
+ fMaxAY = mpNext->maPosition.getY();
+ fMinAY = maPosition.getY();
}
+ }
- void B2DPolygonNode::addToList(B2DPolygonNode*& rpList)
+ void B2DPolygonNode::swapNextPointers(B2DPolygonNode* pCand)
+ {
+ B2DPolygonNode* pTemporary = mpNext;
+ mpNext = pCand->mpNext;
+ pCand->mpNext = pTemporary;
+ mpNext->mpPrevious = this;
+ pCand->mpNext->mpPrevious = pCand;
+ }
+
+ void B2DPolygonNode::addToList(B2DPolygonNode*& rpList)
+ {
+ if(rpList)
{
- if(rpList)
- {
- mpListNext = rpList->mpListNext;
- rpList->mpListNext = this;
- mpListPrevious = rpList;
- mpListNext->mpListPrevious = this;
- }
- else
- {
- rpList = this;
- }
+ mpListNext = rpList->mpListNext;
+ rpList->mpListNext = this;
+ mpListPrevious = rpList;
+ mpListNext->mpListPrevious = this;
+ }
+ else
+ {
+ rpList = this;
}
+ }
- void B2DPolygonNode::remFromList(B2DPolygonNode*& rpList)
+ void B2DPolygonNode::remFromList(B2DPolygonNode*& rpList)
+ {
+ if(mpListNext != this)
{
- if(mpListNext != this)
+ if(rpList == this)
{
- if(rpList == this)
- {
- rpList = mpListPrevious;
- }
-
- mpListPrevious->mpListNext = mpListNext;
- mpListNext->mpListPrevious = mpListPrevious;
- mpListNext = mpListPrevious = this;
+ rpList = mpListPrevious;
}
- else
+
+ mpListPrevious->mpListNext = mpListNext;
+ mpListNext->mpListPrevious = mpListPrevious;
+ mpListNext = mpListPrevious = this;
+ }
+ else
+ {
+ if(rpList == this)
{
- if(rpList == this)
- {
- rpList = 0L;
- }
+ rpList = 0L;
}
}
+ }
- sal_Bool B2DPolygonNode::getOrientation() const
- {
- const B2DPolygonNode* pOutmost = this;
- const B2DPolygonNode* pCurrent = this->getNext();
+ sal_Bool B2DPolygonNode::getOrientation() const
+ {
+ const B2DPolygonNode* pOutmost = this;
+ const B2DPolygonNode* pCurrent = this->getNext();
- while(pCurrent != this)
+ while(pCurrent != this)
+ {
+ if(::basegfx::fTools::more(pOutmost->getPosition().getX(), pCurrent->getPosition().getX()))
{
- if(::basegfx::numeric::fTools::more(pOutmost->getPosition().getX(), pCurrent->getPosition().getX()))
+ if(pCurrent->getPosition().getX() < pOutmost->getPosition().getX())
+ {
+ pOutmost = pCurrent;
+ }
+ else
{
- if(pCurrent->getPosition().getX() < pOutmost->getPosition().getX())
+ if(pCurrent->getPosition().getY() < pOutmost->getPosition().getY())
{
pOutmost = pCurrent;
}
- else
- {
- if(pCurrent->getPosition().getY() < pOutmost->getPosition().getY())
- {
- pOutmost = pCurrent;
- }
- }
}
-
- // next node
- pCurrent = pCurrent->getNext();
}
- ::basegfx::vector::B2DVector aVec1(pOutmost->getPrevious()->getPosition() - pOutmost->getPosition());
- ::basegfx::vector::B2DVector aVec2(pOutmost->getNext()->getPosition() - pOutmost->getPosition());
- return sal_Bool(::basegfx::numeric::fTools::more(aVec1.getX() * aVec2.getY(), aVec1.getY() * aVec2.getX()));
+ // next node
+ pCurrent = pCurrent->getNext();
}
- void B2DPolygonNode::swapOrientation()
- {
- B2DPolygonNode* pCurrent = this;
+ ::basegfx::B2DVector aVec1(pOutmost->getPrevious()->getPosition() - pOutmost->getPosition());
+ ::basegfx::B2DVector aVec2(pOutmost->getNext()->getPosition() - pOutmost->getPosition());
+ return sal_Bool(::basegfx::fTools::more(aVec1.getX() * aVec2.getY(), aVec1.getY() * aVec2.getX()));
+ }
- do {
- pCurrent->swapPreviousNext();
- pCurrent = pCurrent->getPrevious();
- } while(pCurrent != this);
- }
+ void B2DPolygonNode::swapOrientation()
+ {
+ B2DPolygonNode* pCurrent = this;
- ::basegfx::range::B2DRange B2DPolygonNode::getRange() const
- {
- ::basegfx::range::B2DRange aRetval;
- const B2DPolygonNode* pCurrent = this;
+ do {
+ pCurrent->swapPreviousNext();
+ pCurrent = pCurrent->getPrevious();
+ } while(pCurrent != this);
+ }
- do {
- aRetval.expand(pCurrent->getPosition());
- pCurrent = pCurrent->getPrevious();
- } while(pCurrent != this);
+ ::basegfx::B2DRange B2DPolygonNode::getRange() const
+ {
+ ::basegfx::B2DRange aRetval;
+ const B2DPolygonNode* pCurrent = this;
- return aRetval;
- }
+ do {
+ aRetval.expand(pCurrent->getPosition());
+ pCurrent = pCurrent->getPrevious();
+ } while(pCurrent != this);
- sal_Bool B2DPolygonNode::isInside(const ::basegfx::point::B2DPoint& rPoint, sal_Bool bWithBorder) const
+ return aRetval;
+ }
+
+ sal_Bool B2DPolygonNode::isInside(const ::basegfx::B2DPoint& rPoint, sal_Bool bWithBorder) const
+ {
+ sal_Bool bInside(sal_False);
+ const B2DPolygonNode* pCurrent = this;
+
+ do
{
- sal_Bool bInside(sal_False);
- const B2DPolygonNode* pCurrent = this;
+ if(bWithBorder && pCurrent->getPosition().equal(rPoint))
+ {
+ return sal_True;
+ }
+
+ B2DPolygonNode* pNext = pCurrent->getNext();
+ const sal_Bool bCompYA(::basegfx::fTools::more(pCurrent->getPosition().getY(), rPoint.getY()));
+ const sal_Bool bCompYB(::basegfx::fTools::more(pNext->getPosition().getY(), rPoint.getY()));
- do
+ if(bCompYA != bCompYB)
{
- if(bWithBorder && pCurrent->getPosition().equal(rPoint))
+ const sal_Bool bCompXA(::basegfx::fTools::more(pCurrent->getPosition().getX(), rPoint.getX()));
+ const sal_Bool bCompXB(::basegfx::fTools::more(pNext->getPosition().getX(), rPoint.getX()));
+
+ if(bCompXA == bCompXB)
{
- return sal_True;
+ if(bCompXA)
+ {
+ bInside = !bInside;
+ }
}
-
- B2DPolygonNode* pNext = pCurrent->getNext();
- const sal_Bool bCompYA(::basegfx::numeric::fTools::more(pCurrent->getPosition().getY(), rPoint.getY()));
- const sal_Bool bCompYB(::basegfx::numeric::fTools::more(pNext->getPosition().getY(), rPoint.getY()));
-
- if(bCompYA != bCompYB)
+ else
{
- const sal_Bool bCompXA(::basegfx::numeric::fTools::more(pCurrent->getPosition().getX(), rPoint.getX()));
- const sal_Bool bCompXB(::basegfx::numeric::fTools::more(pNext->getPosition().getX(), rPoint.getX()));
+ double fCmp =
+ pNext->getPosition().getX() - (pNext->getPosition().getY() - rPoint.getY()) *
+ (pCurrent->getPosition().getX() - pNext->getPosition().getX()) /
+ (pCurrent->getPosition().getY() - pNext->getPosition().getY());
- if(bCompXA == bCompXB)
+ if(bWithBorder && ::basegfx::fTools::more(fCmp, rPoint.getX()))
{
- if(bCompXA)
- {
- bInside = !bInside;
- }
+ bInside = !bInside;
}
- else
+ else if(::basegfx::fTools::moreOrEqual(fCmp, rPoint.getX()))
{
- double fCmp =
- pNext->getPosition().getX() - (pNext->getPosition().getY() - rPoint.getY()) *
- (pCurrent->getPosition().getX() - pNext->getPosition().getX()) /
- (pCurrent->getPosition().getY() - pNext->getPosition().getY());
-
- if(bWithBorder && ::basegfx::numeric::fTools::more(fCmp, rPoint.getX()))
- {
- bInside = !bInside;
- }
- else if(::basegfx::numeric::fTools::moreOrEqual(fCmp, rPoint.getX()))
- {
- bInside = !bInside;
- }
+ bInside = !bInside;
}
}
+ }
- // next edge
- pCurrent = pNext;
+ // next edge
+ pCurrent = pNext;
- } while(pCurrent != this);
+ } while(pCurrent != this);
- return bInside;
- }
+ return bInside;
+ }
- sal_Bool B2DPolygonNode::isPolygonInside(B2DPolygonNode* pPoly, sal_Bool bWithBorder) const
- {
- B2DPolygonNode* pTest = pPoly;
- sal_Bool bAllAInside(sal_True);
+ sal_Bool B2DPolygonNode::isPolygonInside(B2DPolygonNode* pPoly, sal_Bool bWithBorder) const
+ {
+ B2DPolygonNode* pTest = pPoly;
+ sal_Bool bAllAInside(sal_True);
- do {
- bAllAInside = isInside(pTest->getPosition(), bWithBorder);
- pTest = pTest->getNext();
- } while(bAllAInside && pTest != pPoly);
+ do {
+ bAllAInside = isInside(pTest->getPosition(), bWithBorder);
+ pTest = pTest->getNext();
+ } while(bAllAInside && pTest != pPoly);
- return bAllAInside;
- }
- } // end of namespace polygon
+ return bAllAInside;
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -320,26 +317,23 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ void B2DSimpleCut::solve()
{
- void B2DSimpleCut::solve()
- {
- mpLeft->swapNextPointers(mpRight);
+ mpLeft->swapNextPointers(mpRight);
- if(mbCorrectOrientation)
+ if(mbCorrectOrientation)
+ {
+ if(mpLeft->getOrientation() != mbOrientation)
{
- if(mpLeft->getOrientation() != mbOrientation)
- {
- mpLeft->swapOrientation();
- }
+ mpLeft->swapOrientation();
+ }
- if(mpRight->getOrientation() != mbOrientation)
- {
- mpRight->swapOrientation();
- }
+ if(mpRight->getOrientation() != mbOrientation)
+ {
+ mpRight->swapOrientation();
}
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -347,27 +341,24 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ void B2DClipExtraPolygonInfo::init(B2DPolygonNode* pNew)
{
- void B2DClipExtraPolygonInfo::init(B2DPolygonNode* pNew)
+ maRange = pNew->getRange();
+ mbOrientation = pNew->getOrientation();
+ mnDepth = (mbOrientation) ? 0L : -1L;
+ }
+
+ void B2DClipExtraPolygonInfo::changeDepth(sal_Bool bOrientation)
+ {
+ if(bOrientation)
{
- maRange = pNew->getRange();
- mbOrientation = pNew->getOrientation();
- mnDepth = (mbOrientation) ? 0L : -1L;
+ mnDepth++;
}
-
- void B2DClipExtraPolygonInfo::changeDepth(sal_Bool bOrientation)
+ else
{
- if(bOrientation)
- {
- mnDepth++;
- }
- else
- {
- mnDepth--;
- }
+ mnDepth--;
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
@@ -375,772 +366,769 @@ namespace basegfx
namespace basegfx
{
- namespace polygon
+ B2DPolyPolygonCutter::~B2DPolyPolygonCutter()
{
- B2DPolyPolygonCutter::~B2DPolyPolygonCutter()
+ for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
{
- for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
- {
- delete maPolygonList[a];
- }
-
- maPolygonList.clear();
+ delete maPolygonList[a];
}
- void B2DPolyPolygonCutter::removeIncludedPolygons(sal_Bool bUseOr)
+ maPolygonList.clear();
+ }
+
+ void B2DPolyPolygonCutter::removeIncludedPolygons(sal_Bool bUseOr)
+ {
+ const sal_uInt32 aCount(maPolygonList.size());
+ B2DClipExtraPolygonInfo* pInfos = new B2DClipExtraPolygonInfo[aCount];
+ sal_uInt32 a, b;
+
+ // fill infos
+ for(a = 0L; a < aCount; a++)
{
- const sal_uInt32 aCount(maPolygonList.size());
- B2DClipExtraPolygonInfo* pInfos = new B2DClipExtraPolygonInfo[aCount];
- sal_uInt32 a, b;
+ pInfos[a].init(maPolygonList[a]);
+ }
- // fill infos
- for(a = 0L; a < aCount; a++)
- {
- pInfos[a].init(maPolygonList[a]);
- }
+ // get all includes
+ for(a = 0L; a < aCount; a++)
+ {
+ B2DClipExtraPolygonInfo& rInfoA = pInfos[a];
- // get all includes
- for(a = 0L; a < aCount; a++)
+ for(b = 0L; b < aCount; b++)
{
- B2DClipExtraPolygonInfo& rInfoA = pInfos[a];
+ B2DClipExtraPolygonInfo& rInfoB = pInfos[b];
- for(b = 0L; b < aCount; b++)
+ if(a != b && doRangesInclude(rInfoA.getRange(), rInfoB.getRange()))
{
- B2DClipExtraPolygonInfo& rInfoB = pInfos[b];
-
- if(a != b && doRangesInclude(rInfoA.getRange(), rInfoB.getRange()))
+ // volume B in A, test pA, pB for inclusion, with border
+ if(maPolygonList[a]->isPolygonInside(maPolygonList[b], sal_True))
{
- // volume B in A, test pA, pB for inclusion, with border
- if(maPolygonList[a]->isPolygonInside(maPolygonList[b], sal_True))
- {
- // pB is inside pA
- rInfoB.changeDepth(rInfoA.getOrientation());
- }
+ // pB is inside pA
+ rInfoB.changeDepth(rInfoA.getOrientation());
}
}
}
+ }
- // delete removable
- for(a = 0L, b = 0L; a < aCount; a++)
- {
- B2DClipExtraPolygonInfo& rInfo = pInfos[a];
+ // delete removable
+ for(a = 0L, b = 0L; a < aCount; a++)
+ {
+ B2DClipExtraPolygonInfo& rInfo = pInfos[a];
- if((bUseOr && rInfo.getDepth() != 0L) || (!bUseOr && rInfo.getDepth() < 1L))
- {
- B2DPolygonNodeVector::iterator aPosition(maPolygonList.begin() + b);
- B2DPolygonNode* pCandidate = *aPosition;
- maPolygonList.erase(aPosition);
- deletePolygon(pCandidate);
- }
- else
- {
- b++;
- }
+ if((bUseOr && rInfo.getDepth() != 0L) || (!bUseOr && rInfo.getDepth() < 1L))
+ {
+ B2DPolygonNodeVector::iterator aPosition(maPolygonList.begin() + b);
+ B2DPolygonNode* pCandidate = *aPosition;
+ maPolygonList.erase(aPosition);
+ deletePolygon(pCandidate);
+ }
+ else
+ {
+ b++;
}
-
- // delete infos
- delete[] pInfos;
}
- void B2DPolyPolygonCutter::solveAllCuts(B2DSimpleCutVector& rCuts)
- {
- B2DPolygonNode* pNewList = 0L;
-
- // add all nodes of polys to list
- polysToList(pNewList);
+ // delete infos
+ delete[] pInfos;
+ }
- // solve cuts
- B2DSimpleCutVector::iterator aCandidate(rCuts.begin());
+ void B2DPolyPolygonCutter::solveAllCuts(B2DSimpleCutVector& rCuts)
+ {
+ B2DPolygonNode* pNewList = 0L;
- for(; aCandidate < rCuts.end(); aCandidate++)
- {
- B2DSimpleCut* pCut = *aCandidate;
- pCut->solve();
- delete pCut;
- }
+ // add all nodes of polys to list
+ polysToList(pNewList);
- rCuts.clear();
+ // solve cuts
+ B2DSimpleCutVector::iterator aCandidate(rCuts.begin());
- // extract polys
- listToPolys(pNewList);
+ for(; aCandidate < rCuts.end(); aCandidate++)
+ {
+ B2DSimpleCut* pCut = *aCandidate;
+ pCut->solve();
+ delete pCut;
}
- void B2DPolyPolygonCutter::polysToList(B2DPolygonNode*& rpList)
- {
- B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
+ rCuts.clear();
- for(; aCandidate != maPolygonList.end(); aCandidate++)
- {
- addAllNodes(*aCandidate, rpList);
- }
+ // extract polys
+ listToPolys(pNewList);
+ }
- maPolygonList.clear();
- }
+ void B2DPolyPolygonCutter::polysToList(B2DPolygonNode*& rpList)
+ {
+ B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
- void B2DPolyPolygonCutter::listToPolys(B2DPolygonNode*& rpList)
+ for(; aCandidate != maPolygonList.end(); aCandidate++)
{
- while(rpList)
- {
- // get one
- B2DPolygonNode* pNew = extractNextPolygon(rpList);
-
- if(pNew)
- {
- maPolygonList.push_back(pNew);
- }
- }
+ addAllNodes(*aCandidate, rpList);
}
- B2DPolygonNode* B2DPolyPolygonCutter::createNewPolygon(const B2DPolygon& rPolygon)
+ maPolygonList.clear();
+ }
+
+ void B2DPolyPolygonCutter::listToPolys(B2DPolygonNode*& rpList)
+ {
+ while(rpList)
{
- B2DPolygonNode* pRetval = NULL;
+ // get one
+ B2DPolygonNode* pNew = extractNextPolygon(rpList);
- for(sal_uInt32 a(0L); a < rPolygon.count(); a++)
+ if(pNew)
{
- ::basegfx::point::B2DPoint aPoint(rPolygon.getB2DPoint(a));
- pRetval = new B2DPolygonNode(aPoint, pRetval);
+ maPolygonList.push_back(pNew);
}
-
- return pRetval;
}
+ }
+
+ B2DPolygonNode* B2DPolyPolygonCutter::createNewPolygon(const B2DPolygon& rPolygon)
+ {
+ B2DPolygonNode* pRetval = NULL;
- void B2DPolyPolygonCutter::deletePolygon(B2DPolygonNode* pCand)
+ for(sal_uInt32 a(0L); a < rPolygon.count(); a++)
{
- B2DPolygonNode* pPoly = pCand;
+ ::basegfx::B2DPoint aPoint(rPolygon.getB2DPoint(a));
+ pRetval = new B2DPolygonNode(aPoint, pRetval);
+ }
- while(pPoly)
- {
- B2DPolygonNode* pNext = pPoly->getNext();
+ return pRetval;
+ }
- if(pNext == pPoly)
- {
- pNext = 0L;
- }
+ void B2DPolyPolygonCutter::deletePolygon(B2DPolygonNode* pCand)
+ {
+ B2DPolygonNode* pPoly = pCand;
+
+ while(pPoly)
+ {
+ B2DPolygonNode* pNext = pPoly->getNext();
- delete pPoly;
- pPoly = pNext;
+ if(pNext == pPoly)
+ {
+ pNext = 0L;
}
+
+ delete pPoly;
+ pPoly = pNext;
}
+ }
- void B2DPolyPolygonCutter::addAllNodes(B2DPolygonNode* pPolygon, B2DPolygonNode*& rpList)
- {
- B2DPolygonNode* pAct = pPolygon;
+ void B2DPolyPolygonCutter::addAllNodes(B2DPolygonNode* pPolygon, B2DPolygonNode*& rpList)
+ {
+ B2DPolygonNode* pAct = pPolygon;
- do {
- pAct->addToList(rpList);
- pAct = pAct->getNext();
- } while(pAct != pPolygon);
- }
+ do {
+ pAct->addToList(rpList);
+ pAct = pAct->getNext();
+ } while(pAct != pPolygon);
+ }
- void B2DPolyPolygonCutter::addPolyPolygon(const B2DPolyPolygon& rPolyPolygon, sal_Bool bForceOrientation)
+ void B2DPolyPolygonCutter::addPolyPolygon(const B2DPolyPolygon& rPolyPolygon, sal_Bool bForceOrientation)
+ {
+ for(sal_uInt32 a(0L); a < rPolyPolygon.count(); a++)
{
- for(sal_uInt32 a(0L); a < rPolyPolygon.count(); a++)
- {
- B2DPolygon aCandidate = rPolyPolygon.getB2DPolygon(a);
- aCandidate.removeDoublePoints();
+ B2DPolygon aCandidate = rPolyPolygon.getB2DPolygon(a);
+ aCandidate.removeDoublePoints();
- if(!aCandidate.isClosed() || aCandidate.count() < 3)
- {
- maNotClosedPolygons.append(aCandidate);
- }
- else
+ if(!aCandidate.isClosed() || aCandidate.count() < 3)
+ {
+ maNotClosedPolygons.append(aCandidate);
+ }
+ else
+ {
+ if(bForceOrientation)
{
- if(bForceOrientation)
- {
- ::basegfx::vector::B2DVectorOrientation aOrientation =
- ::basegfx::polygon::tools::getOrientation(aCandidate);
+ ::basegfx::B2DVectorOrientation aOrientation =
+ ::basegfx::tools::getOrientation(aCandidate);
- if(::basegfx::vector::ORIENTATION_POSITIVE != aOrientation)
- {
- aCandidate.flip();
- }
+ if(::basegfx::ORIENTATION_POSITIVE != aOrientation)
+ {
+ aCandidate.flip();
}
-
- B2DPolygonNode* pNew = createNewPolygon(aCandidate);
- maPolygonList.push_back(pNew);
}
+
+ B2DPolygonNode* pNew = createNewPolygon(aCandidate);
+ maPolygonList.push_back(pNew);
}
}
+ }
+
+ void B2DPolyPolygonCutter::getPolyPolygon(B2DPolyPolygon& rPolyPolygon)
+ {
+ B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
- void B2DPolyPolygonCutter::getPolyPolygon(B2DPolyPolygon& rPolyPolygon)
+ for(; aCandidate < maPolygonList.end(); aCandidate++)
{
- B2DPolygonNodeVector::iterator aCandidate(maPolygonList.begin());
+ B2DPolygonNode* pCand = *aCandidate;
+ B2DPolygonNode* pAct = pCand;
+ sal_uInt32 nCount(0L);
+
+ do {
+ nCount++;
+ pAct = pAct->getNext();
+ } while(pAct != pCand);
- for(; aCandidate < maPolygonList.end(); aCandidate++)
+ if(nCount > 2L)
{
- B2DPolygonNode* pCand = *aCandidate;
- B2DPolygonNode* pAct = pCand;
- sal_uInt32 nCount(0L);
+ B2DPolygon aNewPolygon;
do {
- nCount++;
+ aNewPolygon.append(pAct->getPosition());
pAct = pAct->getNext();
} while(pAct != pCand);
- if(nCount > 2L)
- {
- B2DPolygon aNewPolygon;
+ aNewPolygon.setClosed(sal_True);
+ rPolyPolygon.append(aNewPolygon);
+ }
- do {
- aNewPolygon.append(pAct->getPosition());
- pAct = pAct->getNext();
- } while(pAct != pCand);
+ deletePolygon(pCand);
+ }
- aNewPolygon.setClosed(sal_True);
- rPolyPolygon.append(aNewPolygon);
- }
+ maPolygonList.clear();
- deletePolygon(pCand);
- }
+ while(maNotClosedPolygons.count())
+ {
+ rPolyPolygon.append(maNotClosedPolygons.getB2DPolygon(0L));
+ maNotClosedPolygons.remove(0L);
+ }
+ }
- maPolygonList.clear();
+ B2DSimpleCut* B2DPolyPolygonCutter::getExistingCut(B2DSimpleCutVector& rTmpCuts, B2DPolygonNode* pA, B2DPolygonNode* pB)
+ {
+ for(sal_uInt32 a(0L); a < rTmpCuts.size(); a++)
+ {
+ B2DSimpleCut* pCand = rTmpCuts[a];
- while(maNotClosedPolygons.count())
+ if(pCand->isSameCut(pA, pB))
{
- rPolyPolygon.append(maNotClosedPolygons.getB2DPolygon(0L));
- maNotClosedPolygons.remove(0L);
+ return pCand;
}
}
- B2DSimpleCut* B2DPolyPolygonCutter::getExistingCut(B2DSimpleCutVector& rTmpCuts, B2DPolygonNode* pA, B2DPolygonNode* pB)
- {
- for(sal_uInt32 a(0L); a < rTmpCuts.size(); a++)
- {
- B2DSimpleCut* pCand = rTmpCuts[a];
+ return 0L;
+ }
- if(pCand->isSameCut(pA, pB))
- {
- return pCand;
- }
- }
+ B2DPolygonNode* B2DPolyPolygonCutter::extractNextPolygon(B2DPolygonNode*& rpList)
+ {
+ B2DPolygonNode* pStart = rpList;
+
+ // remove all nodes of this poly from list
+ B2DPolygonNode* pAct = pStart;
+ sal_uInt32 nNumNodes(0L);
+
+ do {
+ pAct->remFromList(rpList);
+ pAct = pAct->getNext();
+ nNumNodes++;
+ } while(pAct != pStart);
+ if(nNumNodes < 3L)
+ {
+ deletePolygon(pStart);
return 0L;
}
-
- B2DPolygonNode* B2DPolyPolygonCutter::extractNextPolygon(B2DPolygonNode*& rpList)
+ else
{
- B2DPolygonNode* pStart = rpList;
-
- // remove all nodes of this poly from list
- B2DPolygonNode* pAct = pStart;
- sal_uInt32 nNumNodes(0L);
-
- do {
- pAct->remFromList(rpList);
- pAct = pAct->getNext();
- nNumNodes++;
- } while(pAct != pStart);
-
- if(nNumNodes < 3L)
- {
- deletePolygon(pStart);
- return 0L;
- }
- else
- {
- return pStart;
- }
+ return pStart;
}
+ }
- void B2DPolyPolygonCutter::removeSelfIntersections()
+ void B2DPolyPolygonCutter::removeSelfIntersections()
+ {
+ B2DSimpleCutVector aCuts;
+ B2DSimpleCutVector aNewCuts;
+ B2DPolygonNode* pCand;
+ B2DPolygonNode* pA;
+ B2DPolygonNode* pB;
+ double fMaxAX, fMinAX, fMaxAY, fMinAY;
+ double fMaxBX, fMinBX, fMaxBY, fMinBY;
+ double fCut;
+
+ // first job: Find all cuts and add points there
+ for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
{
- B2DSimpleCutVector aCuts;
- B2DSimpleCutVector aNewCuts;
- B2DPolygonNode* pCand;
- B2DPolygonNode* pA;
- B2DPolygonNode* pB;
- double fMaxAX, fMinAX, fMaxAY, fMinAY;
- double fMaxBX, fMinBX, fMaxBY, fMinBY;
- double fCut;
-
- // first job: Find all cuts and add points there
- for(sal_uInt32 a(0L); a < maPolygonList.size(); a++)
- {
- pCand = maPolygonList[a];
- pA = pCand;
+ pCand = maPolygonList[a];
+ pA = pCand;
+
+ // one run to find same start positions (so there is no need to
+ // search for existing cuts in main loop)
+ do {
+ pB = pA->getNext();
- // one run to find same start positions (so there is no need to
- // search for existing cuts in main loop)
do {
- pB = pA->getNext();
+ if(isSamePos(pA->getPosition(), pB->getPosition()))
+ {
+ aNewCuts.push_back(new B2DSimpleCut(pA, pB, sal_True, pCand->getOrientation()));
+ }
- do {
- if(isSamePos(pA->getPosition(), pB->getPosition()))
- {
- aNewCuts.push_back(new B2DSimpleCut(pA, pB, sal_True, pCand->getOrientation()));
- }
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCand);
- // next B
- pB = pB->getNext();
- } while(pB != pCand);
+ // next A
+ pA = pA->getNext();
+ } while(pA->getNext() != pCand);
- // next A
- pA = pA->getNext();
- } while(pA->getNext() != pCand);
+ // second run to find real cuts
+ pA = pCand;
- // second run to find real cuts
- pA = pCand;
+ do {
+ // get bounds for this edge in poly
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ pB = pA->getNext();
do {
- // get bounds for this edge in poly
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- pB = pA->getNext();
+ pB->calcMinMaxX(fMaxBX, fMinBX);
- do {
- pB->calcMinMaxX(fMaxBX, fMinBX);
+ if(::basegfx::fTools::more(fMaxBX, fMinAX)
+ && ::basegfx::fTools::more(fMaxAX, fMinBX))
+ {
+ pB->calcMinMaxY(fMaxBY, fMinBY);
- if(::basegfx::numeric::fTools::more(fMaxBX, fMinAX)
- && ::basegfx::numeric::fTools::more(fMaxAX, fMinBX))
+ if(::basegfx::fTools::more(fMaxBY, fMinAY)
+ && ::basegfx::fTools::more(fMaxAY, fMinBY))
{
- pB->calcMinMaxY(fMaxBY, fMinBY);
-
- if(::basegfx::numeric::fTools::more(fMaxBY, fMinAY)
- && ::basegfx::numeric::fTools::more(fMaxAY, fMinBY))
+ if(!isSamePos(pA->getPosition(), pB->getPosition()))
{
- if(!isSamePos(pA->getPosition(), pB->getPosition()))
- {
- const ::basegfx::vector::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
- const ::basegfx::vector::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
+ const ::basegfx::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
+ const ::basegfx::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
- if(::basegfx::polygon::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ if(::basegfx::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ {
+ // crossover, two new points
+ ::basegfx::B2DPoint aNewPos(::basegfx::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
+ aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi, sal_True, pCand->getOrientation()));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ }
+ else
+ {
+ if(::basegfx::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
{
- // crossover, two new points
- ::basegfx::point::B2DPoint aNewPos(::basegfx::tuple::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
- B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
- B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
- aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi, sal_True, pCand->getOrientation()));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
+ // startpoint A at edge B, one new point
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
+ aNewCuts.push_back(new B2DSimpleCut(pA, pCutHi, sal_True, pCand->getOrientation()));
}
- else
+ else if(::basegfx::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
{
- if(::basegfx::polygon::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
- {
- // startpoint A at edge B, one new point
- B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
- aNewCuts.push_back(new B2DSimpleCut(pA, pCutHi, sal_True, pCand->getOrientation()));
- }
- else if(::basegfx::polygon::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
- {
- // startpoint B at edge A, one new point
- B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
- aNewCuts.push_back(new B2DSimpleCut(pCutLo, pB, sal_True, pCand->getOrientation()));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- }
+ // startpoint B at edge A, one new point
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
+ aNewCuts.push_back(new B2DSimpleCut(pCutLo, pB, sal_True, pCand->getOrientation()));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
}
}
}
}
+ }
- // next B
- pB = pB->getNext();
- } while(pB != pCand);
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCand);
- // next A
- pA = pA->getNext();
- } while(pA->getNext() != pCand);
+ // next A
+ pA = pA->getNext();
+ } while(pA->getNext() != pCand);
- // copy new cuts to cuts
- aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
- aNewCuts.clear();
- }
+ // copy new cuts to cuts
+ aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
+ aNewCuts.clear();
+ }
- // second job: if there were cuts, split polys
- if(aCuts.size())
- {
- solveAllCuts(aCuts);
- }
+ // second job: if there were cuts, split polys
+ if(aCuts.size())
+ {
+ solveAllCuts(aCuts);
}
+ }
- sal_Bool B2DPolyPolygonCutter::isCrossover(B2DPolygonNode* pA, B2DPolygonNode* pB)
+ sal_Bool B2DPolyPolygonCutter::isCrossover(B2DPolygonNode* pA, B2DPolygonNode* pB)
+ {
+ // build entering vectors
+ ::basegfx::B2DVector aVecA(pA->getPrevious()->getPosition() - pA->getPosition());
+ ::basegfx::B2DVector aVecB(pB->getPrevious()->getPosition() - pA->getPosition());
+ aVecA.normalize();
+ aVecB.normalize();
+ double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX());
+ double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX());
+
+ // build leaving vectors
+ aVecA = pA->getNext()->getPosition() - pA->getPosition();
+ aVecB = pB->getNext()->getPosition() - pA->getPosition();
+ aVecA.normalize();
+ aVecB.normalize();
+ double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX());
+ double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX());
+
+ // compare
+ if(fDegreeA1 > fDegreeA2)
{
- // build entering vectors
- ::basegfx::vector::B2DVector aVecA(pA->getPrevious()->getPosition() - pA->getPosition());
- ::basegfx::vector::B2DVector aVecB(pB->getPrevious()->getPosition() - pA->getPosition());
- aVecA.normalize();
- aVecB.normalize();
- double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX());
- double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX());
-
- // build leaving vectors
- aVecA = pA->getNext()->getPosition() - pA->getPosition();
- aVecB = pB->getNext()->getPosition() - pA->getPosition();
- aVecA.normalize();
- aVecB.normalize();
- double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX());
- double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX());
-
- // compare
- if(fDegreeA1 > fDegreeA2)
- {
- double fTemp = fDegreeA2;
- fDegreeA2 = fDegreeA1;
- fDegreeA1 = fTemp;
- }
+ double fTemp = fDegreeA2;
+ fDegreeA2 = fDegreeA1;
+ fDegreeA1 = fTemp;
+ }
- sal_Bool bB1Inside(::basegfx::numeric::fTools::more(fDegreeB1, fDegreeA1)
- && ::basegfx::numeric::fTools::more(fDegreeA2, fDegreeB1));
- sal_Bool bB2Inside(::basegfx::numeric::fTools::more(fDegreeB2, fDegreeA1)
- && ::basegfx::numeric::fTools::more(fDegreeA2, fDegreeB2));
+ sal_Bool bB1Inside(::basegfx::fTools::more(fDegreeB1, fDegreeA1)
+ && ::basegfx::fTools::more(fDegreeA2, fDegreeB1));
+ sal_Bool bB2Inside(::basegfx::fTools::more(fDegreeB2, fDegreeA1)
+ && ::basegfx::fTools::more(fDegreeA2, fDegreeB2));
- if(bB1Inside && bB2Inside)
- {
- return sal_False;
- }
+ if(bB1Inside && bB2Inside)
+ {
+ return sal_False;
+ }
+
+ sal_Bool bB1Outside(::basegfx::fTools::more(fDegreeA1, fDegreeB1)
+ || ::basegfx::fTools::more(fDegreeB1, fDegreeA2));
+ sal_Bool bB2Outside(::basegfx::fTools::more(fDegreeA1, fDegreeB2)
+ || ::basegfx::fTools::more(fDegreeB2, fDegreeA2));
- sal_Bool bB1Outside(::basegfx::numeric::fTools::more(fDegreeA1, fDegreeB1)
- || ::basegfx::numeric::fTools::more(fDegreeB1, fDegreeA2));
- sal_Bool bB2Outside(::basegfx::numeric::fTools::more(fDegreeA1, fDegreeB2)
- || ::basegfx::numeric::fTools::more(fDegreeB2, fDegreeA2));
+ return !(bB1Outside && bB2Outside);
+ }
- return !(bB1Outside && bB2Outside);
+ sal_Bool B2DPolyPolygonCutter::isCrossover(B2DSimpleCut* pEnter, B2DSimpleCut* pLeave)
+ {
+ // build entering vectors
+ ::basegfx::B2DVector aVecJ(pEnter->getLeft()->getNext()->getPosition() - pEnter->getLeft()->getPosition());
+ ::basegfx::B2DVector aVecA(pEnter->getLeft()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
+ ::basegfx::B2DVector aVecB(pEnter->getRight()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
+ aVecJ.normalize();
+ aVecA.normalize();
+ aVecB.normalize();
+ double fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
+ double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
+ double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
+
+ // move to range [0..2PI[
+ while(fDegreeA2 < 0.0)
+ {
+ fDegreeA2 += (2.0 * F_PI);
}
- sal_Bool B2DPolyPolygonCutter::isCrossover(B2DSimpleCut* pEnter, B2DSimpleCut* pLeave)
+ while(fDegreeA2 >= (2.0 * F_PI))
{
- // build entering vectors
- ::basegfx::vector::B2DVector aVecJ(pEnter->getLeft()->getNext()->getPosition() - pEnter->getLeft()->getPosition());
- ::basegfx::vector::B2DVector aVecA(pEnter->getLeft()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
- ::basegfx::vector::B2DVector aVecB(pEnter->getRight()->getPrevious()->getPosition() - pEnter->getLeft()->getPosition());
- aVecJ.normalize();
- aVecA.normalize();
- aVecB.normalize();
- double fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
- double fDegreeA2 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
- double fDegreeB2 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
-
- // move to range [0..2PI[
- while(fDegreeA2 < 0.0)
- {
- fDegreeA2 += (2.0 * F_PI);
- }
+ fDegreeA2 -= (2.0 * F_PI);
+ }
- while(fDegreeA2 >= (2.0 * F_PI))
- {
- fDegreeA2 -= (2.0 * F_PI);
- }
+ // move to range [0..2PI[
+ while(fDegreeB2 < 0.0)
+ {
+ fDegreeB2 += (2.0 * F_PI);
+ }
- // move to range [0..2PI[
- while(fDegreeB2 < 0.0)
- {
- fDegreeB2 += (2.0 * F_PI);
- }
+ while(fDegreeB2 >= (2.0 * F_PI))
+ {
+ fDegreeB2 -= (2.0 * F_PI);
+ }
- while(fDegreeB2 >= (2.0 * F_PI))
- {
- fDegreeB2 -= (2.0 * F_PI);
- }
+ sal_Bool bA2BiggerB2(::basegfx::fTools::more(fDegreeA2, fDegreeB2));
+
+ // build leaving vectors
+ aVecJ = pLeave->getLeft()->getPrevious()->getPosition() - pLeave->getLeft()->getPosition();
+ aVecA = pLeave->getLeft()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
+ aVecB = pLeave->getRight()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
+ aVecJ.normalize();
+ aVecA.normalize();
+ aVecB.normalize();
+ fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
+ double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
+ double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
+
+ // move to range [0..2PI[
+ while(fDegreeA1 < 0.0)
+ {
+ fDegreeA1 += (2.0 * F_PI);
+ }
- sal_Bool bA2BiggerB2(::basegfx::numeric::fTools::more(fDegreeA2, fDegreeB2));
-
- // build leaving vectors
- aVecJ = pLeave->getLeft()->getPrevious()->getPosition() - pLeave->getLeft()->getPosition();
- aVecA = pLeave->getLeft()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
- aVecB = pLeave->getRight()->getNext()->getPosition() - pLeave->getLeft()->getPosition();
- aVecJ.normalize();
- aVecA.normalize();
- aVecB.normalize();
- fDegreeJo = atan2(aVecJ.getY(), aVecJ.getX());
- double fDegreeA1 = atan2(aVecA.getY(), aVecA.getX()) - fDegreeJo;
- double fDegreeB1 = atan2(aVecB.getY(), aVecB.getX()) - fDegreeJo;
-
- // move to range [0..2PI[
- while(fDegreeA1 < 0.0)
- {
- fDegreeA1 += (2.0 * F_PI);
- }
+ while(fDegreeA1 >= (2.0 * F_PI))
+ {
+ fDegreeA1 -= (2.0 * F_PI);
+ }
- while(fDegreeA1 >= (2.0 * F_PI))
- {
- fDegreeA1 -= (2.0 * F_PI);
- }
+ // move to range [0..2PI[
+ while(fDegreeB1 < 0)
+ {
+ fDegreeB1 += (2.0 * F_PI);
+ }
- // move to range [0..2PI[
- while(fDegreeB1 < 0)
- {
- fDegreeB1 += (2.0 * F_PI);
- }
+ while(fDegreeB1 >= (2.0 * F_PI))
+ {
+ fDegreeB1 -= (2.0 * F_PI);
+ }
- while(fDegreeB1 >= (2.0 * F_PI))
- {
- fDegreeB1 -= (2.0 * F_PI);
- }
+ sal_Bool bA1BiggerB1(::basegfx::fTools::more(fDegreeA1, fDegreeB1));
- sal_Bool bA1BiggerB1(::basegfx::numeric::fTools::more(fDegreeA1, fDegreeB1));
+ // compare
+ return (bA1BiggerB1 == bA2BiggerB2);
+ }
- // compare
- return (bA1BiggerB1 == bA2BiggerB2);
+ void B2DPolyPolygonCutter::removeDoubleIntersections()
+ {
+ double fMaxAX, fMinAX, fMaxAY, fMinAY;
+ double fMaxBX, fMinBX, fMaxBY, fMinBY;
+ double fCut;
+ B2DSimpleCutVector aCuts;
+ B2DSimpleCutVector aTmpCuts;
+ B2DSimpleCutVector aNewCuts;
+ B2DPolygonNode* pCandA;
+ B2DPolygonNode* pCandB;
+ B2DPolygonNode* pA;
+ B2DPolygonNode* pB;
+ sal_uInt32 a;
+
+ // create volume list for all polys for faster compares
+ ::basegfx::B2DRange* pVolumes = new ::basegfx::B2DRange[maPolygonList.size()];
+
+ for(a = 0L; a < maPolygonList.size(); a++)
+ {
+ pVolumes[a] = maPolygonList[a]->getRange();
}
- void B2DPolyPolygonCutter::removeDoubleIntersections()
+ // register cuts (and add points for them) between pCandA and pCandB
+ for(a = 0L; a + 1L < maPolygonList.size(); a++)
{
- double fMaxAX, fMinAX, fMaxAY, fMinAY;
- double fMaxBX, fMinBX, fMaxBY, fMinBY;
- double fCut;
- B2DSimpleCutVector aCuts;
- B2DSimpleCutVector aTmpCuts;
- B2DSimpleCutVector aNewCuts;
- B2DPolygonNode* pCandA;
- B2DPolygonNode* pCandB;
- B2DPolygonNode* pA;
- B2DPolygonNode* pB;
- sal_uInt32 a;
-
- // create volume list for all polys for faster compares
- ::basegfx::range::B2DRange* pVolumes = new ::basegfx::range::B2DRange[maPolygonList.size()];
-
- for(a = 0L; a < maPolygonList.size(); a++)
- {
- pVolumes[a] = maPolygonList[a]->getRange();
- }
+ pCandA = maPolygonList[a];
- // register cuts (and add points for them) between pCandA and pCandB
- for(a = 0L; a + 1L < maPolygonList.size(); a++)
+ for(sal_uInt32 b = a + 1L; b < maPolygonList.size(); b++)
{
- pCandA = maPolygonList[a];
-
- for(sal_uInt32 b = a + 1L; b < maPolygonList.size(); b++)
+ if(doRangesIntersect(pVolumes[a], pVolumes[b]))
{
- if(doRangesIntersect(pVolumes[a], pVolumes[b]))
- {
- pCandB = maPolygonList[b];
- pA = pCandA;
+ pCandB = maPolygonList[b];
+ pA = pCandA;
+
+ // one run to find same start positions (so there is no need to
+ // search for existing cuts in main loop)
+ do {
+ pB = pCandB;
- // one run to find same start positions (so there is no need to
- // search for existing cuts in main loop)
do {
- pB = pCandB;
+ if(isSamePos(pA->getPosition(), pB->getPosition()))
+ {
+ aTmpCuts.push_back(new B2DSimpleCut(pA, pB));
+ }
- do {
- if(isSamePos(pA->getPosition(), pB->getPosition()))
- {
- aTmpCuts.push_back(new B2DSimpleCut(pA, pB));
- }
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCandB);
- // next B
- pB = pB->getNext();
- } while(pB != pCandB);
+ // next A
+ pA = pA->getNext();
+ } while(pA != pCandA);
- // next A
- pA = pA->getNext();
- } while(pA != pCandA);
+ // second run to find real cuts
+ pA = pCandA;
- // second run to find real cuts
- pA = pCandA;
+ do {
+ // get bounds for this edge in poly
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ pB = pCandB;
do {
- // get bounds for this edge in poly
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- pB = pCandB;
+ pB->calcMinMaxX(fMaxBX, fMinBX);
- do {
- pB->calcMinMaxX(fMaxBX, fMinBX);
+ if(::basegfx::fTools::more(fMaxBX, fMinAX)
+ && ::basegfx::fTools::more(fMaxAX, fMinBX))
+ {
+ pB->calcMinMaxY(fMaxBY, fMinBY);
- if(::basegfx::numeric::fTools::more(fMaxBX, fMinAX)
- && ::basegfx::numeric::fTools::more(fMaxAX, fMinBX))
+ if(::basegfx::fTools::more(fMaxBY, fMinAY)
+ && ::basegfx::fTools::more(fMaxAY, fMinBY))
{
- pB->calcMinMaxY(fMaxBY, fMinBY);
-
- if(::basegfx::numeric::fTools::more(fMaxBY, fMinAY)
- && ::basegfx::numeric::fTools::more(fMaxAY, fMinBY))
+ if(!isSamePos(pA->getPosition(), pB->getPosition()))
{
- if(!isSamePos(pA->getPosition(), pB->getPosition()))
- {
- const ::basegfx::vector::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
- const ::basegfx::vector::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
+ const ::basegfx::B2DVector aVectorA(pA->getNext()->getPosition() - pA->getPosition());
+ const ::basegfx::B2DVector aVectorB(pB->getNext()->getPosition() - pB->getPosition());
- if(::basegfx::polygon::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ if(::basegfx::tools::findCut(pA->getPosition(), aVectorA, pB->getPosition(), aVectorB, CUTFLAG_LINE, &fCut))
+ {
+ // crossover, two new points, use as cutpoint
+ ::basegfx::B2DPoint aNewPos(::basegfx::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
+ aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
+ }
+ else
+ {
+ if(::basegfx::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
{
- // crossover, two new points, use as cutpoint
- ::basegfx::point::B2DPoint aNewPos(::basegfx::tuple::interpolate(pA->getPosition(), pA->getNext()->getPosition(), fCut));
- B2DPolygonNode* pCutLo = new B2DPolygonNode(aNewPos, pA);
- B2DPolygonNode* pCutHi = new B2DPolygonNode(aNewPos, pB);
- aNewCuts.push_back(new B2DSimpleCut(pCutLo, pCutHi));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
+ // startpoint A at edge B, one new point
+ // leaves or enters common section
+ B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
+ aTmpCuts.push_back(new B2DSimpleCut(pA, pCutHi));
}
- else
+ else if(::basegfx::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
{
- if(::basegfx::polygon::tools::isPointOnEdge(pA->getPosition(), pB->getPosition(), aVectorB, &fCut))
- {
- // startpoint A at edge B, one new point
- // leaves or enters common section
- B2DPolygonNode* pCutHi = new B2DPolygonNode(pA->getPosition(), pB);
- aTmpCuts.push_back(new B2DSimpleCut(pA, pCutHi));
- }
- else if(::basegfx::polygon::tools::isPointOnEdge(pB->getPosition(), pA->getPosition(), aVectorA, &fCut))
- {
- // startpoint B at edge A, one new point
- // leaves or enters common section
- B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
- aTmpCuts.push_back(new B2DSimpleCut(pCutLo, pB));
- pA->calcMinMaxX(fMaxAX, fMinAX);
- pA->calcMinMaxY(fMaxAY, fMinAY);
- }
+ // startpoint B at edge A, one new point
+ // leaves or enters common section
+ B2DPolygonNode* pCutLo = new B2DPolygonNode(pB->getPosition(), pA);
+ aTmpCuts.push_back(new B2DSimpleCut(pCutLo, pB));
+ pA->calcMinMaxX(fMaxAX, fMinAX);
+ pA->calcMinMaxY(fMaxAY, fMinAY);
}
}
}
}
+ }
- // next B
- pB = pB->getNext();
- } while(pB != pCandB);
-
- // next A
- pA = pA->getNext();
- } while(pA != pCandA);
+ // next B
+ pB = pB->getNext();
+ } while(pB != pCandB);
- // test all temporary cuts for simple criteria
- for(sal_uInt32 c(0L); c < aTmpCuts.size();)
- {
- B2DSimpleCut* pCand = aTmpCuts[c];
- sal_Bool bPrevSamePos(isPrevSamePos(pCand->getLeft(), pCand->getRight()));
- sal_Bool bNextSamePos(isNextSamePos(pCand->getLeft(), pCand->getRight()));
- sal_Bool bDelete(sal_False);
- sal_Bool bIncC(sal_True);
+ // next A
+ pA = pA->getNext();
+ } while(pA != pCandA);
- if(bPrevSamePos && bNextSamePos)
- {
- // single point inside continued same direction section
- bDelete = sal_True;
- }
- else if(!bPrevSamePos && !bNextSamePos)
- {
- // this is no same direction section, test for real cut
- if(isCrossover(pCand->getLeft(), pCand->getRight()))
- {
- // real cut, move to real cutlist
- aNewCuts.push_back(pCand);
- aTmpCuts.erase(aTmpCuts.begin() + c);
- bIncC = sal_False;
- }
- else
- {
- // no cut, just a touch in one point
- bDelete = sal_True;
- }
- }
+ // test all temporary cuts for simple criteria
+ for(sal_uInt32 c(0L); c < aTmpCuts.size();)
+ {
+ B2DSimpleCut* pCand = aTmpCuts[c];
+ sal_Bool bPrevSamePos(isPrevSamePos(pCand->getLeft(), pCand->getRight()));
+ sal_Bool bNextSamePos(isNextSamePos(pCand->getLeft(), pCand->getRight()));
+ sal_Bool bDelete(sal_False);
+ sal_Bool bIncC(sal_True);
- // delete if wanted
- if(bDelete)
+ if(bPrevSamePos && bNextSamePos)
+ {
+ // single point inside continued same direction section
+ bDelete = sal_True;
+ }
+ else if(!bPrevSamePos && !bNextSamePos)
+ {
+ // this is no same direction section, test for real cut
+ if(isCrossover(pCand->getLeft(), pCand->getRight()))
{
- delete pCand;
+ // real cut, move to real cutlist
+ aNewCuts.push_back(pCand);
aTmpCuts.erase(aTmpCuts.begin() + c);
bIncC = sal_False;
}
+ else
+ {
+ // no cut, just a touch in one point
+ bDelete = sal_True;
+ }
+ }
- // next candidate
- if(bIncC)
- c++;
+ // delete if wanted
+ if(bDelete)
+ {
+ delete pCand;
+ aTmpCuts.erase(aTmpCuts.begin() + c);
+ bIncC = sal_False;
}
- // are there entering/leaving same direction sections?
- while(aTmpCuts.size())
+ // next candidate
+ if(bIncC)
+ c++;
+ }
+
+ // are there entering/leaving same direction sections?
+ while(aTmpCuts.size())
+ {
+ // this cuts enter/leave a common same-direction section between
+ // polygons pCandA, pCandB. If it is a real crossover, a cutpoint
+ // for it is needed, else it can be ignored.
+ B2DSimpleCut* pCutA = aTmpCuts[0L];
+ aTmpCuts.erase(aTmpCuts.begin());
+ B2DPolygonNode* pActA = pCutA->getLeft();
+ B2DPolygonNode* pActB = pCutA->getRight();
+ sal_Bool bPrevSamePos(isPrevSamePos(pActA, pActB));
+ sal_Bool bNextSamePos(isNextSamePos(pActA, pActB));
+
+ if(aTmpCuts.size())
{
- // this cuts enter/leave a common same-direction section between
- // polygons pCandA, pCandB. If it is a real crossover, a cutpoint
- // for it is needed, else it can be ignored.
- B2DSimpleCut* pCutA = aTmpCuts[0L];
- aTmpCuts.erase(aTmpCuts.begin());
- B2DPolygonNode* pActA = pCutA->getLeft();
- B2DPolygonNode* pActB = pCutA->getRight();
- sal_Bool bPrevSamePos(isPrevSamePos(pActA, pActB));
- sal_Bool bNextSamePos(isNextSamePos(pActA, pActB));
-
- if(aTmpCuts.size())
+ B2DSimpleCut* pCutB = 0L;
+
+ if(isNextSamePos(pCutA->getLeft(), pCutA->getRight()))
{
- B2DSimpleCut* pCutB = 0L;
+ // this is a start node
+ B2DPolygonNode* pActA = pCutA->getLeft()->getNext();
+ B2DPolygonNode* pActB = pCutA->getRight()->getNext();
- if(isNextSamePos(pCutA->getLeft(), pCutA->getRight()))
+ while(!pCutB && pActA != pCutA->getLeft())
{
- // this is a start node
- B2DPolygonNode* pActA = pCutA->getLeft()->getNext();
- B2DPolygonNode* pActB = pCutA->getRight()->getNext();
-
- while(!pCutB && pActA != pCutA->getLeft())
+ if(!isNextSamePos(pActA, pActB))
{
- if(!isNextSamePos(pActA, pActB))
- {
- pCutB = getExistingCut(aTmpCuts, pActA, pActB);
- }
-
- pActA = pActA->getNext();
- pActB = pActB->getNext();
+ pCutB = getExistingCut(aTmpCuts, pActA, pActB);
}
- if(pCutB)
+ pActA = pActA->getNext();
+ pActB = pActB->getNext();
+ }
+
+ if(pCutB)
+ {
+ const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
+ aTmpCuts.erase(aFindResult);
+
+ if(isCrossover(pCutA, pCutB))
+ {
+ aNewCuts.push_back(pCutB);
+ }
+ else
{
- const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
- aTmpCuts.erase(aFindResult);
+ delete pCutB;
+ }
+ }
+ }
+ else
+ {
+ // this is a end node
+ B2DPolygonNode* pActA = pCutA->getLeft()->getPrevious();
+ B2DPolygonNode* pActB = pCutA->getRight()->getPrevious();
- if(isCrossover(pCutA, pCutB))
- {
- aNewCuts.push_back(pCutB);
- }
- else
- {
- delete pCutB;
- }
+ while(!pCutB && pActA != pCutA->getLeft())
+ {
+ if(!isPrevSamePos(pActA, pActB))
+ {
+ pCutB = getExistingCut(aTmpCuts, pActA, pActB);
}
+
+ pActA = pActA->getPrevious();
+ pActB = pActB->getPrevious();
}
- else
+
+ if(pCutB)
{
- // this is a end node
- B2DPolygonNode* pActA = pCutA->getLeft()->getPrevious();
- B2DPolygonNode* pActB = pCutA->getRight()->getPrevious();
+ const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
+ aTmpCuts.erase(aFindResult);
- while(!pCutB && pActA != pCutA->getLeft())
+ if(isCrossover(pCutB, pCutA))
{
- if(!isPrevSamePos(pActA, pActB))
- {
- pCutB = getExistingCut(aTmpCuts, pActA, pActB);
- }
-
- pActA = pActA->getPrevious();
- pActB = pActB->getPrevious();
+ aNewCuts.push_back(pCutB);
}
-
- if(pCutB)
+ else
{
- const B2DSimpleCutVector::iterator aFindResult = ::std::find(aTmpCuts.begin(), aTmpCuts.end(), pCutB);
- aTmpCuts.erase(aFindResult);
-
- if(isCrossover(pCutB, pCutA))
- {
- aNewCuts.push_back(pCutB);
- }
- else
- {
- delete pCutB;
- }
+ delete pCutB;
}
}
}
-
- // delete cut in EVERY case
- delete pCutA;
}
- // copy new cuts to all cuts
- aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
- aNewCuts.clear();
+ // delete cut in EVERY case
+ delete pCutA;
}
+
+ // copy new cuts to all cuts
+ aCuts.insert(aCuts.begin(), aNewCuts.begin(), aNewCuts.end());
+ aNewCuts.clear();
}
}
+ }
- // delete volume list again
- delete[] pVolumes;
+ // delete volume list again
+ delete[] pVolumes;
- // are there cuts to solve? Solve them all in one run
- if(aCuts.size())
- {
- solveAllCuts(aCuts);
- }
+ // are there cuts to solve? Solve them all in one run
+ if(aCuts.size())
+ {
+ solveAllCuts(aCuts);
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index 3ddb6f11a0a3..60f61b347135 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b2dpolypolygontools.cxx,v $
*
- * $Revision: 1.4 $
+ * $Revision: 1.5 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:40:12 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -87,153 +87,164 @@
namespace basegfx
{
- namespace polygon
+ namespace tools
{
- namespace tools
+ // B2DPolyPolygon tools
+
+ void correctOrientations(::basegfx::B2DPolyPolygon& rCandidate)
{
- // B2DPolyPolygon tools
+ const sal_uInt32 nPolygonCount(rCandidate.count());
+ sal_uInt32 nIndexOfOutmostPolygon(0L);
+ sal_Bool bIndexOfOutmostPolygonSet(sal_False);
- void correctOrientations(::basegfx::polygon::B2DPolyPolygon& rCandidate)
+ for(sal_uInt32 a(0L); a < nPolygonCount; a++)
{
- const sal_uInt32 nPolygonCount(rCandidate.count());
- sal_uInt32 nIndexOfOutmostPolygon(0L);
- sal_Bool bIndexOfOutmostPolygonSet(sal_False);
+ ::basegfx::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
- for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+ if(aCandidate.count() > 2L)
{
- ::basegfx::polygon::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
-
- if(aCandidate.count() > 2L)
+ ::basegfx::B2DVectorOrientation aOrientation =
+ ::basegfx::tools::getOrientation(aCandidate);
+ sal_Bool bDoFlip(::basegfx::ORIENTATION_POSITIVE != aOrientation);
+
+ // init values for depth and compare point for
+ // inside test. Since the ordering makes only sense when assuming
+ // that there are no intersections, the inside test is done with
+ // any point of the candidate, so teke the first one.
+ sal_uInt32 nDepth(0L);
+ const ::basegfx::B2DPoint aTestPoint(aCandidate.getB2DPoint(0L));
+
+ // loop over other polygons and calculate depth
+ for(sal_uInt32 b(0L); b < nPolygonCount; b++)
{
- ::basegfx::vector::B2DVectorOrientation aOrientation =
- ::basegfx::polygon::tools::getOrientation(aCandidate);
- sal_Bool bDoFlip(::basegfx::vector::ORIENTATION_POSITIVE != aOrientation);
-
- // init values for depth and compare point for
- // inside test. Since the ordering makes only sense when assuming
- // that there are no intersections, the inside test is done with
- // any point of the candidate, so teke the first one.
- sal_uInt32 nDepth(0L);
- const ::basegfx::point::B2DPoint aTestPoint(aCandidate.getB2DPoint(0L));
-
- // loop over other polygons and calculate depth
- for(sal_uInt32 b(0L); b < nPolygonCount; b++)
+ if(b != a)
{
- if(b != a)
- {
- ::basegfx::polygon::B2DPolygon aComparePolygon = rCandidate.getB2DPolygon(b);
+ ::basegfx::B2DPolygon aComparePolygon = rCandidate.getB2DPolygon(b);
- if(::basegfx::polygon::tools::isInside(aComparePolygon, aTestPoint))
- {
- nDepth++;
- }
+ if(::basegfx::tools::isInside(aComparePolygon, aTestPoint))
+ {
+ nDepth++;
}
}
+ }
- // if nDepth is odd it is a hole
- sal_Bool bIsHole(1L == (nDepth & 0x00000001));
+ // if nDepth is odd it is a hole
+ sal_Bool bIsHole(1L == (nDepth & 0x00000001));
- // does polygon need to be flipped?
- if((bDoFlip && !bIsHole) || (!bDoFlip && bIsHole))
- {
- aCandidate.flip();
-
- // write back changed polygon
- rCandidate.setB2DPolygon(a, aCandidate);
- }
+ // does polygon need to be flipped?
+ if((bDoFlip && !bIsHole) || (!bDoFlip && bIsHole))
+ {
+ aCandidate.flip();
- // remember the index if it's the outmost polygon
- if(!bIndexOfOutmostPolygonSet && 0L == nDepth)
- {
- bIndexOfOutmostPolygonSet = sal_True;
- nIndexOfOutmostPolygon = a;
- }
+ // write back changed polygon
+ rCandidate.setB2DPolygon(a, aCandidate);
}
- }
- // if the outmost polygon is not the first, move it in front
- if(bIndexOfOutmostPolygonSet && nIndexOfOutmostPolygon > 0L)
- {
- ::basegfx::polygon::B2DPolygon aOutmostPolygon = rCandidate.getB2DPolygon(nIndexOfOutmostPolygon);
- rCandidate.remove(nIndexOfOutmostPolygon);
- rCandidate.insert(0L, aOutmostPolygon);
+ // remember the index if it's the outmost polygon
+ if(!bIndexOfOutmostPolygonSet && 0L == nDepth)
+ {
+ bIndexOfOutmostPolygonSet = sal_True;
+ nIndexOfOutmostPolygon = a;
+ }
}
}
- void removeIntersections(::basegfx::polygon::B2DPolyPolygon& rCandidate,
- sal_Bool bForceOrientation, sal_Bool bInvertRemove)
+ // if the outmost polygon is not the first, move it in front
+ if(bIndexOfOutmostPolygonSet && nIndexOfOutmostPolygon > 0L)
{
- ::basegfx::polygon::B2DPolyPolygonCutter aCutter;
-
- aCutter.addPolyPolygon(rCandidate, bForceOrientation);
- aCutter.removeSelfIntersections();
- aCutter.removeDoubleIntersections();
- aCutter.removeIncludedPolygons(!bInvertRemove);
- rCandidate.clear();
- aCutter.getPolyPolygon(rCandidate);
+ ::basegfx::B2DPolygon aOutmostPolygon = rCandidate.getB2DPolygon(nIndexOfOutmostPolygon);
+ rCandidate.remove(nIndexOfOutmostPolygon);
+ rCandidate.insert(0L, aOutmostPolygon);
}
+ }
+
+ void removeIntersections(::basegfx::B2DPolyPolygon& rCandidate,
+ sal_Bool bForceOrientation, sal_Bool bInvertRemove)
+ {
+ ::basegfx::B2DPolyPolygonCutter aCutter;
+
+ aCutter.addPolyPolygon(rCandidate, bForceOrientation);
+ aCutter.removeSelfIntersections();
+ aCutter.removeDoubleIntersections();
+ aCutter.removeIncludedPolygons(!bInvertRemove);
+ rCandidate.clear();
+ aCutter.getPolyPolygon(rCandidate);
+ }
- ::basegfx::polygon::B2DPolyPolygon adaptiveSubdivideByDistance(const ::basegfx::polygon::B2DPolyPolygon& rCandidate, double fDistanceBound)
+ ::basegfx::B2DPolyPolygon adaptiveSubdivideByDistance(const ::basegfx::B2DPolyPolygon& rCandidate, double fDistanceBound)
+ {
+ ::basegfx::B2DPolyPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolyPolygon aRetval(rCandidate);
+ const sal_uInt32 nPolygonCount(aRetval.count());
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
{
- const sal_uInt32 nPolygonCount(aRetval.count());
+ ::basegfx::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
- for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
+ if(aCandidate.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
-
- if(aCandidate.areControlPointsUsed())
- {
- aCandidate = ::basegfx::polygon::tools::adaptiveSubdivideByDistance(aCandidate, fDistanceBound);
- aRetval.setB2DPolygon(a, aCandidate);
- }
+ aCandidate = ::basegfx::tools::adaptiveSubdivideByDistance(aCandidate, fDistanceBound);
+ aRetval.setB2DPolygon(a, aCandidate);
}
}
-
- return aRetval;
}
- ::basegfx::polygon::B2DPolyPolygon adaptiveSubdivideByAngle(const ::basegfx::polygon::B2DPolyPolygon& rCandidate, double fAngleBound)
+ return aRetval;
+ }
+
+ ::basegfx::B2DPolyPolygon adaptiveSubdivideByAngle(const ::basegfx::B2DPolyPolygon& rCandidate, double fAngleBound)
+ {
+ ::basegfx::B2DPolyPolygon aRetval(rCandidate);
+
+ if(aRetval.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolyPolygon aRetval(rCandidate);
+ const sal_uInt32 nPolygonCount(aRetval.count());
- if(aRetval.areControlPointsUsed())
+ for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
{
- const sal_uInt32 nPolygonCount(aRetval.count());
+ ::basegfx::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
- for(sal_uInt32 a(0L); aRetval.areControlPointsUsed() && a < nPolygonCount; a++)
+ if(aCandidate.areControlPointsUsed())
{
- ::basegfx::polygon::B2DPolygon aCandidate = aRetval.getB2DPolygon(a);
-
- if(aCandidate.areControlPointsUsed())
- {
- aCandidate = ::basegfx::polygon::tools::adaptiveSubdivideByAngle(aCandidate, fAngleBound);
- aRetval.setB2DPolygon(a, aCandidate);
- }
+ aCandidate = ::basegfx::tools::adaptiveSubdivideByAngle(aCandidate, fAngleBound);
+ aRetval.setB2DPolygon(a, aCandidate);
}
}
-
- return aRetval;
}
- ::basegfx::range::B2DRange getRange(const ::basegfx::polygon::B2DPolyPolygon& rCandidate)
+ return aRetval;
+ }
+
+ ::basegfx::B2DRange getRange(const ::basegfx::B2DPolyPolygon& rCandidate)
+ {
+ ::basegfx::B2DRange aRetval;
+ const sal_uInt32 nPolygonCount(rCandidate.count());
+
+ for(sal_uInt32 a(0L); a < nPolygonCount; a++)
{
- ::basegfx::range::B2DRange aRetval;
- const sal_uInt32 nPolygonCount(rCandidate.count());
+ ::basegfx::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
+ aRetval.expand(::basegfx::tools::getRange(aCandidate));
+ }
- for(sal_uInt32 a(0L); a < nPolygonCount; a++)
- {
- ::basegfx::polygon::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
- aRetval.expand(::basegfx::polygon::tools::getRange(aCandidate));
- }
+ return aRetval;
+ }
+
+ ::basegfx::B2DPolyPolygon applyLineDashing(const ::basegfx::B2DPolyPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen)
+ {
+ ::basegfx::B2DPolyPolygon aRetval;
+ const sal_uInt32 nPolygonCount(rCandidate.count());
- return aRetval;
+ for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+ {
+ ::basegfx::B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
+ aRetval.append(applyLineDashing(aCandidate, raDashDotArray, fFullDashDotLen));
}
- } // end of namespace tools
- } // end of namespace polygon
+
+ return aRetval;
+ }
+ } // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b3dpolygon.cxx b/basegfx/source/polygon/b3dpolygon.cxx
index df2672d6bbf4..0d488c04bf2c 100644
--- a/basegfx/source/polygon/b3dpolygon.cxx
+++ b/basegfx/source/polygon/b3dpolygon.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolygon.cxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:31:36 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:06 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -82,17 +82,17 @@
class CoordinateData3D
{
- ::basegfx::point::B3DPoint maPoint;
+ ::basegfx::B3DPoint maPoint;
public:
CoordinateData3D() {}
- CoordinateData3D(const ::basegfx::point::B3DPoint& rData) : maPoint(rData) {}
+ CoordinateData3D(const ::basegfx::B3DPoint& rData) : maPoint(rData) {}
~CoordinateData3D() {}
- const ::basegfx::point::B3DPoint& getCoordinate() const { return maPoint; }
- void setCoordinate(const ::basegfx::point::B3DPoint& rValue) { if(rValue != maPoint) maPoint = rValue; }
+ const ::basegfx::B3DPoint& getCoordinate() const { return maPoint; }
+ void setCoordinate(const ::basegfx::B3DPoint& rValue) { if(rValue != maPoint) maPoint = rValue; }
sal_Bool operator==(const CoordinateData3D& rData ) const { return (maPoint == rData.getCoordinate()); }
- void transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix) { maPoint *= rMatrix; }
+ void transform(const ::basegfx::B3DHomMatrix& rMatrix) { maPoint *= rMatrix; }
};
//////////////////////////////////////////////////////////////////////////////
@@ -133,12 +133,12 @@ public:
return (maVector == rCandidate.maVector);
}
- const ::basegfx::point::B3DPoint& getCoordinate(sal_uInt32 nIndex) const
+ const ::basegfx::B3DPoint& getCoordinate(sal_uInt32 nIndex) const
{
return maVector[nIndex].getCoordinate();
}
- void setCoordinate(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rValue)
+ void setCoordinate(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rValue)
{
maVector[nIndex].setCoordinate(rValue);
}
@@ -229,7 +229,7 @@ public:
}
}
- void transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B3DHomMatrix& rMatrix)
{
CoordinateData3DVector::iterator aStart(maVector.begin());
CoordinateData3DVector::iterator aEnd(maVector.end());
@@ -333,17 +333,17 @@ public:
return sal_False;
}
- const ::basegfx::point::B3DPoint& getPoint(sal_uInt32 nIndex) const
+ const ::basegfx::B3DPoint& getPoint(sal_uInt32 nIndex) const
{
return maPoints.getCoordinate(nIndex);
}
- void setPoint(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rValue)
+ void setPoint(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rValue)
{
maPoints.setCoordinate(nIndex, rValue);
}
- void insert(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rPoint, sal_uInt32 nCount)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
{
if(nCount)
{
@@ -417,7 +417,7 @@ public:
maPoints.removeDoublePointsWholeTrack();
}
- void transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B3DHomMatrix& rMatrix)
{
maPoints.transform(rMatrix);
}
@@ -427,253 +427,250 @@ public:
namespace basegfx
{
- namespace polygon
- {
- // init static default Polygon
- static ImplB3DPolygon maStaticDefaultPolygon;
+ // init static default Polygon
+ static ImplB3DPolygon maStaticDefaultPolygon;
- void B3DPolygon::implForceUniqueCopy()
+ void B3DPolygon::implForceUniqueCopy()
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- mpPolygon = new ImplB3DPolygon(*mpPolygon);
- }
+ mpPolygon->decRefCount();
+ mpPolygon = new ImplB3DPolygon(*mpPolygon);
}
+ }
+
+ B3DPolygon::B3DPolygon()
+ : mpPolygon(&maStaticDefaultPolygon)
+ {
+ mpPolygon->incRefCount();
+ }
- B3DPolygon::B3DPolygon()
- : mpPolygon(&maStaticDefaultPolygon)
+ B3DPolygon::B3DPolygon(const B3DPolygon& rPolygon)
+ : mpPolygon(rPolygon.mpPolygon)
+ {
+ mpPolygon->incRefCount();
+ }
+
+ B3DPolygon::B3DPolygon(const B3DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
+ : mpPolygon(new ImplB3DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
+ {
+ OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B3DPolygon constructor outside range (!)");
+ }
+
+ B3DPolygon::~B3DPolygon()
+ {
+ if(mpPolygon->getRefCount())
{
- mpPolygon->incRefCount();
+ mpPolygon->decRefCount();
}
-
- B3DPolygon::B3DPolygon(const B3DPolygon& rPolygon)
- : mpPolygon(rPolygon.mpPolygon)
+ else
{
- mpPolygon->incRefCount();
+ delete mpPolygon;
}
+ }
- B3DPolygon::B3DPolygon(const B3DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
- : mpPolygon(new ImplB3DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
+ B3DPolygon& B3DPolygon::operator=(const B3DPolygon& rPolygon)
+ {
+ if(mpPolygon->getRefCount())
{
- OSL_ENSURE(nIndex + nCount > rPolygon.mpPolygon->count(), "B3DPolygon constructor outside range (!)");
+ mpPolygon->decRefCount();
}
-
- B3DPolygon::~B3DPolygon()
+ else
{
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- }
- else
- {
- delete mpPolygon;
- }
+ delete mpPolygon;
}
- B3DPolygon& B3DPolygon::operator=(const B3DPolygon& rPolygon)
- {
- if(mpPolygon->getRefCount())
- {
- mpPolygon->decRefCount();
- }
- else
- {
- delete mpPolygon;
- }
+ mpPolygon = rPolygon.mpPolygon;
+ mpPolygon->incRefCount();
- mpPolygon = rPolygon.mpPolygon;
- mpPolygon->incRefCount();
+ return *this;
+ }
- return *this;
+ sal_Bool B3DPolygon::operator==(const B3DPolygon& rPolygon) const
+ {
+ if(mpPolygon == rPolygon.mpPolygon)
+ {
+ return sal_True;
}
- sal_Bool B3DPolygon::operator==(const B3DPolygon& rPolygon) const
- {
- if(mpPolygon == rPolygon.mpPolygon)
- {
- return sal_True;
- }
+ return mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ }
- return mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ sal_Bool B3DPolygon::operator!=(const B3DPolygon& rPolygon) const
+ {
+ if(mpPolygon == rPolygon.mpPolygon)
+ {
+ return sal_False;
}
- sal_Bool B3DPolygon::operator!=(const B3DPolygon& rPolygon) const
- {
- if(mpPolygon == rPolygon.mpPolygon)
- {
- return sal_False;
- }
+ return !mpPolygon->isEqual(*(rPolygon.mpPolygon));
+ }
- return !mpPolygon->isEqual(*(rPolygon.mpPolygon));
- }
+ sal_uInt32 B3DPolygon::count() const
+ {
+ return mpPolygon->count();
+ }
- sal_uInt32 B3DPolygon::count() const
- {
- return mpPolygon->count();
- }
+ ::basegfx::B3DPoint B3DPolygon::getB3DPoint(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
- ::basegfx::point::B3DPoint B3DPolygon::getB3DPoint(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
+ return mpPolygon->getPoint(nIndex);
+ }
- return mpPolygon->getPoint(nIndex);
- }
+ void B3DPolygon::setB3DPoint(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rValue)
+ {
+ OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
- void B3DPolygon::setB3DPoint(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rValue)
+ if(mpPolygon->getPoint(nIndex) != rValue)
{
- OSL_ENSURE(nIndex < mpPolygon->count(), "B3DPolygon access outside range (!)");
-
- if(mpPolygon->getPoint(nIndex) != rValue)
- {
- implForceUniqueCopy();
- mpPolygon->setPoint(nIndex, rValue);
- }
+ implForceUniqueCopy();
+ mpPolygon->setPoint(nIndex, rValue);
}
+ }
- void B3DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::point::B3DPoint& rPoint, sal_uInt32 nCount)
- {
- OSL_ENSURE(nIndex <= mpPolygon->count(), "B3DPolygon Insert outside range (!)");
+ void B3DPolygon::insert(sal_uInt32 nIndex, const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolygon->count(), "B3DPolygon Insert outside range (!)");
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolygon->insert(nIndex, rPoint, nCount);
- }
+ if(nCount)
+ {
+ implForceUniqueCopy();
+ mpPolygon->insert(nIndex, rPoint, nCount);
}
+ }
- void B3DPolygon::append(const ::basegfx::point::B3DPoint& rPoint, sal_uInt32 nCount)
+ void B3DPolygon::append(const ::basegfx::B3DPoint& rPoint, sal_uInt32 nCount)
+ {
+ if(nCount)
{
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
- }
+ implForceUniqueCopy();
+ mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
}
+ }
+
+ void B3DPolygon::insert(sal_uInt32 nIndex, const B3DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolygon->count(), "B3DPolygon Insert outside range (!)");
- void B3DPolygon::insert(sal_uInt32 nIndex, const B3DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
+ if(rPoly.count())
{
- OSL_ENSURE(nIndex <= mpPolygon->count(), "B3DPolygon Insert outside range (!)");
+ implForceUniqueCopy();
- if(rPoly.count())
+ if(!nCount)
{
- implForceUniqueCopy();
-
- if(!nCount)
- {
- nCount = rPoly.count();
- }
-
- if(0L == nIndex2 && nCount == rPoly.count())
- {
- mpPolygon->insert(nIndex, *rPoly.mpPolygon);
- }
- else
- {
- OSL_ENSURE(nIndex2 + nCount > rPoly.mpPolygon->count(), "B3DPolygon Insert outside range (!)");
- ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
- mpPolygon->insert(nIndex, aTempPoly);
- }
+ nCount = rPoly.count();
}
- }
- void B3DPolygon::append(const B3DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
- {
- if(rPoly.count())
+ if(0L == nIndex2 && nCount == rPoly.count())
{
- implForceUniqueCopy();
-
- if(!nCount)
- {
- nCount = rPoly.count();
- }
-
- if(0L == nIndex && nCount == rPoly.count())
- {
- mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
- }
- else
- {
- OSL_ENSURE(nIndex + nCount > rPoly.mpPolygon->count(), "B3DPolygon Append outside range (!)");
- ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
- mpPolygon->insert(mpPolygon->count(), aTempPoly);
- }
+ mpPolygon->insert(nIndex, *rPoly.mpPolygon);
+ }
+ else
+ {
+ OSL_ENSURE(nIndex2 + nCount > rPoly.mpPolygon->count(), "B3DPolygon Insert outside range (!)");
+ ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
+ mpPolygon->insert(nIndex, aTempPoly);
}
}
+ }
- void B3DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ void B3DPolygon::append(const B3DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ if(rPoly.count())
{
- OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B3DPolygon Remove outside range (!)");
+ implForceUniqueCopy();
- if(nCount)
+ if(!nCount)
{
- implForceUniqueCopy();
- mpPolygon->remove(nIndex, nCount);
+ nCount = rPoly.count();
}
- }
- void B3DPolygon::clear()
- {
- if(mpPolygon->getRefCount())
+ if(0L == nIndex && nCount == rPoly.count())
{
- mpPolygon->decRefCount();
+ mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
}
else
{
- delete mpPolygon;
+ OSL_ENSURE(nIndex + nCount > rPoly.mpPolygon->count(), "B3DPolygon Append outside range (!)");
+ ImplB3DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
+ mpPolygon->insert(mpPolygon->count(), aTempPoly);
}
-
- mpPolygon = &maStaticDefaultPolygon;
- mpPolygon->incRefCount();
}
+ }
- sal_Bool B3DPolygon::isClosed() const
+ void B3DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B3DPolygon Remove outside range (!)");
+
+ if(nCount)
{
- return mpPolygon->isClosed();
+ implForceUniqueCopy();
+ mpPolygon->remove(nIndex, nCount);
}
+ }
- void B3DPolygon::setClosed(sal_Bool bNew)
+ void B3DPolygon::clear()
+ {
+ if(mpPolygon->getRefCount())
{
- if(mpPolygon->isClosed() != bNew)
- {
- implForceUniqueCopy();
- mpPolygon->setClosed(bNew);
- }
+ mpPolygon->decRefCount();
}
+ else
+ {
+ delete mpPolygon;
+ }
+
+ mpPolygon = &maStaticDefaultPolygon;
+ mpPolygon->incRefCount();
+ }
+
+ sal_Bool B3DPolygon::isClosed() const
+ {
+ return mpPolygon->isClosed();
+ }
- void B3DPolygon::flip()
+ void B3DPolygon::setClosed(sal_Bool bNew)
+ {
+ if(mpPolygon->isClosed() != bNew)
{
- if(mpPolygon->count() > 1)
- {
- implForceUniqueCopy();
- mpPolygon->flip();
- }
+ implForceUniqueCopy();
+ mpPolygon->setClosed(bNew);
}
+ }
- sal_Bool B3DPolygon::hasDoublePoints() const
+ void B3DPolygon::flip()
+ {
+ if(mpPolygon->count() > 1)
{
- return mpPolygon->hasDoublePoints();
+ implForceUniqueCopy();
+ mpPolygon->flip();
}
+ }
- void B3DPolygon::removeDoublePoints()
+ sal_Bool B3DPolygon::hasDoublePoints() const
+ {
+ return mpPolygon->hasDoublePoints();
+ }
+
+ void B3DPolygon::removeDoublePoints()
+ {
+ if(mpPolygon->count() > 1)
{
- if(mpPolygon->count() > 1)
- {
- implForceUniqueCopy();
- mpPolygon->removeDoublePointsAtBeginEnd();
- mpPolygon->removeDoublePointsWholeTrack();
- }
+ implForceUniqueCopy();
+ mpPolygon->removeDoublePointsAtBeginEnd();
+ mpPolygon->removeDoublePointsWholeTrack();
}
+ }
- void B3DPolygon::transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix)
+ void B3DPolygon::transform(const ::basegfx::B3DHomMatrix& rMatrix)
+ {
+ if(mpPolygon->count())
{
- if(mpPolygon->count())
- {
- implForceUniqueCopy();
- mpPolygon->transform(rMatrix);
- }
+ implForceUniqueCopy();
+ mpPolygon->transform(rMatrix);
}
- } // end of namespace polygon
+ }
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b3dpolygontools.cxx b/basegfx/source/polygon/b3dpolygontools.cxx
index 473aa6baef45..9784ae5930a9 100644
--- a/basegfx/source/polygon/b3dpolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolygontools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolygontools.cxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:31:39 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:07 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -83,275 +83,344 @@
namespace basegfx
{
- namespace polygon
+ namespace tools
{
- namespace tools
+ // B3DPolygon tools
+ void checkClosed(B3DPolygon& rCandidate)
{
- // B3DPolygon tools
- void checkClosed(polygon::B3DPolygon& rCandidate)
+ while(rCandidate.count() > 1L
+ && rCandidate.getB3DPoint(0L).equal(rCandidate.getB3DPoint(rCandidate.count() - 1L)))
{
- while(rCandidate.count() > 1L
- && rCandidate.getB3DPoint(0L).equal(rCandidate.getB3DPoint(rCandidate.count() - 1L)))
- {
- rCandidate.setClosed(sal_True);
- rCandidate.remove(rCandidate.count() - 1L);
- }
+ rCandidate.setClosed(sal_True);
+ rCandidate.remove(rCandidate.count() - 1L);
}
+ }
+
+ // Get successor and predecessor indices. Returning the same index means there
+ // is none. Same for successor.
+ sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- // Get successor and predecessor indices. Returning the same index means there
- // is none. Same for successor.
- sal_uInt32 getIndexOfPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate)
+ if(nIndex)
+ {
+ return nIndex - 1L;
+ }
+ else if(rCandidate.count())
+ {
+ return rCandidate.count() - 1L;
+ }
+ else
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ return nIndex;
+ }
+ }
- if(nIndex)
- {
- return nIndex - 1L;
- }
- else if(rCandidate.count())
- {
- return rCandidate.count() - 1L;
- }
- else
- {
- return nIndex;
- }
+ sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+
+ if(nIndex + 1L < rCandidate.count())
+ {
+ return nIndex + 1L;
}
+ else
+ {
+ return 0L;
+ }
+ }
+
+ sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate)
+ {
+ sal_uInt32 nNewIndex(nIndex);
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate)
+ if(rCandidate.count() > 1)
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ nNewIndex = getIndexOfPredecessor(nIndex, rCandidate);
+ ::basegfx::B3DPoint aPoint(rCandidate.getB3DPoint(nIndex));
- if(nIndex + 1L < rCandidate.count())
- {
- return nIndex + 1L;
- }
- else
+ while(nNewIndex != nIndex
+ && aPoint.equal(rCandidate.getB3DPoint(nNewIndex)))
{
- return 0L;
+ nNewIndex = getIndexOfPredecessor(nNewIndex, rCandidate);
}
}
- sal_uInt32 getIndexOfDifferentPredecessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate)
+ return nNewIndex;
+ }
+
+ sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rCandidate)
+ {
+ sal_uInt32 nNewIndex(nIndex);
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+
+ if(rCandidate.count() > 1)
{
- sal_uInt32 nNewIndex(nIndex);
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ nNewIndex = getIndexOfSuccessor(nIndex, rCandidate);
+ ::basegfx::B3DPoint aPoint(rCandidate.getB3DPoint(nIndex));
- if(rCandidate.count() > 1)
+ while(nNewIndex != nIndex
+ && aPoint.equal(rCandidate.getB3DPoint(nNewIndex)))
{
- nNewIndex = getIndexOfPredecessor(nIndex, rCandidate);
- ::basegfx::point::B3DPoint aPoint(rCandidate.getB3DPoint(nIndex));
-
- while(nNewIndex != nIndex
- && aPoint.equal(rCandidate.getB3DPoint(nNewIndex)))
- {
- nNewIndex = getIndexOfPredecessor(nNewIndex, rCandidate);
- }
+ nNewIndex = getIndexOfSuccessor(nNewIndex, rCandidate);
}
-
- return nNewIndex;
}
- sal_uInt32 getIndexOfDifferentSuccessor(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rCandidate)
- {
- sal_uInt32 nNewIndex(nIndex);
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ return nNewIndex;
+ }
- if(rCandidate.count() > 1)
- {
- nNewIndex = getIndexOfSuccessor(nIndex, rCandidate);
- ::basegfx::point::B3DPoint aPoint(rCandidate.getB3DPoint(nIndex));
-
- while(nNewIndex != nIndex
- && aPoint.equal(rCandidate.getB3DPoint(nNewIndex)))
- {
- nNewIndex = getIndexOfSuccessor(nNewIndex, rCandidate);
- }
- }
+ ::basegfx::B3DRange getRange(const ::basegfx::B3DPolygon& rCandidate)
+ {
+ ::basegfx::B3DRange aRetval;
+ const sal_uInt32 nPointCount(rCandidate.count());
- return nNewIndex;
+ for(sal_uInt32 a(0L); a < nPointCount; a++)
+ {
+ const ::basegfx::B3DPoint aTestPoint(rCandidate.getB3DPoint(a));
+ aRetval.expand(aTestPoint);
}
- ::basegfx::range::B3DRange getRange(const ::basegfx::polygon::B3DPolygon& rCandidate)
- {
- ::basegfx::range::B3DRange aRetval;
- const sal_uInt32 nPointCount(rCandidate.count());
+ return aRetval;
+ }
+
+ double getEdgeLength(const ::basegfx::B3DPolygon& rCandidate, sal_uInt32 nIndex)
+ {
+ OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
- for(sal_uInt32 a(0L); a < nPointCount; a++)
+ if(nIndex < nPointCount)
+ {
+ if(rCandidate.isClosed() || nIndex + 1 != nPointCount)
{
- const ::basegfx::point::B3DPoint aTestPoint(rCandidate.getB3DPoint(a));
- aRetval.expand(aTestPoint);
+ const sal_uInt32 nNextIndex(nIndex + 1 == nPointCount ? 0L : nIndex + 1L);
+ const ::basegfx::B3DPoint aCurrentPoint(rCandidate.getB3DPoint(nIndex));
+ const ::basegfx::B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
+ const ::basegfx::B3DVector aVector(aNextPoint - aCurrentPoint);
+ fRetval = aVector.getLength();
}
+ }
- return aRetval;
+ return fRetval;
+ }
+
+ double getLength(const ::basegfx::B3DPolygon& rCandidate)
+ {
+ // This method may also be implemented using a loop over getEdgeLength, but
+ // since this would cause a lot of sqare roots to be solved it is much better
+ // to sum up the quadrats first and then use a singe suare root (if necessary)
+ double fRetval(0.0);
+ const sal_uInt32 nPointCount(rCandidate.count());
+ const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
+
+ for(sal_uInt32 a(0L); a < nLoopCount; a++)
+ {
+ const sal_uInt32 nNextIndex(a + 1 == nPointCount ? 0L : a + 1L);
+ const ::basegfx::B3DPoint aCurrentPoint(rCandidate.getB3DPoint(a));
+ const ::basegfx::B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
+ const ::basegfx::B3DVector aVector(aNextPoint - aCurrentPoint);
+ fRetval += aVector.scalar(aVector);
}
- double getEdgeLength(const ::basegfx::polygon::B3DPolygon& rCandidate, sal_uInt32 nIndex)
+ if(!::basegfx::fTools::equalZero(fRetval))
{
- OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
+ const double fOne(1.0);
- if(nIndex < nPointCount)
+ if(!::basegfx::fTools::equal(fOne, fRetval))
{
- if(rCandidate.isClosed() || nIndex + 1 != nPointCount)
- {
- const sal_uInt32 nNextIndex(nIndex + 1 == nPointCount ? 0L : nIndex + 1L);
- const ::basegfx::point::B3DPoint aCurrentPoint(rCandidate.getB3DPoint(nIndex));
- const ::basegfx::point::B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
- const ::basegfx::vector::B3DVector aVector(aNextPoint - aCurrentPoint);
- fRetval = aVector.getLength();
- }
+ fRetval = sqrt(fRetval);
}
-
- return fRetval;
}
- double getLength(const ::basegfx::polygon::B3DPolygon& rCandidate)
+ return fRetval;
+ }
+
+ ::basegfx::B3DPoint getPositionAbsolute(const ::basegfx::B3DPolygon& rCandidate, double fDistance, double fLength)
+ {
+ ::basegfx::B3DPoint aRetval;
+ const sal_uInt32 nPointCount(rCandidate.count());
+
+ if(nPointCount > 1L)
{
- // This method may also be implemented using a loop over getEdgeLength, but
- // since this would cause a lot of sqare roots to be solved it is much better
- // to sum up the quadrats first and then use a singe suare root (if necessary)
- double fRetval(0.0);
- const sal_uInt32 nPointCount(rCandidate.count());
- const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
-
- for(sal_uInt32 a(0L); a < nLoopCount; a++)
+ sal_uInt32 nIndex(0L);
+ sal_Bool bIndexDone(sal_False);
+ const double fZero(0.0);
+ double fEdgeLength(fZero);
+
+ // get length if not given
+ if(::basegfx::fTools::equalZero(fLength))
{
- const sal_uInt32 nNextIndex(a + 1 == nPointCount ? 0L : a + 1L);
- const ::basegfx::point::B3DPoint aCurrentPoint(rCandidate.getB3DPoint(a));
- const ::basegfx::point::B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
- const ::basegfx::vector::B3DVector aVector(aNextPoint - aCurrentPoint);
- fRetval += aVector.scalar(aVector);
+ fLength = getLength(rCandidate);
}
- if(!::basegfx::numeric::fTools::equalZero(fRetval))
+ // handle fDistance < 0.0
+ if(::basegfx::fTools::less(fDistance, fZero))
{
- const double fOne(1.0);
-
- if(!::basegfx::numeric::fTools::equal(fOne, fRetval))
+ if(rCandidate.isClosed())
+ {
+ // if fDistance < 0.0 increment with multiple of fLength
+ sal_uInt32 nCount(sal_uInt32(-fDistance / fLength));
+ fDistance += double(nCount + 1L) * fLength;
+ }
+ else
{
- fRetval = sqrt(fRetval);
+ // crop to polygon start
+ fDistance = fZero;
+ bIndexDone = sal_True;
}
}
- return fRetval;
- }
-
- ::basegfx::point::B3DPoint getPositionAbsolute(const ::basegfx::polygon::B3DPolygon& rCandidate, double fDistance, double fLength)
- {
- ::basegfx::point::B3DPoint aRetval;
- const sal_uInt32 nPointCount(rCandidate.count());
-
- if(nPointCount > 1L)
+ // handle fDistance >= fLength
+ if(::basegfx::fTools::moreOrEqual(fDistance, fLength))
{
- sal_uInt32 nIndex(0L);
- sal_Bool bIndexDone(sal_False);
- const double fZero(0.0);
- double fEdgeLength(fZero);
-
- // get length if not given
- if(::basegfx::numeric::fTools::equalZero(fLength))
+ if(rCandidate.isClosed())
{
- fLength = getLength(rCandidate);
+ // if fDistance >= fLength decrement with multiple of fLength
+ sal_uInt32 nCount(sal_uInt32(fDistance / fLength));
+ fDistance -= (double)(nCount) * fLength;
}
-
- // handle fDistance < 0.0
- if(::basegfx::numeric::fTools::less(fDistance, fZero))
+ else
{
- if(rCandidate.isClosed())
- {
- // if fDistance < 0.0 increment with multiple of fLength
- sal_uInt32 nCount(sal_uInt32(-fDistance / fLength));
- fDistance += double(nCount + 1L) * fLength;
- }
- else
- {
- // crop to polygon start
- fDistance = fZero;
- bIndexDone = sal_True;
- }
+ // crop to polygon end
+ fDistance = fZero;
+ nIndex = nPointCount - 1L;
+ bIndexDone = sal_True;
}
+ }
- // handle fDistance >= fLength
- if(::basegfx::numeric::fTools::moreOrEqual(fDistance, fLength))
+ // look for correct index. fDistance is now [0.0 .. fLength[
+ if(!bIndexDone)
+ {
+ do
{
- if(rCandidate.isClosed())
+ // get length of next edge
+ fEdgeLength = getEdgeLength(rCandidate, nIndex);
+
+ if(::basegfx::fTools::moreOrEqual(fDistance, fEdgeLength))
{
- // if fDistance >= fLength decrement with multiple of fLength
- sal_uInt32 nCount(sal_uInt32(fDistance / fLength));
- fDistance -= (double)(nCount) * fLength;
+ // go to next edge
+ fDistance -= fEdgeLength;
+ nIndex++;
}
else
{
- // crop to polygon end
- fDistance = fZero;
- nIndex = nPointCount - 1L;
+ // it's on this edge, stop
bIndexDone = sal_True;
}
+ } while (!bIndexDone);
+ }
+
+ // get the point using nIndex
+ aRetval = rCandidate.getB3DPoint(nIndex);
+
+ // if fDistance != 0.0, move that length on the edge. The edge
+ // length is in fEdgeLength.
+ if(!::basegfx::fTools::equalZero(fDistance))
+ {
+ sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
+ const ::basegfx::B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
+ double fRelative(fZero);
+
+ if(!::basegfx::fTools::equalZero(fEdgeLength))
+ {
+ fRelative = fDistance / fEdgeLength;
}
- // look for correct index. fDistance is now [0.0 .. fLength[
- if(!bIndexDone)
+ // add calculated average value to the return value
+ aRetval += ::basegfx::average(aRetval, aNextPoint, fRelative);
+ }
+ }
+
+ return aRetval;
+ }
+
+ ::basegfx::B3DPoint getPositionRelative(const ::basegfx::B3DPolygon& rCandidate, double fDistance, double fLength)
+ {
+ // get length if not given
+ if(::basegfx::fTools::equalZero(fLength))
+ {
+ fLength = getLength(rCandidate);
+ }
+
+ // multiply fDistance with real length to get absolute position and
+ // use getPositionAbsolute
+ return getPositionAbsolute(rCandidate, fDistance * fLength, fLength);
+ }
+
+ ::basegfx::B3DPolyPolygon applyLineDashing(const ::basegfx::B3DPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen)
+ {
+ ::basegfx::B3DPolyPolygon aRetval;
+
+ if(rCandidate.count() && fFullDashDotLen > 0.0)
+ {
+ const sal_uInt32 nCount(rCandidate.isClosed() ? rCandidate.count() : rCandidate.count() - 1L);
+ sal_uInt32 nDashDotIndex(0L);
+ double fDashDotLength(raDashDotArray[nDashDotIndex]);
+
+ for(sal_uInt32 a(0L); a < nCount; a++)
+ {
+ const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
+ const ::basegfx::B3DPoint aStart(rCandidate.getB3DPoint(a));
+ const ::basegfx::B3DPoint aEnd(rCandidate.getB3DPoint(nNextIndex));
+ ::basegfx::B3DVector aVector(aEnd - aStart);
+ double fLength(aVector.getLength());
+ double fPosOnVector(0.0);
+ aVector.normalize();
+
+ while(fLength >= fDashDotLength)
{
- do
+ // handle [fPosOnVector .. fPosOnVector+fDashDotLength]
+ if(nDashDotIndex % 2)
{
- // get length of next edge
- fEdgeLength = getEdgeLength(rCandidate, nIndex);
+ ::basegfx::B3DPolygon aResult;
- if(::basegfx::numeric::fTools::moreOrEqual(fDistance, fEdgeLength))
+ // add start point
+ if(fPosOnVector == 0.0)
{
- // go to next edge
- fDistance -= fEdgeLength;
- nIndex++;
+ aResult.append(aStart);
}
else
{
- // it's on this edge, stop
- bIndexDone = sal_True;
+ aResult.append(aStart + (aVector * fPosOnVector));
}
- } while (!bIndexDone);
- }
- // get the point using nIndex
- aRetval = rCandidate.getB3DPoint(nIndex);
+ // add end point
+ aResult.append(aStart + (aVector * (fPosOnVector + fDashDotLength)));
- // if fDistance != 0.0, move that length on the edge. The edge
- // length is in fEdgeLength.
- if(!::basegfx::numeric::fTools::equalZero(fDistance))
- {
- sal_uInt32 nNextIndex(getIndexOfSuccessor(nIndex, rCandidate));
- const ::basegfx::point::B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
- double fRelative(fZero);
-
- if(!::basegfx::numeric::fTools::equalZero(fEdgeLength))
- {
- fRelative = fDistance / fEdgeLength;
+ // add line to PolyPolygon
+ aRetval.append(aResult);
}
- // add calculated average value to the return value
- aRetval += ::basegfx::tuple::average(aRetval, aNextPoint, fRelative);
+ // consume from fDashDotLength
+ fPosOnVector += fDashDotLength;
+ fLength -= fDashDotLength;
+ nDashDotIndex = (nDashDotIndex + 1L) % raDashDotArray.size();
+ fDashDotLength = raDashDotArray[nDashDotIndex];
}
- }
- return aRetval;
- }
+ // handle [fPosOnVector .. fPosOnVector+fLength (bzw. end)]
+ if((fLength > 0.0) && (nDashDotIndex % 2))
+ {
+ ::basegfx::B3DPolygon aResult;
- ::basegfx::point::B3DPoint getPositionRelative(const ::basegfx::polygon::B3DPolygon& rCandidate, double fDistance, double fLength)
- {
- // get length if not given
- if(::basegfx::numeric::fTools::equalZero(fLength))
- {
- fLength = getLength(rCandidate);
- }
+ // add start and end point
+ const ::basegfx::B3DPoint aPosA(aStart + (aVector * fPosOnVector));
+ aResult.append(aPosA);
+ aResult.append(aEnd);
- // multiply fDistance with real length to get absolute position and
- // use getPositionAbsolute
- return getPositionAbsolute(rCandidate, fDistance * fLength, fLength);
+ // add line to PolyPolygon
+ aRetval.append(aResult);
+ }
+
+ // consume from fDashDotLength
+ fDashDotLength -= fLength;
+ }
}
- } // end of namespace tools
- } // end of namespace polygon
+ return aRetval;
+ }
+ } // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
diff --git a/basegfx/source/polygon/b3dpolypolygon.cxx b/basegfx/source/polygon/b3dpolypolygon.cxx
index 28e43316f369..bb78552b24e5 100644
--- a/basegfx/source/polygon/b3dpolypolygon.cxx
+++ b/basegfx/source/polygon/b3dpolypolygon.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolypolygon.cxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:31:37 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:07 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -77,7 +77,7 @@
class ImplB3DPolyPolygon
{
- typedef ::std::vector< ::basegfx::polygon::B3DPolygon > PolygonVector;
+ typedef ::std::vector< ::basegfx::B3DPolygon > PolygonVector;
PolygonVector maPolygons;
sal_uInt32 mnRefCount;
@@ -123,17 +123,17 @@ public:
return sal_True;
}
- const ::basegfx::polygon::B3DPolygon& getB3DPolygon(sal_uInt32 nIndex) const
+ const ::basegfx::B3DPolygon& getB3DPolygon(sal_uInt32 nIndex) const
{
return maPolygons[nIndex];
}
- void setB3DPolygon(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rPolygon)
+ void setB3DPolygon(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rPolygon)
{
maPolygons[nIndex] = rPolygon;
}
- void insert(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolygon& rPolygon, sal_uInt32 nCount)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B3DPolygon& rPolygon, sal_uInt32 nCount)
{
if(nCount)
{
@@ -144,7 +144,7 @@ public:
}
}
- void insert(sal_uInt32 nIndex, const ::basegfx::polygon::B3DPolyPolygon& rPolyPolygon)
+ void insert(sal_uInt32 nIndex, const ::basegfx::B3DPolyPolygon& rPolyPolygon)
{
const sal_uInt32 nCount = rPolyPolygon.count();
@@ -205,7 +205,7 @@ public:
}
}
- void transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix)
+ void transform(const ::basegfx::B3DHomMatrix& rMatrix)
{
for(sal_uInt32 a(0L); a < maPolygons.size(); a++)
{
@@ -218,232 +218,229 @@ public:
namespace basegfx
{
- namespace polygon
- {
- // init static default Polygon
- static ImplB3DPolyPolygon maStaticDefaultPolyPolygon;
+ // init static default Polygon
+ static ImplB3DPolyPolygon maStaticDefaultPolyPolygon;
- void B3DPolyPolygon::implForceUniqueCopy()
+ void B3DPolyPolygon::implForceUniqueCopy()
+ {
+ if(mpPolyPolygon->getRefCount())
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- mpPolyPolygon = new ImplB3DPolyPolygon(*mpPolyPolygon);
- }
+ mpPolyPolygon->decRefCount();
+ mpPolyPolygon = new ImplB3DPolyPolygon(*mpPolyPolygon);
}
+ }
+
+ B3DPolyPolygon::B3DPolyPolygon()
+ : mpPolyPolygon(&maStaticDefaultPolyPolygon)
+ {
+ mpPolyPolygon->incRefCount();
+ }
- B3DPolyPolygon::B3DPolyPolygon()
- : mpPolyPolygon(&maStaticDefaultPolyPolygon)
+ B3DPolyPolygon::B3DPolyPolygon(const B3DPolyPolygon& rPolyPolygon)
+ : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
+ {
+ mpPolyPolygon->incRefCount();
+ }
+
+ B3DPolyPolygon::~B3DPolyPolygon()
+ {
+ if(mpPolyPolygon->getRefCount())
{
- mpPolyPolygon->incRefCount();
+ mpPolyPolygon->decRefCount();
}
-
- B3DPolyPolygon::B3DPolyPolygon(const B3DPolyPolygon& rPolyPolygon)
- : mpPolyPolygon(rPolyPolygon.mpPolyPolygon)
+ else
{
- mpPolyPolygon->incRefCount();
+ delete mpPolyPolygon;
}
+ }
- B3DPolyPolygon::~B3DPolyPolygon()
+ B3DPolyPolygon& B3DPolyPolygon::operator=(const B3DPolyPolygon& rPolyPolygon)
+ {
+ if(mpPolyPolygon->getRefCount())
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
+ mpPolyPolygon->decRefCount();
}
-
- B3DPolyPolygon& B3DPolyPolygon::operator=(const B3DPolyPolygon& rPolyPolygon)
+ else
{
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
-
- mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
- mpPolyPolygon->incRefCount();
-
- return *this;
+ delete mpPolyPolygon;
}
- sal_Bool B3DPolyPolygon::operator==(const B3DPolyPolygon& rPolyPolygon) const
- {
- if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
- {
- return sal_True;
- }
+ mpPolyPolygon = rPolyPolygon.mpPolyPolygon;
+ mpPolyPolygon->incRefCount();
- return mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
- }
+ return *this;
+ }
- sal_Bool B3DPolyPolygon::operator!=(const B3DPolyPolygon& rPolyPolygon) const
+ sal_Bool B3DPolyPolygon::operator==(const B3DPolyPolygon& rPolyPolygon) const
+ {
+ if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
{
- if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
- {
- return sal_False;
- }
-
- return !mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ return sal_True;
}
- sal_uInt32 B3DPolyPolygon::count() const
+ return mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ }
+
+ sal_Bool B3DPolyPolygon::operator!=(const B3DPolyPolygon& rPolyPolygon) const
+ {
+ if(mpPolyPolygon == rPolyPolygon.mpPolyPolygon)
{
- return mpPolyPolygon->count();
+ return sal_False;
}
- B3DPolygon B3DPolyPolygon::getB3DPolygon(sal_uInt32 nIndex) const
- {
- OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
+ return !mpPolyPolygon->isEqual(*(rPolyPolygon.mpPolyPolygon));
+ }
- return mpPolyPolygon->getB3DPolygon(nIndex);
- }
+ sal_uInt32 B3DPolyPolygon::count() const
+ {
+ return mpPolyPolygon->count();
+ }
- void B3DPolyPolygon::setB3DPolygon(sal_uInt32 nIndex, const B3DPolygon& rPolygon)
- {
- OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
+ B3DPolygon B3DPolyPolygon::getB3DPolygon(sal_uInt32 nIndex) const
+ {
+ OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
- if(mpPolyPolygon->getB3DPolygon(nIndex) != rPolygon)
- {
- implForceUniqueCopy();
- mpPolyPolygon->setB3DPolygon(nIndex, rPolygon);
- }
- }
+ return mpPolyPolygon->getB3DPolygon(nIndex);
+ }
- void B3DPolyPolygon::insert(sal_uInt32 nIndex, const B3DPolygon& rPolygon, sal_uInt32 nCount)
- {
- OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B3DPolyPolygon Insert outside range (!)");
+ void B3DPolyPolygon::setB3DPolygon(sal_uInt32 nIndex, const B3DPolygon& rPolygon)
+ {
+ OSL_ENSURE(nIndex < mpPolyPolygon->count(), "B3DPolyPolygon access outside range (!)");
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(nIndex, rPolygon, nCount);
- }
+ if(mpPolyPolygon->getB3DPolygon(nIndex) != rPolygon)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->setB3DPolygon(nIndex, rPolygon);
}
+ }
- void B3DPolyPolygon::append(const B3DPolygon& rPolygon, sal_uInt32 nCount)
+ void B3DPolyPolygon::insert(sal_uInt32 nIndex, const B3DPolygon& rPolygon, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B3DPolyPolygon Insert outside range (!)");
+
+ if(nCount)
{
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(nIndex, rPolygon, nCount);
}
+ }
- void B3DPolyPolygon::insert(sal_uInt32 nIndex, const B3DPolyPolygon& rPolyPolygon)
+ void B3DPolyPolygon::append(const B3DPolygon& rPolygon, sal_uInt32 nCount)
+ {
+ if(nCount)
{
- OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B3DPolyPolygon Insert outside range (!)");
-
- if(rPolyPolygon.count())
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(nIndex, rPolyPolygon);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(mpPolyPolygon->count(), rPolygon, nCount);
}
+ }
+
+ void B3DPolyPolygon::insert(sal_uInt32 nIndex, const B3DPolyPolygon& rPolyPolygon)
+ {
+ OSL_ENSURE(nIndex <= mpPolyPolygon->count(), "B3DPolyPolygon Insert outside range (!)");
- void B3DPolyPolygon::append(const B3DPolyPolygon& rPolyPolygon)
+ if(rPolyPolygon.count())
{
- if(rPolyPolygon.count())
- {
- implForceUniqueCopy();
- mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(nIndex, rPolyPolygon);
}
+ }
- void B3DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ void B3DPolyPolygon::append(const B3DPolyPolygon& rPolyPolygon)
+ {
+ if(rPolyPolygon.count())
{
- OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B3DPolyPolygon Remove outside range (!)");
-
- if(nCount)
- {
- implForceUniqueCopy();
- mpPolyPolygon->remove(nIndex, nCount);
- }
+ implForceUniqueCopy();
+ mpPolyPolygon->insert(mpPolyPolygon->count(), rPolyPolygon);
}
+ }
- void B3DPolyPolygon::clear()
- {
- if(mpPolyPolygon->getRefCount())
- {
- mpPolyPolygon->decRefCount();
- }
- else
- {
- delete mpPolyPolygon;
- }
+ void B3DPolyPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
+ {
+ OSL_ENSURE(nIndex + nCount <= mpPolyPolygon->count(), "B3DPolyPolygon Remove outside range (!)");
- mpPolyPolygon = &maStaticDefaultPolyPolygon;
- mpPolyPolygon->incRefCount();
+ if(nCount)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->remove(nIndex, nCount);
}
+ }
- sal_Bool B3DPolyPolygon::isClosed() const
+ void B3DPolyPolygon::clear()
+ {
+ if(mpPolyPolygon->getRefCount())
+ {
+ mpPolyPolygon->decRefCount();
+ }
+ else
{
- sal_Bool bRetval(sal_True);
+ delete mpPolyPolygon;
+ }
- // PolyPOlygon is closed when all contained Polygons are closed or
- // no Polygon exists.
- for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
- {
- if(!(mpPolyPolygon->getB3DPolygon(a)).isClosed())
- {
- bRetval = sal_False;
- }
- }
+ mpPolyPolygon = &maStaticDefaultPolyPolygon;
+ mpPolyPolygon->incRefCount();
+ }
- return bRetval;
- }
+ sal_Bool B3DPolyPolygon::isClosed() const
+ {
+ sal_Bool bRetval(sal_True);
- void B3DPolyPolygon::setClosed(sal_Bool bNew)
+ // PolyPOlygon is closed when all contained Polygons are closed or
+ // no Polygon exists.
+ for(sal_uInt32 a(0L); bRetval && a < mpPolyPolygon->count(); a++)
{
- if(bNew != isClosed())
+ if(!(mpPolyPolygon->getB3DPolygon(a)).isClosed())
{
- implForceUniqueCopy();
- mpPolyPolygon->setClosed(bNew);
+ bRetval = sal_False;
}
}
- void B3DPolyPolygon::flip()
+ return bRetval;
+ }
+
+ void B3DPolyPolygon::setClosed(sal_Bool bNew)
+ {
+ if(bNew != isClosed())
{
implForceUniqueCopy();
- mpPolyPolygon->flip();
+ mpPolyPolygon->setClosed(bNew);
}
+ }
- sal_Bool B3DPolyPolygon::hasDoublePoints() const
- {
- sal_Bool bRetval(sal_False);
-
- for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
- {
- if((mpPolyPolygon->getB3DPolygon(a)).hasDoublePoints())
- {
- bRetval = sal_True;
- }
- }
+ void B3DPolyPolygon::flip()
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->flip();
+ }
- return bRetval;
- }
+ sal_Bool B3DPolyPolygon::hasDoublePoints() const
+ {
+ sal_Bool bRetval(sal_False);
- void B3DPolyPolygon::removeDoublePoints()
+ for(sal_uInt32 a(0L); !bRetval && a < mpPolyPolygon->count(); a++)
{
- if(hasDoublePoints())
+ if((mpPolyPolygon->getB3DPolygon(a)).hasDoublePoints())
{
- implForceUniqueCopy();
- mpPolyPolygon->removeDoublePoints();
+ bRetval = sal_True;
}
}
- void B3DPolyPolygon::transform(const ::basegfx::matrix::B3DHomMatrix& rMatrix)
+ return bRetval;
+ }
+
+ void B3DPolyPolygon::removeDoublePoints()
+ {
+ if(hasDoublePoints())
{
implForceUniqueCopy();
- mpPolyPolygon->transform(rMatrix);
+ mpPolyPolygon->removeDoublePoints();
}
- } // end of namespace polygon
+ }
+
+ void B3DPolyPolygon::transform(const ::basegfx::B3DHomMatrix& rMatrix)
+ {
+ implForceUniqueCopy();
+ mpPolyPolygon->transform(rMatrix);
+ }
} // end of namespace basegfx
// eof
diff --git a/basegfx/source/polygon/b3dpolypolygontools.cxx b/basegfx/source/polygon/b3dpolypolygontools.cxx
index 3b540b258653..4a4e5a3eab2e 100644
--- a/basegfx/source/polygon/b3dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolypolygontools.cxx
@@ -2,9 +2,9 @@
*
* $RCSfile: b3dpolypolygontools.cxx,v $
*
- * $Revision: 1.1 $
+ * $Revision: 1.2 $
*
- * last change: $Author: aw $ $Date: 2003-11-26 14:31:41 $
+ * last change: $Author: aw $ $Date: 2003-11-28 11:18:07 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
@@ -87,26 +87,37 @@
namespace basegfx
{
- namespace polygon
+ namespace tools
{
- namespace tools
+ // B3DPolyPolygon tools
+ ::basegfx::B3DRange getRange(const ::basegfx::B3DPolyPolygon& rCandidate)
{
- // B3DPolyPolygon tools
- ::basegfx::range::B3DRange getRange(const ::basegfx::polygon::B3DPolyPolygon& rCandidate)
+ ::basegfx::B3DRange aRetval;
+ const sal_uInt32 nPolygonCount(rCandidate.count());
+
+ for(sal_uInt32 a(0L); a < nPolygonCount; a++)
{
- ::basegfx::range::B3DRange aRetval;
- const sal_uInt32 nPolygonCount(rCandidate.count());
+ ::basegfx::B3DPolygon aCandidate = rCandidate.getB3DPolygon(a);
+ aRetval.expand(::basegfx::tools::getRange(aCandidate));
+ }
+
+ return aRetval;
+ }
- for(sal_uInt32 a(0L); a < nPolygonCount; a++)
- {
- ::basegfx::polygon::B3DPolygon aCandidate = rCandidate.getB3DPolygon(a);
- aRetval.expand(::basegfx::polygon::tools::getRange(aCandidate));
- }
+ ::basegfx::B3DPolyPolygon applyLineDashing(const ::basegfx::B3DPolyPolygon& rCandidate, const ::std::vector<double>& raDashDotArray, double fFullDashDotLen)
+ {
+ ::basegfx::B3DPolyPolygon aRetval;
+ const sal_uInt32 nPolygonCount(rCandidate.count());
- return aRetval;
+ for(sal_uInt32 a(0L); a < nPolygonCount; a++)
+ {
+ ::basegfx::B3DPolygon aCandidate = rCandidate.getB3DPolygon(a);
+ aRetval.append(applyLineDashing(aCandidate, raDashDotArray, fFullDashDotLen));
}
- } // end of namespace tools
- } // end of namespace polygon
+
+ return aRetval;
+ }
+ } // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-19 21:55:15 +0000