tools/source/generic/poly2.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 #define POLY_CLIP_INT   0
  21 #define POLY_CLIP_UNION 1
  22 #define POLY_CLIP_DIFF  2
  23 #define POLY_CLIP_XOR   3
  24
  25 #include <rtl/math.hxx>
  26 #include <sal/log.hxx>
  27 #include <osl/diagnose.h>
  28 #include <poly.h>
  29 #include <tools/poly.hxx>
  30 #include <tools/debug.hxx>
  31 #include <tools/stream.hxx>
  32 #include <tools/vcompat.hxx>
  33 #include <tools/gen.hxx>
  34 #include <basegfx/polygon/b2dpolypolygon.hxx>
  35 #include <basegfx/polygon/b2dpolygon.hxx>
  36 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  37
  38 ImplPolyPolygon::ImplPolyPolygon( sal_uInt16 nInitSize )
  39 {
  40     mnRefCount  = 1;
  41     mnCount     = nInitSize;
  42     mnSize      = nInitSize;
  43     mnResize    = 16;
  44     mpPolyAry   = new SVPPOLYGON[ nInitSize ];
  45 }
  46
  47 ImplPolyPolygon::ImplPolyPolygon( const ImplPolyPolygon& rImplPolyPoly )
  48 {
  49     mnRefCount  = 1;
  50     mnCount     = rImplPolyPoly.mnCount;
  51     mnSize      = rImplPolyPoly.mnSize;
  52     mnResize    = rImplPolyPoly.mnResize;
  53
  54     if ( rImplPolyPoly.mpPolyAry )
  55     {
  56         mpPolyAry = new SVPPOLYGON[mnSize];
  57         for ( sal_uInt16 i = 0; i < mnCount; i++ )
  58             mpPolyAry[i] = new Polygon( *rImplPolyPoly.mpPolyAry[i] );
  59     }
  60     else
  61         mpPolyAry = NULL;
  62 }
  63
  64 ImplPolyPolygon::~ImplPolyPolygon()
  65 {
  66     if ( mpPolyAry )
  67     {
  68         for ( sal_uInt16 i = 0; i < mnCount; i++ )
  69             delete mpPolyAry[i];
  70         delete[] mpPolyAry;
  71     }
  72 }
  73
  74 namespace tools {
  75
  76 PolyPolygon::PolyPolygon( sal_uInt16 nInitSize, sal_uInt16 nResize )
  77 {
  78     if ( nInitSize > MAX_POLYGONS )
  79         nInitSize = MAX_POLYGONS;
  80     else if ( !nInitSize )
  81         nInitSize = 1;
  82     if ( nResize > MAX_POLYGONS )
  83         nResize = MAX_POLYGONS;
  84     else if ( !nResize )
  85         nResize = 1;
  86     mpImplPolyPolygon = new ImplPolyPolygon( nInitSize, nResize );
  87 }
  88
  89 PolyPolygon::PolyPolygon( const Polygon& rPoly )
  90 {
  91     if ( rPoly.GetSize() )
  92     {
  93         mpImplPolyPolygon = new ImplPolyPolygon( 1 );
  94         mpImplPolyPolygon->mpPolyAry[0] = new Polygon( rPoly );
  95     }
  96     else
  97         mpImplPolyPolygon = new ImplPolyPolygon( 16, 16 );
  98 }
  99
 100 PolyPolygon::PolyPolygon( const tools::PolyPolygon& rPolyPoly )
 101 {
 102     DBG_ASSERT( rPolyPoly.mpImplPolyPolygon->mnRefCount < 0xFFFFFFFE, "PolyPolygon: RefCount overflow" );
 103
 104     mpImplPolyPolygon = rPolyPoly.mpImplPolyPolygon;
 105     mpImplPolyPolygon->mnRefCount++;
 106 }
 107
 108 PolyPolygon::~PolyPolygon()
 109 {
 110     if ( mpImplPolyPolygon->mnRefCount > 1 )
 111         mpImplPolyPolygon->mnRefCount--;
 112     else
 113         delete mpImplPolyPolygon;
 114 }
 115
 116 void PolyPolygon::Insert( const Polygon& rPoly, sal_uInt16 nPos )
 117 {
 118     if ( mpImplPolyPolygon->mnCount >= MAX_POLYGONS )
 119         return;
 120
 121     if ( mpImplPolyPolygon->mnRefCount > 1 )
 122     {
 123         mpImplPolyPolygon->mnRefCount--;
 124         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 125     }
 126
 127     if ( nPos > mpImplPolyPolygon->mnCount )
 128         nPos = mpImplPolyPolygon->mnCount;
 129
 130     if ( !mpImplPolyPolygon->mpPolyAry )
 131         mpImplPolyPolygon->mpPolyAry = new SVPPOLYGON[mpImplPolyPolygon->mnSize];
 132     else if ( mpImplPolyPolygon->mnCount == mpImplPolyPolygon->mnSize )
 133     {
 134         sal_uInt16      nOldSize = mpImplPolyPolygon->mnSize;
 135         sal_uInt16      nNewSize = nOldSize + mpImplPolyPolygon->mnResize;
 136         SVPPOLYGON* pNewAry;
 137
 138         if ( nNewSize >= MAX_POLYGONS )
 139             nNewSize = MAX_POLYGONS;
 140         pNewAry = new SVPPOLYGON[nNewSize];
 141         memcpy( pNewAry, mpImplPolyPolygon->mpPolyAry, nPos*sizeof(SVPPOLYGON) );
 142         memcpy( pNewAry+nPos+1, mpImplPolyPolygon->mpPolyAry+nPos,
 143                 (nOldSize-nPos)*sizeof(SVPPOLYGON) );
 144         delete[] mpImplPolyPolygon->mpPolyAry;
 145         mpImplPolyPolygon->mpPolyAry = pNewAry;
 146         mpImplPolyPolygon->mnSize = nNewSize;
 147     }
 148     else if ( nPos < mpImplPolyPolygon->mnCount )
 149     {
 150         memmove( mpImplPolyPolygon->mpPolyAry+nPos+1,
 151                  mpImplPolyPolygon->mpPolyAry+nPos,
 152                  (mpImplPolyPolygon->mnCount-nPos)*sizeof(SVPPOLYGON) );
 153     }
 154
 155     mpImplPolyPolygon->mpPolyAry[nPos] = new Polygon( rPoly );
 156     mpImplPolyPolygon->mnCount++;
 157 }
 158
 159 void PolyPolygon::Remove( sal_uInt16 nPos )
 160 {
 161     assert(nPos < Count() && "PolyPolygon::Remove(): nPos >= nSize");
 162
 163     if ( mpImplPolyPolygon->mnRefCount > 1 )
 164     {
 165         mpImplPolyPolygon->mnRefCount--;
 166         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 167     }
 168
 169     delete mpImplPolyPolygon->mpPolyAry[nPos];
 170     mpImplPolyPolygon->mnCount--;
 171     memmove( mpImplPolyPolygon->mpPolyAry+nPos,
 172              mpImplPolyPolygon->mpPolyAry+nPos+1,
 173              (mpImplPolyPolygon->mnCount-nPos)*sizeof(SVPPOLYGON) );
 174 }
 175
 176 void PolyPolygon::Replace( const Polygon& rPoly, sal_uInt16 nPos )
 177 {
 178     assert(nPos < Count() && "PolyPolygon::Replace(): nPos >= nSize");
 179
 180     if ( mpImplPolyPolygon->mnRefCount > 1 )
 181     {
 182         mpImplPolyPolygon->mnRefCount--;
 183         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 184     }
 185
 186     delete mpImplPolyPolygon->mpPolyAry[nPos];
 187     mpImplPolyPolygon->mpPolyAry[nPos] = new Polygon( rPoly );
 188 }
 189
 190 const Polygon& PolyPolygon::GetObject( sal_uInt16 nPos ) const
 191 {
 192     assert(nPos < Count() && "PolyPolygon::GetObject(): nPos >= nSize");
 193
 194     return *(mpImplPolyPolygon->mpPolyAry[nPos]);
 195 }
 196
 197 bool PolyPolygon::IsRect() const
 198 {
 199     bool bIsRect = false;
 200     if ( Count() == 1 )
 201         bIsRect = mpImplPolyPolygon->mpPolyAry[ 0 ]->IsRect();
 202     return bIsRect;
 203 }
 204
 205 void PolyPolygon::Clear()
 206 {
 207     if ( mpImplPolyPolygon->mnRefCount > 1 )
 208     {
 209         mpImplPolyPolygon->mnRefCount--;
 210         mpImplPolyPolygon = new ImplPolyPolygon( mpImplPolyPolygon->mnResize,
 211                                                  mpImplPolyPolygon->mnResize );
 212     }
 213     else
 214     {
 215         if ( mpImplPolyPolygon->mpPolyAry )
 216         {
 217             for ( sal_uInt16 i = 0; i < mpImplPolyPolygon->mnCount; i++ )
 218                 delete mpImplPolyPolygon->mpPolyAry[i];
 219             delete[] mpImplPolyPolygon->mpPolyAry;
 220             mpImplPolyPolygon->mpPolyAry = NULL;
 221             mpImplPolyPolygon->mnCount   = 0;
 222             mpImplPolyPolygon->mnSize    = mpImplPolyPolygon->mnResize;
 223         }
 224     }
 225 }
 226
 227 void PolyPolygon::Optimize( PolyOptimizeFlags nOptimizeFlags, const PolyOptimizeData* pData )
 228 {
 229     if(bool(nOptimizeFlags) && Count())
 230     {
 231         // #115630# ImplDrawHatch does not work with beziers included in the polypolygon, take care of that
 232         bool bIsCurve(false);
 233
 234         for(sal_uInt16 a(0); !bIsCurve && a < Count(); a++)
 235         {
 236             if((*this)[a].HasFlags())
 237             {
 238                 bIsCurve = true;
 239             }
 240         }
 241
 242         if(bIsCurve)
 243         {
 244             OSL_ENSURE(false, "Optimize does *not* support curves, falling back to AdaptiveSubdivide()...");
 245             tools::PolyPolygon aPolyPoly;
 246
 247             AdaptiveSubdivide(aPolyPoly);
 248             aPolyPoly.Optimize(nOptimizeFlags, pData);
 249             *this = aPolyPoly;
 250         }
 251         else
 252         {
 253             double      fArea;
 254             const bool  bEdges = ( nOptimizeFlags & PolyOptimizeFlags::EDGES ) == PolyOptimizeFlags::EDGES;
 255             sal_uInt16      nPercent = 0;
 256
 257             if( bEdges )
 258             {
 259                 const Rectangle aBound( GetBoundRect() );
 260
 261                 fArea = ( aBound.GetWidth() + aBound.GetHeight() ) * 0.5;
 262                 nPercent = pData ? pData->GetPercentValue() : 50;
 263                 nOptimizeFlags &= ~PolyOptimizeFlags::EDGES;
 264             }
 265
 266             // watch for ref counter
 267             if( mpImplPolyPolygon->mnRefCount > 1 )
 268             {
 269                 mpImplPolyPolygon->mnRefCount--;
 270                 mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 271             }
 272
 273             // Optimize polygons
 274             for( sal_uInt16 i = 0, nPolyCount = mpImplPolyPolygon->mnCount; i < nPolyCount; i++ )
 275             {
 276                 if( bEdges )
 277                 {
 278                     mpImplPolyPolygon->mpPolyAry[ i ]->Optimize( PolyOptimizeFlags::NO_SAME );
 279                     Polygon::ImplReduceEdges( *( mpImplPolyPolygon->mpPolyAry[ i ] ), fArea, nPercent );
 280                 }
 281
 282                 if( bool(nOptimizeFlags) )
 283                     mpImplPolyPolygon->mpPolyAry[ i ]->Optimize( nOptimizeFlags, pData );
 284             }
 285         }
 286     }
 287 }
 288
 289 void PolyPolygon::AdaptiveSubdivide( tools::PolyPolygon& rResult, const double d ) const
 290 {
 291     rResult.Clear();
 292
 293     Polygon aPolygon;
 294
 295     for( sal_uInt16 i = 0; i < mpImplPolyPolygon->mnCount; i++ )
 296     {
 297         mpImplPolyPolygon->mpPolyAry[ i ]->AdaptiveSubdivide( aPolygon, d );
 298         rResult.Insert( aPolygon );
 299     }
 300 }
 301
 302 tools::PolyPolygon PolyPolygon::SubdivideBezier( const tools::PolyPolygon& rPolyPoly )
 303 {
 304     sal_uInt16 i, nPolys = rPolyPoly.Count();
 305     tools::PolyPolygon aPolyPoly( nPolys );
 306     for( i=0; i<nPolys; ++i )
 307         aPolyPoly.Insert( Polygon::SubdivideBezier( rPolyPoly.GetObject(i) ) );
 308
 309     return aPolyPoly;
 310 }
 311
 312
 313 void PolyPolygon::GetIntersection( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult ) const
 314 {
 315     ImplDoOperation( rPolyPoly, rResult, POLY_CLIP_INT );
 316 }
 317
 318 void PolyPolygon::GetUnion( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult ) const
 319 {
 320     ImplDoOperation( rPolyPoly, rResult, POLY_CLIP_UNION );
 321 }
 322
 323 void PolyPolygon::ImplDoOperation( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult, sal_uIntPtr nOperation ) const
 324 {
 325     // Convert to B2DPolyPolygon, temporarily. It might be
 326     // advantageous in the future, to have a tools::PolyPolygon adaptor that
 327     // just simulates a B2DPolyPolygon here...
 328     basegfx::B2DPolyPolygon aMergePolyPolygonA( getB2DPolyPolygon() );
 329     basegfx::B2DPolyPolygon aMergePolyPolygonB( rPolyPoly.getB2DPolyPolygon() );
 330
 331     // normalize the two polypolygons before. Force properly oriented
 332     // polygons.
 333     aMergePolyPolygonA = basegfx::tools::prepareForPolygonOperation( aMergePolyPolygonA );
 334     aMergePolyPolygonB = basegfx::tools::prepareForPolygonOperation( aMergePolyPolygonB );
 335
 336     switch( nOperation )
 337     {
 338         // All code extracted from svx/source/svdraw/svedtv2.cxx
 339
 340         case POLY_CLIP_UNION:
 341         {
 342             // merge A and B (OR)
 343             aMergePolyPolygonA = basegfx::tools::solvePolygonOperationOr(aMergePolyPolygonA, aMergePolyPolygonB);
 344             break;
 345         }
 346
 347         case POLY_CLIP_DIFF:
 348         {
 349             // subtract B from A (DIFF)
 350             aMergePolyPolygonA = basegfx::tools::solvePolygonOperationDiff(aMergePolyPolygonA, aMergePolyPolygonB);
 351             break;
 352         }
 353
 354         case POLY_CLIP_XOR:
 355         {
 356             // compute XOR between poly A and B
 357             aMergePolyPolygonA = basegfx::tools::solvePolygonOperationXor(aMergePolyPolygonA, aMergePolyPolygonB);
 358             break;
 359         }
 360
 361         default:
 362         case POLY_CLIP_INT:
 363         {
 364             // cut poly 1 against polys 2..n (AND)
 365             aMergePolyPolygonA = basegfx::tools::solvePolygonOperationAnd(aMergePolyPolygonA, aMergePolyPolygonB);
 366             break;
 367         }
 368     }
 369
 370     rResult = tools::PolyPolygon( aMergePolyPolygonA );
 371 }
 372
 373 sal_uInt16 PolyPolygon::Count() const
 374 {
 375     return mpImplPolyPolygon->mnCount;
 376 }
 377
 378 void PolyPolygon::Move( long nHorzMove, long nVertMove )
 379 {
 380     // Required for DrawEngine
 381     if( nHorzMove || nVertMove )
 382     {
 383         if ( mpImplPolyPolygon->mnRefCount > 1 )
 384         {
 385             mpImplPolyPolygon->mnRefCount--;
 386             mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 387         }
 388
 389         // move points
 390         sal_uInt16 nPolyCount = mpImplPolyPolygon->mnCount;
 391         for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
 392             mpImplPolyPolygon->mpPolyAry[i]->Move( nHorzMove, nVertMove );
 393     }
 394 }
 395
 396 void PolyPolygon::Translate( const Point& rTrans )
 397 {
 398     if( mpImplPolyPolygon->mnRefCount > 1 )
 399     {
 400         mpImplPolyPolygon->mnRefCount--;
 401         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 402     }
 403
 404     // move points
 405     for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
 406         mpImplPolyPolygon->mpPolyAry[ i ]->Translate( rTrans );
 407 }
 408
 409 void PolyPolygon::Scale( double fScaleX, double fScaleY )
 410 {
 411     if( mpImplPolyPolygon->mnRefCount > 1 )
 412     {
 413         mpImplPolyPolygon->mnRefCount--;
 414         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 415     }
 416
 417     // Move points
 418     for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
 419         mpImplPolyPolygon->mpPolyAry[ i ]->Scale( fScaleX, fScaleY );
 420 }
 421
 422 void PolyPolygon::Rotate( const Point& rCenter, sal_uInt16 nAngle10 )
 423 {
 424     nAngle10 %= 3600;
 425
 426     if( nAngle10 )
 427     {
 428         const double fAngle = F_PI1800 * nAngle10;
 429         Rotate( rCenter, sin( fAngle ), cos( fAngle ) );
 430     }
 431 }
 432
 433 void PolyPolygon::Rotate( const Point& rCenter, double fSin, double fCos )
 434 {
 435     if( mpImplPolyPolygon->mnRefCount > 1 )
 436     {
 437         mpImplPolyPolygon->mnRefCount--;
 438         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 439     }
 440
 441     // move points
 442     for ( sal_uInt16 i = 0, nCount = mpImplPolyPolygon->mnCount; i < nCount; i++ )
 443         mpImplPolyPolygon->mpPolyAry[ i ]->Rotate( rCenter, fSin, fCos );
 444 }
 445
 446 void PolyPolygon::Clip( const Rectangle& rRect )
 447 {
 448     sal_uInt16 nPolyCount = mpImplPolyPolygon->mnCount;
 449     sal_uInt16 i;
 450
 451     if ( !nPolyCount )
 452         return;
 453
 454     if ( mpImplPolyPolygon->mnRefCount > 1 )
 455     {
 456         mpImplPolyPolygon->mnRefCount--;
 457         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 458     }
 459
 460     // Clip every polygon, deleting the empty ones
 461     for ( i = 0; i < nPolyCount; i++ )
 462         mpImplPolyPolygon->mpPolyAry[i]->Clip( rRect );
 463     while ( nPolyCount )
 464     {
 465         if ( GetObject( nPolyCount-1 ).GetSize() <= 2 )
 466             Remove( nPolyCount-1 );
 467         nPolyCount--;
 468     }
 469 }
 470
 471 Rectangle PolyPolygon::GetBoundRect() const
 472 {
 473     long    nXMin=0, nXMax=0, nYMin=0, nYMax=0;
 474     bool    bFirst = true;
 475     sal_uInt16  nPolyCount = mpImplPolyPolygon->mnCount;
 476
 477     for ( sal_uInt16 n = 0; n < nPolyCount; n++ )
 478     {
 479         const Polygon*  pPoly = mpImplPolyPolygon->mpPolyAry[n];
 480         const Point*    pAry = pPoly->GetConstPointAry();
 481         sal_uInt16          nPointCount = pPoly->GetSize();
 482
 483         for ( sal_uInt16 i = 0; i < nPointCount; i++ )
 484         {
 485             const Point* pPt = &pAry[ i ];
 486
 487             if ( bFirst )
 488             {
 489                 nXMin = nXMax = pPt->X();
 490                 nYMin = nYMax = pPt->Y();
 491                 bFirst = false;
 492             }
 493             else
 494             {
 495                 if ( pPt->X() < nXMin )
 496                     nXMin = pPt->X();
 497                 if ( pPt->X() > nXMax )
 498                     nXMax = pPt->X();
 499                 if ( pPt->Y() < nYMin )
 500                     nYMin = pPt->Y();
 501                 if ( pPt->Y() > nYMax )
 502                     nYMax = pPt->Y();
 503             }
 504         }
 505     }
 506
 507     if ( !bFirst )
 508         return Rectangle( nXMin, nYMin, nXMax, nYMax );
 509     else
 510         return Rectangle();
 511 }
 512
 513 Polygon& PolyPolygon::operator[]( sal_uInt16 nPos )
 514 {
 515     assert(nPos < Count() && "PolyPolygon::[](): nPos >= nSize");
 516
 517     if ( mpImplPolyPolygon->mnRefCount > 1 )
 518     {
 519         mpImplPolyPolygon->mnRefCount--;
 520         mpImplPolyPolygon = new ImplPolyPolygon( *mpImplPolyPolygon );
 521     }
 522
 523     return *(mpImplPolyPolygon->mpPolyAry[nPos]);
 524 }
 525
 526 PolyPolygon& PolyPolygon::operator=( const tools::PolyPolygon& rPolyPoly )
 527 {
 528     if (this == &rPolyPoly)
 529         return *this;
 530
 531     DBG_ASSERT( rPolyPoly.mpImplPolyPolygon->mnRefCount < 0xFFFFFFFE, "PolyPolygon: RefCount overflow" );
 532
 533     rPolyPoly.mpImplPolyPolygon->mnRefCount++;
 534
 535     if ( mpImplPolyPolygon->mnRefCount > 1 )
 536         mpImplPolyPolygon->mnRefCount--;
 537     else
 538         delete mpImplPolyPolygon;
 539
 540     mpImplPolyPolygon = rPolyPoly.mpImplPolyPolygon;
 541     return *this;
 542 }
 543
 544 bool PolyPolygon::operator==( const tools::PolyPolygon& rPolyPoly ) const
 545 {
 546     if ( rPolyPoly.mpImplPolyPolygon == mpImplPolyPolygon )
 547         return true;
 548     else
 549         return false;
 550 }
 551
 552 bool PolyPolygon::IsEqual( const tools::PolyPolygon& rPolyPoly ) const
 553 {
 554     bool bIsEqual = true;
 555     if ( Count() != rPolyPoly.Count() )
 556         bIsEqual = false;
 557     else
 558     {
 559         sal_uInt16 i;
 560         for ( i = 0; i < Count(); i++ )
 561         {
 562             if (!GetObject( i ).IsEqual( rPolyPoly.GetObject( i ) ) )
 563             {
 564                 bIsEqual = false;
 565                 break;
 566             }
 567         }
 568     }
 569     return bIsEqual;
 570 }
 571
 572 SvStream& ReadPolyPolygon( SvStream& rIStream, tools::PolyPolygon& rPolyPoly )
 573 {
 574     DBG_ASSERTWARNING( rIStream.GetVersion(), "PolyPolygon::>> - Solar-Version not set on rIStream" );
 575
 576     Polygon* pPoly;
 577     sal_uInt16 nPolyCount(0);
 578
 579     // Read number of polygons
 580     rIStream.ReadUInt16( nPolyCount );
 581
 582     const size_t nMinRecordSize = sizeof(sal_uInt16);
 583     const size_t nMaxRecords = rIStream.remainingSize() / nMinRecordSize;
 584     if (nPolyCount > nMaxRecords)
 585     {
 586         SAL_WARN("tools", "Parsing error: " << nMaxRecords <<
 587                  " max possible entries, but " << nPolyCount << " claimed, truncating");
 588         nPolyCount = nMaxRecords;
 589     }
 590
 591     if( nPolyCount )
 592     {
 593         if ( rPolyPoly.mpImplPolyPolygon->mnRefCount > 1 )
 594             rPolyPoly.mpImplPolyPolygon->mnRefCount--;
 595         else
 596             delete rPolyPoly.mpImplPolyPolygon;
 597
 598         rPolyPoly.mpImplPolyPolygon = new ImplPolyPolygon( nPolyCount );
 599
 600         for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
 601         {
 602             pPoly = new Polygon;
 603             ReadPolygon( rIStream, *pPoly );
 604             rPolyPoly.mpImplPolyPolygon->mpPolyAry[i] = pPoly;
 605         }
 606     }
 607     else
 608         rPolyPoly = tools::PolyPolygon();
 609
 610     return rIStream;
 611 }
 612
 613 SvStream& WritePolyPolygon( SvStream& rOStream, const tools::PolyPolygon& rPolyPoly )
 614 {
 615     DBG_ASSERTWARNING( rOStream.GetVersion(), "PolyPolygon::<< - Solar-Version not set on rOStream" );
 616
 617     // Write number of polygons
 618     sal_uInt16 nPolyCount = rPolyPoly.mpImplPolyPolygon->mnCount;
 619     rOStream.WriteUInt16( nPolyCount );
 620
 621     // output polygons
 622     for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
 623         WritePolygon( rOStream, *(rPolyPoly.mpImplPolyPolygon->mpPolyAry[i]) );
 624
 625     return rOStream;
 626 }
 627
 628 void PolyPolygon::Read( SvStream& rIStream )
 629 {
 630     VersionCompat aCompat( rIStream, StreamMode::READ );
 631
 632     DBG_ASSERTWARNING( rIStream.GetVersion(), "PolyPolygon::>> - Solar-Version not set on rIStream" );
 633
 634     Polygon* pPoly;
 635     sal_uInt16 nPolyCount(0);
 636
 637     // Read number of polygons
 638     rIStream.ReadUInt16( nPolyCount );
 639
 640     const size_t nMinRecordSize = sizeof(sal_uInt16);
 641     const size_t nMaxRecords = rIStream.remainingSize() / nMinRecordSize;
 642     if (nPolyCount > nMaxRecords)
 643     {
 644         SAL_WARN("tools", "Parsing error: " << nMaxRecords <<
 645                  " max possible entries, but " << nPolyCount << " claimed, truncating");
 646         nPolyCount = nMaxRecords;
 647     }
 648
 649     if( nPolyCount )
 650     {
 651         if ( mpImplPolyPolygon->mnRefCount > 1 )
 652             mpImplPolyPolygon->mnRefCount--;
 653         else
 654             delete mpImplPolyPolygon;
 655
 656         mpImplPolyPolygon = new ImplPolyPolygon( nPolyCount );
 657
 658         for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
 659         {
 660             pPoly = new Polygon;
 661             pPoly->ImplRead( rIStream );
 662             mpImplPolyPolygon->mpPolyAry[i] = pPoly;
 663         }
 664     }
 665     else
 666         *this = tools::PolyPolygon();
 667 }
 668
 669 void PolyPolygon::Write( SvStream& rOStream ) const
 670 {
 671     VersionCompat aCompat( rOStream, StreamMode::WRITE, 1 );
 672
 673     DBG_ASSERTWARNING( rOStream.GetVersion(), "PolyPolygon::<< - Solar-Version not set on rOStream" );
 674
 675     // Write number of polygons
 676     sal_uInt16 nPolyCount = mpImplPolyPolygon->mnCount;
 677     rOStream.WriteUInt16( nPolyCount );
 678
 679     // Output polygons
 680     for ( sal_uInt16 i = 0; i < nPolyCount; i++ )
 681         mpImplPolyPolygon->mpPolyAry[i]->ImplWrite( rOStream );
 682 }
 683
 684 // convert to basegfx::B2DPolyPolygon and return
 685 basegfx::B2DPolyPolygon PolyPolygon::getB2DPolyPolygon() const
 686 {
 687     basegfx::B2DPolyPolygon aRetval;
 688
 689     for(sal_uInt16 a(0); a < mpImplPolyPolygon->mnCount; a++)
 690     {
 691         Polygon* pCandidate = mpImplPolyPolygon->mpPolyAry[a];
 692         aRetval.append(pCandidate->getB2DPolygon());
 693     }
 694
 695     return aRetval;
 696 }
 697
 698 // constructor to convert from basegfx::B2DPolyPolygon
 699 PolyPolygon::PolyPolygon(const basegfx::B2DPolyPolygon& rPolyPolygon)
 700 {
 701     const sal_uInt16 nCount(sal_uInt16(rPolyPolygon.count()));
 702     DBG_ASSERT(sal_uInt32(nCount) == rPolyPolygon.count(),
 703         "PolyPolygon::PolyPolygon: Too many sub-polygons in given basegfx::B2DPolyPolygon (!)");
 704
 705     if ( nCount )
 706     {
 707         mpImplPolyPolygon = new ImplPolyPolygon( nCount );
 708
 709         for(sal_uInt16 a(0); a < nCount; a++)
 710         {
 711             basegfx::B2DPolygon aCandidate(rPolyPolygon.getB2DPolygon(sal_uInt32(a)));
 712             mpImplPolyPolygon->mpPolyAry[a] = new Polygon( aCandidate );
 713         }
 714     }
 715     else
 716     {
 717         mpImplPolyPolygon = new ImplPolyPolygon( 16, 16 );
 718     }
 719 }
 720
 721 } /* namespace tools */
 722
 723 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */