basegfx/source/polygon/b2dpolygon.cxx

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