sw/source/core/edit/ednumber.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: ednumber.cxx,v $
  10  * $Revision: 1.28 $
  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_sw.hxx"
  33
  34
  35 #include <hintids.hxx>
  36 #include <editsh.hxx>
  37 #include <edimp.hxx>
  38 #include <doc.hxx>
  39 #include <ndtxt.hxx>
  40 #include <paratr.hxx>
  41 #include <swundo.hxx>
  42 #include <numrule.hxx>
  43
  44 SV_IMPL_VARARR_SORT( _SwPamRanges, SwPamRange )
  45
  46
  47 SwPamRanges::SwPamRanges( const SwPaM& rRing )
  48 {
  49     const SwPaM* pTmp = &rRing;
  50     do {
  51         Insert( pTmp->GetMark()->nNode, pTmp->GetPoint()->nNode );
  52     } while( &rRing != ( pTmp = (const SwPaM*)pTmp->GetNext() ));
  53 }
  54
  55
  56 void SwPamRanges::Insert( const SwNodeIndex& rIdx1, const SwNodeIndex& rIdx2 )
  57 {
  58     SwPamRange aRg( rIdx1.GetIndex(), rIdx2.GetIndex() );
  59     if( aRg.nEnd < aRg.nStart )
  60     {   aRg.nStart = aRg.nEnd; aRg.nEnd = rIdx1.GetIndex(); }
  61
  62     USHORT nPos = 0;
  63     const SwPamRange* pTmp;
  64     if( Count() && Seek_Entry( aRg, &nPos ))            // suche Insert Position
  65     {
  66         // ist der im Array stehende kleiner ??
  67         if( ( pTmp = GetData()+ nPos )->nEnd < aRg.nEnd )
  68         {
  69             aRg.nEnd = pTmp->nEnd;
  70             Remove( nPos, 1 );          // zusammenfassen
  71         }
  72         else
  73             return;             // ende, weil schon alle zusammengefasst waren
  74     }
  75
  76     BOOL bEnde;
  77     do {
  78         bEnde = TRUE;
  79
  80         // mit dem Vorgaenger zusammenfassen ??
  81         if( nPos > 0 )
  82         {
  83             if( ( pTmp = GetData()+( nPos-1 ))->nEnd == aRg.nStart
  84                 || pTmp->nEnd+1 == aRg.nStart )
  85             {
  86                 aRg.nStart = pTmp->nStart;
  87                 bEnde = FALSE;
  88                 Remove( --nPos, 1 );            // zusammenfassen
  89             }
  90             // SSelection im Bereich ??
  91             else if( pTmp->nStart <= aRg.nStart && aRg.nEnd <= pTmp->nEnd )
  92                 return;
  93         }
  94             // mit dem Nachfolger zusammenfassen ??
  95         if( nPos < Count() )
  96         {
  97             if( ( pTmp = GetData() + nPos )->nStart == aRg.nEnd ||
  98                 pTmp->nStart == aRg.nEnd+1 )
  99             {
 100                 aRg.nEnd = pTmp->nEnd;
 101                 bEnde = FALSE;
 102                 Remove( nPos, 1 );              // zusammenfassen
 103             }
 104
 105             // SSelection im Bereich ??
 106             else if( pTmp->nStart <= aRg.nStart && aRg.nEnd <= pTmp->nEnd )
 107                 return;
 108         }
 109     } while( !bEnde );
 110
 111     _SwPamRanges::Insert( aRg );
 112 }
 113
 114
 115
 116 SwPaM& SwPamRanges::SetPam( USHORT nArrPos, SwPaM& rPam )
 117 {
 118     ASSERT_ID( nArrPos < Count(), ERR_VAR_IDX );
 119     const SwPamRange& rTmp = *(GetData() + nArrPos );
 120     rPam.GetPoint()->nNode = rTmp.nStart;
 121     rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), 0 );
 122     rPam.SetMark();
 123     rPam.GetPoint()->nNode = rTmp.nEnd;
 124     rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), 0 );
 125     return rPam;
 126 }
 127
 128
 129
 130 // Numerierung Outline Regelwerk
 131
 132
 133 void SwEditShell::SetOutlineNumRule(const SwNumRule& rRule)
 134 {
 135     StartAllAction();           // Klammern fuers Updaten !!
 136     GetDoc()->SetOutlineNumRule(rRule);
 137     EndAllAction();
 138 }
 139
 140
 141 const SwNumRule* SwEditShell::GetOutlineNumRule() const
 142 {
 143     return GetDoc()->GetOutlineNumRule();
 144 }
 145
 146 // setzt, wenn noch keine Numerierung, sonst wird geaendert
 147 // arbeitet mit alten und neuen Regeln, nur Differenzen aktualisieren
 148
 149 // Absaetze ohne Numerierung, aber mit Einzuegen
 150
 151 BOOL SwEditShell::NoNum()
 152 {
 153     BOOL bRet = TRUE;
 154     StartAllAction();
 155
 156     SwPaM* pCrsr = GetCrsr();
 157     if( pCrsr->GetNext() != pCrsr )                     // Mehrfachselektion ?
 158     {
 159         GetDoc()->StartUndo( UNDO_START, NULL );
 160         SwPamRanges aRangeArr( *pCrsr );
 161         SwPaM aPam( *pCrsr->GetPoint() );
 162         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 163             bRet = bRet && GetDoc()->NoNum( aRangeArr.SetPam( n, aPam ));
 164         GetDoc()->EndUndo( UNDO_END, NULL );
 165     }
 166     else
 167         bRet = GetDoc()->NoNum( *pCrsr );
 168
 169     EndAllAction();
 170     return bRet;
 171 }
 172 // Loeschen, Splitten der Aufzaehlungsliste
 173
 174 // -> #i29560#
 175 BOOL SwEditShell::HasNumber() const
 176 {
 177     BOOL bResult = FALSE;
 178
 179     const SwTxtNode * pTxtNd =
 180         GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();
 181
 182     if (pTxtNd)
 183     {
 184         bResult = pTxtNd->HasNumber();
 185
 186         // --> OD 2005-10-26 #b6340308#
 187         // special case: outline numbered, not counted paragraph
 188         if ( bResult &&
 189              pTxtNd->GetNumRule() == GetDoc()->GetOutlineNumRule() &&
 190              !pTxtNd->IsCountedInList() )
 191         {
 192             bResult = FALSE;
 193         }
 194         // <--
 195     }
 196
 197     return bResult;
 198 }
 199
 200 BOOL SwEditShell::HasBullet() const
 201 {
 202     BOOL bResult = FALSE;
 203
 204     const SwTxtNode * pTxtNd =
 205         GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();
 206
 207     if (pTxtNd)
 208     {
 209         bResult = pTxtNd->HasBullet();
 210     }
 211
 212     return bResult;
 213 }
 214 // <- #i29560#
 215
 216 void SwEditShell::DelNumRules()
 217 {
 218     StartAllAction();
 219
 220     SwPaM* pCrsr = GetCrsr();
 221     if( pCrsr->GetNext() != pCrsr )                     // Mehrfachselektion ?
 222     {
 223         GetDoc()->StartUndo( UNDO_START, NULL );
 224         SwPamRanges aRangeArr( *pCrsr );
 225         SwPaM aPam( *pCrsr->GetPoint() );
 226         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 227         {
 228             GetDoc()->DelNumRules( aRangeArr.SetPam( n, aPam ) );
 229         }
 230         GetDoc()->EndUndo( UNDO_END, NULL );
 231     }
 232     else
 233         GetDoc()->DelNumRules( *pCrsr );
 234
 235     // rufe das AttrChangeNotify auf der UI-Seite. Sollte eigentlich
 236     // ueberfluessig sein, aber VB hatte darueber eine Bugrep.
 237     CallChgLnk();
 238
 239     // --> OD 2005-10-24 #126346# - cursor can not be anymore in
 240     // front of a label, because numbering/bullet is deleted.
 241     SetInFrontOfLabel( FALSE );
 242     // <--
 243
 244     GetDoc()->SetModified();
 245     EndAllAction();
 246 }
 247
 248 // Hoch-/Runterstufen
 249
 250
 251 BOOL SwEditShell::NumUpDown( BOOL bDown )
 252 {
 253     StartAllAction();
 254
 255     BOOL bRet = TRUE;
 256     SwPaM* pCrsr = GetCrsr();
 257     if( pCrsr->GetNext() == pCrsr )                     // keine Mehrfachselektion ?
 258         bRet = GetDoc()->NumUpDown( *pCrsr, bDown );
 259     else
 260     {
 261         GetDoc()->StartUndo( UNDO_START, NULL );
 262         SwPamRanges aRangeArr( *pCrsr );
 263         SwPaM aPam( *pCrsr->GetPoint() );
 264         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 265             bRet = bRet && GetDoc()->NumUpDown( aRangeArr.SetPam( n, aPam ), bDown );
 266         GetDoc()->EndUndo( UNDO_END, NULL );
 267     }
 268     GetDoc()->SetModified();
 269
 270     // --> FME 2005-09-19 #i54693# Update marked numbering levels
 271     if ( IsInFrontOfLabel() )
 272         UpdateMarkedListLevel();
 273     // <--
 274
 275     CallChgLnk();
 276
 277     EndAllAction();
 278     return bRet;
 279 }
 280 // -> #i23726#
 281 BOOL SwEditShell::IsFirstOfNumRule() const
 282 {
 283     BOOL bResult = FALSE;
 284
 285     SwPaM * pCrsr = GetCrsr();
 286     if (pCrsr->GetNext() == pCrsr)
 287     {
 288         bResult = IsFirstOfNumRule(*pCrsr);
 289     }
 290
 291     return bResult;
 292 }
 293
 294 BOOL SwEditShell::IsFirstOfNumRule(const SwPaM & rPaM) const
 295 {
 296     BOOL bResult = FALSE;
 297
 298     SwPosition aPos(*rPaM.GetPoint());
 299     bResult = GetDoc()->IsFirstOfNumRule(aPos);
 300
 301     return bResult;
 302 }
 303 // <- #i23726#
 304
 305 // -> #i23725#
 306 // --> OD 2008-06-09 #i90078#
 307 // Remove unused default parameter <nLevel> and <bRelative>.
 308 // Adjust method name and parameter name
 309 void SwEditShell::ChangeIndentOfAllListLevels( short nDiff )
 310 {
 311     StartAllAction();
 312
 313     const SwNumRule *pCurNumRule = GetCurNumRule();
 314     //#120911# check if numbering rule really exists
 315     if (pCurNumRule)
 316     {
 317         SwNumRule aRule(*pCurNumRule);
 318         // --> OD 2008-06-09 #i90078#
 319         aRule.ChangeIndent( nDiff );
 320         // <--
 321
 322         // --> OD 2008-03-17 #refactorlists#
 323         // no start of new list
 324         SetCurNumRule( aRule, false );
 325         // <--
 326     }
 327
 328     EndAllAction();
 329 }
 330
 331 // --> OD 2008-06-09 #i90078#
 332 // Adjust method name
 333 void SwEditShell::SetIndent(short nIndent, const SwPosition & rPos)
 334 // <--
 335 {
 336     StartAllAction();
 337
 338     SwNumRule *pCurNumRule = GetDoc()->GetCurrNumRule(rPos);
 339
 340     if (pCurNumRule)
 341     {
 342         SwPaM aPaM(rPos);
 343         SwTxtNode * pTxtNode = aPaM.GetNode()->GetTxtNode();
 344
 345         // --> OD 2008-06-09 #i90078#
 346 //        int nLevel = -1;
 347 //        int nReferenceLevel = pTxtNode->GetActualListLevel();
 348 //        if (! IsFirstOfNumRule(aPaM))
 349 //            nLevel = nReferenceLevel;
 350
 351         SwNumRule aRule(*pCurNumRule);
 352 //        aRule.ChangeIndent(nIndent, nLevel, nReferenceLevel, FALSE);
 353         if ( IsFirstOfNumRule() )
 354         {
 355             aRule.SetIndentOfFirstListLevelAndChangeOthers( nIndent );
 356         }
 357         else if ( pTxtNode->GetActualListLevel() >= 0  )
 358         {
 359             aRule.SetIndent( nIndent,
 360                              static_cast<USHORT>(pTxtNode->GetActualListLevel()) );
 361         }
 362         // <--
 363
 364         // --> OD 2005-02-18 #i42921# - 3rd parameter = false in order to
 365         // suppress setting of num rule at <aPaM>.
 366         // --> OD 2008-03-17 #refactorlists#
 367         // do not apply any list
 368         GetDoc()->SetNumRule( aPaM, aRule, false, String(), sal_False );
 369         // <--
 370     }
 371
 372     EndAllAction();
 373 }
 374 // <- #i23725#
 375
 376 BOOL SwEditShell::MoveParagraph( long nOffset )
 377 {
 378     StartAllAction();
 379
 380     SwPaM *pCrsr = GetCrsr();
 381     if( !pCrsr->HasMark() )
 382     {
 383         // sorge dafuer, das Bound1 und Bound2 im gleichen Node stehen
 384         pCrsr->SetMark();
 385         pCrsr->DeleteMark();
 386     }
 387
 388     BOOL bRet = GetDoc()->MoveParagraph( *pCrsr, nOffset );
 389
 390     GetDoc()->SetModified();
 391     EndAllAction();
 392     return bRet;
 393 }
 394
 395 //#outline level add by zhaojianwei
 396 int SwEditShell::GetCurrentParaOutlineLevel( ) const
 397 {
 398     int nLevel = 0;
 399
 400     SwPaM* pCrsr = GetCrsr();
 401     const SwTxtNode* pTxtNd = pCrsr->GetNode()->GetTxtNode();
 402     if( pTxtNd )
 403         nLevel = pTxtNd->GetAttrOutlineLevel();
 404     return nLevel;
 405 }
 406 //<-end,zhaojianwei
 407
 408 void SwEditShell::GetCurrentOutlineLevels( sal_uInt8& rUpper, sal_uInt8& rLower )
 409 {
 410     SwPaM* pCrsr = GetCrsr();
 411     SwPaM aCrsr( *pCrsr->Start() );
 412     aCrsr.SetMark();
 413     if( pCrsr->HasMark() )
 414         *aCrsr.GetPoint() = *pCrsr->End();
 415     GetDoc()->GotoNextNum( *aCrsr.GetPoint(), FALSE,
 416                             &rUpper, &rLower );
 417 }
 418
 419 BOOL SwEditShell::MoveNumParas( BOOL bUpperLower, BOOL bUpperLeft )
 420 {
 421     StartAllAction();
 422
 423     // auf alle Selektionen ??
 424     SwPaM* pCrsr = GetCrsr();
 425     SwPaM aCrsr( *pCrsr->Start() );
 426     aCrsr.SetMark();
 427
 428     if( pCrsr->HasMark() )
 429         *aCrsr.GetPoint() = *pCrsr->End();
 430
 431     BOOL bRet = FALSE;
 432     BYTE nUpperLevel, nLowerLevel;
 433     if( GetDoc()->GotoNextNum( *aCrsr.GetPoint(), FALSE,
 434                                 &nUpperLevel, &nLowerLevel ))
 435     {
 436         if( bUpperLower )
 437         {
 438             // ueber die naechste Nummerierung
 439             long nOffset = 0;
 440             const SwNode* pNd;
 441
 442             if( bUpperLeft )            // verschiebe nach oben
 443             {
 444                 SwPosition aPos( *aCrsr.GetMark() );
 445                 if( GetDoc()->GotoPrevNum( aPos, FALSE ) )
 446                     nOffset = aPos.nNode.GetIndex() -
 447                             aCrsr.GetMark()->nNode.GetIndex();
 448                 else
 449                 {
 450                     ULONG nStt = aPos.nNode.GetIndex(), nIdx = nStt - 1;
 451                     while( nIdx && (
 452                         ( pNd = GetDoc()->GetNodes()[ nIdx ])->IsSectionNode() ||
 453                         ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode())))
 454                         --nIdx;
 455                     if( GetDoc()->GetNodes()[ nIdx ]->IsTxtNode() )
 456                         nOffset = nIdx - nStt;
 457                 }
 458             }
 459             else                                        // verschiebe nach unten
 460             {
 461                 const SwNumRule* pOrig = aCrsr.GetNode(FALSE)->GetTxtNode()->GetNumRule();
 462                 if( aCrsr.GetNode()->IsTxtNode() &&
 463                     pOrig == aCrsr.GetNode()->GetTxtNode()->GetNumRule() )
 464                 {
 465                     ULONG nStt = aCrsr.GetPoint()->nNode.GetIndex(), nIdx = nStt+1;
 466
 467                     while (nIdx < GetDoc()->GetNodes().Count()-1)
 468                     {
 469                         pNd = GetDoc()->GetNodes()[ nIdx ];
 470
 471                         if (pNd->IsSectionNode() ||
 472                             ( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsSectionNode()) ||
 473                             ( pNd->IsTxtNode() && pOrig == ((SwTxtNode*)pNd)->GetNumRule() &&
 474                               ((SwTxtNode*)pNd)->GetActualListLevel() > nUpperLevel ))
 475                         {
 476                             ++nIdx;
 477                         }
 478                         // --> OD 2005-11-14 #i57856#
 479                         else
 480                         {
 481                             break;
 482                         }
 483                         // <--
 484                     }
 485
 486                     if( nStt == nIdx || !GetDoc()->GetNodes()[ nIdx ]->IsTxtNode() )
 487                         nOffset = 1;
 488                     else
 489                         nOffset = nIdx - nStt;
 490                 }
 491                 else
 492                     nOffset = 1;
 493             }
 494
 495             if( nOffset )
 496             {
 497                 aCrsr.Move( fnMoveBackward, fnGoNode );
 498                 bRet = GetDoc()->MoveParagraph( aCrsr, nOffset );
 499             }
 500         }
 501         else if( bUpperLeft ? nUpperLevel : nLowerLevel+1 < MAXLEVEL )
 502         {
 503             aCrsr.Move( fnMoveBackward, fnGoNode );
 504             bRet = GetDoc()->NumUpDown( aCrsr, !bUpperLeft );
 505         }
 506     }
 507
 508     GetDoc()->SetModified();
 509     EndAllAction();
 510     return bRet;
 511 }
 512
 513 BOOL SwEditShell::OutlineUpDown( short nOffset )
 514 {
 515     StartAllAction();
 516
 517     BOOL bRet = TRUE;
 518     SwPaM* pCrsr = GetCrsr();
 519     if( pCrsr->GetNext() == pCrsr )                     // keine Mehrfachselektion ?
 520         bRet = GetDoc()->OutlineUpDown( *pCrsr, nOffset );
 521     else
 522     {
 523         GetDoc()->StartUndo( UNDO_START, NULL );
 524         SwPamRanges aRangeArr( *pCrsr );
 525         SwPaM aPam( *pCrsr->GetPoint() );
 526         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 527             bRet = bRet && GetDoc()->OutlineUpDown(
 528                                     aRangeArr.SetPam( n, aPam ), nOffset );
 529         GetDoc()->EndUndo( UNDO_END, NULL );
 530     }
 531     GetDoc()->SetModified();
 532     EndAllAction();
 533     return bRet;
 534 }
 535
 536
 537 BOOL SwEditShell::MoveOutlinePara( short nOffset )
 538 {
 539     StartAllAction();
 540     BOOL bRet = GetDoc()->MoveOutlinePara( *GetCrsr(), nOffset );
 541     EndAllAction();
 542     return bRet;
 543 }
 544
 545 // Outlines and SubOutline are ReadOnly?
 546 BOOL SwEditShell::IsProtectedOutlinePara() const
 547 {
 548     BOOL bRet = FALSE;
 549     const SwNode& rNd = GetCrsr()->Start()->nNode.GetNode();
 550     if( rNd.IsTxtNode() )
 551     {
 552         const SwOutlineNodes& rOutlNd = GetDoc()->GetNodes().GetOutLineNds();
 553         SwNodePtr pNd = (SwNodePtr)&rNd;
 554         BOOL bFirst = TRUE;
 555         USHORT nPos;
 556         int nLvl(0);
 557         if( !rOutlNd.Seek_Entry( pNd, &nPos ) && nPos )
 558             --nPos;
 559
 560         for( ; nPos < rOutlNd.Count(); ++nPos )
 561         {
 562             SwNodePtr pTmpNd = rOutlNd[ nPos ];
 563
 564             // --> OD 2008-04-02 #refactorlists#
 565 //            BYTE nTmpLvl = GetRealLevel( pTmpNd->GetTxtNode()->
 566 //                                    GetTxtColl()->GetOutlineLevel() );
 567  //           int nTmpLvl = pTmpNd->GetTxtNode()->GetOutlineLevel();//#outline level,zhaojianwei
 568             int nTmpLvl = pTmpNd->GetTxtNode()->GetAttrOutlineLevel();
 569  //           ASSERT( nTmpLvl >= 0 && nTmpLvl < MAXLEVEL,
 570             ASSERT( nTmpLvl >= 0 && nTmpLvl <= MAXLEVEL,                        //<-end,zhaojianwei
 571                     "<SwEditShell::IsProtectedOutlinePara()>" );
 572             // <--
 573             if( bFirst )
 574             {
 575                 nLvl = nTmpLvl;
 576                 bFirst = FALSE;
 577             }
 578             else if( nLvl >= nTmpLvl )
 579                 break;
 580
 581             if( pTmpNd->IsProtect() )
 582             {
 583                 bRet = TRUE;
 584                 break;
 585             }
 586         }
 587     }
 588 #ifndef PRODUCT
 589     else
 590     {
 591         ASSERT(!this, "Cursor not on an outline node" );
 592     }
 593 #endif
 594     return bRet;
 595 }
 596
 597 /** Test whether outline may be moved (bCopy == false)
 598  *                           or copied (bCopy == true)
 599  * Verify these conditions:
 600  * 1) outline must be within main body (and not in redline)
 601  * 2) outline must not be within table
 602  * 3) if bCopy is set, outline must not be write protected
 603  */
 604 BOOL lcl_IsOutlineMoveAndCopyable( const SwDoc* pDoc, USHORT nIdx, bool bCopy )
 605 {
 606     const SwNodes& rNds = pDoc->GetNodes();
 607     const SwNode* pNd = rNds.GetOutLineNds()[ nIdx ];
 608     return pNd->GetIndex() >= rNds.GetEndOfExtras().GetIndex() &&   // 1) body
 609             !pNd->FindTableNode() &&                                // 2) table
 610             ( bCopy || !pNd->IsProtect() );                         // 3) write
 611 }
 612
 613 BOOL SwEditShell::IsOutlineMovable( USHORT nIdx ) const
 614 {
 615     return lcl_IsOutlineMoveAndCopyable( GetDoc(), nIdx, false );
 616 }
 617
 618 BOOL SwEditShell::IsOutlineCopyable( USHORT nIdx ) const
 619 {
 620     return lcl_IsOutlineMoveAndCopyable( GetDoc(), nIdx, true );
 621 }
 622
 623
 624 BOOL SwEditShell::NumOrNoNum( BOOL bNumOn, BOOL bChkStart ) // #115901#
 625 {
 626     BOOL bRet = FALSE;
 627     SwPaM* pCrsr = GetCrsr();
 628     if( pCrsr->GetNext() == pCrsr && !pCrsr->HasMark() &&
 629         ( !bChkStart || !pCrsr->GetPoint()->nContent.GetIndex()) )
 630     {
 631         StartAllAction();               // Klammern fuers Updaten !!
 632         // #115901#
 633         bRet = GetDoc()->NumOrNoNum( pCrsr->GetPoint()->nNode, !bNumOn ); // #i29560#
 634         EndAllAction();
 635     }
 636     return bRet;
 637 }
 638
 639 BOOL SwEditShell::IsNoNum( BOOL bChkStart ) const
 640 {
 641     // ein Backspace im Absatz ohne Nummer wird zum Delete
 642     BOOL bResult = FALSE;
 643     SwPaM* pCrsr = GetCrsr();
 644
 645     if (pCrsr->GetNext() == pCrsr && !pCrsr->HasMark() &&
 646         (!bChkStart || !pCrsr->GetPoint()->nContent.GetIndex()))
 647     {
 648         const SwTxtNode* pTxtNd = pCrsr->GetNode()->GetTxtNode();
 649
 650         if (pTxtNd)
 651         {
 652             bResult =  ! pTxtNd->IsCountedInList();
 653         }
 654     }
 655
 656     return bResult;
 657 }
 658
 659 // --> OD 2008-02-29 #refactorlists# - removed <pHasChilds>
 660 BYTE SwEditShell::GetNumLevel() const
 661 {
 662     // gebe die akt. Ebene zurueck, auf der sich der Point vom Cursor befindet
 663     //BYTE nLevel = NO_NUMBERING;       //#outline level,zhaojianwei
 664     BYTE nLevel = MAXLEVEL;             //end,zhaojianwei
 665
 666     SwPaM* pCrsr = GetCrsr();
 667     const SwTxtNode* pTxtNd = pCrsr->GetNode()->GetTxtNode();
 668
 669     // --> FME 2005-09-12 #124972# Made code robust:
 670     ASSERT( pTxtNd, "GetNumLevel() without text node" )
 671     if ( !pTxtNd )
 672         return nLevel;
 673     // <--
 674
 675     const SwNumRule* pRule = pTxtNd->GetNumRule();
 676     if(pRule)
 677     {
 678         // --> OD 2008-05-09 #refactorlists#
 679         const int nListLevelOfTxtNode( pTxtNd->GetActualListLevel() );
 680         if ( nListLevelOfTxtNode >= 0 )
 681         {
 682             nLevel = static_cast<BYTE>( nListLevelOfTxtNode );
 683         }
 684         // <--
 685     }
 686
 687     return nLevel;
 688 }
 689
 690 const SwNumRule* SwEditShell::GetCurNumRule() const
 691 {
 692     return GetDoc()->GetCurrNumRule( *GetCrsr()->GetPoint() );
 693 }
 694
 695 // OD 2008-02-08 #newlistlevelattrs# - add handling of parameter <bResetIndentAttrs>
 696 // --> OD 2008-03-17 #refactorlists#
 697 void SwEditShell::SetCurNumRule( const SwNumRule& rRule,
 698                                  const bool bCreateNewList,
 699                                  const String sContinuedListId,
 700                                  const bool bResetIndentAttrs )
 701 {
 702     StartAllAction();
 703
 704     SwPaM* pCrsr = GetCrsr();
 705     if( pCrsr->GetNext() != pCrsr )                     // Mehrfachselektion ?
 706     {
 707         GetDoc()->StartUndo( UNDO_START, NULL );
 708         SwPamRanges aRangeArr( *pCrsr );
 709         SwPaM aPam( *pCrsr->GetPoint() );
 710         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 711           {
 712             aRangeArr.SetPam( n, aPam );
 713             // --> OD 2008-02-08 #newlistlevelattrs#
 714             // --> OD 2008-03-17 #refactorlists#
 715             GetDoc()->SetNumRule( aPam, rRule,
 716                                   bCreateNewList, sContinuedListId,
 717                                   sal_True, bResetIndentAttrs );
 718             // <--
 719             GetDoc()->SetCounted( aPam, true );
 720           }
 721         GetDoc()->EndUndo( UNDO_END, NULL );
 722     }
 723     else
 724     {
 725         GetDoc()->StartUndo( UNDO_START, NULL );
 726
 727         // --> OD 2008-02-08 #newlistlevelattrs#
 728         // --> OD 2008-03-17 #refactorlists#
 729         GetDoc()->SetNumRule( *pCrsr, rRule,
 730                               bCreateNewList, sContinuedListId,
 731                               sal_True, bResetIndentAttrs );
 732         GetDoc()->SetCounted( *pCrsr, true );
 733
 734         GetDoc()->EndUndo( UNDO_END, NULL );
 735     }
 736
 737     EndAllAction();
 738 }
 739
 740 String SwEditShell::GetUniqueNumRuleName( const String* pChkStr, BOOL bAutoNum ) const
 741 {
 742     return GetDoc()->GetUniqueNumRuleName( pChkStr, bAutoNum );
 743 }
 744
 745 void SwEditShell::ChgNumRuleFmts( const SwNumRule& rRule )
 746 {
 747     StartAllAction();
 748     GetDoc()->ChgNumRuleFmts( rRule );
 749     EndAllAction();
 750 }
 751
 752 BOOL SwEditShell::ReplaceNumRule( const String& rOldRule, const String& rNewRule )
 753 {
 754     StartAllAction();
 755     BOOL bRet = GetDoc()->ReplaceNumRule( *GetCrsr()->GetPoint(), rOldRule, rNewRule );
 756     EndAllAction();
 757     return bRet;
 758 }
 759
 760 void SwEditShell::SetNumRuleStart( BOOL bFlag )
 761 {
 762     StartAllAction();
 763
 764     SwPaM* pCrsr = GetCrsr();
 765     if( pCrsr->GetNext() != pCrsr )                     // Mehrfachselektion ?
 766     {
 767         GetDoc()->StartUndo( UNDO_START, NULL );
 768         SwPamRanges aRangeArr( *pCrsr );
 769         SwPaM aPam( *pCrsr->GetPoint() );
 770         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 771             GetDoc()->SetNumRuleStart( *aRangeArr.SetPam( n, aPam ).GetPoint(), bFlag );
 772         GetDoc()->EndUndo( UNDO_END, NULL );
 773     }
 774     else
 775         GetDoc()->SetNumRuleStart( *pCrsr->GetPoint(), bFlag );
 776
 777     EndAllAction();
 778 }
 779
 780 BOOL SwEditShell::IsNumRuleStart() const
 781 {
 782     BOOL bResult = FALSE;
 783     const SwTxtNode* pTxtNd = GetCrsr()->GetNode()->GetTxtNode();
 784     if( pTxtNd )
 785         bResult = pTxtNd->IsListRestart() ? TRUE : FALSE;
 786     return bResult;
 787 }
 788
 789 void SwEditShell::SetNodeNumStart( USHORT nStt )
 790 {
 791     StartAllAction();
 792
 793     SwPaM* pCrsr = GetCrsr();
 794     if( pCrsr->GetNext() != pCrsr )                     // Mehrfachselektion ?
 795     {
 796         GetDoc()->StartUndo( UNDO_START, NULL );
 797         SwPamRanges aRangeArr( *pCrsr );
 798         SwPaM aPam( *pCrsr->GetPoint() );
 799         for( USHORT n = 0; n < aRangeArr.Count(); ++n )
 800             GetDoc()->SetNodeNumStart( *aRangeArr.SetPam( n, aPam ).GetPoint(), nStt );
 801         GetDoc()->EndUndo( UNDO_END, NULL );
 802     }
 803     else
 804         GetDoc()->SetNodeNumStart( *pCrsr->GetPoint(), nStt );
 805
 806     EndAllAction();
 807 }
 808
 809 USHORT SwEditShell::GetNodeNumStart() const
 810 {
 811     const SwTxtNode* pTxtNd = GetCrsr()->GetNode()->GetTxtNode();
 812     // --> OD 2008-02-28 #refactorlists#
 813     // correction: check, if list restart value is set at text node and
 814     // use new method <SwTxtNode::GetAttrListRestartValue()>.
 815     // return USHRT_MAX, if no list restart value is found.
 816     if ( pTxtNd && pTxtNd->HasAttrListRestartValue() )
 817     {
 818         return static_cast<USHORT>(pTxtNd->GetAttrListRestartValue());
 819     }
 820     return USHRT_MAX;
 821     // <--
 822 }
 823
 824 /*-- 26.08.2005 14:47:17---------------------------------------------------
 825
 826   -----------------------------------------------------------------------*/
 827 // --> OD 2008-03-18 #refactorlists#
 828 const SwNumRule * SwEditShell::SearchNumRule( const bool bForward,
 829                                               const bool bNum,
 830                                               const bool bOutline,
 831                                               int nNonEmptyAllowed,
 832                                               String& sListId )
 833 {
 834     return GetDoc()->SearchNumRule( *(bForward ? GetCrsr()->End() : GetCrsr()->Start()),
 835                                     bForward, bNum, bOutline, nNonEmptyAllowed,
 836                                     sListId );
 837 }
 838 // <--