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

Generated by: LCOV version 1.10