basegfx/source/inc/polygontemplate.hxx

   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: polygontemplate.hxx,v $
  10  * $Revision: 1.8 $
  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 #ifndef _POLYGON_TEMPLATE_HXX
  32 #define _POLYGON_TEMPLATE_HXX
  33
  34 #include <vector>
  35
  36 //////////////////////////////////////////////////////////////////////////////
  37
  38 template < class Point > class ImplSimplePointEntry
  39 {
  40     Point                                                                                       maPoint;
  41
  42 public:
  43     ImplSimplePointEntry()
  44     :   maPoint(Point::getEmptyPoint())
  45     {
  46     }
  47
  48     ImplSimplePointEntry(const Point& rInitPoint)
  49     :   maPoint(rInitPoint)
  50     {
  51     }
  52
  53     const Point& getPoint() const
  54     {
  55         return maPoint;
  56     }
  57
  58     void setPoint(const Point& rValue)
  59     {
  60         maPoint = rValue;
  61     }
  62
  63     bool operator==(const ImplSimplePointEntry& rEntry) const
  64     {
  65         return (maPoint == rEntry.maPoint);
  66     }
  67 };
  68
  69 //////////////////////////////////////////////////////////////////////////////
  70
  71 template < class Vector > class ImplSimpleBezierEntry
  72 {
  73     Vector                                                                                      maBackward;
  74     Vector                                                                                      maForward;
  75
  76 public:
  77     ImplSimpleBezierEntry()
  78     :   maBackward(Vector::getEmptyVector()),
  79         maForward(Vector::getEmptyVector())
  80     {
  81     }
  82
  83     ImplSimpleBezierEntry(const Vector& rInitBackward, const Vector& rInitForward)
  84     :   maBackward(rInitBackward),
  85         maForward(rInitForward)
  86     {
  87     }
  88
  89     const Vector& getBackwardVector() const
  90     {
  91         return maBackward;
  92     }
  93
  94     void setBackwardVector(const Vector& rValue)
  95     {
  96         maBackward = rValue;
  97     }
  98
  99     const Vector& getForwardVector() const
 100     {
 101         return maForward;
 102     }
 103
 104     void setForwardVector(const Vector& rValue)
 105     {
 106         maForward = rValue;
 107     }
 108
 109     bool isBezierNeeded()
 110     {
 111         if(!maBackward.equalZero() || !maForward.equalZero())
 112             return true;
 113         return false;
 114     }
 115
 116     bool operator==(const ImplSimpleBezierEntry& rEntry) const
 117     {
 118         return ((maBackward == rEntry.maBackward) && (maForward == rEntry.maForward));
 119     }
 120
 121     void doInvertForFlip()
 122     {
 123         maBackward = -maBackward;
 124         maForward = -maForward;
 125     }
 126 };
 127
 128 //////////////////////////////////////////////////////////////////////////////
 129
 130 template < class Point, class Vector > class ImplPolygonTemplate
 131 {
 132     typedef ImplSimplePointEntry< Point > LocalImplSimplePointEntry;
 133     typedef ImplSimpleBezierEntry< Vector > LocalImplSimpleBezierEntry;
 134     typedef ::std::vector< LocalImplSimplePointEntry > SimplePointVector;
 135     typedef ::std::vector< LocalImplSimpleBezierEntry > SimpleBezierVector;
 136
 137     sal_uInt32                                                                          mnBezierCount;
 138     SimplePointVector                                                           maPoints;
 139     SimpleBezierVector*                                                         mpVectors;
 140
 141     unsigned                                                                            mbIsClosed : 1;
 142
 143     void implTryToReduceToPointVector()
 144     {
 145         if(!mnBezierCount && mpVectors)
 146         {
 147             delete mpVectors;
 148             mpVectors = 0L;
 149         }
 150     }
 151
 152 public:
 153     bool isBezier() const
 154     {
 155         return bool(mnBezierCount);
 156     }
 157
 158     bool isClosed() const
 159     {
 160         return bool(mbIsClosed);
 161     }
 162
 163     void setClosed(bool bNew)
 164     {
 165         mbIsClosed = bNew;
 166     }
 167
 168     sal_uInt32 count() const
 169     {
 170         return maPoints.size();
 171     }
 172
 173     ImplPolygonTemplate()
 174     :   mnBezierCount(0L),
 175         mpVectors(0L),
 176         mbIsClosed(false)
 177     {
 178         // complete initialization with defaults
 179     }
 180
 181     ImplPolygonTemplate(const ImplPolygonTemplate& rSource)
 182     :   mnBezierCount(0L),
 183         maPoints(rSource.maPoints),
 184         mpVectors(0L),
 185         mbIsClosed(rSource.mbIsClosed)
 186     {
 187         // complete initialization using copy
 188         if(rSource.mpVectors && rSource.mnBezierCount)
 189         {
 190             mpVectors = new SimpleBezierVector(*rSource.mpVectors);
 191             mnBezierCount = rSource.mnBezierCount;
 192         }
 193     }
 194
 195     ImplPolygonTemplate(const ImplPolygonTemplate& rSource, sal_uInt32 nIndex, sal_uInt32 nCount)
 196     :   mnBezierCount(0L),
 197         maPoints(nCount),
 198         mpVectors(0L),
 199         mbIsClosed(rSource.mbIsClosed)
 200     {
 201         // complete initialization using partly copy
 202         if(nCount)
 203         {
 204             // copy point data
 205             {
 206                 SimplePointVector::const_iterator aStart(rSource.maPoints.begin());
 207                 aStart += nIndex;
 208                 SimplePointVector::const_iterator aEnd(aStart);
 209                 aEnd += nCount;
 210                 maPoints.insert(0L, aStart, aEnd);
 211             }
 212
 213             // copy bezier data
 214             if(rSource.mpVectors && rSource.mnBezierCount)
 215             {
 216                 mpVectors = new SimpleBezierVector();
 217                 mpVectors->reserve(nCount);
 218
 219                 SimpleBezierVector::iterator aStart(mpVectors->begin());
 220                 aStart += nIndex;
 221                 SimpleBezierVector::iterator aEnd(aStart);
 222                 aEnd += nCount;
 223
 224                 for( ; aStart != aEnd; ++aStart )
 225                 {
 226                     if(aStart->isBezierNeeded())
 227                     {
 228                         mnBezierCount++;
 229                     }
 230
 231                     mpVectors->push_back(*aStart);
 232                 }
 233
 234                 // maybe vectors are not needed anymore, try to reduce memory footprint
 235                 implTryToReduceToPointVector();
 236             }
 237         }
 238     }
 239
 240     ~ImplPolygonTemplate()
 241     {
 242         if(mpVectors)
 243         {
 244             delete mpVectors;
 245         }
 246     }
 247
 248     bool isEqual(const ImplPolygonTemplate& rPointList) const
 249     {
 250         // same point count?
 251         if(maPoints.size() != rPointList.maPoints.size())
 252             return false;
 253
 254         // if zero points the polys are equal
 255         if(!maPoints.size())
 256             return true;
 257
 258         // if bezier count used it needs to be equal
 259         if(mnBezierCount != rPointList.mnBezierCount)
 260             return false;
 261
 262         // compare point content
 263         if(maPoints != rPointList.maPoints)
 264             return false;
 265
 266         // beziercounts are equal: if it's zero, we are done
 267         if(!mnBezierCount)
 268             return true;
 269
 270         // beziercounts are equal and not zero; compare them
 271         OSL_ENSURE(0L != mpVectors, "Error: Bezier list needs to exist here(!)");
 272         OSL_ENSURE(0L != rPointList.mpVectors, "Error: Bezier list needs to exist here(!)");
 273
 274         return (*mpVectors == *rPointList.mpVectors);
 275     }
 276
 277     const Point& getPoint(sal_uInt32 nIndex) const
 278     {
 279         return maPoints[nIndex].getPoint();
 280     }
 281
 282     void setPoint(sal_uInt32 nIndex, const Point& rValue)
 283     {
 284         maPoints[nIndex].setPoint(rValue);
 285     }
 286
 287     const Vector& getBackwardVector(sal_uInt32 nIndex) const
 288     {
 289         if(mpVectors)
 290             return ((*mpVectors)[nIndex]).getBackwardVector();
 291         else
 292             return Vector::getEmptyVector();
 293     }
 294
 295     void setBackwardVector(sal_uInt32 nIndex, const Vector& rValue)
 296     {
 297         if(mpVectors)
 298         {
 299             LocalImplSimpleBezierEntry& rDest = (*mpVectors)[nIndex];
 300             bool bBezierNeededBefore(rDest.isBezierNeeded());
 301             ((*mpVectors)[nIndex]).setBackwardVector(rValue);
 302             bool bBezierNeededAfter(rDest.isBezierNeeded());
 303
 304             if(bBezierNeededBefore != bBezierNeededAfter)
 305             {
 306                 if(bBezierNeededAfter)
 307                     mnBezierCount++;
 308                 else
 309                     mnBezierCount--;
 310             }
 311         }
 312         else
 313         {
 314             bool bEmptyVector(rValue.equalZero());
 315
 316             if(bEmptyVector)
 317                 return;
 318
 319             mpVectors = new SimpleBezierVector(maPoints.size());
 320             ((*mpVectors)[nIndex]).setBackwardVector(rValue);
 321             mnBezierCount++;
 322         }
 323     }
 324
 325     const Vector& getForwardVector(sal_uInt32 nIndex) const
 326     {
 327         if(mpVectors)
 328             return ((*mpVectors)[nIndex]).getForwardVector();
 329         else
 330             return Vector::getEmptyVector();
 331     }
 332
 333     void setForwardVector(sal_uInt32 nIndex, const Vector& rValue)
 334     {
 335         if(mpVectors)
 336         {
 337             LocalImplSimpleBezierEntry& rDest = (*mpVectors)[nIndex];
 338             bool bBezierNeededBefore(rDest.isBezierNeeded());
 339             ((*mpVectors)[nIndex]).setForwardVector(rValue);
 340             bool bBezierNeededAfter(rDest.isBezierNeeded());
 341
 342             if(bBezierNeededBefore != bBezierNeededAfter)
 343             {
 344                 if(bBezierNeededAfter)
 345                     mnBezierCount++;
 346                 else
 347                     mnBezierCount--;
 348             }
 349         }
 350         else
 351         {
 352             bool bEmptyVector(rValue.equalZero());
 353
 354             if(bEmptyVector)
 355                 return;
 356
 357             mpVectors = new SimpleBezierVector(maPoints.size());
 358             ((*mpVectors)[nIndex]).setForwardVector(rValue);
 359             mnBezierCount++;
 360         }
 361     }
 362
 363     void insert(sal_uInt32 nIndex, const Point& rPoint, sal_uInt32 nCount)
 364     {
 365         if(nCount)
 366         {
 367             // maybe vectors are not needed anymore, try to reduce memory footprint
 368             implTryToReduceToPointVector();
 369
 370             // add nCount copies of rPoint
 371             {
 372                 LocalImplSimplePointEntry aNode(rPoint);
 373                 SimplePointVector::iterator aIndex(maPoints.begin());
 374                 aIndex += nIndex;
 375                 maPoints.insert(aIndex, nCount, aNode);
 376             }
 377
 378             // add nCount empty entries to keep indices synchronized
 379             if(mpVectors)
 380             {
 381                 LocalImplSimpleBezierEntry aNode;
 382                 SimpleBezierVector::iterator aIndex(mpVectors->begin());
 383                 aIndex += nIndex;
 384                 mpVectors->insert(aIndex, nCount, aNode);
 385             }
 386         }
 387     }
 388
 389     void insert(sal_uInt32 nIndex, const ImplPolygonTemplate& rSource)
 390     {
 391         const sal_uInt32 nCount(rSource.maPoints.size());
 392
 393         if(nCount)
 394         {
 395             // instert point data
 396             {
 397                 SimplePointVector::iterator aIndex(maPoints.begin());
 398                 aIndex += nIndex;
 399
 400                 SimplePointVector::const_iterator aStart(rSource.maPoints.begin());
 401                 SimplePointVector::const_iterator aEnd(rSource.maPoints.end());
 402
 403                 maPoints.insert(aIndex, aStart, aEnd);
 404             }
 405
 406             // insert bezier data
 407             if(rSource.mpVectors && rSource.mnBezierCount)
 408             {
 409                 SimpleBezierVector::iterator aIndex(mpVectors->begin());
 410                 aIndex += nIndex;
 411
 412                 SimpleBezierVector::iterator aStart(rSource.mpVectors->begin());
 413                 SimpleBezierVector::iterator aEnd(rSource.mpVectors->end());
 414
 415                 if(!mpVectors)
 416                 {
 417                     mpVectors = new SimpleBezierVector(maPoints.size() - nCount);
 418                 }
 419
 420                 mpVectors->insert(aIndex, aStart, aEnd);
 421
 422                 mnBezierCount += rSource.mnBezierCount;
 423             }
 424             else
 425             {
 426                 // maybe vectors are not needed anymore, try to reduce memory footprint
 427                 implTryToReduceToPointVector();
 428
 429                 // add nCount empty entries to keep indices synchronized
 430                 if(mpVectors)
 431                 {
 432                     LocalImplSimpleBezierEntry aNode;
 433                     SimpleBezierVector::iterator aIndex(mpVectors->begin());
 434                     aIndex += nIndex;
 435                     mpVectors->insert(aIndex, nCount, aNode);
 436                 }
 437             }
 438         }
 439     }
 440
 441     void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
 442     {
 443         if(nCount)
 444         {
 445             // maybe vectors are not needed anymore, try to reduce memory footprint
 446             implTryToReduceToPointVector();
 447
 448             // remove point data
 449             {
 450                 SimplePointVector::iterator aStart(maPoints.begin());
 451                 aStart += nIndex;
 452                 const SimplePointVector::iterator aEnd(aStart + nCount);
 453
 454                 maPoints.erase(aStart, aEnd);
 455             }
 456
 457             // remove bezier data
 458             if(mpVectors)
 459             {
 460                 SimpleBezierVector::iterator aStart(mpVectors->begin());
 461                 aStart += nIndex;
 462                 const SimpleBezierVector::iterator aEnd(aStart + nCount);
 463
 464                 // take care for correct mnBezierCount BEFORE erase
 465                 if(mnBezierCount)
 466                 {
 467                     SimpleBezierVector::iterator aTestIter(aStart);
 468
 469                     for( ; mnBezierCount && aTestIter != aEnd; ++aTestIter)
 470                     {
 471                         if(aTestIter->isBezierNeeded())
 472                             mnBezierCount--;
 473                     }
 474                 }
 475
 476                 if(mnBezierCount)
 477                 {
 478                     // erase nodes
 479                     mpVectors->erase(aStart, aEnd);
 480                 }
 481                 else
 482                 {
 483                     // try to reduce, maybe 0L == mnBezierCount
 484                     implTryToReduceToPointVector();
 485                 }
 486             }
 487         }
 488     }
 489
 490     void flip()
 491     {
 492         if(maPoints.size() > 1)
 493         {
 494             // maybe vectors are not needed anymore, try to reduce memory footprint
 495             implTryToReduceToPointVector();
 496
 497             // calculate half size
 498             const sal_uInt32 nHalfSize(maPoints.size() >> 1L);
 499
 500             // flip point data
 501             {
 502                 SimplePointVector::iterator aStart(maPoints.begin());
 503                 SimplePointVector::iterator aEnd(maPoints.end());
 504
 505                 for(sal_uInt32 a(0); a < nHalfSize; a++)
 506                 {
 507                     LocalImplSimplePointEntry aTemp = *aStart;
 508                     *aStart++ = *aEnd;
 509                     *aEnd-- = aTemp;
 510                 }
 511             }
 512
 513             // flip bezier data
 514             if(mpVectors)
 515             {
 516                 SimpleBezierVector::iterator aStart(mpVectors->begin());
 517                 SimpleBezierVector::iterator aEnd(mpVectors->end());
 518
 519                 for(sal_uInt32 a(0); a < nHalfSize; a++)
 520                 {
 521                     LocalImplSimpleBezierEntry aTemp = *aStart;
 522                     aTemp.doInvertForFlip();
 523                     *aStart = *aEnd;
 524                     aStart->doInvertForFlip();
 525                     aStart++;
 526                     *aEnd-- = aTemp;
 527                 }
 528
 529                 // also flip vectors of middle point (if existing)
 530                 if(maPoints.size() % 2)
 531                 {
 532                     (*mpVectors)[nHalfSize].doInvertForFlip();
 533                 }
 534             }
 535         }
 536     }
 537 };
 538
 539 //////////////////////////////////////////////////////////////////////////////
 540
 541 #endif _POLYGON_TEMPLATE_HXX