LCOV - code coverage report
Current view: top level - vcl/source/gdi - regionband.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 488 0.0 %
Date: 2014-04-14 Functions: 0 33 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             : #include <tools/stream.hxx>
      21             : #include <tools/debug.hxx>
      22             : #include <regionband.hxx>
      23             : 
      24           0 : RegionBand::RegionBand()
      25             : :   mpFirstBand(0),
      26           0 :     mpLastCheckedBand(0)
      27             : {
      28           0 : }
      29             : 
      30           0 : RegionBand::RegionBand(const RegionBand& rRef)
      31             : :   mpFirstBand(0),
      32           0 :     mpLastCheckedBand(0)
      33             : {
      34           0 :     *this = rRef;
      35           0 : }
      36             : 
      37           0 : RegionBand& RegionBand::operator=(const RegionBand& rRef)
      38             : {
      39           0 :     ImplRegionBand* pPrevBand = 0;
      40           0 :     ImplRegionBand* pBand = rRef.mpFirstBand;
      41             : 
      42           0 :     while(pBand)
      43             :     {
      44           0 :         ImplRegionBand* pNewBand = new ImplRegionBand(*pBand);
      45             : 
      46             :         // first element? -> set as first into the list
      47           0 :         if(pBand == rRef.mpFirstBand)
      48             :         {
      49           0 :             mpFirstBand = pNewBand;
      50             :         }
      51             :         else
      52             :         {
      53           0 :             pPrevBand->mpNextBand = pNewBand;
      54             :         }
      55             : 
      56           0 :         pPrevBand = pNewBand;
      57           0 :         pBand = pBand->mpNextBand;
      58             :     }
      59             : 
      60           0 :     return *this;
      61             : }
      62             : 
      63           0 : RegionBand::RegionBand(const Rectangle& rRect)
      64             : :   mpFirstBand(0),
      65           0 :     mpLastCheckedBand(0)
      66             : {
      67           0 :     const long nTop(std::min(rRect.Top(), rRect.Bottom()));
      68           0 :     const long nBottom(std::max(rRect.Top(), rRect.Bottom()));
      69           0 :     const long nLeft(std::min(rRect.Left(), rRect.Right()));
      70           0 :     const long nRight(std::max(rRect.Left(), rRect.Right()));
      71             : 
      72             :     // add band with boundaries of the rectangle
      73           0 :     mpFirstBand = new ImplRegionBand(nTop, nBottom);
      74             : 
      75             :     // Set left and right boundaries of the band
      76           0 :     mpFirstBand->Union(nLeft, nRight);
      77             : 
      78           0 : }
      79             : 
      80           0 : void RegionBand::implReset()
      81             : {
      82           0 :     ImplRegionBand* pBand = mpFirstBand;
      83             : 
      84           0 :     while(pBand)
      85             :     {
      86           0 :         ImplRegionBand* pTempBand = pBand->mpNextBand;
      87           0 :         delete pBand;
      88           0 :         pBand = pTempBand;
      89             :     }
      90             : 
      91           0 :     mpLastCheckedBand = 0;
      92             : 
      93           0 : }
      94             : 
      95           0 : RegionBand::~RegionBand()
      96             : {
      97           0 :     implReset();
      98           0 : }
      99             : 
     100           0 : bool RegionBand::operator==( const RegionBand& rRegionBand ) const
     101             : {
     102             : 
     103             :     // initialise pointers
     104           0 :     ImplRegionBand*      pOwnRectBand = mpFirstBand;
     105           0 :     ImplRegionBandSep*   pOwnRectBandSep = pOwnRectBand->mpFirstSep;
     106           0 :     ImplRegionBand*      pSecondRectBand = rRegionBand.mpFirstBand;
     107           0 :     ImplRegionBandSep*   pSecondRectBandSep = pSecondRectBand->mpFirstSep;
     108             : 
     109           0 :     while ( pOwnRectBandSep && pSecondRectBandSep )
     110             :     {
     111             :         // get boundaries of current rectangle
     112           0 :         long nOwnXLeft = pOwnRectBandSep->mnXLeft;
     113           0 :         long nSecondXLeft = pSecondRectBandSep->mnXLeft;
     114             : 
     115           0 :         if ( nOwnXLeft != nSecondXLeft )
     116             :         {
     117           0 :             return false;
     118             :         }
     119             : 
     120           0 :         long nOwnYTop = pOwnRectBand->mnYTop;
     121           0 :         long nSecondYTop = pSecondRectBand->mnYTop;
     122             : 
     123           0 :         if ( nOwnYTop != nSecondYTop )
     124             :         {
     125           0 :             return false;
     126             :         }
     127             : 
     128           0 :         long nOwnXRight = pOwnRectBandSep->mnXRight;
     129           0 :         long nSecondXRight = pSecondRectBandSep->mnXRight;
     130             : 
     131           0 :         if ( nOwnXRight != nSecondXRight )
     132             :         {
     133           0 :             return false;
     134             :         }
     135             : 
     136           0 :         long nOwnYBottom = pOwnRectBand->mnYBottom;
     137           0 :         long nSecondYBottom = pSecondRectBand->mnYBottom;
     138             : 
     139           0 :         if ( nOwnYBottom != nSecondYBottom )
     140             :         {
     141           0 :             return false;
     142             :         }
     143             : 
     144             :         // get next separation from current band
     145           0 :         pOwnRectBandSep = pOwnRectBandSep->mpNextSep;
     146             : 
     147             :         // no separation found? -> go to next band!
     148           0 :         if ( !pOwnRectBandSep )
     149             :         {
     150             :             // get next band
     151           0 :             pOwnRectBand = pOwnRectBand->mpNextBand;
     152             : 
     153             :             // get first separation in current band
     154           0 :             if( pOwnRectBand )
     155             :             {
     156           0 :                 pOwnRectBandSep = pOwnRectBand->mpFirstSep;
     157             :             }
     158             :         }
     159             : 
     160             :         // get next separation from current band
     161           0 :         pSecondRectBandSep = pSecondRectBandSep->mpNextSep;
     162             : 
     163             :         // no separation found? -> go to next band!
     164           0 :         if ( !pSecondRectBandSep )
     165             :         {
     166             :             // get next band
     167           0 :             pSecondRectBand = pSecondRectBand->mpNextBand;
     168             : 
     169             :             // get first separation in current band
     170           0 :             if( pSecondRectBand )
     171             :             {
     172           0 :                 pSecondRectBandSep = pSecondRectBand->mpFirstSep;
     173             :             }
     174             :         }
     175             : 
     176           0 :         if ( pOwnRectBandSep && !pSecondRectBandSep )
     177             :         {
     178           0 :             return false;
     179             :         }
     180             : 
     181           0 :         if ( !pOwnRectBandSep && pSecondRectBandSep )
     182             :         {
     183           0 :             return false;
     184             :         }
     185             :     }
     186             : 
     187           0 :     return true;
     188             : }
     189             : 
     190             : enum StreamEntryType { STREAMENTRY_BANDHEADER, STREAMENTRY_SEPARATION, STREAMENTRY_END };
     191             : 
     192           0 : void RegionBand::load(SvStream& rIStrm)
     193             : {
     194             :     // clear this nstance's data
     195           0 :     implReset();
     196             : 
     197             :     // get all bands
     198           0 :     ImplRegionBand* pCurrBand = 0;
     199             : 
     200             :     // get header from first element
     201           0 :     sal_uInt16 nTmp16(0);
     202           0 :     rIStrm.ReadUInt16( nTmp16 );
     203             : 
     204           0 :     while(STREAMENTRY_END != (StreamEntryType)nTmp16)
     205             :     {
     206             :         // insert new band or new separation?
     207           0 :         if(STREAMENTRY_BANDHEADER == (StreamEntryType)nTmp16)
     208             :         {
     209           0 :             sal_Int32 nYTop(0);
     210           0 :             sal_Int32 nYBottom(0);
     211             : 
     212           0 :             rIStrm.ReadInt32( nYTop );
     213           0 :             rIStrm.ReadInt32( nYBottom );
     214             : 
     215             :             // create band
     216           0 :             ImplRegionBand* pNewBand = new ImplRegionBand( nYTop, nYBottom );
     217             : 
     218             :             // first element? -> set as first into the list
     219           0 :             if ( !pCurrBand )
     220             :             {
     221           0 :                 mpFirstBand = pNewBand;
     222             :             }
     223             :             else
     224             :             {
     225           0 :                 pCurrBand->mpNextBand = pNewBand;
     226             :             }
     227             : 
     228             :             // save pointer for next creation
     229           0 :             pCurrBand = pNewBand;
     230             :         }
     231             :         else
     232             :         {
     233           0 :             sal_Int32 nXLeft(0);
     234           0 :             sal_Int32 nXRight(0);
     235             : 
     236           0 :             rIStrm.ReadInt32( nXLeft );
     237           0 :             rIStrm.ReadInt32( nXRight );
     238             : 
     239             :             // add separation
     240           0 :             if ( pCurrBand )
     241             :             {
     242           0 :                 pCurrBand->Union( nXLeft, nXRight );
     243             :             }
     244             :         }
     245             : 
     246           0 :         if( rIStrm.IsEof() )
     247             :         {
     248             :             OSL_ENSURE(false, "premature end of region stream" );
     249           0 :             implReset();
     250           0 :             return;
     251             :         }
     252             : 
     253             :         // get next header
     254           0 :         rIStrm.ReadUInt16( nTmp16 );
     255             :     }
     256             : 
     257             : }
     258             : 
     259           0 : void RegionBand::save(SvStream& rOStrm) const
     260             : {
     261           0 :     ImplRegionBand* pBand = mpFirstBand;
     262             : 
     263           0 :     while(pBand)
     264             :     {
     265             :         // put boundaries
     266           0 :         rOStrm.WriteUInt16( (sal_uInt16)STREAMENTRY_BANDHEADER );
     267           0 :         rOStrm.WriteInt32( static_cast<sal_Int32>(pBand->mnYTop) );
     268           0 :         rOStrm.WriteInt32( static_cast<sal_Int32>(pBand->mnYBottom) );
     269             : 
     270             :         // put separations of current band
     271           0 :         ImplRegionBandSep* pSep = pBand->mpFirstSep;
     272             : 
     273           0 :         while(pSep)
     274             :         {
     275             :             // put separation
     276           0 :             rOStrm.WriteUInt16( (sal_uInt16)STREAMENTRY_SEPARATION );
     277           0 :             rOStrm.WriteInt32( static_cast<sal_Int32>(pSep->mnXLeft) );
     278           0 :             rOStrm.WriteInt32( static_cast<sal_Int32>(pSep->mnXRight) );
     279             : 
     280             :             // next separation from current band
     281           0 :             pSep = pSep->mpNextSep;
     282             :         }
     283             : 
     284           0 :         pBand = pBand->mpNextBand;
     285             :     }
     286             : 
     287             :     // put endmarker
     288           0 :     rOStrm.WriteUInt16( (sal_uInt16)STREAMENTRY_END );
     289           0 : }
     290             : 
     291           0 : bool RegionBand::isSingleRectangle() const
     292             : {
     293             :     // just one band?
     294           0 :     if(mpFirstBand && !mpFirstBand->mpNextBand)
     295             :     {
     296             :         // just one sep?
     297           0 :         if(mpFirstBand->mpFirstSep && !mpFirstBand->mpFirstSep->mpNextSep)
     298             :         {
     299           0 :             return true;
     300             :         }
     301             :     }
     302             : 
     303           0 :     return false;
     304             : }
     305             : 
     306           0 : void RegionBand::InsertBand(ImplRegionBand* pPreviousBand, ImplRegionBand* pBandToInsert)
     307             : {
     308             :     OSL_ASSERT(pBandToInsert!=NULL);
     309             : 
     310           0 :     if(!pPreviousBand)
     311             :     {
     312             :         // Insert band before all others.
     313           0 :         if(mpFirstBand)
     314             :         {
     315           0 :             mpFirstBand->mpPrevBand = pBandToInsert;
     316             :         }
     317             : 
     318           0 :         pBandToInsert->mpNextBand = mpFirstBand;
     319           0 :         mpFirstBand = pBandToInsert;
     320             :     }
     321             :     else
     322             :     {
     323             :         // Insert band directly after pPreviousBand.
     324           0 :         pBandToInsert->mpNextBand = pPreviousBand->mpNextBand;
     325           0 :         pPreviousBand->mpNextBand = pBandToInsert;
     326           0 :         pBandToInsert->mpPrevBand = pPreviousBand;
     327             :     }
     328             : 
     329           0 : }
     330             : 
     331           0 : void RegionBand::processPoints()
     332             : {
     333           0 :     ImplRegionBand* pRegionBand = mpFirstBand;
     334             : 
     335           0 :     while(pRegionBand)
     336             :     {
     337             :         // generate separations from the lines and process union
     338           0 :         pRegionBand->ProcessPoints();
     339           0 :         pRegionBand = pRegionBand->mpNextBand;
     340             :     }
     341             : 
     342           0 : }
     343             : 
     344             : /** This function is similar to the RegionBand::InsertBands() method.
     345             :     It creates a minimal set of missing bands so that the entire vertical
     346             :     interval from nTop to nBottom is covered by bands.
     347             : */
     348           0 : void RegionBand::ImplAddMissingBands(const long nTop, const long nBottom)
     349             : {
     350             :     // Iterate over already existing bands and add missing bands atop the
     351             :     // first and between two bands.
     352           0 :     ImplRegionBand* pPreviousBand = NULL;
     353           0 :     ImplRegionBand* pBand = ImplGetFirstRegionBand();
     354           0 :     long nCurrentTop (nTop);
     355             : 
     356           0 :     while (pBand != NULL && nCurrentTop<nBottom)
     357             :     {
     358           0 :         if (nCurrentTop < pBand->mnYTop)
     359             :         {
     360             :             // Create new band above the current band.
     361             :             ImplRegionBand* pAboveBand = new ImplRegionBand(
     362             :                 nCurrentTop,
     363           0 :                 ::std::min(nBottom,pBand->mnYTop-1));
     364           0 :             InsertBand(pPreviousBand, pAboveBand);
     365             :         }
     366             : 
     367             :         // Adapt the top of the interval to prevent overlapping bands.
     368           0 :         nCurrentTop = ::std::max(nTop, pBand->mnYBottom+1);
     369             : 
     370             :         // Advance to next band.
     371           0 :         pPreviousBand = pBand;
     372           0 :         pBand = pBand->mpNextBand;
     373             :     }
     374             : 
     375             :     // We still have to cover two cases:
     376             :     // 1. The region does not yet contain any bands.
     377             :     // 2. The intervall nTop->nBottom extends past the bottom most band.
     378           0 :     if (nCurrentTop <= nBottom
     379           0 :         && (pBand==NULL || nBottom>pBand->mnYBottom))
     380             :     {
     381             :         // When there is no previous band then the new one will be the
     382             :         // first.  Otherwise the new band is inserted behind the last band.
     383             :         InsertBand(
     384             :             pPreviousBand,
     385             :             new ImplRegionBand(
     386             :                 nCurrentTop,
     387           0 :                 nBottom));
     388             :     }
     389             : 
     390           0 : }
     391             : 
     392           0 : void RegionBand::CreateBandRange(long nYTop, long nYBottom)
     393             : {
     394             :     // add top band
     395           0 :     mpFirstBand = new ImplRegionBand( nYTop-1, nYTop-1 );
     396             : 
     397             :     // begin first search from the first element
     398           0 :     mpLastCheckedBand = mpFirstBand;
     399           0 :     ImplRegionBand* pBand = mpFirstBand;
     400             : 
     401           0 :     for ( int i = nYTop; i <= nYBottom+1; i++ )
     402             :     {
     403             :         // create new band
     404           0 :         ImplRegionBand* pNewBand = new ImplRegionBand( i, i );
     405           0 :         pBand->mpNextBand = pNewBand;
     406             : 
     407           0 :         if ( pBand != mpFirstBand )
     408             :         {
     409           0 :             pNewBand->mpPrevBand = pBand;
     410             :         }
     411             : 
     412           0 :         pBand = pBand->mpNextBand;
     413             :     }
     414             : 
     415           0 : }
     416             : 
     417           0 : bool RegionBand::InsertLine(const Point& rStartPt, const Point& rEndPt, long nLineId)
     418             : {
     419             :     long nX, nY;
     420             : 
     421             :     // lines consisting of a single point do not interest here
     422           0 :     if ( rStartPt == rEndPt )
     423             :     {
     424           0 :         return true;
     425             :     }
     426             : 
     427           0 :     LineType eLineType = (rStartPt.Y() > rEndPt.Y()) ? LINE_DESCENDING : LINE_ASCENDING;
     428           0 :     if ( rStartPt.X() == rEndPt.X() )
     429             :     {
     430             :         // vertical line
     431           0 :         const long nEndY = rEndPt.Y();
     432             : 
     433           0 :         nX = rStartPt.X();
     434           0 :         nY = rStartPt.Y();
     435             : 
     436           0 :         if( nEndY > nY )
     437             :         {
     438           0 :             for ( ; nY <= nEndY; nY++ )
     439             :             {
     440           0 :                 Point aNewPoint( nX, nY );
     441             :                 InsertPoint( aNewPoint, nLineId,
     442           0 :                              (aNewPoint == rEndPt) || (aNewPoint == rStartPt),
     443           0 :                              eLineType );
     444             :             }
     445             :         }
     446             :         else
     447             :         {
     448           0 :             for ( ; nY >= nEndY; nY-- )
     449             :             {
     450           0 :                 Point aNewPoint( nX, nY );
     451             :                 InsertPoint( aNewPoint, nLineId,
     452           0 :                              (aNewPoint == rEndPt) || (aNewPoint == rStartPt),
     453           0 :                              eLineType );
     454             :             }
     455             :         }
     456             :     }
     457           0 :     else if ( rStartPt.Y() != rEndPt.Y() )
     458             :     {
     459           0 :         const long  nDX = labs( rEndPt.X() - rStartPt.X() );
     460           0 :         const long  nDY = labs( rEndPt.Y() - rStartPt.Y() );
     461           0 :         const long  nStartX = rStartPt.X();
     462           0 :         const long  nStartY = rStartPt.Y();
     463           0 :         const long  nEndX = rEndPt.X();
     464           0 :         const long  nEndY = rEndPt.Y();
     465           0 :         const long  nXInc = ( nStartX < nEndX ) ? 1L : -1L;
     466           0 :         const long  nYInc = ( nStartY < nEndY ) ? 1L : -1L;
     467             : 
     468           0 :         if ( nDX >= nDY )
     469             :         {
     470           0 :             const long  nDYX = ( nDY - nDX ) << 1;
     471           0 :             const long  nDY2 = nDY << 1;
     472           0 :             long        nD = nDY2 - nDX;
     473             : 
     474           0 :             for ( nX = nStartX, nY = nStartY; nX != nEndX; nX += nXInc )
     475             :             {
     476           0 :                 InsertPoint( Point( nX, nY ), nLineId, nStartX == nX, eLineType );
     477             : 
     478           0 :                 if ( nD < 0L )
     479           0 :                     nD += nDY2;
     480             :                 else
     481           0 :                     nD += nDYX, nY += nYInc;
     482             :             }
     483             :         }
     484             :         else
     485             :         {
     486           0 :             const long  nDYX = ( nDX - nDY ) << 1;
     487           0 :             const long  nDY2 = nDX << 1;
     488           0 :             long        nD = nDY2 - nDY;
     489             : 
     490           0 :             for ( nX = nStartX, nY = nStartY; nY != nEndY; nY += nYInc )
     491             :             {
     492           0 :                 InsertPoint( Point( nX, nY ), nLineId, nStartY == nY, eLineType );
     493             : 
     494           0 :                 if ( nD < 0L )
     495           0 :                     nD += nDY2;
     496             :                 else
     497           0 :                     nD += nDYX, nX += nXInc;
     498             :             }
     499             :         }
     500             : 
     501             :         // last point
     502           0 :         InsertPoint( Point( nEndX, nEndY ), nLineId, true, eLineType );
     503             :     }
     504             : 
     505           0 :     return true;
     506             : }
     507             : 
     508           0 : bool RegionBand::InsertPoint(const Point &rPoint, long nLineID, bool bEndPoint, LineType eLineType)
     509             : {
     510             :     DBG_ASSERT( mpFirstBand != NULL, "RegionBand::InsertPoint - no bands available!" );
     511             : 
     512           0 :     if ( rPoint.Y() == mpLastCheckedBand->mnYTop )
     513             :     {
     514           0 :         mpLastCheckedBand->InsertPoint( rPoint.X(), nLineID, bEndPoint, eLineType );
     515           0 :         return true;
     516             :     }
     517             : 
     518           0 :     if ( rPoint.Y() > mpLastCheckedBand->mnYTop )
     519             :     {
     520             :         // Search ascending
     521           0 :         while ( mpLastCheckedBand )
     522             :         {
     523             :             // Insert point if possible
     524           0 :             if ( rPoint.Y() == mpLastCheckedBand->mnYTop )
     525             :             {
     526           0 :                 mpLastCheckedBand->InsertPoint( rPoint.X(), nLineID, bEndPoint, eLineType );
     527           0 :                 return true;
     528             :             }
     529             : 
     530           0 :             mpLastCheckedBand = mpLastCheckedBand->mpNextBand;
     531             :         }
     532             : 
     533             :         OSL_ENSURE(false, "RegionBand::InsertPoint reached the end of the list!" );
     534             :     }
     535             :     else
     536             :     {
     537             :         // Search descending
     538           0 :         while ( mpLastCheckedBand )
     539             :         {
     540             :             // Insert point if possible
     541           0 :             if ( rPoint.Y() == mpLastCheckedBand->mnYTop )
     542             :             {
     543           0 :                 mpLastCheckedBand->InsertPoint( rPoint.X(), nLineID, bEndPoint, eLineType );
     544           0 :                 return true;
     545             :             }
     546             : 
     547           0 :             mpLastCheckedBand = mpLastCheckedBand->mpPrevBand;
     548             :         }
     549             : 
     550             :         OSL_ENSURE(false, "RegionBand::InsertPoint reached the beginning of the list!" );
     551             :     }
     552             : 
     553             :     OSL_ENSURE(false, "RegionBand::InsertPoint point not inserted!" );
     554             : 
     555             :     // reinitialize pointer (should never be reached!)
     556           0 :     mpLastCheckedBand = mpFirstBand;
     557             : 
     558           0 :     return false;
     559             : }
     560             : 
     561           0 : bool RegionBand::OptimizeBandList()
     562             : {
     563           0 :     ImplRegionBand* pPrevBand = 0;
     564           0 :     ImplRegionBand* pBand = mpFirstBand;
     565             : 
     566           0 :     while ( pBand )
     567             :     {
     568           0 :         const bool bBTEqual = pBand->mpNextBand && (pBand->mnYBottom == pBand->mpNextBand->mnYTop);
     569             : 
     570             :         // no separation? -> remove!
     571           0 :         if ( pBand->IsEmpty() || (bBTEqual && (pBand->mnYBottom == pBand->mnYTop)) )
     572             :         {
     573             :             // save pointer
     574           0 :             ImplRegionBand* pOldBand = pBand;
     575             : 
     576             :             // previous element of the list
     577           0 :             if ( pBand == mpFirstBand )
     578           0 :                 mpFirstBand = pBand->mpNextBand;
     579             :             else
     580           0 :                 pPrevBand->mpNextBand = pBand->mpNextBand;
     581             : 
     582           0 :             pBand = pBand->mpNextBand;
     583           0 :             delete pOldBand;
     584             :         }
     585             :         else
     586             :         {
     587             :             // fixup
     588           0 :             if ( bBTEqual )
     589           0 :                 pBand->mnYBottom = pBand->mpNextBand->mnYTop-1;
     590             : 
     591             :             // this and next band with equal separations? -> combine!
     592           0 :             if ( pBand->mpNextBand &&
     593           0 :                  ((pBand->mnYBottom+1) == pBand->mpNextBand->mnYTop) &&
     594           0 :                  (*pBand == *pBand->mpNextBand) )
     595             :             {
     596             :                 // expand current height
     597           0 :                 pBand->mnYBottom = pBand->mpNextBand->mnYBottom;
     598             : 
     599             :                 // remove next band from list
     600           0 :                 ImplRegionBand* pDeletedBand = pBand->mpNextBand;
     601           0 :                 pBand->mpNextBand = pDeletedBand->mpNextBand;
     602           0 :                 delete pDeletedBand;
     603             : 
     604             :                 // check band again!
     605             :             }
     606             :             else
     607             :             {
     608             :                 // count rectangles within band
     609           0 :                 ImplRegionBandSep* pSep = pBand->mpFirstSep;
     610           0 :                 while ( pSep )
     611             :                 {
     612           0 :                     pSep = pSep->mpNextSep;
     613             :                 }
     614             : 
     615           0 :                 pPrevBand = pBand;
     616           0 :                 pBand = pBand->mpNextBand;
     617             :             }
     618             :         }
     619             :     }
     620             : 
     621             : #ifdef DBG_UTIL
     622             :     pBand = mpFirstBand;
     623             :     while ( pBand )
     624             :     {
     625             :         DBG_ASSERT( pBand->mpFirstSep != NULL, "Exiting RegionBand::OptimizeBandList(): empty band in region!" );
     626             : 
     627             :         if ( pBand->mnYBottom < pBand->mnYTop )
     628             :             OSL_ENSURE(false, "RegionBand::OptimizeBandList(): YBottomBoundary < YTopBoundary" );
     629             : 
     630             :         if ( pBand->mpNextBand )
     631             :         {
     632             :             if ( pBand->mnYBottom >= pBand->mpNextBand->mnYTop )
     633             :                 OSL_ENSURE(false, "RegionBand::OptimizeBandList(): overlapping bands in region!" );
     634             :         }
     635             : 
     636             :         pBand = pBand->mpNextBand;
     637             :     }
     638             : #endif
     639             : 
     640           0 :     return (0 != mpFirstBand);
     641             : }
     642             : 
     643           0 : void RegionBand::Move(long nHorzMove, long nVertMove)
     644             : {
     645           0 :     ImplRegionBand* pBand = mpFirstBand;
     646             : 
     647           0 :     while(pBand)
     648             :     {
     649             :         // process the vertical move
     650           0 :         if(nVertMove)
     651             :         {
     652           0 :             pBand->mnYTop = pBand->mnYTop + nVertMove;
     653           0 :             pBand->mnYBottom = pBand->mnYBottom + nVertMove;
     654             :         }
     655             : 
     656             :         // process the horizontal move
     657           0 :         if(nHorzMove)
     658             :         {
     659           0 :             pBand->MoveX(nHorzMove);
     660             :         }
     661             : 
     662           0 :         pBand = pBand->mpNextBand;
     663             :     }
     664             : 
     665           0 : }
     666             : 
     667           0 : void RegionBand::Scale(double fScaleX, double fScaleY)
     668             : {
     669           0 :     ImplRegionBand* pBand = mpFirstBand;
     670             : 
     671           0 :     while(pBand)
     672             :     {
     673             :         // process the vertical move
     674           0 :         if(0.0 != fScaleY)
     675             :         {
     676           0 :             pBand->mnYTop = basegfx::fround(pBand->mnYTop * fScaleY);
     677           0 :             pBand->mnYBottom = basegfx::fround(pBand->mnYBottom * fScaleY);
     678             :         }
     679             : 
     680             :         // process the horizontal move
     681           0 :         if(0.0 != fScaleX)
     682             :         {
     683           0 :             pBand->ScaleX(fScaleX);
     684             :         }
     685             : 
     686           0 :         pBand = pBand->mpNextBand;
     687             :     }
     688             : 
     689           0 : }
     690             : 
     691           0 : void RegionBand::InsertBands(long nTop, long nBottom)
     692             : {
     693             :     // region empty? -> set rectagle as first entry!
     694           0 :     if ( !mpFirstBand )
     695             :     {
     696             :         // add band with boundaries of the rectangle
     697           0 :         mpFirstBand = new ImplRegionBand( nTop, nBottom );
     698           0 :         return;
     699             :     }
     700             : 
     701             :     // find/insert bands for the boundaries of the rectangle
     702           0 :     bool bTopBoundaryInserted = false;
     703           0 :     bool bTop2BoundaryInserted = false;
     704           0 :     bool bBottomBoundaryInserted = false;
     705             : 
     706             :     // special case: top boundary is above the first band
     707             :     ImplRegionBand* pNewBand;
     708             : 
     709           0 :     if ( nTop < mpFirstBand->mnYTop )
     710             :     {
     711             :         // create new band above the first in the list
     712           0 :         pNewBand = new ImplRegionBand( nTop, mpFirstBand->mnYTop );
     713             : 
     714           0 :         if ( nBottom < mpFirstBand->mnYTop )
     715             :         {
     716           0 :             pNewBand->mnYBottom = nBottom;
     717             :         }
     718             : 
     719             :         // insert band into the list
     720           0 :         pNewBand->mpNextBand = mpFirstBand;
     721           0 :         mpFirstBand = pNewBand;
     722             : 
     723           0 :         bTopBoundaryInserted = true;
     724             :     }
     725             : 
     726             :     // insert band(s) into the list
     727           0 :     ImplRegionBand* pBand = mpFirstBand;
     728             : 
     729           0 :     while ( pBand )
     730             :     {
     731             :         // Insert Bands if possible
     732           0 :         if ( !bTopBoundaryInserted )
     733             :         {
     734           0 :             bTopBoundaryInserted = InsertSingleBand( pBand, nTop - 1 );
     735             :         }
     736             : 
     737           0 :         if ( !bTop2BoundaryInserted )
     738             :         {
     739           0 :             bTop2BoundaryInserted = InsertSingleBand( pBand, nTop );
     740             :         }
     741             : 
     742           0 :         if ( !bBottomBoundaryInserted && (nTop != nBottom) )
     743             :         {
     744           0 :             bBottomBoundaryInserted = InsertSingleBand( pBand, nBottom );
     745             :         }
     746             : 
     747             :         // both boundaries inserted? -> nothing more to do
     748           0 :         if ( bTopBoundaryInserted && bTop2BoundaryInserted && bBottomBoundaryInserted )
     749             :         {
     750           0 :             break;
     751             :         }
     752             : 
     753             :         // insert bands between two bands if necessary
     754           0 :         if ( pBand->mpNextBand )
     755             :         {
     756           0 :             if ( (pBand->mnYBottom + 1) < pBand->mpNextBand->mnYTop )
     757             :             {
     758             :                 // copy band with list and set new boundary
     759           0 :                 pNewBand = new ImplRegionBand( pBand->mnYBottom+1, pBand->mpNextBand->mnYTop-1 );
     760             : 
     761             :                 // insert band into the list
     762           0 :                 pNewBand->mpNextBand = pBand->mpNextBand;
     763           0 :                 pBand->mpNextBand = pNewBand;
     764             :             }
     765             :         }
     766             : 
     767           0 :         pBand = pBand->mpNextBand;
     768             :     }
     769             : 
     770             : }
     771             : 
     772           0 : bool RegionBand::InsertSingleBand(ImplRegionBand* pBand, long nYBandPosition)
     773             : {
     774             :     // boundary already included in band with height 1? -> nothing to do!
     775           0 :     if ( (pBand->mnYTop == pBand->mnYBottom) && (nYBandPosition == pBand->mnYTop) )
     776             :     {
     777           0 :         return true;
     778             :     }
     779             : 
     780             :     // insert single height band on top?
     781             :     ImplRegionBand* pNewBand;
     782             : 
     783           0 :     if ( nYBandPosition == pBand->mnYTop )
     784             :     {
     785             :         // copy band with list and set new boundary
     786           0 :         pNewBand = new ImplRegionBand( *pBand );
     787           0 :         pNewBand->mnYTop = nYBandPosition+1;
     788             : 
     789             :         // insert band into the list
     790           0 :         pNewBand->mpNextBand = pBand->mpNextBand;
     791           0 :         pBand->mnYBottom = nYBandPosition;
     792           0 :         pBand->mpNextBand = pNewBand;
     793             : 
     794           0 :         return true;
     795             :     }
     796             : 
     797             :     // top of new rectangle within the current band? -> insert new band and copy data
     798           0 :     if ( (nYBandPosition > pBand->mnYTop) && (nYBandPosition < pBand->mnYBottom) )
     799             :     {
     800             :         // copy band with list and set new boundary
     801           0 :         pNewBand = new ImplRegionBand( *pBand );
     802           0 :         pNewBand->mnYTop = nYBandPosition;
     803             : 
     804             :         // insert band into the list
     805           0 :         pNewBand->mpNextBand = pBand->mpNextBand;
     806           0 :         pBand->mnYBottom = nYBandPosition;
     807           0 :         pBand->mpNextBand = pNewBand;
     808             : 
     809             :         // copy band with list and set new boundary
     810           0 :         pNewBand = new ImplRegionBand( *pBand );
     811           0 :         pNewBand->mnYTop = nYBandPosition;
     812             : 
     813             :         // insert band into the list
     814           0 :         pBand->mpNextBand->mnYTop = nYBandPosition+1;
     815             : 
     816           0 :         pNewBand->mpNextBand = pBand->mpNextBand;
     817           0 :         pBand->mnYBottom = nYBandPosition - 1;
     818           0 :         pBand->mpNextBand = pNewBand;
     819             : 
     820           0 :         return true;
     821             :     }
     822             : 
     823             :     // create new band behind the current in the list
     824           0 :     if ( !pBand->mpNextBand )
     825             :     {
     826           0 :         if ( nYBandPosition == pBand->mnYBottom )
     827             :         {
     828             :             // copy band with list and set new boundary
     829           0 :             pNewBand = new ImplRegionBand( *pBand );
     830           0 :             pNewBand->mnYTop = pBand->mnYBottom;
     831           0 :             pNewBand->mnYBottom = nYBandPosition;
     832             : 
     833           0 :             pBand->mnYBottom = nYBandPosition-1;
     834             : 
     835             :             // append band to the list
     836           0 :             pBand->mpNextBand = pNewBand;
     837           0 :             return true;
     838             :         }
     839             : 
     840           0 :         if ( nYBandPosition > pBand->mnYBottom )
     841             :         {
     842             :             // create new band
     843           0 :             pNewBand = new ImplRegionBand( pBand->mnYBottom + 1, nYBandPosition );
     844             : 
     845             :             // append band to the list
     846           0 :             pBand->mpNextBand = pNewBand;
     847           0 :             return true;
     848             :         }
     849             :     }
     850             : 
     851           0 :     return false;
     852             : }
     853             : 
     854           0 : void RegionBand::Union(long nLeft, long nTop, long nRight, long nBottom)
     855             : {
     856             :     DBG_ASSERT( nLeft <= nRight, "RegionBand::Union() - nLeft > nRight" );
     857             :     DBG_ASSERT( nTop <= nBottom, "RegionBand::Union() - nTop > nBottom" );
     858             : 
     859             :     // process union
     860           0 :     ImplRegionBand* pBand = mpFirstBand;
     861           0 :     while ( pBand )
     862             :     {
     863           0 :         if ( pBand->mnYTop >= nTop )
     864             :         {
     865           0 :             if ( pBand->mnYBottom <= nBottom )
     866           0 :                 pBand->Union( nLeft, nRight );
     867             :             else
     868             :             {
     869             : #ifdef DBG_UTIL
     870             :                 long nCurY = pBand->mnYBottom;
     871             :                 pBand = pBand->mpNextBand;
     872             :                 while ( pBand )
     873             :                 {
     874             :                     if ( (pBand->mnYTop < nCurY) || (pBand->mnYBottom < nCurY) )
     875             :                     {
     876             :                         OSL_ENSURE(false, "RegionBand::Union() - Bands not sorted!" );
     877             :                     }
     878             :                     pBand = pBand->mpNextBand;
     879             :                 }
     880             : #endif
     881           0 :                 break;
     882             :             }
     883             :         }
     884             : 
     885           0 :         pBand = pBand->mpNextBand;
     886             :     }
     887             : 
     888           0 : }
     889             : 
     890           0 : void RegionBand::Intersect(long nLeft, long nTop, long nRight, long nBottom)
     891             : {
     892             :     // process intersections
     893           0 :     ImplRegionBand* pPrevBand = 0;
     894           0 :     ImplRegionBand* pBand = mpFirstBand;
     895             : 
     896           0 :     while(pBand)
     897             :     {
     898             :         // band within intersection boundary? -> process. otherwise remove
     899           0 :         if((pBand->mnYTop >= nTop) && (pBand->mnYBottom <= nBottom))
     900             :         {
     901             :             // process intersection
     902           0 :             pBand->Intersect(nLeft, nRight);
     903           0 :             pPrevBand = pBand;
     904           0 :             pBand = pBand->mpNextBand;
     905             :         }
     906             :         else
     907             :         {
     908           0 :             ImplRegionBand* pOldBand = pBand;
     909             : 
     910           0 :             if(pBand == mpFirstBand)
     911             :             {
     912           0 :                 mpFirstBand = pBand->mpNextBand;
     913             :             }
     914             :             else
     915             :             {
     916           0 :                 pPrevBand->mpNextBand = pBand->mpNextBand;
     917             :             }
     918             : 
     919           0 :             pBand = pBand->mpNextBand;
     920           0 :             delete pOldBand;
     921             :         }
     922             :     }
     923             : 
     924           0 : }
     925             : 
     926           0 : void RegionBand::Union(const RegionBand& rSource)
     927             : {
     928             :     // apply all rectangles from rSource to this
     929           0 :     ImplRegionBand* pBand = rSource.mpFirstBand;
     930             : 
     931           0 :     while ( pBand )
     932             :     {
     933             :         // insert bands if the boundaries are not already in the list
     934           0 :         InsertBands(pBand->mnYTop, pBand->mnYBottom);
     935             : 
     936             :         // process all elements of the list
     937           0 :         ImplRegionBandSep* pSep = pBand->mpFirstSep;
     938             : 
     939           0 :         while(pSep)
     940             :         {
     941           0 :             Union(pSep->mnXLeft, pBand->mnYTop, pSep->mnXRight, pBand->mnYBottom);
     942           0 :             pSep = pSep->mpNextSep;
     943             :         }
     944             : 
     945           0 :         pBand = pBand->mpNextBand;
     946             :     }
     947             : 
     948           0 : }
     949             : 
     950           0 : void RegionBand::Exclude(long nLeft, long nTop, long nRight, long nBottom)
     951             : {
     952             :     DBG_ASSERT( nLeft <= nRight, "RegionBand::Exclude() - nLeft > nRight" );
     953             :     DBG_ASSERT( nTop <= nBottom, "RegionBand::Exclude() - nTop > nBottom" );
     954             : 
     955             :     // process exclude
     956           0 :     ImplRegionBand* pBand = mpFirstBand;
     957             : 
     958           0 :     while(pBand)
     959             :     {
     960           0 :         if(pBand->mnYTop >= nTop)
     961             :         {
     962           0 :             if(pBand->mnYBottom <= nBottom)
     963             :             {
     964           0 :                 pBand->Exclude(nLeft, nRight);
     965             :             }
     966             :             else
     967             :             {
     968             : #ifdef DBG_UTIL
     969             :                 long nCurY = pBand->mnYBottom;
     970             :                 pBand = pBand->mpNextBand;
     971             : 
     972             :                 while(pBand)
     973             :                 {
     974             :                     if((pBand->mnYTop < nCurY) || (pBand->mnYBottom < nCurY))
     975             :                     {
     976             :                         OSL_ENSURE(false, "RegionBand::Exclude() - Bands not sorted!" );
     977             :                     }
     978             : 
     979             :                     pBand = pBand->mpNextBand;
     980             :                 }
     981             : #endif
     982           0 :                 break;
     983             :             }
     984             :         }
     985             : 
     986           0 :         pBand = pBand->mpNextBand;
     987             :     }
     988             : 
     989           0 : }
     990             : 
     991           0 : void RegionBand::XOr(long nLeft, long nTop, long nRight, long nBottom)
     992             : {
     993             :     DBG_ASSERT( nLeft <= nRight, "RegionBand::Exclude() - nLeft > nRight" );
     994             :     DBG_ASSERT( nTop <= nBottom, "RegionBand::Exclude() - nTop > nBottom" );
     995             : 
     996             :     // process xor
     997           0 :     ImplRegionBand* pBand = mpFirstBand;
     998             : 
     999           0 :     while(pBand)
    1000             :     {
    1001           0 :         if(pBand->mnYTop >= nTop)
    1002             :         {
    1003           0 :             if(pBand->mnYBottom <= nBottom)
    1004             :             {
    1005           0 :                 pBand->XOr(nLeft, nRight);
    1006             :             }
    1007             :             else
    1008             :             {
    1009             : #ifdef DBG_UTIL
    1010             :                 long nCurY = pBand->mnYBottom;
    1011             :                 pBand = pBand->mpNextBand;
    1012             : 
    1013             :                 while(pBand)
    1014             :                 {
    1015             :                     if((pBand->mnYTop < nCurY) || (pBand->mnYBottom < nCurY))
    1016             :                     {
    1017             :                         OSL_ENSURE(false, "RegionBand::XOr() - Bands not sorted!" );
    1018             :                     }
    1019             : 
    1020             :                     pBand = pBand->mpNextBand;
    1021             :                 }
    1022             : #endif
    1023           0 :                 break;
    1024             :             }
    1025             :         }
    1026             : 
    1027           0 :         pBand = pBand->mpNextBand;
    1028             :     }
    1029             : 
    1030           0 : }
    1031             : 
    1032           0 : void RegionBand::Intersect(const RegionBand& rSource)
    1033             : {
    1034             :     // mark all bands as untouched
    1035           0 :     ImplRegionBand* pBand = mpFirstBand;
    1036             : 
    1037           0 :     while ( pBand )
    1038             :     {
    1039           0 :         pBand->mbTouched = false;
    1040           0 :         pBand = pBand->mpNextBand;
    1041             :     }
    1042             : 
    1043           0 :     pBand = rSource.mpFirstBand;
    1044             : 
    1045           0 :     while ( pBand )
    1046             :     {
    1047             :         // insert bands if the boundaries are not already in the list
    1048           0 :         InsertBands( pBand->mnYTop, pBand->mnYBottom );
    1049             : 
    1050             :         // process all elements of the list
    1051           0 :         ImplRegionBandSep* pSep = pBand->mpFirstSep;
    1052             : 
    1053           0 :         while ( pSep )
    1054             :         {
    1055             :             // left boundary?
    1056           0 :             if ( pSep == pBand->mpFirstSep )
    1057             :             {
    1058             :                 // process intersection and do not remove untouched bands
    1059           0 :                 Exclude( LONG_MIN+1, pBand->mnYTop, pSep->mnXLeft-1, pBand->mnYBottom );
    1060             :             }
    1061             : 
    1062             :             // right boundary?
    1063           0 :             if ( pSep->mpNextSep == NULL )
    1064             :             {
    1065             :                 // process intersection and do not remove untouched bands
    1066           0 :                 Exclude( pSep->mnXRight+1, pBand->mnYTop, LONG_MAX-1, pBand->mnYBottom );
    1067             :             }
    1068             :             else
    1069             :             {
    1070             :                 // process intersection and do not remove untouched bands
    1071           0 :                 Exclude( pSep->mnXRight+1, pBand->mnYTop, pSep->mpNextSep->mnXLeft-1, pBand->mnYBottom );
    1072             :             }
    1073             : 
    1074           0 :             pSep = pSep->mpNextSep;
    1075             :         }
    1076             : 
    1077           0 :         pBand = pBand->mpNextBand;
    1078             :     }
    1079             : 
    1080             :     // remove all untouched bands if bands already left
    1081           0 :     ImplRegionBand* pPrevBand = 0;
    1082           0 :     pBand = mpFirstBand;
    1083             : 
    1084           0 :     while ( pBand )
    1085             :     {
    1086           0 :         if ( !pBand->mbTouched )
    1087             :         {
    1088             :             // save pointer
    1089           0 :             ImplRegionBand* pOldBand = pBand;
    1090             : 
    1091             :             // previous element of the list
    1092           0 :             if ( pBand == mpFirstBand )
    1093             :             {
    1094           0 :                 mpFirstBand = pBand->mpNextBand;
    1095             :             }
    1096             :             else
    1097             :             {
    1098           0 :                 pPrevBand->mpNextBand = pBand->mpNextBand;
    1099             :             }
    1100             : 
    1101           0 :             pBand = pBand->mpNextBand;
    1102           0 :             delete pOldBand;
    1103             :         }
    1104             :         else
    1105             :         {
    1106           0 :             pPrevBand = pBand;
    1107           0 :             pBand = pBand->mpNextBand;
    1108             :         }
    1109             :     }
    1110             : 
    1111           0 : }
    1112             : 
    1113           0 : bool RegionBand::Exclude(const RegionBand& rSource)
    1114             : {
    1115             :     // apply all rectangles to the region passed to this region
    1116           0 :     ImplRegionBand* pBand = rSource.mpFirstBand;
    1117             : 
    1118           0 :     while ( pBand )
    1119             :     {
    1120             :         // insert bands if the boundaries are not already in the list
    1121           0 :         InsertBands( pBand->mnYTop, pBand->mnYBottom );
    1122             : 
    1123             :         // process all elements of the list
    1124           0 :         ImplRegionBandSep* pSep = pBand->mpFirstSep;
    1125             : 
    1126           0 :         while ( pSep )
    1127             :         {
    1128           0 :             Exclude( pSep->mnXLeft, pBand->mnYTop, pSep->mnXRight, pBand->mnYBottom );
    1129           0 :             pSep = pSep->mpNextSep;
    1130             :         }
    1131             : 
    1132             :         // to test less bands, already check in the loop
    1133           0 :         if ( !OptimizeBandList() )
    1134             :         {
    1135           0 :             return false;
    1136             :         }
    1137             : 
    1138           0 :         pBand = pBand->mpNextBand;
    1139             :     }
    1140             : 
    1141           0 :     return true;
    1142             : }
    1143             : 
    1144           0 : Rectangle RegionBand::GetBoundRect() const
    1145             : {
    1146             : 
    1147             :     // get the boundaries of the first band
    1148           0 :     long nYTop(mpFirstBand->mnYTop);
    1149           0 :     long nYBottom(mpFirstBand->mnYBottom);
    1150           0 :     long nXLeft(mpFirstBand->GetXLeftBoundary());
    1151           0 :     long nXRight(mpFirstBand->GetXRightBoundary());
    1152             : 
    1153             :     // look in the band list (don't test first band again!)
    1154           0 :     ImplRegionBand* pBand = mpFirstBand->mpNextBand;
    1155             : 
    1156           0 :     while ( pBand )
    1157             :     {
    1158           0 :         nYBottom = pBand->mnYBottom;
    1159           0 :         nXLeft = std::min( nXLeft, pBand->GetXLeftBoundary() );
    1160           0 :         nXRight = std::max( nXRight, pBand->GetXRightBoundary() );
    1161             : 
    1162           0 :         pBand = pBand->mpNextBand;
    1163             :     }
    1164             : 
    1165           0 :     return Rectangle( nXLeft, nYTop, nXRight, nYBottom );
    1166             : }
    1167             : 
    1168           0 : void RegionBand::XOr(const RegionBand& rSource)
    1169             : {
    1170           0 :     ImplRegionBand* pBand = rSource.mpFirstBand;
    1171             : 
    1172           0 :     while ( pBand )
    1173             :     {
    1174             :         // insert bands if the boundaries are not already in the list
    1175           0 :         InsertBands( pBand->mnYTop, pBand->mnYBottom );
    1176             : 
    1177             :         // process all elements of the list
    1178           0 :         ImplRegionBandSep* pSep = pBand->mpFirstSep;
    1179             : 
    1180           0 :         while ( pSep )
    1181             :         {
    1182           0 :             XOr( pSep->mnXLeft, pBand->mnYTop, pSep->mnXRight, pBand->mnYBottom );
    1183           0 :             pSep = pSep->mpNextSep;
    1184             :         }
    1185             : 
    1186           0 :         pBand = pBand->mpNextBand;
    1187             :     }
    1188           0 : }
    1189             : 
    1190           0 : bool RegionBand::IsInside(const Point& rPoint) const
    1191             : {
    1192             : 
    1193             :     // search band list
    1194           0 :     ImplRegionBand* pBand = mpFirstBand;
    1195             : 
    1196           0 :     while(pBand)
    1197             :     {
    1198             :         // is point within band?
    1199           0 :         if((pBand->mnYTop <= rPoint.Y()) && (pBand->mnYBottom >= rPoint.Y()))
    1200             :         {
    1201             :             // is point within separation of the band?
    1202           0 :             if(pBand->IsInside(rPoint.X()))
    1203             :             {
    1204           0 :                 return true;
    1205             :             }
    1206             :             else
    1207             :             {
    1208           0 :                 return false;
    1209             :             }
    1210             :         }
    1211             : 
    1212           0 :         pBand = pBand->mpNextBand;
    1213             :     }
    1214             : 
    1215           0 :     return false;
    1216             : }
    1217             : 
    1218           0 : void RegionBand::GetRegionRectangles(RectangleVector& rTarget) const
    1219             : {
    1220             :     // clear result vector
    1221           0 :     rTarget.clear();
    1222           0 :     ImplRegionBand* mpCurrRectBand = mpFirstBand;
    1223           0 :     Rectangle aRectangle;
    1224             : 
    1225           0 :     while(mpCurrRectBand)
    1226             :     {
    1227           0 :         ImplRegionBandSep* mpCurrRectBandSep = mpCurrRectBand->mpFirstSep;
    1228             : 
    1229           0 :         aRectangle.Top() = mpCurrRectBand->mnYTop;
    1230           0 :         aRectangle.Bottom() = mpCurrRectBand->mnYBottom;
    1231             : 
    1232           0 :         while(mpCurrRectBandSep)
    1233             :         {
    1234           0 :             aRectangle.Left() = mpCurrRectBandSep->mnXLeft;
    1235           0 :             aRectangle.Right() = mpCurrRectBandSep->mnXRight;
    1236           0 :             rTarget.push_back(aRectangle);
    1237           0 :             mpCurrRectBandSep = mpCurrRectBandSep->mpNextSep;
    1238             :         }
    1239             : 
    1240           0 :         mpCurrRectBand = mpCurrRectBand->mpNextBand;
    1241             :     }
    1242           0 : }
    1243             : 
    1244           0 : sal_uInt32 RegionBand::getRectangleCount() const
    1245             : {
    1246           0 :     sal_uInt32 nCount = 0;
    1247           0 :     const ImplRegionBand* pBand = mpFirstBand;
    1248             : 
    1249           0 :     while(pBand)
    1250             :     {
    1251           0 :         ImplRegionBandSep* pSep = pBand->mpFirstSep;
    1252             : 
    1253           0 :         while(pSep)
    1254             :         {
    1255           0 :             nCount++;
    1256           0 :             pSep = pSep->mpNextSep;
    1257             :         }
    1258             : 
    1259           0 :         pBand = pBand->mpNextBand;
    1260             :     }
    1261             : 
    1262           0 :     return 0;
    1263             : }
    1264             : 
    1265             : #ifdef DBG_UTIL
    1266             : const char* ImplDbgTestRegionBand(const void* pObj)
    1267             : {
    1268             :     const RegionBand* pRegionBand = reinterpret_cast< const RegionBand* >(pObj);
    1269             : 
    1270             :     if(pRegionBand)
    1271             :     {
    1272             :         const ImplRegionBand* pBand = pRegionBand->ImplGetFirstRegionBand();
    1273             : 
    1274             :         while(pBand)
    1275             :         {
    1276             :             if(pBand->mnYBottom < pBand->mnYTop)
    1277             :             {
    1278             :                 return "YBottom < YTop";
    1279             :             }
    1280             : 
    1281             :             if(pBand->mpNextBand)
    1282             :             {
    1283             :                 if(pBand->mnYBottom >= pBand->mpNextBand->mnYTop)
    1284             :                 {
    1285             :                     return "overlapping bands in region";
    1286             :                 }
    1287             :             }
    1288             : 
    1289             :             if(pBand->mbTouched)
    1290             :             {
    1291             :                 return "Band-mbTouched overwrite";
    1292             :             }
    1293             : 
    1294             :             ImplRegionBandSep* pSep = pBand->mpFirstSep;
    1295             : 
    1296             :             while(pSep)
    1297             :             {
    1298             :                 if(pSep->mnXRight < pSep->mnXLeft)
    1299             :                 {
    1300             :                     return "XLeft < XRight";
    1301             :                 }
    1302             : 
    1303             :                 if(pSep->mpNextSep)
    1304             :                 {
    1305             :                     if(pSep->mnXRight >= pSep->mpNextSep->mnXLeft)
    1306             :                     {
    1307             :                         return "overlapping separations in region";
    1308             :                     }
    1309             :                 }
    1310             : 
    1311             :                 if ( pSep->mbRemoved )
    1312             :                 {
    1313             :                     return "Sep-mbRemoved overwrite";
    1314             :                 }
    1315             : 
    1316             :                 pSep = pSep->mpNextSep;
    1317             :             }
    1318             : 
    1319             :             pBand = pBand->mpNextBand;
    1320             :         }
    1321             :     }
    1322             : 
    1323             :     return 0;
    1324             : }
    1325             : #endif
    1326             : 
    1327             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10