sw/source/core/edit/ednumber.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 <editsh.hxx>
  21 #include <edimp.hxx>
  22 #include <doc.hxx>
  23 #include <IDocumentUndoRedo.hxx>
  24 #include <IDocumentState.hxx>
  25 #include <ndtxt.hxx>
  26 #include <txtfrm.hxx>
  27 #include <swundo.hxx>
  28 #include <numrule.hxx>
  29 #include <osl/diagnose.h>
  30
  31 SwPamRanges::SwPamRanges( const SwPaM& rRing )
  32 {
  33     for(SwPaM& rTmp : const_cast<SwPaM*>(&rRing)->GetRingContainer())
  34         Insert( rTmp.GetMark()->GetNode(), rTmp.GetPoint()->GetNode() );
  35 }
  36
  37 void SwPamRanges::Insert( const SwNode& rIdx1, const SwNode& rIdx2 )
  38 {
  39     SwPamRange aRg( rIdx1.GetIndex(), rIdx2.GetIndex() );
  40     if( aRg.nEnd < aRg.nStart )
  41     {   aRg.nStart = aRg.nEnd; aRg.nEnd = rIdx1.GetIndex(); }
  42
  43     o3tl::sorted_vector<SwPamRange>::const_iterator it = maVector.lower_bound(aRg); //search Insert Position
  44     size_t nPos = it - maVector.begin();
  45     if (!maVector.empty() && (it != maVector.end()) && (*it) == aRg)
  46     {
  47         // is the one in the Array smaller?
  48         SwPamRange const& rTmp = maVector[nPos];
  49         if( rTmp.nEnd < aRg.nEnd )
  50         {
  51             aRg.nEnd = rTmp.nEnd;
  52             maVector.erase(maVector.begin() + nPos); // combine
  53         }
  54         else
  55             return; // done, because by precondition everything is combined
  56     }
  57
  58     bool bEnd;
  59     do {
  60         bEnd = true;
  61
  62         // combine with predecessor?
  63         if( nPos > 0 )
  64         {
  65             SwPamRange const& rTmp = maVector[nPos-1];
  66             if( rTmp.nEnd == aRg.nStart
  67                 || rTmp.nEnd+1 == aRg.nStart )
  68             {
  69                 aRg.nStart = rTmp.nStart;
  70                 bEnd = false;
  71                 maVector.erase( maVector.begin() + --nPos ); // combine
  72             }
  73             // range contained in rTmp?
  74             else if( rTmp.nStart <= aRg.nStart && aRg.nEnd <= rTmp.nEnd )
  75                 return;
  76         }
  77         // combine with successor?
  78         if( nPos < maVector.size() )
  79         {
  80             SwPamRange const& rTmp = maVector[nPos];
  81             if( rTmp.nStart == aRg.nEnd ||
  82                 rTmp.nStart == aRg.nEnd+1 )
  83             {
  84                 aRg.nEnd = rTmp.nEnd;
  85                 bEnd = false;
  86                 maVector.erase( maVector.begin() + nPos ); // combine
  87             }
  88
  89             // range contained in rTmp?
  90             else if( rTmp.nStart <= aRg.nStart && aRg.nEnd <= rTmp.nEnd )
  91                 return;
  92         }
  93     } while( !bEnd );
  94
  95     maVector.insert( aRg );
  96 }
  97
  98 SwPaM& SwPamRanges::SetPam( size_t nArrPos, SwPaM& rPam )
  99 {
 100     assert( nArrPos < Count() );
 101     const SwPamRange& rTmp = maVector[ nArrPos ];
 102     rPam.GetPoint()->Assign(rTmp.nStart);
 103     rPam.SetMark();
 104     rPam.GetPoint()->Assign(rTmp.nEnd);
 105     return rPam;
 106 }
 107
 108 // Rule book for outline numbering
 109
 110 void SwEditShell::SetOutlineNumRule(const SwNumRule& rRule)
 111 {
 112     StartAllAction();       // bracketing for updating!
 113     GetDoc()->SetOutlineNumRule(rRule);
 114     EndAllAction();
 115 }
 116
 117 const SwNumRule* SwEditShell::GetOutlineNumRule() const
 118 {
 119     return GetDoc()->GetOutlineNumRule();
 120 }
 121
 122 // Set if there is no numbering yet, else update.
 123 // Works with old and new rules. Update only differences.
 124
 125 // paragraphs without numbering, with indentations
 126 void SwEditShell::NoNum()
 127 {
 128     StartAllAction();
 129
 130     SwPaM* pCursor = GetCursor();
 131     if( pCursor->GetNext() != pCursor )         // Multiple selection?
 132     {
 133         GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 134         SwPamRanges aRangeArr( *pCursor );
 135         SwPaM aPam( *pCursor->GetPoint() );
 136         for( size_t n = 0; n < aRangeArr.Count(); ++n )
 137             GetDoc()->NoNum( aRangeArr.SetPam( n, aPam ));
 138         GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 139     }
 140     else
 141         // sw_redlinehide: leave cursor as is, will be split at Point & apply to new node
 142         GetDoc()->NoNum( *pCursor );
 143
 144     EndAllAction();
 145 }
 146
 147 // The entire selection is numbered (ignoring unnumbered empty lines)
 148 bool SwEditShell::SelectionHasNumber() const
 149 {
 150     bool bResult = false;
 151     for (SwPaM& rPaM : GetCursor()->GetRingContainer())
 152     {
 153         SwNodeOffset nStt = rPaM.Start()->GetNodeIndex();
 154         SwNodeOffset nEnd = rPaM.End()->GetNodeIndex();
 155         for (SwNodeOffset nPos = nStt; nPos<=nEnd; nPos++)
 156         {
 157             SwTextNode* pTextNd = mxDoc->GetNodes()[nPos]->GetTextNode();
 158             if (pTextNd)
 159             {
 160                 pTextNd = sw::GetParaPropsNode(*GetLayout(), *pTextNd);
 161             }
 162             if (pTextNd && (!bResult || pTextNd->Len()!=0))
 163             {
 164                 bResult = pTextNd->HasNumber();
 165
 166                 // #b6340308# special case: outline numbered, not counted paragraph
 167                 if (bResult &&
 168                     pTextNd->GetNumRule() == GetDoc()->GetOutlineNumRule() &&
 169                     !pTextNd->IsCountedInList())
 170                 {
 171                     bResult = false;
 172                 }
 173                 if (!bResult && pTextNd->Len())
 174                     break;
 175             }
 176         }
 177     }
 178
 179     return bResult;
 180 }
 181
 182 // add a new function to determine number on/off status
 183 bool SwEditShell::SelectionHasBullet() const
 184 {
 185     bool bResult = false;
 186     for (SwPaM& rPaM : GetCursor()->GetRingContainer())
 187     {
 188         SwNodeOffset nStt = rPaM.Start()->GetNodeIndex();
 189         SwNodeOffset nEnd = rPaM.End()->GetNodeIndex();
 190         for (SwNodeOffset nPos = nStt; nPos<=nEnd; nPos++)
 191         {
 192             SwTextNode* pTextNd = mxDoc->GetNodes()[nPos]->GetTextNode();
 193             if (pTextNd)
 194             {
 195                 pTextNd = sw::GetParaPropsNode(*GetLayout(), *pTextNd);
 196             }
 197             if (pTextNd && (!bResult || pTextNd->Len()!=0))
 198             {
 199                 bResult = pTextNd->HasBullet();
 200
 201                 if (!bResult && pTextNd->Len())
 202                     break;
 203             }
 204         }
 205     }
 206
 207     return bResult;
 208 }
 209
 210 // -> #i29560#
 211 bool SwEditShell::HasNumber() const
 212 {
 213     bool bResult = false;
 214
 215     const SwTextNode *const pTextNd = sw::GetParaPropsNode(*GetLayout(), GetCursor()->GetPoint()->GetNode());
 216
 217     if (pTextNd)
 218     {
 219         bResult = pTextNd->HasNumber();
 220
 221         // special case: outline numbered, not counted paragraph
 222         if ( bResult &&
 223              pTextNd->GetNumRule() == GetDoc()->GetOutlineNumRule() &&
 224              !pTextNd->IsCountedInList() )
 225         {
 226             bResult = false;
 227         }
 228     }
 229
 230     return bResult;
 231 }
 232
 233 bool SwEditShell::HasBullet() const
 234 {
 235     bool bResult = false;
 236
 237     const SwTextNode *const pTextNd = sw::GetParaPropsNode(*GetLayout(), GetCursor()->GetPoint()->GetNode());
 238
 239     if (pTextNd)
 240     {
 241         bResult = pTextNd->HasBullet();
 242     }
 243
 244     return bResult;
 245 }
 246 // <- #i29560#
 247
 248 // delete, split list
 249 void SwEditShell::DelNumRules()
 250 {
 251     StartAllAction();
 252
 253     SwPaM* pCursor = GetCursor();
 254     if( pCursor->IsMultiSelection() )
 255     {
 256         GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 257         for (SwPaM& rPaM : pCursor->GetRingContainer())
 258         {
 259             GetDoc()->DelNumRules(rPaM, GetLayout());
 260         }
 261         GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 262     }
 263     else
 264         GetDoc()->DelNumRules(*pCursor, GetLayout());
 265
 266     // Call AttrChangeNotify on the UI-side. Should actually be redundant but there was a bug once.
 267     CallChgLnk();
 268
 269     // Cursor cannot be in front of a label anymore, because numbering/bullet is deleted.
 270     SetInFrontOfLabel( false );
 271
 272     GetDoc()->getIDocumentState().SetModified();
 273     EndAllAction();
 274 }
 275
 276 // up- & downgrading
 277 void SwEditShell::NumUpDown( bool bDown )
 278 {
 279     StartAllAction();
 280
 281     SwPaM* pCursor = GetCursor();
 282     if( !pCursor->IsMultiSelection() )
 283         GetDoc()->NumUpDown(*pCursor, bDown, GetLayout());
 284     else
 285     {
 286         GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 287         SwPamRanges aRangeArr( *pCursor );
 288         SwPaM aPam( *pCursor->GetPoint() );
 289         for( size_t n = 0; n < aRangeArr.Count(); ++n )
 290             GetDoc()->NumUpDown(aRangeArr.SetPam( n, aPam ), bDown, GetLayout());
 291         GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 292     }
 293     GetDoc()->getIDocumentState().SetModified();
 294
 295     // #i54693# Update marked numbering levels
 296     if ( IsInFrontOfLabel() )
 297         UpdateMarkedListLevel();
 298
 299     CallChgLnk();
 300
 301     EndAllAction();
 302 }
 303
 304 bool SwEditShell::IsFirstOfNumRuleAtCursorPos() const
 305 {
 306     return SwDoc::IsFirstOfNumRuleAtPos(*GetCursor()->GetPoint(), *GetLayout());
 307 }
 308
 309 // -> #i23725#, #i90078#
 310 void SwEditShell::ChangeIndentOfAllListLevels( const sal_Int32 nDiff )
 311 {
 312     StartAllAction();
 313
 314     const SwNumRule *pCurNumRule = GetNumRuleAtCurrCursorPos();
 315     if ( pCurNumRule != nullptr )
 316     {
 317         SwNumRule aRule(*pCurNumRule);
 318         const SwNumFormat& aRootNumFormat(aRule.Get(0));
 319         if( nDiff > 0 || aRootNumFormat.GetIndentAt() + nDiff > 0) // fdo#42708
 320         {
 321             // #i90078#
 322             aRule.ChangeIndent( nDiff );
 323         }
 324         // no start of new list
 325         SetCurNumRule( aRule, false );
 326     }
 327
 328     EndAllAction();
 329 }
 330
 331 // #i90078#
 332 void SwEditShell::SetIndent(short nIndent, const SwPosition & rPos)
 333 {
 334     StartAllAction();
 335
 336     SwPosition pos(rPos);
 337     SwNumRule *pCurNumRule = SwDoc::GetNumRuleAtPos(pos, GetLayout());
 338
 339     if (pCurNumRule)
 340     {
 341         SwNumRule aRule(*pCurNumRule);
 342         if ( !IsMultiSelection() && IsFirstOfNumRuleAtCursorPos() )
 343         {
 344             aRule.SetIndentOfFirstListLevelAndChangeOthers( nIndent );
 345         }
 346         else
 347         {
 348             const SwTextNode* pTextNode = pos.GetNode().GetTextNode();
 349             if ( pTextNode != nullptr
 350                  && pTextNode->GetActualListLevel() >= 0 )
 351             {
 352                 aRule.SetIndent( nIndent, static_cast< sal_uInt16 >( pTextNode->GetActualListLevel() ) );
 353             }
 354         }
 355
 356         // change numbering rule - changed numbering rule is not applied at <aPaM>
 357         SwPaM aPaM(pos);
 358         GetDoc()->SetNumRule(aPaM, aRule, SwDoc::SetNumRuleMode::DontSetItem, GetLayout(), OUString());
 359     }
 360
 361     EndAllAction();
 362 }
 363
 364 bool SwEditShell::MoveParagraph( SwNodeOffset nOffset )
 365 {
 366     StartAllAction();
 367
 368     SwPaM *pCursor = GetCursor();
 369
 370     bool bRet = GetDoc()->MoveParagraph( *pCursor, nOffset );
 371
 372     GetDoc()->getIDocumentState().SetModified();
 373     EndAllAction();
 374     return bRet;
 375 }
 376
 377 int SwEditShell::GetCurrentParaOutlineLevel( ) const
 378 {
 379     int nLevel = 0;
 380
 381     SwPaM* pCursor = GetCursor();
 382     const SwTextNode *const pTextNd = sw::GetParaPropsNode(*GetLayout(), pCursor->GetPoint()->GetNode());
 383     if (pTextNd)
 384         nLevel = pTextNd->GetAttrOutlineLevel();
 385     return nLevel;
 386 }
 387
 388 void SwEditShell::GetCurrentOutlineLevels( sal_uInt8& rUpper, sal_uInt8& rLower )
 389 {
 390     SwPaM* pCursor = GetCursor();
 391     SwPaM aCursor( *pCursor->Start() );
 392     aCursor.SetMark();
 393     if( pCursor->HasMark() )
 394         *aCursor.GetPoint() = *pCursor->End();
 395     SwDoc::GotoNextNum(*aCursor.GetPoint(), GetLayout(), false, &rUpper, &rLower);
 396 }
 397
 398 bool SwEditShell::MoveNumParas( bool bUpperLower, bool bUpperLeft )
 399 {
 400     StartAllAction();
 401
 402     // On all selections?
 403     SwPaM* pCursor = GetCursor();
 404     SwPaM aCursor( *pCursor->Start() );
 405     aCursor.SetMark();
 406
 407     if( pCursor->HasMark() )
 408         *aCursor.GetPoint() = *pCursor->End();
 409
 410     bool bRet = false;
 411     sal_uInt8 nUpperLevel, nLowerLevel;
 412     if (SwDoc::GotoNextNum( *aCursor.GetPoint(), GetLayout(), false,
 413                                 &nUpperLevel, &nLowerLevel ))
 414     {
 415         if( bUpperLower )
 416         {
 417             // on top of the next numbering
 418             SwNodeOffset nOffset(0);
 419             const SwNode* pNd;
 420
 421             if( bUpperLeft ) // move up
 422             {
 423                 SwPosition aPos( *aCursor.GetMark() );
 424                 if (SwDoc::GotoPrevNum( aPos, GetLayout(), false ))
 425                     nOffset = aPos.GetNodeIndex() -
 426                             aCursor.GetMark()->GetNodeIndex();
 427                 else
 428                 {
 429                     SwNodeOffset nStt = aPos.GetNodeIndex(), nIdx = nStt - 1;
 430
 431                     if (SwTextNode const*const pStart = aPos.GetNode().GetTextNode())
 432                     {
 433                         std::pair<SwTextNode *, SwTextNode *> nodes(
 434                             sw::GetFirstAndLastNode(*GetLayout(), *pStart));
 435                         nIdx = nodes.first->GetIndex() - 1;
 436                     }
 437                     while( nIdx && (
 438                         ( pNd = GetDoc()->GetNodes()[ nIdx ])->IsSectionNode() ||
 439                         ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode())))
 440                         --nIdx;
 441                     if( GetDoc()->GetNodes()[ nIdx ]->IsTextNode() )
 442                         nOffset = nIdx - nStt;
 443                 }
 444             }
 445             else             // move down
 446             {
 447                 assert(!aCursor.GetPointNode().IsTextNode()
 448                     || sw::IsParaPropsNode(*GetLayout(), *aCursor.GetPointNode().GetTextNode()));
 449                 const SwNumRule* pOrig = sw::GetParaPropsNode(*GetLayout(), *aCursor.GetMarkNode().GetTextNode())->GetNumRule();
 450                 if( aCursor.GetPointNode().IsTextNode() &&
 451                     pOrig == aCursor.GetPointNode().GetTextNode()->GetNumRule() )
 452                 {
 453                     SwNodeOffset nStt = aCursor.GetPoint()->GetNodeIndex(), nIdx = nStt+1;
 454                     if (SwTextNode const*const pStart = aCursor.GetPoint()->GetNode().GetTextNode())
 455                     {
 456                         std::pair<SwTextNode *, SwTextNode *> nodes(
 457                             sw::GetFirstAndLastNode(*GetLayout(), *pStart));
 458                         nIdx = nodes.second->GetIndex() + 1;
 459                     }
 460
 461                     while (nIdx < GetDoc()->GetNodes().Count()-1)
 462                     {
 463                         pNd = GetDoc()->GetNodes()[ nIdx ];
 464
 465                         if (pNd->IsSectionNode() ||
 466                             (pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode()))
 467                         {
 468                             ++nIdx;
 469                         }
 470                         else if (pNd->IsTextNode())
 471                         {
 472                             SwTextNode const*const pTextNode =
 473                                 sw::GetParaPropsNode(*GetLayout(), *pNd);
 474                             if (pOrig == pTextNode->GetNumRule()
 475                                 && pTextNode->GetActualListLevel() > nUpperLevel)
 476                             {
 477                                 std::pair<SwTextNode *, SwTextNode *> nodes(
 478                                     sw::GetFirstAndLastNode(*GetLayout(), *pTextNode));
 479                                 nIdx = nodes.second->GetIndex() + 1;
 480                             }
 481                             else
 482                             {
 483                                 break;
 484                             }
 485                         }
 486                         // #i57856#
 487                         else
 488                         {
 489                             break;
 490                         }
 491                     }
 492
 493                     if( nStt == nIdx || !GetDoc()->GetNodes()[ nIdx ]->IsTextNode() )
 494                         nOffset = SwNodeOffset(1);
 495                     else
 496                         nOffset = nIdx - nStt;
 497                 }
 498                 else
 499                     nOffset = SwNodeOffset(1);
 500             }
 501
 502             if( nOffset )
 503             {
 504                 aCursor.Move( fnMoveBackward, GoInNode );
 505                 bRet = GetDoc()->MoveParagraph( aCursor, nOffset );
 506             }
 507         }
 508         else if( (bUpperLeft ? nUpperLevel : nLowerLevel+1) < MAXLEVEL )
 509         {
 510             aCursor.Move( fnMoveBackward, GoInNode );
 511             bRet = GetDoc()->NumUpDown(aCursor, !bUpperLeft, GetLayout());
 512         }
 513     }
 514
 515     GetDoc()->getIDocumentState().SetModified();
 516     EndAllAction();
 517     return bRet;
 518 }
 519
 520 bool SwEditShell::OutlineUpDown( short nOffset )
 521 {
 522     StartAllAction();
 523
 524     bool bRet = true;
 525     SwPaM* pCursor = GetCursor();
 526     if( !pCursor->IsMultiSelection() )
 527         bRet = GetDoc()->OutlineUpDown(*pCursor, nOffset, GetLayout());
 528     else
 529     {
 530         GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 531         SwPamRanges aRangeArr( *pCursor );
 532         SwPaM aPam( *pCursor->GetPoint() );
 533         for( size_t n = 0; n < aRangeArr.Count(); ++n )
 534             bRet = bRet && GetDoc()->OutlineUpDown(
 535                             aRangeArr.SetPam(n, aPam), nOffset, GetLayout());
 536         GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 537     }
 538     GetDoc()->getIDocumentState().SetModified();
 539     EndAllAction();
 540     return bRet;
 541 }
 542
 543 bool SwEditShell::MoveOutlinePara( SwOutlineNodes::difference_type nOffset,
 544                 SwOutlineNodesInline* pOutlineNodesInline )
 545 {
 546     StartAllAction();
 547     bool bRet = GetDoc()->MoveOutlinePara( *GetCursor(), nOffset, pOutlineNodesInline );
 548     EndAllAction();
 549     return bRet;
 550 }
 551
 552 // Outlines and SubOutline are ReadOnly?
 553 bool SwEditShell::IsProtectedOutlinePara() const
 554 {
 555     bool bRet = false;
 556     const SwNode& rNd = GetCursor()->Start()->GetNode();
 557     if( rNd.IsTextNode() )
 558     {
 559         const SwOutlineNodes& rOutlNd = GetDoc()->GetNodes().GetOutLineNds();
 560         bool bFirst = true;
 561         SwOutlineNodes::size_type nPos;
 562         int nLvl(0);
 563         if (!rOutlNd.Seek_Entry(&rNd, &nPos) && nPos)
 564             --nPos;
 565
 566         for( ; nPos < rOutlNd.size(); ++nPos )
 567         {
 568             SwNode* pTmpNd = rOutlNd[ nPos ];
 569
 570             if (!sw::IsParaPropsNode(*GetLayout(), *pTmpNd->GetTextNode()))
 571             {
 572                 continue;
 573             }
 574
 575             int nTmpLvl = pTmpNd->GetTextNode()->GetAttrOutlineLevel();
 576
 577             OSL_ENSURE( nTmpLvl >= 0 && nTmpLvl <= MAXLEVEL,
 578                     "<SwEditShell::IsProtectedOutlinePara()>" );
 579
 580             if( bFirst )
 581             {
 582                 nLvl = nTmpLvl;
 583                 bFirst = false;
 584             }
 585             else if( nLvl >= nTmpLvl )
 586                 break;
 587
 588             if( pTmpNd->IsProtect() )
 589             {
 590                 bRet = true;
 591                 break;
 592             }
 593         }
 594     }
 595 #if OSL_DEBUG_LEVEL > 0
 596     else
 597     {
 598         OSL_FAIL("Cursor not on an outline node");
 599     }
 600 #endif
 601     return bRet;
 602 }
 603
 604 /** Test whether outline may be moved (bCopy == false)
 605  *                           or copied (bCopy == true)
 606  * Verify these conditions:
 607  * 1) outline must be within main body (and not in redline)
 608  * 2) outline must not be within table
 609  * 3) if bCopy is set, outline must not be write protected
 610  */
 611 static bool lcl_IsOutlineMoveAndCopyable(SwEditShell const& rShell,
 612         SwOutlineNodes::size_type const nIdx, bool const bCopy)
 613 {
 614     const SwNodes& rNds = rShell.GetDoc()->GetNodes();
 615     const SwNode* pNd = rNds.GetOutLineNds()[ nIdx ];
 616     return pNd->GetIndex() >= rNds.GetEndOfExtras().GetIndex() &&   // 1) body
 617             !pNd->FindTableNode() &&                                // 2) table
 618             sw::IsParaPropsNode(*rShell.GetLayout(), *pNd->GetTextNode()) &&
 619             ( bCopy || !pNd->IsProtect() );                         // 3) write
 620 }
 621
 622 bool SwEditShell::IsOutlineMovable( SwOutlineNodes::size_type nIdx ) const
 623 {
 624     return lcl_IsOutlineMoveAndCopyable( *this, nIdx, false );
 625 }
 626
 627 bool SwEditShell::IsOutlineCopyable( SwOutlineNodes::size_type nIdx ) const
 628 {
 629     return lcl_IsOutlineMoveAndCopyable( *this, nIdx, true );
 630 }
 631
 632 bool SwEditShell::NumOrNoNum( bool bNumOn )
 633 {
 634     bool bRet = false;
 635
 636     if ( !IsMultiSelection()
 637          && !HasSelection()
 638          && IsSttPara() )
 639     {
 640         StartAllAction();
 641         SwPosition const pos(sw::GetParaPropsPos(*GetLayout(), *GetCursor()->GetPoint()));
 642         bRet = GetDoc()->NumOrNoNum(pos.GetNode(), !bNumOn);
 643         EndAllAction();
 644     }
 645     return bRet;
 646 }
 647
 648 bool SwEditShell::IsNoNum() const
 649 {
 650     // a Backspace in the paragraph without number becomes a Delete
 651     bool bResult = false;
 652
 653     if ( !IsMultiSelection()
 654          && !HasSelection()
 655          && IsSttPara() )
 656     {
 657         const SwTextNode* pTextNd = sw::GetParaPropsNode(*GetLayout(), GetCursor()->GetPoint()->GetNode());
 658         if ( pTextNd != nullptr )
 659         {
 660             bResult =  !pTextNd->IsCountedInList();
 661         }
 662     }
 663
 664     return bResult;
 665 }
 666
 667 sal_uInt8 SwEditShell::GetNumLevel() const
 668 {
 669     // return current level where the point of the cursor is
 670     sal_uInt8 nLevel = MAXLEVEL;
 671
 672     SwPaM* pCursor = GetCursor();
 673     const SwTextNode *const pTextNd = sw::GetParaPropsNode(*GetLayout(), pCursor->GetPoint()->GetNode());
 674
 675     OSL_ENSURE( pTextNd, "GetNumLevel() without text node" );
 676     if ( pTextNd == nullptr )
 677         return nLevel;
 678
 679     const SwNumRule* pRule = pTextNd->GetNumRule();
 680     if ( pRule != nullptr )
 681     {
 682         const int nListLevelOfTextNode( pTextNd->GetActualListLevel() );
 683         if ( nListLevelOfTextNode >= 0 )
 684         {
 685             nLevel = static_cast<sal_uInt8>( nListLevelOfTextNode );
 686         }
 687     }
 688
 689     return nLevel;
 690 }
 691
 692 const SwNumRule* SwEditShell::GetNumRuleAtCurrCursorPos() const
 693 {
 694     SwPosition pos(*GetCursor()->GetPoint());
 695     return SwDoc::GetNumRuleAtPos( pos, GetLayout() );
 696 }
 697
 698 const SwNumRule* SwEditShell::GetNumRuleAtCurrentSelection() const
 699 {
 700     const SwNumRule* pNumRuleAtCurrentSelection = nullptr;
 701
 702     bool bDifferentNumRuleFound = false;
 703     for(const SwPaM& rCurrentCursor : GetCursor()->GetRingContainer())
 704     {
 705         const SwNode& rEndNode(rCurrentCursor.End()->GetNode());
 706
 707         for ( SwNodeIndex aNode(rCurrentCursor.Start()->GetNode()); aNode <= rEndNode; ++aNode )
 708         {
 709             SwPosition pos(aNode);
 710             const SwNumRule* pNumRule = SwDoc::GetNumRuleAtPos(pos, GetLayout());
 711             if ( pNumRule == nullptr )
 712             {
 713                 continue;
 714             }
 715             else if ( pNumRule != pNumRuleAtCurrentSelection )
 716             {
 717                 if ( pNumRuleAtCurrentSelection == nullptr )
 718                 {
 719                     pNumRuleAtCurrentSelection = pNumRule;
 720                 }
 721                 else
 722                 {
 723                     pNumRuleAtCurrentSelection = nullptr;
 724                     bDifferentNumRuleFound = true;
 725                     break;
 726                 }
 727             }
 728         }
 729         if(bDifferentNumRuleFound)
 730             break;
 731     }
 732
 733     return pNumRuleAtCurrentSelection;
 734 }
 735
 736 void SwEditShell::SetCurNumRule( const SwNumRule& rRule,
 737                                  bool bCreateNewList,
 738                                  const OUString& rContinuedListId,
 739                                  const bool bResetIndentAttrs )
 740 {
 741     StartAllAction();
 742
 743     GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::INSATTR, nullptr );
 744
 745     SwPaM* pCursor = GetCursor();
 746     if( IsMultiSelection() )
 747     {
 748         OUString sContinuedListId(rContinuedListId);
 749         for (SwPaM& rPaM : pCursor->GetRingContainer())
 750         {
 751             OUString sListId = GetDoc()->SetNumRule(rPaM, rRule,
 752               (bCreateNewList ? SwDoc::SetNumRuleMode::CreateNewList : SwDoc::SetNumRuleMode::Default)
 753               | (bResetIndentAttrs ? SwDoc::SetNumRuleMode::ResetIndentAttrs : SwDoc::SetNumRuleMode::Default),
 754               GetLayout(), sContinuedListId);
 755
 756             //tdf#87548 On creating a new list for a multi-selection only
 757             //create a single new list for the multi-selection, not one per selection
 758             if (bCreateNewList)
 759             {
 760                 sContinuedListId = sListId;
 761                 bCreateNewList = false;
 762             }
 763
 764             GetDoc()->SetCounted(rPaM, true, GetLayout());
 765         }
 766     }
 767     else
 768     {
 769         GetDoc()->SetNumRule( *pCursor, rRule,
 770               (bCreateNewList ? SwDoc::SetNumRuleMode::CreateNewList : SwDoc::SetNumRuleMode::Default)
 771               | (bResetIndentAttrs ? SwDoc::SetNumRuleMode::ResetIndentAttrs : SwDoc::SetNumRuleMode::Default),
 772               GetLayout(), rContinuedListId);
 773         GetDoc()->SetCounted( *pCursor, true, GetLayout() );
 774     }
 775     GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::INSATTR, nullptr );
 776
 777     EndAllAction();
 778 }
 779
 780 OUString SwEditShell::GetUniqueNumRuleName() const
 781 {
 782     return GetDoc()->GetUniqueNumRuleName();
 783 }
 784
 785 void SwEditShell::ChgNumRuleFormats( const SwNumRule& rRule )
 786 {
 787     StartAllAction();
 788     GetDoc()->ChgNumRuleFormats( rRule );
 789     EndAllAction();
 790 }
 791
 792 void SwEditShell::ReplaceNumRule( const OUString& rOldRule, const OUString& rNewRule )
 793 {
 794     StartAllAction();
 795     SwPosition const pos(sw::GetParaPropsPos(*GetLayout(), *GetCursor()->GetPoint()));
 796     GetDoc()->ReplaceNumRule( pos, rOldRule, rNewRule );
 797     EndAllAction();
 798 }
 799
 800 void SwEditShell::SetNumRuleStart( bool bFlag, SwPaM* pPaM )
 801 {
 802     StartAllAction();
 803     SwPaM* pCursor = pPaM ? pPaM : GetCursor();
 804     if( pCursor->IsMultiSelection() )         // multiple selection ?
 805     {
 806         GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 807         SwPamRanges aRangeArr( *pCursor );
 808         SwPaM aPam( *pCursor->GetPoint() );
 809         for( size_t n = 0; n < aRangeArr.Count(); ++n )
 810         {
 811             SwPosition const pos(sw::GetParaPropsPos(*GetLayout(), *aRangeArr.SetPam( n, aPam ).GetPoint()));
 812             GetDoc()->SetNumRuleStart( pos, bFlag );
 813         }
 814         GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 815     }
 816     else
 817     {
 818         SwPosition const pos(sw::GetParaPropsPos(*GetLayout(), *GetCursor()->GetPoint()));
 819         GetDoc()->SetNumRuleStart(pos, bFlag);
 820     }
 821
 822     EndAllAction();
 823 }
 824
 825 bool SwEditShell::IsNumRuleStart( SwPaM* pPaM ) const
 826 {
 827     SwPaM* pCursor = pPaM ? pPaM : GetCursor( );
 828     const SwTextNode *const pTextNd = sw::GetParaPropsNode(*GetLayout(), pCursor->GetPoint()->GetNode());
 829     return pTextNd && pTextNd->IsListRestart();
 830 }
 831
 832 void SwEditShell::SetNodeNumStart( sal_uInt16 nStt )
 833 {
 834     StartAllAction();
 835
 836     SwPaM* pCursor = GetCursor();
 837     if( pCursor->IsMultiSelection() )         // multiple selection ?
 838     {
 839         GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 840         SwPamRanges aRangeArr( *pCursor );
 841         SwPaM aPam( *pCursor->GetPoint() );
 842         for( size_t n = 0; n < aRangeArr.Count(); ++n )
 843         {
 844             SwPosition const pos(sw::GetParaPropsPos(*GetLayout(), *aRangeArr.SetPam( n, aPam ).GetPoint()));
 845             GetDoc()->SetNodeNumStart( pos, nStt );
 846         }
 847         GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 848     }
 849     else
 850     {
 851         SwPosition const pos(sw::GetParaPropsPos(*GetLayout(), *pCursor->GetPoint()));
 852         GetDoc()->SetNodeNumStart( pos, nStt );
 853     }
 854
 855     EndAllAction();
 856 }
 857
 858 sal_uInt16 SwEditShell::GetNodeNumStart( SwPaM* pPaM ) const
 859 {
 860     SwPaM* pCursor = pPaM ? pPaM : GetCursor();
 861     const SwTextNode *const pTextNd = sw::GetParaPropsNode(*GetLayout(), pCursor->GetPoint()->GetNode());
 862     // correction: check, if list restart value is set at text node and
 863     // use new method <SwTextNode::GetAttrListRestartValue()>.
 864     // return USHRT_MAX, if no list restart value is found.
 865     if ( pTextNd && pTextNd->HasAttrListRestartValue() )
 866     {
 867         return o3tl::narrowing<sal_uInt16>(pTextNd->GetAttrListRestartValue());
 868     }
 869     return USHRT_MAX;
 870 }
 871
 872 const SwNumRule * SwEditShell::SearchNumRule( const bool bNum,
 873                                               OUString& sListId )
 874 {
 875     return GetDoc()->SearchNumRule( *(GetCursor()->Start()),
 876                                     false/*bForward*/, bNum, false/*bOutline*/, -1/*nNonEmptyAllowe*/,
 877                                     sListId, GetLayout() );
 878 }
 879
 880 std::set<OUString> SwEditShell::GetUsedBullets()
 881 {
 882     return GetDoc()->GetUsedBullets();
 883 }
 884
 885 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */