LCOV - code coverage report
Current view: top level - sc/source/core/data - olinetab.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 486 0.0 %
Date: 2014-04-14 Functions: 0 63 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 <limits.h>
      21             : 
      22             : #include "olinetab.hxx"
      23             : #include "global.hxx"
      24             : #include "rechead.hxx"
      25             : #include "address.hxx"
      26             : #include "table.hxx"
      27             : 
      28           0 : ScOutlineEntry::ScOutlineEntry( SCCOLROW nNewStart, SCCOLROW nNewSize, bool bNewHidden ) :
      29             :     nStart  ( nNewStart ),
      30             :     nSize   ( nNewSize ),
      31             :     bHidden ( bNewHidden ),
      32           0 :     bVisible( true )
      33             : {
      34           0 : }
      35             : 
      36           0 : ScOutlineEntry::ScOutlineEntry( const ScOutlineEntry& rEntry ) :
      37             :     nStart  ( rEntry.nStart ),
      38             :     nSize   ( rEntry.nSize ),
      39             :     bHidden ( rEntry.bHidden ),
      40           0 :     bVisible( rEntry.bVisible )
      41             : {
      42           0 : }
      43             : 
      44           0 : SCCOLROW ScOutlineEntry::GetStart() const
      45             : {
      46           0 :     return nStart;
      47             : }
      48             : 
      49           0 : SCSIZE ScOutlineEntry::GetSize() const
      50             : {
      51           0 :     return nSize;
      52             : }
      53             : 
      54           0 : SCCOLROW ScOutlineEntry::GetEnd() const
      55             : {
      56           0 :     return nStart+nSize-1;
      57             : }
      58           0 : bool ScOutlineEntry::IsHidden() const
      59             : {
      60           0 :     return bHidden;
      61             : }
      62             : 
      63           0 : bool ScOutlineEntry::IsVisible() const
      64             : {
      65           0 :     return bVisible;
      66             : }
      67             : 
      68           0 : void ScOutlineEntry::Move( SCsCOLROW nDelta )
      69             : {
      70           0 :     SCCOLROW nNewPos = nStart + nDelta;
      71           0 :     if (nNewPos<0)
      72             :     {
      73             :         OSL_FAIL("OutlineEntry < 0");
      74           0 :         nNewPos = 0;
      75             :     }
      76           0 :     nStart = nNewPos;
      77           0 : }
      78             : 
      79           0 : void ScOutlineEntry::SetSize( SCSIZE nNewSize )
      80             : {
      81           0 :     if (nNewSize>0)
      82           0 :         nSize = nNewSize;
      83             :     else
      84             :     {
      85             :         OSL_FAIL("ScOutlineEntry Size == 0");
      86             :     }
      87           0 : }
      88             : 
      89           0 : void ScOutlineEntry::SetPosSize( SCCOLROW nNewPos, SCSIZE nNewSize )
      90             : {
      91           0 :     nStart = nNewPos;
      92           0 :     SetSize( nNewSize );
      93           0 : }
      94             : 
      95           0 : void ScOutlineEntry::SetHidden( bool bNewHidden )
      96             : {
      97           0 :     bHidden = bNewHidden;
      98           0 : }
      99             : 
     100           0 : void ScOutlineEntry::SetVisible( bool bNewVisible )
     101             : {
     102           0 :     bVisible = bNewVisible;
     103           0 : }
     104             : 
     105           0 : ScOutlineCollection::ScOutlineCollection() {}
     106             : 
     107           0 : size_t ScOutlineCollection::size() const
     108             : {
     109           0 :     return maEntries.size();
     110             : }
     111             : 
     112           0 : void ScOutlineCollection::clear()
     113             : {
     114           0 :     maEntries.clear();
     115           0 : }
     116             : 
     117           0 : void ScOutlineCollection::insert(ScOutlineEntry* pEntry)
     118             : {
     119           0 :     SCCOLROW nStart = pEntry->GetStart();
     120           0 :     maEntries.insert(nStart, pEntry);
     121           0 : }
     122             : 
     123           0 : ScOutlineCollection::iterator ScOutlineCollection::begin()
     124             : {
     125           0 :     return maEntries.begin();
     126             : }
     127             : 
     128           0 : ScOutlineCollection::iterator ScOutlineCollection::end()
     129             : {
     130           0 :     return maEntries.end();
     131             : }
     132             : 
     133           0 : ScOutlineCollection::const_iterator ScOutlineCollection::begin() const
     134             : {
     135           0 :     return maEntries.begin();
     136             : }
     137             : 
     138           0 : ScOutlineCollection::const_iterator ScOutlineCollection::end() const
     139             : {
     140           0 :     return maEntries.end();
     141             : }
     142             : 
     143           0 : void ScOutlineCollection::erase(iterator pos)
     144             : {
     145           0 :     maEntries.erase(pos);
     146           0 : }
     147             : 
     148           0 : bool ScOutlineCollection::empty() const
     149             : {
     150           0 :     return maEntries.empty();
     151             : }
     152             : 
     153           0 : ScOutlineCollection::iterator ScOutlineCollection::FindStart(SCCOLROW nMinStart)
     154             : {
     155           0 :     return maEntries.lower_bound(nMinStart);
     156             : }
     157             : 
     158           0 : ScOutlineArray::ScOutlineArray() :
     159           0 :     nDepth(0) {}
     160             : 
     161           0 : ScOutlineArray::ScOutlineArray( const ScOutlineArray& rArray ) :
     162           0 :     nDepth( rArray.nDepth )
     163             : {
     164           0 :     for (size_t nLevel = 0; nLevel < nDepth; ++nLevel)
     165             :     {
     166           0 :         const ScOutlineCollection& rColl = rArray.aCollections[nLevel];
     167           0 :         ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
     168           0 :         for (; it != itEnd; ++it)
     169             :         {
     170           0 :             const ScOutlineEntry* pEntry = it->second;
     171           0 :             aCollections[nLevel].insert(new ScOutlineEntry(*pEntry));
     172             :         }
     173             :     }
     174           0 : }
     175             : 
     176           0 : void ScOutlineArray::FindEntry(
     177             :     SCCOLROW nSearchPos, size_t& rFindLevel, size_t& rFindIndex,
     178             :     size_t nMaxLevel )
     179             : {
     180           0 :     rFindLevel = rFindIndex = 0;
     181             : 
     182           0 :     if (nMaxLevel > nDepth)
     183           0 :         nMaxLevel = nDepth;
     184             : 
     185           0 :     for (size_t nLevel = 0; nLevel < nMaxLevel; ++nLevel)               //! rueckwaerts suchen ?
     186             :     {
     187           0 :         ScOutlineCollection* pCollect = &aCollections[nLevel];
     188           0 :         ScOutlineCollection::iterator it = pCollect->begin(), itEnd = pCollect->end();
     189           0 :         for (; it != itEnd; ++it)
     190             :         {
     191           0 :             ScOutlineEntry* pEntry = it->second;
     192           0 :             if (pEntry->GetStart() <= nSearchPos && pEntry->GetEnd() >= nSearchPos)
     193             :             {
     194           0 :                 rFindLevel = nLevel + 1;            // naechster Level (zum Einfuegen)
     195           0 :                 rFindIndex = std::distance(pCollect->begin(), it);
     196             :             }
     197             :         }
     198             :     }
     199           0 : }
     200             : 
     201           0 : bool ScOutlineArray::Insert(
     202             :     SCCOLROW nStartCol, SCCOLROW nEndCol, bool& rSizeChanged, bool bHidden, bool bVisible )
     203             : {
     204           0 :     rSizeChanged = false;
     205             : 
     206             :     size_t nStartLevel, nEndLevel, nStartIndex, nEndIndex;
     207           0 :     bool bFound = false;
     208             : 
     209             :     bool bCont;
     210             :     sal_uInt16 nFindMax;
     211           0 :     FindEntry( nStartCol, nStartLevel, nStartIndex );       // nLevel = neuer Level (alter+1) !!!
     212           0 :     FindEntry( nEndCol, nEndLevel, nEndIndex );
     213           0 :     nFindMax = std::max(nStartLevel,nEndLevel);
     214           0 :     do
     215             :     {
     216           0 :         bCont = false;
     217             : 
     218           0 :         if (nStartLevel == nEndLevel && nStartIndex == nEndIndex && nStartLevel < SC_OL_MAXDEPTH)
     219           0 :             bFound = true;
     220             : 
     221           0 :         if (!bFound)
     222             :         {
     223           0 :             if (nFindMax>0)
     224             :             {
     225           0 :                 --nFindMax;
     226           0 :                 if (nStartLevel)
     227             :                 {
     228           0 :                     ScOutlineCollection::const_iterator it = aCollections[nStartLevel-1].begin();
     229           0 :                     std::advance(it, nStartIndex);
     230           0 :                     if (it->second->GetStart() == nStartCol)
     231           0 :                         FindEntry(nStartCol, nStartLevel, nStartIndex, nFindMax);
     232             :                 }
     233             : 
     234           0 :                 if (nEndLevel)
     235             :                 {
     236           0 :                     ScOutlineCollection::const_iterator it = aCollections[nEndLevel-1].begin();
     237           0 :                     std::advance(it, nEndIndex);
     238           0 :                     if (it->second->GetEnd() == nEndCol)
     239           0 :                         FindEntry(nEndCol, nEndLevel, nEndIndex, nFindMax);
     240             :                 }
     241           0 :                 bCont = true;
     242             :             }
     243             :         }
     244             :     }
     245           0 :     while ( !bFound && bCont );
     246             : 
     247           0 :     if (!bFound)
     248           0 :         return false;
     249             : 
     250           0 :     size_t nLevel = nStartLevel;
     251             : 
     252             :     //  untere verschieben
     253             : 
     254           0 :     bool bNeedSize = false;
     255           0 :     if (nDepth > 0)
     256             :     {
     257           0 :         for (size_t nMoveLevel = nDepth-1; nMoveLevel >= nLevel; --nMoveLevel)
     258             :         {
     259           0 :             ScOutlineCollection& rColl = aCollections[nMoveLevel];
     260           0 :             ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
     261           0 :             while (it != itEnd)
     262             :             {
     263           0 :                 ScOutlineEntry* pEntry = it->second;
     264           0 :                 SCCOLROW nEntryStart = pEntry->GetStart();
     265           0 :                 if (nEntryStart >= nStartCol && nEntryStart <= nEndCol)
     266             :                 {
     267           0 :                     if (nMoveLevel >= SC_OL_MAXDEPTH - 1)
     268             :                     {
     269           0 :                         rSizeChanged = false;               // kein Platz
     270           0 :                         return false;
     271             :                     }
     272           0 :                     aCollections[nMoveLevel+1].insert(new ScOutlineEntry(*pEntry));
     273           0 :                     size_t nPos = std::distance(rColl.begin(), it);
     274           0 :                     rColl.erase(it);
     275           0 :                     it = rColl.begin();
     276           0 :                     std::advance(it, nPos);
     277           0 :                     itEnd = rColl.end();
     278           0 :                     if (nMoveLevel == nDepth - 1)
     279           0 :                         bNeedSize = true;
     280             :                 }
     281             :                 else
     282           0 :                     ++it;
     283             :             }
     284           0 :             if (nMoveLevel == 0)
     285           0 :                 break;
     286             :         }
     287             :     }
     288             : 
     289           0 :     if (bNeedSize)
     290             :     {
     291           0 :         ++nDepth;
     292           0 :         rSizeChanged = true;
     293             :     }
     294             : 
     295           0 :     if (nDepth <= nLevel)
     296             :     {
     297           0 :         nDepth = nLevel+1;
     298           0 :         rSizeChanged = true;
     299             :     }
     300             : 
     301           0 :     ScOutlineEntry* pNewEntry = new ScOutlineEntry( nStartCol, nEndCol+1-nStartCol, bHidden );
     302           0 :     pNewEntry->SetVisible( bVisible );
     303           0 :     aCollections[nLevel].insert(pNewEntry);
     304             : 
     305           0 :     return true;
     306             : }
     307             : 
     308           0 : size_t ScOutlineArray::GetDepth() const
     309             : {
     310           0 :     return nDepth;
     311             : }
     312             : 
     313           0 : bool ScOutlineArray::FindTouchedLevel(
     314             :     SCCOLROW nBlockStart, SCCOLROW nBlockEnd, size_t& rFindLevel) const
     315             : {
     316           0 :     bool bFound = false;
     317           0 :     rFindLevel = 0;
     318             : 
     319           0 :     for (size_t nLevel = 0; nLevel < nDepth; ++nLevel)
     320             :     {
     321           0 :         const ScOutlineCollection* pCollect = &aCollections[nLevel];
     322           0 :         ScOutlineCollection::const_iterator it = pCollect->begin(), itEnd = pCollect->end();
     323           0 :         for (; it != itEnd; ++it)
     324             :         {
     325           0 :             const ScOutlineEntry* pEntry = it->second;
     326           0 :             SCCOLROW nStart = pEntry->GetStart();
     327           0 :             SCCOLROW nEnd   = pEntry->GetEnd();
     328             : 
     329           0 :             if ( ( nBlockStart>=nStart && nBlockStart<=nEnd ) ||
     330           0 :                  ( nBlockEnd  >=nStart && nBlockEnd  <=nEnd ) )
     331             :             {
     332           0 :                 rFindLevel = nLevel;            // wirklicher Level
     333           0 :                 bFound = true;
     334             :             }
     335             :         }
     336             :     }
     337             : 
     338           0 :     return bFound;
     339             : }
     340             : 
     341           0 : void ScOutlineArray::RemoveSub(SCCOLROW nStartPos, SCCOLROW nEndPos, size_t nLevel)
     342             : {
     343           0 :     if ( nLevel >= nDepth )
     344           0 :         return;
     345             : 
     346           0 :     ScOutlineCollection& rColl = aCollections[nLevel];
     347             : 
     348           0 :     ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
     349           0 :     while (it != itEnd)
     350             :     {
     351           0 :         ScOutlineEntry* pEntry = it->second;
     352           0 :         SCCOLROW nStart = pEntry->GetStart();
     353           0 :         SCCOLROW nEnd   = pEntry->GetEnd();
     354           0 :         if (nStart >= nStartPos && nEnd <= nEndPos)
     355             :         {
     356             :             // Overlaps.
     357           0 :             RemoveSub( nStart, nEnd, nLevel+1 );
     358             : 
     359             :             // Re-calc iterator positions after the tree gets invalidated.
     360           0 :             size_t nPos = std::distance(rColl.begin(), it);
     361           0 :             rColl.erase(it);
     362           0 :             it = rColl.begin();
     363           0 :             std::advance(it, nPos);
     364           0 :             itEnd = rColl.end();
     365             :         }
     366             :         else
     367           0 :             ++it;
     368             :     }
     369             : 
     370           0 :     it = rColl.begin();
     371           0 :     itEnd = rColl.end();
     372             : 
     373           0 :     while (it != itEnd)
     374             :     {
     375           0 :         ScOutlineEntry* pEntry = it->second;
     376           0 :         SCCOLROW nStart = pEntry->GetStart();
     377           0 :         SCCOLROW nEnd   = pEntry->GetEnd();
     378             : 
     379           0 :         if (nStart >= nStartPos && nEnd <= nEndPos)
     380             :         {
     381           0 :             RemoveSub( nStart, nEnd, nLevel+1 );
     382             : 
     383             :             // Re-calc iterator positions after the tree gets invalidated.
     384           0 :             size_t nPos = std::distance(rColl.begin(), it);
     385           0 :             rColl.erase(it);
     386           0 :             it = rColl.begin();
     387           0 :             std::advance(it, nPos);
     388           0 :             itEnd = rColl.end();
     389             :         }
     390             :         else
     391           0 :             ++it;
     392             :     }
     393             : }
     394             : 
     395           0 : void ScOutlineArray::PromoteSub(SCCOLROW nStartPos, SCCOLROW nEndPos, size_t nStartLevel)
     396             : {
     397           0 :     if (nStartLevel==0)
     398             :     {
     399             :         OSL_FAIL("PromoteSub mit Level 0");
     400           0 :         return;
     401             :     }
     402             : 
     403           0 :     for (size_t nLevel = nStartLevel; nLevel < nDepth; ++nLevel)
     404             :     {
     405           0 :         ScOutlineCollection& rColl = aCollections[nLevel];
     406           0 :         ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
     407           0 :         while (it != itEnd)
     408             :         {
     409           0 :             ScOutlineEntry* pEntry = it->second;
     410           0 :             SCCOLROW nStart = pEntry->GetStart();
     411           0 :             SCCOLROW nEnd   = pEntry->GetEnd();
     412           0 :             if (nStart >= nStartPos && nEnd <= nEndPos)
     413             :             {
     414           0 :                 aCollections[nLevel-1].insert(new ScOutlineEntry(*pEntry));
     415             : 
     416             :                 // Re-calc iterator positions after the tree gets invalidated.
     417           0 :                 size_t nPos = std::distance(rColl.begin(), it);
     418           0 :                 rColl.erase(it);
     419           0 :                 it = rColl.begin();
     420           0 :                 std::advance(it, nPos);
     421           0 :                 itEnd = rColl.end();
     422             :             }
     423             :             else
     424           0 :                 ++it;
     425             :         }
     426             : 
     427           0 :         it = rColl.begin();
     428           0 :         itEnd = rColl.end();
     429             : 
     430           0 :         while (it != itEnd)
     431             :         {
     432           0 :             ScOutlineEntry* pEntry = it->second;
     433           0 :             SCCOLROW nStart = pEntry->GetStart();
     434           0 :             SCCOLROW nEnd   = pEntry->GetEnd();
     435           0 :             if (nStart >= nStartPos && nEnd <= nEndPos)
     436             :             {
     437           0 :                 aCollections[nLevel-1].insert(new ScOutlineEntry(*pEntry));
     438             : 
     439             :                 // Re-calc iterator positions after the tree gets invalidated.
     440           0 :                 size_t nPos = std::distance(rColl.begin(), it);
     441           0 :                 rColl.erase(it);
     442           0 :                 it = rColl.begin();
     443           0 :                 std::advance(it, nPos);
     444           0 :                 itEnd = rColl.end();
     445             :             }
     446             :             else
     447           0 :                 ++it;
     448             :         }
     449             :     }
     450             : }
     451             : 
     452           0 : bool ScOutlineArray::DecDepth()                         // nDepth auf leere Levels anpassen
     453             : {
     454           0 :     bool bChanged = false;
     455             :     bool bCont;
     456           0 :     do
     457             :     {
     458           0 :         bCont = false;
     459           0 :         if (nDepth)
     460             :         {
     461           0 :             if (aCollections[nDepth-1].empty())
     462             :             {
     463           0 :                 --nDepth;
     464           0 :                 bChanged = true;
     465           0 :                 bCont = true;
     466             :             }
     467             :         }
     468             :     }
     469             :     while (bCont);
     470             : 
     471           0 :     return bChanged;
     472             : }
     473             : 
     474           0 : bool ScOutlineArray::Remove( SCCOLROW nBlockStart, SCCOLROW nBlockEnd, bool& rSizeChanged )
     475             : {
     476             :     size_t nLevel;
     477           0 :     FindTouchedLevel( nBlockStart, nBlockEnd, nLevel );
     478             : 
     479           0 :     ScOutlineCollection* pCollect = &aCollections[nLevel];
     480           0 :     ScOutlineCollection::iterator it = pCollect->begin(), itEnd = pCollect->end();
     481           0 :     bool bAny = false;
     482           0 :     while (it != itEnd)
     483             :     {
     484           0 :         ScOutlineEntry* pEntry = it->second;
     485           0 :         SCCOLROW nStart = pEntry->GetStart();
     486           0 :         SCCOLROW nEnd   = pEntry->GetEnd();
     487           0 :         if (nBlockStart <= nEnd && nBlockEnd >= nStart)
     488             :         {
     489             :             // Overlaps.
     490           0 :             pCollect->erase(it);
     491           0 :             PromoteSub( nStart, nEnd, nLevel+1 );
     492           0 :             itEnd = pCollect->end();
     493           0 :             it = pCollect->FindStart( nEnd+1 );
     494           0 :             bAny = true;
     495             :         }
     496             :         else
     497           0 :             ++it;
     498             :     }
     499             : 
     500           0 :     if (bAny)                                   // Depth anpassen
     501           0 :         if (DecDepth())
     502           0 :             rSizeChanged = true;
     503             : 
     504           0 :     return bAny;
     505             : }
     506             : 
     507           0 : ScOutlineEntry* ScOutlineArray::GetEntry(size_t nLevel, size_t nIndex)
     508             : {
     509           0 :     if (nLevel >= nDepth)
     510           0 :         return NULL;
     511             : 
     512           0 :     ScOutlineCollection& rColl = aCollections[nLevel];
     513           0 :     if (nIndex >= rColl.size())
     514           0 :         return NULL;
     515             : 
     516           0 :     ScOutlineCollection::iterator it = rColl.begin();
     517           0 :     std::advance(it, nIndex);
     518           0 :     return it->second;
     519             : }
     520             : 
     521           0 : const ScOutlineEntry* ScOutlineArray::GetEntry(size_t nLevel, size_t nIndex) const
     522             : {
     523           0 :     if (nLevel >= nDepth)
     524           0 :         return NULL;
     525             : 
     526           0 :     const ScOutlineCollection& rColl = aCollections[nLevel];
     527           0 :     if (nIndex >= rColl.size())
     528           0 :         return NULL;
     529             : 
     530           0 :     ScOutlineCollection::const_iterator it = rColl.begin();
     531           0 :     std::advance(it, nIndex);
     532           0 :     return it->second;
     533             : }
     534             : 
     535           0 : size_t ScOutlineArray::GetCount(size_t nLevel) const
     536             : {
     537           0 :     if (nLevel >= nDepth)
     538           0 :         return 0;
     539             : 
     540           0 :     return aCollections[nLevel].size();
     541             : }
     542             : 
     543           0 : const ScOutlineEntry* ScOutlineArray::GetEntryByPos(size_t nLevel, SCCOLROW nPos) const
     544             : {
     545           0 :     if (nLevel >= nDepth)
     546           0 :         return NULL;
     547             : 
     548           0 :     const ScOutlineCollection& rColl = aCollections[nLevel];
     549           0 :     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
     550           0 :     for (; it != itEnd; ++it)
     551             :     {
     552           0 :         const ScOutlineEntry* pEntry = it->second;
     553           0 :         if (pEntry->GetStart() <= nPos && nPos <= pEntry->GetEnd())
     554           0 :             return pEntry;
     555             :     }
     556             : 
     557           0 :     return NULL;
     558             : }
     559             : 
     560           0 : bool ScOutlineArray::GetEntryIndex(size_t nLevel, SCCOLROW nPos, size_t& rnIndex) const
     561             : {
     562           0 :     if (nLevel >= nDepth)
     563           0 :         return false;
     564             : 
     565             :     // found entry contains passed position
     566           0 :     const ScOutlineCollection& rColl = aCollections[nLevel];
     567           0 :     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
     568           0 :     for (; it != itEnd; ++it)
     569             :     {
     570           0 :         const ScOutlineEntry* p = it->second;
     571           0 :         if (p->GetStart() <= nPos && nPos <= p->GetEnd())
     572             :         {
     573           0 :             rnIndex = std::distance(rColl.begin(), it);
     574           0 :             return true;
     575             :         }
     576             :     }
     577           0 :     return false;
     578             : }
     579             : 
     580           0 : bool ScOutlineArray::GetEntryIndexInRange(
     581             :     size_t nLevel, SCCOLROW nBlockStart, SCCOLROW nBlockEnd, size_t& rnIndex) const
     582             : {
     583           0 :     if (nLevel >= nDepth)
     584           0 :         return false;
     585             : 
     586             :     // found entry will be completely inside of passed range
     587           0 :     const ScOutlineCollection& rColl = aCollections[nLevel];
     588           0 :     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
     589           0 :     for (; it != itEnd; ++it)
     590             :     {
     591           0 :         const ScOutlineEntry* p = it->second;
     592           0 :         if (nBlockStart <= p->GetStart() && p->GetEnd() <= nBlockEnd)
     593             :         {
     594           0 :             rnIndex = std::distance(rColl.begin(), it);
     595           0 :             return true;
     596             :         }
     597             :     }
     598           0 :     return false;
     599             : }
     600             : 
     601           0 : void ScOutlineArray::SetVisibleBelow(
     602             :     size_t nLevel, size_t nEntry, bool bValue, bool bSkipHidden)
     603             : {
     604           0 :     const ScOutlineEntry* pEntry = GetEntry( nLevel, nEntry );
     605           0 :     if (!pEntry)
     606           0 :         return;
     607             : 
     608           0 :     SCCOLROW nStart = pEntry->GetStart();
     609           0 :     SCCOLROW nEnd   = pEntry->GetEnd();
     610             : 
     611           0 :     for (size_t nSubLevel = nLevel+1; nSubLevel < nDepth; ++nSubLevel)
     612             :     {
     613           0 :         ScOutlineCollection& rColl = aCollections[nSubLevel];
     614           0 :         ScOutlineCollection::iterator it = rColl.begin(), itEnd = rColl.end();
     615           0 :         for (; it != itEnd; ++it)
     616             :         {
     617           0 :             ScOutlineEntry* p = it->second;
     618           0 :             if (p->GetStart() >= nStart && p->GetEnd() <= nEnd)
     619             :             {
     620           0 :                 p->SetVisible(bValue);
     621           0 :                 if (bSkipHidden && !p->IsHidden())
     622             :                 {
     623           0 :                     size_t nPos = std::distance(rColl.begin(), it);
     624           0 :                     SetVisibleBelow(nSubLevel, nPos, bValue, true);
     625             :                 }
     626             :             }
     627             :         }
     628             : 
     629           0 :         if (bSkipHidden)
     630           0 :             nSubLevel = nDepth;             // Abbruch
     631             :     }
     632             : }
     633             : 
     634           0 : void ScOutlineArray::GetRange(SCCOLROW& rStart, SCCOLROW& rEnd) const
     635             : {
     636           0 :     const ScOutlineCollection& rColl = aCollections[0];
     637           0 :     if (!rColl.empty())
     638             :     {
     639           0 :         ScOutlineCollection::const_iterator it = rColl.begin();
     640           0 :         rStart = it->second->GetStart();
     641           0 :         std::advance(it, rColl.size()-1);
     642           0 :         rEnd = it->second->GetEnd();
     643             :     }
     644             :     else
     645           0 :         rStart = rEnd = 0;
     646           0 : }
     647             : 
     648           0 : void ScOutlineArray::ExtendBlock(size_t nLevel, SCCOLROW& rBlkStart, SCCOLROW& rBlkEnd)
     649             : {
     650           0 :     if (nLevel >= nDepth)
     651           0 :         return;
     652             : 
     653           0 :     const ScOutlineCollection& rColl = aCollections[nLevel];
     654           0 :     ScOutlineCollection::const_iterator it = rColl.begin(), itEnd = rColl.end();
     655           0 :     for (; it != itEnd; ++it)
     656             :     {
     657           0 :         const ScOutlineEntry* pEntry = it->second;
     658           0 :         SCCOLROW nStart = pEntry->GetStart();
     659           0 :         SCCOLROW nEnd   = pEntry->GetEnd();
     660             : 
     661           0 :         if (rBlkStart <= nEnd && rBlkEnd >= nStart)
     662             :         {
     663           0 :             if (nStart < rBlkStart)
     664           0 :                 rBlkStart = nStart;
     665           0 :             if (nEnd > rBlkEnd)
     666           0 :                 rBlkEnd = nEnd;
     667             :         }
     668             :     }
     669             : }
     670             : 
     671           0 : bool ScOutlineArray::TestInsertSpace(SCSIZE nSize, SCCOLROW nMaxVal) const
     672             : {
     673           0 :     const ScOutlineCollection& rColl = aCollections[0];
     674           0 :     if (rColl.empty())
     675           0 :         return true;
     676             : 
     677           0 :     ScOutlineCollection::const_iterator it = rColl.begin();
     678           0 :     std::advance(it, rColl.size()-1);
     679           0 :     SCCOLROW nEnd = it->second->GetEnd();
     680           0 :     return sal::static_int_cast<SCCOLROW>(nEnd+nSize) <= nMaxVal;
     681             : }
     682             : 
     683           0 : void ScOutlineArray::InsertSpace(SCCOLROW nStartPos, SCSIZE nSize)
     684             : {
     685           0 :     ScSubOutlineIterator aIter( this );
     686             :     ScOutlineEntry* pEntry;
     687           0 :     while ((pEntry = aIter.GetNext()) != NULL)
     688             :     {
     689           0 :         if ( pEntry->GetStart() >= nStartPos )
     690           0 :             pEntry->Move(static_cast<SCsCOLROW>(nSize));
     691             :         else
     692             :         {
     693           0 :             SCCOLROW nEnd = pEntry->GetEnd();
     694             :             //  immer erweitern, wenn innerhalb der Gruppe eingefuegt
     695             :             //  beim Einfuegen am Ende nur, wenn die Gruppe nicht ausgeblendet ist
     696           0 :             if ( nEnd >= nStartPos || ( nEnd+1 >= nStartPos && !pEntry->IsHidden() ) )
     697             :             {
     698           0 :                 SCSIZE nEntrySize = pEntry->GetSize();
     699           0 :                 nEntrySize += nSize;
     700           0 :                 pEntry->SetSize( nEntrySize );
     701             :             }
     702             :         }
     703             :     }
     704           0 : }
     705             : 
     706           0 : bool ScOutlineArray::DeleteSpace(SCCOLROW nStartPos, SCSIZE nSize)
     707             : {
     708           0 :     SCCOLROW nEndPos = nStartPos + nSize - 1;
     709           0 :     sal_Bool bNeedSave = false;                         // Original fuer Undo benoetigt?
     710           0 :     sal_Bool bChanged = false;                          // fuer Test auf Level
     711             : 
     712           0 :     ScSubOutlineIterator aIter( this );
     713             :     ScOutlineEntry* pEntry;
     714           0 :     while((pEntry=aIter.GetNext())!=NULL)
     715             :     {
     716           0 :         SCCOLROW nEntryStart = pEntry->GetStart();
     717           0 :         SCCOLROW nEntryEnd   = pEntry->GetEnd();
     718           0 :         SCSIZE nEntrySize    = pEntry->GetSize();
     719             : 
     720           0 :         if ( nEntryEnd >= nStartPos )
     721             :         {
     722           0 :             if ( nEntryStart > nEndPos )                                        // rechts
     723           0 :                 pEntry->Move(-(static_cast<SCsCOLROW>(nSize)));
     724           0 :             else if ( nEntryStart < nStartPos && nEntryEnd >= nEndPos )         // aussen
     725           0 :                 pEntry->SetSize( nEntrySize-nSize );
     726             :             else
     727             :             {
     728           0 :                 bNeedSave = true;
     729           0 :                 if ( nEntryStart >= nStartPos && nEntryEnd <= nEndPos )             // innen
     730             :                 {
     731           0 :                     aIter.DeleteLast();
     732           0 :                     bChanged = true;
     733             :                 }
     734           0 :                 else if ( nEntryStart >= nStartPos )                                // rechts ueber
     735           0 :                     pEntry->SetPosSize( nStartPos, static_cast<SCSIZE>(nEntryEnd-nEndPos) );
     736             :                 else                                                                // links ueber
     737           0 :                     pEntry->SetSize( static_cast<SCSIZE>(nStartPos-nEntryStart) );
     738             :             }
     739             :         }
     740             :     }
     741             : 
     742           0 :     if (bChanged)
     743           0 :         DecDepth();
     744             : 
     745           0 :     return bNeedSave;
     746             : }
     747             : 
     748           0 : bool ScOutlineArray::ManualAction(
     749             :     SCCOLROW nStartPos, SCCOLROW nEndPos, bool bShow, const ScTable& rTable, bool bCol)
     750             : {
     751           0 :     bool bModified = false;
     752           0 :     ScSubOutlineIterator aIter( this );
     753             :     ScOutlineEntry* pEntry;
     754           0 :     while((pEntry=aIter.GetNext())!=NULL)
     755             :     {
     756           0 :         SCCOLROW nEntryStart = pEntry->GetStart();
     757           0 :         SCCOLROW nEntryEnd   = pEntry->GetEnd();
     758             : 
     759           0 :         if (nEntryEnd>=nStartPos && nEntryStart<=nEndPos)
     760             :         {
     761           0 :             if ( pEntry->IsHidden() == bShow )
     762             :             {
     763             :                 //  #i12341# hide if all columns/rows are hidden, show if at least one
     764             :                 //  is visible
     765           0 :                 SCCOLROW nEnd = rTable.LastHiddenColRow(nEntryStart, bCol);
     766           0 :                 bool bAllHidden = (nEntryEnd <= nEnd && nEnd <
     767           0 :                         ::std::numeric_limits<SCCOLROW>::max());
     768             : 
     769           0 :                 bool bToggle = ( bShow != bAllHidden );
     770           0 :                 if ( bToggle )
     771             :                 {
     772           0 :                     pEntry->SetHidden( !bShow );
     773           0 :                     SetVisibleBelow( aIter.LastLevel(), aIter.LastEntry(), bShow, bShow );
     774           0 :                     bModified = true;
     775             :                 }
     776             :             }
     777             :         }
     778             :     }
     779           0 :     return bModified;
     780             : }
     781             : 
     782           0 : void ScOutlineArray::RemoveAll()
     783             : {
     784           0 :     for (size_t nLevel = 0; nLevel < nDepth; ++nLevel)
     785           0 :         aCollections[nLevel].clear();
     786             : 
     787           0 :     nDepth = 0;
     788           0 : }
     789             : 
     790           0 : ScOutlineTable::ScOutlineTable()
     791             : {
     792           0 : }
     793             : 
     794           0 : ScOutlineTable::ScOutlineTable( const ScOutlineTable& rOutline ) :
     795             :     aColOutline( rOutline.aColOutline ),
     796           0 :     aRowOutline( rOutline.aRowOutline )
     797             : {
     798           0 : }
     799             : 
     800           0 : bool ScOutlineTable::TestInsertCol( SCSIZE nSize )
     801             : {
     802           0 :     return aColOutline.TestInsertSpace( nSize, MAXCOL );
     803             : }
     804             : 
     805           0 : void ScOutlineTable::InsertCol( SCCOL nStartCol, SCSIZE nSize )
     806             : {
     807           0 :     aColOutline.InsertSpace( nStartCol, nSize );
     808           0 : }
     809             : 
     810           0 : bool ScOutlineTable::DeleteCol( SCCOL nStartCol, SCSIZE nSize )
     811             : {
     812           0 :     return aColOutline.DeleteSpace( nStartCol, nSize );
     813             : }
     814             : 
     815           0 : bool ScOutlineTable::TestInsertRow( SCSIZE nSize )
     816             : {
     817           0 :     return aRowOutline.TestInsertSpace( nSize, MAXROW );
     818             : }
     819             : 
     820           0 : void ScOutlineTable::InsertRow( SCROW nStartRow, SCSIZE nSize )
     821             : {
     822           0 :     aRowOutline.InsertSpace( nStartRow, nSize );
     823           0 : }
     824             : 
     825           0 : bool ScOutlineTable::DeleteRow( SCROW nStartRow, SCSIZE nSize )
     826             : {
     827           0 :     return aRowOutline.DeleteSpace( nStartRow, nSize );
     828             : }
     829             : 
     830           0 : ScSubOutlineIterator::ScSubOutlineIterator( ScOutlineArray* pOutlineArray ) :
     831             :         pArray( pOutlineArray ),
     832             :         nStart( 0 ),
     833             :         nEnd( SCCOLROW_MAX ),                           // alle durchgehen
     834             :         nSubLevel( 0 ),
     835           0 :         nSubEntry( 0 )
     836             : {
     837           0 :     nDepth = pArray->nDepth;
     838           0 : }
     839             : 
     840           0 : ScSubOutlineIterator::ScSubOutlineIterator(
     841             :     ScOutlineArray* pOutlineArray, size_t nLevel, size_t nEntry ) :
     842           0 :         pArray( pOutlineArray )
     843             : {
     844           0 :     const ScOutlineCollection& rColl = pArray->aCollections[nLevel];
     845           0 :     ScOutlineCollection::const_iterator it = rColl.begin();
     846           0 :     std::advance(it, nEntry);
     847           0 :     const ScOutlineEntry* pEntry = it->second;
     848           0 :     nStart = pEntry->GetStart();
     849           0 :     nEnd   = pEntry->GetEnd();
     850           0 :     nSubLevel = nLevel + 1;
     851           0 :     nSubEntry = 0;
     852           0 :     nDepth = pArray->nDepth;
     853           0 : }
     854             : 
     855           0 : ScOutlineEntry* ScSubOutlineIterator::GetNext()
     856             : {
     857           0 :     ScOutlineEntry* pEntry = NULL;
     858           0 :     bool bFound = false;
     859           0 :     do
     860             :     {
     861           0 :         if (nSubLevel >= nDepth)
     862           0 :             return NULL;
     863             : 
     864           0 :         ScOutlineCollection& rColl = pArray->aCollections[nSubLevel];
     865           0 :         if (nSubEntry < rColl.size())
     866             :         {
     867           0 :             ScOutlineCollection::iterator it = rColl.begin();
     868           0 :             std::advance(it, nSubEntry);
     869           0 :             pEntry = it->second;
     870             : 
     871           0 :             if (pEntry->GetStart() >= nStart && pEntry->GetEnd() <= nEnd)
     872           0 :                 bFound = true;
     873             : 
     874           0 :             ++nSubEntry;
     875             :         }
     876             :         else
     877             :         {
     878             :             // Go to the next sub-level.
     879           0 :             nSubEntry = 0;
     880           0 :             ++nSubLevel;
     881             :         }
     882             :     }
     883           0 :     while (!bFound);
     884           0 :     return pEntry;                  // nSubLevel gueltig, wenn pEntry != 0
     885             : }
     886             : 
     887           0 : size_t ScSubOutlineIterator::LastLevel() const
     888             : {
     889           0 :     return nSubLevel;
     890             : }
     891             : 
     892           0 : size_t ScSubOutlineIterator::LastEntry() const
     893             : {
     894           0 :     if (nSubEntry == 0)
     895             :     {
     896             :         OSL_FAIL("ScSubOutlineIterator::LastEntry before GetNext");
     897           0 :         return 0;
     898             :     }
     899           0 :     return nSubEntry-1;
     900             : }
     901             : 
     902           0 : void ScSubOutlineIterator::DeleteLast()
     903             : {
     904           0 :     if (nSubLevel >= nDepth)
     905             :     {
     906             :         OSL_FAIL("ScSubOutlineIterator::DeleteLast after End");
     907           0 :         return;
     908             :     }
     909           0 :     if (nSubEntry == 0)
     910             :     {
     911             :         OSL_FAIL("ScSubOutlineIterator::DeleteLast before GetNext");
     912           0 :         return;
     913             :     }
     914             : 
     915           0 :     --nSubEntry;
     916           0 :     ScOutlineCollection& rColl = pArray->aCollections[nSubLevel];
     917             :     OSL_ASSERT(nSubEntry < rColl.size());
     918           0 :     ScOutlineCollection::iterator it = rColl.begin();
     919           0 :     std::advance(it, nSubEntry);
     920           0 :     rColl.erase(it);
     921           0 : }
     922             : 
     923             : 
     924             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10