sw/source/uibase/wrtsh/delete.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 <wrtsh.hxx>
  21 #include <swcrsr.hxx>
  22 #include <editeng/lrspitem.hxx>
  23 #include <view.hxx>
  24 #include <drawbase.hxx>
  25 #include <unobaseclass.hxx>
  26 #include <fmtanchr.hxx>
  27 #include <flyfrm.hxx>
  28 #include <ndtxt.hxx>
  29 #include <txtfld.hxx>
  30 #include <docufld.hxx>
  31 #include <IDocumentUndoRedo.hxx>
  32 #include <i18nutil/unicode.hxx>
  33 #include <rtl/character.hxx>
  34 #include <doc.hxx>
  35
  36 inline void SwWrtShell::OpenMark()
  37 {
  38     StartAllAction();
  39     ResetCursorStack();
  40     KillPams();
  41     SetMark();
  42 }
  43
  44 inline void SwWrtShell::CloseMark( bool bOkFlag )
  45 {
  46     if( bOkFlag )
  47         UpdateAttr();
  48     else
  49         SwapPam();
  50
  51     ClearMark();
  52     EndAllAction();
  53 }
  54
  55
  56
  57 // #i23725#
  58 bool SwWrtShell::TryRemoveIndent()
  59 {
  60     bool bResult = false;
  61
  62     SfxItemSet aAttrSet(GetAttrPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE>{});
  63     GetCurAttr(aAttrSet);
  64
  65     SvxLRSpaceItem aItem = aAttrSet.Get(RES_LR_SPACE);
  66     short aOldFirstLineOfst = aItem.GetTextFirstLineOffset();
  67
  68     if (aOldFirstLineOfst > 0)
  69     {
  70         aItem.SetTextFirstLineOffset(0);
  71         bResult = true;
  72     }
  73     else if (aOldFirstLineOfst < 0)
  74     {
  75         aItem.SetTextFirstLineOffset(0);
  76         aItem.SetLeft(aItem.GetLeft() + aOldFirstLineOfst);
  77
  78         bResult = true;
  79     }
  80     else if (aItem.GetLeft() != 0)
  81     {
  82         aItem.SetLeft(0);
  83         bResult = true;
  84     }
  85
  86     if (bResult)
  87     {
  88         aAttrSet.Put(aItem);
  89         SetAttrSet(aAttrSet);
  90     }
  91
  92     return bResult;
  93 }
  94
  95 /** Description: Erase the line. */
  96
  97 void SwWrtShell::DelLine()
  98 {
  99     SwActContext aActContext(this);
 100     ResetCursorStack();
 101         // remember the old cursor
 102     Push();
 103     ClearMark();
 104     SwCursorShell::LeftMargin();
 105     SetMark();
 106     SwCursorShell::RightMargin();
 107
 108     bool bRet = Delete();
 109     Pop(SwCursorShell::PopMode::DeleteCurrent);
 110     if( bRet )
 111         UpdateAttr();
 112 }
 113
 114 void SwWrtShell::DelToStartOfLine()
 115 {
 116     OpenMark();
 117     SwCursorShell::LeftMargin();
 118     bool bRet = Delete();
 119     CloseMark( bRet );
 120 }
 121
 122 void SwWrtShell::DelToEndOfLine()
 123 {
 124     OpenMark();
 125     SwCursorShell::RightMargin();
 126     bool bRet = Delete();
 127     CloseMark( bRet );
 128 }
 129
 130 bool SwWrtShell::DelLeft()
 131 {
 132     // If it's a Fly, throw it away
 133     SelectionType nSelType = GetSelectionType();
 134     const SelectionType nCmp = SelectionType::Frame | SelectionType::Graphic | SelectionType::Ole | SelectionType::DrawObject;
 135     if( nCmp & nSelType )
 136     {
 137         // #108205# Remember object's position.
 138         Point aTmpPt = GetObjRect().TopLeft();
 139
 140         DelSelectedObj();
 141
 142         // #108205# Set cursor to remembered position.
 143         SetCursor(&aTmpPt);
 144
 145         LeaveSelFrameMode();
 146         UnSelectFrame();
 147
 148         nSelType = GetSelectionType();
 149         if ( nCmp & nSelType )
 150         {
 151             EnterSelFrameMode();
 152             GotoNextFly();
 153         }
 154
 155         return true;
 156     }
 157
 158     // If a selection exists, erase this
 159     if ( IsSelection() )
 160     {
 161         if( !IsBlockMode() || HasSelection() )
 162         {
 163             //OS: Once again Basic: SwActContext must be leaved
 164             //before EnterStdMode!
 165             {
 166                 SwActContext aActContext(this);
 167                 ResetCursorStack();
 168                 Delete();
 169                 UpdateAttr();
 170             }
 171             if( IsBlockMode() )
 172             {
 173                 NormalizePam();
 174                 ClearMark();
 175                 EnterBlockMode();
 176             }
 177             else
 178                 EnterStdMode();
 179             return true;
 180         }
 181         else
 182             EnterStdMode();
 183     }
 184
 185     // JP 29.06.95: never erase a table standing in front of it.
 186     bool bSwap = false;
 187     const SwTableNode * pWasInTableNd = SwCursorShell::IsCursorInTable();
 188
 189     if( SwCursorShell::IsSttPara())
 190     {
 191         // Start/EndAllAction to avoid cursor flickering
 192         UnoActionContext c(GetDoc());
 193         SwCursorShell::Push();
 194
 195         // #i4032# Don't actually call a 'delete' if we
 196         // changed the table cell, compare DelRight().
 197         const SwStartNode * pSNdOld = pWasInTableNd ?
 198                                       GetSwCursor()->GetNode().FindTableBoxStartNode() :
 199                                       nullptr;
 200
 201         // If the cursor is at the beginning of a paragraph, try to step
 202         // backwards. On failure we are done.
 203         bool bDoSomething = SwCursorShell::Left(1,CRSR_SKIP_CHARS);
 204
 205         if (bDoSomething)
 206         {
 207             // If the cursor entered or left a table (or both) we are done.
 208             const SwTableNode* pIsInTableNd = SwCursorShell::IsCursorInTable();
 209             bDoSomething = pIsInTableNd == pWasInTableNd;
 210
 211             if (bDoSomething)
 212             {
 213                 const SwStartNode* pSNdNew = pIsInTableNd ?
 214                     GetSwCursor()->GetNode().FindTableBoxStartNode() :
 215                     nullptr;
 216
 217                 // #i4032# Don't actually call a 'delete' if we
 218                 // changed the table cell, compare DelRight().
 219                 bDoSomething = pSNdOld == pSNdNew;
 220             }
 221         }
 222
 223         if (!bDoSomething)
 224         {
 225             // tdf#115132 Restore previous position and we are done
 226             SwCursorShell::Pop(SwCursorShell::PopMode::DeleteCurrent);
 227             return false;
 228         }
 229
 230         SwCursorShell::Pop(SwCursorShell::PopMode::DeleteStack);
 231
 232         OpenMark();
 233         SwCursorShell::Right(1,CRSR_SKIP_CHARS);
 234         SwCursorShell::SwapPam();
 235         bSwap = true;
 236     }
 237     else
 238     {
 239         // If we are just to the right to a fieldmark, then remove it completely
 240         const SwPosition* pCurPos = GetCursor()->GetPoint();
 241         SwPosition aPrevChar(*pCurPos);
 242         --aPrevChar.nContent;
 243         sw::mark::IFieldmark* pFm = getIDocumentMarkAccess()->getFieldmarkAt(aPrevChar);
 244         if (pFm && pFm->GetMarkEnd() == *pCurPos)
 245         {
 246             mxDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
 247             IDocumentMarkAccess::DeleteFieldmarkCommand(*pFm);
 248             getIDocumentMarkAccess()->deleteMark(pFm);
 249             mxDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
 250             return true;
 251         }
 252
 253         OpenMark();
 254         SwCursorShell::Left(1, CRSR_SKIP_CHARS);
 255         if (SvtScriptType::ASIAN == GetScriptType())
 256         {
 257             sal_uInt32 nCode = GetChar(false);
 258             if ( rtl::isSurrogate( nCode ) )
 259             {
 260                 OUString sStr = GetSelText();
 261                 sal_Int32 nIndex = 0;
 262                 nCode = sStr.iterateCodePoints( &nIndex );
 263             }
 264
 265             if ( unicode::isIVSSelector( nCode ) )
 266             {
 267                 SwCursorShell::Push();
 268                 SwCursorShell::Left(1, CRSR_SKIP_CHARS);
 269                 OUString sStr = GetSelText();
 270                 sal_Int32 nIndex = 0;
 271                 nCode = sStr.iterateCodePoints( &nIndex );
 272                 if ( unicode::isCJKIVSCharacter( nCode ) )
 273                     SwCursorShell::Pop( SwCursorShell::PopMode::DeleteStack );
 274                 else
 275                     SwCursorShell::Pop( SwCursorShell::PopMode::DeleteCurrent ); // For the weak script.
 276             }
 277         }
 278     }
 279     bool bRet = Delete();
 280     if( !bRet && bSwap )
 281         SwCursorShell::SwapPam();
 282     CloseMark( bRet );
 283     if (!bRet)
 284     {   // false indicates HasReadonlySel failed
 285         std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetView().GetFrameWeld(), "modules/swriter/ui/inforeadonlydialog.ui"));
 286         std::unique_ptr<weld::MessageDialog> xInfo(xBuilder->weld_message_dialog("InfoReadonlyDialog"));
 287         xInfo->run();
 288     }
 289     return bRet;
 290 }
 291
 292 bool SwWrtShell::DelRight()
 293 {
 294         // Will be or'ed, if a tableselection exists;
 295         // will here be implemented on SelectionType::Table
 296     bool bRet = false;
 297     SelectionType nSelection = GetSelectionType();
 298     if(nSelection & SelectionType::TableCell)
 299         nSelection = SelectionType::Table;
 300     if(nSelection & SelectionType::Text)
 301         nSelection = SelectionType::Text;
 302
 303     switch( nSelection & ~SelectionType::Ornament )
 304     {
 305     case SelectionType::PostIt:
 306     case SelectionType::Text:
 307     case SelectionType::Table:
 308     case SelectionType::NumberList:
 309             //  If a selection exists, erase it.
 310         if( IsSelection() )
 311         {
 312             if( !IsBlockMode() || HasSelection() )
 313             {
 314                 //OS: And once again Basic: SwActContext must be
 315                 //leaved before EnterStdMode !
 316                 {
 317                     SwActContext aActContext(this);
 318                     ResetCursorStack();
 319                     Delete();
 320                     UpdateAttr();
 321                 }
 322                 if( IsBlockMode() )
 323                 {
 324                     NormalizePam();
 325                     ClearMark();
 326                     EnterBlockMode();
 327                 }
 328                 else
 329                     EnterStdMode();
 330                 bRet = true;
 331                 break;
 332             }
 333             else
 334                 EnterStdMode();
 335         }
 336
 337         if (SwCursorShell::IsEndPara())
 338         {
 339             // Start/EndAllAction to avoid cursor flickering
 340             UnoActionContext c(GetDoc());
 341
 342             const SwTableNode* pWasInTableNd = IsCursorInTable();
 343             // #108049# Save the startnode of the current cell
 344             const SwStartNode* pSNdOld = pWasInTableNd ?
 345                 GetSwCursor()->GetNode().FindTableBoxStartNode() : nullptr;
 346             bool bCheckDelFull = SelectionType::Text & nSelection && SwCursorShell::IsSttPara();
 347             bool bDelFull = false;
 348             bool bDoNothing = false;
 349
 350             // #i41424# Introduced a couple of
 351             // Push()-Pop() pairs here. The reason for this is that a
 352             // Right()-Left() combination does not make sure, that
 353             // the cursor will be in its initial state, because there
 354             // may be a numbering in front of the next paragraph.
 355             SwCursorShell::Push();
 356
 357             if (SwCursorShell::Right(1, CRSR_SKIP_CHARS))
 358             {
 359                 const SwTableNode* pCurrTableNd = IsCursorInTable();
 360                 bDelFull = bCheckDelFull && pCurrTableNd && pCurrTableNd != pWasInTableNd;
 361                 if (!bDelFull && (IsCursorInTable() || (pCurrTableNd != pWasInTableNd)))
 362                 {
 363                     // #108049# Save the startnode of the current cell.
 364                     // May be different to pSNdOld as we have moved.
 365                     const SwStartNode* pSNdNew = pCurrTableNd ?
 366                         GetSwCursor()->GetNode().FindTableBoxStartNode() : nullptr;
 367
 368                     // tdf#115132 Only keep cursor position instead of deleting
 369                     // if we have moved to a different cell
 370                     bDoNothing = pSNdOld != pSNdNew;
 371                 }
 372             }
 373
 374             // restore cursor
 375             SwCursorShell::Pop(SwCursorShell::PopMode::DeleteCurrent);
 376
 377             if (bDelFull)
 378             {
 379                 DelFullPara();
 380                 UpdateAttr();
 381             }
 382             if (bDelFull || bDoNothing)
 383                 break;
 384         }
 385
 386         {
 387             // If we are just ahead of a fieldmark, then remove it completely
 388             sw::mark::IFieldmark *const pFm = getIDocumentMarkAccess()->getFieldmarkAt(*GetCursor()->GetPoint());
 389             if (pFm && pFm->GetMarkStart() == *GetCursor()->GetPoint())
 390             {
 391                 mxDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
 392                 IDocumentMarkAccess::DeleteFieldmarkCommand(*pFm);
 393                 getIDocumentMarkAccess()->deleteMark(pFm);
 394                 mxDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
 395                 bRet = true;
 396                 break;
 397             }
 398         }
 399
 400         OpenMark();
 401         SwCursorShell::Right(1, CRSR_SKIP_CELLS);
 402         bRet = Delete();
 403         CloseMark( bRet );
 404         if (!bRet)
 405         {   // false indicates HasReadonlySel failed
 406             std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetView().GetFrameWeld(), "modules/swriter/ui/inforeadonlydialog.ui"));
 407             std::unique_ptr<weld::MessageDialog> xInfo(xBuilder->weld_message_dialog("InfoReadonlyDialog"));
 408             xInfo->run();
 409         }
 410         break;
 411
 412     case SelectionType::Frame:
 413     case SelectionType::Graphic:
 414     case SelectionType::Ole:
 415     case SelectionType::DrawObject:
 416     case SelectionType::DrawObjectEditMode:
 417     case SelectionType::DbForm:
 418         {
 419             // #108205# Remember object's position.
 420             Point aTmpPt = GetObjRect().TopLeft();
 421
 422             // Remember the anchor of the selected object before deletion.
 423             std::unique_ptr<SwPosition> pAnchor;
 424             SwFlyFrame* pFly = GetSelectedFlyFrame();
 425             if (pFly)
 426             {
 427                 SwFrameFormat* pFormat = pFly->GetFormat();
 428                 if (pFormat)
 429                 {
 430                     RndStdIds eAnchorId = pFormat->GetAnchor().GetAnchorId();
 431                     if ((eAnchorId == RndStdIds::FLY_AS_CHAR || eAnchorId == RndStdIds::FLY_AT_CHAR)
 432                         && pFormat->GetAnchor().GetContentAnchor())
 433                     {
 434                         pAnchor.reset(new SwPosition(*pFormat->GetAnchor().GetContentAnchor()));
 435                     }
 436                 }
 437             }
 438
 439             // Group deletion of the object and its comment together.
 440             mxDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
 441
 442             DelSelectedObj();
 443
 444             if (pAnchor)
 445             {
 446                 SwTextNode* pTextNode = pAnchor->nNode.GetNode().GetTextNode();
 447                 if (pTextNode)
 448                 {
 449                     const SwTextField* pField(
 450                         pTextNode->GetFieldTextAttrAt(pAnchor->nContent.GetIndex(), true));
 451                     if (pField
 452                         && dynamic_cast<const SwPostItField*>(pField->GetFormatField().GetField()))
 453                     {
 454                         // Remove the comment of the deleted object.
 455                         *GetCurrentShellCursor().GetPoint() = *pAnchor;
 456                         DelRight();
 457                     }
 458                 }
 459             }
 460
 461             mxDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
 462
 463             // #108205# Set cursor to remembered position.
 464             SetCursor(&aTmpPt);
 465
 466             LeaveSelFrameMode();
 467             UnSelectFrame();
 468             OSL_ENSURE( !IsFrameSelected(),
 469                     "<SwWrtShell::DelRight(..)> - <SwWrtShell::UnSelectFrame()> should unmark all objects" );
 470             // leave draw mode, if necessary.
 471             {
 472                 if (GetView().GetDrawFuncPtr())
 473                 {
 474                     GetView().GetDrawFuncPtr()->Deactivate();
 475                     GetView().SetDrawFuncPtr(nullptr);
 476                 }
 477                 if ( GetView().IsDrawMode() )
 478                 {
 479                     GetView().LeaveDrawCreate();
 480                 }
 481             }
 482         }
 483
 484         // <IsFrameSelected()> can't be true - see above.
 485         {
 486             nSelection = GetSelectionType();
 487             if ( SelectionType::Frame & nSelection ||
 488                  SelectionType::Graphic & nSelection ||
 489                  SelectionType::Ole & nSelection ||
 490                  SelectionType::DrawObject & nSelection )
 491             {
 492                 EnterSelFrameMode();
 493                 GotoNextFly();
 494             }
 495         }
 496         bRet = true;
 497         break;
 498     default: break;
 499     }
 500     return bRet;
 501 }
 502
 503 void SwWrtShell::DelToEndOfPara()
 504 {
 505     SwActContext aActContext(this);
 506     ResetCursorStack();
 507     Push();
 508     SetMark();
 509     if( !MovePara(GoCurrPara,fnParaEnd))
 510     {
 511         Pop(SwCursorShell::PopMode::DeleteCurrent);
 512         return;
 513     }
 514     bool bRet = Delete();
 515     Pop(SwCursorShell::PopMode::DeleteCurrent);
 516     if( bRet )
 517         UpdateAttr();
 518 }
 519
 520 void SwWrtShell::DelToStartOfPara()
 521 {
 522     SwActContext aActContext(this);
 523     ResetCursorStack();
 524     Push();
 525     SetMark();
 526     if( !MovePara(GoCurrPara,fnParaStart))
 527     {
 528         Pop(SwCursorShell::PopMode::DeleteCurrent);
 529         return;
 530     }
 531     bool bRet = Delete();
 532     Pop(SwCursorShell::PopMode::DeleteCurrent);
 533     if( bRet )
 534         UpdateAttr();
 535 }
 536
 537 // All erase operations should work with Find instead with
 538 // Nxt-/PrvDelim, because the latter works with Wrap Around
 539 // -- that's probably not wished.
 540
 541 void SwWrtShell::DelToStartOfSentence()
 542 {
 543     if(IsStartOfDoc())
 544         return;
 545     OpenMark();
 546     bool bRet = BwdSentence_() && Delete();
 547     CloseMark( bRet );
 548 }
 549
 550 bool SwWrtShell::DelToEndOfSentence()
 551 {
 552     if(IsEndOfDoc())
 553         return false;
 554     OpenMark();
 555     bool bRet(false);
 556     // fdo#60967: special case that is documented in help: delete
 557     // paragraph following table if cursor is at end of last cell in table
 558     if (IsEndOfTable())
 559     {
 560         Push();
 561         ClearMark();
 562         if (SwCursorShell::Right(1,CRSR_SKIP_CHARS))
 563         {
 564             SetMark();
 565             if (!IsEndPara()) // can only be at the end if it's empty
 566             {   // for an empty paragraph this would actually select the _next_
 567                 SwCursorShell::MovePara(GoCurrPara, fnParaEnd);
 568             }
 569             if (!IsEndOfDoc()) // do not delete last paragraph in body text
 570             {
 571                 bRet = DelFullPara();
 572             }
 573         }
 574         Pop(SwCursorShell::PopMode::DeleteCurrent);
 575     }
 576     else
 577     {
 578         bRet = FwdSentence_() && Delete();
 579     }
 580     CloseMark( bRet );
 581     return bRet;
 582 }
 583
 584 void SwWrtShell::DelNxtWord()
 585 {
 586     if(IsEndOfDoc())
 587         return;
 588     SwActContext aActContext(this);
 589     ResetCursorStack();
 590     EnterStdMode();
 591     SetMark();
 592     if(IsEndWrd() && !IsStartWord())
 593         NxtWrdForDelete(); // #i92468#
 594     if(IsStartWord() || IsEndPara())
 595         NxtWrdForDelete(); // #i92468#
 596     else
 597         EndWrd();
 598
 599     bool bRet = Delete();
 600     if( bRet )
 601         UpdateAttr();
 602     else
 603         SwapPam();
 604     ClearMark();
 605 }
 606
 607 void SwWrtShell::DelPrvWord()
 608 {
 609     if(IsStartOfDoc())
 610         return;
 611     SwActContext aActContext(this);
 612     ResetCursorStack();
 613     EnterStdMode();
 614     SetMark();
 615     if ( !IsStartWord() ||
 616          !PrvWrdForDelete() ) // #i92468#
 617     {
 618         if (IsEndWrd() || IsSttPara())
 619             PrvWrdForDelete(); // #i92468#
 620         else
 621             SttWrd();
 622     }
 623     bool bRet = Delete();
 624     if( bRet )
 625         UpdateAttr();
 626     else
 627         SwapPam();
 628     ClearMark();
 629 }
 630
 631 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */