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