sc/source/ui/view/select.cxx

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