sc/source/ui/view/select.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: select.cxx,v $
  10  * $Revision: 1.20 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34
  35
  36 // INCLUDE ---------------------------------------------------------------
  37
  38 #include <tools/urlobj.hxx>
  39 #include <vcl/sound.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <sfx2/docfile.hxx>
  42
  43 #include "select.hxx"
  44 #include "sc.hrc"
  45 #include "tabvwsh.hxx"
  46 #include "scmod.hxx"
  47 #include "document.hxx"
  48 //#include "dataobj.hxx"
  49 #include "transobj.hxx"
  50 #include "docsh.hxx"
  51 #include "tabprotection.hxx"
  52
  53 #define SC_SELENG_REFMODE_UPDATE_INTERVAL_MIN 65
  54
  55 extern USHORT nScFillModeMouseModifier;                         // global.cxx
  56
  57 using namespace com::sun::star;
  58
  59 // STATIC DATA -----------------------------------------------------------
  60
  61 static Point aSwitchPos;                                //! Member
  62 static BOOL bDidSwitch = FALSE;
  63
  64 // -----------------------------------------------------------------------
  65
  66 //
  67 //                                      View (Gridwin / Tastatur)
  68 //
  69
  70 ScViewFunctionSet::ScViewFunctionSet( ScViewData* pNewViewData ) :
  71         pViewData( pNewViewData ),
  72         pEngine( NULL ),
  73         bAnchor( FALSE ),
  74         bStarted( FALSE )
  75 {
  76     DBG_ASSERT(pViewData, "ViewData==0 bei FunctionSet");
  77 }
  78
  79 ScSplitPos ScViewFunctionSet::GetWhich()
  80 {
  81     if (pEngine)
  82         return pEngine->GetWhich();
  83     else
  84         return pViewData->GetActivePart();
  85 }
  86
  87 ULONG ScViewFunctionSet::CalcUpdateInterval( const Size& rWinSize, const Point& rEffPos,
  88                                              bool bLeftScroll, bool bTopScroll, bool bRightScroll, bool bBottomScroll )
  89 {
  90     ULONG nUpdateInterval = SELENG_AUTOREPEAT_INTERVAL_MAX;
  91     Window* pWin = pEngine->GetWindow();
  92     Rectangle aScrRect = pWin->GetDesktopRectPixel();
  93     Point aRootPos = pWin->OutputToAbsoluteScreenPixel(Point(0,0));
  94     if (bRightScroll)
  95     {
  96         double nWinRight = rWinSize.getWidth() + aRootPos.getX();
  97         double nMarginRight = aScrRect.GetWidth() - nWinRight;
  98         double nHOffset = rEffPos.X() - rWinSize.Width();
  99         double nHAccelRate = nHOffset / nMarginRight;
 100
 101         if (nHAccelRate > 1.0)
 102             nHAccelRate = 1.0;
 103
 104         nUpdateInterval = static_cast<ULONG>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nHAccelRate));
 105     }
 106
 107     if (bLeftScroll)
 108     {
 109         double nMarginLeft = aRootPos.getX();
 110         double nHOffset = -rEffPos.X();
 111         double nHAccelRate = nHOffset / nMarginLeft;
 112
 113         if (nHAccelRate > 1.0)
 114             nHAccelRate = 1.0;
 115
 116         ULONG nTmp = static_cast<ULONG>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nHAccelRate));
 117         if (nUpdateInterval > nTmp)
 118             nUpdateInterval = nTmp;
 119     }
 120
 121     if (bBottomScroll)
 122     {
 123         double nWinBottom = rWinSize.getHeight() + aRootPos.getY();
 124         double nMarginBottom = aScrRect.GetHeight() - nWinBottom;
 125         double nVOffset = rEffPos.Y() - rWinSize.Height();
 126         double nVAccelRate = nVOffset / nMarginBottom;
 127
 128         if (nVAccelRate > 1.0)
 129             nVAccelRate = 1.0;
 130
 131         ULONG nTmp = static_cast<ULONG>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nVAccelRate));
 132         if (nUpdateInterval > nTmp)
 133             nUpdateInterval = nTmp;
 134     }
 135
 136     if (bTopScroll)
 137     {
 138         double nMarginTop = aRootPos.getY();
 139         double nVOffset = -rEffPos.Y();
 140         double nVAccelRate = nVOffset / nMarginTop;
 141
 142         if (nVAccelRate > 1.0)
 143             nVAccelRate = 1.0;
 144
 145         ULONG nTmp = static_cast<ULONG>(SELENG_AUTOREPEAT_INTERVAL_MAX*(1.0 - nVAccelRate));
 146         if (nUpdateInterval > nTmp)
 147             nUpdateInterval = nTmp;
 148     }
 149
 150 #ifdef WNT
 151     ScTabViewShell* pViewShell = pViewData->GetViewShell();
 152     bool bRefMode = pViewShell && pViewShell->IsRefInputMode();
 153     if (bRefMode && nUpdateInterval < SC_SELENG_REFMODE_UPDATE_INTERVAL_MIN)
 154         // Lower the update interval during ref mode, because re-draw can be
 155         // expensive on Windows.  Making this interval too small would queue up
 156         // the scroll/paint requests which would cause semi-infinite
 157         // scrolls even after the mouse cursor is released.  We don't have
 158         // this problem on Linux.
 159         nUpdateInterval = SC_SELENG_REFMODE_UPDATE_INTERVAL_MIN;
 160 #endif
 161     return nUpdateInterval;
 162 }
 163
 164 void ScViewFunctionSet::SetSelectionEngine( ScViewSelectionEngine* pSelEngine )
 165 {
 166     pEngine = pSelEngine;
 167 }
 168
 169 //              Drag & Drop
 170
 171 void __EXPORT ScViewFunctionSet::BeginDrag()
 172 {
 173     SCTAB nTab = pViewData->GetTabNo();
 174
 175     SCsCOL nPosX;
 176     SCsROW nPosY;
 177     if (pEngine)
 178     {
 179         Point aMPos = pEngine->GetMousePosPixel();
 180         pViewData->GetPosFromPixel( aMPos.X(), aMPos.Y(), GetWhich(), nPosX, nPosY );
 181     }
 182     else
 183     {
 184         nPosX = pViewData->GetCurX();
 185         nPosY = pViewData->GetCurY();
 186     }
 187
 188     ScModule* pScMod = SC_MOD();
 189     BOOL bRefMode = pScMod->IsFormulaMode();
 190     if (!bRefMode)
 191     {
 192         pViewData->GetView()->FakeButtonUp( GetWhich() );       // ButtonUp wird verschluckt
 193
 194         ScMarkData& rMark = pViewData->GetMarkData();
 195 //              rMark.SetMarking(FALSE);                                                // es fehlt ein ButtonUp
 196         rMark.MarkToSimple();
 197         if ( rMark.IsMarked() && !rMark.IsMultiMarked() )
 198         {
 199             ScDocument* pClipDoc = new ScDocument( SCDOCMODE_CLIP );
 200             // bApi = TRUE -> no error mesages
 201             BOOL bCopied = pViewData->GetView()->CopyToClip( pClipDoc, FALSE, TRUE );
 202             if ( bCopied )
 203             {
 204                 sal_Int8 nDragActions = pViewData->GetView()->SelectionEditable() ?
 205                                         ( DND_ACTION_COPYMOVE | DND_ACTION_LINK ) :
 206                                         ( DND_ACTION_COPY | DND_ACTION_LINK );
 207
 208                 ScDocShell* pDocSh = pViewData->GetDocShell();
 209                 TransferableObjectDescriptor aObjDesc;
 210                 pDocSh->FillTransferableObjectDescriptor( aObjDesc );
 211                 aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 212                 // maSize is set in ScTransferObj ctor
 213
 214                 ScTransferObj* pTransferObj = new ScTransferObj( pClipDoc, aObjDesc );
 215                 uno::Reference<datatransfer::XTransferable> xTransferable( pTransferObj );
 216
 217                 // set position of dragged cell within range
 218                 ScRange aMarkRange = pTransferObj->GetRange();
 219                 SCCOL nStartX = aMarkRange.aStart.Col();
 220                 SCROW nStartY = aMarkRange.aStart.Row();
 221                 SCCOL nHandleX = (nPosX >= (SCsCOL) nStartX) ? nPosX - nStartX : 0;
 222                 SCROW nHandleY = (nPosY >= (SCsROW) nStartY) ? nPosY - nStartY : 0;
 223                 pTransferObj->SetDragHandlePos( nHandleX, nHandleY );
 224                 pTransferObj->SetVisibleTab( nTab );
 225
 226                 pTransferObj->SetDragSource( pDocSh, rMark );
 227
 228                 Window* pWindow = pViewData->GetActiveWin();
 229                 if ( pWindow->IsTracking() )
 230                     pWindow->EndTracking( ENDTRACK_CANCEL );    // abort selecting
 231
 232                 SC_MOD()->SetDragObject( pTransferObj, NULL );          // for internal D&D
 233                 pTransferObj->StartDrag( pWindow, nDragActions );
 234
 235                 return;                 // dragging started
 236             }
 237             else
 238                 delete pClipDoc;
 239         }
 240     }
 241
 242     Sound::Beep();                      // can't drag
 243 }
 244
 245 //              Selektion
 246
 247 void __EXPORT ScViewFunctionSet::CreateAnchor()
 248 {
 249     if (bAnchor) return;
 250
 251     BOOL bRefMode = SC_MOD()->IsFormulaMode();
 252     if (bRefMode)
 253         SetAnchor( pViewData->GetRefStartX(), pViewData->GetRefStartY() );
 254     else
 255         SetAnchor( pViewData->GetCurX(), pViewData->GetCurY() );
 256 }
 257
 258 void ScViewFunctionSet::SetAnchor( SCCOL nPosX, SCROW nPosY )
 259 {
 260     BOOL bRefMode = SC_MOD()->IsFormulaMode();
 261     ScTabView* pView = pViewData->GetView();
 262     SCTAB nTab = pViewData->GetTabNo();
 263
 264     if (bRefMode)
 265     {
 266         pView->DoneRefMode( FALSE );
 267         aAnchorPos.Set( nPosX, nPosY, nTab );
 268         pView->InitRefMode( aAnchorPos.Col(), aAnchorPos.Row(), aAnchorPos.Tab(),
 269                             SC_REFTYPE_REF );
 270         bStarted = TRUE;
 271     }
 272     else if (pViewData->IsAnyFillMode())
 273     {
 274         aAnchorPos.Set( nPosX, nPosY, nTab );
 275         bStarted = TRUE;
 276     }
 277     else
 278     {
 279         // nicht weg und gleich wieder hin
 280         if ( bStarted && pView->IsMarking( nPosX, nPosY, nTab ) )
 281         {
 282             // nix
 283         }
 284         else
 285         {
 286             pView->DoneBlockMode( TRUE );
 287             aAnchorPos.Set( nPosX, nPosY, nTab );
 288             ScMarkData& rMark = pViewData->GetMarkData();
 289             if ( rMark.IsMarked() || rMark.IsMultiMarked() )
 290             {
 291                 pView->InitBlockMode( aAnchorPos.Col(), aAnchorPos.Row(),
 292                                         aAnchorPos.Tab(), TRUE );
 293                 bStarted = TRUE;
 294             }
 295             else
 296                 bStarted = FALSE;
 297         }
 298     }
 299     bAnchor = TRUE;
 300 }
 301
 302 void __EXPORT ScViewFunctionSet::DestroyAnchor()
 303 {
 304     BOOL bRefMode = SC_MOD()->IsFormulaMode();
 305     if (bRefMode)
 306         pViewData->GetView()->DoneRefMode( TRUE );
 307     else
 308         pViewData->GetView()->DoneBlockMode( TRUE );
 309
 310     bAnchor = FALSE;
 311 }
 312
 313 void ScViewFunctionSet::SetAnchorFlag( BOOL bSet )
 314 {
 315     bAnchor = bSet;
 316 }
 317
 318 BOOL __EXPORT ScViewFunctionSet::SetCursorAtPoint( const Point& rPointPixel, BOOL /* bDontSelectAtCursor */ )
 319 {
 320     if ( bDidSwitch )
 321     {
 322         if ( rPointPixel == aSwitchPos )
 323             return FALSE;                                       // nicht auf falschem Fenster scrollen
 324         else
 325             bDidSwitch = FALSE;
 326     }
 327     aSwitchPos = rPointPixel;           // nur wichtig, wenn bDidSwitch
 328
 329     //  treat position 0 as -1, so scrolling is always possible
 330     //  (with full screen and hidden headers, the top left border may be at 0)
 331     //  (moved from ScViewData::GetPosFromPixel)
 332
 333     Point aEffPos = rPointPixel;
 334     if ( aEffPos.X() == 0 )
 335         aEffPos.X() = -1;
 336     if ( aEffPos.Y() == 0 )
 337         aEffPos.Y() = -1;
 338
 339     //  Scrolling
 340
 341     Size aWinSize = pEngine->GetWindow()->GetOutputSizePixel();
 342         bool bRightScroll  = ( aEffPos.X() >= aWinSize.Width() );
 343         bool bLeftScroll  = ( aEffPos.X() < 0 );
 344         bool bBottomScroll = ( aEffPos.Y() >= aWinSize.Height() );
 345         bool bTopScroll = ( aEffPos.Y() < 0 );
 346         bool bScroll = bRightScroll || bBottomScroll || bLeftScroll || bTopScroll;
 347
 348     SCsCOL      nPosX;
 349     SCsROW      nPosY;
 350     pViewData->GetPosFromPixel( aEffPos.X(), aEffPos.Y(), GetWhich(),
 351                                 nPosX, nPosY, TRUE, TRUE );             // mit Repair
 352
 353     //  fuer AutoFill in der Mitte der Zelle umschalten
 354     //  dabei aber nicht das Scrolling nach rechts/unten verhindern
 355     if ( pViewData->IsFillMode() || pViewData->GetFillMode() == SC_FILL_MATRIX )
 356     {
 357         BOOL bLeft, bTop;
 358         pViewData->GetMouseQuadrant( aEffPos, GetWhich(), nPosX, nPosY, bLeft, bTop );
 359         ScDocument* pDoc = pViewData->GetDocument();
 360         SCTAB nTab = pViewData->GetTabNo();
 361         if ( bLeft && !bRightScroll )
 362                         do --nPosX; while ( nPosX>=0 && pDoc->ColHidden( nPosX, nTab ) );
 363         if ( bTop && !bBottomScroll )
 364         {
 365             if (--nPosY >= 0)
 366             {
 367                 nPosY = pDoc->LastVisibleRow(0, nPosY, nTab);
 368                 if (!ValidRow(nPosY))
 369                     nPosY = -1;
 370             }
 371         }
 372         //      negativ ist erlaubt
 373     }
 374
 375     //  ueber Fixier-Grenze bewegt?
 376
 377     ScSplitPos eWhich = GetWhich();
 378     if ( eWhich == pViewData->GetActivePart() )
 379     {
 380         if ( pViewData->GetHSplitMode() == SC_SPLIT_FIX )
 381             if ( aEffPos.X() >= aWinSize.Width() )
 382             {
 383                 if ( eWhich == SC_SPLIT_TOPLEFT )
 384                     pViewData->GetView()->ActivatePart( SC_SPLIT_TOPRIGHT ), bScroll = FALSE, bDidSwitch = TRUE;
 385                 else if ( eWhich == SC_SPLIT_BOTTOMLEFT )
 386                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bScroll = FALSE, bDidSwitch = TRUE;
 387             }
 388
 389         if ( pViewData->GetVSplitMode() == SC_SPLIT_FIX )
 390             if ( aEffPos.Y() >= aWinSize.Height() )
 391             {
 392                 if ( eWhich == SC_SPLIT_TOPLEFT )
 393                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMLEFT ), bScroll = FALSE, bDidSwitch = TRUE;
 394                 else if ( eWhich == SC_SPLIT_TOPRIGHT )
 395                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bScroll = FALSE, bDidSwitch = TRUE;
 396             }
 397     }
 398
 399     if (bScroll)
 400     {
 401         // Adjust update interval based on how far the mouse pointer is from the edge.
 402         ULONG nUpdateInterval = CalcUpdateInterval(
 403             aWinSize, aEffPos, bLeftScroll, bTopScroll, bRightScroll, bBottomScroll);
 404         pEngine->SetUpdateInterval(nUpdateInterval);
 405     }
 406     else
 407     {
 408         // Don't forget to reset the interval when not scrolling!
 409         pEngine->SetUpdateInterval(SELENG_AUTOREPEAT_INTERVAL);
 410     }
 411
 412     pViewData->ResetOldCursor();
 413     return SetCursorAtCell( nPosX, nPosY, bScroll );
 414 }
 415
 416 BOOL ScViewFunctionSet::SetCursorAtCell( SCsCOL nPosX, SCsROW nPosY, BOOL bScroll )
 417 {
 418     ScTabView* pView = pViewData->GetView();
 419     SCTAB nTab = pViewData->GetTabNo();
 420     ScDocument* pDoc = pViewData->GetDocument();
 421
 422     if ( pDoc->IsTabProtected(nTab) )
 423     {
 424         if (nPosX < 0 || nPosY < 0)
 425             return false;
 426
 427         ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
 428         bool bSkipProtected   = !pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
 429         bool bSkipUnprotected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
 430
 431         if ( bSkipProtected && bSkipUnprotected )
 432             return FALSE;
 433
 434         bool bCellProtected = pDoc->HasAttrib(nPosX, nPosY, nTab, nPosX, nPosY, nTab, HASATTR_PROTECTED);
 435         if ( (bCellProtected && bSkipProtected) || (!bCellProtected && bSkipUnprotected) )
 436             // Don't select this cell!
 437             return FALSE;
 438     }
 439
 440     ScModule* pScMod = SC_MOD();
 441     ScTabViewShell* pViewShell = pViewData->GetViewShell();
 442     bool bRefMode = ( pViewShell ? pViewShell->IsRefInputMode() : false );
 443
 444     BOOL bHide = !bRefMode && !pViewData->IsAnyFillMode() &&
 445             ( nPosX != (SCsCOL) pViewData->GetCurX() || nPosY != (SCsROW) pViewData->GetCurY() );
 446
 447     if (bHide)
 448         pView->HideAllCursors();
 449
 450     if (bScroll)
 451     {
 452         if (bRefMode)
 453         {
 454             ScSplitPos eWhich = GetWhich();
 455             pView->AlignToCursor( nPosX, nPosY, SC_FOLLOW_LINE, &eWhich );
 456         }
 457         else
 458             pView->AlignToCursor( nPosX, nPosY, SC_FOLLOW_LINE );
 459     }
 460
 461     if (bRefMode)
 462     {
 463         // #90910# if no input is possible from this doc, don't move the reference cursor around
 464         if ( !pScMod->IsModalMode(pViewData->GetSfxDocShell()) )
 465         {
 466             if (!bAnchor)
 467             {
 468                 pView->DoneRefMode( TRUE );
 469                 pView->InitRefMode( nPosX, nPosY, pViewData->GetTabNo(), SC_REFTYPE_REF );
 470             }
 471
 472             pView->UpdateRef( nPosX, nPosY, pViewData->GetTabNo() );
 473         }
 474     }
 475     else if (pViewData->IsFillMode() ||
 476             (pViewData->GetFillMode() == SC_FILL_MATRIX && (nScFillModeMouseModifier & KEY_MOD1) ))
 477     {
 478         //      Wenn eine Matrix angefasst wurde, kann mit Ctrl auf AutoFill zurueckgeschaltet werden
 479
 480         SCCOL nStartX, nEndX;
 481         SCROW nStartY, nEndY; // Block
 482         SCTAB nDummy;
 483         pViewData->GetSimpleArea( nStartX, nStartY, nDummy, nEndX, nEndY, nDummy );
 484
 485         if (pViewData->GetRefType() != SC_REFTYPE_FILL)
 486         {
 487             pView->InitRefMode( nStartX, nStartY, nTab, SC_REFTYPE_FILL );
 488             CreateAnchor();
 489         }
 490
 491         ScRange aDelRange;
 492         BOOL bOldDelMark = pViewData->GetDelMark( aDelRange );
 493
 494         if ( nPosX+1 >= (SCsCOL) nStartX && nPosX <= (SCsCOL) nEndX &&
 495              nPosY+1 >= (SCsROW) nStartY && nPosY <= (SCsROW) nEndY &&
 496              ( nPosX != nEndX || nPosY != nEndY ) )                                             // verkleinern ?
 497         {
 498             //  Richtung (links oder oben)
 499
 500             long nSizeX = 0;
 501             for (SCCOL i=nPosX+1; i<=nEndX; i++)
 502                 nSizeX += pDoc->GetColWidth( i, nTab );
 503             long nSizeY = (long) pDoc->GetRowHeight( nPosY+1, nEndY, nTab );
 504
 505             SCCOL nDelStartX = nStartX;
 506             SCROW nDelStartY = nStartY;
 507             if ( nSizeX > nSizeY )
 508                 nDelStartX = nPosX + 1;
 509             else
 510                 nDelStartY = nPosY + 1;
 511             // 0 braucht nicht mehr getrennt abgefragt zu werden, weil nPosX/Y auch negativ wird
 512
 513             if ( nDelStartX < nStartX )
 514                 nDelStartX = nStartX;
 515             if ( nDelStartY < nStartY )
 516                 nDelStartY = nStartY;
 517
 518             //  Bereich setzen
 519
 520             pViewData->SetDelMark( ScRange( nDelStartX,nDelStartY,nTab,
 521                                             nEndX,nEndY,nTab ) );
 522             pViewData->GetView()->UpdateShrinkOverlay();
 523
 524 #if 0
 525             if ( bOldDelMark )
 526             {
 527                 ScUpdateRect aRect( aDelRange.aStart.Col(), aDelRange.aStart.Row(),
 528                                     aDelRange.aEnd.Col(), aDelRange.aEnd.Row() );
 529                 aRect.SetNew( nDelStartX,nDelStartY, nEndX,nEndY );
 530                 SCCOL nPaintStartX;
 531                 SCROW nPaintStartY;
 532                 SCCOL nPaintEndX;
 533                 SCROW nPaintEndY;
 534                 if (aRect.GetDiff( nPaintStartX, nPaintStartY, nPaintEndX, nPaintEndY ))
 535                     pViewData->GetView()->
 536                         PaintArea( nPaintStartX, nPaintStartY,
 537                                     nPaintEndX, nPaintEndY, SC_UPDATE_MARKS );
 538             }
 539             else
 540 #endif
 541                 pViewData->GetView()->
 542                     PaintArea( nStartX,nDelStartY, nEndX,nEndY, SC_UPDATE_MARKS );
 543
 544             nPosX = nEndX;              // roten Rahmen um ganzen Bereich lassen
 545             nPosY = nEndY;
 546
 547             //  Referenz wieder richtigherum, falls unten umgedreht
 548             if ( nStartX != pViewData->GetRefStartX() || nStartY != pViewData->GetRefStartY() )
 549             {
 550                 pViewData->GetView()->DoneRefMode();
 551                 pViewData->GetView()->InitRefMode( nStartX, nStartY, nTab, SC_REFTYPE_FILL );
 552             }
 553         }
 554         else
 555         {
 556             if ( bOldDelMark )
 557             {
 558                 pViewData->ResetDelMark();
 559                 pViewData->GetView()->UpdateShrinkOverlay();
 560
 561 #if 0
 562                 pViewData->GetView()->
 563                     PaintArea( aDelRange.aStart.Col(), aDelRange.aStart.Row(),
 564                                aDelRange.aEnd.Col(), aDelRange.aEnd.Row(), SC_UPDATE_MARKS );
 565 #endif
 566             }
 567
 568             BOOL bNegX = ( nPosX < (SCsCOL) nStartX );
 569             BOOL bNegY = ( nPosY < (SCsROW) nStartY );
 570
 571             long nSizeX = 0;
 572             if ( bNegX )
 573             {
 574                 //      #94321# in SetCursorAtPoint hidden columns are skipped.
 575                 //      They must be skipped here too, or the result will always be the first hidden column.
 576                                 do ++nPosX; while ( nPosX<nStartX && pDoc->ColHidden(nPosX, nTab) );
 577                 for (SCCOL i=nPosX; i<nStartX; i++)
 578                     nSizeX += pDoc->GetColWidth( i, nTab );
 579             }
 580             else
 581                 for (SCCOL i=nEndX+1; i<=nPosX; i++)
 582                     nSizeX += pDoc->GetColWidth( i, nTab );
 583
 584             long nSizeY = 0;
 585             if ( bNegY )
 586             {
 587                 //      #94321# in SetCursorAtPoint hidden rows are skipped.
 588                 //      They must be skipped here too, or the result will always be the first hidden row.
 589                 if (++nPosY < nStartY)
 590                 {
 591                     nPosY = pDoc->FirstVisibleRow(nPosY, nStartY-1, nTab);
 592                     if (!ValidRow(nPosY))
 593                         nPosY = nStartY;
 594                 }
 595                 nSizeY += pDoc->GetRowHeight( nPosY, nStartY-1, nTab );
 596             }
 597             else
 598                 nSizeY += pDoc->GetRowHeight( nEndY+1, nPosY, nTab );
 599
 600             if ( nSizeX > nSizeY )                      // Fill immer nur in einer Richtung
 601             {
 602                 nPosY = nEndY;
 603                 bNegY = FALSE;
 604             }
 605             else
 606             {
 607                 nPosX = nEndX;
 608                 bNegX = FALSE;
 609             }
 610
 611             SCCOL nRefStX = bNegX ? nEndX : nStartX;
 612             SCROW nRefStY = bNegY ? nEndY : nStartY;
 613             if ( nRefStX != pViewData->GetRefStartX() || nRefStY != pViewData->GetRefStartY() )
 614             {
 615                 pViewData->GetView()->DoneRefMode();
 616                 pViewData->GetView()->InitRefMode( nRefStX, nRefStY, nTab, SC_REFTYPE_FILL );
 617             }
 618         }
 619
 620         pView->UpdateRef( nPosX, nPosY, nTab );
 621     }
 622     else if (pViewData->IsAnyFillMode())
 623     {
 624         BYTE nMode = pViewData->GetFillMode();
 625         if ( nMode == SC_FILL_EMBED_LT || nMode == SC_FILL_EMBED_RB )
 626         {
 627             DBG_ASSERT( pDoc->IsEmbedded(), "!pDoc->IsEmbedded()" );
 628             ScRange aRange;
 629             pDoc->GetEmbedded( aRange);
 630             ScRefType eRefMode = (nMode == SC_FILL_EMBED_LT) ? SC_REFTYPE_EMBED_LT : SC_REFTYPE_EMBED_RB;
 631             if (pViewData->GetRefType() != eRefMode)
 632             {
 633                 if ( nMode == SC_FILL_EMBED_LT )
 634                     pView->InitRefMode( aRange.aEnd.Col(), aRange.aEnd.Row(), nTab, eRefMode );
 635                 else
 636                     pView->InitRefMode( aRange.aStart.Col(), aRange.aStart.Row(), nTab, eRefMode );
 637                 CreateAnchor();
 638             }
 639
 640             pView->UpdateRef( nPosX, nPosY, nTab );
 641         }
 642         else if ( nMode == SC_FILL_MATRIX )
 643         {
 644             SCCOL nStartX, nEndX;
 645             SCROW nStartY, nEndY; // Block
 646             SCTAB nDummy;
 647             pViewData->GetSimpleArea( nStartX, nStartY, nDummy, nEndX, nEndY, nDummy );
 648
 649             if (pViewData->GetRefType() != SC_REFTYPE_FILL)
 650             {
 651                 pView->InitRefMode( nStartX, nStartY, nTab, SC_REFTYPE_FILL );
 652                 CreateAnchor();
 653             }
 654
 655             if ( nPosX < nStartX ) nPosX = nStartX;
 656             if ( nPosY < nStartY ) nPosY = nStartY;
 657
 658             pView->UpdateRef( nPosX, nPosY, nTab );
 659         }
 660         // else neue Modi
 661     }
 662     else                                        // normales Markieren
 663     {
 664         BOOL bHideCur = bAnchor && ( (SCCOL)nPosX != pViewData->GetCurX() ||
 665                                      (SCROW)nPosY != pViewData->GetCurY() );
 666         if (bHideCur)
 667             pView->HideAllCursors();                    // sonst zweimal: Block und SetCursor
 668
 669         if (bAnchor)
 670         {
 671             if (!bStarted)
 672             {
 673                 BOOL bMove = ( nPosX != (SCsCOL) aAnchorPos.Col() ||
 674                                 nPosY != (SCsROW) aAnchorPos.Row() );
 675                 if ( bMove || ( pEngine && pEngine->GetMouseEvent().IsShift() ) )
 676                 {
 677                     pView->InitBlockMode( aAnchorPos.Col(), aAnchorPos.Row(),
 678                                             aAnchorPos.Tab(), TRUE );
 679                     bStarted = TRUE;
 680                 }
 681             }
 682             if (bStarted)
 683                 // If the selection is already started, don't set the cursor.
 684                 pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab, FALSE, FALSE, TRUE );
 685             else
 686                 pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
 687         }
 688         else
 689         {
 690             ScMarkData& rMark = pViewData->GetMarkData();
 691             if (rMark.IsMarked() || rMark.IsMultiMarked())
 692             {
 693                 pView->DoneBlockMode(TRUE);
 694                 pView->InitBlockMode( nPosX, nPosY, nTab, TRUE );
 695                 pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab );
 696
 697                 aAnchorPos.Set( nPosX, nPosY, nTab );
 698                 bStarted = TRUE;
 699             }
 700             // #i3875# *Hack* When a new cell is Ctrl-clicked with no pre-selected cells,
 701             // it highlights that new cell as well as the old cell where the cursor is
 702             // positioned prior to the click.  A selection mode via Shift-F8 should also
 703             // follow the same behavior.
 704             else if ( pViewData->IsSelCtrlMouseClick() )
 705             {
 706                 SCCOL nOldX = pViewData->GetCurX();
 707                 SCROW nOldY = pViewData->GetCurY();
 708
 709                 pView->InitBlockMode( nOldX, nOldY, nTab, TRUE );
 710                 pView->MarkCursor( (SCCOL) nOldX, (SCROW) nOldY, nTab );
 711
 712                 if ( nOldX != nPosX || nOldY != nPosY )
 713                 {
 714                     pView->DoneBlockMode( TRUE );
 715                     pView->InitBlockMode( nPosX, nPosY, nTab, TRUE );
 716                     pView->MarkCursor( (SCCOL) nPosX, (SCROW) nPosY, nTab );
 717                     aAnchorPos.Set( nPosX, nPosY, nTab );
 718                 }
 719
 720                 bStarted = TRUE;
 721             }
 722             pView->SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
 723         }
 724
 725         pViewData->SetRefStart( nPosX, nPosY, nTab );
 726         if (bHideCur)
 727             pView->ShowAllCursors();
 728     }
 729
 730     if (bHide)
 731         pView->ShowAllCursors();
 732
 733     return TRUE;
 734 }
 735
 736 BOOL __EXPORT ScViewFunctionSet::IsSelectionAtPoint( const Point& rPointPixel )
 737 {
 738     BOOL bRefMode = SC_MOD()->IsFormulaMode();
 739     if (bRefMode)
 740         return FALSE;
 741
 742     if (pViewData->IsAnyFillMode())
 743         return FALSE;
 744
 745     ScMarkData& rMark = pViewData->GetMarkData();
 746     if (bAnchor || !rMark.IsMultiMarked())
 747     {
 748         SCsCOL  nPosX;
 749         SCsROW  nPosY;
 750         pViewData->GetPosFromPixel( rPointPixel.X(), rPointPixel.Y(), GetWhich(), nPosX, nPosY );
 751         return pViewData->GetMarkData().IsCellMarked( (SCCOL) nPosX, (SCROW) nPosY );
 752     }
 753
 754     return FALSE;
 755 }
 756
 757 void __EXPORT ScViewFunctionSet::DeselectAtPoint( const Point& /* rPointPixel */ )
 758 {
 759     //  gibt's nicht
 760 }
 761
 762 void __EXPORT ScViewFunctionSet::DeselectAll()
 763 {
 764     if (pViewData->IsAnyFillMode())
 765         return;
 766
 767     BOOL bRefMode = SC_MOD()->IsFormulaMode();
 768     if (bRefMode)
 769     {
 770         pViewData->GetView()->DoneRefMode( FALSE );
 771     }
 772     else
 773     {
 774         pViewData->GetView()->DoneBlockMode( FALSE );
 775         pViewData->GetViewShell()->UpdateInputHandler();
 776     }
 777
 778     bAnchor = FALSE;
 779 }
 780
 781 //------------------------------------------------------------------------
 782
 783 ScViewSelectionEngine::ScViewSelectionEngine( Window* pWindow, ScTabView* pView,
 784                                                 ScSplitPos eSplitPos ) :
 785         SelectionEngine( pWindow, pView->GetFunctionSet() ),
 786         eWhich( eSplitPos )
 787 {
 788     //  Parameter einstellen
 789     SetSelectionMode( MULTIPLE_SELECTION );
 790     EnableDrag( TRUE );
 791 }
 792
 793
 794 //------------------------------------------------------------------------
 795
 796 //
 797 //                                      Spalten- / Zeilenheader
 798 //
 799
 800 ScHeaderFunctionSet::ScHeaderFunctionSet( ScViewData* pNewViewData ) :
 801         pViewData( pNewViewData ),
 802         bColumn( FALSE ),
 803         eWhich( SC_SPLIT_TOPLEFT ),
 804         bAnchor( FALSE ),
 805         nCursorPos( 0 )
 806 {
 807     DBG_ASSERT(pViewData, "ViewData==0 bei FunctionSet");
 808 }
 809
 810 void ScHeaderFunctionSet::SetColumn( BOOL bSet )
 811 {
 812     bColumn = bSet;
 813 }
 814
 815 void ScHeaderFunctionSet::SetWhich( ScSplitPos eNew )
 816 {
 817     eWhich = eNew;
 818 }
 819
 820 void __EXPORT ScHeaderFunctionSet::BeginDrag()
 821 {
 822     // gippsnich
 823 }
 824
 825 void __EXPORT ScHeaderFunctionSet::CreateAnchor()
 826 {
 827     if (bAnchor)
 828         return;
 829
 830     ScTabView* pView = pViewData->GetView();
 831     pView->DoneBlockMode( TRUE );
 832     if (bColumn)
 833     {
 834         pView->InitBlockMode( static_cast<SCCOL>(nCursorPos), 0, pViewData->GetTabNo(), TRUE, TRUE, FALSE );
 835         pView->MarkCursor( static_cast<SCCOL>(nCursorPos), MAXROW, pViewData->GetTabNo() );
 836     }
 837     else
 838     {
 839         pView->InitBlockMode( 0, nCursorPos, pViewData->GetTabNo(), TRUE, FALSE, TRUE );
 840         pView->MarkCursor( MAXCOL, nCursorPos, pViewData->GetTabNo() );
 841     }
 842     bAnchor = TRUE;
 843 }
 844
 845 void __EXPORT ScHeaderFunctionSet::DestroyAnchor()
 846 {
 847     pViewData->GetView()->DoneBlockMode( TRUE );
 848     bAnchor = FALSE;
 849 }
 850
 851 BOOL __EXPORT ScHeaderFunctionSet::SetCursorAtPoint( const Point& rPointPixel, BOOL /* bDontSelectAtCursor */ )
 852 {
 853     if ( bDidSwitch )
 854     {
 855         //      die naechste gueltige Position muss vom anderen Fenster kommen
 856         if ( rPointPixel == aSwitchPos )
 857             return FALSE;                                       // nicht auf falschem Fenster scrollen
 858         else
 859             bDidSwitch = FALSE;
 860     }
 861
 862     //  Scrolling
 863
 864     Size aWinSize = pViewData->GetActiveWin()->GetOutputSizePixel();
 865     BOOL bScroll;
 866     if (bColumn)
 867         bScroll = ( rPointPixel.X() < 0 || rPointPixel.X() >= aWinSize.Width() );
 868     else
 869         bScroll = ( rPointPixel.Y() < 0 || rPointPixel.Y() >= aWinSize.Height() );
 870
 871     //  ueber Fixier-Grenze bewegt?
 872
 873     BOOL bSwitched = FALSE;
 874     if ( bColumn )
 875     {
 876         if ( pViewData->GetHSplitMode() == SC_SPLIT_FIX )
 877         {
 878             if ( rPointPixel.X() > aWinSize.Width() )
 879             {
 880                 if ( eWhich == SC_SPLIT_TOPLEFT )
 881                     pViewData->GetView()->ActivatePart( SC_SPLIT_TOPRIGHT ), bSwitched = TRUE;
 882                 else if ( eWhich == SC_SPLIT_BOTTOMLEFT )
 883                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bSwitched = TRUE;
 884             }
 885         }
 886     }
 887     else                                // Zeilenkoepfe
 888     {
 889         if ( pViewData->GetVSplitMode() == SC_SPLIT_FIX )
 890         {
 891             if ( rPointPixel.Y() > aWinSize.Height() )
 892             {
 893                 if ( eWhich == SC_SPLIT_TOPLEFT )
 894                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMLEFT ), bSwitched = TRUE;
 895                 else if ( eWhich == SC_SPLIT_TOPRIGHT )
 896                     pViewData->GetView()->ActivatePart( SC_SPLIT_BOTTOMRIGHT ), bSwitched = TRUE;
 897             }
 898         }
 899     }
 900     if (bSwitched)
 901     {
 902         aSwitchPos = rPointPixel;
 903         bDidSwitch = TRUE;
 904         return FALSE;                           // nicht mit falschen Positionen rechnen
 905     }
 906
 907     //
 908
 909     SCsCOL      nPosX;
 910     SCsROW      nPosY;
 911     pViewData->GetPosFromPixel( rPointPixel.X(), rPointPixel.Y(), pViewData->GetActivePart(),
 912                                 nPosX, nPosY, FALSE );
 913     if (bColumn)
 914     {
 915         nCursorPos = static_cast<SCCOLROW>(nPosX);
 916         nPosY = pViewData->GetPosY(WhichV(pViewData->GetActivePart()));
 917     }
 918     else
 919     {
 920         nCursorPos = static_cast<SCCOLROW>(nPosY);
 921         nPosX = pViewData->GetPosX(WhichH(pViewData->GetActivePart()));
 922     }
 923
 924     ScTabView* pView = pViewData->GetView();
 925     BOOL bHide = pViewData->GetCurX() != nPosX ||
 926                  pViewData->GetCurY() != nPosY;
 927     if (bHide)
 928         pView->HideAllCursors();
 929
 930     if (bScroll)
 931         pView->AlignToCursor( nPosX, nPosY, SC_FOLLOW_LINE );
 932     pView->SetCursor( nPosX, nPosY );
 933
 934     if ( !bAnchor || !pView->IsBlockMode() )
 935     {
 936         pView->DoneBlockMode( TRUE );
 937         pViewData->GetMarkData().MarkToMulti();                 //! wer verstellt das ???
 938         pView->InitBlockMode( nPosX, nPosY, pViewData->GetTabNo(), TRUE, bColumn, !bColumn );
 939
 940         bAnchor = TRUE;
 941     }
 942
 943     pView->MarkCursor( nPosX, nPosY, pViewData->GetTabNo(), bColumn, !bColumn );
 944
 945     //  SelectionChanged innerhalb von HideCursor wegen UpdateAutoFillMark
 946     pView->SelectionChanged();
 947
 948     if (bHide)
 949         pView->ShowAllCursors();
 950
 951     return TRUE;
 952 }
 953
 954 BOOL __EXPORT ScHeaderFunctionSet::IsSelectionAtPoint( const Point& rPointPixel )
 955 {
 956     SCsCOL      nPosX;
 957     SCsROW      nPosY;
 958     pViewData->GetPosFromPixel( rPointPixel.X(), rPointPixel.Y(), pViewData->GetActivePart(),
 959                                 nPosX, nPosY, FALSE );
 960
 961     ScMarkData& rMark = pViewData->GetMarkData();
 962     if (bColumn)
 963         return rMark.IsColumnMarked( nPosX );
 964     else
 965         return rMark.IsRowMarked( nPosY );
 966 }
 967
 968 void __EXPORT ScHeaderFunctionSet::DeselectAtPoint( const Point& /* rPointPixel */ )
 969 {
 970 }
 971
 972 void __EXPORT ScHeaderFunctionSet::DeselectAll()
 973 {
 974     pViewData->GetView()->DoneBlockMode( FALSE );
 975     bAnchor = FALSE;
 976 }
 977
 978 //------------------------------------------------------------------------
 979
 980 ScHeaderSelectionEngine::ScHeaderSelectionEngine( Window* pWindow, ScHeaderFunctionSet* pFuncSet ) :
 981         SelectionEngine( pWindow, pFuncSet )
 982 {
 983     //  Parameter einstellen
 984     SetSelectionMode( MULTIPLE_SELECTION );
 985     EnableDrag( FALSE );
 986 }
 987
 988
 989
 990
 991