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