sc/source/core/data/table5.cxx

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