LCOV - code coverage report
Current view: top level - sc/source/ui/view - tabview2.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 347 787 44.1 %
Date: 2015-06-13 12:38:46 Functions: 23 35 65.7 %
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 <editeng/eeitem.hxx>
      22             : #include <vcl/timer.hxx>
      23             : #include <vcl/msgbox.hxx>
      24             : #include <sfx2/app.hxx>
      25             : #include <sfx2/viewfrm.hxx>
      26             : #include <sfx2/bindings.hxx>
      27             : #include <sfx2/childwin.hxx>
      28             : 
      29             : #include "attrib.hxx"
      30             : #include "pagedata.hxx"
      31             : #include "tabview.hxx"
      32             : #include "tabvwsh.hxx"
      33             : #include "printfun.hxx"
      34             : #include "stlpool.hxx"
      35             : #include "docsh.hxx"
      36             : #include "gridwin.hxx"
      37             : #include "olinewin.hxx"
      38             : #include "uiitems.hxx"
      39             : #include "sc.hrc"
      40             : #include "viewutil.hxx"
      41             : #include "colrowba.hxx"
      42             : #include "waitoff.hxx"
      43             : #include "globstr.hrc"
      44             : #include "scmod.hxx"
      45             : #include "tabprotection.hxx"
      46             : #include "markdata.hxx"
      47             : #include "inputopt.hxx"
      48             : 
      49             : namespace {
      50             : 
      51          10 : bool isCellQualified(ScDocument* pDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, bool bSelectLocked, bool bSelectUnlocked)
      52             : {
      53             :     bool bCellProtected = pDoc->HasAttrib(
      54          10 :         nCol, nRow, nTab, nCol, nRow, nTab, HASATTR_PROTECTED);
      55             : 
      56          10 :     if (bCellProtected && !bSelectLocked)
      57           0 :         return false;
      58             : 
      59          10 :     if (!bCellProtected && !bSelectUnlocked)
      60           0 :         return false;
      61             : 
      62          10 :     return true;
      63             : }
      64             : 
      65           2 : void moveCursorByProtRule(
      66             :     SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY, SCTAB nTab, ScDocument* pDoc)
      67             : {
      68           2 :     bool bSelectLocked = true;
      69           2 :     bool bSelectUnlocked = true;
      70           2 :     ScTableProtection* pTabProtection = pDoc->GetTabProtection(nTab);
      71           2 :     if (pTabProtection && pTabProtection->isProtected())
      72             :     {
      73           0 :         bSelectLocked   = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
      74           0 :         bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
      75             :     }
      76             : 
      77           2 :     if (nMovX > 0)
      78             :     {
      79           6 :         for (SCCOL i = 0; i < nMovX && rCol < MAXCOL; ++i)
      80             :         {
      81           5 :             SCCOL nNewUnhiddenCol = rCol + 1;
      82           5 :             SCCOL nEndCol = 0;
      83          10 :             while(pDoc->ColHidden(nNewUnhiddenCol, nTab, NULL, &nEndCol))
      84             :             {
      85           0 :                 if(nNewUnhiddenCol >= MAXCOL)
      86           0 :                     return;
      87             : 
      88           0 :                 i += nEndCol - nNewUnhiddenCol + 1;
      89           0 :                 nNewUnhiddenCol = nEndCol +1;
      90             :             }
      91             : 
      92           5 :             if (!isCellQualified(pDoc, nNewUnhiddenCol, rRow, nTab, bSelectLocked, bSelectUnlocked))
      93           0 :                 break;
      94           5 :             rCol = nNewUnhiddenCol;
      95             :         }
      96             :     }
      97           1 :     else if (nMovX < 0)
      98             :     {
      99           0 :         for (SCCOL i = 0; i > nMovX && rCol > 0; --i)
     100             :         {
     101           0 :             SCCOL nNewUnhiddenCol = rCol - 1;
     102           0 :             SCCOL nStartCol = 0;
     103           0 :             while(pDoc->ColHidden(nNewUnhiddenCol, nTab, &nStartCol))
     104             :             {
     105           0 :                 if(nNewUnhiddenCol <= 0)
     106           0 :                     return;
     107             : 
     108           0 :                 i -= nNewUnhiddenCol - nStartCol + 1;
     109           0 :                 nNewUnhiddenCol = nStartCol - 1;
     110             :             }
     111             : 
     112           0 :             if (!isCellQualified(pDoc, nNewUnhiddenCol, rRow, nTab, bSelectLocked, bSelectUnlocked))
     113           0 :                 break;
     114           0 :             rCol = nNewUnhiddenCol;
     115             :         }
     116             :     }
     117             : 
     118           2 :     if (nMovY > 0)
     119             :     {
     120           6 :         for (SCROW i = 0; i < nMovY && rRow < MAXROW; ++i)
     121             :         {
     122           5 :             SCROW nNewUnhiddenRow = rRow + 1;
     123           5 :             SCROW nEndRow = 0;
     124          10 :             while(pDoc->RowHidden(nNewUnhiddenRow, nTab, NULL, &nEndRow))
     125             :             {
     126           0 :                 if(nNewUnhiddenRow >= MAXROW)
     127           0 :                     return;
     128             : 
     129           0 :                 i += nEndRow - nNewUnhiddenRow + 1;
     130           0 :                 nNewUnhiddenRow = nEndRow + 1;
     131             :             }
     132             : 
     133           5 :             if (!isCellQualified(pDoc, rCol, nNewUnhiddenRow, nTab, bSelectLocked, bSelectUnlocked))
     134           0 :                 break;
     135           5 :             rRow = nNewUnhiddenRow;
     136             :         }
     137             :     }
     138           1 :     else if (nMovY < 0)
     139             :     {
     140           0 :         for (SCROW i = 0; i > nMovY && rRow > 0; --i)
     141             :         {
     142           0 :             SCROW nNewUnhiddenRow = rRow - 1;
     143           0 :             SCROW nStartRow = 0;
     144           0 :             while(pDoc->RowHidden(nNewUnhiddenRow, nTab, &nStartRow))
     145             :             {
     146           0 :                 if(nNewUnhiddenRow <= 0)
     147           0 :                     return;
     148             : 
     149           0 :                 i -= nNewUnhiddenRow - nStartRow + 1;
     150           0 :                 nNewUnhiddenRow = nStartRow - 1;
     151             :             }
     152             : 
     153           0 :             if (!isCellQualified(pDoc, rCol, nNewUnhiddenRow, nTab, bSelectLocked, bSelectUnlocked))
     154           0 :                 break;
     155           0 :             rRow = nNewUnhiddenRow;
     156             :         }
     157             :     }
     158             : }
     159             : 
     160           4 : bool checkBoundary(SCCOL& rCol, SCROW& rRow)
     161             : {
     162           4 :     bool bGood = true;
     163           4 :     if (rCol < 0)
     164             :     {
     165           0 :         rCol = 0;
     166           0 :         bGood = false;
     167             :     }
     168           4 :     else if (rCol > MAXCOL)
     169             :     {
     170           0 :         rCol = MAXCOL;
     171           0 :         bGood = false;
     172             :     }
     173             : 
     174           4 :     if (rRow < 0)
     175             :     {
     176           0 :         rRow = 0;
     177           0 :         bGood = false;
     178             :     }
     179           4 :     else if (rRow > MAXROW)
     180             :     {
     181           0 :         rRow = MAXROW;
     182           0 :         bGood = false;
     183             :     }
     184           4 :     return bGood;
     185             : }
     186             : 
     187           2 : void moveCursorByMergedCell(
     188             :     SCCOL& rCol, SCROW& rRow, SCsCOL nMovX, SCsROW nMovY, SCTAB nTab,
     189             :     ScDocument* pDoc, const ScViewData& rViewData)
     190             : {
     191           2 :     SCCOL nOrigX = rViewData.GetCurX();
     192           2 :     SCROW nOrigY = rViewData.GetCurY();
     193             : 
     194           2 :     ScTableProtection* pTabProtection = pDoc->GetTabProtection(nTab);
     195           2 :     bool bSelectLocked = true;
     196           2 :     bool bSelectUnlocked = true;
     197           2 :     if (pTabProtection && pTabProtection->isProtected())
     198             :     {
     199           0 :         bSelectLocked   = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
     200           0 :         bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
     201             :     }
     202             : 
     203             :     const ScMergeAttr* pMergeAttr = static_cast<const ScMergeAttr*>(
     204           2 :         pDoc->GetAttr(nOrigX, nOrigY, nTab, ATTR_MERGE));
     205             : 
     206           2 :     bool bOriginMerged = false;
     207           2 :     SCsCOL nColSpan = 1;
     208           2 :     SCsROW nRowSpan = 1;
     209           2 :     if (pMergeAttr && pMergeAttr->IsMerged())
     210             :     {
     211           0 :         nColSpan = pMergeAttr->GetColMerge();
     212           0 :         nRowSpan = pMergeAttr->GetRowMerge();
     213           0 :         bOriginMerged = true;
     214             :     }
     215             : 
     216           2 :     if (nMovX > 0)
     217             :     {
     218           1 :         SCCOL nOld = rCol;
     219           1 :         if (bOriginMerged)
     220             :         {
     221             :             // Original cell is merged.  Push the block end outside the merged region.
     222           0 :             if (nOrigX < MAXCOL && nOrigX < rCol && rCol <= nOrigX + nColSpan - 1)
     223           0 :                 rCol = nOrigX + nColSpan;
     224             :         }
     225             :         else
     226             :         {
     227           1 :             pDoc->SkipOverlapped(rCol, rRow, nTab);
     228             :         }
     229             : 
     230           1 :         if (nOld < rCol)
     231             :         {
     232             :             // The block end has moved.  Check the protection setting and move back if needed.
     233           0 :             checkBoundary(rCol, rRow);
     234           0 :             if (!isCellQualified(pDoc, rCol, rRow, nTab, bSelectLocked, bSelectUnlocked))
     235           0 :                 --rCol;
     236             :         }
     237             :     }
     238           2 :     if (nMovX < 0)
     239             :     {
     240           0 :         SCCOL nOld = rCol;
     241           0 :         if (bOriginMerged)
     242             :         {
     243           0 :             if (nOrigX > 0 && nOrigX <= rCol && rCol < nOrigX + nColSpan - 1)
     244             :                 // Block end is still within the merged region.  Push it outside.
     245           0 :                 rCol = nOrigX - 1;
     246             :         }
     247             :         else
     248             :         {
     249           0 :             pDoc->SkipOverlapped(rCol, rRow, nTab);
     250             :         }
     251             : 
     252           0 :         if (nOld > rCol)
     253             :         {
     254             :             // The block end has moved.  Check the protection setting and move back if needed.
     255           0 :             checkBoundary(rCol, rRow);
     256           0 :             if (!isCellQualified(pDoc, rCol, rRow, nTab, bSelectLocked, bSelectUnlocked))
     257           0 :                 ++rCol;
     258             :         }
     259             :     }
     260           2 :     if (nMovY > 0)
     261             :     {
     262           1 :         SCROW nOld = rRow;
     263           1 :         if (bOriginMerged)
     264             :         {
     265             :             // Original cell is merged.  Push the block end outside the merged region.
     266           0 :             if (nOrigY < MAXROW && nOrigY < rRow && rRow <= nOrigY + nRowSpan - 1)
     267           0 :                 rRow = nOrigY + nRowSpan;
     268             :         }
     269             :         else
     270             :         {
     271           1 :             pDoc->SkipOverlapped(rCol, rRow, nTab);
     272             :         }
     273             : 
     274           1 :         if (nOld < rRow)
     275             :         {
     276             :             // The block end has moved.  Check the protection setting and move back if needed.
     277           0 :             checkBoundary(rCol, rRow);
     278           0 :             if (!isCellQualified(pDoc, rCol, rRow, nTab, bSelectLocked, bSelectUnlocked))
     279           0 :                 --rRow;
     280             :         }
     281             :     }
     282           2 :     if (nMovY < 0)
     283             :     {
     284           0 :         SCROW nOld = rRow;
     285           0 :         if (bOriginMerged)
     286             :         {
     287           0 :             if (nOrigY > 0 && nOrigY <= rRow && rRow < nOrigY + nRowSpan - 1)
     288             :                 // Block end is still within the merged region.  Push it outside.
     289           0 :                 rRow = nOrigY - 1;
     290             :         }
     291             :         else
     292             :         {
     293           0 :             pDoc->SkipOverlapped(rCol, rRow, nTab);
     294             :         }
     295             : 
     296           0 :         if (nOld > rRow)
     297             :         {
     298             :             // The block end has moved.  Check the protection setting and move back if needed.
     299           0 :             checkBoundary(rCol, rRow);
     300           0 :             if (!isCellQualified(pDoc, rCol, rRow, nTab, bSelectLocked, bSelectUnlocked))
     301           0 :                 ++rRow;
     302             :         }
     303             :     }
     304           2 : }
     305             : 
     306             : }
     307             : 
     308           7 : void ScTabView::PaintMarks(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow )
     309             : {
     310           7 :     if (!ValidCol(nStartCol)) nStartCol = MAXCOL;
     311           7 :     if (!ValidRow(nStartRow)) nStartRow = MAXROW;
     312           7 :     if (!ValidCol(nEndCol)) nEndCol = MAXCOL;
     313           7 :     if (!ValidRow(nEndRow)) nEndRow = MAXROW;
     314             : 
     315           7 :     bool bLeft = (nStartCol==0 && nEndCol==MAXCOL);
     316           7 :     bool bTop = (nStartRow==0 && nEndRow==MAXROW);
     317             : 
     318           7 :     if (bLeft)
     319           0 :         PaintLeftArea( nStartRow, nEndRow );
     320           7 :     if (bTop)
     321           1 :         PaintTopArea( nStartCol, nEndCol );
     322             : 
     323             :     aViewData.GetDocument()->ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow,
     324           7 :                                             aViewData.GetTabNo() );
     325           7 :     PaintArea( nStartCol, nStartRow, nEndCol, nEndRow, SC_UPDATE_MARKS );
     326           7 : }
     327             : 
     328           0 : bool ScTabView::IsMarking( SCCOL nCol, SCROW nRow, SCTAB nTab ) const
     329             : {
     330           0 :     return IsBlockMode()
     331           0 :         && nBlockStartX == nCol
     332           0 :         && nBlockStartY == nRow
     333           0 :         && nBlockStartZ == nTab;
     334             : }
     335             : 
     336         104 : void ScTabView::InitOwnBlockMode()
     337             : {
     338         104 :     if (!IsBlockMode())
     339             :     {
     340             :         //  Wenn keine (alte) Markierung mehr da ist, Anker in SelectionEngine loeschen:
     341             : 
     342         104 :         ScMarkData& rMark = aViewData.GetMarkData();
     343         104 :         if (!rMark.IsMarked() && !rMark.IsMultiMarked())
     344         104 :             GetSelEngine()->CursorPosChanging( false, false );
     345             : 
     346         104 :         meBlockMode = Own;
     347         104 :         nBlockStartX = 0;
     348         104 :         nBlockStartY = 0;
     349         104 :         nBlockStartZ = 0;
     350         104 :         nBlockEndX = 0;
     351         104 :         nBlockEndY = 0;
     352         104 :         nBlockEndZ = 0;
     353             : 
     354         104 :         SelectionChanged();     // Status wird mit gesetzer Markierung abgefragt
     355             :     }
     356         104 : }
     357             : 
     358         211 : void ScTabView::InitBlockMode( SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
     359             :                                bool bTestNeg, bool bCols, bool bRows, bool bForceNeg )
     360             : {
     361         211 :     if (!IsBlockMode())
     362             :     {
     363         211 :         if (!ValidCol(nCurX)) nCurX = MAXCOL;
     364         211 :         if (!ValidRow(nCurY)) nCurY = MAXROW;
     365             : 
     366         211 :         ScMarkData& rMark = aViewData.GetMarkData();
     367         211 :         SCTAB nTab = aViewData.GetTabNo();
     368             : 
     369             :         //  Teil von Markierung aufheben?
     370         211 :         if (bForceNeg)
     371           0 :             bBlockNeg = true;
     372         211 :         else if (bTestNeg)
     373             :         {
     374           1 :             if ( bCols )
     375           0 :                 bBlockNeg = rMark.IsColumnMarked( nCurX );
     376           1 :             else if ( bRows )
     377           0 :                 bBlockNeg = rMark.IsRowMarked( nCurY );
     378             :             else
     379           1 :                 bBlockNeg = rMark.IsCellMarked( nCurX, nCurY );
     380             :         }
     381             :         else
     382         210 :             bBlockNeg = false;
     383         211 :         rMark.SetMarkNegative(bBlockNeg);
     384             : 
     385         211 :         meBlockMode = Normal;
     386         211 :         bBlockCols = bCols;
     387         211 :         bBlockRows = bRows;
     388         211 :         nBlockStartX = nBlockStartXOrig = nCurX;
     389         211 :         nBlockStartY = nBlockStartYOrig = nCurY;
     390         211 :         nBlockStartZ = nCurZ;
     391         211 :         nBlockEndX = nOldCurX = nBlockStartX;
     392         211 :         nBlockEndY = nOldCurY = nBlockStartY;
     393         211 :         nBlockEndZ = nBlockStartZ;
     394             : 
     395         211 :         if (bBlockCols)
     396             :         {
     397           0 :             nBlockStartY = nBlockStartYOrig = 0;
     398           0 :             nBlockEndY = MAXROW;
     399             :         }
     400             : 
     401         211 :         if (bBlockRows)
     402             :         {
     403           0 :             nBlockStartX = nBlockStartXOrig = 0;
     404           0 :             nBlockEndX = MAXCOL;
     405             :         }
     406             : 
     407         211 :         rMark.SetMarkArea( ScRange( nBlockStartX,nBlockStartY, nTab, nBlockEndX,nBlockEndY, nTab ) );
     408             : 
     409         211 :         UpdateSelectionOverlay();
     410             :     }
     411         211 : }
     412             : 
     413        1101 : void ScTabView::DoneBlockMode( bool bContinue )
     414             : {
     415             :     //  Wenn zwischen Tabellen- und Header SelectionEngine gewechselt wird,
     416             :     //  wird evtl. DeselectAll gerufen, weil die andere Engine keinen Anker hat.
     417             :     //  Mit bMoveIsShift wird verhindert, dass dann die Selektion aufgehoben wird.
     418             : 
     419        1101 :     if (IsBlockMode() && !bMoveIsShift)
     420             :     {
     421         307 :         ScMarkData& rMark = aViewData.GetMarkData();
     422         307 :         bool bFlag = rMark.GetMarkingFlag();
     423         307 :         rMark.SetMarking(false);
     424             : 
     425         307 :         if (bBlockNeg && !bContinue)
     426           0 :             rMark.MarkToMulti();
     427             : 
     428         307 :         if (bContinue)
     429           0 :             rMark.MarkToMulti();
     430             :         else
     431             :         {
     432             :             //  Die Tabelle kann an dieser Stelle ungueltig sein, weil DoneBlockMode
     433             :             //  aus SetTabNo aufgerufen wird
     434             :             //  (z.B. wenn die aktuelle Tabelle von einer anderen View aus geloescht wird)
     435             : 
     436         307 :             SCTAB nTab = aViewData.GetTabNo();
     437         307 :             ScDocument* pDoc = aViewData.GetDocument();
     438         307 :             if ( pDoc->HasTable(nTab) )
     439         307 :                 PaintBlock( true );                             // true -> Block loeschen
     440             :             else
     441           0 :                 rMark.ResetMark();
     442             :         }
     443         307 :         meBlockMode = None;
     444             : 
     445         307 :         rMark.SetMarking(bFlag);
     446         307 :         rMark.SetMarkNegative(false);
     447             :     }
     448        1101 : }
     449             : 
     450        1796 : bool ScTabView::IsBlockMode() const
     451             : {
     452        1796 :     return meBlockMode != None;
     453             : }
     454             : 
     455         212 : void ScTabView::MarkCursor( SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
     456             :                             bool bCols, bool bRows, bool bCellSelection )
     457             : {
     458         212 :     if (!ValidCol(nCurX)) nCurX = MAXCOL;
     459         212 :     if (!ValidRow(nCurY)) nCurY = MAXROW;
     460             : 
     461         212 :     if (!IsBlockMode())
     462             :     {
     463             :         OSL_FAIL( "MarkCursor nicht im BlockMode" );
     464           0 :         InitBlockMode( nCurX, nCurY, nCurZ, false, bCols, bRows );
     465             :     }
     466             : 
     467         212 :     if (bCols)
     468           0 :         nCurY = MAXROW;
     469         212 :     if (bRows)
     470           0 :         nCurX = MAXCOL;
     471             : 
     472         212 :     ScMarkData& rMark = aViewData.GetMarkData();
     473             :     OSL_ENSURE(rMark.IsMarked() || rMark.IsMultiMarked(), "MarkCursor, !IsMarked()");
     474         212 :     ScRange aMarkRange;
     475         212 :     rMark.GetMarkArea(aMarkRange);
     476         636 :     if (( aMarkRange.aStart.Col() != nBlockStartX && aMarkRange.aEnd.Col() != nBlockStartX ) ||
     477         636 :         ( aMarkRange.aStart.Row() != nBlockStartY && aMarkRange.aEnd.Row() != nBlockStartY ) ||
     478         212 :         ( meBlockMode == Own ))
     479             :     {
     480             :         //  Markierung ist veraendert worden
     481             :         //  (z.B. MarkToSimple, wenn per negativ alles bis auf ein Rechteck geloescht wurde)
     482             :         //  oder nach InitOwnBlockMode wird mit Shift-Klick weitermarkiert...
     483             : 
     484           0 :         bool bOldShift = bMoveIsShift;
     485           0 :         bMoveIsShift = false;               //  wirklich umsetzen
     486           0 :         DoneBlockMode(false);               //! direkt Variablen setzen? (-> kein Geflacker)
     487           0 :         bMoveIsShift = bOldShift;
     488             : 
     489           0 :         InitBlockMode( aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
     490           0 :                         nBlockStartZ, rMark.IsMarkNegative(), bCols, bRows );
     491             :     }
     492             : 
     493         212 :     if ( nCurX != nOldCurX || nCurY != nOldCurY )
     494             :     {
     495             :         // Current cursor has moved
     496             : 
     497          22 :         SCTAB nTab = nCurZ;
     498             : 
     499          22 :         if ( bCellSelection )
     500             :         {
     501             :             // Expand selection area accordingly when the current selection ends
     502             :             // with a merged cell.
     503           2 :             SCsCOL nCurXOffset = 0;
     504           2 :             SCsCOL nBlockStartXOffset = 0;
     505           2 :             SCsROW nCurYOffset = 0;
     506           2 :             SCsROW nBlockStartYOffset = 0;
     507           2 :             bool bBlockStartMerged = false;
     508           2 :             const ScMergeAttr* pMergeAttr = NULL;
     509           2 :             ScDocument* pDocument = aViewData.GetDocument();
     510             : 
     511             :             // The following block checks whether or not the "BlockStart" (anchor)
     512             :             // cell is merged.  If it's merged, it'll then move the position of the
     513             :             // anchor cell to the corner that's diagonally opposite of the
     514             :             // direction of a current selection area.  For instance, if a current
     515             :             // selection is moving in the upperleft direction, the anchor cell will
     516             :             // move to the lower-right corner of the merged anchor cell, and so on.
     517             : 
     518             :             pMergeAttr = static_cast<const ScMergeAttr*>(
     519           2 :                 pDocument->GetAttr( nBlockStartXOrig, nBlockStartYOrig, nTab, ATTR_MERGE ) );
     520           2 :             if ( pMergeAttr->IsMerged() )
     521             :             {
     522           0 :                 SCsCOL nColSpan = pMergeAttr->GetColMerge();
     523           0 :                 SCsROW nRowSpan = pMergeAttr->GetRowMerge();
     524             : 
     525           0 :                 if ( !( nCurX >= nBlockStartXOrig + nColSpan - 1 && nCurY >= nBlockStartYOrig + nRowSpan - 1 ) )
     526             :                 {
     527           0 :                     nBlockStartX = nCurX >= nBlockStartXOrig ? nBlockStartXOrig : nBlockStartXOrig + nColSpan - 1;
     528           0 :                     nBlockStartY = nCurY >= nBlockStartYOrig ? nBlockStartYOrig : nBlockStartYOrig + nRowSpan - 1;
     529           0 :                     nCurXOffset  = (nCurX >= nBlockStartXOrig && nCurX < nBlockStartXOrig + nColSpan - 1) ?
     530           0 :                         nBlockStartXOrig - nCurX + nColSpan - 1 : 0;
     531           0 :                     nCurYOffset  = (nCurY >= nBlockStartYOrig && nCurY < nBlockStartYOrig + nRowSpan - 1) ?
     532           0 :                         nBlockStartYOrig - nCurY + nRowSpan - 1 : 0;
     533           0 :                     bBlockStartMerged = true;
     534             :                 }
     535             :             }
     536             : 
     537             :             // The following block checks whether or not the current cell is
     538             :             // merged.  If it is, it'll then set the appropriate X & Y offset
     539             :             // values (nCurXOffset & nCurYOffset) such that the selection area will
     540             :             // grow by those specified offset amounts.  Note that the values of
     541             :             // nCurXOffset/nCurYOffset may also be specified in the previous code
     542             :             // block, in which case whichever value is greater will take on.
     543             : 
     544             :             pMergeAttr = static_cast<const ScMergeAttr*>(
     545           2 :                 pDocument->GetAttr( nCurX, nCurY, nTab, ATTR_MERGE ) );
     546           2 :             if ( pMergeAttr->IsMerged() )
     547             :             {
     548           0 :                 SCsCOL nColSpan = pMergeAttr->GetColMerge();
     549           0 :                 SCsROW nRowSpan = pMergeAttr->GetRowMerge();
     550             : 
     551           0 :                 if ( !( nBlockStartX >= nCurX + nColSpan - 1 && nBlockStartY >= nCurY + nRowSpan - 1 ) )
     552             :                 {
     553           0 :                     if ( nBlockStartX <= nCurX + nColSpan - 1 )
     554             :                     {
     555           0 :                         SCsCOL nCurXOffsetTemp = (nCurX < nCurX + nColSpan - 1) ? nColSpan - 1 : 0;
     556           0 :                         nCurXOffset = nCurXOffset > nCurXOffsetTemp ? nCurXOffset : nCurXOffsetTemp;
     557             :                     }
     558           0 :                     if ( nBlockStartY <= nCurY + nRowSpan - 1 )
     559             :                     {
     560           0 :                         SCsROW nCurYOffsetTemp = (nCurY < nCurY + nRowSpan - 1) ? nRowSpan - 1 : 0;
     561           0 :                         nCurYOffset = nCurYOffset > nCurYOffsetTemp ? nCurYOffset : nCurYOffsetTemp;
     562             :                     }
     563           0 :                     if ( !( nBlockStartX <= nCurX && nBlockStartY <= nCurY ) &&
     564           0 :                          !( nBlockStartX > nCurX + nColSpan - 1 && nBlockStartY > nCurY + nRowSpan - 1 ) )
     565             :                     {
     566           0 :                         nBlockStartXOffset = (nBlockStartX > nCurX && nBlockStartX <= nCurX + nColSpan - 1) ? nCurX - nBlockStartX : 0;
     567           0 :                         nBlockStartYOffset = (nBlockStartY > nCurY && nBlockStartY <= nCurY + nRowSpan - 1) ? nCurY - nBlockStartY : 0;
     568             :                     }
     569             :                 }
     570             :             }
     571             :             else
     572             :             {
     573             :                 // The current cell is not merged.  Move the anchor cell to its
     574             :                 // original position.
     575           2 :                 if ( !bBlockStartMerged )
     576             :                 {
     577           2 :                     nBlockStartX = nBlockStartXOrig;
     578           2 :                     nBlockStartY = nBlockStartYOrig;
     579             :                 }
     580             :             }
     581             : 
     582           2 :             nBlockStartX = nBlockStartX + nBlockStartXOffset >= 0 ? nBlockStartX + nBlockStartXOffset : 0;
     583           2 :             nBlockStartY = nBlockStartY + nBlockStartYOffset >= 0 ? nBlockStartY + nBlockStartYOffset : 0;
     584           2 :             nBlockEndX = nCurX + nCurXOffset > MAXCOL ? MAXCOL : nCurX + nCurXOffset;
     585           2 :             nBlockEndY = nCurY + nCurYOffset > MAXROW ? MAXROW : nCurY + nCurYOffset;
     586             :         }
     587             :         else
     588             :         {
     589          20 :             nBlockEndX = nCurX;
     590          20 :             nBlockEndY = nCurY;
     591             :         }
     592             : 
     593             :         // Set new selection area
     594          22 :         rMark.SetMarkArea( ScRange( nBlockStartX, nBlockStartY, nTab, nBlockEndX, nBlockEndY, nTab ) );
     595             : 
     596          22 :         UpdateSelectionOverlay();
     597          22 :         SelectionChanged();
     598             : 
     599          22 :         nOldCurX = nCurX;
     600          22 :         nOldCurY = nCurY;
     601             : 
     602          22 :         aViewData.GetViewShell()->UpdateInputHandler();
     603             :     }
     604             : 
     605         212 :     if ( !bCols && !bRows )
     606         212 :         aHdrFunc.SetAnchorFlag( false );
     607         212 : }
     608             : 
     609           0 : void ScTabView::GetPageMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, SCsCOL& rPageX, SCsROW& rPageY)
     610             : {
     611             :     SCCOL nCurX;
     612             :     SCROW nCurY;
     613           0 :     if (aViewData.IsRefMode())
     614             :     {
     615           0 :         nCurX = aViewData.GetRefEndX();
     616           0 :         nCurY = aViewData.GetRefEndY();
     617             :     }
     618           0 :     else if (IsBlockMode())
     619             :     {
     620             :         // block end position.
     621           0 :         nCurX = nBlockEndX;
     622           0 :         nCurY = nBlockEndY;
     623             :     }
     624             :     else
     625             :     {
     626             :         // cursor position
     627           0 :         nCurX = aViewData.GetCurX();
     628           0 :         nCurY = aViewData.GetCurY();
     629             :     }
     630             : 
     631           0 :     ScSplitPos eWhich = aViewData.GetActivePart();
     632           0 :     ScHSplitPos eWhichX = WhichH( eWhich );
     633           0 :     ScVSplitPos eWhichY = WhichV( eWhich );
     634             : 
     635             :     SCsCOL nPageX;
     636             :     SCsROW nPageY;
     637           0 :     if (nMovX >= 0)
     638           0 :         nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, 1, eWhichX )) * nMovX;
     639             :     else
     640           0 :         nPageX = ((SCsCOL) aViewData.CellsAtX( nCurX, -1, eWhichX )) * nMovX;
     641             : 
     642           0 :     if (nMovY >= 0)
     643           0 :         nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, 1, eWhichY )) * nMovY;
     644             :     else
     645           0 :         nPageY = ((SCsROW) aViewData.CellsAtY( nCurY, -1, eWhichY )) * nMovY;
     646             : 
     647           0 :     if (nMovX != 0 && nPageX == 0) nPageX = (nMovX>0) ? 1 : -1;
     648           0 :     if (nMovY != 0 && nPageY == 0) nPageY = (nMovY>0) ? 1 : -1;
     649             : 
     650           0 :     rPageX = nPageX;
     651           0 :     rPageY = nPageY;
     652           0 : }
     653             : 
     654          83 : void ScTabView::GetAreaMoveEndPosition(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode,
     655             :                                        SCsCOL& rAreaX, SCsROW& rAreaY, ScFollowMode& rMode)
     656             : {
     657          83 :     SCCOL nNewX = -1;
     658          83 :     SCROW nNewY = -1;
     659             : 
     660             :     // current cursor position.
     661          83 :     SCCOL nCurX = aViewData.GetCurX();
     662          83 :     SCROW nCurY = aViewData.GetCurY();
     663             : 
     664          83 :     if (aViewData.IsRefMode())
     665             :     {
     666           0 :         nNewX = aViewData.GetRefEndX();
     667           0 :         nNewY = aViewData.GetRefEndY();
     668           0 :         nCurX = aViewData.GetRefStartX();
     669           0 :         nCurY = aViewData.GetRefStartY();
     670             :     }
     671          83 :     else if (IsBlockMode())
     672             :     {
     673             :         // block end position.
     674          83 :         nNewX = nBlockEndX;
     675          83 :         nNewY = nBlockEndY;
     676             :     }
     677             :     else
     678             :     {
     679           0 :         nNewX = nCurX;
     680           0 :         nNewY = nCurY;
     681             :     }
     682             : 
     683          83 :     ScDocument* pDoc = aViewData.GetDocument();
     684          83 :     SCTAB nTab = aViewData.GetTabNo();
     685             : 
     686             :     //  FindAreaPos kennt nur -1 oder 1 als Richtung
     687          83 :     ScModule* pScModule = SC_MOD();
     688          83 :     bool bLegacyCellSelection = pScModule->GetInputOptions().GetLegacyCellSelection();
     689          83 :     SCCOL nVirtualX = bLegacyCellSelection ? nNewX : nCurX;
     690          83 :     SCROW nVirtualY = bLegacyCellSelection ? nNewY : nCurY;
     691             : 
     692             :     SCsCOLROW i;
     693          83 :     if ( nMovX > 0 )
     694          42 :         for ( i=0; i<nMovX; i++ )
     695          21 :             pDoc->FindAreaPos( nNewX, nVirtualY, nTab,  SC_MOVE_RIGHT );
     696          83 :     if ( nMovX < 0 )
     697          42 :         for ( i=0; i<-nMovX; i++ )
     698          21 :             pDoc->FindAreaPos( nNewX, nVirtualY, nTab,  SC_MOVE_LEFT );
     699          83 :     if ( nMovY > 0 )
     700          40 :         for ( i=0; i<nMovY; i++ )
     701          20 :             pDoc->FindAreaPos( nVirtualX, nNewY, nTab,  SC_MOVE_DOWN );
     702          83 :     if ( nMovY < 0 )
     703          42 :         for ( i=0; i<-nMovY; i++ )
     704          21 :             pDoc->FindAreaPos( nVirtualX, nNewY, nTab,  SC_MOVE_UP );
     705             : 
     706          83 :     if (eMode==SC_FOLLOW_JUMP)                  // unten/rechts nicht zuviel grau anzeigen
     707             :     {
     708          83 :         if (nMovX != 0 && nNewX == MAXCOL)
     709           5 :             eMode = SC_FOLLOW_LINE;
     710          83 :         if (nMovY != 0 && nNewY == MAXROW)
     711           4 :             eMode = SC_FOLLOW_LINE;
     712             :     }
     713             : 
     714          83 :     if (aViewData.IsRefMode())
     715             :     {
     716           0 :         rAreaX = nNewX - aViewData.GetRefEndX();
     717           0 :         rAreaY = nNewY - aViewData.GetRefEndY();
     718             :     }
     719          83 :     else if (IsBlockMode())
     720             :     {
     721          83 :         rAreaX = nNewX - nBlockEndX;
     722          83 :         rAreaY = nNewY - nBlockEndY;
     723             :     }
     724             :     else
     725             :     {
     726           0 :         rAreaX = nNewX - nCurX;
     727           0 :         rAreaY = nNewY - nCurY;
     728             :     }
     729          83 :     rMode = eMode;
     730          83 : }
     731             : 
     732          34 : void ScTabView::SkipCursorHorizontal(SCsCOL& rCurX, SCsROW& rCurY, SCsCOL nOldX, SCsROW nMovX)
     733             : {
     734          34 :     ScDocument* pDoc = aViewData.GetDocument();
     735          34 :     SCTAB nTab = aViewData.GetTabNo();
     736             : 
     737          34 :     bool bSkipProtected = false, bSkipUnprotected = false;
     738          34 :     ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
     739          34 :     if (pProtect && pProtect->isProtected())
     740             :     {
     741           0 :         bSkipProtected   = !pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
     742           0 :         bSkipUnprotected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
     743             :     }
     744             : 
     745          34 :     bool bSkipCell = false;
     746          34 :     bool bHFlip = false;
     747          34 :     do
     748             :     {
     749          34 :         bSkipCell = pDoc->ColHidden(rCurX, nTab) || pDoc->IsHorOverlapped(rCurX, rCurY, nTab);
     750          34 :         if (bSkipProtected && !bSkipCell)
     751           0 :             bSkipCell = pDoc->HasAttrib(rCurX, rCurY, nTab, rCurX, rCurY, nTab, HASATTR_PROTECTED);
     752          34 :         if (bSkipUnprotected && !bSkipCell)
     753           0 :             bSkipCell = !pDoc->HasAttrib(rCurX, rCurY, nTab, rCurX, rCurY, nTab, HASATTR_PROTECTED);
     754             : 
     755          34 :         if (bSkipCell)
     756             :         {
     757           0 :             if (rCurX <= 0 || rCurX >= MAXCOL)
     758             :             {
     759           0 :                 if (bHFlip)
     760             :                 {
     761           0 :                     rCurX = nOldX;
     762           0 :                     bSkipCell = false;
     763             :                 }
     764             :                 else
     765             :                 {
     766           0 :                     nMovX = -nMovX;
     767           0 :                     if (nMovX > 0)
     768           0 :                         ++rCurX;
     769             :                     else
     770           0 :                         --rCurX;
     771           0 :                     bHFlip = true;
     772             :                 }
     773             :             }
     774             :             else
     775           0 :                 if (nMovX > 0)
     776           0 :                     ++rCurX;
     777             :                 else
     778           0 :                     --rCurX;
     779             :         }
     780             :     }
     781             :     while (bSkipCell);
     782             : 
     783          34 :     if (pDoc->IsVerOverlapped(rCurX, rCurY, nTab))
     784             :     {
     785           0 :         aViewData.SetOldCursor(rCurX, rCurY);
     786           0 :         while (pDoc->IsVerOverlapped(rCurX, rCurY, nTab))
     787           0 :             --rCurY;
     788             :     }
     789          34 : }
     790             : 
     791          33 : void ScTabView::SkipCursorVertical(SCsCOL& rCurX, SCsROW& rCurY, SCsROW nOldY, SCsROW nMovY)
     792             : {
     793          33 :     ScDocument* pDoc = aViewData.GetDocument();
     794          33 :     SCTAB nTab = aViewData.GetTabNo();
     795             : 
     796          33 :     bool bSkipProtected = false, bSkipUnprotected = false;
     797          33 :     ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
     798          33 :     if (pProtect && pProtect->isProtected())
     799             :     {
     800           0 :         bSkipProtected   = !pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
     801           0 :         bSkipUnprotected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
     802             :     }
     803             : 
     804          33 :     bool bSkipCell = false;
     805          33 :     bool bVFlip = false;
     806          33 :     do
     807             :     {
     808          33 :         SCROW nLastRow = -1;
     809          33 :         bSkipCell = pDoc->RowHidden(rCurY, nTab, NULL, &nLastRow) || pDoc->IsVerOverlapped( rCurX, rCurY, nTab );
     810          33 :         if (bSkipProtected && !bSkipCell)
     811           0 :             bSkipCell = pDoc->HasAttrib(rCurX, rCurY, nTab, rCurX, rCurY, nTab, HASATTR_PROTECTED);
     812          33 :         if (bSkipUnprotected && !bSkipCell)
     813           0 :             bSkipCell = !pDoc->HasAttrib(rCurX, rCurY, nTab, rCurX, rCurY, nTab, HASATTR_PROTECTED);
     814             : 
     815          33 :         if (bSkipCell)
     816             :         {
     817           0 :             if (rCurY <= 0 || rCurY >= MAXROW)
     818             :             {
     819           0 :                 if (bVFlip)
     820             :                 {
     821           0 :                     rCurY = nOldY;
     822           0 :                     bSkipCell = false;
     823             :                 }
     824             :                 else
     825             :                 {
     826           0 :                     nMovY = -nMovY;
     827           0 :                     if (nMovY > 0)
     828           0 :                         ++rCurY;
     829             :                     else
     830           0 :                         --rCurY;
     831           0 :                     bVFlip = true;
     832             :                 }
     833             :             }
     834             :             else
     835           0 :                 if (nMovY > 0)
     836           0 :                     ++rCurY;
     837             :                 else
     838           0 :                     --rCurY;
     839             :         }
     840             :     }
     841             :     while (bSkipCell);
     842             : 
     843          33 :     if (pDoc->IsHorOverlapped(rCurX, rCurY, nTab))
     844             :     {
     845           0 :         aViewData.SetOldCursor(rCurX, rCurY);
     846           0 :         while (pDoc->IsHorOverlapped(rCurX, rCurY, nTab))
     847           0 :             --rCurX;
     848             :     }
     849          33 : }
     850             : 
     851           2 : void ScTabView::ExpandBlock(SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode)
     852             : {
     853           2 :     if (!nMovX && !nMovY)
     854             :         // Nothing to do.  Bail out.
     855           2 :         return;
     856             : 
     857           2 :     ScTabViewShell* pViewShell = aViewData.GetViewShell();
     858           2 :     bool bRefInputMode = pViewShell && pViewShell->IsRefInputMode();
     859           2 :     if (bRefInputMode && !aViewData.IsRefMode())
     860             :         // initialize formula reference mode if it hasn't already.
     861           0 :         InitRefMode(aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo(), SC_REFTYPE_REF);
     862             : 
     863           2 :     ScDocument* pDoc = aViewData.GetDocument();
     864             : 
     865           2 :     if (aViewData.IsRefMode())
     866             :     {
     867             :         // formula reference mode
     868             : 
     869           0 :         SCCOL nNewX = aViewData.GetRefEndX();
     870           0 :         SCROW nNewY = aViewData.GetRefEndY();
     871           0 :         SCTAB nRefTab = aViewData.GetRefEndZ();
     872             : 
     873           0 :         bool bSelectLocked = true;
     874           0 :         bool bSelectUnlocked = true;
     875           0 :         ScTableProtection* pTabProtection = pDoc->GetTabProtection(nRefTab);
     876           0 :         if (pTabProtection && pTabProtection->isProtected())
     877             :         {
     878           0 :             bSelectLocked   = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
     879           0 :             bSelectUnlocked = pTabProtection->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
     880             :         }
     881             : 
     882           0 :         moveCursorByProtRule(nNewX, nNewY, nMovX, nMovY, nRefTab, pDoc);
     883           0 :         checkBoundary(nNewX, nNewY);
     884             : 
     885           0 :         if (nMovX)
     886             :         {
     887           0 :             SCCOL nTempX = nNewX;
     888           0 :             while (pDoc->IsHorOverlapped(nTempX, nNewY, nRefTab))
     889             :             {
     890           0 :                 if (nMovX > 0)
     891           0 :                     ++nTempX;
     892             :                 else
     893           0 :                     --nTempX;
     894           0 :                 if (!checkBoundary(nTempX, nNewY))
     895           0 :                     break;
     896             :             }
     897           0 :             if (isCellQualified(pDoc, nTempX, nNewY, nRefTab, bSelectLocked, bSelectUnlocked))
     898           0 :                 nNewX = nTempX;
     899             :         }
     900             : 
     901           0 :         if (nMovY)
     902             :         {
     903           0 :             SCROW nTempY = nNewY;
     904           0 :             while (pDoc->IsVerOverlapped(nNewX, nTempY, nRefTab))
     905             :             {
     906           0 :                 if (nMovY > 0)
     907           0 :                     ++nTempY;
     908             :                 else
     909           0 :                     --nTempY;
     910           0 :                 if (!checkBoundary(nNewX, nTempY))
     911           0 :                     break;
     912             :             }
     913           0 :             if (isCellQualified(pDoc, nNewX, nTempY, nRefTab, bSelectLocked, bSelectUnlocked))
     914           0 :                 nNewY = nTempY;
     915             :         }
     916             : 
     917           0 :         pDoc->SkipOverlapped(nNewX, nNewY, nRefTab);
     918           0 :         UpdateRef(nNewX, nNewY, nRefTab);
     919           0 :         AlignToCursor(nNewX, nNewY, eMode);
     920             :     }
     921             :     else
     922             :     {
     923             :         // normal selection mode
     924             : 
     925           2 :         SCTAB nTab = aViewData.GetTabNo();
     926           2 :         SCCOL nOrigX = aViewData.GetCurX();
     927           2 :         SCROW nOrigY = aViewData.GetCurY();
     928             : 
     929             :         // Note that the origin position *never* moves during selection.
     930             : 
     931           2 :         if (!IsBlockMode())
     932           1 :             InitBlockMode(nOrigX, nOrigY, nTab, true);
     933             : 
     934           2 :         moveCursorByProtRule(nBlockEndX, nBlockEndY, nMovX, nMovY, nTab, pDoc);
     935           2 :         checkBoundary(nBlockEndX, nBlockEndY);
     936           2 :         moveCursorByMergedCell(nBlockEndX, nBlockEndY, nMovX, nMovY, nTab, pDoc, aViewData);
     937           2 :         checkBoundary(nBlockEndX, nBlockEndY);
     938             : 
     939           2 :         MarkCursor(nBlockEndX, nBlockEndY, nTab, false, false, true);
     940             : 
     941             :         // Check if the entire row(s) or column(s) are selected.
     942           2 :         ScSplitPos eActive = aViewData.GetActivePart();
     943           2 :         bool bRowSelected = (nBlockStartX == 0 && nBlockEndX == MAXCOL);
     944           2 :         bool bColSelected = (nBlockStartY == 0 && nBlockEndY == MAXROW);
     945           2 :         SCsCOL nAlignX = bRowSelected ? aViewData.GetPosX(WhichH(eActive)) : nBlockEndX;
     946           2 :         SCsROW nAlignY = bColSelected ? aViewData.GetPosY(WhichV(eActive)) : nBlockEndY;
     947           2 :         AlignToCursor(nAlignX, nAlignY, eMode);
     948             : 
     949           2 :         SelectionChanged();
     950             :     }
     951             : }
     952             : 
     953           0 : void ScTabView::ExpandBlockPage(SCsCOL nMovX, SCsROW nMovY)
     954             : {
     955             :     SCsCOL nPageX;
     956             :     SCsROW nPageY;
     957           0 :     GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
     958           0 :     ExpandBlock(nPageX, nPageY, SC_FOLLOW_FIX);
     959           0 : }
     960             : 
     961           0 : void ScTabView::ExpandBlockArea(SCsCOL nMovX, SCsROW nMovY)
     962             : {
     963             :     SCsCOL nAreaX;
     964             :     SCsROW nAreaY;
     965             :     ScFollowMode eMode;
     966           0 :     GetAreaMoveEndPosition(nMovX, nMovY, SC_FOLLOW_JUMP, nAreaX, nAreaY, eMode);
     967           0 :     ExpandBlock(nAreaX, nAreaY, eMode);
     968           0 : }
     969             : 
     970           0 : void ScTabView::UpdateCopySourceOverlay()
     971             : {
     972           0 :     for (sal_uInt8 i = 0; i < 4; ++i)
     973           0 :         if (pGridWin[i] && pGridWin[i]->IsVisible())
     974           0 :             pGridWin[i]->UpdateCopySourceOverlay();
     975           0 : }
     976             : 
     977         476 : void ScTabView::UpdateSelectionOverlay()
     978             : {
     979        2380 :     for (sal_uInt16 i=0; i<4; i++)
     980        1904 :         if ( pGridWin[i] && pGridWin[i]->IsVisible() )
     981         476 :             pGridWin[i]->UpdateSelectionOverlay();
     982         476 : }
     983             : 
     984           0 : void ScTabView::UpdateShrinkOverlay()
     985             : {
     986           0 :     for (sal_uInt16 i=0; i<4; i++)
     987           0 :         if ( pGridWin[i] && pGridWin[i]->IsVisible() )
     988           0 :             pGridWin[i]->UpdateShrinkOverlay();
     989           0 : }
     990             : 
     991        2275 : void ScTabView::UpdateAllOverlays()
     992             : {
     993       11375 :     for (sal_uInt16 i=0; i<4; i++)
     994        9100 :         if ( pGridWin[i] && pGridWin[i]->IsVisible() )
     995        1957 :             pGridWin[i]->UpdateAllOverlays();
     996        2275 : }
     997             : 
     998             : //!
     999             : //! PaintBlock in zwei Methoden aufteilen: RepaintBlock und RemoveBlock o.ae.
    1000             : //!
    1001             : 
    1002         981 : void ScTabView::PaintBlock( bool bReset )
    1003             : {
    1004         981 :     ScMarkData& rMark = aViewData.GetMarkData();
    1005         981 :     SCTAB nTab = aViewData.GetTabNo();
    1006         981 :     bool bMulti = rMark.IsMultiMarked();
    1007         981 :     if (rMark.IsMarked() || bMulti)
    1008             :     {
    1009         146 :         ScRange aMarkRange;
    1010         146 :         HideAllCursors();
    1011         146 :         if (bMulti)
    1012             :         {
    1013           3 :             bool bFlag = rMark.GetMarkingFlag();
    1014           3 :             rMark.SetMarking(false);
    1015           3 :             rMark.MarkToMulti();
    1016           3 :             rMark.GetMultiMarkArea(aMarkRange);
    1017           3 :             rMark.MarkToSimple();
    1018           3 :             rMark.SetMarking(bFlag);
    1019             :         }
    1020             :         else
    1021         143 :             rMark.GetMarkArea(aMarkRange);
    1022             : 
    1023         146 :         nBlockStartX = aMarkRange.aStart.Col();
    1024         146 :         nBlockStartY = aMarkRange.aStart.Row();
    1025         146 :         nBlockStartZ = aMarkRange.aStart.Tab();
    1026         146 :         nBlockEndX = aMarkRange.aEnd.Col();
    1027         146 :         nBlockEndY = aMarkRange.aEnd.Row();
    1028         146 :         nBlockEndZ = aMarkRange.aEnd.Tab();
    1029             : 
    1030         146 :         bool bDidReset = false;
    1031             : 
    1032         146 :         if ( nTab>=nBlockStartZ && nTab<=nBlockEndZ )
    1033             :         {
    1034         146 :             if ( bReset )
    1035             :             {
    1036             :                 // Invertieren beim Loeschen nur auf aktiver View
    1037         139 :                 if ( aViewData.IsActive() )
    1038             :                 {
    1039         139 :                     rMark.ResetMark();
    1040         139 :                     UpdateSelectionOverlay();
    1041         139 :                     bDidReset = true;
    1042             :                 }
    1043             :             }
    1044             :             else
    1045           7 :                 PaintMarks( nBlockStartX, nBlockStartY, nBlockEndX, nBlockEndY );
    1046             :         }
    1047             : 
    1048         146 :         if ( bReset && !bDidReset )
    1049           0 :             rMark.ResetMark();
    1050             : 
    1051         146 :         ShowAllCursors();
    1052             :     }
    1053         981 : }
    1054             : 
    1055           0 : void ScTabView::SelectAll( bool bContinue )
    1056             : {
    1057           0 :     ScMarkData& rMark = aViewData.GetMarkData();
    1058           0 :     SCTAB nTab = aViewData.GetTabNo();
    1059             : 
    1060           0 :     if (rMark.IsMarked())
    1061             :     {
    1062           0 :         ScRange aMarkRange;
    1063           0 :         rMark.GetMarkArea( aMarkRange );
    1064           0 :         if ( aMarkRange == ScRange( 0,0,nTab, MAXCOL,MAXROW,nTab ) )
    1065           0 :             return;
    1066             :     }
    1067             : 
    1068           0 :     DoneBlockMode( bContinue );
    1069           0 :     InitBlockMode( 0,0,nTab );
    1070           0 :     MarkCursor( MAXCOL,MAXROW,nTab );
    1071             : 
    1072           0 :     SelectionChanged();
    1073             : }
    1074             : 
    1075           0 : void ScTabView::SelectAllTables()
    1076             : {
    1077           0 :     ScDocument* pDoc = aViewData.GetDocument();
    1078           0 :     ScMarkData& rMark = aViewData.GetMarkData();
    1079           0 :     SCTAB nCount = pDoc->GetTableCount();
    1080             : 
    1081           0 :     if (nCount>1)
    1082             :     {
    1083           0 :         for (SCTAB i=0; i<nCount; i++)
    1084           0 :             rMark.SelectTable( i, true );
    1085             : 
    1086           0 :         aViewData.GetDocShell()->PostPaintExtras();
    1087           0 :         SfxBindings& rBind = aViewData.GetBindings();
    1088           0 :         rBind.Invalidate( FID_FILL_TAB );
    1089           0 :         rBind.Invalidate( FID_TAB_DESELECTALL );
    1090             :     }
    1091           0 : }
    1092             : 
    1093           0 : void ScTabView::DeselectAllTables()
    1094             : {
    1095           0 :     ScDocument* pDoc = aViewData.GetDocument();
    1096           0 :     ScMarkData& rMark = aViewData.GetMarkData();
    1097           0 :     SCTAB nTab = aViewData.GetTabNo();
    1098           0 :     SCTAB nCount = pDoc->GetTableCount();
    1099             : 
    1100           0 :     for (SCTAB i=0; i<nCount; i++)
    1101           0 :         rMark.SelectTable( i, ( i == nTab ) );
    1102             : 
    1103           0 :     aViewData.GetDocShell()->PostPaintExtras();
    1104           0 :     SfxBindings& rBind = aViewData.GetBindings();
    1105           0 :     rBind.Invalidate( FID_FILL_TAB );
    1106           0 :     rBind.Invalidate( FID_TAB_DESELECTALL );
    1107           0 : }
    1108             : 
    1109           0 : static bool lcl_FitsInWindow( double fScaleX, double fScaleY, sal_uInt16 nZoom,
    1110             :                         long nWindowX, long nWindowY, ScDocument* pDoc, SCTAB nTab,
    1111             :                         SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
    1112             :                         SCCOL nFixPosX, SCROW nFixPosY )
    1113             : {
    1114           0 :     double fZoomFactor = (double)Fraction(nZoom,100);
    1115           0 :     fScaleX *= fZoomFactor;
    1116           0 :     fScaleY *= fZoomFactor;
    1117             : 
    1118           0 :     long nBlockX = 0;
    1119             :     SCCOL nCol;
    1120           0 :     for (nCol=0; nCol<nFixPosX; nCol++)
    1121             :     {
    1122             :         //  for frozen panes, add both parts
    1123           0 :         sal_uInt16 nColTwips = pDoc->GetColWidth( nCol, nTab );
    1124           0 :         if (nColTwips)
    1125             :         {
    1126           0 :             nBlockX += (long)(nColTwips * fScaleX);
    1127           0 :             if (nBlockX > nWindowX)
    1128           0 :                 return false;
    1129             :         }
    1130             :     }
    1131           0 :     for (nCol=nStartCol; nCol<=nEndCol; nCol++)
    1132             :     {
    1133           0 :         sal_uInt16 nColTwips = pDoc->GetColWidth( nCol, nTab );
    1134           0 :         if (nColTwips)
    1135             :         {
    1136           0 :             nBlockX += (long)(nColTwips * fScaleX);
    1137           0 :             if (nBlockX > nWindowX)
    1138           0 :                 return false;
    1139             :         }
    1140             :     }
    1141             : 
    1142           0 :     long nBlockY = 0;
    1143           0 :     for (SCROW nRow = 0; nRow <= nFixPosY-1; ++nRow)
    1144             :     {
    1145           0 :         if (pDoc->RowHidden(nRow, nTab))
    1146           0 :             continue;
    1147             : 
    1148             :         //  for frozen panes, add both parts
    1149           0 :         sal_uInt16 nRowTwips = pDoc->GetRowHeight(nRow, nTab);
    1150           0 :         if (nRowTwips)
    1151             :         {
    1152           0 :             nBlockY += (long)(nRowTwips * fScaleY);
    1153           0 :             if (nBlockY > nWindowY)
    1154           0 :                 return false;
    1155             :         }
    1156             :     }
    1157           0 :     for (SCROW nRow = nStartRow; nRow <= nEndRow; ++nRow)
    1158             :     {
    1159           0 :         sal_uInt16 nRowTwips = pDoc->GetRowHeight(nRow, nTab);
    1160           0 :         if (nRowTwips)
    1161             :         {
    1162           0 :             nBlockY += (long)(nRowTwips * fScaleY);
    1163           0 :             if (nBlockY > nWindowY)
    1164           0 :                 return false;
    1165             :         }
    1166             :     }
    1167             : 
    1168           0 :     return true;
    1169             : }
    1170             : 
    1171           0 : sal_uInt16 ScTabView::CalcZoom( SvxZoomType eType, sal_uInt16 nOldZoom )
    1172             : {
    1173           0 :     sal_uInt16 nZoom = 100;
    1174             : 
    1175           0 :     switch ( eType )
    1176             :     {
    1177             :         case SvxZoomType::PERCENT: // rZoom ist kein besonderer prozentualer Wert
    1178           0 :             nZoom = nOldZoom;
    1179           0 :             break;
    1180             : 
    1181             :         case SvxZoomType::OPTIMAL:  // nZoom entspricht der optimalen Gr"o\se
    1182             :             {
    1183           0 :                 ScMarkData& rMark = aViewData.GetMarkData();
    1184           0 :                 ScDocument* pDoc = aViewData.GetDocument();
    1185             : 
    1186           0 :                 if (!rMark.IsMarked() && !rMark.IsMultiMarked())
    1187           0 :                     nZoom = 100;                // nothing selected
    1188             :                 else
    1189             :                 {
    1190           0 :                     SCTAB   nTab = aViewData.GetTabNo();
    1191           0 :                     ScRange aMarkRange;
    1192           0 :                     if ( aViewData.GetSimpleArea( aMarkRange ) != SC_MARK_SIMPLE )
    1193           0 :                         rMark.GetMultiMarkArea( aMarkRange );
    1194             : 
    1195           0 :                     SCCOL   nStartCol = aMarkRange.aStart.Col();
    1196           0 :                     SCROW   nStartRow = aMarkRange.aStart.Row();
    1197           0 :                     SCTAB   nStartTab = aMarkRange.aStart.Tab();
    1198           0 :                     SCCOL   nEndCol = aMarkRange.aEnd.Col();
    1199           0 :                     SCROW   nEndRow = aMarkRange.aEnd.Row();
    1200           0 :                     SCTAB   nEndTab = aMarkRange.aEnd.Tab();
    1201             : 
    1202           0 :                     if ( nTab < nStartTab && nTab > nEndTab )
    1203           0 :                         nTab = nStartTab;
    1204             : 
    1205           0 :                     ScSplitPos eUsedPart = aViewData.GetActivePart();
    1206             : 
    1207           0 :                     SCCOL nFixPosX = 0;
    1208           0 :                     SCROW nFixPosY = 0;
    1209           0 :                     if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
    1210             :                     {
    1211             :                         //  use right part
    1212           0 :                         eUsedPart = (WhichV(eUsedPart)==SC_SPLIT_TOP) ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT;
    1213           0 :                         nFixPosX = aViewData.GetFixPosX();
    1214           0 :                         if ( nStartCol < nFixPosX )
    1215           0 :                             nStartCol = nFixPosX;
    1216             :                     }
    1217           0 :                     if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
    1218             :                     {
    1219             :                         //  use bottom part
    1220           0 :                         eUsedPart = (WhichH(eUsedPart)==SC_SPLIT_LEFT) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
    1221           0 :                         nFixPosY = aViewData.GetFixPosY();
    1222           0 :                         if ( nStartRow < nFixPosY )
    1223           0 :                             nStartRow = nFixPosY;
    1224             :                     }
    1225             : 
    1226           0 :                     if (pGridWin[eUsedPart])
    1227             :                     {
    1228             :                         //  Because scale is rounded to pixels, the only reliable way to find
    1229             :                         //  the right scale is to check if a zoom fits
    1230             : 
    1231           0 :                         Size aWinSize = pGridWin[eUsedPart]->GetOutputSizePixel();
    1232             : 
    1233             :                         //  for frozen panes, use sum of both parts for calculation
    1234             : 
    1235           0 :                         if ( nFixPosX != 0 )
    1236           0 :                             aWinSize.Width() += GetGridWidth( SC_SPLIT_LEFT );
    1237           0 :                         if ( nFixPosY != 0 )
    1238           0 :                             aWinSize.Height() += GetGridHeight( SC_SPLIT_TOP );
    1239             : 
    1240           0 :                         ScDocShell* pDocSh = aViewData.GetDocShell();
    1241           0 :                         double nPPTX = ScGlobal::nScreenPPTX / pDocSh->GetOutputFactor();
    1242           0 :                         double nPPTY = ScGlobal::nScreenPPTY;
    1243             : 
    1244           0 :                         sal_uInt16 nMin = MINZOOM;
    1245           0 :                         sal_uInt16 nMax = MAXZOOM;
    1246           0 :                         while ( nMax > nMin )
    1247             :                         {
    1248           0 :                             sal_uInt16 nTest = (nMin+nMax+1)/2;
    1249           0 :                             if ( lcl_FitsInWindow(
    1250           0 :                                         nPPTX, nPPTY, nTest, aWinSize.Width(), aWinSize.Height(),
    1251             :                                         pDoc, nTab, nStartCol, nStartRow, nEndCol, nEndRow,
    1252           0 :                                         nFixPosX, nFixPosY ) )
    1253           0 :                                 nMin = nTest;
    1254             :                             else
    1255           0 :                                 nMax = nTest-1;
    1256             :                         }
    1257             :                         OSL_ENSURE( nMin == nMax, "Schachtelung ist falsch" );
    1258           0 :                         nZoom = nMin;
    1259             : 
    1260           0 :                         if ( nZoom != nOldZoom )
    1261             :                         {
    1262             :                             // scroll to block only in active split part
    1263             :                             // (the part for which the size was calculated)
    1264             : 
    1265           0 :                             if ( nStartCol <= nEndCol )
    1266           0 :                                 aViewData.SetPosX( WhichH(eUsedPart), nStartCol );
    1267           0 :                             if ( nStartRow <= nEndRow )
    1268           0 :                                 aViewData.SetPosY( WhichV(eUsedPart), nStartRow );
    1269             :                         }
    1270             :                     }
    1271             :                 }
    1272             :             }
    1273           0 :             break;
    1274             : 
    1275             :             case SvxZoomType::WHOLEPAGE:    // nZoom entspricht der ganzen Seite oder
    1276             :             case SvxZoomType::PAGEWIDTH:    // nZoom entspricht der Seitenbreite
    1277             :                 {
    1278           0 :                     SCTAB               nCurTab     = aViewData.GetTabNo();
    1279           0 :                     ScDocument*         pDoc        = aViewData.GetDocument();
    1280           0 :                     ScStyleSheetPool*   pStylePool  = pDoc->GetStyleSheetPool();
    1281             :                     SfxStyleSheetBase*  pStyleSheet =
    1282             :                                             pStylePool->Find( pDoc->GetPageStyle( nCurTab ),
    1283           0 :                                                               SFX_STYLE_FAMILY_PAGE );
    1284             : 
    1285             :                     OSL_ENSURE( pStyleSheet, "PageStyle not found :-/" );
    1286             : 
    1287           0 :                     if ( pStyleSheet )
    1288             :                     {
    1289             :                         ScPrintFunc aPrintFunc( aViewData.GetDocShell(),
    1290           0 :                                                 aViewData.GetViewShell()->GetPrinter(true),
    1291           0 :                                                 nCurTab );
    1292             : 
    1293           0 :                         Size aPageSize = aPrintFunc.GetDataSize();
    1294             : 
    1295             :                         //  use the size of the largest GridWin for normal split,
    1296             :                         //  or both combined for frozen panes, with the (document) size
    1297             :                         //  of the frozen part added to the page size
    1298             :                         //  (with frozen panes, the size of the individual parts
    1299             :                         //  depends on the scale that is to be calculated)
    1300             : 
    1301           0 :                         if (!pGridWin[SC_SPLIT_BOTTOMLEFT])
    1302           0 :                             return nZoom;
    1303             : 
    1304           0 :                         Size aWinSize = pGridWin[SC_SPLIT_BOTTOMLEFT]->GetOutputSizePixel();
    1305           0 :                         ScSplitMode eHMode = aViewData.GetHSplitMode();
    1306           0 :                         if ( eHMode != SC_SPLIT_NONE && pGridWin[SC_SPLIT_BOTTOMRIGHT] )
    1307             :                         {
    1308           0 :                             long nOtherWidth = pGridWin[SC_SPLIT_BOTTOMRIGHT]->
    1309           0 :                                                         GetOutputSizePixel().Width();
    1310           0 :                             if ( eHMode == SC_SPLIT_FIX )
    1311             :                             {
    1312           0 :                                 aWinSize.Width() += nOtherWidth;
    1313           0 :                                 for ( SCCOL nCol = aViewData.GetPosX(SC_SPLIT_LEFT);
    1314           0 :                                         nCol < aViewData.GetFixPosX(); nCol++ )
    1315           0 :                                     aPageSize.Width() += pDoc->GetColWidth( nCol, nCurTab );
    1316             :                             }
    1317           0 :                             else if ( nOtherWidth > aWinSize.Width() )
    1318           0 :                                 aWinSize.Width() = nOtherWidth;
    1319             :                         }
    1320           0 :                         ScSplitMode eVMode = aViewData.GetVSplitMode();
    1321           0 :                         if ( eVMode != SC_SPLIT_NONE && pGridWin[SC_SPLIT_TOPLEFT] )
    1322             :                         {
    1323           0 :                             long nOtherHeight = pGridWin[SC_SPLIT_TOPLEFT]->
    1324           0 :                                                         GetOutputSizePixel().Height();
    1325           0 :                             if ( eVMode == SC_SPLIT_FIX )
    1326             :                             {
    1327           0 :                                 aWinSize.Height() += nOtherHeight;
    1328           0 :                                 aPageSize.Height() += pDoc->GetRowHeight(
    1329             :                                         aViewData.GetPosY(SC_SPLIT_TOP),
    1330           0 :                                         aViewData.GetFixPosY()-1, nCurTab);
    1331             :                             }
    1332           0 :                             else if ( nOtherHeight > aWinSize.Height() )
    1333           0 :                                 aWinSize.Height() = nOtherHeight;
    1334             :                         }
    1335             : 
    1336           0 :                         double nPPTX = ScGlobal::nScreenPPTX / aViewData.GetDocShell()->GetOutputFactor();
    1337           0 :                         double nPPTY = ScGlobal::nScreenPPTY;
    1338             : 
    1339           0 :                         long nZoomX = (long) ( aWinSize.Width() * 100 /
    1340           0 :                                                ( aPageSize.Width() * nPPTX ) );
    1341           0 :                         long nZoomY = (long) ( aWinSize.Height() * 100 /
    1342           0 :                                                ( aPageSize.Height() * nPPTY ) );
    1343             : 
    1344           0 :                         if (nZoomX > 0)
    1345           0 :                             nZoom = static_cast<sal_uInt16>(nZoomX);
    1346             : 
    1347           0 :                         if (eType == SvxZoomType::WHOLEPAGE && nZoomY > 0 && nZoomY < nZoom)
    1348           0 :                             nZoom = static_cast<sal_uInt16>(nZoomY);
    1349             :                     }
    1350             :                 }
    1351           0 :                 break;
    1352             : 
    1353             :         default:
    1354             :             OSL_FAIL("Unknown Zoom-Revision");
    1355             :     }
    1356             : 
    1357           0 :     return nZoom;
    1358             : }
    1359             : 
    1360             : //  wird z.B. gerufen, wenn sich das View-Fenster verschiebt:
    1361             : 
    1362         689 : void ScTabView::StopMarking()
    1363             : {
    1364         689 :     ScSplitPos eActive = aViewData.GetActivePart();
    1365         689 :     if (pGridWin[eActive])
    1366         689 :         pGridWin[eActive]->StopMarking();
    1367             : 
    1368         689 :     ScHSplitPos eH = WhichH(eActive);
    1369         689 :     if (pColBar[eH])
    1370         689 :         pColBar[eH]->StopMarking();
    1371             : 
    1372         689 :     ScVSplitPos eV = WhichV(eActive);
    1373         689 :     if (pRowBar[eV])
    1374         689 :         pRowBar[eV]->StopMarking();
    1375         689 : }
    1376             : 
    1377       10714 : void ScTabView::HideNoteMarker()
    1378             : {
    1379       53570 :     for (sal_uInt16 i=0; i<4; i++)
    1380       42856 :         if (pGridWin[i] && pGridWin[i]->IsVisible())
    1381       10366 :             pGridWin[i]->HideNoteMarker();
    1382       10714 : }
    1383             : 
    1384         348 : void ScTabView::MakeDrawLayer()
    1385             : {
    1386         348 :     if (!pDrawView)
    1387             :     {
    1388         213 :         aViewData.GetDocShell()->MakeDrawLayer();
    1389             : 
    1390             :         //  pDrawView wird per Notify gesetzt
    1391             :         OSL_ENSURE(pDrawView,"ScTabView::MakeDrawLayer funktioniert nicht");
    1392             : 
    1393             :         // #114409#
    1394        1065 :         for(sal_uInt16 a(0); a < 4; a++)
    1395             :         {
    1396         852 :             if(pGridWin[a])
    1397             :             {
    1398         213 :                 pGridWin[a]->DrawLayerCreated();
    1399             :             }
    1400             :         }
    1401             :     }
    1402         348 : }
    1403             : 
    1404           0 : void ScTabView::ErrorMessage( sal_uInt16 nGlobStrId )
    1405             : {
    1406           0 :     if ( SC_MOD()->IsInExecuteDrop() )
    1407             :     {
    1408             :         // #i28468# don't show error message when called from Drag&Drop, silently abort instead
    1409           0 :         return;
    1410             :     }
    1411             : 
    1412           0 :     StopMarking();      // falls per Focus aus MouseButtonDown aufgerufen
    1413             : 
    1414           0 :     vcl::Window* pParent = aViewData.GetDialogParent();
    1415           0 :     ScWaitCursorOff aWaitOff( pParent );
    1416           0 :     bool bFocus = pParent && pParent->HasFocus();
    1417             : 
    1418           0 :     if(nGlobStrId==STR_PROTECTIONERR)
    1419             :     {
    1420           0 :         if(aViewData.GetDocShell()->IsReadOnly())
    1421             :         {
    1422           0 :             nGlobStrId=STR_READONLYERR;
    1423             :         }
    1424             :     }
    1425             : 
    1426           0 :     ScopedVclPtrInstance< InfoBox > aBox( pParent, ScGlobal::GetRscString( nGlobStrId ) );
    1427           0 :     aBox->Execute();
    1428           0 :     if (bFocus)
    1429           0 :         pParent->GrabFocus();
    1430             : }
    1431             : 
    1432           2 : void ScTabView::UpdatePageBreakData( bool bForcePaint )
    1433             : {
    1434           2 :     ScPageBreakData* pNewData = NULL;
    1435             : 
    1436           2 :     if (aViewData.IsPagebreakMode())
    1437             :     {
    1438           1 :         ScDocShell* pDocSh = aViewData.GetDocShell();
    1439           1 :         ScDocument& rDoc = pDocSh->GetDocument();
    1440           1 :         SCTAB nTab = aViewData.GetTabNo();
    1441             : 
    1442           1 :         sal_uInt16 nCount = rDoc.GetPrintRangeCount(nTab);
    1443           1 :         if (!nCount)
    1444           0 :             nCount = 1;
    1445           1 :         pNewData = new ScPageBreakData(nCount);
    1446             : 
    1447           1 :         ScPrintFunc aPrintFunc( pDocSh, pDocSh->GetPrinter(), nTab, 0,0,NULL, NULL, pNewData );
    1448             :         //  ScPrintFunc fuellt im ctor die PageBreakData
    1449           1 :         if ( nCount > 1 )
    1450             :         {
    1451           0 :             aPrintFunc.ResetBreaks(nTab);
    1452           0 :             pNewData->AddPages();
    1453             :         }
    1454             : 
    1455             :         //  Druckbereiche veraendert?
    1456           1 :         if ( bForcePaint || ( pPageBreakData && !( *pPageBreakData == *pNewData ) ) )
    1457           0 :             PaintGrid();
    1458             :     }
    1459             : 
    1460           2 :     delete pPageBreakData;
    1461           2 :     pPageBreakData = pNewData;
    1462         158 : }
    1463             : 
    1464             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11