LCOV - code coverage report
Current view: top level - sc/source/ui/view - select.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 62 466 13.3 %
Date: 2015-06-13 12:38:46 Functions: 10 28 35.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 <tools/urlobj.hxx>
      21             : #include <vcl/svapp.hxx>
      22             : #include <sfx2/docfile.hxx>
      23             : 
      24             : #include "select.hxx"
      25             : #include "sc.hrc"
      26             : #include "tabvwsh.hxx"
      27             : #include "scmod.hxx"
      28             : #include "document.hxx"
      29             : #include "transobj.hxx"
      30             : #include "docsh.hxx"
      31             : #include "tabprotection.hxx"
      32             : #include "markdata.hxx"
      33             : #include <gridwin.hxx>
      34             : 
      35             : #if defined WNT
      36             : #define SC_SELENG_REFMODE_UPDATE_INTERVAL_MIN 65
      37             : #endif
      38             : 
      39             : extern sal_uInt16 nScFillModeMouseModifier;             // global.cxx
      40             : 
      41             : using namespace com::sun::star;
      42             : 
      43             : // STATIC DATA -----------------------------------------------------------
      44             : 
      45          52 : static Point aSwitchPos;                //! Member
      46             : static bool bDidSwitch = false;
      47             : 
      48             : // View (Gridwin / keyboard)
      49         348 : ScViewFunctionSet::ScViewFunctionSet( ScViewData* pNewViewData ) :
      50             :         pViewData( pNewViewData ),
      51             :         pEngine( NULL ),
      52             :         bAnchor( false ),
      53         348 :         bStarted( false )
      54             : {
      55             :     OSL_ENSURE(pViewData, "ViewData==0 at FunctionSet");
      56         348 : }
      57             : 
      58           0 : ScSplitPos ScViewFunctionSet::GetWhich()
      59             : {
      60           0 :     if (pEngine)
      61           0 :         return pEngine->GetWhich();
      62             :     else
      63           0 :         return pViewData->GetActivePart();
      64             : }
      65             : 
      66           0 : sal_uLong ScViewFunctionSet::CalcUpdateInterval( const Size& rWinSize, const Point& rEffPos,
      67             :                                              bool bLeftScroll, bool bTopScroll, bool bRightScroll, bool bBottomScroll )
      68             : {
      69           0 :     sal_uLong nUpdateInterval = SELENG_AUTOREPEAT_INTERVAL_MAX;
      70           0 :     vcl::Window* pWin = pEngine->GetWindow();
      71           0 :     Rectangle aScrRect = pWin->GetDesktopRectPixel();
      72           0 :     Point aRootPos = pWin->OutputToAbsoluteScreenPixel(Point(0,0));
      73           0 :     if (bRightScroll)
      74             :     {
      75           0 :         double nWinRight = rWinSize.getWidth() + aRootPos.getX();
      76           0 :         double nMarginRight = aScrRect.GetWidth() - nWinRight;
      77           0 :         double nHOffset = rEffPos.X() - rWinSize.Width();
      78           0 :         double nHAccelRate = nHOffset / nMarginRight;
      79             : 
      80           0 :         if (nHAccelRate > 1.0)
      81           0 :             nHAccelRate = 1.0;
      82             : 
      83           0 :         nUpdateInterval = static_cast<sal_uLong>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nHAccelRate));
      84             :     }
      85             : 
      86           0 :     if (bLeftScroll)
      87             :     {
      88           0 :         double nMarginLeft = aRootPos.getX();
      89           0 :         double nHOffset = -rEffPos.X();
      90           0 :         double nHAccelRate = nHOffset / nMarginLeft;
      91             : 
      92           0 :         if (nHAccelRate > 1.0)
      93           0 :             nHAccelRate = 1.0;
      94             : 
      95           0 :         sal_uLong nTmp = static_cast<sal_uLong>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nHAccelRate));
      96           0 :         if (nUpdateInterval > nTmp)
      97           0 :             nUpdateInterval = nTmp;
      98             :     }
      99             : 
     100           0 :     if (bBottomScroll)
     101             :     {
     102           0 :         double nWinBottom = rWinSize.getHeight() + aRootPos.getY();
     103           0 :         double nMarginBottom = aScrRect.GetHeight() - nWinBottom;
     104           0 :         double nVOffset = rEffPos.Y() - rWinSize.Height();
     105           0 :         double nVAccelRate = nVOffset / nMarginBottom;
     106             : 
     107           0 :         if (nVAccelRate > 1.0)
     108           0 :             nVAccelRate = 1.0;
     109             : 
     110           0 :         sal_uLong nTmp = static_cast<sal_uLong>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nVAccelRate));
     111           0 :         if (nUpdateInterval > nTmp)
     112           0 :             nUpdateInterval = nTmp;
     113             :     }
     114             : 
     115           0 :     if (bTopScroll)
     116             :     {
     117           0 :         double nMarginTop = aRootPos.getY();
     118           0 :         double nVOffset = -rEffPos.Y();
     119           0 :         double nVAccelRate = nVOffset / nMarginTop;
     120             : 
     121           0 :         if (nVAccelRate > 1.0)
     122           0 :             nVAccelRate = 1.0;
     123             : 
     124           0 :         sal_uLong nTmp = static_cast<sal_uLong>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nVAccelRate));
     125           0 :         if (nUpdateInterval > nTmp)
     126           0 :             nUpdateInterval = nTmp;
     127             :     }
     128             : 
     129             : #ifdef WNT
     130             :     ScTabViewShell* pViewShell = pViewData->GetViewShell();
     131             :     bool bRefMode = pViewShell && pViewShell->IsRefInputMode();
     132             :     if (bRefMode && nUpdateInterval < SC_SELENG_REFMODE_UPDATE_INTERVAL_MIN)
     133             :         // Lower the update interval during ref mode, because re-draw can be
     134             :         // expensive on Windows.  Making this interval too small would queue up
     135             :         // the scroll/paint requests which would cause semi-infinite
     136             :         // scrolls even after the mouse cursor is released.  We don't have
     137             :         // this problem on Linux.
     138             :         nUpdateInterval = SC_SELENG_REFMODE_UPDATE_INTERVAL_MIN;
     139             : #endif
     140           0 :     return nUpdateInterval;
     141             : }
     142             : 
     143         348 : void ScViewFunctionSet::SetSelectionEngine( ScViewSelectionEngine* pSelEngine )
     144             : {
     145         348 :     pEngine = pSelEngine;
     146         348 : }
     147             : 
     148             : // Drag & Drop
     149           0 : void ScViewFunctionSet::BeginDrag()
     150             : {
     151           0 :     SCTAB nTab = pViewData->GetTabNo();
     152             : 
     153             :     SCsCOL nPosX;
     154             :     SCsROW nPosY;
     155           0 :     if (pEngine)
     156             :     {
     157           0 :         Point aMPos = pEngine->GetMousePosPixel();
     158           0 :         pViewData->GetPosFromPixel( aMPos.X(), aMPos.Y(), GetWhich(), nPosX, nPosY );
     159             :     }
     160             :     else
     161             :     {
     162           0 :         nPosX = pViewData->GetCurX();
     163           0 :         nPosY = pViewData->GetCurY();
     164             :     }
     165             : 
     166           0 :     ScModule* pScMod = SC_MOD();
     167           0 :     bool bRefMode = pScMod->IsFormulaMode();
     168           0 :     if (!bRefMode)
     169             :     {
     170           0 :         pViewData->GetView()->FakeButtonUp( GetWhich() );   // ButtonUp is swallowed
     171             : 
     172           0 :         ScMarkData& rMark = pViewData->GetMarkData();
     173           0 :         rMark.MarkToSimple();
     174           0 :         if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
     175             :         {
     176           0 :             ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP );
     177             :             // bApi = TRUE -> no error messages
     178           0 :             bool bCopied = pViewData->GetView()->CopyToClip( pClipDoc, false, true );
     179           0 :             if ( bCopied )
     180             :             {
     181           0 :                 sal_Int8 nDragActions = pViewData->GetView()->SelectionEditable() ?
     182             :                                         ( DND_ACTION_COPYMOVE | DND_ACTION_LINK ) :
     183           0 :                                         ( DND_ACTION_COPY | DND_ACTION_LINK );
     184             : 
     185           0 :                 ScDocShell* pDocSh = pViewData->GetDocShell();
     186           0 :                 TransferableObjectDescriptor aObjDesc;
     187           0 :                 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
     188           0 :                 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
     189             :                 // maSize is set in ScTransferObj ctor
     190             : 
     191           0 :                 ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc );
     192           0 :                 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
     193             : 
     194             :                 // set position of dragged cell within range
     195           0 :                 ScRange aMarkRange = pTransferObj->GetRange();
     196           0 :                 SCCOL nStartX = aMarkRange.aStart.Col();
     197           0 :                 SCROW nStartY = aMarkRange.aStart.Row();
     198           0 :                 SCCOL nHandleX = (nPosX >= (SCsCOL) nStartX) ? nPosX - nStartX : 0;
     199           0 :                 SCROW nHandleY = (nPosY >= (SCsROW) nStartY) ? nPosY - nStartY : 0;
     200           0 :                 pTransferObj->SetDragHandlePos( nHandleX, nHandleY );
     201           0 :                 pTransferObj->SetVisibleTab( nTab );
     202             : 
     203           0 :                 pTransferObj->SetDragSource( pDocSh, rMark );
     204             : 
     205           0 :                 vcl::Window* pWindow = pViewData->GetActiveWin();
     206           0 :                 if ( pWindow->IsTracking() )
     207           0 :                     pWindow->EndTracking( TrackingEventFlags::Cancel );    // abort selecting
     208             : 
     209           0 :                 SC_MOD()->SetDragObject( pTransferObj, NULL );      // for internal D&D
     210           0 :                 pTransferObj->StartDrag( pWindow, nDragActions );
     211             : 
     212           0 :                 return;         // dragging started
     213             :             }
     214             :             else
     215           0 :                 delete pClipDoc;
     216             :         }
     217             :     }
     218             : 
     219             : }
     220             : 
     221             : // Selection
     222           0 : void ScViewFunctionSet::CreateAnchor()
     223             : {
     224           0 :     if (bAnchor) return;
     225             : 
     226           0 :     bool bRefMode = SC_MOD()->IsFormulaMode();
     227           0 :     if (bRefMode)
     228           0 :         SetAnchor( pViewData->GetRefStartX(), pViewData->GetRefStartY() );
     229             :     else
     230           0 :         SetAnchor( pViewData->GetCurX(), pViewData->GetCurY() );
     231             : }
     232             : 
     233           0 : void ScViewFunctionSet::SetAnchor( SCCOL nPosX, SCROW nPosY )
     234             : {
     235           0 :     bool bRefMode = SC_MOD()->IsFormulaMode();
     236           0 :     ScTabView* pView = pViewData->GetView();
     237           0 :     SCTAB nTab = pViewData->GetTabNo();
     238             : 
     239           0 :     if (bRefMode)
     240             :     {
     241           0 :         pView->DoneRefMode( false );
     242           0 :         aAnchorPos.Set( nPosX, nPosY, nTab );
     243           0 :         pView->InitRefMode( aAnchorPos.Col(), aAnchorPos.Row(), aAnchorPos.Tab(),
     244           0 :                             SC_REFTYPE_REF );
     245           0 :         bStarted = true;
     246             :     }
     247           0 :     else if (pViewData->IsAnyFillMode())
     248             :     {
     249           0 :         aAnchorPos.Set( nPosX, nPosY, nTab );
     250           0 :         bStarted = true;
     251             :     }
     252             :     else
     253             :     {
     254             :         // don't go there and back again
     255           0 :         if ( bStarted && pView->IsMarking( nPosX, nPosY, nTab ) )
     256             :         {
     257             :             // don't do anything
     258             :         }
     259             :         else
     260             :         {
     261           0 :             pView->DoneBlockMode( true );
     262           0 :             aAnchorPos.Set( nPosX, nPosY, nTab );
     263           0 :             ScMarkData& rMark = pViewData->GetMarkData();
     264           0 :             if ( rMark.IsMarked() || rMark.IsMultiMarked() )
     265             :             {
     266           0 :                 pView->InitBlockMode( aAnchorPos.Col(), aAnchorPos.Row(),
     267           0 :                                         aAnchorPos.Tab(), true );
     268           0 :                 bStarted = true;
     269             :             }
     270             :             else
     271           0 :                 bStarted = false;
     272             :         }
     273             :     }
     274           0 :     bAnchor = true;
     275           0 : }
     276             : 
     277           0 : void ScViewFunctionSet::DestroyAnchor()
     278             : {
     279           0 :     bool bRefMode = SC_MOD()->IsFormulaMode();
     280           0 :     if (bRefMode)
     281           0 :         pViewData->GetView()->DoneRefMode( true );
     282             :     else
     283           0 :         pViewData->GetView()->DoneBlockMode( true );
     284             : 
     285           0 :     bAnchor = false;
     286           0 : }
     287             : 
     288           0 : void ScViewFunctionSet::SetAnchorFlag( bool bSet )
     289             : {
     290           0 :     bAnchor = bSet;
     291           0 : }
     292             : 
     293           0 : bool ScViewFunctionSet::SetCursorAtPoint( const Point& rPointPixel, bool /* bDontSelectAtCursor */ )
     294             : {
     295           0 :     if ( bDidSwitch )
     296             :     {
     297           0 :         if ( rPointPixel == aSwitchPos )
     298           0 :             return false;                   // don't scroll in wrong window
     299             :         else
     300           0 :             bDidSwitch = false;
     301             :     }
     302           0 :     aSwitchPos = rPointPixel;       // only important, if bDidSwitch
     303             : 
     304             :     //  treat position 0 as -1, so scrolling is always possible
     305             :     //  (with full screen and hidden headers, the top left border may be at 0)
     306             :     //  (moved from ScViewData::GetPosFromPixel)
     307             : 
     308           0 :     Point aEffPos = rPointPixel;
     309           0 :     if ( aEffPos.X() == 0 )
     310           0 :         aEffPos.X() = -1;
     311           0 :     if ( aEffPos.Y() == 0 )
     312           0 :         aEffPos.Y() = -1;
     313             : 
     314             :     //  Scrolling
     315           0 :     Size aWinSize = pEngine->GetWindow()->GetOutputSizePixel();
     316           0 :     bool bRightScroll  = ( aEffPos.X() >= aWinSize.Width() );
     317           0 :     bool bLeftScroll  = ( aEffPos.X() < 0 );
     318           0 :     bool bBottomScroll = ( aEffPos.Y() >= aWinSize.Height() );
     319           0 :     bool bTopScroll = ( aEffPos.Y() < 0 );
     320           0 :     bool bScroll = bRightScroll || bBottomScroll || bLeftScroll || bTopScroll;
     321             : 
     322             :     SCsCOL  nPosX;
     323             :     SCsROW  nPosY;
     324           0 :     pViewData->GetPosFromPixel( aEffPos.X(), aEffPos.Y(), GetWhich(),
     325           0 :                                 nPosX, nPosY, true, true );     // with Repair
     326             : 
     327             :     // for Autofill switch in the center of cell
     328             :     // thereby don't prevent scrolling to bottom/right
     329           0 :     if ( pViewData->IsFillMode() || pViewData->GetFillMode() == SC_FILL_MATRIX )
     330             :     {
     331             :         bool bLeft, bTop;
     332           0 :         pViewData->GetMouseQuadrant( aEffPos, GetWhich(), nPosX, nPosY, bLeft, bTop );
     333           0 :         ScDocument* pDoc = pViewData->GetDocument();
     334           0 :         SCTAB nTab = pViewData->GetTabNo();
     335           0 :         if ( bLeft && !bRightScroll )
     336           0 :             do --nPosX; while ( nPosX>=0 && pDoc->ColHidden( nPosX, nTab ) );
     337           0 :         if ( bTop && !bBottomScroll )
     338             :         {
     339           0 :             if (--nPosY >= 0)
     340             :             {
     341           0 :                 nPosY = pDoc->LastVisibleRow(0, nPosY, nTab);
     342           0 :                 if (!ValidRow(nPosY))
     343           0 :                     nPosY = -1;
     344             :             }
     345             :         }
     346             :         // negative value is allowed
     347             :     }
     348             : 
     349             :     // moved out of fix limit?
     350           0 :     ScSplitPos eWhich = GetWhich();
     351           0 :     if ( eWhich == pViewData->GetActivePart() )
     352             :     {
     353           0 :         if ( pViewData->GetHSplitMode() == SC_SPLIT_FIX )
     354           0 :             if ( aEffPos.X() >= aWinSize.Width() )
     355             :             {
     356           0 :                 if ( eWhich == SC_SPLIT_TOPLEFT )
     357           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_TOPRIGHT ), bScroll = false, bDidSwitch = true;
     358           0 :                 else if ( eWhich == SC_SPLIT_BOTTOMLEFT )
     359           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bScroll = false, bDidSwitch = true;
     360             :             }
     361             : 
     362           0 :         if ( pViewData->GetVSplitMode() == SC_SPLIT_FIX )
     363           0 :             if ( aEffPos.Y() >= aWinSize.Height() )
     364             :             {
     365           0 :                 if ( eWhich == SC_SPLIT_TOPLEFT )
     366           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMLEFT ), bScroll = false, bDidSwitch = true;
     367           0 :                 else if ( eWhich == SC_SPLIT_TOPRIGHT )
     368           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bScroll = false, bDidSwitch = true;
     369             :             }
     370             :     }
     371             : 
     372           0 :     if (bScroll)
     373             :     {
     374             :         // Adjust update interval based on how far the mouse pointer is from the edge.
     375             :         sal_uLong nUpdateInterval = CalcUpdateInterval(
     376           0 :             aWinSize, aEffPos, bLeftScroll, bTopScroll, bRightScroll, bBottomScroll);
     377           0 :         pEngine->SetUpdateInterval(nUpdateInterval);
     378             :     }
     379             :     else
     380             :     {
     381             :         // Don't forget to reset the interval when not scrolling!
     382           0 :         pEngine->SetUpdateInterval(SELENG_AUTOREPEAT_INTERVAL);
     383             :     }
     384             : 
     385           0 :     pViewData->ResetOldCursor();
     386           0 :     return SetCursorAtCell( nPosX, nPosY, bScroll );
     387             : }
     388             : 
     389          86 : bool ScViewFunctionSet::SetCursorAtCell( SCsCOL nPosX, SCsROW nPosY, bool bScroll )
     390             : {
     391          86 :     ScTabView* pView = pViewData->GetView();
     392          86 :     SCTAB nTab = pViewData->GetTabNo();
     393          86 :     ScDocument* pDoc = pViewData->GetDocument();
     394             : 
     395          86 :     if ( pDoc->IsTabProtected(nTab) )
     396             :     {
     397           0 :         if (nPosX < 0 || nPosY < 0)
     398           0 :             return false;
     399             : 
     400           0 :         ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
     401           0 :         if (!pProtect)
     402           0 :             return false;
     403             : 
     404           0 :         bool bSkipProtected   = !pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
     405           0 :         bool bSkipUnprotected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
     406             : 
     407           0 :         if ( bSkipProtected && bSkipUnprotected )
     408           0 :             return false;
     409             : 
     410           0 :         bool bCellProtected = pDoc->HasAttrib(nPosX, nPosY, nTab, nPosX, nPosY, nTab, HASATTR_PROTECTED);
     411           0 :         if ( (bCellProtected && bSkipProtected) || (!bCellProtected && bSkipUnprotected) )
     412             :             // Don't select this cell!
     413           0 :             return false;
     414             :     }
     415             : 
     416          86 :     ScModule* pScMod = SC_MOD();
     417          86 :     ScTabViewShell* pViewShell = pViewData->GetViewShell();
     418          86 :     bool bRefMode = pViewShell && pViewShell->IsRefInputMode();
     419             : 
     420         241 :     bool bHide = !bRefMode && !pViewData->IsAnyFillMode() &&
     421         223 :             ( nPosX != (SCsCOL) pViewData->GetCurX() || nPosY != (SCsROW) pViewData->GetCurY() );
     422             : 
     423          86 :     if (bHide)
     424          69 :         pView->HideAllCursors();
     425             : 
     426          86 :     if (bScroll)
     427             :     {
     428           0 :         if (bRefMode)
     429             :         {
     430           0 :             ScSplitPos eWhich = GetWhich();
     431           0 :             pView->AlignToCursor( nPosX, nPosY, SC_FOLLOW_LINE, &eWhich );
     432             :         }
     433             :         else
     434           0 :             pView->AlignToCursor( nPosX, nPosY, SC_FOLLOW_LINE );
     435             :     }
     436             : 
     437          86 :     if (bRefMode)
     438             :     {
     439             :         // if no input is possible from this doc, don't move the reference cursor around
     440           0 :         if ( !pScMod->IsModalMode(pViewData->GetSfxDocShell()) )
     441             :         {
     442           0 :             if (!bAnchor)
     443             :             {
     444           0 :                 pView->DoneRefMode( true );
     445           0 :                 pView->InitRefMode( nPosX, nPosY, pViewData->GetTabNo(), SC_REFTYPE_REF );
     446             :             }
     447             : 
     448           0 :             pView->UpdateRef( nPosX, nPosY, pViewData->GetTabNo() );
     449           0 :             pView->SelectionChanged();
     450             :         }
     451             :     }
     452         172 :     else if (pViewData->IsFillMode() ||
     453          86 :             (pViewData->GetFillMode() == SC_FILL_MATRIX && (nScFillModeMouseModifier & KEY_MOD1) ))
     454             :     {
     455             :         // If a matrix got touched, switch back to Autofill is possible with Ctrl
     456             : 
     457             :         SCCOL nStartX, nEndX;
     458             :         SCROW nStartY, nEndY; // Block
     459             :         SCTAB nDummy;
     460           0 :         pViewData->GetSimpleArea( nStartX, nStartY, nDummy, nEndX, nEndY, nDummy );
     461             : 
     462           0 :         if (pViewData->GetRefType() != SC_REFTYPE_FILL)
     463             :         {
     464           0 :             pView->InitRefMode( nStartX, nStartY, nTab, SC_REFTYPE_FILL );
     465           0 :             CreateAnchor();
     466             :         }
     467             : 
     468           0 :         ScRange aDelRange;
     469           0 :         bool bOldDelMark = pViewData->GetDelMark( aDelRange );
     470             : 
     471           0 :         if ( nPosX+1 >= (SCsCOL) nStartX && nPosX <= (SCsCOL) nEndX &&
     472           0 :              nPosY+1 >= (SCsROW) nStartY && nPosY <= (SCsROW) nEndY &&
     473           0 :              ( nPosX != nEndX || nPosY != nEndY ) )                     // minimize?
     474             :         {
     475             :             // direction (left or top)
     476             : 
     477           0 :             long nSizeX = 0;
     478           0 :             for (SCCOL i=nPosX+1; i<=nEndX; i++)
     479           0 :                 nSizeX += pDoc->GetColWidth( i, nTab );
     480           0 :             long nSizeY = (long) pDoc->GetRowHeight( nPosY+1, nEndY, nTab );
     481             : 
     482           0 :             SCCOL nDelStartX = nStartX;
     483           0 :             SCROW nDelStartY = nStartY;
     484           0 :             if ( nSizeX > nSizeY )
     485           0 :                 nDelStartX = nPosX + 1;
     486             :             else
     487           0 :                 nDelStartY = nPosY + 1;
     488             :             // there is no need to check for zero, because nPosX/Y is also negative
     489             : 
     490           0 :             if ( nDelStartX < nStartX )
     491           0 :                 nDelStartX = nStartX;
     492           0 :             if ( nDelStartY < nStartY )
     493           0 :                 nDelStartY = nStartY;
     494             : 
     495             :             // set range
     496             : 
     497             :             pViewData->SetDelMark( ScRange( nDelStartX,nDelStartY,nTab,
     498           0 :                                             nEndX,nEndY,nTab ) );
     499           0 :             pViewData->GetView()->UpdateShrinkOverlay();
     500             : 
     501           0 :             pViewData->GetView()->
     502           0 :                 PaintArea( nStartX,nDelStartY, nEndX,nEndY, SC_UPDATE_MARKS );
     503             : 
     504           0 :             nPosX = nEndX;      // keep red border around range
     505           0 :             nPosY = nEndY;
     506             : 
     507             :             // reference the right way up, if it's upside down below
     508           0 :             if ( nStartX != pViewData->GetRefStartX() || nStartY != pViewData->GetRefStartY() )
     509             :             {
     510           0 :                 pViewData->GetView()->DoneRefMode();
     511           0 :                 pViewData->GetView()->InitRefMode( nStartX, nStartY, nTab, SC_REFTYPE_FILL );
     512           0 :             }
     513             :         }
     514             :         else
     515             :         {
     516           0 :             if ( bOldDelMark )
     517             :             {
     518           0 :                 pViewData->ResetDelMark();
     519           0 :                 pViewData->GetView()->UpdateShrinkOverlay();
     520             :             }
     521             : 
     522           0 :             bool bNegX = ( nPosX < (SCsCOL) nStartX );
     523           0 :             bool bNegY = ( nPosY < (SCsROW) nStartY );
     524             : 
     525           0 :             long nSizeX = 0;
     526           0 :             if ( bNegX )
     527             :             {
     528             :                 //  in SetCursorAtPoint hidden columns are skipped.
     529             :                 //  They must be skipped here too, or the result will always be the first hidden column.
     530           0 :                 do ++nPosX; while ( nPosX<nStartX && pDoc->ColHidden(nPosX, nTab) );
     531           0 :                 for (SCCOL i=nPosX; i<nStartX; i++)
     532           0 :                     nSizeX += pDoc->GetColWidth( i, nTab );
     533             :             }
     534             :             else
     535           0 :                 for (SCCOL i=nEndX+1; i<=nPosX; i++)
     536           0 :                     nSizeX += pDoc->GetColWidth( i, nTab );
     537             : 
     538           0 :             long nSizeY = 0;
     539           0 :             if ( bNegY )
     540             :             {
     541             :                 //  in SetCursorAtPoint hidden rows are skipped.
     542             :                 //  They must be skipped here too, or the result will always be the first hidden row.
     543           0 :                 if (++nPosY < nStartY)
     544             :                 {
     545           0 :                     nPosY = pDoc->FirstVisibleRow(nPosY, nStartY-1, nTab);
     546           0 :                     if (!ValidRow(nPosY))
     547           0 :                         nPosY = nStartY;
     548             :                 }
     549           0 :                 nSizeY += pDoc->GetRowHeight( nPosY, nStartY-1, nTab );
     550             :             }
     551             :             else
     552           0 :                 nSizeY += pDoc->GetRowHeight( nEndY+1, nPosY, nTab );
     553             : 
     554           0 :             if ( nSizeX > nSizeY )          // Fill only ever in one direction
     555             :             {
     556           0 :                 nPosY = nEndY;
     557           0 :                 bNegY = false;
     558             :             }
     559             :             else
     560             :             {
     561           0 :                 nPosX = nEndX;
     562           0 :                 bNegX = false;
     563             :             }
     564             : 
     565           0 :             SCCOL nRefStX = bNegX ? nEndX : nStartX;
     566           0 :             SCROW nRefStY = bNegY ? nEndY : nStartY;
     567           0 :             if ( nRefStX != pViewData->GetRefStartX() || nRefStY != pViewData->GetRefStartY() )
     568             :             {
     569           0 :                 pViewData->GetView()->DoneRefMode();
     570           0 :                 pViewData->GetView()->InitRefMode( nRefStX, nRefStY, nTab, SC_REFTYPE_FILL );
     571             :             }
     572             :         }
     573             : 
     574           0 :         pView->UpdateRef( nPosX, nPosY, nTab );
     575             :     }
     576          86 :     else if (pViewData->IsAnyFillMode())
     577             :     {
     578           0 :         sal_uInt8 nMode = pViewData->GetFillMode();
     579           0 :         if ( nMode == SC_FILL_EMBED_LT || nMode == SC_FILL_EMBED_RB )
     580             :         {
     581             :             OSL_ENSURE( pDoc->IsEmbedded(), "!pDoc->IsEmbedded()" );
     582           0 :             ScRange aRange;
     583           0 :             pDoc->GetEmbedded( aRange);
     584           0 :             ScRefType eRefMode = (nMode == SC_FILL_EMBED_LT) ? SC_REFTYPE_EMBED_LT : SC_REFTYPE_EMBED_RB;
     585           0 :             if (pViewData->GetRefType() != eRefMode)
     586             :             {
     587           0 :                 if ( nMode == SC_FILL_EMBED_LT )
     588           0 :                     pView->InitRefMode( aRange.aEnd.Col(), aRange.aEnd.Row(), nTab, eRefMode );
     589             :                 else
     590           0 :                     pView->InitRefMode( aRange.aStart.Col(), aRange.aStart.Row(), nTab, eRefMode );
     591           0 :                 CreateAnchor();
     592             :             }
     593             : 
     594           0 :             pView->UpdateRef( nPosX, nPosY, nTab );
     595             :         }
     596           0 :         else if ( nMode == SC_FILL_MATRIX )
     597             :         {
     598             :             SCCOL nStartX, nEndX;
     599             :             SCROW nStartY, nEndY; // Block
     600             :             SCTAB nDummy;
     601           0 :             pViewData->GetSimpleArea( nStartX, nStartY, nDummy, nEndX, nEndY, nDummy );
     602             : 
     603           0 :             if (pViewData->GetRefType() != SC_REFTYPE_FILL)
     604             :             {
     605           0 :                 pView->InitRefMode( nStartX, nStartY, nTab, SC_REFTYPE_FILL );
     606           0 :                 CreateAnchor();
     607             :             }
     608             : 
     609           0 :             if ( nPosX < nStartX ) nPosX = nStartX;
     610           0 :             if ( nPosY < nStartY ) nPosY = nStartY;
     611             : 
     612           0 :             pView->UpdateRef( nPosX, nPosY, nTab );
     613             :         }
     614             :         // else new modes
     615             :     }
     616             :     else                    // regular selection
     617             :     {
     618          86 :         bool bHideCur = bAnchor && ( (SCCOL)nPosX != pViewData->GetCurX() ||
     619          86 :                                      (SCROW)nPosY != pViewData->GetCurY() );
     620          86 :         if (bHideCur)
     621           0 :             pView->HideAllCursors();            // otherwise twice: Block and SetCursor
     622             : 
     623          86 :         if (bAnchor)
     624             :         {
     625           0 :             if (!bStarted)
     626             :             {
     627           0 :                 bool bMove = ( nPosX != (SCsCOL) aAnchorPos.Col() ||
     628           0 :                                 nPosY != (SCsROW) aAnchorPos.Row() );
     629           0 :                 if ( bMove || ( pEngine && pEngine->GetMouseEvent().IsShift() ) )
     630             :                 {
     631           0 :                     pView->InitBlockMode( aAnchorPos.Col(), aAnchorPos.Row(),
     632           0 :                                             aAnchorPos.Tab(), true );
     633           0 :                     bStarted = true;
     634             :                 }
     635             :             }
     636           0 :             if (bStarted)
     637             :                 // If the selection is already started, don't set the cursor.
     638           0 :                 pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab, false, false, true );
     639             :             else
     640           0 :                 pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
     641             :         }
     642             :         else
     643             :         {
     644          86 :             ScMarkData& rMark = pViewData->GetMarkData();
     645          86 :             if (rMark.IsMarked() || rMark.IsMultiMarked())
     646             :             {
     647           0 :                 pView->DoneBlockMode(true);
     648           0 :                 pView->InitBlockMode( nPosX, nPosY, nTab, true );
     649           0 :                 pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab );
     650             : 
     651           0 :                 aAnchorPos.Set( nPosX, nPosY, nTab );
     652           0 :                 bStarted = true;
     653             :             }
     654             :             // #i3875# *Hack* When a new cell is Ctrl-clicked with no pre-selected cells,
     655             :             // it highlights that new cell as well as the old cell where the cursor is
     656             :             // positioned prior to the click.  A selection mode via Shift-F8 should also
     657             :             // follow the same behavior.
     658          86 :             else if ( pViewData->IsSelCtrlMouseClick() )
     659             :             {
     660           0 :                 SCCOL nOldX = pViewData->GetCurX();
     661           0 :                 SCROW nOldY = pViewData->GetCurY();
     662             : 
     663           0 :                 pView->InitBlockMode( nOldX, nOldY, nTab, true );
     664           0 :                 pView->MarkCursor( (SCCOL) nOldX, (SCROW) nOldY, nTab );
     665             : 
     666           0 :                 if ( nOldX != nPosX || nOldY != nPosY )
     667             :                 {
     668           0 :                     pView->DoneBlockMode( true );
     669           0 :                     pView->InitBlockMode( nPosX, nPosY, nTab, true );
     670           0 :                     pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab );
     671           0 :                     aAnchorPos.Set( nPosX, nPosY, nTab );
     672             :                 }
     673             : 
     674           0 :                 bStarted = true;
     675             :             }
     676          86 :             pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
     677             :         }
     678             : 
     679          86 :         pViewData->SetRefStart( nPosX, nPosY, nTab );
     680          86 :         if (bHideCur)
     681           0 :             pView->ShowAllCursors();
     682             :     }
     683             : 
     684          86 :     if (bHide)
     685          69 :         pView->ShowAllCursors();
     686             : 
     687          86 :     return true;
     688             : }
     689             : 
     690           0 : bool ScViewFunctionSet::IsSelectionAtPoint( const Point& rPointPixel )
     691             : {
     692           0 :     bool bRefMode = SC_MOD()->IsFormulaMode();
     693           0 :     if (bRefMode)
     694           0 :         return false;
     695             : 
     696           0 :     if (pViewData->IsAnyFillMode())
     697           0 :         return false;
     698             : 
     699           0 :     ScMarkData& rMark = pViewData->GetMarkData();
     700           0 :     if (bAnchor || !rMark.IsMultiMarked())
     701             :     {
     702             :         SCsCOL  nPosX;
     703             :         SCsROW  nPosY;
     704           0 :         pViewData->GetPosFromPixel( rPointPixel.X(), rPointPixel.Y(), GetWhich(), nPosX, nPosY );
     705           0 :         return pViewData->GetMarkData().IsCellMarked( (SCCOL) nPosX, (SCROW) nPosY );
     706             :     }
     707             : 
     708           0 :     return false;
     709             : }
     710             : 
     711           0 : void ScViewFunctionSet::DeselectAtPoint( const Point& /* rPointPixel */ )
     712             : {
     713             :     // doesn't exist
     714           0 : }
     715             : 
     716         190 : void ScViewFunctionSet::DeselectAll()
     717             : {
     718         190 :     if (pViewData->IsAnyFillMode())
     719         190 :         return;
     720             : 
     721         190 :     bool bRefMode = SC_MOD()->IsFormulaMode();
     722         190 :     if (bRefMode)
     723             :     {
     724           0 :         pViewData->GetView()->DoneRefMode( false );
     725             :     }
     726             :     else
     727             :     {
     728         190 :         pViewData->GetView()->DoneBlockMode( false );
     729         190 :         pViewData->GetViewShell()->UpdateInputHandler();
     730             :     }
     731             : 
     732         190 :     bAnchor = false;
     733             : }
     734             : 
     735         348 : ScViewSelectionEngine::ScViewSelectionEngine( vcl::Window* pWindow, ScTabView* pView,
     736             :                                                 ScSplitPos eSplitPos ) :
     737         348 :         SelectionEngine( pWindow, &pView->GetFunctionSet() ),
     738         348 :         eWhich( eSplitPos )
     739             : {
     740         348 :     SetSelectionMode( MULTIPLE_SELECTION );
     741         348 :     EnableDrag( true );
     742         348 : }
     743             : 
     744             : // column and row headers
     745         348 : ScHeaderFunctionSet::ScHeaderFunctionSet( ScViewData* pNewViewData ) :
     746             :         pViewData( pNewViewData ),
     747             :         bColumn( false ),
     748             :         eWhich( SC_SPLIT_TOPLEFT ),
     749             :         bAnchor( false ),
     750         348 :         nCursorPos( 0 )
     751             : {
     752             :     OSL_ENSURE(pViewData, "ViewData==0 at FunctionSet");
     753         348 : }
     754             : 
     755           0 : void ScHeaderFunctionSet::SetColumn( bool bSet )
     756             : {
     757           0 :     bColumn = bSet;
     758           0 : }
     759             : 
     760           8 : void ScHeaderFunctionSet::SetWhich( ScSplitPos eNew )
     761             : {
     762           8 :     eWhich = eNew;
     763           8 : }
     764             : 
     765           0 : void ScHeaderFunctionSet::BeginDrag()
     766             : {
     767             :     // doesn't exist
     768           0 : }
     769             : 
     770           0 : void ScHeaderFunctionSet::CreateAnchor()
     771             : {
     772           0 :     if (bAnchor)
     773           0 :         return;
     774             : 
     775           0 :     ScTabView* pView = pViewData->GetView();
     776           0 :     pView->DoneBlockMode( true );
     777           0 :     if (bColumn)
     778             :     {
     779           0 :         pView->InitBlockMode( static_cast<SCCOL>(nCursorPos), 0, pViewData->GetTabNo(), true, true, false );
     780           0 :         pView->MarkCursor( static_cast<SCCOL>(nCursorPos), MAXROW, pViewData->GetTabNo() );
     781             :     }
     782             :     else
     783             :     {
     784           0 :         pView->InitBlockMode( 0, nCursorPos, pViewData->GetTabNo(), true, false, true );
     785           0 :         pView->MarkCursor( MAXCOL, nCursorPos, pViewData->GetTabNo() );
     786             :     }
     787           0 :     bAnchor = true;
     788             : }
     789             : 
     790           0 : void ScHeaderFunctionSet::DestroyAnchor()
     791             : {
     792           0 :     pViewData->GetView()->DoneBlockMode( true );
     793           0 :     bAnchor = false;
     794           0 : }
     795             : 
     796           0 : bool ScHeaderFunctionSet::SetCursorAtPoint( const Point& rPointPixel, bool /* bDontSelectAtCursor */ )
     797             : {
     798           0 :     if ( bDidSwitch )
     799             :     {
     800             :         // next valid position has to be originated from another window
     801           0 :         if ( rPointPixel == aSwitchPos )
     802           0 :             return false;                   // don't scroll in the wrong window
     803             :         else
     804           0 :             bDidSwitch = false;
     805             :     }
     806             : 
     807             :     //  Scrolling
     808           0 :     Size aWinSize = pViewData->GetActiveWin()->GetOutputSizePixel();
     809             :     bool bScroll;
     810           0 :     if (bColumn)
     811           0 :         bScroll = ( rPointPixel.X() < 0 || rPointPixel.X() >= aWinSize.Width() );
     812             :     else
     813           0 :         bScroll = ( rPointPixel.Y() < 0 || rPointPixel.Y() >= aWinSize.Height() );
     814             : 
     815             :     // moved out of fix limit?
     816           0 :     bool bSwitched = false;
     817           0 :     if ( bColumn )
     818             :     {
     819           0 :         if ( pViewData->GetHSplitMode() == SC_SPLIT_FIX )
     820             :         {
     821           0 :             if ( rPointPixel.X() > aWinSize.Width() )
     822             :             {
     823           0 :                 if ( eWhich == SC_SPLIT_TOPLEFT )
     824           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_TOPRIGHT ), bSwitched = true;
     825           0 :                 else if ( eWhich == SC_SPLIT_BOTTOMLEFT )
     826           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bSwitched = true;
     827             :             }
     828             :         }
     829             :     }
     830             :     else                // column headers
     831             :     {
     832           0 :         if ( pViewData->GetVSplitMode() == SC_SPLIT_FIX )
     833             :         {
     834           0 :             if ( rPointPixel.Y() > aWinSize.Height() )
     835             :             {
     836           0 :                 if ( eWhich == SC_SPLIT_TOPLEFT )
     837           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMLEFT ), bSwitched = true;
     838           0 :                 else if ( eWhich == SC_SPLIT_TOPRIGHT )
     839           0 :                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bSwitched = true;
     840             :             }
     841             :         }
     842             :     }
     843           0 :     if (bSwitched)
     844             :     {
     845           0 :         aSwitchPos = rPointPixel;
     846           0 :         bDidSwitch = true;
     847           0 :         return false;               // do not crunch with wrong positions
     848             :     }
     849             : 
     850             :     SCsCOL  nPosX;
     851             :     SCsROW  nPosY;
     852             :     pViewData->GetPosFromPixel( rPointPixel.X(), rPointPixel.Y(), pViewData->GetActivePart(),
     853           0 :                                 nPosX, nPosY, false );
     854           0 :     if (bColumn)
     855             :     {
     856           0 :         nCursorPos = static_cast<SCCOLROW>(nPosX);
     857           0 :         nPosY = pViewData->GetPosY(WhichV(pViewData->GetActivePart()));
     858             :     }
     859             :     else
     860             :     {
     861           0 :         nCursorPos = static_cast<SCCOLROW>(nPosY);
     862           0 :         nPosX = pViewData->GetPosX(WhichH(pViewData->GetActivePart()));
     863             :     }
     864             : 
     865           0 :     ScTabView* pView = pViewData->GetView();
     866           0 :     bool bHide = pViewData->GetCurX() != nPosX ||
     867           0 :                  pViewData->GetCurY() != nPosY;
     868           0 :     if (bHide)
     869           0 :         pView->HideAllCursors();
     870             : 
     871           0 :     if (bScroll)
     872           0 :         pView->AlignToCursor( nPosX, nPosY, SC_FOLLOW_LINE );
     873           0 :     pView->SetCursor( nPosX, nPosY );
     874             : 
     875           0 :     if ( !bAnchor || !pView->IsBlockMode() )
     876             :     {
     877           0 :         pView->DoneBlockMode( true );
     878           0 :         pViewData->GetMarkData().MarkToMulti();         //! who changes this?
     879           0 :         pView->InitBlockMode( nPosX, nPosY, pViewData->GetTabNo(), true, bColumn, !bColumn );
     880             : 
     881           0 :         bAnchor = true;
     882             :     }
     883             : 
     884           0 :     pView->MarkCursor( nPosX, nPosY, pViewData->GetTabNo(), bColumn, !bColumn );
     885             : 
     886             :     // SelectionChanged inside of HideCursor because of UpdateAutoFillMark
     887           0 :     pView->SelectionChanged();
     888             : 
     889           0 :     if (bHide)
     890           0 :         pView->ShowAllCursors();
     891             : 
     892           0 :     return true;
     893             : }
     894             : 
     895           0 : bool ScHeaderFunctionSet::IsSelectionAtPoint( const Point& rPointPixel )
     896             : {
     897             :     SCsCOL  nPosX;
     898             :     SCsROW  nPosY;
     899             :     pViewData->GetPosFromPixel( rPointPixel.X(), rPointPixel.Y(), pViewData->GetActivePart(),
     900           0 :                                 nPosX, nPosY, false );
     901             : 
     902           0 :     ScMarkData& rMark = pViewData->GetMarkData();
     903           0 :     if (bColumn)
     904           0 :         return rMark.IsColumnMarked( nPosX );
     905             :     else
     906           0 :         return rMark.IsRowMarked( nPosY );
     907             : }
     908             : 
     909           0 : void ScHeaderFunctionSet::DeselectAtPoint( const Point& /* rPointPixel */ )
     910             : {
     911           0 : }
     912             : 
     913           0 : void ScHeaderFunctionSet::DeselectAll()
     914             : {
     915           0 :     pViewData->GetView()->DoneBlockMode( false );
     916           0 :     bAnchor = false;
     917           0 : }
     918             : 
     919         348 : ScHeaderSelectionEngine::ScHeaderSelectionEngine( vcl::Window* pWindow, ScHeaderFunctionSet* pFuncSet ) :
     920         348 :         SelectionEngine( pWindow, pFuncSet )
     921             : {
     922         348 :     SetSelectionMode( MULTIPLE_SELECTION );
     923         348 :     EnableDrag( false );
     924         504 : }
     925             : 
     926             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11