sc/source/ui/view/cellsh4.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 <sfx2/request.hxx>
  21
  22 #include "cellsh.hxx"
  23 #include "tabvwsh.hxx"
  24 #include "global.hxx"
  25 #include "scmod.hxx"
  26 #include "inputhdl.hxx"
  27 #include "inputwin.hxx"
  28 #include "document.hxx"
  29 #include "sc.hrc"
  30
  31 #include <vcl/svapp.hxx>
  32
  33 void ScCellShell::ExecuteCursor( SfxRequest& rReq )
  34 {
  35     ScViewData* pData = GetViewData();
  36     ScTabViewShell* pTabViewShell   = pData->GetViewShell();
  37     const SfxItemSet*   pReqArgs = rReq.GetArgs();
  38     sal_uInt16              nSlotId  = rReq.GetSlot();
  39     SCsCOLROW           nRepeat = 1;
  40     bool                bSel = false;
  41     bool                bKeep = false;
  42
  43     if ( pReqArgs != nullptr )
  44     {
  45         const   SfxPoolItem* pItem;
  46         if (pReqArgs->HasItem(FN_PARAM_1, &pItem))
  47             nRepeat = static_cast<SCsCOLROW>(static_cast<const SfxInt16Item*>(pItem)->GetValue());
  48         if (pReqArgs->HasItem(FN_PARAM_2, &pItem))
  49             bSel = static_cast<const SfxBoolItem*>(pItem)->GetValue();
  50     }
  51     else
  52     {
  53         //  evaluate locked selection mode
  54
  55         sal_uInt16 nLocked = pTabViewShell->GetLockedModifiers();
  56         if ( nLocked & KEY_SHIFT )
  57             bSel = true;                // EXT
  58         else if ( nLocked & KEY_MOD1 )
  59         {
  60             // ADD mode: keep the selection, start a new block when marking with shift again
  61             bKeep = true;
  62         }
  63     }
  64
  65     if (bSel)
  66     {
  67         switch (nSlotId)
  68         {
  69             case SID_CURSORDOWN:
  70                 rReq.SetSlot(SID_CURSORDOWN_SEL);
  71             break;
  72             case SID_CURSORUP:
  73                 rReq.SetSlot(SID_CURSORUP_SEL);
  74             break;
  75             case SID_CURSORRIGHT:
  76                 rReq.SetSlot(SID_CURSORRIGHT_SEL);
  77             break;
  78             case SID_CURSORLEFT:
  79                 rReq.SetSlot(SID_CURSORLEFT_SEL);
  80             break;
  81             case SID_CURSORPAGEDOWN:
  82                 rReq.SetSlot(SID_CURSORPAGEDOWN_SEL);
  83             break;
  84             case SID_CURSORPAGEUP:
  85                 rReq.SetSlot(SID_CURSORPAGEUP_SEL);
  86             break;
  87             case SID_CURSORPAGERIGHT:
  88                 rReq.SetSlot(SID_CURSORPAGERIGHT_SEL);
  89             break;
  90             case SID_CURSORPAGELEFT:
  91                 rReq.SetSlot(SID_CURSORPAGELEFT_SEL);
  92             break;
  93             case SID_CURSORBLKDOWN:
  94                 rReq.SetSlot(SID_CURSORBLKDOWN_SEL);
  95             break;
  96             case SID_CURSORBLKUP:
  97                 rReq.SetSlot(SID_CURSORBLKUP_SEL);
  98             break;
  99             case SID_CURSORBLKRIGHT:
 100                 rReq.SetSlot(SID_CURSORBLKRIGHT_SEL);
 101             break;
 102             case SID_CURSORBLKLEFT:
 103                 rReq.SetSlot(SID_CURSORBLKLEFT_SEL);
 104             break;
 105             default:
 106                 ;
 107         }
 108         ExecuteCursorSel(rReq);
 109         return;
 110     }
 111
 112     SCsCOLROW nRTLSign = 1;
 113     if ( pData->GetDocument()->IsLayoutRTL( pData->GetTabNo() ) )
 114     {
 115         //! evaluate cursor movement option?
 116         nRTLSign = -1;
 117     }
 118
 119     // once extra, so that the cursor will not be painted too often with ExecuteInputDirect:
 120     pTabViewShell->HideAllCursors();
 121
 122     // #i123629#
 123     if( pTabViewShell->GetCurObjectSelectionType() == OST_Editing )
 124         pTabViewShell->SetForceFocusOnCurCell(true);
 125     else
 126         pTabViewShell->SetForceFocusOnCurCell(false);
 127
 128     //OS: once for all should do, however!
 129     pTabViewShell->ExecuteInputDirect();
 130     switch ( nSlotId )
 131     {
 132         case SID_CURSORDOWN:
 133             pTabViewShell->MoveCursorRel(   0,  nRepeat, SC_FOLLOW_LINE, bSel, bKeep );
 134             break;
 135
 136         case SID_CURSORBLKDOWN:
 137             pTabViewShell->MoveCursorArea( 0, nRepeat, SC_FOLLOW_JUMP, bSel, bKeep );
 138             break;
 139
 140         case SID_CURSORUP:
 141             pTabViewShell->MoveCursorRel(   0,  -nRepeat, SC_FOLLOW_LINE, bSel, bKeep );
 142             break;
 143
 144         case SID_CURSORBLKUP:
 145             pTabViewShell->MoveCursorArea( 0, -nRepeat, SC_FOLLOW_JUMP, bSel, bKeep );
 146             break;
 147
 148         case SID_CURSORLEFT:
 149             pTabViewShell->MoveCursorRel( static_cast<SCsCOL>(-nRepeat * nRTLSign), 0, SC_FOLLOW_LINE, bSel, bKeep );
 150             break;
 151
 152         case SID_CURSORBLKLEFT:
 153             pTabViewShell->MoveCursorArea( static_cast<SCsCOL>(-nRepeat * nRTLSign), 0, SC_FOLLOW_JUMP, bSel, bKeep );
 154             break;
 155
 156         case SID_CURSORRIGHT:
 157             pTabViewShell->MoveCursorRel(   static_cast<SCsCOL>(nRepeat * nRTLSign), 0, SC_FOLLOW_LINE, bSel, bKeep );
 158             break;
 159
 160         case SID_CURSORBLKRIGHT:
 161             pTabViewShell->MoveCursorArea( static_cast<SCsCOL>(nRepeat * nRTLSign), 0, SC_FOLLOW_JUMP, bSel, bKeep );
 162             break;
 163
 164         case SID_CURSORPAGEDOWN:
 165             pTabViewShell->MoveCursorPage(  0, nRepeat, SC_FOLLOW_FIX, bSel, bKeep );
 166             break;
 167
 168         case SID_CURSORPAGEUP:
 169             pTabViewShell->MoveCursorPage(  0, -nRepeat, SC_FOLLOW_FIX, bSel, bKeep );
 170             break;
 171
 172         case SID_CURSORPAGERIGHT_: //XXX !!!
 173             pTabViewShell->MoveCursorPage( static_cast<SCsCOL>(nRepeat), 0, SC_FOLLOW_FIX, bSel, bKeep );
 174             break;
 175
 176         case SID_CURSORPAGELEFT_: //XXX !!!
 177             pTabViewShell->MoveCursorPage( static_cast<SCsCOL>(-nRepeat), 0, SC_FOLLOW_FIX, bSel, bKeep );
 178             break;
 179
 180         default:
 181             OSL_FAIL("Unknown message in ViewShell (Cursor)");
 182             return;
 183     }
 184
 185     pTabViewShell->ShowAllCursors();
 186
 187     rReq.AppendItem( SfxInt16Item(FN_PARAM_1, static_cast<sal_Int16>(nRepeat)) );
 188     rReq.AppendItem( SfxBoolItem(FN_PARAM_2, bSel) );
 189     rReq.Done();
 190 }
 191
 192 void ScCellShell::GetStateCursor( SfxItemSet& /* rSet */ )
 193 {
 194 }
 195
 196 void ScCellShell::ExecuteCursorSel( SfxRequest& rReq )
 197 {
 198     sal_uInt16 nSlotId  = rReq.GetSlot();
 199     ScTabViewShell* pViewShell = GetViewData()->GetViewShell();
 200     ScInputHandler* pInputHdl = pViewShell->GetInputHandler();
 201     pViewShell->HideAllCursors();
 202     if (pInputHdl && pInputHdl->IsInputMode())
 203     {
 204         // the current cell is in edit mode.  Commit the text before moving on.
 205         pViewShell->ExecuteInputDirect();
 206     }
 207
 208     SCsCOLROW nRepeat = 1;
 209     const SfxItemSet* pReqArgs = rReq.GetArgs();
 210     // get repetition
 211     if ( pReqArgs != nullptr )
 212     {
 213         const SfxPoolItem* pItem;
 214         if (pReqArgs->HasItem(FN_PARAM_1, &pItem))
 215             nRepeat = static_cast<SCsCOLROW>(static_cast<const SfxInt16Item*>(pItem)->GetValue());
 216     }
 217
 218     SCsROW nMovY = nRepeat;
 219     // Horizontal direction depends on whether or not the UI language is RTL.
 220     SCsCOL nMovX = nRepeat;
 221     if (GetViewData()->GetDocument()->IsLayoutRTL(GetViewData()->GetTabNo()))
 222     {
 223         // mirror horizontal movement for right-to-left mode.
 224         nMovX = -nRepeat;
 225     }
 226
 227     switch (nSlotId)
 228     {
 229         case SID_CURSORDOWN_SEL:
 230             pViewShell->ExpandBlock(0, nMovY, SC_FOLLOW_LINE);
 231         break;
 232         case SID_CURSORUP_SEL:
 233             pViewShell->ExpandBlock(0, -nMovY, SC_FOLLOW_LINE);
 234         break;
 235         case SID_CURSORRIGHT_SEL:
 236             pViewShell->ExpandBlock(nMovX, 0, SC_FOLLOW_LINE);
 237         break;
 238         case SID_CURSORLEFT_SEL:
 239             pViewShell->ExpandBlock(-nMovX, 0, SC_FOLLOW_LINE);
 240         break;
 241         case SID_CURSORPAGEUP_SEL:
 242             pViewShell->ExpandBlockPage(0, -nMovY);
 243         break;
 244         case SID_CURSORPAGEDOWN_SEL:
 245             pViewShell->ExpandBlockPage(0, nMovY);
 246         break;
 247         case SID_CURSORPAGERIGHT_SEL:
 248             pViewShell->ExpandBlockPage(nMovX, 0);
 249         break;
 250         case SID_CURSORPAGELEFT_SEL:
 251             pViewShell->ExpandBlockPage(-nMovX, 0);
 252         break;
 253         case SID_CURSORBLKDOWN_SEL:
 254             pViewShell->ExpandBlockArea(0, nMovY);
 255         break;
 256         case SID_CURSORBLKUP_SEL:
 257             pViewShell->ExpandBlockArea(0, -nMovY);
 258         break;
 259         case SID_CURSORBLKRIGHT_SEL:
 260             pViewShell->ExpandBlockArea(nMovX , 0);
 261         break;
 262         case SID_CURSORBLKLEFT_SEL:
 263             pViewShell->ExpandBlockArea(-nMovX, 0);
 264         break;
 265         default:
 266             ;
 267     }
 268     pViewShell->ShowAllCursors();
 269
 270     rReq.AppendItem( SfxInt16Item(FN_PARAM_1,static_cast<sal_Int16>(nRepeat)) );
 271     rReq.Done();
 272 }
 273
 274 void ScCellShell::ExecuteMove( SfxRequest& rReq )
 275 {
 276     ScTabViewShell* pTabViewShell   = GetViewData()->GetViewShell();
 277     sal_uInt16 nSlotId  = rReq.GetSlot();
 278     const SfxItemSet* pReqArgs = rReq.GetArgs();
 279
 280     if(nSlotId != SID_CURSORTOPOFSCREEN && nSlotId != SID_CURSORENDOFSCREEN)
 281         pTabViewShell->ExecuteInputDirect();
 282     switch ( nSlotId )
 283     {
 284         case SID_NEXT_TABLE:
 285         case SID_NEXT_TABLE_SEL:
 286             pTabViewShell->SelectNextTab( 1, (nSlotId == SID_NEXT_TABLE_SEL) );
 287             break;
 288
 289         case SID_PREV_TABLE:
 290         case SID_PREV_TABLE_SEL:
 291             pTabViewShell->SelectNextTab( -1, (nSlotId == SID_PREV_TABLE_SEL) );
 292             break;
 293
 294         //  cursor movements in range do not originate from Basic,
 295         //  because the ScSbxRange-object changes the marking at input
 296
 297         case SID_NEXT_UNPROTECT:
 298             pTabViewShell->FindNextUnprot( false, !rReq.IsAPI() );
 299             break;
 300
 301         case SID_PREV_UNPROTECT:
 302             pTabViewShell->FindNextUnprot( true, !rReq.IsAPI() );
 303             break;
 304
 305         case SID_CURSORENTERUP:
 306             if (rReq.IsAPI())
 307                 pTabViewShell->MoveCursorRel( 0, -1, SC_FOLLOW_LINE, false );
 308             else
 309                 pTabViewShell->MoveCursorEnter( true );
 310             break;
 311
 312         case SID_CURSORENTERDOWN:
 313             if (rReq.IsAPI())
 314                 pTabViewShell->MoveCursorRel( 0, 1, SC_FOLLOW_LINE, false );
 315             else
 316                 pTabViewShell->MoveCursorEnter( false );
 317             break;
 318
 319         case SID_SELECT_COL:
 320             {
 321                 const SfxPoolItem* pColItem;
 322                 const SfxPoolItem* pModifierItem;
 323                 if ( pReqArgs && pReqArgs->HasItem( FN_PARAM_1, &pColItem ) &&
 324                      pReqArgs->HasItem( FN_PARAM_2, &pModifierItem ) )
 325                 {
 326                     SCCOL nCol = static_cast<SCCOL>(static_cast<const SfxInt32Item*>(pColItem)->GetValue());;
 327                     sal_Int16 nModifier = static_cast<sal_Int16>(static_cast<const SfxInt16Item*>(pModifierItem)->GetValue());
 328
 329                     pTabViewShell->MarkColumns( nCol, nModifier );
 330                 }
 331                 else
 332                     pTabViewShell->MarkColumns();
 333             }
 334             break;
 335
 336         case SID_SELECT_ROW:
 337             {
 338                 const SfxPoolItem* pRowItem;
 339                 const SfxPoolItem* pModifierItem;
 340                 if ( pReqArgs && pReqArgs->HasItem( FN_PARAM_1, &pRowItem ) &&
 341                      pReqArgs->HasItem( FN_PARAM_2, &pModifierItem ) )
 342                 {
 343                     SCROW nRow = static_cast<SCROW>(static_cast<const SfxInt32Item*>(pRowItem)->GetValue());;
 344                     sal_Int16 nModifier = static_cast<sal_Int16>(static_cast<const SfxInt16Item*>(pModifierItem)->GetValue());
 345
 346                     pTabViewShell->MarkRows( nRow, nModifier );
 347                 }
 348                 else
 349                     pTabViewShell->MarkRows();
 350             }
 351             break;
 352
 353         case SID_SELECT_NONE:
 354             pTabViewShell->Unmark();
 355             break;
 356
 357         case SID_ALIGNCURSOR:
 358             pTabViewShell->AlignToCursor( GetViewData()->GetCurX(), GetViewData()->GetCurY(), SC_FOLLOW_JUMP );
 359             break;
 360
 361         case SID_MARKDATAAREA:
 362             pTabViewShell->MarkDataArea();
 363             break;
 364
 365         case SID_MARKARRAYFORMULA:
 366             pTabViewShell->MarkMatrixFormula();
 367             break;
 368
 369         case SID_SETINPUTMODE:
 370             SC_MOD()->SetInputMode( SC_INPUT_TABLE );
 371             break;
 372
 373         case SID_FOCUS_INPUTLINE:
 374             {
 375                 ScInputHandler* pHdl = SC_MOD()->GetInputHdl( pTabViewShell );
 376                 if (pHdl)
 377                 {
 378                     ScInputWindow* pWin = pHdl->GetInputWindow();
 379                     if (pWin)
 380                         pWin->SwitchToTextWin();
 381                 }
 382             }
 383             break;
 384
 385         case SID_CURSORTOPOFSCREEN:
 386             pTabViewShell->MoveCursorScreen( 0, -1, SC_FOLLOW_LINE, false );
 387             break;
 388
 389         case SID_CURSORENDOFSCREEN:
 390             pTabViewShell->MoveCursorScreen( 0, 1, SC_FOLLOW_LINE, false );
 391             break;
 392
 393         default:
 394             OSL_FAIL("Unknown message in ViewShell (Cursor)");
 395             return;
 396     }
 397
 398     rReq.Done();
 399 }
 400
 401 void ScCellShell::ExecutePageSel( SfxRequest& rReq )
 402 {
 403     sal_uInt16              nSlotId  = rReq.GetSlot();
 404     switch ( nSlotId )
 405     {
 406         case SID_CURSORHOME_SEL:        rReq.SetSlot( SID_CURSORHOME );  break;
 407         case SID_CURSOREND_SEL:         rReq.SetSlot( SID_CURSOREND );  break;
 408         case SID_CURSORTOPOFFILE_SEL:   rReq.SetSlot( SID_CURSORTOPOFFILE );  break;
 409         case SID_CURSORENDOFFILE_SEL:   rReq.SetSlot( SID_CURSORENDOFFILE );  break;
 410         default:
 411             OSL_FAIL("Unknown message in ViewShell (ExecutePageSel)");
 412             return;
 413     }
 414     rReq.AppendItem( SfxBoolItem(FN_PARAM_2, true) );
 415     ExecuteSlot( rReq, GetInterface() );
 416 }
 417
 418 void ScCellShell::ExecutePage( SfxRequest& rReq )
 419 {
 420     ScTabViewShell* pTabViewShell   = GetViewData()->GetViewShell();
 421     const SfxItemSet*   pReqArgs = rReq.GetArgs();
 422     sal_uInt16              nSlotId  = rReq.GetSlot();
 423     bool                bSel = false;
 424     bool                bKeep = false;
 425
 426     if ( pReqArgs != nullptr )
 427     {
 428         const   SfxPoolItem* pItem;
 429         if (pReqArgs->HasItem(FN_PARAM_2, &pItem))
 430             bSel = static_cast<const SfxBoolItem*>(pItem)->GetValue();
 431     }
 432     else
 433     {
 434         //  evaluate locked selection mode
 435
 436         sal_uInt16 nLocked = pTabViewShell->GetLockedModifiers();
 437         if ( nLocked & KEY_SHIFT )
 438             bSel = true;                // EXT
 439         else if ( nLocked & KEY_MOD1 )
 440         {
 441             // ADD mode: keep the selection, start a new block when marking with shift again
 442             bKeep = true;
 443         }
 444     }
 445
 446     pTabViewShell->ExecuteInputDirect();
 447     switch ( nSlotId )
 448     {
 449         case SID_CURSORHOME:
 450             pTabViewShell->MoveCursorEnd( -1, 0, SC_FOLLOW_LINE, bSel, bKeep );
 451             break;
 452
 453         case SID_CURSOREND:
 454             pTabViewShell->MoveCursorEnd( 1, 0, SC_FOLLOW_JUMP, bSel, bKeep );
 455             break;
 456
 457         case SID_CURSORTOPOFFILE:
 458             pTabViewShell->MoveCursorEnd( -1, -1, SC_FOLLOW_LINE, bSel, bKeep );
 459             break;
 460
 461         case SID_CURSORENDOFFILE:
 462             pTabViewShell->MoveCursorEnd( 1, 1, SC_FOLLOW_JUMP, bSel, bKeep );
 463             break;
 464
 465         default:
 466             OSL_FAIL("Unknown message in ViewShell (ExecutePage)");
 467             return;
 468     }
 469
 470     rReq.AppendItem( SfxBoolItem(FN_PARAM_2, bSel) );
 471     rReq.Done();
 472 }
 473
 474 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */