LCOV - code coverage report
Current view: top level - sc/source/core/data - table5.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 506 644 78.6 %
Date: 2014-11-03 Functions: 56 60 93.3 %
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 "scitems.hxx"
      21             : #include "attrib.hxx"
      22             : #include "patattr.hxx"
      23             : #include "docpool.hxx"
      24             : #include "formulacell.hxx"
      25             : #include "table.hxx"
      26             : #include "column.hxx"
      27             : #include "document.hxx"
      28             : #include "drwlayer.hxx"
      29             : #include "olinetab.hxx"
      30             : #include "userlist.hxx"
      31             : #include "stlsheet.hxx"
      32             : #include "global.hxx"
      33             : #include "rechead.hxx"
      34             : #include "stlpool.hxx"
      35             : #include "brdcst.hxx"
      36             : #include "tabprotection.hxx"
      37             : #include "globstr.hrc"
      38             : #include "segmenttree.hxx"
      39             : #include "columniterator.hxx"
      40             : #include "globalnames.hxx"
      41             : #include "scmod.hxx"
      42             : #include "printopt.hxx"
      43             : 
      44             : #include <com/sun/star/sheet/TablePageBreakData.hpp>
      45             : 
      46             : #include <algorithm>
      47             : #include <limits>
      48             : #include <iostream>
      49             : 
      50             : using ::com::sun::star::uno::Sequence;
      51             : using ::com::sun::star::sheet::TablePageBreakData;
      52             : using ::std::set;
      53             : 
      54             : // STATIC DATA -----------------------------------------------------------
      55             : 
      56             : #define GET_SCALEVALUE(set,id)  static_cast<const SfxUInt16Item&>(set.Get( id )).GetValue()
      57             : 
      58        5660 : void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
      59             : {
      60        5660 :     if ( pDocument->IsImportingXML() )
      61       10802 :         return;
      62             : 
      63             :     // pUserArea != NULL -> print area is specified.  We need to force-update
      64             :     // the page breaks.
      65             : 
      66         438 :     if (!pUserArea)
      67             :     {
      68         434 :         if (!bPageSizeValid)
      69         158 :             return;
      70             : 
      71             :         // Always update breaks if force breaks option has changed
      72         276 :         if (mbPageBreaksValid && mbForceBreaks == SC_MOD()->GetPrintOptions().GetForceBreaks())
      73         200 :             return;
      74             :     }
      75             : 
      76          80 :     SfxStyleSheetBase* pStyle = pDocument->GetStyleSheetPool()->
      77          80 :                                     Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
      78          80 :     if ( !pStyle )
      79             :     {
      80             :         OSL_FAIL("UpdatePageBreaks: Style not found");
      81           0 :         return;
      82             :     }
      83          80 :     SfxItemSet* pStyleSet = &pStyle->GetItemSet();
      84             :     const SfxPoolItem* pItem;
      85             : 
      86             :     SCCOL nX;
      87          80 :     SCCOL nStartCol = 0;
      88          80 :     SCROW nStartRow = 0;
      89          80 :     SCCOL nEndCol = MAXCOL;
      90          80 :     SCROW nEndRow = MAXROW;
      91          80 :     if (pUserArea)
      92             :     {
      93           4 :         nStartCol = pUserArea->aStart.Col();
      94           4 :         nStartRow = pUserArea->aStart.Row();
      95           4 :         nEndCol = pUserArea->aEnd.Col();
      96           4 :         nEndRow = pUserArea->aEnd.Row();
      97             :     }
      98             :     else
      99             :     {
     100          76 :         sal_uInt16 nAreaCount = GetPrintRangeCount();
     101          76 :         if ( nAreaCount > 1 )
     102             :         {
     103             :             //  bei mehreren Bereichen nichts anzeigen:
     104             : 
     105           0 :             for (nX=0; nX<MAXCOL; nX++)
     106           0 :                 RemoveColBreak(nX, true, false);
     107             : 
     108           0 :             RemoveRowPageBreaks(0, MAXROW-1);
     109             : 
     110           0 :             return;
     111             :         }
     112          76 :         else if ( nAreaCount == 1 )
     113             :         {
     114           8 :             const ScRange* pArea = GetPrintRange( 0 );
     115           8 :             if (pArea)
     116             :             {
     117           8 :                 nStartCol = pArea->aStart.Col();
     118           8 :                 nStartRow = pArea->aStart.Row();
     119           8 :                 nEndCol = pArea->aEnd.Col();
     120           8 :                 nEndRow = pArea->aEnd.Row();
     121             :             }
     122             :         }           // sonst alles
     123             :     }
     124             : 
     125             :     // get bSkipColBreaks/bSkipRowBreaks flags:
     126             :     // fdo#40788 - print range scale settings can cause manual breaks to be
     127             :     // ignored (see below). This behaviour may now be set by the user.
     128          80 :     mbForceBreaks = SC_MOD()->GetPrintOptions().GetForceBreaks();
     129          80 :     bool bSkipColBreaks = false;
     130          80 :     bool bSkipRowBreaks = false;
     131             : 
     132          80 :     if (!mbForceBreaks)
     133             :     {
     134          80 :          if ( pStyleSet->GetItemState( ATTR_PAGE_SCALETOPAGES, false, &pItem ) == SfxItemState::SET )
     135             :          {
     136             :               OSL_ENSURE( pItem->ISA(SfxUInt16Item), "invalid Item" );
     137           0 :               bSkipColBreaks = bSkipRowBreaks = static_cast<const SfxUInt16Item*>(pItem)->GetValue() > 0;
     138             :          }
     139             : 
     140          80 :          if ( !bSkipColBreaks && pStyleSet->GetItemState(ATTR_PAGE_SCALETO, false, &pItem) == SfxItemState::SET )
     141             :          {
     142             :               // #i54993# when fitting to width or height, ignore only manual breaks in that direction
     143           0 :               const ScPageScaleToItem* pScaleToItem = static_cast<const ScPageScaleToItem*>(pItem);
     144           0 :               if ( pScaleToItem->GetWidth() > 0 )
     145           0 :                    bSkipColBreaks = true;
     146           0 :               if ( pScaleToItem->GetHeight() > 0 )
     147           0 :                    bSkipRowBreaks = true;
     148             :          }
     149             :     }
     150             : 
     151          80 :     long nPageSizeX = aPageSizeTwips.Width();
     152          80 :     long nPageSizeY = aPageSizeTwips.Height();
     153             : 
     154             :         //  Anfang: Breaks loeschen
     155             : 
     156          80 :     for (nX=0; nX<nStartCol; nX++)
     157           0 :         RemoveColBreak(nX, true, false);
     158          80 :     RemoveRowPageBreaks(0, nStartRow-1);
     159             : 
     160          80 :     if (nStartCol > 0)
     161           0 :         SetColBreak(nStartCol, true, false);  // AREABREAK
     162          80 :     if (nStartRow > 0)
     163           0 :         SetRowBreak(nStartRow, true, false);  // AREABREAK
     164             : 
     165             :         //  Mittelteil: Breaks verteilen
     166             : 
     167          80 :     bool bRepeatCol = ( nRepeatStartX != SCCOL_REPEAT_NONE );
     168          80 :     bool bColFound = false;
     169          80 :     long nSizeX = 0;
     170       69888 :     for (nX=nStartCol; nX<=nEndCol; nX++)
     171             :     {
     172       69808 :         bool bStartOfPage = false;
     173       69808 :         long nThisX = ColHidden(nX) ? 0 : pColWidth[nX];
     174       69808 :         bool bManualBreak = HasColManualBreak(nX);
     175       69808 :         if ( (nSizeX+nThisX > nPageSizeX) || (bManualBreak && !bSkipColBreaks) )
     176             :         {
     177        9966 :             SetColBreak(nX, true, false);
     178        9966 :             nSizeX = 0;
     179        9966 :             bStartOfPage = true;
     180             :         }
     181       59842 :         else if (nX != nStartCol)
     182       59762 :             RemoveColBreak(nX, true, false);
     183             :         else
     184          80 :             bStartOfPage = true;
     185             : 
     186       69808 :         if ( bStartOfPage && bRepeatCol && nX>nRepeatStartX && !bColFound )
     187             :         {
     188             :             // subtract size of repeat columns from page size
     189          12 :             for (SCCOL i=nRepeatStartX; i<=nRepeatEndX; i++)
     190           6 :                 nPageSizeX -= ColHidden(i) ? 0 : pColWidth[i];
     191          12 :             while (nX<=nRepeatEndX)
     192           0 :                 RemoveColBreak(++nX, true, false);
     193           6 :             bColFound = true;
     194             :         }
     195             : 
     196       69808 :         nSizeX += nThisX;
     197             :     }
     198             : 
     199             :     // Remove all page breaks in range.
     200          80 :     RemoveRowPageBreaks(nStartRow+1, nEndRow);
     201             : 
     202             :     // And set new page breaks.
     203          80 :     bool bRepeatRow = ( nRepeatStartY != SCROW_REPEAT_NONE );
     204          80 :     bool bRowFound = false;
     205          80 :     long nSizeY = 0;
     206          80 :     ScFlatBoolRowSegments::ForwardIterator aIterHidden(*mpHiddenRows);
     207          80 :     ScFlatUInt16RowSegments::ForwardIterator aIterHeights(*mpRowHeights);
     208          80 :     SCROW nNextManualBreak = GetNextManualBreak(nStartRow); // -1 => no more manual breaks
     209     1421730 :     for (SCROW nY = nStartRow; nY <= nEndRow; ++nY)
     210             :     {
     211     1421650 :         bool bStartOfPage = false;
     212     1421650 :         bool bThisRowHidden = false;
     213     1421650 :         aIterHidden.getValue(nY, bThisRowHidden);
     214     1421650 :         long nThisY = 0;
     215     1421650 :         if (!bThisRowHidden)
     216             :         {
     217             :             sal_uInt16 nTmp;
     218     1421626 :             aIterHeights.getValue(nY, nTmp);
     219     1421626 :             nThisY = static_cast<long>(nTmp);
     220             :         }
     221             : 
     222     1421650 :         bool bManualBreak = false;
     223     1421650 :         if (nNextManualBreak >= 0)
     224             :         {
     225          16 :             bManualBreak = (nY == nNextManualBreak);
     226          16 :             if (nY >= nNextManualBreak)
     227             :                 // Query the next menual break position.
     228           4 :                 nNextManualBreak = GetNextManualBreak(nY+1);
     229             :         }
     230             : 
     231     1421650 :         if ( (nSizeY+nThisY > nPageSizeY) || (bManualBreak && !bSkipRowBreaks) )
     232             :         {
     233     1421350 :             SetRowBreak(nY, true, false);
     234     1421350 :             nSizeY = 0;
     235     1421350 :             bStartOfPage = true;
     236             :         }
     237         300 :         else if (nY != nStartRow)
     238             :             ; // page break already removed
     239             :         else
     240          80 :             bStartOfPage = true;
     241             : 
     242     1421650 :         if ( bStartOfPage && bRepeatRow && nY>nRepeatStartY && !bRowFound )
     243             :         {
     244             :             // subtract size of repeat rows from page size
     245           6 :             unsigned long nHeights = GetTotalRowHeight(nRepeatStartY, nRepeatEndY);
     246             : #if OSL_DEBUG_LEVEL > 0
     247             :             if (nHeights == ::std::numeric_limits<unsigned long>::max())
     248             :                 OSL_FAIL("ScTable::UpdatePageBreaks: row heights overflow");
     249             : #endif
     250           6 :             nPageSizeY -= nHeights;
     251           6 :             if (nY <= nRepeatEndY)
     252           0 :                 RemoveRowPageBreaks(nY, nRepeatEndY);
     253           6 :             bRowFound = true;
     254             :         }
     255             : 
     256     1421650 :         if (bThisRowHidden)
     257             :         {
     258             :             // Hidden row range.  Skip them unless there is a manual break.
     259          24 :             SCROW nLastCommon = aIterHidden.getLastPos();
     260          24 :             if (nNextManualBreak >= 0)
     261           0 :                 nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
     262          24 :             nY = nLastCommon;
     263             :         }
     264             :         else
     265             :         {
     266             :             // Visible row range.
     267             : 
     268     1421626 :             SCROW nLastHidden = aIterHidden.getLastPos();
     269     1421626 :             SCROW nLastHeight = aIterHeights.getLastPos();
     270     1421626 :             SCROW nLastCommon = ::std::min(nLastHidden, nLastHeight);
     271     1421626 :             if (nNextManualBreak >= 0)
     272          12 :                 nLastCommon = ::std::min(nLastCommon, nNextManualBreak-1);
     273             : 
     274     1421626 :             if (nLastCommon > nY)
     275             :             {
     276     1421482 :                 long nMaxMultiple = static_cast<long>(nLastCommon - nY);
     277     1421482 :                 long nMultiple = (nPageSizeY - nSizeY) / nThisY;
     278     1421482 :                 if (nMultiple > nMaxMultiple)
     279         124 :                     nMultiple = nMaxMultiple;
     280     1421482 :                 if (nMultiple > 1)
     281             :                 {
     282     1421478 :                     nSizeY += nThisY * (nMultiple - 1);
     283     1421478 :                     nY += nMultiple - 1;
     284             :                 }
     285             :             }
     286             :         }
     287             : 
     288     1421650 :         nSizeY += nThisY;
     289             :     }
     290             : 
     291             :         //  Ende: Breaks loeschen
     292             : 
     293          80 :     if (nEndCol < MAXCOL)
     294             :     {
     295          12 :         SetColBreak(nEndCol+1, true, false);  // AREABREAK
     296       12112 :         for (nX=nEndCol+2; nX<=MAXCOL; nX++)
     297       12100 :             RemoveColBreak(nX, true, false);
     298             :     }
     299          80 :     if (nEndRow < MAXROW)
     300             :     {
     301          12 :         SetRowBreak(nEndRow+1, true, false);  // AREABREAK
     302          12 :         if (nEndRow+2 <= MAXROW)
     303          12 :             RemoveRowPageBreaks(nEndRow+2, MAXROW);
     304             :     }
     305          80 :     mbPageBreaksValid = !pUserArea;     // #i116881# the valid flag can only apply to the "no user area" case
     306             : }
     307             : 
     308           0 : void ScTable::RemoveManualBreaks()
     309             : {
     310           0 :     maRowManualBreaks.clear();
     311           0 :     maColManualBreaks.clear();
     312           0 :     InvalidatePageBreaks();
     313             : 
     314           0 :     if (IsStreamValid())
     315           0 :         SetStreamValid(false);
     316           0 : }
     317             : 
     318           0 : bool ScTable::HasManualBreaks() const
     319             : {
     320           0 :     return !maRowManualBreaks.empty() || !maColManualBreaks.empty();
     321             : }
     322             : 
     323         246 : void ScTable::SetRowManualBreaks( const ::std::set<SCROW>& rBreaks )
     324             : {
     325         246 :     maRowManualBreaks = rBreaks;
     326         246 :     InvalidatePageBreaks();
     327         246 :     if (IsStreamValid())
     328           0 :         SetStreamValid(false);
     329         246 : }
     330             : 
     331         216 : void ScTable::SetColManualBreaks( const ::std::set<SCCOL>& rBreaks )
     332             : {
     333         216 :     maColManualBreaks = rBreaks;
     334         216 :     InvalidatePageBreaks();
     335         216 :     if (IsStreamValid())
     336           0 :         SetStreamValid(false);
     337         216 : }
     338             : 
     339         124 : void ScTable::GetAllRowBreaks(set<SCROW>& rBreaks, bool bPage, bool bManual) const
     340             : {
     341         124 :     if (bPage)
     342           0 :         rBreaks = maRowPageBreaks;
     343             : 
     344         124 :     if (bManual)
     345             :     {
     346             :         using namespace std;
     347         124 :         copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
     348             :     }
     349         124 : }
     350             : 
     351         124 : void ScTable::GetAllColBreaks(set<SCCOL>& rBreaks, bool bPage, bool bManual) const
     352             : {
     353         124 :     if (bPage)
     354           0 :         rBreaks = maColPageBreaks;
     355             : 
     356         124 :     if (bManual)
     357             :     {
     358             :         using namespace std;
     359         124 :         copy(maColManualBreaks.begin(), maColManualBreaks.end(), inserter(rBreaks, rBreaks.begin()));
     360             :     }
     361         124 : }
     362             : 
     363       22738 : bool ScTable::HasRowPageBreak(SCROW nRow) const
     364             : {
     365       22738 :     if (!ValidRow(nRow))
     366           0 :         return false;
     367             : 
     368       22738 :     return maRowPageBreaks.find(nRow) != maRowPageBreaks.end();
     369             : }
     370             : 
     371       66324 : bool ScTable::HasColPageBreak(SCCOL nCol) const
     372             : {
     373       66324 :     if (!ValidCol(nCol))
     374           0 :         return false;
     375             : 
     376       66324 :     return maColPageBreaks.find(nCol) != maColPageBreaks.end();
     377             : }
     378             : 
     379       22782 : bool ScTable::HasRowManualBreak(SCROW nRow) const
     380             : {
     381       22782 :     if (!ValidRow(nRow))
     382           0 :         return false;
     383             : 
     384       22782 :     return maRowManualBreaks.find(nRow) != maRowManualBreaks.end();
     385             : }
     386             : 
     387      136132 : bool ScTable::HasColManualBreak(SCCOL nCol) const
     388             : {
     389      136132 :     if (!ValidCol(nCol))
     390           0 :         return false;
     391             : 
     392      136132 :     return maColManualBreaks.find(nCol) != maColManualBreaks.end();
     393             : }
     394             : 
     395          84 : SCROW ScTable::GetNextManualBreak(SCROW nRow) const
     396             : {
     397          84 :     set<SCROW>::const_iterator itr = maRowManualBreaks.lower_bound(nRow);
     398          84 :     return itr == maRowManualBreaks.end() ? -1 : *itr;
     399             : }
     400             : 
     401         172 : void ScTable::RemoveRowPageBreaks(SCROW nStartRow, SCROW nEndRow)
     402             : {
     403             :     using namespace std;
     404             : 
     405         172 :     if (!ValidRow(nStartRow) || !ValidRow(nEndRow))
     406         252 :         return;
     407             : 
     408          92 :     set<SCROW>::iterator low  = maRowPageBreaks.lower_bound(nStartRow);
     409          92 :     set<SCROW>::iterator high = maRowPageBreaks.upper_bound(nEndRow);
     410          92 :     maRowPageBreaks.erase(low, high);
     411             : }
     412             : 
     413           6 : void ScTable::RemoveRowBreak(SCROW nRow, bool bPage, bool bManual)
     414             : {
     415           6 :     if (!ValidRow(nRow))
     416           6 :         return;
     417             : 
     418           6 :     if (bPage)
     419           0 :         maRowPageBreaks.erase(nRow);
     420             : 
     421           6 :     if (bManual)
     422             :     {
     423           6 :         maRowManualBreaks.erase(nRow);
     424           6 :         InvalidatePageBreaks();
     425             :     }
     426             : }
     427             : 
     428       71864 : void ScTable::RemoveColBreak(SCCOL nCol, bool bPage, bool bManual)
     429             : {
     430       71864 :     if (!ValidCol(nCol))
     431       71864 :         return;
     432             : 
     433       71864 :     if (bPage)
     434       71862 :         maColPageBreaks.erase(nCol);
     435             : 
     436       71864 :     if (bManual)
     437             :     {
     438           2 :         maColManualBreaks.erase(nCol);
     439           2 :         InvalidatePageBreaks();
     440             :     }
     441             : }
     442             : 
     443     1421364 : void ScTable::SetRowBreak(SCROW nRow, bool bPage, bool bManual)
     444             : {
     445     1421364 :     if (!ValidRow(nRow))
     446     1421364 :         return;
     447             : 
     448     1421364 :     if (bPage)
     449     1421362 :         maRowPageBreaks.insert(nRow);
     450             : 
     451     1421364 :     if (bManual)
     452             :     {
     453           2 :         maRowManualBreaks.insert(nRow);
     454           2 :         InvalidatePageBreaks();
     455             :     }
     456             : }
     457             : 
     458        9980 : void ScTable::SetColBreak(SCCOL nCol, bool bPage, bool bManual)
     459             : {
     460        9980 :     if (!ValidCol(nCol))
     461        9980 :         return;
     462             : 
     463        9980 :     if (bPage)
     464        9978 :         maColPageBreaks.insert(nCol);
     465             : 
     466        9980 :     if (bManual)
     467             :     {
     468           2 :         maColManualBreaks.insert(nCol);
     469           2 :         InvalidatePageBreaks();
     470             :     }
     471             : }
     472             : 
     473          12 : Sequence<TablePageBreakData> ScTable::GetRowBreakData() const
     474             : {
     475             :     using ::std::copy;
     476             :     using ::std::inserter;
     477             : 
     478          12 :     set<SCROW> aRowBreaks = maRowPageBreaks;
     479          12 :     copy(maRowManualBreaks.begin(), maRowManualBreaks.end(), inserter(aRowBreaks, aRowBreaks.begin()));
     480             : 
     481          12 :     set<SCROW>::const_iterator itr = aRowBreaks.begin(), itrEnd = aRowBreaks.end();
     482          12 :     Sequence<TablePageBreakData> aSeq(aRowBreaks.size());
     483             : 
     484          56 :     for (sal_Int32 i = 0; itr != itrEnd; ++itr, ++i)
     485             :     {
     486          44 :         SCROW nRow = *itr;
     487          44 :         TablePageBreakData aData;
     488          44 :         aData.Position = nRow;
     489          44 :         aData.ManualBreak = HasRowManualBreak(nRow);
     490          44 :         aSeq[i] = aData;
     491             :     }
     492             : 
     493          12 :     return aSeq;
     494             : }
     495             : 
     496    18959911 : bool ScTable::RowHidden(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
     497             : {
     498    18959911 :     if (!ValidRow(nRow))
     499             :     {
     500           2 :         if (pFirstRow)
     501           2 :             *pFirstRow = nRow;
     502           2 :         if (pLastRow)
     503           0 :             *pLastRow = nRow;
     504           2 :         return true;
     505             :     }
     506             : 
     507             :     ScFlatBoolRowSegments::RangeData aData;
     508    18959909 :     if (!mpHiddenRows->getRangeData(nRow, aData))
     509             :     {
     510             :         // search failed.
     511           0 :         if (pFirstRow)
     512           0 :             *pFirstRow = nRow;
     513           0 :         if (pLastRow)
     514           0 :             *pLastRow = nRow;
     515           0 :         return true;
     516             :     }
     517             : 
     518    18959909 :     if (pFirstRow)
     519    12583406 :         *pFirstRow = aData.mnRow1;
     520    18959909 :     if (pLastRow)
     521    18339011 :         *pLastRow = aData.mnRow2;
     522             : 
     523    18959909 :     return aData.mbValue;
     524             : }
     525             : 
     526         226 : bool ScTable::RowHiddenLeaf(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
     527             : {
     528         226 :     if (!ValidRow(nRow))
     529             :     {
     530           0 :         if (pFirstRow)
     531           0 :             *pFirstRow = nRow;
     532           0 :         if (pLastRow)
     533           0 :             *pLastRow = nRow;
     534           0 :         return true;
     535             :     }
     536             : 
     537             :     ScFlatBoolRowSegments::RangeData aData;
     538         226 :     if (!mpHiddenRows->getRangeDataLeaf(nRow, aData))
     539             :     {
     540             :         // search failed.
     541           0 :         if (pFirstRow)
     542           0 :             *pFirstRow = nRow;
     543           0 :         if (pLastRow)
     544           0 :             *pLastRow = nRow;
     545           0 :         return true;
     546             :     }
     547             : 
     548         226 :     if (pFirstRow)
     549           0 :         *pFirstRow = aData.mnRow1;
     550         226 :     if (pLastRow)
     551         226 :         *pLastRow = aData.mnRow2;
     552             : 
     553         226 :     return aData.mbValue;
     554             : }
     555             : 
     556           6 : bool ScTable::HasHiddenRows(SCROW nStartRow, SCROW nEndRow) const
     557             : {
     558           6 :     SCROW nRow = nStartRow;
     559          18 :     while (nRow <= nEndRow)
     560             :     {
     561           6 :         SCROW nLastRow = -1;
     562           6 :         bool bHidden = RowHidden(nRow, NULL, &nLastRow);
     563           6 :         if (bHidden)
     564           0 :             return true;
     565             : 
     566           6 :         nRow = nLastRow + 1;
     567             :     }
     568           6 :     return false;
     569             : }
     570             : 
     571     8230218 : bool ScTable::ColHidden(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
     572             : {
     573     8230218 :     if (!ValidCol(nCol))
     574           0 :         return true;
     575             : 
     576             :     ScFlatBoolColSegments::RangeData aData;
     577     8230218 :     if (!mpHiddenCols->getRangeData(nCol, aData))
     578           0 :         return true;
     579             : 
     580     8230218 :     if (pFirstCol)
     581          20 :         *pFirstCol = aData.mnCol1;
     582     8230218 :     if (pLastCol)
     583       26219 :         *pLastCol = aData.mnCol2;
     584             : 
     585     8230218 :     return aData.mbValue;
     586             : }
     587             : 
     588         872 : bool ScTable::SetRowHidden(SCROW nStartRow, SCROW nEndRow, bool bHidden)
     589             : {
     590         872 :     bool bChanged = false;
     591         872 :     if (bHidden)
     592         306 :         bChanged = mpHiddenRows->setTrue(nStartRow, nEndRow);
     593             :     else
     594         566 :         bChanged = mpHiddenRows->setFalse(nStartRow, nEndRow);
     595             : 
     596         872 :     if (bChanged)
     597             :     {
     598         278 :         if (IsStreamValid())
     599           0 :             SetStreamValid(false);
     600             :     }
     601             : 
     602         872 :     return bChanged;
     603             : }
     604             : 
     605      109870 : bool ScTable::SetColHidden(SCCOL nStartCol, SCCOL nEndCol, bool bHidden)
     606             : {
     607      109870 :     bool bChanged = false;
     608      109870 :     if (bHidden)
     609         654 :         bChanged = mpHiddenCols->setTrue(nStartCol, nEndCol);
     610             :     else
     611      109216 :         bChanged = mpHiddenCols->setFalse(nStartCol, nEndCol);
     612             : 
     613      109870 :     if (bChanged)
     614             :     {
     615         834 :         if (IsStreamValid())
     616           2 :             SetStreamValid(false);
     617             :     }
     618             : 
     619      109870 :     return bChanged;
     620             : }
     621             : 
     622         104 : void ScTable::CopyColHidden(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
     623             : {
     624         104 :     SCCOL nCol = nStartCol;
     625         312 :     while (nCol <= nEndCol)
     626             :     {
     627             :         SCCOL nLastCol;
     628         104 :         bool bHidden = rTable.ColHidden(nCol, NULL, &nLastCol);
     629         104 :         if (nLastCol > nEndCol)
     630         104 :             nLastCol = nEndCol;
     631             : 
     632         104 :         SetColHidden(nCol, nLastCol, bHidden);
     633         104 :         nCol = nLastCol + 1;
     634             :     }
     635         104 : }
     636             : 
     637         104 : void ScTable::CopyRowHidden(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
     638             : {
     639         104 :     SCROW nRow = nStartRow;
     640         312 :     while (nRow <= nEndRow)
     641             :     {
     642         104 :         SCROW nLastRow = -1;
     643         104 :         bool bHidden = rTable.RowHidden(nRow, NULL, &nLastRow);
     644         104 :         if (nLastRow > nEndRow)
     645         104 :             nLastRow = nEndRow;
     646         104 :         SetRowHidden(nRow, nLastRow, bHidden);
     647         104 :         nRow = nLastRow + 1;
     648             :     }
     649         104 : }
     650             : 
     651         350 : void ScTable::CopyRowHeight(ScTable& rSrcTable, SCROW nStartRow, SCROW nEndRow, SCROW nSrcOffset)
     652             : {
     653         350 :     SCROW nRow = nStartRow;
     654             :     ScFlatUInt16RowSegments::RangeData aSrcData;
     655        1312 :     while (nRow <= nEndRow)
     656             :     {
     657         612 :         if (!rSrcTable.mpRowHeights->getRangeData(nRow + nSrcOffset, aSrcData))
     658             :             // Something is wrong !
     659           0 :             return;
     660             : 
     661         612 :         SCROW nLastRow = aSrcData.mnRow2 - nSrcOffset;
     662         612 :         if (nLastRow > nEndRow)
     663         214 :             nLastRow = nEndRow;
     664             : 
     665         612 :         mpRowHeights->setValue(nRow, nLastRow, aSrcData.mnValue);
     666         612 :         nRow = nLastRow + 1;
     667             :     }
     668             : }
     669             : 
     670         318 : SCROW ScTable::FirstVisibleRow(SCROW nStartRow, SCROW nEndRow) const
     671             : {
     672         318 :     SCROW nRow = nStartRow;
     673             :     ScFlatBoolRowSegments::RangeData aData;
     674         858 :     while (nRow <= nEndRow)
     675             :     {
     676         540 :         if (!ValidRow(nRow))
     677           0 :             break;
     678             : 
     679         540 :         if (!mpHiddenRows->getRangeData(nRow, aData))
     680             :             // failed to get range data.
     681           0 :             break;
     682             : 
     683         540 :         if (!aData.mbValue)
     684             :             // visible row found
     685         318 :             return nRow;
     686             : 
     687         222 :         nRow = aData.mnRow2 + 1;
     688             :     }
     689             : 
     690           0 :     return ::std::numeric_limits<SCROW>::max();
     691             : }
     692             : 
     693          12 : SCROW ScTable::LastVisibleRow(SCROW nStartRow, SCROW nEndRow) const
     694             : {
     695          12 :     SCROW nRow = nEndRow;
     696             :     ScFlatBoolRowSegments::RangeData aData;
     697          24 :     while (nRow >= nStartRow)
     698             :     {
     699          12 :         if (!ValidRow(nRow))
     700           0 :             break;
     701             : 
     702          12 :         if (!mpHiddenRows->getRangeData(nRow, aData))
     703             :             // failed to get range data.
     704           0 :             break;
     705             : 
     706          12 :         if (!aData.mbValue)
     707             :             // visible row found
     708          12 :             return nRow;
     709             : 
     710           0 :         nRow = aData.mnRow1 - 1;
     711             :     }
     712             : 
     713           0 :     return ::std::numeric_limits<SCROW>::max();
     714             : }
     715             : 
     716          76 : SCROW ScTable::CountVisibleRows(SCROW nStartRow, SCROW nEndRow) const
     717             : {
     718          76 :     SCROW nCount = 0;
     719          76 :     SCROW nRow = nStartRow;
     720             :     ScFlatBoolRowSegments::RangeData aData;
     721         228 :     while (nRow <= nEndRow)
     722             :     {
     723          76 :         if (!mpHiddenRows->getRangeData(nRow, aData))
     724           0 :             break;
     725             : 
     726          76 :         if (aData.mnRow2 > nEndRow)
     727          76 :             aData.mnRow2 = nEndRow;
     728             : 
     729          76 :         if (!aData.mbValue)
     730          76 :             nCount += aData.mnRow2 - nRow + 1;
     731             : 
     732          76 :         nRow = aData.mnRow2 + 1;
     733             :     }
     734          76 :     return nCount;
     735             : }
     736             : 
     737        7034 : sal_uInt32 ScTable::GetTotalRowHeight(SCROW nStartRow, SCROW nEndRow, bool bHiddenAsZero ) const
     738             : {
     739        7034 :     sal_uInt32 nHeight = 0;
     740        7034 :     SCROW nRow = nStartRow;
     741             :     ScFlatBoolRowSegments::RangeData aData;
     742       21506 :     while (nRow <= nEndRow)
     743             :     {
     744        7438 :         if (!mpHiddenRows->getRangeData(nRow, aData))
     745           0 :             break;
     746             : 
     747        7438 :         if (aData.mnRow2 > nEndRow)
     748        1984 :             aData.mnRow2 = nEndRow;
     749             : 
     750        7438 :         if ( !( bHiddenAsZero && aData.mbValue ) )
     751             :             // visible row range.
     752        7192 :             nHeight += mpRowHeights->getSumValue(nRow, aData.mnRow2);
     753             : 
     754        7438 :         nRow = aData.mnRow2 + 1;
     755             :     }
     756             : 
     757        7034 :     return nHeight;
     758             : }
     759             : 
     760           0 : SCCOLROW ScTable::LastHiddenColRow(SCCOLROW nPos, bool bCol) const
     761             : {
     762           0 :     if (bCol)
     763             :     {
     764           0 :         SCCOL nCol = static_cast<SCCOL>(nPos);
     765           0 :         if (ColHidden(nCol))
     766             :         {
     767           0 :             for (SCCOL i = nCol+1; i <= MAXCOL; ++i)
     768             :             {
     769           0 :                 if (!ColHidden(nCol))
     770           0 :                     return nCol - 1;
     771             :             }
     772             :         }
     773             :     }
     774             :     else
     775             :     {
     776           0 :         SCROW nRow = static_cast<SCROW>(nPos);
     777             :         SCROW nLastRow;
     778           0 :         if (RowHidden(nRow, NULL, &nLastRow))
     779           0 :             return static_cast<SCCOLROW>(nLastRow);
     780             :     }
     781           0 :     return ::std::numeric_limits<SCCOLROW>::max();
     782             : }
     783             : 
     784    12588407 : bool ScTable::RowFiltered(SCROW nRow, SCROW* pFirstRow, SCROW* pLastRow) const
     785             : {
     786    12588407 :     if (!ValidRow(nRow))
     787           0 :         return false;
     788             : 
     789             :     ScFlatBoolRowSegments::RangeData aData;
     790    12588407 :     if (!mpFilteredRows->getRangeData(nRow, aData))
     791             :         // search failed.
     792           0 :         return false;
     793             : 
     794    12588407 :     if (pFirstRow)
     795    12583182 :         *pFirstRow = aData.mnRow1;
     796    12588407 :     if (pLastRow)
     797    12588331 :         *pLastRow = aData.mnRow2;
     798             : 
     799    12588407 :     return aData.mbValue;
     800             : }
     801             : 
     802         146 : bool ScTable::ColFiltered(SCCOL nCol, SCCOL* pFirstCol, SCCOL* pLastCol) const
     803             : {
     804         146 :     if (!ValidCol(nCol))
     805           0 :         return false;
     806             : 
     807             :     ScFlatBoolColSegments::RangeData aData;
     808         146 :     if (!mpFilteredCols->getRangeData(nCol, aData))
     809             :         // search failed.
     810           0 :         return false;
     811             : 
     812         146 :     if (pFirstCol)
     813           0 :         *pFirstCol = aData.mnCol1;
     814         146 :     if (pLastCol)
     815         104 :         *pLastCol = aData.mnCol2;
     816             : 
     817         146 :     return aData.mbValue;
     818             : }
     819             : 
     820        1797 : bool ScTable::HasFilteredRows(SCROW nStartRow, SCROW nEndRow) const
     821             : {
     822        1797 :     SCROW nRow = nStartRow;
     823        5391 :     while (nRow <= nEndRow)
     824             :     {
     825        1797 :         SCROW nLastRow = nRow;
     826        1797 :         bool bFiltered = RowFiltered(nRow, NULL, &nLastRow);
     827        1797 :         if (bFiltered)
     828           0 :             return true;
     829             : 
     830        1797 :         nRow = nLastRow + 1;
     831             :     }
     832        1797 :     return false;
     833             : }
     834             : 
     835         104 : void ScTable::CopyColFiltered(ScTable& rTable, SCCOL nStartCol, SCCOL nEndCol)
     836             : {
     837         104 :     SCCOL nCol = nStartCol;
     838         312 :     while (nCol <= nEndCol)
     839             :     {
     840         104 :         SCCOL nLastCol = -1;
     841         104 :         bool bFiltered = rTable.ColFiltered(nCol, NULL, &nLastCol);
     842         104 :         if (nLastCol > nEndCol)
     843         104 :             nLastCol = nEndCol;
     844             : 
     845         104 :         SetColFiltered(nCol, nLastCol, bFiltered);
     846         104 :         nCol = nLastCol + 1;
     847             :     }
     848         104 : }
     849             : 
     850         104 : void ScTable::CopyRowFiltered(ScTable& rTable, SCROW nStartRow, SCROW nEndRow)
     851             : {
     852         104 :     SCROW nRow = nStartRow;
     853         312 :     while (nRow <= nEndRow)
     854             :     {
     855         104 :         SCROW nLastRow = -1;
     856         104 :         bool bFiltered = rTable.RowFiltered(nRow, NULL, &nLastRow);
     857         104 :         if (nLastRow > nEndRow)
     858         104 :             nLastRow = nEndRow;
     859         104 :         SetRowFiltered(nRow, nLastRow, bFiltered);
     860         104 :         nRow = nLastRow + 1;
     861             :     }
     862         104 : }
     863             : 
     864         748 : void ScTable::SetRowFiltered(SCROW nStartRow, SCROW nEndRow, bool bFiltered)
     865             : {
     866         748 :     if (bFiltered)
     867         178 :         mpFilteredRows->setTrue(nStartRow, nEndRow);
     868             :     else
     869         570 :         mpFilteredRows->setFalse(nStartRow, nEndRow);
     870         748 : }
     871             : 
     872         104 : void ScTable::SetColFiltered(SCCOL nStartCol, SCCOL nEndCol, bool bFiltered)
     873             : {
     874         104 :     if (bFiltered)
     875           0 :         mpFilteredCols->setTrue(nStartCol, nEndCol);
     876             :     else
     877         104 :         mpFilteredCols->setFalse(nStartCol, nEndCol);
     878         104 : }
     879             : 
     880          72 : SCROW ScTable::FirstNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
     881             : {
     882          72 :     SCROW nRow = nStartRow;
     883             :     ScFlatBoolRowSegments::RangeData aData;
     884         144 :     while (nRow <= nEndRow)
     885             :     {
     886          72 :         if (!ValidRow(nRow))
     887           0 :             break;
     888             : 
     889          72 :         if (!mpFilteredRows->getRangeData(nRow, aData))
     890             :             // failed to get range data.
     891           0 :             break;
     892             : 
     893          72 :         if (!aData.mbValue)
     894             :             // non-filtered row found
     895          72 :             return nRow;
     896             : 
     897           0 :         nRow = aData.mnRow2 + 1;
     898             :     }
     899             : 
     900           0 :     return ::std::numeric_limits<SCROW>::max();
     901             : }
     902             : 
     903           0 : SCROW ScTable::LastNonFilteredRow(SCROW nStartRow, SCROW nEndRow) const
     904             : {
     905           0 :     SCROW nRow = nEndRow;
     906             :     ScFlatBoolRowSegments::RangeData aData;
     907           0 :     while (nRow >= nStartRow)
     908             :     {
     909           0 :         if (!ValidRow(nRow))
     910           0 :             break;
     911             : 
     912           0 :         if (!mpFilteredRows->getRangeData(nRow, aData))
     913             :             // failed to get range data.
     914           0 :             break;
     915             : 
     916           0 :         if (!aData.mbValue)
     917             :             // non-filtered row found
     918           0 :             return nRow;
     919             : 
     920           0 :         nRow = aData.mnRow1 - 1;
     921             :     }
     922             : 
     923           0 :     return ::std::numeric_limits<SCROW>::max();
     924             : }
     925             : 
     926         142 : SCROW ScTable::CountNonFilteredRows(SCROW nStartRow, SCROW nEndRow) const
     927             : {
     928         142 :     SCROW nCount = 0;
     929         142 :     SCROW nRow = nStartRow;
     930             :     ScFlatBoolRowSegments::RangeData aData;
     931         426 :     while (nRow <= nEndRow)
     932             :     {
     933         142 :         if (!mpFilteredRows->getRangeData(nRow, aData))
     934           0 :             break;
     935             : 
     936         142 :         if (aData.mnRow2 > nEndRow)
     937         142 :             aData.mnRow2 = nEndRow;
     938             : 
     939         142 :         if (!aData.mbValue)
     940         142 :             nCount += aData.mnRow2 - nRow + 1;
     941             : 
     942         142 :         nRow = aData.mnRow2 + 1;
     943             :     }
     944         142 :     return nCount;
     945             : }
     946             : 
     947          14 : bool ScTable::IsManualRowHeight(SCROW nRow) const
     948             : {
     949          14 :     return (pRowFlags->GetValue(nRow) & CR_MANUALSIZE) != 0;
     950             : }
     951             : 
     952             : namespace {
     953             : 
     954         152 : void lcl_syncFlags(ScFlatBoolColSegments& rColSegments, ScFlatBoolRowSegments& rRowSegments,
     955             :     sal_uInt8* pColFlags, ScBitMaskCompressedArray< SCROW, sal_uInt8>* pRowFlags, const sal_uInt8 nFlagMask)
     956             : {
     957             :     using ::sal::static_int_cast;
     958             : 
     959         152 :     sal_uInt8 nFlagMaskComplement = static_int_cast<sal_uInt8>(~nFlagMask);
     960             : 
     961         152 :     pRowFlags->AndValue(0, MAXROW, nFlagMaskComplement);
     962      155800 :     for (SCCOL i = 0; i <= MAXCOL; ++i)
     963      155648 :         pColFlags[i] &= nFlagMaskComplement;
     964             : 
     965             :     {
     966             :         // row hidden flags.
     967             : 
     968         152 :         SCROW nRow = 0;
     969             :         ScFlatBoolRowSegments::RangeData aData;
     970         456 :         while (nRow <= MAXROW)
     971             :         {
     972         152 :             if (!rRowSegments.getRangeData(nRow, aData))
     973           0 :                 break;
     974             : 
     975         152 :             if (aData.mbValue)
     976           0 :                 pRowFlags->OrValue(nRow, aData.mnRow2, nFlagMask);
     977             : 
     978         152 :             nRow = aData.mnRow2 + 1;
     979             :         }
     980             :     }
     981             : 
     982             :     {
     983             :         // column hidden flags.
     984             : 
     985         152 :         SCCOL nCol = 0;
     986             :         ScFlatBoolColSegments::RangeData aData;
     987         456 :         while (nCol <= MAXCOL)
     988             :         {
     989         152 :             if (!rColSegments.getRangeData(nCol, aData))
     990           0 :                 break;
     991             : 
     992         152 :             if (aData.mbValue)
     993             :             {
     994           0 :                 for (SCCOL i = nCol; i <= aData.mnCol2; ++i)
     995           0 :                     pColFlags[i] |= nFlagMask;
     996             :             }
     997             : 
     998         152 :             nCol = aData.mnCol2 + 1;
     999             :         }
    1000             :     }
    1001         152 : }
    1002             : 
    1003             : }
    1004             : 
    1005          76 : void ScTable::SyncColRowFlags()
    1006             : {
    1007             :     using ::sal::static_int_cast;
    1008             : 
    1009          76 :     sal_uInt8 nManualBreakComplement = static_int_cast<sal_uInt8>(~CR_MANUALBREAK);
    1010             : 
    1011             :     // Manual breaks.
    1012          76 :     pRowFlags->AndValue(0, MAXROW, nManualBreakComplement);
    1013       77900 :     for (SCCOL i = 0; i <= MAXCOL; ++i)
    1014       77824 :         pColFlags[i] &= nManualBreakComplement;
    1015             : 
    1016          76 :     if (!maRowManualBreaks.empty())
    1017             :     {
    1018           0 :         for (set<SCROW>::const_iterator itr = maRowManualBreaks.begin(), itrEnd = maRowManualBreaks.end();
    1019             :               itr != itrEnd; ++itr)
    1020           0 :             pRowFlags->OrValue(*itr, CR_MANUALBREAK);
    1021             :     }
    1022             : 
    1023          76 :     if (!maColManualBreaks.empty())
    1024             :     {
    1025           0 :         for (set<SCCOL>::const_iterator itr = maColManualBreaks.begin(), itrEnd = maColManualBreaks.end();
    1026             :               itr != itrEnd; ++itr)
    1027           0 :             pColFlags[*itr] |= CR_MANUALBREAK;
    1028             :     }
    1029             : 
    1030             :     // Hidden flags.
    1031          76 :     lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, pColFlags, pRowFlags, CR_HIDDEN);
    1032          76 :     lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, pColFlags, pRowFlags, CR_FILTERED);
    1033          76 : }
    1034             : 
    1035         720 : void ScTable::SetPageSize( const Size& rSize )
    1036             : {
    1037         720 :     if ( rSize.Width() != 0 && rSize.Height() != 0 )
    1038             :     {
    1039         720 :         if (aPageSizeTwips != rSize)
    1040         302 :             InvalidatePageBreaks();
    1041             : 
    1042         720 :         bPageSizeValid = true;
    1043         720 :         aPageSizeTwips = rSize;
    1044             :     }
    1045             :     else
    1046           0 :         bPageSizeValid = false;
    1047         720 : }
    1048             : 
    1049       58217 : bool ScTable::IsProtected() const
    1050             : {
    1051       58217 :     return pTabProtection.get() && pTabProtection->isProtected();
    1052             : }
    1053             : 
    1054          36 : void ScTable::SetProtection(const ScTableProtection* pProtect)
    1055             : {
    1056          36 :     if (pProtect)
    1057          36 :         pTabProtection.reset(new ScTableProtection(*pProtect));
    1058             :     else
    1059           0 :         pTabProtection.reset();
    1060             : 
    1061          36 :     if (IsStreamValid())
    1062           0 :         SetStreamValid(false);
    1063          36 : }
    1064             : 
    1065         300 : ScTableProtection* ScTable::GetProtection()
    1066             : {
    1067         300 :     return pTabProtection.get();
    1068             : }
    1069             : 
    1070        4720 : Size ScTable::GetPageSize() const
    1071             : {
    1072        4720 :     if ( bPageSizeValid )
    1073         292 :         return aPageSizeTwips;
    1074             :     else
    1075        4428 :         return Size();  // leer
    1076             : }
    1077             : 
    1078         632 : void ScTable::SetRepeatArea( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCROW nEndRow )
    1079             : {
    1080             :     // #i117952# page break calculation uses these values (set from ScPrintFunc), not pRepeatColRange/pRepeatRowRange
    1081         632 :     if ( nStartCol != nRepeatStartX || nEndCol != nRepeatEndX || nStartRow != nRepeatStartY || nEndRow != nRepeatEndY )
    1082          24 :         InvalidatePageBreaks();
    1083             : 
    1084         632 :     nRepeatStartX = nStartCol;
    1085         632 :     nRepeatEndX   = nEndCol;
    1086         632 :     nRepeatStartY = nStartRow;
    1087         632 :     nRepeatEndY   = nEndRow;
    1088         632 : }
    1089             : 
    1090       17478 : void ScTable::StartListening( const ScAddress& rAddress, SvtListener* pListener )
    1091             : {
    1092       17478 :     if (!ValidCol(rAddress.Col()))
    1093       17478 :         return;
    1094             : 
    1095       17478 :     aCol[rAddress.Col()].StartListening( *pListener, rAddress.Row() );
    1096             : }
    1097             : 
    1098        1828 : void ScTable::EndListening( const ScAddress& rAddress, SvtListener* pListener )
    1099             : {
    1100        1828 :     if (!ValidCol(rAddress.Col()))
    1101        1828 :         return;
    1102             : 
    1103        1828 :     aCol[rAddress.Col()].EndListening( *pListener, rAddress.Row() );
    1104             : }
    1105             : 
    1106       22946 : void ScTable::StartListening( sc::StartListeningContext& rCxt, SCCOL nCol, SCROW nRow, SvtListener& rListener )
    1107             : {
    1108       22946 :     if (!ValidCol(nCol))
    1109       22946 :         return;
    1110             : 
    1111       22946 :     aCol[nCol].StartListening(rCxt, nRow, rListener);
    1112             : }
    1113             : 
    1114         528 : void ScTable::EndListening( sc::EndListeningContext& rCxt, SCCOL nCol, SCROW nRow, SvtListener& rListener )
    1115             : {
    1116         528 :     if (!ValidCol(nCol))
    1117         528 :         return;
    1118             : 
    1119         528 :     aCol[nCol].EndListening(rCxt, nRow, rListener);
    1120             : }
    1121             : 
    1122         766 : void ScTable::SetPageStyle( const OUString& rName )
    1123             : {
    1124         766 :     if ( aPageStyle != rName )
    1125             :     {
    1126         754 :         OUString           aStrNew    = rName;
    1127         754 :         SfxStyleSheetBasePool*  pStylePool = pDocument->GetStyleSheetPool();
    1128         754 :         SfxStyleSheetBase*      pNewStyle  = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
    1129             : 
    1130         754 :         if ( !pNewStyle )
    1131             :         {
    1132           0 :             aStrNew = ScGlobal::GetRscString(STR_STYLENAME_STANDARD);
    1133           0 :             pNewStyle = pStylePool->Find( aStrNew, SFX_STYLE_FAMILY_PAGE );
    1134             :         }
    1135             : 
    1136         754 :         if ( aPageStyle != aStrNew )
    1137             :         {
    1138         754 :             SfxStyleSheetBase* pOldStyle = pStylePool->Find( aPageStyle, SFX_STYLE_FAMILY_PAGE );
    1139             : 
    1140         754 :             if ( pOldStyle && pNewStyle )
    1141             :             {
    1142         754 :                 SfxItemSet&  rOldSet          = pOldStyle->GetItemSet();
    1143         754 :                 SfxItemSet&  rNewSet          = pNewStyle->GetItemSet();
    1144         754 :                 const sal_uInt16 nOldScale        = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALE);
    1145         754 :                 const sal_uInt16 nOldScaleToPages = GET_SCALEVALUE(rOldSet,ATTR_PAGE_SCALETOPAGES);
    1146         754 :                 const sal_uInt16 nNewScale        = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALE);
    1147         754 :                 const sal_uInt16 nNewScaleToPages = GET_SCALEVALUE(rNewSet,ATTR_PAGE_SCALETOPAGES);
    1148             : 
    1149         754 :                 if ( (nOldScale != nNewScale) || (nOldScaleToPages != nNewScaleToPages) )
    1150           0 :                     InvalidateTextWidth(NULL, NULL, false, false);
    1151             :             }
    1152             : 
    1153         754 :             if ( pNewStyle )            // auch ohne den alten (fuer UpdateStdNames)
    1154         754 :                 aPageStyle = aStrNew;
    1155             : 
    1156         754 :             if (IsStreamValid())
    1157           0 :                 SetStreamValid(false);
    1158         754 :         }
    1159             :     }
    1160         766 : }
    1161             : 
    1162         266 : void ScTable::PageStyleModified( const OUString& rNewName )
    1163             : {
    1164         266 :     aPageStyle = rNewName;
    1165         266 :     InvalidateTextWidth(NULL, NULL, false, false);      // don't know what was in the style before
    1166         266 : }
    1167             : 
    1168       24830 : void ScTable::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* pAdrTo,
    1169             :                                    bool bNumFormatChanged, bool bBroadcast )
    1170             : {
    1171       24830 :     if ( pAdrFrom && !pAdrTo )
    1172             :     {
    1173             :         // Special case: only process the "from" cell.
    1174           0 :         SCCOL nCol = pAdrFrom->Col();
    1175           0 :         SCROW nRow = pAdrFrom->Row();
    1176           0 :         ScColumn& rCol = aCol[nCol];
    1177           0 :         ScRefCellValue aCell = rCol.GetCellValue(nRow);
    1178           0 :         if (aCell.isEmpty())
    1179           0 :             return;
    1180             : 
    1181           0 :         rCol.SetTextWidth(nRow, TEXTWIDTH_DIRTY);
    1182             : 
    1183           0 :         if ( bNumFormatChanged )
    1184           0 :             rCol.SetScriptType(nRow, SC_SCRIPTTYPE_UNKNOWN);
    1185             : 
    1186           0 :         if ( bBroadcast )
    1187             :         {   // nur bei CalcAsShown
    1188           0 :             switch (aCell.meType)
    1189             :             {
    1190             :                 case CELLTYPE_VALUE :
    1191           0 :                     rCol.Broadcast(nRow);
    1192           0 :                     break;
    1193             :                 case CELLTYPE_FORMULA :
    1194           0 :                     aCell.mpFormula->SetDirty();
    1195           0 :                     break;
    1196             :                 default:
    1197             :                 {
    1198             :                     // added to avoid warnings
    1199             :                 }
    1200             :             }
    1201             :         }
    1202             : 
    1203           0 :         return;
    1204             :     }
    1205             : 
    1206       24830 :     const SCCOL nCol1 = pAdrFrom ? pAdrFrom->Col() : 0;
    1207       24830 :     const SCROW nRow1 = pAdrFrom ? pAdrFrom->Row() : 0;
    1208       24830 :     const SCCOL nCol2 = pAdrTo   ? pAdrTo->Col()   : MAXCOL;
    1209       24830 :     const SCROW nRow2 = pAdrTo   ? pAdrTo->Row()   : MAXROW;
    1210             : 
    1211      485458 :     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
    1212             :     {
    1213      460628 :         ScColumnTextWidthIterator aIter(aCol[nCol], nRow1, nRow2);
    1214             : 
    1215      464322 :         for (; aIter.hasCell(); aIter.next())
    1216             :         {
    1217        3694 :             SCROW nRow = aIter.getPos();
    1218        3694 :             aIter.setValue(TEXTWIDTH_DIRTY);
    1219        3694 :             ScRefCellValue aCell = aCol[nCol].GetCellValue(nRow);
    1220        3694 :             if (aCell.isEmpty())
    1221           0 :                 continue;
    1222             : 
    1223        3694 :             if ( bNumFormatChanged )
    1224         282 :                 aCol[nCol].SetScriptType(nRow, SC_SCRIPTTYPE_UNKNOWN);
    1225             : 
    1226        3694 :             if ( bBroadcast )
    1227             :             {   // nur bei CalcAsShown
    1228           0 :                 switch (aCell.meType)
    1229             :                 {
    1230             :                     case CELLTYPE_VALUE :
    1231           0 :                         aCol[nCol].Broadcast(nRow);
    1232           0 :                         break;
    1233             :                     case CELLTYPE_FORMULA :
    1234           0 :                         aCell.mpFormula->SetDirty();
    1235           0 :                         break;
    1236             :                     default:
    1237             :                     {
    1238             :                         // added to avoid warnings
    1239             :                     }
    1240             :                 }
    1241             :             }
    1242        3694 :         }
    1243             :     }
    1244         228 : }
    1245             : 
    1246             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10