basegfx/source/polygon/b2dpolygon.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: b2dpolygon.cxx,v $
  10  * $Revision: 1.22 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basegfx.hxx"
  33 #include <osl/diagnose.h>
  34 #include <basegfx/polygon/b2dpolygon.hxx>
  35 #include <basegfx/point/b2dpoint.hxx>
  36 #include <basegfx/vector/b2dvector.hxx>
  37 #include <basegfx/matrix/b2dhommatrix.hxx>
  38 #include <basegfx/curve/b2dcubicbezier.hxx>
  39 #include <rtl/instance.hxx>
  40 #include <basegfx/polygon/b2dpolygontools.hxx>
  41 #include <boost/scoped_ptr.hpp>
  42 #include <vector>
  43 #include <algorithm>
  44
  45 //////////////////////////////////////////////////////////////////////////////
  46
  47 class CoordinateData2D
  48 {
  49     basegfx::B2DPoint                                                           maPoint;
  50
  51 public:
  52     CoordinateData2D()
  53     :   maPoint()
  54     {}
  55
  56     explicit CoordinateData2D(const basegfx::B2DPoint& rData)
  57     :   maPoint(rData)
  58     {}
  59
  60     const basegfx::B2DPoint& getCoordinate() const
  61     {
  62         return maPoint;
  63     }
  64
  65     void setCoordinate(const basegfx::B2DPoint& rValue)
  66     {
  67         if(rValue != maPoint)
  68             maPoint = rValue;
  69     }
  70
  71     bool operator==(const CoordinateData2D& rData ) const
  72     {
  73         return (maPoint == rData.getCoordinate());
  74     }
  75
  76     void transform(const basegfx::B2DHomMatrix& rMatrix)
  77     {
  78         maPoint *= rMatrix;
  79     }
  80 };
  81
  82 //////////////////////////////////////////////////////////////////////////////
  83
  84 class CoordinateDataArray2D
  85 {
  86     typedef ::std::vector< CoordinateData2D > CoordinateData2DVector;
  87
  88     CoordinateData2DVector                                                      maVector;
  89
  90 public:
  91     explicit CoordinateDataArray2D(sal_uInt32 nCount)
  92     :   maVector(nCount)
  93     {
  94     }
  95
  96     explicit CoordinateDataArray2D(const CoordinateDataArray2D& rOriginal)
  97     :   maVector(rOriginal.maVector)
  98     {
  99     }
 100
 101     CoordinateDataArray2D(const CoordinateDataArray2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 102     :   maVector(rOriginal.maVector.begin() + nIndex, rOriginal.maVector.begin() + (nIndex + nCount))
 103     {
 104     }
 105
 106     sal_uInt32 count() const
 107     {
 108         return maVector.size();
 109     }
 110
 111     bool operator==(const CoordinateDataArray2D& rCandidate) const
 112     {
 113         return (maVector == rCandidate.maVector);
 114     }
 115
 116     const basegfx::B2DPoint& getCoordinate(sal_uInt32 nIndex) const
 117     {
 118         return maVector[nIndex].getCoordinate();
 119     }
 120
 121     void setCoordinate(sal_uInt32 nIndex, const basegfx::B2DPoint& rValue)
 122     {
 123         maVector[nIndex].setCoordinate(rValue);
 124     }
 125
 126     void insert(sal_uInt32 nIndex, const CoordinateData2D& rValue, sal_uInt32 nCount)
 127     {
 128         if(nCount)
 129         {
 130             // add nCount copies of rValue
 131             CoordinateData2DVector::iterator aIndex(maVector.begin());
 132             aIndex += nIndex;
 133             maVector.insert(aIndex, nCount, rValue);
 134         }
 135     }
 136
 137     void insert(sal_uInt32 nIndex, const CoordinateDataArray2D& rSource)
 138     {
 139         const sal_uInt32 nCount(rSource.maVector.size());
 140
 141         if(nCount)
 142         {
 143             // insert data
 144             CoordinateData2DVector::iterator aIndex(maVector.begin());
 145             aIndex += nIndex;
 146             CoordinateData2DVector::const_iterator aStart(rSource.maVector.begin());
 147             CoordinateData2DVector::const_iterator aEnd(rSource.maVector.end());
 148             maVector.insert(aIndex, aStart, aEnd);
 149         }
 150     }
 151
 152     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 153     {
 154         if(nCount)
 155         {
 156             // remove point data
 157             CoordinateData2DVector::iterator aStart(maVector.begin());
 158             aStart += nIndex;
 159             const CoordinateData2DVector::iterator aEnd(aStart + nCount);
 160             maVector.erase(aStart, aEnd);
 161         }
 162     }
 163
 164     void flip(bool bIsClosed)
 165     {
 166         if(maVector.size() > 1)
 167         {
 168             // to keep the same point at index 0, just flip all points except the
 169             // first one when closed
 170             const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
 171             CoordinateData2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
 172             CoordinateData2DVector::iterator aEnd(maVector.end() - 1);
 173
 174             for(sal_uInt32 a(0); a < nHalfSize; a++)
 175             {
 176                 ::std::swap(*aStart, *aEnd);
 177                 aStart++;
 178                 aEnd--;
 179             }
 180         }
 181     }
 182
 183     void removeDoublePointsAtBeginEnd()
 184     {
 185         // remove from end as long as there are at least two points
 186         // and begin/end are equal
 187         while((maVector.size() > 1) && (maVector[0] == maVector[maVector.size() - 1]))
 188         {
 189             maVector.pop_back();
 190         }
 191     }
 192
 193     void removeDoublePointsWholeTrack()
 194     {
 195         sal_uInt32 nIndex(0);
 196
 197         // test as long as there are at least two points and as long as the index
 198         // is smaller or equal second last point
 199         while((maVector.size() > 1) && (nIndex <= maVector.size() - 2))
 200         {
 201             if(maVector[nIndex] == maVector[nIndex + 1])
 202             {
 203                 // if next is same as index, delete next
 204                 maVector.erase(maVector.begin() + (nIndex + 1));
 205             }
 206             else
 207             {
 208                 // if different, step forward
 209                 nIndex++;
 210             }
 211         }
 212     }
 213
 214     void transform(const basegfx::B2DHomMatrix& rMatrix)
 215     {
 216         CoordinateData2DVector::iterator aStart(maVector.begin());
 217         CoordinateData2DVector::iterator aEnd(maVector.end());
 218
 219         for(; aStart != aEnd; aStart++)
 220         {
 221             aStart->transform(rMatrix);
 222         }
 223     }
 224 };
 225
 226 //////////////////////////////////////////////////////////////////////////////
 227
 228 class ControlVectorPair2D
 229 {
 230     basegfx::B2DVector                                                  maPrevVector;
 231     basegfx::B2DVector                                                  maNextVector;
 232
 233 public:
 234     const basegfx::B2DVector& getPrevVector() const
 235     {
 236         return maPrevVector;
 237     }
 238
 239     void setPrevVector(const basegfx::B2DVector& rValue)
 240     {
 241         if(rValue != maPrevVector)
 242             maPrevVector = rValue;
 243     }
 244
 245     const basegfx::B2DVector& getNextVector() const
 246     {
 247         return maNextVector;
 248     }
 249
 250     void setNextVector(const basegfx::B2DVector& rValue)
 251     {
 252         if(rValue != maNextVector)
 253             maNextVector = rValue;
 254     }
 255
 256     bool operator==(const ControlVectorPair2D& rData) const
 257     {
 258         return (maPrevVector == rData.getPrevVector() && maNextVector == rData.getNextVector());
 259     }
 260
 261     void flip()
 262     {
 263         ::std::swap(maPrevVector, maNextVector);
 264     }
 265 };
 266
 267 //////////////////////////////////////////////////////////////////////////////
 268
 269 class ControlVectorArray2D
 270 {
 271     typedef ::std::vector< ControlVectorPair2D > ControlVectorPair2DVector;
 272
 273     ControlVectorPair2DVector                                                   maVector;
 274     sal_uInt32                                                                                  mnUsedVectors;
 275
 276 public:
 277     explicit ControlVectorArray2D(sal_uInt32 nCount)
 278     :   maVector(nCount),
 279         mnUsedVectors(0)
 280     {}
 281
 282     ControlVectorArray2D(const ControlVectorArray2D& rOriginal, sal_uInt32 nIndex, sal_uInt32 nCount)
 283     :   maVector(),
 284         mnUsedVectors(0)
 285     {
 286         ControlVectorPair2DVector::const_iterator aStart(rOriginal.maVector.begin());
 287         aStart += nIndex;
 288         ControlVectorPair2DVector::const_iterator aEnd(aStart);
 289         aEnd += nCount;
 290         maVector.reserve(nCount);
 291
 292         for(; aStart != aEnd; aStart++)
 293         {
 294             if(!aStart->getPrevVector().equalZero())
 295                 mnUsedVectors++;
 296
 297             if(!aStart->getNextVector().equalZero())
 298                 mnUsedVectors++;
 299
 300             maVector.push_back(*aStart);
 301         }
 302     }
 303
 304     sal_uInt32 count() const
 305     {
 306         return maVector.size();
 307     }
 308
 309     bool operator==(const ControlVectorArray2D& rCandidate) const
 310     {
 311         return (maVector == rCandidate.maVector);
 312     }
 313
 314     bool isUsed() const
 315     {
 316         return (0 != mnUsedVectors);
 317     }
 318
 319     const basegfx::B2DVector& getPrevVector(sal_uInt32 nIndex) const
 320     {
 321         return maVector[nIndex].getPrevVector();
 322     }
 323
 324     void setPrevVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 325     {
 326         bool bWasUsed(mnUsedVectors && !maVector[nIndex].getPrevVector().equalZero());
 327         bool bIsUsed(!rValue.equalZero());
 328
 329         if(bWasUsed)
 330         {
 331             if(bIsUsed)
 332             {
 333                 maVector[nIndex].setPrevVector(rValue);
 334             }
 335             else
 336             {
 337                 maVector[nIndex].setPrevVector(basegfx::B2DVector::getEmptyVector());
 338                 mnUsedVectors--;
 339             }
 340         }
 341         else
 342         {
 343             if(bIsUsed)
 344             {
 345                 maVector[nIndex].setPrevVector(rValue);
 346                 mnUsedVectors++;
 347             }
 348         }
 349     }
 350
 351     const basegfx::B2DVector& getNextVector(sal_uInt32 nIndex) const
 352     {
 353         return maVector[nIndex].getNextVector();
 354     }
 355
 356     void setNextVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 357     {
 358         bool bWasUsed(mnUsedVectors && !maVector[nIndex].getNextVector().equalZero());
 359         bool bIsUsed(!rValue.equalZero());
 360
 361         if(bWasUsed)
 362         {
 363             if(bIsUsed)
 364             {
 365                 maVector[nIndex].setNextVector(rValue);
 366             }
 367             else
 368             {
 369                 maVector[nIndex].setNextVector(basegfx::B2DVector::getEmptyVector());
 370                 mnUsedVectors--;
 371             }
 372         }
 373         else
 374         {
 375             if(bIsUsed)
 376             {
 377                 maVector[nIndex].setNextVector(rValue);
 378                 mnUsedVectors++;
 379             }
 380         }
 381     }
 382
 383     void insert(sal_uInt32 nIndex, const ControlVectorPair2D& rValue, sal_uInt32 nCount)
 384     {
 385         if(nCount)
 386         {
 387             // add nCount copies of rValue
 388             ControlVectorPair2DVector::iterator aIndex(maVector.begin());
 389             aIndex += nIndex;
 390             maVector.insert(aIndex, nCount, rValue);
 391
 392             if(!rValue.getPrevVector().equalZero())
 393                 mnUsedVectors += nCount;
 394
 395             if(!rValue.getNextVector().equalZero())
 396                 mnUsedVectors += nCount;
 397         }
 398     }
 399
 400     void insert(sal_uInt32 nIndex, const ControlVectorArray2D& rSource)
 401     {
 402         const sal_uInt32 nCount(rSource.maVector.size());
 403
 404         if(nCount)
 405         {
 406             // insert data
 407             ControlVectorPair2DVector::iterator aIndex(maVector.begin());
 408             aIndex += nIndex;
 409             ControlVectorPair2DVector::const_iterator aStart(rSource.maVector.begin());
 410             ControlVectorPair2DVector::const_iterator aEnd(rSource.maVector.end());
 411             maVector.insert(aIndex, aStart, aEnd);
 412
 413             for(; aStart != aEnd; aStart++)
 414             {
 415                 if(!aStart->getPrevVector().equalZero())
 416                     mnUsedVectors++;
 417
 418                 if(!aStart->getNextVector().equalZero())
 419                     mnUsedVectors++;
 420             }
 421         }
 422     }
 423
 424     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 425     {
 426         if(nCount)
 427         {
 428             const ControlVectorPair2DVector::iterator aDeleteStart(maVector.begin() + nIndex);
 429             const ControlVectorPair2DVector::iterator aDeleteEnd(aDeleteStart + nCount);
 430             ControlVectorPair2DVector::const_iterator aStart(aDeleteStart);
 431
 432             for(; mnUsedVectors && aStart != aDeleteEnd; aStart++)
 433             {
 434                 if(!aStart->getPrevVector().equalZero())
 435                     mnUsedVectors--;
 436
 437                 if(mnUsedVectors && !aStart->getNextVector().equalZero())
 438                     mnUsedVectors--;
 439             }
 440
 441             // remove point data
 442             maVector.erase(aDeleteStart, aDeleteEnd);
 443         }
 444     }
 445
 446     void flip(bool bIsClosed)
 447     {
 448         if(maVector.size() > 1)
 449         {
 450             // to keep the same point at index 0, just flip all points except the
 451             // first one when closed
 452             const sal_uInt32 nHalfSize(bIsClosed ? (maVector.size() - 1) >> 1 : maVector.size() >> 1);
 453             ControlVectorPair2DVector::iterator aStart(bIsClosed ? maVector.begin() + 1 : maVector.begin());
 454             ControlVectorPair2DVector::iterator aEnd(maVector.end() - 1);
 455
 456             for(sal_uInt32 a(0); a < nHalfSize; a++)
 457             {
 458                 // swap Prev and Next
 459                 aStart->flip();
 460                 aEnd->flip();
 461
 462                 // swap entries
 463                 ::std::swap(*aStart, *aEnd);
 464
 465                 aStart++;
 466                 aEnd--;
 467             }
 468
 469             if(aStart == aEnd)
 470             {
 471                 // swap Prev and Next at middle element (if exists)
 472                 aStart->flip();
 473             }
 474
 475             if(bIsClosed)
 476             {
 477                 // swap Prev and Next at start element
 478                 maVector.begin()->flip();
 479             }
 480         }
 481     }
 482 };
 483
 484 //////////////////////////////////////////////////////////////////////////////
 485
 486 class ImplBufferedData
 487 {
 488 private:
 489     // Possibility to hold the last subdivision
 490     boost::scoped_ptr< basegfx::B2DPolygon >            mpDefaultSubdivision;
 491
 492     // Possibility to hold the last B2DRange calculation
 493     boost::scoped_ptr< basegfx::B2DRange >                  mpB2DRange;
 494
 495 public:
 496     ImplBufferedData()
 497     :   mpDefaultSubdivision(),
 498         mpB2DRange()
 499     {}
 500
 501     const basegfx::B2DPolygon& getDefaultAdaptiveSubdivision(const basegfx::B2DPolygon& rSource) const
 502     {
 503         if(!mpDefaultSubdivision)
 504         {
 505             const_cast< ImplBufferedData* >(this)->mpDefaultSubdivision.reset(new basegfx::B2DPolygon(basegfx::tools::adaptiveSubdivideByCount(rSource, 9)));
 506         }
 507
 508         return *mpDefaultSubdivision;
 509     }
 510
 511     const basegfx::B2DRange& getB2DRange(const basegfx::B2DPolygon& rSource) const
 512     {
 513         if(!mpB2DRange)
 514         {
 515             basegfx::B2DRange aNewRange;
 516             const sal_uInt32 nPointCount(rSource.count());
 517
 518             if(nPointCount)
 519             {
 520                 for(sal_uInt32 a(0); a < nPointCount; a++)
 521                 {
 522                     aNewRange.expand(rSource.getB2DPoint(a));
 523                 }
 524
 525                 if(rSource.areControlPointsUsed())
 526                 {
 527                     const sal_uInt32 nEdgeCount(rSource.isClosed() ? nPointCount : nPointCount - 1);
 528
 529                     if(nEdgeCount)
 530                     {
 531                         basegfx::B2DCubicBezier aEdge;
 532                         aEdge.setStartPoint(rSource.getB2DPoint(0));
 533
 534                         for(sal_uInt32 b(0); b < nEdgeCount; b++)
 535                         {
 536                             const sal_uInt32 nNextIndex((b + 1) % nPointCount);
 537                             aEdge.setControlPointA(rSource.getNextControlPoint(b));
 538                             aEdge.setControlPointB(rSource.getPrevControlPoint(nNextIndex));
 539                             aEdge.setEndPoint(rSource.getB2DPoint(nNextIndex));
 540
 541                             if(aEdge.isBezier())
 542                             {
 543                                 const basegfx::B2DRange aBezierRangeWithControlPoints(aEdge.getRange());
 544
 545                                 if(!aNewRange.isInside(aBezierRangeWithControlPoints))
 546                                 {
 547                                     // the range with control points of the current edge is not completely
 548                                     // inside the current range without control points. Expand current range by
 549                                     // subdividing the bezier segment.
 550                                     // Ideal here is a subdivision at the extreme values, so use
 551                                     // getAllExtremumPositions to get all extremas in one run
 552                                     ::std::vector< double > aExtremas;
 553
 554                                     aExtremas.reserve(4);
 555                                     aEdge.getAllExtremumPositions(aExtremas);
 556
 557                                     const sal_uInt32 nExtremaCount(aExtremas.size());
 558
 559                                     for(sal_uInt32 c(0); c < nExtremaCount; c++)
 560                                     {
 561                                         aNewRange.expand(aEdge.interpolatePoint(aExtremas[c]));
 562                                     }
 563                                 }
 564                             }
 565
 566                             // prepare next edge
 567                             aEdge.setStartPoint(aEdge.getEndPoint());
 568                         }
 569                     }
 570                 }
 571             }
 572
 573             const_cast< ImplBufferedData* >(this)->mpB2DRange.reset(new basegfx::B2DRange(aNewRange));
 574         }
 575
 576         return *mpB2DRange;
 577     }
 578 };
 579
 580 //////////////////////////////////////////////////////////////////////////////
 581
 582 class ImplB2DPolygon
 583 {
 584 private:
 585     // The point vector. This vector exists always and defines the
 586     // count of members.
 587     CoordinateDataArray2D                                                       maPoints;
 588
 589     // The control point vectors. This vectors are created on demand
 590     // and may be zero.
 591     boost::scoped_ptr< ControlVectorArray2D >           mpControlVector;
 592
 593     // buffered data for e.g. default subdivision and range
 594     boost::scoped_ptr< ImplBufferedData >           mpBufferedData;
 595
 596     // flag which decides if this polygon is opened or closed
 597     bool                                            mbIsClosed;
 598
 599 public:
 600     const basegfx::B2DPolygon& getDefaultAdaptiveSubdivision(const basegfx::B2DPolygon& rSource) const
 601     {
 602         if(!mpControlVector || !mpControlVector->isUsed())
 603         {
 604             return rSource;
 605         }
 606
 607         if(!mpBufferedData)
 608         {
 609             const_cast< ImplB2DPolygon* >(this)->mpBufferedData.reset(new ImplBufferedData);
 610         }
 611
 612         return mpBufferedData->getDefaultAdaptiveSubdivision(rSource);
 613     }
 614
 615     const basegfx::B2DRange& getB2DRange(const basegfx::B2DPolygon& rSource) const
 616     {
 617         if(!mpBufferedData)
 618         {
 619             const_cast< ImplB2DPolygon* >(this)->mpBufferedData.reset(new ImplBufferedData);
 620         }
 621
 622         return mpBufferedData->getB2DRange(rSource);
 623     }
 624
 625     ImplB2DPolygon()
 626     :   maPoints(0),
 627         mpControlVector(),
 628         mpBufferedData(),
 629         mbIsClosed(false)
 630     {}
 631
 632     ImplB2DPolygon(const ImplB2DPolygon& rToBeCopied)
 633     :   maPoints(rToBeCopied.maPoints),
 634         mpControlVector(),
 635         mpBufferedData(),
 636         mbIsClosed(rToBeCopied.mbIsClosed)
 637     {
 638         // complete initialization using copy
 639         if(rToBeCopied.mpControlVector && rToBeCopied.mpControlVector->isUsed())
 640         {
 641             mpControlVector.reset( new ControlVectorArray2D(*rToBeCopied.mpControlVector) );
 642         }
 643     }
 644
 645     ImplB2DPolygon(const ImplB2DPolygon& rToBeCopied, sal_uInt32 nIndex, sal_uInt32 nCount)
 646     :   maPoints(rToBeCopied.maPoints, nIndex, nCount),
 647         mpControlVector(),
 648         mpBufferedData(),
 649         mbIsClosed(rToBeCopied.mbIsClosed)
 650     {
 651         // complete initialization using partly copy
 652         if(rToBeCopied.mpControlVector && rToBeCopied.mpControlVector->isUsed())
 653         {
 654             mpControlVector.reset( new ControlVectorArray2D(*rToBeCopied.mpControlVector, nIndex, nCount) );
 655
 656             if(!mpControlVector->isUsed())
 657                 mpControlVector.reset();
 658         }
 659     }
 660
 661     ImplB2DPolygon& operator=( const ImplB2DPolygon& rToBeCopied )
 662     {
 663         maPoints = rToBeCopied.maPoints;
 664         mpControlVector.reset();
 665         mpBufferedData.reset();
 666         mbIsClosed = rToBeCopied.mbIsClosed;
 667
 668         // complete initialization using copy
 669         if(rToBeCopied.mpControlVector && rToBeCopied.mpControlVector->isUsed())
 670             mpControlVector.reset( new ControlVectorArray2D(*rToBeCopied.mpControlVector) );
 671
 672         return *this;
 673     }
 674
 675     sal_uInt32 count() const
 676     {
 677         return maPoints.count();
 678     }
 679
 680     bool isClosed() const
 681     {
 682         return mbIsClosed;
 683     }
 684
 685     void setClosed(bool bNew)
 686     {
 687         if(bNew != mbIsClosed)
 688         {
 689             mpBufferedData.reset();
 690             mbIsClosed = bNew;
 691         }
 692     }
 693
 694     bool operator==(const ImplB2DPolygon& rCandidate) const
 695     {
 696         if(mbIsClosed == rCandidate.mbIsClosed)
 697         {
 698             if(maPoints == rCandidate.maPoints)
 699             {
 700                 bool bControlVectorsAreEqual(true);
 701
 702                 if(mpControlVector)
 703                 {
 704                     if(rCandidate.mpControlVector)
 705                     {
 706                         bControlVectorsAreEqual = ((*mpControlVector) == (*rCandidate.mpControlVector));
 707                     }
 708                     else
 709                     {
 710                         // candidate has no control vector, so it's assumed all unused.
 711                         bControlVectorsAreEqual = !mpControlVector->isUsed();
 712                     }
 713                 }
 714                 else
 715                 {
 716                     if(rCandidate.mpControlVector)
 717                     {
 718                         // we have no control vector, so it's assumed all unused.
 719                         bControlVectorsAreEqual = !rCandidate.mpControlVector->isUsed();
 720                     }
 721                 }
 722
 723                 if(bControlVectorsAreEqual)
 724                 {
 725                     return true;
 726                 }
 727             }
 728         }
 729
 730         return false;
 731     }
 732
 733     const basegfx::B2DPoint& getPoint(sal_uInt32 nIndex) const
 734     {
 735         return maPoints.getCoordinate(nIndex);
 736     }
 737
 738     void setPoint(sal_uInt32 nIndex, const basegfx::B2DPoint& rValue)
 739     {
 740         mpBufferedData.reset();
 741         maPoints.setCoordinate(nIndex, rValue);
 742     }
 743
 744     void insert(sal_uInt32 nIndex, const basegfx::B2DPoint& rPoint, sal_uInt32 nCount)
 745     {
 746         if(nCount)
 747         {
 748             mpBufferedData.reset();
 749             CoordinateData2D aCoordinate(rPoint);
 750             maPoints.insert(nIndex, aCoordinate, nCount);
 751
 752             if(mpControlVector)
 753             {
 754                 ControlVectorPair2D aVectorPair;
 755                 mpControlVector->insert(nIndex, aVectorPair, nCount);
 756             }
 757         }
 758     }
 759
 760     const basegfx::B2DVector& getPrevControlVector(sal_uInt32 nIndex) const
 761     {
 762         if(mpControlVector)
 763         {
 764             return mpControlVector->getPrevVector(nIndex);
 765         }
 766         else
 767         {
 768             return basegfx::B2DVector::getEmptyVector();
 769         }
 770     }
 771
 772     void setPrevControlVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 773     {
 774         if(!mpControlVector)
 775         {
 776             if(!rValue.equalZero())
 777             {
 778                 mpBufferedData.reset();
 779                 mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
 780                 mpControlVector->setPrevVector(nIndex, rValue);
 781             }
 782         }
 783         else
 784         {
 785             mpBufferedData.reset();
 786             mpControlVector->setPrevVector(nIndex, rValue);
 787
 788             if(!mpControlVector->isUsed())
 789                 mpControlVector.reset();
 790         }
 791     }
 792
 793     const basegfx::B2DVector& getNextControlVector(sal_uInt32 nIndex) const
 794     {
 795         if(mpControlVector)
 796         {
 797             return mpControlVector->getNextVector(nIndex);
 798         }
 799         else
 800         {
 801             return basegfx::B2DVector::getEmptyVector();
 802         }
 803     }
 804
 805     void setNextControlVector(sal_uInt32 nIndex, const basegfx::B2DVector& rValue)
 806     {
 807         if(!mpControlVector)
 808         {
 809             if(!rValue.equalZero())
 810             {
 811                 mpBufferedData.reset();
 812                 mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
 813                 mpControlVector->setNextVector(nIndex, rValue);
 814             }
 815         }
 816         else
 817         {
 818             mpBufferedData.reset();
 819             mpControlVector->setNextVector(nIndex, rValue);
 820
 821             if(!mpControlVector->isUsed())
 822                 mpControlVector.reset();
 823         }
 824     }
 825
 826     bool areControlPointsUsed() const
 827     {
 828         return (mpControlVector && mpControlVector->isUsed());
 829     }
 830
 831     void resetControlVectors(sal_uInt32 nIndex)
 832     {
 833         setPrevControlVector(nIndex, basegfx::B2DVector::getEmptyVector());
 834         setNextControlVector(nIndex, basegfx::B2DVector::getEmptyVector());
 835     }
 836
 837     void resetControlVectors()
 838     {
 839         mpBufferedData.reset();
 840         mpControlVector.reset();
 841     }
 842
 843     void setControlVectors(sal_uInt32 nIndex, const basegfx::B2DVector& rPrev, const basegfx::B2DVector& rNext)
 844     {
 845         setPrevControlVector(nIndex, rPrev);
 846         setNextControlVector(nIndex, rNext);
 847     }
 848
 849     void appendBezierSegment(const basegfx::B2DVector& rNext, const basegfx::B2DVector& rPrev, const basegfx::B2DPoint& rPoint)
 850     {
 851         mpBufferedData.reset();
 852         const sal_uInt32 nCount(maPoints.count());
 853
 854         if(nCount)
 855         {
 856             setNextControlVector(nCount - 1, rNext);
 857         }
 858
 859         insert(nCount, rPoint, 1);
 860         setPrevControlVector(nCount, rPrev);
 861     }
 862
 863     void insert(sal_uInt32 nIndex, const ImplB2DPolygon& rSource)
 864     {
 865         const sal_uInt32 nCount(rSource.maPoints.count());
 866
 867         if(nCount)
 868         {
 869             mpBufferedData.reset();
 870
 871             if(rSource.mpControlVector && rSource.mpControlVector->isUsed() && !mpControlVector)
 872             {
 873                 mpControlVector.reset( new ControlVectorArray2D(maPoints.count()) );
 874             }
 875
 876             maPoints.insert(nIndex, rSource.maPoints);
 877
 878             if(rSource.mpControlVector)
 879             {
 880                 mpControlVector->insert(nIndex, *rSource.mpControlVector);
 881
 882                 if(!mpControlVector->isUsed())
 883                     mpControlVector.reset();
 884             }
 885             else if(mpControlVector)
 886             {
 887                 ControlVectorPair2D aVectorPair;
 888                 mpControlVector->insert(nIndex, aVectorPair, nCount);
 889             }
 890         }
 891     }
 892
 893     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 894     {
 895         if(nCount)
 896         {
 897             mpBufferedData.reset();
 898             maPoints.remove(nIndex, nCount);
 899
 900             if(mpControlVector)
 901             {
 902                 mpControlVector->remove(nIndex, nCount);
 903
 904                 if(!mpControlVector->isUsed())
 905                     mpControlVector.reset();
 906             }
 907         }
 908     }
 909
 910     void flip()
 911     {
 912         if(maPoints.count() > 1)
 913         {
 914             mpBufferedData.reset();
 915
 916             // flip points
 917             maPoints.flip(mbIsClosed);
 918
 919             if(mpControlVector)
 920             {
 921                 // flip control vector
 922                 mpControlVector->flip(mbIsClosed);
 923             }
 924         }
 925     }
 926
 927     bool hasDoublePoints() const
 928     {
 929         if(mbIsClosed)
 930         {
 931             // check for same start and end point
 932             const sal_uInt32 nIndex(maPoints.count() - 1);
 933
 934             if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
 935             {
 936                 if(mpControlVector)
 937                 {
 938                     if(mpControlVector->getNextVector(nIndex).equalZero() && mpControlVector->getPrevVector(0).equalZero())
 939                     {
 940                         return true;
 941                     }
 942                 }
 943                 else
 944                 {
 945                     return true;
 946                 }
 947             }
 948         }
 949
 950         // test for range
 951         for(sal_uInt32 a(0); a < maPoints.count() - 1; a++)
 952         {
 953             if(maPoints.getCoordinate(a) == maPoints.getCoordinate(a + 1))
 954             {
 955                 if(mpControlVector)
 956                 {
 957                     if(mpControlVector->getNextVector(a).equalZero() && mpControlVector->getPrevVector(a + 1).equalZero())
 958                     {
 959                         return true;
 960                     }
 961                 }
 962                 else
 963                 {
 964                     return true;
 965                 }
 966             }
 967         }
 968
 969         return false;
 970     }
 971
 972     void removeDoublePointsAtBeginEnd()
 973     {
 974         // Only remove DoublePoints at Begin and End when poly is closed
 975         if(mbIsClosed)
 976         {
 977             mpBufferedData.reset();
 978
 979             if(mpControlVector)
 980             {
 981                 bool bRemove;
 982
 983                 do
 984                 {
 985                     bRemove = false;
 986
 987                     if(maPoints.count() > 1)
 988                     {
 989                         const sal_uInt32 nIndex(maPoints.count() - 1);
 990
 991                         if(maPoints.getCoordinate(0) == maPoints.getCoordinate(nIndex))
 992                         {
 993                             if(mpControlVector)
 994                             {
 995                                 if(mpControlVector->getNextVector(nIndex).equalZero() && mpControlVector->getPrevVector(0).equalZero())
 996                                 {
 997                                     bRemove = true;
 998                                 }
 999                             }
1000                             else
1001                             {
1002                                 bRemove = true;
1003                             }
1004                         }
1005                     }
1006
1007                     if(bRemove)
1008                     {
1009                         const sal_uInt32 nIndex(maPoints.count() - 1);
1010
1011                         if(mpControlVector && !mpControlVector->getPrevVector(nIndex).equalZero())
1012                         {
1013                             mpControlVector->setPrevVector(0, mpControlVector->getPrevVector(nIndex));
1014                         }
1015
1016                         remove(nIndex, 1);
1017                     }
1018                 }
1019                 while(bRemove);
1020             }
1021             else
1022             {
1023                 maPoints.removeDoublePointsAtBeginEnd();
1024             }
1025         }
1026     }
1027
1028     void removeDoublePointsWholeTrack()
1029     {
1030         mpBufferedData.reset();
1031
1032         if(mpControlVector)
1033         {
1034             sal_uInt32 nIndex(0);
1035
1036             // test as long as there are at least two points and as long as the index
1037             // is smaller or equal second last point
1038             while((maPoints.count() > 1) && (nIndex <= maPoints.count() - 2))
1039             {
1040                 bool bRemove(maPoints.getCoordinate(nIndex) == maPoints.getCoordinate(nIndex + 1));
1041
1042                 if(bRemove)
1043                 {
1044                     if(mpControlVector)
1045                     {
1046                         if(!mpControlVector->getNextVector(nIndex).equalZero() || !mpControlVector->getPrevVector(nIndex + 1).equalZero())
1047                         {
1048                             bRemove = false;
1049                         }
1050                     }
1051                 }
1052
1053                 if(bRemove)
1054                 {
1055                     if(mpControlVector && !mpControlVector->getPrevVector(nIndex).equalZero())
1056                     {
1057                         mpControlVector->setPrevVector(nIndex + 1, mpControlVector->getPrevVector(nIndex));
1058                     }
1059
1060                     // if next is same as index and the control vectors are unused, delete index
1061                     remove(nIndex, 1);
1062                 }
1063                 else
1064                 {
1065                     // if different, step forward
1066                     nIndex++;
1067                 }
1068             }
1069         }
1070         else
1071         {
1072             maPoints.removeDoublePointsWholeTrack();
1073         }
1074     }
1075
1076     void transform(const basegfx::B2DHomMatrix& rMatrix)
1077     {
1078         mpBufferedData.reset();
1079
1080         if(mpControlVector)
1081         {
1082             for(sal_uInt32 a(0); a < maPoints.count(); a++)
1083             {
1084                 basegfx::B2DPoint aCandidate = maPoints.getCoordinate(a);
1085
1086                 if(mpControlVector->isUsed())
1087                 {
1088                     const basegfx::B2DVector& rPrevVector(mpControlVector->getPrevVector(a));
1089                     const basegfx::B2DVector& rNextVector(mpControlVector->getNextVector(a));
1090
1091                     if(!rPrevVector.equalZero())
1092                     {
1093                         basegfx::B2DVector aPrevVector(rMatrix * rPrevVector);
1094                         mpControlVector->setPrevVector(a, aPrevVector);
1095                     }
1096
1097                     if(!rNextVector.equalZero())
1098                     {
1099                         basegfx::B2DVector aNextVector(rMatrix * rNextVector);
1100                         mpControlVector->setNextVector(a, aNextVector);
1101                     }
1102                 }
1103
1104                 aCandidate *= rMatrix;
1105                 maPoints.setCoordinate(a, aCandidate);
1106             }
1107
1108             if(!mpControlVector->isUsed())
1109                 mpControlVector.reset();
1110         }
1111         else
1112         {
1113             maPoints.transform(rMatrix);
1114         }
1115     }
1116 };
1117
1118 //////////////////////////////////////////////////////////////////////////////
1119
1120 namespace basegfx
1121 {
1122     namespace
1123     {
1124         struct DefaultPolygon: public rtl::Static<B2DPolygon::ImplType, DefaultPolygon> {};
1125     }
1126
1127     B2DPolygon::B2DPolygon()
1128     :   mpPolygon(DefaultPolygon::get())
1129     {}
1130
1131     B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon)
1132     :   mpPolygon(rPolygon.mpPolygon)
1133     {}
1134
1135     B2DPolygon::B2DPolygon(const B2DPolygon& rPolygon, sal_uInt32 nIndex, sal_uInt32 nCount)
1136     :   mpPolygon(ImplB2DPolygon(*rPolygon.mpPolygon, nIndex, nCount))
1137     {
1138         // TODO(P2): one extra temporary here (cow_wrapper copies
1139         // given ImplB2DPolygon into its internal impl_t wrapper type)
1140         OSL_ENSURE(nIndex + nCount <= rPolygon.mpPolygon->count(), "B2DPolygon constructor outside range (!)");
1141     }
1142
1143     B2DPolygon::~B2DPolygon()
1144     {
1145     }
1146
1147     B2DPolygon& B2DPolygon::operator=(const B2DPolygon& rPolygon)
1148     {
1149         mpPolygon = rPolygon.mpPolygon;
1150         return *this;
1151     }
1152
1153     void B2DPolygon::makeUnique()
1154     {
1155         mpPolygon.make_unique();
1156     }
1157
1158     bool B2DPolygon::operator==(const B2DPolygon& rPolygon) const
1159     {
1160         if(mpPolygon.same_object(rPolygon.mpPolygon))
1161             return true;
1162
1163         return ((*mpPolygon) == (*rPolygon.mpPolygon));
1164     }
1165
1166     bool B2DPolygon::operator!=(const B2DPolygon& rPolygon) const
1167     {
1168         return !(*this == rPolygon);
1169     }
1170
1171     sal_uInt32 B2DPolygon::count() const
1172     {
1173         return mpPolygon->count();
1174     }
1175
1176     B2DPoint B2DPolygon::getB2DPoint(sal_uInt32 nIndex) const
1177     {
1178         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1179
1180         return mpPolygon->getPoint(nIndex);
1181     }
1182
1183     void B2DPolygon::setB2DPoint(sal_uInt32 nIndex, const B2DPoint& rValue)
1184     {
1185         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1186
1187         if(getB2DPoint(nIndex) != rValue)
1188         {
1189             mpPolygon->setPoint(nIndex, rValue);
1190         }
1191     }
1192
1193     void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPoint& rPoint, sal_uInt32 nCount)
1194     {
1195         OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
1196
1197         if(nCount)
1198         {
1199             mpPolygon->insert(nIndex, rPoint, nCount);
1200         }
1201     }
1202
1203     void B2DPolygon::append(const B2DPoint& rPoint, sal_uInt32 nCount)
1204     {
1205         if(nCount)
1206         {
1207             mpPolygon->insert(mpPolygon->count(), rPoint, nCount);
1208         }
1209     }
1210
1211     B2DPoint B2DPolygon::getPrevControlPoint(sal_uInt32 nIndex) const
1212     {
1213         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1214
1215         if(mpPolygon->areControlPointsUsed())
1216         {
1217             return mpPolygon->getPoint(nIndex) + mpPolygon->getPrevControlVector(nIndex);
1218         }
1219         else
1220         {
1221             return mpPolygon->getPoint(nIndex);
1222         }
1223     }
1224
1225     B2DPoint B2DPolygon::getNextControlPoint(sal_uInt32 nIndex) const
1226     {
1227         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1228
1229         if(mpPolygon->areControlPointsUsed())
1230         {
1231             return mpPolygon->getPoint(nIndex) + mpPolygon->getNextControlVector(nIndex);
1232         }
1233         else
1234         {
1235             return mpPolygon->getPoint(nIndex);
1236         }
1237     }
1238
1239     void B2DPolygon::setPrevControlPoint(sal_uInt32 nIndex, const B2DPoint& rValue)
1240     {
1241         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1242         const basegfx::B2DVector aNewVector(rValue - mpPolygon->getPoint(nIndex));
1243
1244         if(mpPolygon->getPrevControlVector(nIndex) != aNewVector)
1245         {
1246             mpPolygon->setPrevControlVector(nIndex, aNewVector);
1247         }
1248     }
1249
1250     void B2DPolygon::setNextControlPoint(sal_uInt32 nIndex, const B2DPoint& rValue)
1251     {
1252         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1253         const basegfx::B2DVector aNewVector(rValue - mpPolygon->getPoint(nIndex));
1254
1255         if(mpPolygon->getNextControlVector(nIndex) != aNewVector)
1256         {
1257             mpPolygon->setNextControlVector(nIndex, aNewVector);
1258         }
1259     }
1260
1261     void B2DPolygon::setControlPoints(sal_uInt32 nIndex, const basegfx::B2DPoint& rPrev, const basegfx::B2DPoint& rNext)
1262     {
1263         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1264         const B2DPoint aPoint(mpPolygon->getPoint(nIndex));
1265         const basegfx::B2DVector aNewPrev(rPrev - aPoint);
1266         const basegfx::B2DVector aNewNext(rNext - aPoint);
1267
1268         if(mpPolygon->getPrevControlVector(nIndex) != aNewPrev || mpPolygon->getNextControlVector(nIndex) != aNewNext)
1269         {
1270             mpPolygon->setControlVectors(nIndex, aNewPrev, aNewNext);
1271         }
1272     }
1273
1274     void B2DPolygon::resetPrevControlPoint(sal_uInt32 nIndex)
1275     {
1276         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1277
1278         if(mpPolygon->areControlPointsUsed() && !mpPolygon->getPrevControlVector(nIndex).equalZero())
1279         {
1280             mpPolygon->setPrevControlVector(nIndex, B2DVector::getEmptyVector());
1281         }
1282     }
1283
1284     void B2DPolygon::resetNextControlPoint(sal_uInt32 nIndex)
1285     {
1286         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1287
1288         if(mpPolygon->areControlPointsUsed() && !mpPolygon->getNextControlVector(nIndex).equalZero())
1289         {
1290             mpPolygon->setNextControlVector(nIndex, B2DVector::getEmptyVector());
1291         }
1292     }
1293
1294     void B2DPolygon::resetControlPoints(sal_uInt32 nIndex)
1295     {
1296         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1297
1298         if(mpPolygon->areControlPointsUsed() &&
1299             (!mpPolygon->getPrevControlVector(nIndex).equalZero() || !mpPolygon->getNextControlVector(nIndex).equalZero()))
1300         {
1301             mpPolygon->resetControlVectors(nIndex);
1302         }
1303     }
1304
1305     void B2DPolygon::resetControlPoints()
1306     {
1307         if(mpPolygon->areControlPointsUsed())
1308         {
1309             mpPolygon->resetControlVectors();
1310         }
1311     }
1312
1313     void B2DPolygon::appendBezierSegment(
1314         const B2DPoint& rNextControlPoint,
1315         const B2DPoint& rPrevControlPoint,
1316         const B2DPoint& rPoint)
1317     {
1318         const B2DVector aNewNextVector(mpPolygon->count() ? B2DVector(rNextControlPoint - mpPolygon->getPoint(mpPolygon->count() - 1)) : B2DVector::getEmptyVector());
1319         const B2DVector aNewPrevVector(rPrevControlPoint - rPoint);
1320
1321         if(aNewNextVector.equalZero() && aNewPrevVector.equalZero())
1322         {
1323             mpPolygon->insert(mpPolygon->count(), rPoint, 1);
1324         }
1325         else
1326         {
1327             mpPolygon->appendBezierSegment(aNewNextVector, aNewPrevVector, rPoint);
1328         }
1329     }
1330
1331     bool B2DPolygon::areControlPointsUsed() const
1332     {
1333         return mpPolygon->areControlPointsUsed();
1334     }
1335
1336     bool B2DPolygon::isPrevControlPointUsed(sal_uInt32 nIndex) const
1337     {
1338         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1339
1340         return (mpPolygon->areControlPointsUsed() && !mpPolygon->getPrevControlVector(nIndex).equalZero());
1341     }
1342
1343     bool B2DPolygon::isNextControlPointUsed(sal_uInt32 nIndex) const
1344     {
1345         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1346
1347         return (mpPolygon->areControlPointsUsed() && !mpPolygon->getNextControlVector(nIndex).equalZero());
1348     }
1349
1350     B2VectorContinuity B2DPolygon::getContinuityInPoint(sal_uInt32 nIndex) const
1351     {
1352         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1353
1354         if(mpPolygon->areControlPointsUsed())
1355         {
1356             const B2DVector& rPrev(mpPolygon->getPrevControlVector(nIndex));
1357             const B2DVector& rNext(mpPolygon->getNextControlVector(nIndex));
1358
1359             return getContinuity(rPrev, rNext);
1360         }
1361         else
1362         {
1363             return CONTINUITY_NONE;
1364         }
1365     }
1366
1367     bool B2DPolygon::isBezierSegment(sal_uInt32 nIndex) const
1368     {
1369         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1370
1371         if(mpPolygon->areControlPointsUsed())
1372         {
1373             // Check if the edge exists
1374             const bool bNextIndexValidWithoutClose(nIndex + 1 < mpPolygon->count());
1375
1376             if(bNextIndexValidWithoutClose || mpPolygon->isClosed())
1377             {
1378                 const sal_uInt32 nNextIndex(bNextIndexValidWithoutClose ? nIndex + 1 : 0);
1379                 return (!mpPolygon->getPrevControlVector(nNextIndex).equalZero()
1380                     || !mpPolygon->getNextControlVector(nIndex).equalZero());
1381             }
1382             else
1383             {
1384                 // no valid edge -> no bezier segment, even when local next
1385                 // vector may be used
1386                 return false;
1387             }
1388         }
1389         else
1390         {
1391             // no control points -> no bezier segment
1392             return false;
1393         }
1394     }
1395
1396     void B2DPolygon::getBezierSegment(sal_uInt32 nIndex, B2DCubicBezier& rTarget) const
1397     {
1398         OSL_ENSURE(nIndex < mpPolygon->count(), "B2DPolygon access outside range (!)");
1399         const bool bNextIndexValidWithoutClose(nIndex + 1 < mpPolygon->count());
1400
1401         if(bNextIndexValidWithoutClose || mpPolygon->isClosed())
1402         {
1403             const sal_uInt32 nNextIndex(bNextIndexValidWithoutClose ? nIndex + 1 : 0);
1404             rTarget.setStartPoint(mpPolygon->getPoint(nIndex));
1405             rTarget.setEndPoint(mpPolygon->getPoint(nNextIndex));
1406
1407             if(mpPolygon->areControlPointsUsed())
1408             {
1409                 rTarget.setControlPointA(rTarget.getStartPoint() + mpPolygon->getNextControlVector(nIndex));
1410                 rTarget.setControlPointB(rTarget.getEndPoint() + mpPolygon->getPrevControlVector(nNextIndex));
1411             }
1412             else
1413             {
1414                 // no bezier, reset control poins at rTarget
1415                 rTarget.setControlPointA(rTarget.getStartPoint());
1416                 rTarget.setControlPointB(rTarget.getEndPoint());
1417             }
1418         }
1419         else
1420         {
1421             // no valid edge at all, reset rTarget to current point
1422             const B2DPoint aPoint(mpPolygon->getPoint(nIndex));
1423             rTarget.setStartPoint(aPoint);
1424             rTarget.setEndPoint(aPoint);
1425             rTarget.setControlPointA(aPoint);
1426             rTarget.setControlPointB(aPoint);
1427         }
1428     }
1429
1430     B2DPolygon B2DPolygon::getDefaultAdaptiveSubdivision() const
1431     {
1432         return mpPolygon->getDefaultAdaptiveSubdivision(*this);
1433     }
1434
1435     B2DRange B2DPolygon::getB2DRange() const
1436     {
1437         return mpPolygon->getB2DRange(*this);
1438     }
1439
1440     void B2DPolygon::insert(sal_uInt32 nIndex, const B2DPolygon& rPoly, sal_uInt32 nIndex2, sal_uInt32 nCount)
1441     {
1442         OSL_ENSURE(nIndex <= mpPolygon->count(), "B2DPolygon Insert outside range (!)");
1443
1444         if(rPoly.count())
1445         {
1446             if(!nCount)
1447             {
1448                 nCount = rPoly.count();
1449             }
1450
1451             if(0 == nIndex2 && nCount == rPoly.count())
1452             {
1453                 mpPolygon->insert(nIndex, *rPoly.mpPolygon);
1454             }
1455             else
1456             {
1457                 OSL_ENSURE(nIndex2 + nCount <= rPoly.mpPolygon->count(), "B2DPolygon Insert outside range (!)");
1458                 ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex2, nCount);
1459                 mpPolygon->insert(nIndex, aTempPoly);
1460             }
1461         }
1462     }
1463
1464     void B2DPolygon::append(const B2DPolygon& rPoly, sal_uInt32 nIndex, sal_uInt32 nCount)
1465     {
1466         if(rPoly.count())
1467         {
1468             if(!nCount)
1469             {
1470                 nCount = rPoly.count();
1471             }
1472
1473             if(0 == nIndex && nCount == rPoly.count())
1474             {
1475                 mpPolygon->insert(mpPolygon->count(), *rPoly.mpPolygon);
1476             }
1477             else
1478             {
1479                 OSL_ENSURE(nIndex + nCount <= rPoly.mpPolygon->count(), "B2DPolygon Append outside range (!)");
1480                 ImplB2DPolygon aTempPoly(*rPoly.mpPolygon, nIndex, nCount);
1481                 mpPolygon->insert(mpPolygon->count(), aTempPoly);
1482             }
1483         }
1484     }
1485
1486     void B2DPolygon::remove(sal_uInt32 nIndex, sal_uInt32 nCount)
1487     {
1488         OSL_ENSURE(nIndex + nCount <= mpPolygon->count(), "B2DPolygon Remove outside range (!)");
1489
1490         if(nCount)
1491         {
1492             mpPolygon->remove(nIndex, nCount);
1493         }
1494     }
1495
1496     void B2DPolygon::clear()
1497     {
1498         mpPolygon = DefaultPolygon::get();
1499     }
1500
1501     bool B2DPolygon::isClosed() const
1502     {
1503         return mpPolygon->isClosed();
1504     }
1505
1506     void B2DPolygon::setClosed(bool bNew)
1507     {
1508         if(isClosed() != bNew)
1509         {
1510             mpPolygon->setClosed(bNew);
1511         }
1512     }
1513
1514     void B2DPolygon::flip()
1515     {
1516         if(count() > 1)
1517         {
1518             mpPolygon->flip();
1519         }
1520     }
1521
1522     bool B2DPolygon::hasDoublePoints() const
1523     {
1524         return (mpPolygon->count() > 1 && mpPolygon->hasDoublePoints());
1525     }
1526
1527     void B2DPolygon::removeDoublePoints()
1528     {
1529         if(hasDoublePoints())
1530         {
1531             mpPolygon->removeDoublePointsAtBeginEnd();
1532             mpPolygon->removeDoublePointsWholeTrack();
1533         }
1534     }
1535
1536     void B2DPolygon::transform(const B2DHomMatrix& rMatrix)
1537     {
1538         if(mpPolygon->count() && !rMatrix.isIdentity())
1539         {
1540             mpPolygon->transform(rMatrix);
1541         }
1542     }
1543 } // end of namespace basegfx
1544
1545 //////////////////////////////////////////////////////////////////////////////
1546 // eof