LCOV - code coverage report
Current view: top level - tools/source/generic - poly2.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 328 0.0 %
Date: 2014-04-14 Functions: 0 36 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10