xref: /aoo42x/main/sw/source/core/doc/docfmt.cxx (revision 870262e3)
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 #define _ZFORLIST_DECLARE_TABLE
29 #define _SVSTDARR_USHORTSSORT
30 #define _SVSTDARR_USHORTS
31 #include <hintids.hxx>
32 #include <rtl/logfile.hxx>
33 #include <svl/itemiter.hxx>
34 #include <sfx2/app.hxx>
35 #include <editeng/tstpitem.hxx>
36 #include <editeng/eeitem.hxx>
37 #include <editeng/langitem.hxx>
38 #include <editeng/lrspitem.hxx>
39 #include <editeng/brkitem.hxx>
40 #include <svl/whiter.hxx>
41 #ifndef _ZFORLIST_HXX //autogen
42 #define _ZFORLIST_DECLARE_TABLE
43 #include <svl/zforlist.hxx>
44 #endif
45 #include <comphelper/processfactory.hxx>
46 #include <unotools/misccfg.hxx>
47 #include <com/sun/star/i18n/WordType.hdl>
48 #include <fmtpdsc.hxx>
49 #include <fmthdft.hxx>
50 #include <fmtcntnt.hxx>
51 #include <frmatr.hxx>
52 #include <doc.hxx>
53 #include <IDocumentUndoRedo.hxx>
54 #include <rootfrm.hxx>
55 #include <pagefrm.hxx>
56 #include <hints.hxx>			// fuer SwHyphenBug (in SetDefault)
57 #include <ndtxt.hxx>
58 #include <pam.hxx>
59 #include <UndoCore.hxx>
60 #include <UndoAttribute.hxx>
61 #include <ndgrf.hxx>
62 #include <pagedesc.hxx>			// Fuer Sonderbehandlung in InsFrmFmt
63 #include <rolbck.hxx>			// Undo-Attr
64 #include <mvsave.hxx>			// servieren: Veraenderungen erkennen
65 #include <txatbase.hxx>
66 #include <swtable.hxx>
67 #include <swtblfmt.hxx>
68 #include <charfmt.hxx>
69 #include <docary.hxx>
70 #include <paratr.hxx>
71 #include <redline.hxx>
72 #include <reffld.hxx>
73 #include <txtinet.hxx>
74 #include <fmtinfmt.hxx>
75 #include <breakit.hxx>
76 #include <SwStyleNameMapper.hxx>
77 #include <fmtautofmt.hxx>
78 #include <istyleaccess.hxx>
79 #include <SwUndoFmt.hxx>
80 #include <docsh.hxx>
81 
82 using namespace ::com::sun::star::i18n;
83 using namespace ::com::sun::star::lang;
84 using namespace ::com::sun::star::uno;
85 
SV_IMPL_PTRARR(SwFrmFmts,SwFrmFmtPtr)86 SV_IMPL_PTRARR(SwFrmFmts,SwFrmFmtPtr)
87 SV_IMPL_PTRARR(SwCharFmts,SwCharFmtPtr)
88 
89 //Spezifische Frameformate (Rahmen)
90 SV_IMPL_PTRARR(SwSpzFrmFmts,SwFrmFmtPtr)
91 
92 /*
93  * interne Funktionen
94  */
95 
96 sal_Bool SetTxtFmtCollNext( const SwTxtFmtCollPtr& rpTxtColl, void* pArgs )
97 {
98 	SwTxtFmtColl *pDel = (SwTxtFmtColl*) pArgs;
99 	if ( &rpTxtColl->GetNextTxtFmtColl() == pDel )
100 	{
101 		rpTxtColl->SetNextTxtFmtColl( *rpTxtColl );
102 	}
103 	return sal_True;
104 }
105 
106 /*
107  * Zuruecksetzen der harten Formatierung fuer Text
108  */
109 
110 // Uebergabeparameter fuer _Rst und lcl_SetTxtFmtColl
111 struct ParaRstFmt
112 {
113 	SwFmtColl* pFmtColl;
114 	SwHistory* pHistory;
115 	const SwPosition *pSttNd, *pEndNd;
116 	const SfxItemSet* pDelSet;
117 	sal_uInt16 nWhich;
118     bool bReset;
119     bool bResetListAttrs;
120     bool bResetAll;
121     bool bInclRefToxMark;
122 
ParaRstFmtParaRstFmt123 	ParaRstFmt( const SwPosition* pStt, const SwPosition* pEnd,
124                 SwHistory* pHst, sal_uInt16 nWhch = 0, const SfxItemSet* pSet = 0 )
125         : pFmtColl(0),
126           pHistory(pHst),
127           pSttNd(pStt),
128           pEndNd(pEnd),
129           pDelSet(pSet),
130           nWhich(nWhch),
131           bReset( false ),
132           bResetListAttrs( false ),
133           bResetAll( true ),
134           bInclRefToxMark( false )
135     {
136     }
137 
ParaRstFmtParaRstFmt138 	ParaRstFmt( SwHistory* pHst )
139         : pFmtColl(0),
140           pHistory(pHst),
141           pSttNd(0),
142           pEndNd(0),
143           pDelSet(0),
144           nWhich(0),
145           bReset( false ),
146           bResetListAttrs( false ),
147           bResetAll( true ),
148           bInclRefToxMark( false )
149     {
150     }
151 };
152 
153 /* in pArgs steht die ChrFmtTablle vom Dokument
154  * (wird bei Selectionen am Start/Ende und bei keiner SSelection benoetigt)
155  */
156 
lcl_RstTxtAttr(const SwNodePtr & rpNd,void * pArgs)157 sal_Bool lcl_RstTxtAttr( const SwNodePtr& rpNd, void* pArgs )
158 {
159     ParaRstFmt* pPara = (ParaRstFmt*)pArgs;
160     SwTxtNode * pTxtNode = (SwTxtNode*)rpNd->GetTxtNode();
161     if( pTxtNode && pTxtNode->GetpSwpHints() )
162     {
163         SwIndex aSt( pTxtNode, 0 );
164         sal_uInt16 nEnd = pTxtNode->Len();
165 
166         if( &pPara->pSttNd->nNode.GetNode() == pTxtNode &&
167             pPara->pSttNd->nContent.GetIndex() )
168             aSt = pPara->pSttNd->nContent.GetIndex();
169 
170         if( &pPara->pEndNd->nNode.GetNode() == rpNd )
171             nEnd = pPara->pEndNd->nContent.GetIndex();
172 
173         if( pPara->pHistory )
174         {
175             // fuers Undo alle Attribute sichern
176             SwRegHistory aRHst( *pTxtNode, pPara->pHistory );
177             pTxtNode->GetpSwpHints()->Register( &aRHst );
178             pTxtNode->RstTxtAttr( aSt, nEnd - aSt.GetIndex(), pPara->nWhich,
179                                   pPara->pDelSet, pPara->bInclRefToxMark );
180             if( pTxtNode->GetpSwpHints() )
181                 pTxtNode->GetpSwpHints()->DeRegister();
182         }
183         else
184             pTxtNode->RstTxtAttr( aSt, nEnd - aSt.GetIndex(), pPara->nWhich,
185                                   pPara->pDelSet, pPara->bInclRefToxMark );
186     }
187     return sal_True;
188 }
189 
lcl_RstAttr(const SwNodePtr & rpNd,void * pArgs)190 sal_Bool lcl_RstAttr( const SwNodePtr& rpNd, void* pArgs )
191 {
192     const ParaRstFmt* pPara = (ParaRstFmt*) pArgs;
193     SwCntntNode* pNode = (SwCntntNode*) rpNd->GetCntntNode();
194     if( pNode && pNode->HasSwAttrSet() )
195 	{
196         const sal_Bool bLocked = pNode->IsModifyLocked();
197         pNode->LockModify();
198 
199         SwDoc* pDoc = pNode->GetDoc();
200 
201         SfxItemSet aSavedAttrsSet(
202             pDoc->GetAttrPool(),
203             RES_PAGEDESC, RES_BREAK,
204             RES_PARATR_NUMRULE, RES_PARATR_NUMRULE,
205             RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END - 1,
206             0 );
207         const SfxItemSet* pAttrSetOfNode = pNode->GetpSwAttrSet();
208 
209         SvUShorts aClearWhichIds;
210         // restoring all paragraph list attributes
211         {
212             SfxItemSet aListAttrSet( pDoc->GetAttrPool(),
213                                      RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END - 1,
214                                      0 );
215             aListAttrSet.Set( *pAttrSetOfNode );
216             if ( aListAttrSet.Count() )
217             {
218                 aSavedAttrsSet.Put( aListAttrSet );
219                 SfxItemIter aIter( aListAttrSet );
220                 const SfxPoolItem* pItem = aIter.GetCurItem();
221                 while( pItem )
222                 {
223                     aClearWhichIds.Insert( pItem->Which(), aClearWhichIds.Count() );
224                     pItem = aIter.NextItem();
225                 }
226             }
227         }
228 
229         const SfxPoolItem* pItem;
230         sal_uInt16 __READONLY_DATA aSavIds[3] =
231                 { RES_PAGEDESC, RES_BREAK, RES_PARATR_NUMRULE };
232         for ( sal_uInt16 n = 0; n < 3; ++n )
233         {
234             if ( SFX_ITEM_SET == pAttrSetOfNode->GetItemState( aSavIds[n], sal_False, &pItem ) )
235             {
236                 bool bSave = false;
237                 switch (aSavIds[n])
238                 {
239                 case RES_PAGEDESC:
240                     bSave = 0 != ( (SwFmtPageDesc*) pItem )->GetPageDesc();
241                     break;
242                 case RES_BREAK:
243                     bSave = SVX_BREAK_NONE != ( (SvxFmtBreakItem*) pItem )->GetBreak();
244                     break;
245                 case RES_PARATR_NUMRULE:
246                     bSave = 0 != ( (SwNumRuleItem*) pItem )->GetValue().Len();
247                     break;
248                 }
249                 if ( bSave )
250                 {
251                     aSavedAttrsSet.Put( *pItem );
252                     aClearWhichIds.Insert( aSavIds[n], aClearWhichIds.Count() );
253                 }
254             }
255         }
256 
257         // do not clear items directly from item set and only clear to be kept
258         // attributes, if no deletion item set is found.
259         const bool bKeepAttributes =
260                     !pPara || !pPara->pDelSet || pPara->pDelSet->Count() == 0;
261         if ( bKeepAttributes )
262         {
263             pNode->ResetAttr( aClearWhichIds );
264         }
265 
266         if( !bLocked )
267             pNode->UnlockModify();
268 
269         if ( pPara )
270         {
271             SwRegHistory aRegH( pNode, *pNode, pPara->pHistory );
272 
273             if ( pPara->pDelSet && pPara->pDelSet->Count() )
274             {
275                 ASSERT( !bKeepAttributes,
276                         "<lcl_RstAttr(..)> - certain attributes are kept, but not needed. -> please inform OD" );
277                 SfxItemIter aIter( *pPara->pDelSet );
278                 pItem = aIter.FirstItem();
279                 while ( sal_True )
280                 {
281                     if ( ( pItem->Which() != RES_PAGEDESC &&
282                            pItem->Which() != RES_BREAK &&
283                            pItem->Which() != RES_PARATR_NUMRULE ) ||
284                          ( aSavedAttrsSet.GetItemState( pItem->Which(), sal_False ) != SFX_ITEM_SET ) )
285                     {
286                         pNode->ResetAttr( pItem->Which() );
287                     }
288                     if ( aIter.IsAtEnd() )
289                         break;
290                     pItem = aIter.NextItem();
291                 }
292             }
293             else if ( pPara->bResetAll )
294                 pNode->ResetAllAttr();
295             else
296                 pNode->ResetAttr( RES_PARATR_BEGIN, POOLATTR_END - 1 );
297         }
298         else
299             pNode->ResetAllAttr();
300 
301         // only restore saved attributes, if needed
302         if ( bKeepAttributes && aSavedAttrsSet.Count() )
303         {
304             pNode->LockModify();
305 
306             pNode->SetAttr( aSavedAttrsSet );
307 
308             if ( !bLocked )
309                 pNode->UnlockModify();
310         }
311     }
312     return sal_True;
313 }
314 
315 
RstTxtAttrs(const SwPaM & rRg,sal_Bool bInclRefToxMark)316 void SwDoc::RstTxtAttrs(const SwPaM &rRg, sal_Bool bInclRefToxMark )
317 {
318 	SwHistory* pHst = 0;
319 	SwDataChanged aTmp( rRg, 0 );
320     if (GetIDocumentUndoRedo().DoesUndo())
321     {
322         SwUndoResetAttr* pUndo = new SwUndoResetAttr( rRg, RES_CHRFMT );
323         pHst = &pUndo->GetHistory();
324         GetIDocumentUndoRedo().AppendUndo(pUndo);
325     }
326 	const SwPosition *pStt = rRg.Start(), *pEnd = rRg.End();
327 	ParaRstFmt aPara( pStt, pEnd, pHst );
328     aPara.bInclRefToxMark = ( bInclRefToxMark == sal_True );
329 	GetNodes().ForEach( pStt->nNode.GetIndex(), pEnd->nNode.GetIndex()+1,
330 						lcl_RstTxtAttr, &aPara );
331 	SetModified();
332 }
333 
ResetAttrs(const SwPaM & rRg,sal_Bool bTxtAttr,const SvUShortsSort * pAttrs,const bool bSendDataChangedEvents)334 void SwDoc::ResetAttrs( const SwPaM &rRg,
335                         sal_Bool bTxtAttr,
336                         const SvUShortsSort* pAttrs,
337                         // --> OD 2008-11-28 #b96644#
338                         const bool bSendDataChangedEvents )
339                         // <--
340 {
341 	SwPaM* pPam = (SwPaM*)&rRg;
342 	if( !bTxtAttr && pAttrs && pAttrs->Count() &&
343 		RES_TXTATR_END > (*pAttrs)[ 0 ] )
344 		bTxtAttr = sal_True;
345 
346 	if( !rRg.HasMark() )
347 	{
348 		SwTxtNode* pTxtNd = rRg.GetPoint()->nNode.GetNode().GetTxtNode();
349 		if( !pTxtNd )
350 			return ;
351 
352 		pPam = new SwPaM( *rRg.GetPoint() );
353 
354 		SwIndex& rSt = pPam->GetPoint()->nContent;
355 		sal_uInt16 nMkPos, nPtPos = rSt.GetIndex();
356 
357 		// JP 22.08.96: Sonderfall: steht der Crsr in einem URL-Attribut
358 		//				dann wird dessen Bereich genommen
359         SwTxtAttr const*const pURLAttr(
360             pTxtNd->GetTxtAttrAt(rSt.GetIndex(), RES_TXTATR_INETFMT));
361         if (pURLAttr && pURLAttr->GetINetFmt().GetValue().Len())
362 		{
363 			nMkPos = *pURLAttr->GetStart();
364 			nPtPos = *pURLAttr->End();
365 		}
366 		else
367 		{
368 			Boundary aBndry;
369 			if( pBreakIt->GetBreakIter().is() )
370 				aBndry = pBreakIt->GetBreakIter()->getWordBoundary(
371 							pTxtNd->GetTxt(), nPtPos,
372 							pBreakIt->GetLocale( pTxtNd->GetLang( nPtPos ) ),
373 							WordType::ANY_WORD /*ANYWORD_IGNOREWHITESPACES*/,
374 							sal_True );
375 
376 			if( aBndry.startPos < nPtPos && nPtPos < aBndry.endPos )
377 			{
378 				nMkPos = (xub_StrLen)aBndry.startPos;
379 				nPtPos = (xub_StrLen)aBndry.endPos;
380 			}
381 			else
382 			{
383 				nPtPos = nMkPos = rSt.GetIndex();
384 				if( bTxtAttr )
385 					pTxtNd->DontExpandFmt( rSt, sal_True );
386 			}
387 		}
388 
389 		rSt = nMkPos;
390 		pPam->SetMark();
391 		pPam->GetPoint()->nContent = nPtPos;
392 	}
393 
394     // --> OD 2008-11-28 #i96644#
395 //    SwDataChanged aTmp( *pPam, 0 );
396     std::auto_ptr< SwDataChanged > pDataChanged;
397     if ( bSendDataChangedEvents )
398     {
399         pDataChanged.reset( new SwDataChanged( *pPam, 0 ) );
400     }
401     // <--
402 	SwHistory* pHst = 0;
403     if (GetIDocumentUndoRedo().DoesUndo())
404     {
405         SwUndoResetAttr* pUndo = new SwUndoResetAttr( rRg,
406             static_cast<sal_uInt16>(bTxtAttr ? RES_CONDTXTFMTCOLL : RES_TXTFMTCOLL ));
407 		if( pAttrs && pAttrs->Count() )
408         {
409             pUndo->SetAttrs( *pAttrs );
410         }
411         pHst = &pUndo->GetHistory();
412         GetIDocumentUndoRedo().AppendUndo(pUndo);
413     }
414 
415 	const SwPosition *pStt = pPam->Start(), *pEnd = pPam->End();
416 	ParaRstFmt aPara( pStt, pEnd, pHst );
417 
418     // mst: not including META here; it seems attrs with CH_TXTATR are omitted
419     sal_uInt16 __FAR_DATA aResetableSetRange[] = {
420         RES_FRMATR_BEGIN, RES_FRMATR_END-1,
421         RES_CHRATR_BEGIN, RES_CHRATR_END-1,
422         RES_PARATR_BEGIN, RES_PARATR_END-1,
423         // --> OD 2008-02-25 #refactorlists#
424         RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END-1,
425         // <--
426         RES_TXTATR_INETFMT, RES_TXTATR_INETFMT,
427         RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT,
428         RES_TXTATR_CJK_RUBY, RES_TXTATR_CJK_RUBY,
429         RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER,
430         RES_UNKNOWNATR_BEGIN, RES_UNKNOWNATR_END-1,
431         0
432     };
433 
434 	SfxItemSet aDelSet( GetAttrPool(), aResetableSetRange );
435 	if( pAttrs && pAttrs->Count() )
436 	{
437 		for( sal_uInt16 n = pAttrs->Count(); n; )
438 			if( POOLATTR_END > (*pAttrs)[ --n ] )
439 				aDelSet.Put( *GetDfltAttr( (*pAttrs)[ n ] ));
440 
441 		if( aDelSet.Count() )
442 			aPara.pDelSet = &aDelSet;
443 	}
444 
445 	sal_Bool bAdd = sal_True;
446 	SwNodeIndex aTmpStt( pStt->nNode );
447 	SwNodeIndex aTmpEnd( pEnd->nNode );
448 	if( pStt->nContent.GetIndex() )		// nur ein Teil
449 	{
450 		// dann spaeter aufsetzen und alle CharFmtAttr -> TxtFmtAttr
451 		SwTxtNode* pTNd = aTmpStt.GetNode().GetTxtNode();
452         if( pTNd && pTNd->HasSwAttrSet() && pTNd->GetpSwAttrSet()->Count() )
453 		{
454             if (pHst)
455             {
456                 SwRegHistory history(pTNd, *pTNd, pHst);
457                 pTNd->FmtToTxtAttr(pTNd);
458             }
459             else
460             {
461                 pTNd->FmtToTxtAttr(pTNd);
462             }
463 		}
464 
465 		aTmpStt++;
466 	}
467 	if( pEnd->nContent.GetIndex() == pEnd->nNode.GetNode().GetCntntNode()->Len() )
468 		// dann spaeter aufsetzen und alle CharFmtAttr -> TxtFmtAttr
469 		aTmpEnd++, bAdd = sal_False;
470 	else if( pStt->nNode != pEnd->nNode || !pStt->nContent.GetIndex() )
471 	{
472 		SwTxtNode* pTNd = aTmpEnd.GetNode().GetTxtNode();
473         if( pTNd && pTNd->HasSwAttrSet() && pTNd->GetpSwAttrSet()->Count() )
474 		{
475             if (pHst)
476             {
477                 SwRegHistory history(pTNd, *pTNd, pHst);
478                 pTNd->FmtToTxtAttr(pTNd);
479             }
480             else
481             {
482                 pTNd->FmtToTxtAttr(pTNd);
483             }
484 		}
485 	}
486 
487 	if( aTmpStt < aTmpEnd )
488 		GetNodes().ForEach( pStt->nNode, aTmpEnd, lcl_RstAttr, &aPara );
489 	else if( !rRg.HasMark() )
490 	{
491         aPara.bResetAll = false ;
492 		::lcl_RstAttr( &pStt->nNode.GetNode(), &aPara );
493         aPara.bResetAll = true ;
494 	}
495 
496 	if( bTxtAttr )
497 	{
498 		if( bAdd )
499 			aTmpEnd++;
500 		GetNodes().ForEach( pStt->nNode, aTmpEnd, lcl_RstTxtAttr, &aPara );
501 	}
502 
503 	if( pPam != &rRg )
504 		delete pPam;
505 
506 	SetModified();
507 }
508 
509 #define DELETECHARSETS if ( bDelete ) { delete pCharSet; delete pOtherSet; }
510 
511 // Einfuegen der Hints nach Inhaltsformen;
512 // wird in SwDoc::Insert(..., SwFmtHint &rHt) benutzt
513 
lcl_InsAttr(SwDoc * const pDoc,const SwPaM & rRg,const SfxItemSet & rChgSet,const SetAttrMode nFlags,SwUndoAttr * const pUndo,const bool bExpandCharToPara=false)514 static bool lcl_InsAttr(
515     SwDoc *const pDoc,
516     const SwPaM &rRg,
517     const SfxItemSet& rChgSet,
518     const SetAttrMode nFlags,
519     SwUndoAttr *const pUndo,
520     //Modify here for #119405, by easyfan, 2012-05-24
521     const bool bExpandCharToPara=false)
522     //End of modification, by easyfan
523 {
524     // teil die Sets auf (fuer Selektion in Nodes)
525     const SfxItemSet* pCharSet = 0;
526     const SfxItemSet* pOtherSet = 0;
527     bool bDelete = false;
528     bool bCharAttr = false;
529     bool bOtherAttr = false;
530 
531     // Check, if we can work with rChgSet or if we have to create additional SfxItemSets
532     if ( 1 == rChgSet.Count() )
533     {
534         SfxItemIter aIter( rChgSet );
535         const SfxPoolItem* pItem = aIter.FirstItem();
536 
537         if (!IsInvalidItem(pItem))
538         {
539             const sal_uInt16 nWhich = pItem->Which();
540 
541             if ( isCHRATR(nWhich) ||
542                  (RES_TXTATR_CHARFMT == nWhich) ||
543                  (RES_TXTATR_INETFMT == nWhich) ||
544                  (RES_TXTATR_AUTOFMT == nWhich) ||
545                  (RES_TXTATR_UNKNOWN_CONTAINER == nWhich) )
546             {
547                 pCharSet  = &rChgSet;
548                 bCharAttr = true;
549             }
550 
551             if (    isPARATR(nWhich)
552                     || isPARATR_LIST(nWhich)
553                     || isFRMATR(nWhich)
554                     || isGRFATR(nWhich)
555                     || isUNKNOWNATR(nWhich)
556                     || isDrawingLayerAttribute(nWhich) ) //UUUU
557             {
558                 pOtherSet = &rChgSet;
559                 bOtherAttr = true;
560             }
561         }
562     }
563 
564     // Build new itemset if either
565     // - rChgSet.Count() > 1 or
566     // - The attribute in rChgSet does not belong to one of the above categories
567     if ( !bCharAttr && !bOtherAttr )
568     {
569         SfxItemSet* pTmpCharItemSet = new SfxItemSet( pDoc->GetAttrPool(),
570                                    RES_CHRATR_BEGIN, RES_CHRATR_END-1,
571                                    RES_TXTATR_AUTOFMT, RES_TXTATR_AUTOFMT,
572                                    RES_TXTATR_INETFMT, RES_TXTATR_INETFMT,
573                                    RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT,
574                RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER,
575                                    0 );
576 
577         SfxItemSet* pTmpOtherItemSet = new SfxItemSet( pDoc->GetAttrPool(),
578                                     RES_PARATR_BEGIN, RES_PARATR_END-1,
579                                     RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END-1,
580                                     RES_FRMATR_BEGIN, RES_FRMATR_END-1,
581                                     RES_GRFATR_BEGIN, RES_GRFATR_END-1,
582                                     RES_UNKNOWNATR_BEGIN, RES_UNKNOWNATR_END-1,
583 
584                                     //UUUU FillAttribute support
585                                     XATTR_FILL_FIRST, XATTR_FILL_LAST,
586 
587                                     0 );
588 
589         pTmpCharItemSet->Put( rChgSet );
590         pTmpOtherItemSet->Put( rChgSet );
591 
592         pCharSet = pTmpCharItemSet;
593         pOtherSet = pTmpOtherItemSet;
594 
595         bDelete = true;
596     }
597 
598     SwHistory* pHistory = pUndo ? &pUndo->GetHistory() : 0;
599     bool bRet = false;
600     const SwPosition *pStt = rRg.Start(), *pEnd = rRg.End();
601     SwCntntNode* pNode = pStt->nNode.GetNode().GetCntntNode();
602 
603     if( pNode && pNode->IsTxtNode() )
604     {
605         // -> #i27615#
606         if (rRg.IsInFrontOfLabel())
607         {
608             SwTxtNode * pTxtNd = pNode->GetTxtNode();
609             SwNumRule * pNumRule = pTxtNd->GetNumRule();
610 
611             if ( !pNumRule )
612             {
613                 ASSERT( false,
614                         "<InsAttr(..)> - PaM in front of label, but text node has no numbering rule set. This is a serious defect, please inform OD." );
615                 DELETECHARSETS
616                 return false;
617             }
618 
619             SwNumFmt aNumFmt = pNumRule->Get(static_cast<sal_uInt16>(pTxtNd->GetActualListLevel()));
620             SwCharFmt * pCharFmt =
621                 pDoc->FindCharFmtByName(aNumFmt.GetCharFmtName());
622 
623             if (pCharFmt)
624             {
625                 if (pHistory)
626                     pHistory->Add(pCharFmt->GetAttrSet(), *pCharFmt);
627 
628                 if ( pCharSet )
629                     pCharFmt->SetFmtAttr(*pCharSet);
630             }
631 
632             DELETECHARSETS
633             return true;
634         }
635 
636         const SwIndex& rSt = pStt->nContent;
637 
638         // Attribute ohne Ende haben keinen Bereich
639         if ( !bCharAttr && !bOtherAttr )
640         {
641             SfxItemSet aTxtSet( pDoc->GetAttrPool(),
642                         RES_TXTATR_NOEND_BEGIN, RES_TXTATR_NOEND_END-1 );
643             aTxtSet.Put( rChgSet );
644             if( aTxtSet.Count() )
645             {
646                 SwRegHistory history( pNode, *pNode, pHistory );
647                 bRet = history.InsertItems(
648                     aTxtSet, rSt.GetIndex(), rSt.GetIndex(), nFlags ) || bRet;
649 
650                 if (bRet && (pDoc->IsRedlineOn() || (!pDoc->IsIgnoreRedline()
651                                 && pDoc->GetRedlineTbl().Count())))
652                 {
653                     SwPaM aPam( pStt->nNode, pStt->nContent.GetIndex()-1,
654                                 pStt->nNode, pStt->nContent.GetIndex() );
655 
656                     if( pUndo )
657                         pUndo->SaveRedlineData( aPam, sal_True );
658 
659                     if( pDoc->IsRedlineOn() )
660                         pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, aPam ), true);
661                     else
662                         pDoc->SplitRedline( aPam );
663                 }
664             }
665         }
666 
667         // TextAttribute mit Ende expandieren nie ihren Bereich
668         if ( !bCharAttr && !bOtherAttr )
669         {
670             // CharFmt wird gesondert behandelt !!!
671             // JP 22.08.96: URL-Attribute auch!!
672             // TEST_TEMP ToDo: AutoFmt!
673             SfxItemSet aTxtSet( pDoc->GetAttrPool(),
674                                 RES_TXTATR_REFMARK, RES_TXTATR_TOXMARK,
675                                 RES_TXTATR_META, RES_TXTATR_METAFIELD,
676                                 RES_TXTATR_CJK_RUBY, RES_TXTATR_CJK_RUBY,
677                                 RES_TXTATR_INPUTFIELD, RES_TXTATR_INPUTFIELD,
678                                 0 );
679 
680             aTxtSet.Put( rChgSet );
681             if( aTxtSet.Count() )
682             {
683                 sal_uInt16 nInsCnt = rSt.GetIndex();
684                 sal_uInt16 nEnd = pStt->nNode == pEnd->nNode
685                                 ? pEnd->nContent.GetIndex()
686                                 : pNode->Len();
687                 SwRegHistory history( pNode, *pNode, pHistory );
688                 bRet = history.InsertItems( aTxtSet, nInsCnt, nEnd, nFlags )
689                        || bRet;
690 
691                 if (bRet && (pDoc->IsRedlineOn() || (!pDoc->IsIgnoreRedline()
692                                 && pDoc->GetRedlineTbl().Count())))
693                 {
694                     // wurde Text-Inhalt eingefuegt? (RefMark/TOXMarks ohne Ende)
695                     sal_Bool bTxtIns = nInsCnt != rSt.GetIndex();
696                     // wurde Inhalt eingefuegt oder ueber die Selektion gesetzt?
697                     SwPaM aPam( pStt->nNode, bTxtIns ? nInsCnt + 1 : nEnd,
698                                 pStt->nNode, nInsCnt );
699                     if( pUndo )
700                         pUndo->SaveRedlineData( aPam, bTxtIns );
701 
702                     if( pDoc->IsRedlineOn() )
703                         pDoc->AppendRedline(
704                             new SwRedline(
705                                 bTxtIns ? nsRedlineType_t::REDLINE_INSERT : nsRedlineType_t::REDLINE_FORMAT, aPam ),
706                                 true);
707                     else if( bTxtIns )
708                         pDoc->SplitRedline( aPam );
709                 }
710             }
711         }
712     }
713 
714     // bei PageDesc's, die am Node gesetzt werden, muss immer das
715     // Auto-Flag gesetzt werden!!
716     if( pOtherSet && pOtherSet->Count() )
717     {
718         SwTableNode* pTblNd;
719         const SwFmtPageDesc* pDesc;
720         if( SFX_ITEM_SET == pOtherSet->GetItemState( RES_PAGEDESC,
721                         sal_False, (const SfxPoolItem**)&pDesc ))
722         {
723             if( pNode )
724             {
725                 // Auto-Flag setzen, nur in Vorlagen ist ohne Auto !
726                 SwFmtPageDesc aNew( *pDesc );
727                 // Bug 38479: AutoFlag wird jetzt in der WrtShell gesetzt
728                 // aNew.SetAuto();
729 
730                 // Tabellen kennen jetzt auch Umbrueche
731                 if( 0 == (nFlags & nsSetAttrMode::SETATTR_APICALL) &&
732                     0 != ( pTblNd = pNode->FindTableNode() ) )
733                 {
734                     SwTableNode* pCurTblNd = pTblNd;
735                     while ( 0 != ( pCurTblNd = pCurTblNd->StartOfSectionNode()->FindTableNode() ) )
736                         pTblNd = pCurTblNd;
737 
738                     // dann am Tabellen Format setzen
739                     SwFrmFmt* pFmt = pTblNd->GetTable().GetFrmFmt();
740                     SwRegHistory aRegH( pFmt, *pTblNd, pHistory );
741                     pFmt->SetFmtAttr( aNew );
742                     bRet = true;
743                 }
744                 else
745                 {
746                     SwRegHistory aRegH( pNode, *pNode, pHistory );
747                     bRet = pNode->SetAttr( aNew ) || bRet;
748                 }
749             }
750 
751             // bOtherAttr = true means that pOtherSet == rChgSet. In this case
752             // we know, that there is only one attribute in pOtherSet. We cannot
753             // perform the following operations, instead we return:
754             if ( bOtherAttr )
755                 return bRet;
756 
757             const_cast<SfxItemSet*>(pOtherSet)->ClearItem( RES_PAGEDESC );
758             if( !pOtherSet->Count() )
759             {
760                 DELETECHARSETS
761                 return bRet;
762             }
763         }
764 
765         // Tabellen kennen jetzt auch Umbrueche
766         const SvxFmtBreakItem* pBreak;
767         if( pNode && 0 == (nFlags & nsSetAttrMode::SETATTR_APICALL) &&
768             0 != (pTblNd = pNode->FindTableNode() ) &&
769             SFX_ITEM_SET == pOtherSet->GetItemState( RES_BREAK,
770                         sal_False, (const SfxPoolItem**)&pBreak ) )
771         {
772             SwTableNode* pCurTblNd = pTblNd;
773             while ( 0 != ( pCurTblNd = pCurTblNd->StartOfSectionNode()->FindTableNode() ) )
774                 pTblNd = pCurTblNd;
775 
776             // dann am Tabellen Format setzen
777             SwFrmFmt* pFmt = pTblNd->GetTable().GetFrmFmt();
778             SwRegHistory aRegH( pFmt, *pTblNd, pHistory );
779             pFmt->SetFmtAttr( *pBreak );
780             bRet = true;
781 
782             // bOtherAttr = true means that pOtherSet == rChgSet. In this case
783             // we know, that there is only one attribute in pOtherSet. We cannot
784             // perform the following operations, instead we return:
785             if ( bOtherAttr )
786                 return bRet;
787 
788             const_cast<SfxItemSet*>(pOtherSet)->ClearItem( RES_BREAK );
789             if( !pOtherSet->Count() )
790             {
791                 DELETECHARSETS
792                 return bRet;
793             }
794         }
795 
796         {
797             // wenns eine PoolNumRule ist, diese ggfs. anlegen
798             const SwNumRuleItem* pRule;
799             sal_uInt16 nPoolId;
800             if( SFX_ITEM_SET == pOtherSet->GetItemState( RES_PARATR_NUMRULE,
801                                 sal_False, (const SfxPoolItem**)&pRule ) &&
802                 !pDoc->FindNumRulePtr( pRule->GetValue() ) &&
803                 USHRT_MAX != (nPoolId = SwStyleNameMapper::GetPoolIdFromUIName ( pRule->GetValue(),
804                                 nsSwGetPoolIdFromName::GET_POOLID_NUMRULE )) )
805                 pDoc->GetNumRuleFromPool( nPoolId );
806         }
807 
808     }
809 
810     if( !rRg.HasMark() )		// kein Bereich
811     {
812         if( !pNode )
813         {
814             DELETECHARSETS
815             return bRet;
816         }
817 
818         if( pNode->IsTxtNode() && pCharSet && pCharSet->Count() )
819         {
820             SwTxtNode* pTxtNd = static_cast<SwTxtNode*>(pNode);
821             const SwIndex& rSt = pStt->nContent;
822             sal_uInt16 nMkPos, nPtPos = rSt.GetIndex();
823             const String& rStr = pTxtNd->GetTxt();
824 
825             // JP 22.08.96: Sonderfall: steht der Crsr in einem URL-Attribut
826             //				dann wird dessen Bereich genommen
827             SwTxtAttr const*const pURLAttr(
828                 pTxtNd->GetTxtAttrAt(rSt.GetIndex(), RES_TXTATR_INETFMT));
829             if (pURLAttr && pURLAttr->GetINetFmt().GetValue().Len())
830             {
831                 nMkPos = *pURLAttr->GetStart();
832                 nPtPos = *pURLAttr->End();
833             }
834             else
835             {
836                 Boundary aBndry;
837                 if( pBreakIt->GetBreakIter().is() )
838                     aBndry = pBreakIt->GetBreakIter()->getWordBoundary(
839                                 pTxtNd->GetTxt(), nPtPos,
840                                 pBreakIt->GetLocale( pTxtNd->GetLang( nPtPos ) ),
841                                 WordType::ANY_WORD /*ANYWORD_IGNOREWHITESPACES*/,
842                                 sal_True );
843 
844                 if( aBndry.startPos < nPtPos && nPtPos < aBndry.endPos )
845                 {
846                     nMkPos = (xub_StrLen)aBndry.startPos;
847                     nPtPos = (xub_StrLen)aBndry.endPos;
848                 }
849                 else
850                     nPtPos = nMkPos = rSt.GetIndex();
851             }
852 
853             // erstmal die zu ueberschreibenden Attribute aus dem
854             // SwpHintsArray entfernen, wenn die Selektion den gesamten
855             // Absatz umspannt. (Diese Attribute werden als FormatAttr.
856             // eingefuegt und verdraengen nie die TextAttr.!)
857             if( !(nFlags & nsSetAttrMode::SETATTR_DONTREPLACE ) &&
858                 pTxtNd->HasHints() && !nMkPos && nPtPos == rStr.Len() )
859             {
860                 SwIndex aSt( pTxtNd );
861                 if( pHistory )
862                 {
863                     // fuers Undo alle Attribute sichern
864                     SwRegHistory aRHst( *pTxtNd, pHistory );
865                     pTxtNd->GetpSwpHints()->Register( &aRHst );
866                     pTxtNd->RstTxtAttr( aSt, nPtPos, 0, pCharSet );
867                     if( pTxtNd->GetpSwpHints() )
868                         pTxtNd->GetpSwpHints()->DeRegister();
869                 }
870                 else
871                     pTxtNd->RstTxtAttr( aSt, nPtPos, 0, pCharSet );
872             }
873 
874             // the SwRegHistory inserts the attribute into the TxtNode!
875             SwRegHistory history( pNode, *pNode, pHistory );
876             bRet = history.InsertItems( *pCharSet, nMkPos, nPtPos, nFlags )
877                 || bRet;
878 
879             if( pDoc->IsRedlineOn() )
880             {
881                 SwPaM aPam( *pNode, nMkPos, *pNode, nPtPos );
882 
883                 if( pUndo )
884                     pUndo->SaveRedlineData( aPam, sal_False );
885                 pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_FORMAT, aPam ), true);
886             }
887         }
888         if( pOtherSet && pOtherSet->Count() )
889         {
890             SwRegHistory aRegH( pNode, *pNode, pHistory );
891 
892             //UUUU Need to check for unique item for DrawingLayer items of type NameOrIndex
893             // and evtl. correct that item to ensure unique names for that type. This call may
894             // modify/correct entries inside of the given SfxItemSet
895             SfxItemSet aTempLocalCopy(*pOtherSet);
896 
897             pDoc->CheckForUniqueItemForLineFillNameOrIndex(aTempLocalCopy);
898             bRet = pNode->SetAttr(aTempLocalCopy) || bRet;
899         }
900 
901         DELETECHARSETS
902         return bRet;
903     }
904 
905     if( pDoc->IsRedlineOn() && pCharSet && pCharSet->Count() )
906     {
907         if( pUndo )
908             pUndo->SaveRedlineData( rRg, sal_False );
909         pDoc->AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_FORMAT, rRg ), true);
910     }
911 
912     /* jetzt wenn Bereich */
913     sal_uLong nNodes = 0;
914 
915     SwNodeIndex aSt( pDoc->GetNodes() );
916     SwNodeIndex aEnd( pDoc->GetNodes() );
917     SwIndex aCntEnd( pEnd->nContent );
918 
919     if( pNode )
920     {
921         sal_uInt16 nLen = pNode->Len();
922         if( pStt->nNode != pEnd->nNode )
923             aCntEnd.Assign( pNode, nLen );
924 
925         if( pStt->nContent.GetIndex() != 0 || aCntEnd.GetIndex() != nLen )
926         {
927             // the SwRegHistory inserts the attribute into the TxtNode!
928             if( pNode->IsTxtNode() && pCharSet && pCharSet->Count() )
929             {
930                 SwRegHistory history( pNode, *pNode, pHistory );
931                 bRet = history.InsertItems(*pCharSet,
932                         pStt->nContent.GetIndex(), aCntEnd.GetIndex(), nFlags)
933                     || bRet;
934             }
935 
936             if( pOtherSet && pOtherSet->Count() )
937             {
938                 SwRegHistory aRegH( pNode, *pNode, pHistory );
939                 bRet = pNode->SetAttr( *pOtherSet ) || bRet;
940             }
941 
942             // lediglich Selektion in einem Node.
943             if( pStt->nNode == pEnd->nNode )
944             {
945             //Modify here for #119405, by easyfan, 2012-05-24
946             //The data parameter flag: bExpandCharToPara, comes from the data member of SwDoc,
947             //Which is set in SW MS word Binary filter WW8ImplRreader. With this flag on, means that
948             //current setting attribute set is a character range properties set and comes from a MS word
949             //binary file, And the setting range include a paragraph end position (0X0D);
950             //More specifications, as such property inside the character range properties set recorded in
951             //MS word binary file are dealed and inserted into data model (SwDoc) one by one, so we
952             //only dealing the scenario that the char properties set with 1 item inside;
953 
954                     if (bExpandCharToPara && pCharSet && pCharSet->Count() ==1 )
955             {
956                 SwTxtNode* pCurrentNd = pStt->nNode.GetNode().GetTxtNode();
957 
958                 if (pCurrentNd)
959                 {
960                     pCurrentNd->TryCharSetExpandToNum(*pCharSet);
961 
962                 }
963             }
964             //End of modification, by easyfan
965                 DELETECHARSETS
966                 return bRet;
967             }
968             ++nNodes;
969             aSt.Assign( pStt->nNode.GetNode(), +1 );
970         }
971         else
972             aSt = pStt->nNode;
973         aCntEnd = pEnd->nContent; // aEnd wurde veraendert !!
974     }
975     else
976         aSt.Assign( pStt->nNode.GetNode(), +1 );
977 
978     // aSt zeigt jetzt auf den ersten vollen Node
979 
980     /*
981      * die Selektion umfasst mehr als einen Node
982      */
983     if( pStt->nNode < pEnd->nNode )
984     {
985         pNode = pEnd->nNode.GetNode().GetCntntNode();
986         if(pNode)
987         {
988             sal_uInt16 nLen = pNode->Len();
989             if( aCntEnd.GetIndex() != nLen )
990             {
991                 // the SwRegHistory inserts the attribute into the TxtNode!
992                 if( pNode->IsTxtNode() && pCharSet && pCharSet->Count() )
993                 {
994                     SwRegHistory history( pNode, *pNode, pHistory );
995                     history.InsertItems(*pCharSet,
996                             0, aCntEnd.GetIndex(), nFlags);
997                 }
998 
999                 if( pOtherSet && pOtherSet->Count() )
1000                 {
1001                     SwRegHistory aRegH( pNode, *pNode, pHistory );
1002                     pNode->SetAttr( *pOtherSet );
1003                 }
1004 
1005                 ++nNodes;
1006                 aEnd = pEnd->nNode;
1007             }
1008             else
1009                 aEnd.Assign( pEnd->nNode.GetNode(), +1 );
1010         }
1011         else
1012             aEnd = pEnd->nNode;
1013     }
1014     else
1015         aEnd.Assign( pEnd->nNode.GetNode(), +1 );
1016 
1017     // aEnd zeigt jetzt HINTER den letzten voll Node
1018 
1019     /* Bearbeitung der vollstaendig selektierten Nodes. */
1020 // alle Attribute aus dem Set zuruecksetzen !!
1021     if( pCharSet && pCharSet->Count() && !( nsSetAttrMode::SETATTR_DONTREPLACE & nFlags ) )
1022     {
1023 
1024         ParaRstFmt aPara( pStt, pEnd, pHistory, 0, pCharSet );
1025         pDoc->GetNodes().ForEach( aSt, aEnd, lcl_RstTxtAttr, &aPara );
1026     }
1027 
1028     sal_Bool bCreateSwpHints = pCharSet && (
1029         SFX_ITEM_SET == pCharSet->GetItemState( RES_TXTATR_CHARFMT, sal_False ) ||
1030         SFX_ITEM_SET == pCharSet->GetItemState( RES_TXTATR_INETFMT, sal_False ) );
1031 
1032     for(; aSt < aEnd; aSt++ )
1033     {
1034         pNode = aSt.GetNode().GetCntntNode();
1035         if( !pNode )
1036             continue;
1037 
1038         SwTxtNode* pTNd = pNode->GetTxtNode();
1039         if( pHistory )
1040         {
1041             SwRegHistory aRegH( pNode, *pNode, pHistory );
1042             SwpHints *pSwpHints;
1043 
1044             if( pTNd && pCharSet && pCharSet->Count() )
1045             {
1046                 pSwpHints = bCreateSwpHints ? &pTNd->GetOrCreateSwpHints()
1047                                             : pTNd->GetpSwpHints();
1048                 if( pSwpHints )
1049                     pSwpHints->Register( &aRegH );
1050 
1051                 pTNd->SetAttr( *pCharSet, 0, pTNd->GetTxt().Len(), nFlags );
1052                 if( pSwpHints )
1053                     pSwpHints->DeRegister();
1054             }
1055             if( pOtherSet && pOtherSet->Count() )
1056                 pNode->SetAttr( *pOtherSet );
1057         }
1058         else
1059         {
1060             if( pTNd && pCharSet && pCharSet->Count() )
1061                 pTNd->SetAttr( *pCharSet, 0, pTNd->GetTxt().Len(), nFlags );
1062             if( pOtherSet && pOtherSet->Count() )
1063                 pNode->SetAttr( *pOtherSet );
1064         }
1065         ++nNodes;
1066     }
1067 
1068     //The data parameter flag: bExpandCharToPara, comes from the data member of SwDoc,
1069     //Which is set in SW MS word Binary filter WW8ImplRreader. With this flag on, means that
1070     //current setting attribute set is a character range properties set and comes from a MS word
1071     //binary file, And the setting range include a paragraph end position (0X0D);
1072     //More specifications, as such property inside the character range properties set recorded in
1073     //MS word binary file are dealed and inserted into data model (SwDoc) one by one, so we
1074     //only dealing the scenario that the char properties set with 1 item inside;
1075     if (bExpandCharToPara && pCharSet && pCharSet->Count() ==1)
1076     {
1077         SwPosition aStartPos (*rRg.Start());
1078         SwPosition aEndPos (*rRg.End());
1079 
1080         if (aEndPos.nNode.GetNode().GetTxtNode() && aEndPos.nContent != aEndPos.nNode.GetNode().GetTxtNode()->Len())
1081             aEndPos.nNode--;
1082 
1083         for (;aStartPos<=aEndPos;aStartPos.nNode++)
1084         {
1085             SwTxtNode* pCurrentNd = aStartPos.nNode.GetNode().GetTxtNode();
1086 
1087             if (pCurrentNd)
1088             {
1089                 pCurrentNd->TryCharSetExpandToNum(*pCharSet);
1090 
1091             }
1092 
1093         }
1094     }
1095 
1096     DELETECHARSETS
1097     return (nNodes != 0) || bRet;
1098 }
1099 
InsertPoolItem(const SwPaM & rRg,const SfxPoolItem & rHt,const SetAttrMode nFlags,const bool bExpandCharToPara)1100 bool SwDoc::InsertPoolItem(
1101     const SwPaM &rRg,
1102     const SfxPoolItem &rHt,
1103     const SetAttrMode nFlags,
1104     const bool bExpandCharToPara)
1105 {
1106     SwDataChanged aTmp( rRg, 0 );
1107     SwUndoAttr* pUndoAttr = 0;
1108     if (GetIDocumentUndoRedo().DoesUndo())
1109     {
1110         GetIDocumentUndoRedo().ClearRedo();
1111         pUndoAttr = new SwUndoAttr( rRg, rHt, nFlags );
1112     }
1113 
1114     SfxItemSet aSet( GetAttrPool(), rHt.Which(), rHt.Which() );
1115     aSet.Put( rHt );
1116     const bool bRet = lcl_InsAttr( this, rRg, aSet, nFlags, pUndoAttr,bExpandCharToPara );
1117 
1118     if (GetIDocumentUndoRedo().DoesUndo())
1119     {
1120         GetIDocumentUndoRedo().AppendUndo( pUndoAttr );
1121     }
1122 
1123     if( bRet )
1124     {
1125         SetModified();
1126     }
1127     return bRet;
1128 }
1129 
InsertItemSet(const SwPaM & rRg,const SfxItemSet & rSet,const SetAttrMode nFlags)1130 bool SwDoc::InsertItemSet ( const SwPaM &rRg, const SfxItemSet &rSet,
1131                             const SetAttrMode nFlags )
1132 {
1133 	SwDataChanged aTmp( rRg, 0 );
1134 	SwUndoAttr* pUndoAttr = 0;
1135     if (GetIDocumentUndoRedo().DoesUndo())
1136     {
1137         GetIDocumentUndoRedo().ClearRedo();
1138         pUndoAttr = new SwUndoAttr( rRg, rSet, nFlags );
1139 	}
1140 
1141     bool bRet = lcl_InsAttr( this, rRg, rSet, nFlags, pUndoAttr );
1142 
1143     if (GetIDocumentUndoRedo().DoesUndo())
1144     {
1145         GetIDocumentUndoRedo().AppendUndo( pUndoAttr );
1146     }
1147 
1148 	if( bRet )
1149 		SetModified();
1150 	return bRet;
1151 }
1152 
1153 
1154 	// Setze das Attribut im angegebenen Format. Ist Undo aktiv, wird
1155 	// das alte in die Undo-History aufgenommen
SetAttr(const SfxPoolItem & rAttr,SwFmt & rFmt)1156 void SwDoc::SetAttr( const SfxPoolItem& rAttr, SwFmt& rFmt )
1157 {
1158 	SfxItemSet aSet( GetAttrPool(), rAttr.Which(), rAttr.Which() );
1159 	aSet.Put( rAttr );
1160 	SetAttr( aSet, rFmt );
1161 }
1162 
1163 
1164 	// Setze das Attribut im angegebenen Format. Ist Undo aktiv, wird
1165 	// das alte in die Undo-History aufgenommen
SetAttr(const SfxItemSet & rSet,SwFmt & rFmt)1166 void SwDoc::SetAttr( const SfxItemSet& rSet, SwFmt& rFmt )
1167 {
1168     if (GetIDocumentUndoRedo().DoesUndo())
1169     {
1170         SwUndoFmtAttrHelper aTmp( rFmt );
1171         rFmt.SetFmtAttr( rSet );
1172         if ( aTmp.GetUndo() )
1173         {
1174             GetIDocumentUndoRedo().AppendUndo( aTmp.ReleaseUndo() );
1175         }
1176         else
1177         {
1178             GetIDocumentUndoRedo().ClearRedo();
1179         }
1180     }
1181     else
1182     {
1183         rFmt.SetFmtAttr( rSet );
1184     }
1185 	SetModified();
1186 }
1187 
1188 // --> OD 2008-02-12 #newlistlevelattrs#
ResetAttrAtFormat(const sal_uInt16 nWhichId,SwFmt & rChangedFormat)1189 void SwDoc::ResetAttrAtFormat( const sal_uInt16 nWhichId,
1190                                SwFmt& rChangedFormat )
1191 {
1192     SwUndo *const pUndo = (GetIDocumentUndoRedo().DoesUndo())
1193         ?   new SwUndoFmtResetAttr( rChangedFormat, nWhichId )
1194         :   0;
1195 
1196     const sal_Bool bAttrReset = rChangedFormat.ResetFmtAttr( nWhichId );
1197 
1198     if ( bAttrReset )
1199     {
1200         if ( pUndo )
1201         {
1202             GetIDocumentUndoRedo().AppendUndo( pUndo );
1203         }
1204 
1205         SetModified();
1206     }
1207     else if ( pUndo )
1208         delete pUndo;
1209 }
1210 // <--
1211 
lcl_SetNewDefTabStops(SwTwips nOldWidth,SwTwips nNewWidth,SvxTabStopItem & rChgTabStop)1212 int lcl_SetNewDefTabStops( SwTwips nOldWidth, SwTwips nNewWidth,
1213 								SvxTabStopItem& rChgTabStop )
1214 {
1215 	// dann aender bei allen TabStop die default's auf den neuen Wert
1216 	// !!! Achtung: hier wird immer auf dem PoolAttribut gearbeitet,
1217 	// 				damit nicht in allen Sets die gleiche Berechnung
1218 	//				auf dem gleichen TabStop (gepoolt!) vorgenommen
1219 	//				wird. Als Modify wird ein FmtChg verschickt.
1220 
1221 	sal_uInt16 nOldCnt = rChgTabStop.Count();
1222 	if( !nOldCnt || nOldWidth == nNewWidth )
1223 		return sal_False;
1224 
1225 	// suche den Anfang der Defaults
1226 	SvxTabStop* pTabs = ((SvxTabStop*)rChgTabStop.GetStart())
1227 						+ (nOldCnt-1);
1228 	sal_uInt16 n;
1229 
1230 	for( n = nOldCnt; n ; --n, --pTabs )
1231 		if( SVX_TAB_ADJUST_DEFAULT != pTabs->GetAdjustment() )
1232 			break;
1233 	++n;
1234 	if( n < nOldCnt )	// die DefTabStops loeschen
1235 		rChgTabStop.Remove( n, nOldCnt - n );
1236 	return sal_True;
1237 }
1238 
1239 // Setze das Attribut als neues default Attribut in diesem Dokument.
1240 // Ist Undo aktiv, wird das alte in die Undo-History aufgenommen
SetDefault(const SfxPoolItem & rAttr)1241 void SwDoc::SetDefault( const SfxPoolItem& rAttr )
1242 {
1243 	SfxItemSet aSet( GetAttrPool(), rAttr.Which(), rAttr.Which() );
1244 	aSet.Put( rAttr );
1245 	SetDefault( aSet );
1246 }
1247 
SetDefault(const SfxItemSet & rSet)1248 void SwDoc::SetDefault( const SfxItemSet& rSet )
1249 {
1250 	if( !rSet.Count() )
1251 		return;
1252 
1253 	SwModify aCallMod( 0 );
1254 	SwAttrSet aOld( GetAttrPool(), rSet.GetRanges() ),
1255 			aNew( GetAttrPool(), rSet.GetRanges() );
1256 	SfxItemIter aIter( rSet );
1257 	sal_uInt16 nWhich;
1258 	const SfxPoolItem* pItem = aIter.GetCurItem();
1259 	SfxItemPool* pSdrPool = GetAttrPool().GetSecondaryPool();
1260 	while( sal_True )
1261 	{
1262 		sal_Bool bCheckSdrDflt = sal_False;
1263 		nWhich = pItem->Which();
1264 		aOld.Put( GetAttrPool().GetDefaultItem( nWhich ) );
1265 		GetAttrPool().SetPoolDefaultItem( *pItem );
1266 		aNew.Put( GetAttrPool().GetDefaultItem( nWhich ) );
1267 
1268         if (isCHRATR(nWhich) || isTXTATR(nWhich))
1269         {
1270 			aCallMod.Add( pDfltTxtFmtColl );
1271 			aCallMod.Add( pDfltCharFmt );
1272 			bCheckSdrDflt = 0 != pSdrPool;
1273         }
1274         else if ( isPARATR(nWhich) ||
1275                   // --> OD 2008-02-25 #refactorlists#
1276                   isPARATR_LIST(nWhich) )
1277                   // <--
1278         {
1279 			aCallMod.Add( pDfltTxtFmtColl );
1280 			bCheckSdrDflt = 0 != pSdrPool;
1281         }
1282         else if (isGRFATR(nWhich))
1283         {
1284             aCallMod.Add( pDfltGrfFmtColl );
1285         }
1286         else if (isFRMATR(nWhich) || isDrawingLayerAttribute(nWhich) ) //UUUU
1287         {
1288 			aCallMod.Add( pDfltGrfFmtColl );
1289 			aCallMod.Add( pDfltTxtFmtColl );
1290 			aCallMod.Add( pDfltFrmFmt );
1291         }
1292         else if (isBOXATR(nWhich))
1293         {
1294             aCallMod.Add( pDfltFrmFmt );
1295         }
1296 
1297 		// copy also the defaults
1298 		if( bCheckSdrDflt )
1299 		{
1300 			sal_uInt16 nEdtWhich, nSlotId;
1301 			if( 0 != (nSlotId = GetAttrPool().GetSlotId( nWhich ) ) &&
1302 				nSlotId != nWhich &&
1303 				0 != (nEdtWhich = pSdrPool->GetWhich( nSlotId )) &&
1304 				nSlotId != nEdtWhich )
1305 			{
1306 				SfxPoolItem* pCpy = pItem->Clone();
1307 				pCpy->SetWhich( nEdtWhich );
1308 				pSdrPool->SetPoolDefaultItem( *pCpy );
1309 				delete pCpy;
1310 			}
1311 		}
1312 
1313 		if( aIter.IsAtEnd() )
1314 			break;
1315 		pItem = aIter.NextItem();
1316 	}
1317 
1318 	if( aNew.Count() && aCallMod.GetDepends() )
1319     {
1320         if (GetIDocumentUndoRedo().DoesUndo())
1321         {
1322             GetIDocumentUndoRedo().AppendUndo( new SwUndoDefaultAttr( aOld ) );
1323         }
1324 
1325 		const SfxPoolItem* pTmpItem;
1326 		if( ( SFX_ITEM_SET ==
1327                 aNew.GetItemState( RES_PARATR_TABSTOP, sal_False, &pTmpItem ) ) &&
1328 			((SvxTabStopItem*)pTmpItem)->Count() )
1329 		{
1330 			// TabStop-Aenderungen behandeln wir erstmal anders:
1331 			// dann aender bei allen TabStop die dafault's auf den neuen Wert
1332 			// !!! Achtung: hier wird immer auf dem PoolAttribut gearbeitet,
1333 			// 				damit nicht in allen Sets die gleiche Berechnung
1334 			//				auf dem gleichen TabStop (gepoolt!) vorgenommen
1335 			//				wird. Als Modify wird ein FmtChg verschickt.
1336 			SwTwips nNewWidth = (*(SvxTabStopItem*)pTmpItem)[ 0 ].GetTabPos(),
1337 					nOldWidth = ((SvxTabStopItem&)aOld.Get(RES_PARATR_TABSTOP))[ 0 ].GetTabPos();
1338 
1339 			int bChg = sal_False;
1340 			sal_uInt32 nMaxItems = GetAttrPool().GetItemCount2( RES_PARATR_TABSTOP );
1341 			for( sal_uInt32 n = 0; n < nMaxItems; ++n )
1342 				if( 0 != (pTmpItem = GetAttrPool().GetItem2( RES_PARATR_TABSTOP, n ) ))
1343 					bChg |= lcl_SetNewDefTabStops( nOldWidth, nNewWidth,
1344 												*(SvxTabStopItem*)pTmpItem );
1345 
1346 			aNew.ClearItem( RES_PARATR_TABSTOP );
1347 			aOld.ClearItem( RES_PARATR_TABSTOP );
1348 			if( bChg )
1349 			{
1350 				SwFmtChg aChgFmt( pDfltCharFmt );
1351 				// dann sage mal den Frames bescheid
1352 				aCallMod.ModifyNotification( &aChgFmt, &aChgFmt );
1353 			}
1354 		}
1355 	}
1356 
1357 	if( aNew.Count() && aCallMod.GetDepends() )
1358 	{
1359 		SwAttrSetChg aChgOld( aOld, aOld );
1360 		SwAttrSetChg aChgNew( aNew, aNew );
1361 		aCallMod.ModifyNotification( &aChgOld, &aChgNew );		// alle veraenderten werden verschickt
1362 	}
1363 
1364 	// und die default-Formate wieder beim Object austragen
1365 	SwClient* pDep;
1366 	while( 0 != ( pDep = (SwClient*)aCallMod.GetDepends()) )
1367 		aCallMod.Remove( pDep );
1368 
1369 	SetModified();
1370 }
1371 
1372 	// Erfrage das Default Attribut in diesem Dokument.
GetDefault(sal_uInt16 nFmtHint) const1373 const SfxPoolItem& SwDoc::GetDefault( sal_uInt16 nFmtHint ) const
1374 {
1375 	return GetAttrPool().GetDefaultItem( nFmtHint );
1376 }
1377 
1378 /*
1379  * Loeschen der Formate
1380  */
DelCharFmt(sal_uInt16 nFmt,sal_Bool bBroadcast)1381 void SwDoc::DelCharFmt(sal_uInt16 nFmt, sal_Bool bBroadcast)
1382 {
1383     SwCharFmt * pDel = (*pCharFmtTbl)[nFmt];
1384 
1385     if (bBroadcast)
1386         BroadcastStyleOperation(pDel->GetName(), SFX_STYLE_FAMILY_CHAR,
1387                                 SFX_STYLESHEET_ERASED);
1388 
1389     if (GetIDocumentUndoRedo().DoesUndo())
1390     {
1391         SwUndo * pUndo =
1392             new SwUndoCharFmtDelete(pDel, this);
1393 
1394         GetIDocumentUndoRedo().AppendUndo(pUndo);
1395     }
1396 
1397 	pCharFmtTbl->DeleteAndDestroy(nFmt);
1398 
1399 	SetModified();
1400 }
1401 
DelCharFmt(SwCharFmt * pFmt,sal_Bool bBroadcast)1402 void SwDoc::DelCharFmt( SwCharFmt *pFmt, sal_Bool bBroadcast )
1403 {
1404 	sal_uInt16 nFmt = pCharFmtTbl->GetPos( pFmt );
1405 	ASSERT( USHRT_MAX != nFmt, "Fmt not found," );
1406 
1407 	DelCharFmt( nFmt, bBroadcast );
1408 }
1409 
DelFrmFmt(SwFrmFmt * pFmt,sal_Bool bBroadcast)1410 void SwDoc::DelFrmFmt( SwFrmFmt *pFmt, sal_Bool bBroadcast )
1411 {
1412 	if( pFmt->ISA( SwTableBoxFmt ) || pFmt->ISA( SwTableLineFmt ))
1413 	{
1414 		ASSERT( sal_False, "Format is no longer in DocArray, "
1415 					   "can be deleted by delete" );
1416 		delete pFmt;
1417 	}
1418 	else
1419 	{
1420 
1421 		//Das Format muss in einem der beiden Arrays stehen, in welchem
1422 		//werden wir schon merken.
1423 		sal_uInt16 nPos;
1424 		if ( USHRT_MAX != ( nPos = pFrmFmtTbl->GetPos( pFmt )) )
1425         {
1426             if (bBroadcast)
1427                 BroadcastStyleOperation(pFmt->GetName(),
1428                                         SFX_STYLE_FAMILY_FRAME,
1429                                         SFX_STYLESHEET_ERASED);
1430 
1431             if (GetIDocumentUndoRedo().DoesUndo())
1432             {
1433                 SwUndo * pUndo = new SwUndoFrmFmtDelete(pFmt, this);
1434 
1435                 GetIDocumentUndoRedo().AppendUndo(pUndo);
1436             }
1437 
1438 			pFrmFmtTbl->DeleteAndDestroy( nPos );
1439         }
1440 		else
1441 		{
1442 			nPos = GetSpzFrmFmts()->GetPos( pFmt );
1443 			ASSERT( nPos != USHRT_MAX, "FrmFmt not found." );
1444 			if( USHRT_MAX != nPos )
1445 				GetSpzFrmFmts()->DeleteAndDestroy( nPos );
1446 		}
1447 	}
1448 }
1449 
DelTblFrmFmt(SwTableFmt * pFmt)1450 void SwDoc::DelTblFrmFmt( SwTableFmt *pFmt )
1451 {
1452 	sal_uInt16 nPos = pTblFrmFmtTbl->GetPos( pFmt );
1453 	ASSERT( USHRT_MAX != nPos, "Fmt not found," );
1454 	pTblFrmFmtTbl->DeleteAndDestroy( nPos );
1455 }
1456 
1457 /*
1458  * Erzeugen der Formate
1459  */
MakeFlyFrmFmt(const String & rFmtName,SwFrmFmt * pDerivedFrom)1460 SwFlyFrmFmt *SwDoc::MakeFlyFrmFmt( const String &rFmtName,
1461 									SwFrmFmt *pDerivedFrom )
1462 {
1463 	SwFlyFrmFmt *pFmt = new SwFlyFrmFmt( GetAttrPool(), rFmtName, pDerivedFrom );
1464 	GetSpzFrmFmts()->Insert(pFmt, GetSpzFrmFmts()->Count());
1465 	SetModified();
1466 	return pFmt;
1467 }
1468 
MakeDrawFrmFmt(const String & rFmtName,SwFrmFmt * pDerivedFrom)1469 SwDrawFrmFmt *SwDoc::MakeDrawFrmFmt( const String &rFmtName,
1470 									 SwFrmFmt *pDerivedFrom )
1471 {
1472 	SwDrawFrmFmt *pFmt = new SwDrawFrmFmt( GetAttrPool(), rFmtName, pDerivedFrom);
1473 	GetSpzFrmFmts()->Insert(pFmt,GetSpzFrmFmts()->Count());
1474 	SetModified();
1475 	return pFmt;
1476 }
1477 
1478 
GetTblFrmFmtCount(sal_Bool bUsed) const1479 sal_uInt16 SwDoc::GetTblFrmFmtCount(sal_Bool bUsed) const
1480 {
1481 	sal_uInt16 nCount = pTblFrmFmtTbl->Count();
1482 	if(bUsed)
1483 	{
1484         SwAutoFmtGetDocNode aGetHt( &GetNodes() );
1485 		for ( sal_uInt16 i = nCount; i; )
1486 		{
1487 			if((*pTblFrmFmtTbl)[--i]->GetInfo( aGetHt ))
1488 
1489 				--nCount;
1490 		}
1491 	}
1492 
1493 	return nCount;
1494 }
1495 
1496 
GetTblFrmFmt(sal_uInt16 nFmt,sal_Bool bUsed) const1497 SwFrmFmt& SwDoc::GetTblFrmFmt(sal_uInt16 nFmt, sal_Bool bUsed ) const
1498 {
1499 	sal_uInt16 nRemoved = 0;
1500 	if(bUsed)
1501 	{
1502         SwAutoFmtGetDocNode aGetHt( &GetNodes() );
1503 		for ( sal_uInt16 i = 0; i <= nFmt; i++ )
1504 		{
1505 			while ( (*pTblFrmFmtTbl)[ i + nRemoved]->GetInfo( aGetHt ))
1506 			{
1507 				nRemoved++;
1508 			}
1509 		}
1510 	}
1511 	return *((*pTblFrmFmtTbl)[nRemoved + nFmt]);
1512 }
1513 
MakeTblFrmFmt(const String & rFmtName,SwFrmFmt * pDerivedFrom)1514 SwTableFmt* SwDoc::MakeTblFrmFmt( const String &rFmtName,
1515 									SwFrmFmt *pDerivedFrom )
1516 {
1517 	SwTableFmt* pFmt = new SwTableFmt( GetAttrPool(), rFmtName, pDerivedFrom );
1518 	pTblFrmFmtTbl->Insert( pFmt, pTblFrmFmtTbl->Count() );
1519 	SetModified();
1520 
1521 	return pFmt;
1522 }
1523 
MakeFrmFmt(const String & rFmtName,SwFrmFmt * pDerivedFrom,sal_Bool bBroadcast,sal_Bool bAuto)1524 SwFrmFmt *SwDoc::MakeFrmFmt(const String &rFmtName,
1525 							SwFrmFmt *pDerivedFrom,
1526                             sal_Bool bBroadcast, sal_Bool bAuto)
1527 {
1528 
1529 	SwFrmFmt *pFmt = new SwFrmFmt( GetAttrPool(), rFmtName, pDerivedFrom );
1530 
1531     pFmt->SetAuto(bAuto);
1532 	pFrmFmtTbl->Insert( pFmt, pFrmFmtTbl->Count());
1533 	SetModified();
1534 
1535     if (bBroadcast)
1536     {
1537         BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_PARA,
1538                                 SFX_STYLESHEET_CREATED);
1539 
1540         if (GetIDocumentUndoRedo().DoesUndo())
1541         {
1542             SwUndo * pUndo = new SwUndoFrmFmtCreate(pFmt, pDerivedFrom, this);
1543 
1544             GetIDocumentUndoRedo().AppendUndo(pUndo);
1545         }
1546     }
1547 
1548 	return pFmt;
1549 }
1550 
_MakeFrmFmt(const String & rFmtName,SwFmt * pDerivedFrom,sal_Bool bBroadcast,sal_Bool bAuto)1551 SwFmt *SwDoc::_MakeFrmFmt(const String &rFmtName,
1552 							SwFmt *pDerivedFrom,
1553                             sal_Bool bBroadcast, sal_Bool bAuto)
1554 {
1555     SwFrmFmt *pFrmFmt = dynamic_cast<SwFrmFmt*>(pDerivedFrom);
1556     pFrmFmt = MakeFrmFmt( rFmtName, pFrmFmt, bBroadcast, bAuto );
1557     return dynamic_cast<SwFmt*>(pFrmFmt);
1558 }
1559 
1560 
1561 // --> OD 2005-01-13 #i40550# - add parameter <bAuto> - not relevant
MakeCharFmt(const String & rFmtName,SwCharFmt * pDerivedFrom,sal_Bool bBroadcast,sal_Bool)1562 SwCharFmt *SwDoc::MakeCharFmt( const String &rFmtName,
1563                                SwCharFmt *pDerivedFrom,
1564                                sal_Bool bBroadcast,
1565                                sal_Bool )
1566 // <--
1567 {
1568 	SwCharFmt *pFmt = new SwCharFmt( GetAttrPool(), rFmtName, pDerivedFrom );
1569     pCharFmtTbl->Insert( pFmt, pCharFmtTbl->Count() );
1570     pFmt->SetAuto( sal_False );
1571     SetModified();
1572 
1573     if (GetIDocumentUndoRedo().DoesUndo())
1574     {
1575         SwUndo * pUndo = new SwUndoCharFmtCreate(pFmt, pDerivedFrom, this);
1576 
1577         GetIDocumentUndoRedo().AppendUndo(pUndo);
1578     }
1579 
1580     if (bBroadcast)
1581     {
1582         BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_CHAR,
1583                                 SFX_STYLESHEET_CREATED);
1584     }
1585 
1586 	return pFmt;
1587 }
1588 
_MakeCharFmt(const String & rFmtName,SwFmt * pDerivedFrom,sal_Bool bBroadcast,sal_Bool bAuto)1589 SwFmt *SwDoc::_MakeCharFmt(const String &rFmtName,
1590 							SwFmt *pDerivedFrom,
1591                             sal_Bool bBroadcast, sal_Bool bAuto)
1592 {
1593     SwCharFmt *pCharFmt = dynamic_cast<SwCharFmt*>(pDerivedFrom);
1594     pCharFmt = MakeCharFmt( rFmtName, pCharFmt, bBroadcast, bAuto );
1595     return dynamic_cast<SwFmt*>(pCharFmt);
1596 }
1597 
1598 
1599 /*
1600  * Erzeugen der FormatCollections
1601  */
1602 // TXT
1603 // --> OD 2005-01-13 #i40550# - add parameter <bAuto> - not relevant
MakeTxtFmtColl(const String & rFmtName,SwTxtFmtColl * pDerivedFrom,sal_Bool bBroadcast,sal_Bool)1604 SwTxtFmtColl* SwDoc::MakeTxtFmtColl( const String &rFmtName,
1605 									 SwTxtFmtColl *pDerivedFrom,
1606                                      sal_Bool bBroadcast,
1607                                      sal_Bool )
1608 // <--
1609 {
1610 	SwTxtFmtColl *pFmtColl = new SwTxtFmtColl( GetAttrPool(), rFmtName,
1611 												pDerivedFrom );
1612 	pTxtFmtCollTbl->Insert(pFmtColl, pTxtFmtCollTbl->Count());
1613 	pFmtColl->SetAuto( sal_False );
1614 	SetModified();
1615 
1616     if (GetIDocumentUndoRedo().DoesUndo())
1617     {
1618         SwUndo * pUndo = new SwUndoTxtFmtCollCreate(pFmtColl, pDerivedFrom,
1619                                                     this);
1620         GetIDocumentUndoRedo().AppendUndo(pUndo);
1621     }
1622 
1623     if (bBroadcast)
1624         BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_PARA,
1625                                 SFX_STYLESHEET_CREATED);
1626 
1627 	return pFmtColl;
1628 }
1629 
_MakeTxtFmtColl(const String & rFmtName,SwFmt * pDerivedFrom,sal_Bool bBroadcast,sal_Bool bAuto)1630 SwFmt *SwDoc::_MakeTxtFmtColl(const String &rFmtName,
1631 							SwFmt *pDerivedFrom,
1632                             sal_Bool bBroadcast, sal_Bool bAuto)
1633 {
1634     SwTxtFmtColl *pTxtFmtColl = dynamic_cast<SwTxtFmtColl*>(pDerivedFrom);
1635     pTxtFmtColl = MakeTxtFmtColl( rFmtName, pTxtFmtColl, bBroadcast, bAuto );
1636     return dynamic_cast<SwFmt*>(pTxtFmtColl);
1637 }
1638 
1639 
1640 //FEATURE::CONDCOLL
MakeCondTxtFmtColl(const String & rFmtName,SwTxtFmtColl * pDerivedFrom,sal_Bool bBroadcast)1641 SwConditionTxtFmtColl* SwDoc::MakeCondTxtFmtColl( const String &rFmtName,
1642                                                   SwTxtFmtColl *pDerivedFrom,
1643                                                   sal_Bool bBroadcast)
1644 {
1645 	SwConditionTxtFmtColl*pFmtColl = new SwConditionTxtFmtColl( GetAttrPool(),
1646 													rFmtName, pDerivedFrom );
1647 	pTxtFmtCollTbl->Insert(pFmtColl, pTxtFmtCollTbl->Count());
1648 	pFmtColl->SetAuto( sal_False );
1649 	SetModified();
1650 
1651     if (bBroadcast)
1652         BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_PARA,
1653                                 SFX_STYLESHEET_CREATED);
1654 
1655 	return pFmtColl;
1656 }
1657 //FEATURE::CONDCOLL
1658 
1659 // GRF
1660 
MakeGrfFmtColl(const String & rFmtName,SwGrfFmtColl * pDerivedFrom)1661 SwGrfFmtColl* SwDoc::MakeGrfFmtColl( const String &rFmtName,
1662 									 SwGrfFmtColl *pDerivedFrom )
1663 {
1664 	SwGrfFmtColl *pFmtColl = new SwGrfFmtColl( GetAttrPool(), rFmtName,
1665 												pDerivedFrom );
1666 	pGrfFmtCollTbl->Insert( pFmtColl, pGrfFmtCollTbl->Count() );
1667 	pFmtColl->SetAuto( sal_False );
1668 	SetModified();
1669 	return pFmtColl;
1670 }
1671 
DelTxtFmtColl(sal_uInt16 nFmtColl,sal_Bool bBroadcast)1672 void SwDoc::DelTxtFmtColl(sal_uInt16 nFmtColl, sal_Bool bBroadcast)
1673 {
1674 	ASSERT( nFmtColl, "Remove fuer Coll 0." );
1675 
1676 	// Wer hat die zu loeschende als Next
1677 	SwTxtFmtColl *pDel = (*pTxtFmtCollTbl)[nFmtColl];
1678 	if( pDfltTxtFmtColl == pDel )
1679 		return;		// default nie loeschen !!
1680 
1681     if (bBroadcast)
1682         BroadcastStyleOperation(pDel->GetName(), SFX_STYLE_FAMILY_PARA,
1683                                 SFX_STYLESHEET_ERASED);
1684 
1685     if (GetIDocumentUndoRedo().DoesUndo())
1686     {
1687         SwUndoTxtFmtCollDelete * pUndo =
1688             new SwUndoTxtFmtCollDelete(pDel, this);
1689 
1690         GetIDocumentUndoRedo().AppendUndo(pUndo);
1691     }
1692 
1693 	// Die FmtColl austragen
1694 	pTxtFmtCollTbl->Remove(nFmtColl);
1695 	// Next korrigieren
1696 	pTxtFmtCollTbl->ForEach( 1, pTxtFmtCollTbl->Count(),
1697 							&SetTxtFmtCollNext, pDel );
1698 	delete pDel;
1699 	SetModified();
1700 }
1701 
DelTxtFmtColl(SwTxtFmtColl * pColl,sal_Bool bBroadcast)1702 void SwDoc::DelTxtFmtColl( SwTxtFmtColl *pColl, sal_Bool bBroadcast )
1703 {
1704 	sal_uInt16 nFmt = pTxtFmtCollTbl->GetPos( pColl );
1705 	ASSERT( USHRT_MAX != nFmt, "Collection not found," );
1706 	DelTxtFmtColl( nFmt, bBroadcast );
1707 }
1708 
lcl_SetTxtFmtColl(const SwNodePtr & rpNode,void * pArgs)1709 sal_Bool lcl_SetTxtFmtColl( const SwNodePtr& rpNode, void* pArgs )
1710 {
1711     SwCntntNode* pCNd = (SwCntntNode*) rpNode->GetTxtNode();
1712     if ( pCNd )
1713     {
1714         ParaRstFmt* pPara = (ParaRstFmt*) pArgs;
1715 
1716         SwTxtFmtColl* pFmt = static_cast< SwTxtFmtColl* >( pPara->pFmtColl );
1717         if ( pPara->bReset )
1718         {
1719 
1720             lcl_RstAttr( pCNd, pPara );
1721 
1722             // check, if paragraph style has changed
1723             if ( pPara->bResetListAttrs &&
1724                  pFmt != pCNd->GetFmtColl() &&
1725                  pFmt->GetItemState( RES_PARATR_NUMRULE ) == SFX_ITEM_SET )
1726             {
1727                 // --> OD 2009-09-07 #b6876367#
1728                 // Check, if the list style of the paragraph will change.
1729                 bool bChangeOfListStyleAtParagraph( true );
1730                 SwTxtNode* pTNd( dynamic_cast<SwTxtNode*>(pCNd) );
1731                 ASSERT( pTNd,
1732                         "<lcl_SetTxtFmtColl(..)> - text node expected -> crash" );
1733                 {
1734                     SwNumRule* pNumRuleAtParagraph( pTNd->GetNumRule() );
1735                     if ( pNumRuleAtParagraph )
1736                     {
1737                         const SwNumRuleItem& rNumRuleItemAtParagraphStyle =
1738                                                             pFmt->GetNumRule();
1739                         if ( rNumRuleItemAtParagraphStyle.GetValue() ==
1740                                                 pNumRuleAtParagraph->GetName() )
1741                         {
1742                             bChangeOfListStyleAtParagraph = false;
1743                         }
1744                     }
1745                 }
1746 
1747                 if ( bChangeOfListStyleAtParagraph )
1748                 {
1749                     std::auto_ptr< SwRegHistory > pRegH;
1750                     if ( pPara->pHistory )
1751                     {
1752                         pRegH.reset( new SwRegHistory( pTNd, *pTNd, pPara->pHistory ) );
1753                     }
1754 
1755                     pCNd->ResetAttr( RES_PARATR_NUMRULE );
1756 
1757                     // reset all list attributes
1758                     pCNd->ResetAttr( RES_PARATR_LIST_LEVEL );
1759                     pCNd->ResetAttr( RES_PARATR_LIST_ISRESTART );
1760                     pCNd->ResetAttr( RES_PARATR_LIST_RESTARTVALUE );
1761                     pCNd->ResetAttr( RES_PARATR_LIST_ISCOUNTED );
1762                     pCNd->ResetAttr( RES_PARATR_LIST_ID );
1763                 }
1764             }
1765         }
1766 
1767         // erst in die History aufnehmen, damit ggfs. alte Daten
1768 		// gesichert werden koennen
1769 		if( pPara->pHistory )
1770 			pPara->pHistory->Add( pCNd->GetFmtColl(), pCNd->GetIndex(),
1771 									ND_TEXTNODE );
1772 
1773         pCNd->ChgFmtColl( pFmt );
1774 
1775 		pPara->nWhich++;
1776 	}
1777 	return sal_True;
1778 }
1779 
1780 
SetTxtFmtColl(const SwPaM & rRg,SwTxtFmtColl * pFmt,const bool bReset,const bool bResetListAttrs)1781 sal_Bool SwDoc::SetTxtFmtColl(
1782     const SwPaM &rRg,
1783     SwTxtFmtColl *pFmt,
1784     const bool bReset,
1785     const bool bResetListAttrs )
1786 {
1787 	SwDataChanged aTmp( rRg, 0 );
1788 	const SwPosition *pStt = rRg.Start(), *pEnd = rRg.End();
1789 	SwHistory* pHst = 0;
1790 	sal_Bool bRet = sal_True;
1791 
1792     if (GetIDocumentUndoRedo().DoesUndo())
1793     {
1794         SwUndoFmtColl* pUndo = new SwUndoFmtColl( rRg, pFmt,
1795                                                   bReset,
1796                                                   bResetListAttrs );
1797         pHst = pUndo->GetHistory();
1798         GetIDocumentUndoRedo().AppendUndo(pUndo);
1799     }
1800 
1801     ParaRstFmt aPara( pStt, pEnd, pHst );
1802     aPara.pFmtColl = pFmt;
1803     aPara.bReset = bReset;
1804     aPara.bResetListAttrs = bResetListAttrs;
1805 
1806     GetNodes().ForEach( pStt->nNode.GetIndex(), pEnd->nNode.GetIndex()+1,
1807                         lcl_SetTxtFmtColl, &aPara );
1808     if ( !aPara.nWhich )
1809         bRet = sal_False;           // keinen gueltigen Node gefunden
1810 
1811     if ( bRet )
1812     {
1813         SetModified();
1814     }
1815 
1816     return bRet;
1817 }
1818 
1819 
1820 // ---- Kopiere die Formate in sich selbst (SwDoc) ----------------------
1821 
CopyFmt(const SwFmt & rFmt,const SvPtrarr & rFmtArr,FNCopyFmt fnCopyFmt,const SwFmt & rDfltFmt)1822 SwFmt* SwDoc::CopyFmt( const SwFmt& rFmt,
1823 						const SvPtrarr& rFmtArr,
1824 						FNCopyFmt fnCopyFmt, const SwFmt& rDfltFmt )
1825 {
1826 	//  kein-Autoformat || default Format || Collection-Format
1827 	// dann suche danach.
1828 	if( !rFmt.IsAuto() || !rFmt.GetRegisteredIn() )
1829 		for( sal_uInt16 n = 0; n < rFmtArr.Count(); n++ )
1830 		{
1831 			// ist die Vorlage schon im Doc vorhanden ??
1832 			if( ((SwFmt*)rFmtArr[n])->GetName().Equals( rFmt.GetName() ))
1833 				return (SwFmt*)rFmtArr[n];
1834 		}
1835 
1836 	// suche erstmal nach dem "Parent"
1837 	SwFmt* pParent = (SwFmt*)&rDfltFmt;
1838 	if( rFmt.DerivedFrom() && pParent != rFmt.DerivedFrom() )
1839 		pParent = CopyFmt( *rFmt.DerivedFrom(), rFmtArr,
1840 								fnCopyFmt, rDfltFmt );
1841 
1842 	// erzeuge das Format und kopiere die Attribute
1843     // --> OD 2005-01-13 #i40550#
1844     SwFmt* pNewFmt = (this->*fnCopyFmt)( rFmt.GetName(), pParent, sal_False, sal_True );
1845     // <--
1846     pNewFmt->SetAuto( rFmt.IsAuto() );
1847 	pNewFmt->CopyAttrs( rFmt, sal_True );			// kopiere Attribute
1848 
1849 	pNewFmt->SetPoolFmtId( rFmt.GetPoolFmtId() );
1850 	pNewFmt->SetPoolHelpId( rFmt.GetPoolHelpId() );
1851 
1852 	// HelpFile-Id immer auf dflt setzen !!
1853 	pNewFmt->SetPoolHlpFileId( UCHAR_MAX );
1854 
1855 	return pNewFmt;
1856 }
1857 
1858 
1859 // ---- kopiere das Frame-Format --------
CopyFrmFmt(const SwFrmFmt & rFmt)1860 SwFrmFmt* SwDoc::CopyFrmFmt( const SwFrmFmt& rFmt )
1861 {
1862 
1863     return (SwFrmFmt*)CopyFmt( rFmt, *GetFrmFmts(), &SwDoc::_MakeFrmFmt,
1864                                 *GetDfltFrmFmt() );
1865 }
1866 
1867 // ---- kopiere das Char-Format --------
CopyCharFmt(const SwCharFmt & rFmt)1868 SwCharFmt* SwDoc::CopyCharFmt( const SwCharFmt& rFmt )
1869 {
1870 	return (SwCharFmt*)CopyFmt( rFmt, *GetCharFmts(),
1871 								&SwDoc::_MakeCharFmt,
1872 								*GetDfltCharFmt() );
1873 }
1874 
1875 
1876 // --- Kopiere TextNodes ----
1877 
CopyTxtColl(const SwTxtFmtColl & rColl)1878 SwTxtFmtColl* SwDoc::CopyTxtColl( const SwTxtFmtColl& rColl )
1879 {
1880 	SwTxtFmtColl* pNewColl = FindTxtFmtCollByName( rColl.GetName() );
1881 	if( pNewColl )
1882 		return pNewColl;
1883 
1884 	// suche erstmal nach dem "Parent"
1885 	SwTxtFmtColl* pParent = pDfltTxtFmtColl;
1886 	if( pParent != rColl.DerivedFrom() )
1887 		pParent = CopyTxtColl( *(SwTxtFmtColl*)rColl.DerivedFrom() );
1888 
1889 
1890 //FEATURE::CONDCOLL
1891 	if( RES_CONDTXTFMTCOLL == rColl.Which() )
1892 	{
1893 		pNewColl = new SwConditionTxtFmtColl( GetAttrPool(), rColl.GetName(),
1894 												pParent);
1895 		pTxtFmtCollTbl->Insert( pNewColl, pTxtFmtCollTbl->Count() );
1896 		pNewColl->SetAuto( sal_False );
1897 		SetModified();
1898 
1899 		// Kopiere noch die Bedingungen
1900 		((SwConditionTxtFmtColl*)pNewColl)->SetConditions(
1901 							((SwConditionTxtFmtColl&)rColl).GetCondColls() );
1902 	}
1903 	else
1904 //FEATURE::CONDCOLL
1905 		pNewColl = MakeTxtFmtColl( rColl.GetName(), pParent );
1906 
1907 	// kopiere jetzt noch die Auto-Formate oder kopiere die Attribute
1908 	pNewColl->CopyAttrs( rColl, sal_True );
1909 
1910     // setze noch den Outline-Level
1911     if ( rColl.IsAssignedToListLevelOfOutlineStyle() )
1912         pNewColl->AssignToListLevelOfOutlineStyle( rColl.GetAssignedOutlineStyleLevel() );
1913 
1914     pNewColl->SetPoolFmtId( rColl.GetPoolFmtId() );
1915     pNewColl->SetPoolHelpId( rColl.GetPoolHelpId() );
1916 
1917 	// HelpFile-Id immer auf dflt setzen !!
1918 	pNewColl->SetPoolHlpFileId( UCHAR_MAX );
1919 
1920 	if( &rColl.GetNextTxtFmtColl() != &rColl )
1921 		pNewColl->SetNextTxtFmtColl( *CopyTxtColl( rColl.GetNextTxtFmtColl() ));
1922 
1923 	// ggfs. die NumRule erzeugen
1924 	if( this != rColl.GetDoc() )
1925 	{
1926 		const SfxPoolItem* pItem;
1927 		if( SFX_ITEM_SET == pNewColl->GetItemState( RES_PARATR_NUMRULE,
1928 			sal_False, &pItem ))
1929 		{
1930 			const SwNumRule* pRule;
1931 			const String& rName = ((SwNumRuleItem*)pItem)->GetValue();
1932 			if( rName.Len() &&
1933 				0 != ( pRule = rColl.GetDoc()->FindNumRulePtr( rName )) &&
1934 				!pRule->IsAutoRule() )
1935 			{
1936 				SwNumRule* pDestRule = FindNumRulePtr( rName );
1937 				if( pDestRule )
1938 					pDestRule->SetInvalidRule( sal_True );
1939 				else
1940 					MakeNumRule( rName, pRule );
1941 			}
1942 		}
1943 	}
1944 	return pNewColl;
1945 }
1946 
1947 // --- Kopiere GrafikNodes ----
1948 
CopyGrfColl(const SwGrfFmtColl & rColl)1949 SwGrfFmtColl* SwDoc::CopyGrfColl( const SwGrfFmtColl& rColl )
1950 {
1951 	SwGrfFmtColl* pNewColl = FindGrfFmtCollByName( rColl.GetName() );
1952 	if( pNewColl )
1953 		return pNewColl;
1954 
1955 	// suche erstmal nach dem "Parent"
1956 	SwGrfFmtColl* pParent = pDfltGrfFmtColl;
1957 	if( pParent != rColl.DerivedFrom() )
1958 		pParent = CopyGrfColl( *(SwGrfFmtColl*)rColl.DerivedFrom() );
1959 
1960 	// falls nicht, so kopiere sie
1961 	pNewColl = MakeGrfFmtColl( rColl.GetName(), pParent );
1962 
1963 	// noch die Attribute kopieren
1964 	pNewColl->CopyAttrs( rColl );
1965 
1966 	pNewColl->SetPoolFmtId( rColl.GetPoolFmtId() );
1967 	pNewColl->SetPoolHelpId( rColl.GetPoolHelpId() );
1968 
1969 	// HelpFile-Id immer auf dflt setzen !!
1970 	pNewColl->SetPoolHlpFileId( UCHAR_MAX );
1971 
1972 	return pNewColl;
1973 }
1974 
lcl_FindPageDesc(const SwPageDescs & rArr,const String & rName)1975 SwPageDesc* lcl_FindPageDesc( const SwPageDescs& rArr, const String& rName )
1976 {
1977 	for( sal_uInt16 n = rArr.Count(); n; )
1978 	{
1979 		SwPageDesc* pDesc = rArr[ --n ];
1980 		if( pDesc->GetName() == rName )
1981 			return pDesc;
1982 	}
1983 	return 0;
1984 }
1985 
CopyFmtArr(const SvPtrarr & rSourceArr,SvPtrarr & rDestArr,FNCopyFmt fnCopyFmt,SwFmt & rDfltFmt)1986 void SwDoc::CopyFmtArr( const SvPtrarr& rSourceArr,
1987 						SvPtrarr& rDestArr,
1988 						FNCopyFmt fnCopyFmt,
1989 						SwFmt& rDfltFmt )
1990 {
1991 	sal_uInt16 nSrc;
1992 	SwFmt* pSrc, *pDest;
1993 
1994 	// 1. Schritt alle Formate anlegen (das 0. ueberspringen - Default!)
1995 	for( nSrc = rSourceArr.Count(); nSrc > 1; )
1996 	{
1997 		pSrc = (SwFmt*)rSourceArr[ --nSrc ];
1998 		if( pSrc->IsDefault() || pSrc->IsAuto() )
1999 			continue;
2000 
2001 		if( 0 == FindFmtByName( rDestArr, pSrc->GetName() ) )
2002 		{
2003 			if( RES_CONDTXTFMTCOLL == pSrc->Which() )
2004                 MakeCondTxtFmtColl( pSrc->GetName(), (SwTxtFmtColl*)&rDfltFmt );
2005 			else
2006                 // --> OD 2005-01-13 #i40550#
2007                 (this->*fnCopyFmt)( pSrc->GetName(), &rDfltFmt, sal_False, sal_True );
2008                 // <--
2009 		}
2010 	}
2011 
2012 	// 2. Schritt alle Attribute kopieren, richtige Parents setzen
2013 	for( nSrc = rSourceArr.Count(); nSrc > 1; )
2014 	{
2015 		pSrc = (SwFmt*)rSourceArr[ --nSrc ];
2016 		if( pSrc->IsDefault() || pSrc->IsAuto() )
2017 			continue;
2018 
2019 		pDest = FindFmtByName( rDestArr, pSrc->GetName() );
2020 		pDest->SetAuto( sal_False );
2021 		pDest->DelDiffs( *pSrc );
2022 
2023         // #i94285#: existing <SwFmtPageDesc> instance, before copying attributes
2024         const SfxPoolItem* pItem;
2025         if( &GetAttrPool() != pSrc->GetAttrSet().GetPool() &&
2026             SFX_ITEM_SET == pSrc->GetAttrSet().GetItemState(
2027             RES_PAGEDESC, sal_False, &pItem ) &&
2028             ((SwFmtPageDesc*)pItem)->GetPageDesc() )
2029         {
2030             SwFmtPageDesc aPageDesc( *(SwFmtPageDesc*)pItem );
2031             const String& rNm = aPageDesc.GetPageDesc()->GetName();
2032             SwPageDesc* pPageDesc = ::lcl_FindPageDesc( aPageDescs, rNm );
2033             if( !pPageDesc )
2034             {
2035                 pPageDesc = aPageDescs[ MakePageDesc( rNm ) ];
2036             }
2037             aPageDesc.RegisterToPageDesc( *pPageDesc );
2038             SwAttrSet aTmpAttrSet( pSrc->GetAttrSet() );
2039             aTmpAttrSet.Put( aPageDesc );
2040             pDest->SetFmtAttr( aTmpAttrSet );
2041         }
2042         else
2043         {
2044             pDest->SetFmtAttr( pSrc->GetAttrSet() );
2045         }
2046 
2047 		pDest->SetPoolFmtId( pSrc->GetPoolFmtId() );
2048 		pDest->SetPoolHelpId( pSrc->GetPoolHelpId() );
2049 
2050 		// HelpFile-Id immer auf dflt setzen !!
2051 		pDest->SetPoolHlpFileId( UCHAR_MAX );
2052 
2053 		if( pSrc->DerivedFrom() )
2054 			pDest->SetDerivedFrom( FindFmtByName( rDestArr,
2055 										pSrc->DerivedFrom()->GetName() ) );
2056 		if( RES_TXTFMTCOLL == pSrc->Which() ||
2057 			RES_CONDTXTFMTCOLL == pSrc->Which() )
2058 		{
2059 			SwTxtFmtColl* pSrcColl = (SwTxtFmtColl*)pSrc,
2060 						* pDstColl = (SwTxtFmtColl*)pDest;
2061 			if( &pSrcColl->GetNextTxtFmtColl() != pSrcColl )
2062 				pDstColl->SetNextTxtFmtColl( *(SwTxtFmtColl*)FindFmtByName(
2063 					rDestArr, pSrcColl->GetNextTxtFmtColl().GetName() ) );
2064 
2065 			// setze noch den Outline-Level
2066 			if(pSrcColl->IsAssignedToListLevelOfOutlineStyle())
2067 				pDstColl->AssignToListLevelOfOutlineStyle(pSrcColl->GetAssignedOutlineStyleLevel());
2068 
2069 //FEATURE::CONDCOLL
2070 			if( RES_CONDTXTFMTCOLL == pSrc->Which() )
2071 				// Kopiere noch die Bedingungen
2072 				// aber erst die alten loeschen!
2073 				((SwConditionTxtFmtColl*)pDstColl)->SetConditions(
2074 							((SwConditionTxtFmtColl*)pSrc)->GetCondColls() );
2075 //FEATURE::CONDCOLL
2076 		}
2077 	}
2078 }
2079 
CopyPageDescHeaderFooterImpl(bool bCpyHeader,const SwFrmFmt & rSrcFmt,SwFrmFmt & rDestFmt)2080 void SwDoc::CopyPageDescHeaderFooterImpl( bool bCpyHeader,
2081 								const SwFrmFmt& rSrcFmt, SwFrmFmt& rDestFmt )
2082 {
2083 	// jetzt noch Header-/Footer-Attribute richtig behandeln
2084 	// Contenten Nodes Dokumentuebergreifend kopieren!
2085 	sal_uInt16 nAttr = static_cast<sal_uInt16>( bCpyHeader ? RES_HEADER : RES_FOOTER );
2086 	const SfxPoolItem* pItem;
2087 	if( SFX_ITEM_SET != rSrcFmt.GetAttrSet().GetItemState( nAttr, sal_False, &pItem ))
2088 		return ;
2089 
2090 	// Im Header steht noch der Verweis auf das Format aus dem
2091 	// anderen Document!!
2092 	SfxPoolItem* pNewItem = pItem->Clone();
2093 
2094 	SwFrmFmt* pOldFmt;
2095 	if( bCpyHeader )
2096 		 pOldFmt = ((SwFmtHeader*)pNewItem)->GetHeaderFmt();
2097 	else
2098 		 pOldFmt = ((SwFmtFooter*)pNewItem)->GetFooterFmt();
2099 
2100 	if( pOldFmt )
2101 	{
2102 		SwFrmFmt* pNewFmt = new SwFrmFmt( GetAttrPool(), "CpyDesc",
2103 											GetDfltFrmFmt() );
2104 		pNewFmt->CopyAttrs( *pOldFmt, sal_True );
2105 
2106 		if( SFX_ITEM_SET == pNewFmt->GetAttrSet().GetItemState(
2107 			RES_CNTNT, sal_False, &pItem ))
2108 		{
2109 			SwFmtCntnt* pCntnt = (SwFmtCntnt*)pItem;
2110 			if( pCntnt->GetCntntIdx() )
2111 			{
2112 				SwNodeIndex aTmpIdx( GetNodes().GetEndOfAutotext() );
2113 				const SwNodes& rSrcNds = rSrcFmt.GetDoc()->GetNodes();
2114 				SwStartNode* pSttNd = GetNodes().MakeEmptySection( aTmpIdx,
2115 												bCpyHeader
2116 													? SwHeaderStartNode
2117 													: SwFooterStartNode );
2118 				const SwNode& rCSttNd = pCntnt->GetCntntIdx()->GetNode();
2119 				SwNodeRange aRg( rCSttNd, 0, *rCSttNd.EndOfSectionNode() );
2120 				aTmpIdx = *pSttNd->EndOfSectionNode();
2121 				rSrcNds._Copy( aRg, aTmpIdx );
2122 				aTmpIdx = *pSttNd;
2123                 rSrcFmt.GetDoc()->CopyFlyInFlyImpl( aRg, 0, aTmpIdx );
2124                 pNewFmt->SetFmtAttr( SwFmtCntnt( pSttNd ));
2125 			}
2126 			else
2127                 pNewFmt->ResetFmtAttr( RES_CNTNT );
2128 		}
2129 		if( bCpyHeader )
2130             ((SwFmtHeader*)pNewItem)->RegisterToFormat(*pNewFmt);
2131 		else
2132             ((SwFmtFooter*)pNewItem)->RegisterToFormat(*pNewFmt);
2133         rDestFmt.SetFmtAttr( *pNewItem );
2134 	}
2135 	delete pNewItem;
2136 }
2137 
CopyPageDesc(const SwPageDesc & rSrcDesc,SwPageDesc & rDstDesc,sal_Bool bCopyPoolIds)2138 void SwDoc::CopyPageDesc( const SwPageDesc& rSrcDesc, SwPageDesc& rDstDesc,
2139 							sal_Bool bCopyPoolIds )
2140 {
2141 	sal_Bool bNotifyLayout = sal_False;
2142 	SwRootFrm* pTmpRoot = GetCurrentLayout();//swmod 080219
2143 
2144 	rDstDesc.SetLandscape( rSrcDesc.GetLandscape() );
2145 	rDstDesc.SetNumType( rSrcDesc.GetNumType() );
2146 	if( rDstDesc.ReadUseOn() != rSrcDesc.ReadUseOn() )
2147 	{
2148 		rDstDesc.WriteUseOn( rSrcDesc.ReadUseOn() );
2149 		bNotifyLayout = sal_True;
2150 	}
2151 
2152 	if( bCopyPoolIds )
2153 	{
2154 		rDstDesc.SetPoolFmtId( rSrcDesc.GetPoolFmtId() );
2155 		rDstDesc.SetPoolHelpId( rSrcDesc.GetPoolHelpId() );
2156 		// HelpFile-Id immer auf dflt setzen !!
2157 		rDstDesc.SetPoolHlpFileId( UCHAR_MAX );
2158 	}
2159 
2160 	if( rSrcDesc.GetFollow() != &rSrcDesc )
2161 	{
2162 		SwPageDesc* pFollow = ::lcl_FindPageDesc( aPageDescs,
2163 									rSrcDesc.GetFollow()->GetName() );
2164 		if( !pFollow )
2165 		{
2166 			// dann mal kopieren
2167 			sal_uInt16 nPos = MakePageDesc( rSrcDesc.GetFollow()->GetName() );
2168 			pFollow = aPageDescs[ nPos ];
2169 			CopyPageDesc( *rSrcDesc.GetFollow(), *pFollow );
2170 		}
2171 		rDstDesc.SetFollow( pFollow );
2172 		bNotifyLayout = sal_True;
2173 	}
2174 
2175 	// die Header/Footer-Attribute werden gesondert kopiert, die Content-
2176 	// Sections muessen vollstaendig mitgenommen werden!
2177 	{
2178 		SfxItemSet aAttrSet( rSrcDesc.GetMaster().GetAttrSet() );
2179 		aAttrSet.ClearItem( RES_HEADER );
2180 		aAttrSet.ClearItem( RES_FOOTER );
2181 
2182 		rDstDesc.GetMaster().DelDiffs( aAttrSet );
2183         rDstDesc.GetMaster().SetFmtAttr( aAttrSet );
2184 
2185 		aAttrSet.ClearItem();
2186 		aAttrSet.Put( rSrcDesc.GetLeft().GetAttrSet() );
2187 		aAttrSet.ClearItem( RES_HEADER );
2188 		aAttrSet.ClearItem( RES_FOOTER );
2189 
2190 		rDstDesc.GetLeft().DelDiffs( aAttrSet );
2191         rDstDesc.GetLeft().SetFmtAttr( aAttrSet );
2192 	}
2193 
2194 	CopyHeader( rSrcDesc.GetMaster(), rDstDesc.GetMaster() );
2195 	CopyFooter( rSrcDesc.GetMaster(), rDstDesc.GetMaster() );
2196 	if( !rDstDesc.IsHeaderShared() )
2197 		CopyHeader( rSrcDesc.GetLeft(), rDstDesc.GetLeft() );
2198 	else
2199         rDstDesc.GetLeft().SetFmtAttr( rDstDesc.GetMaster().GetHeader() );
2200 
2201 	if( !rDstDesc.IsFooterShared() )
2202 		CopyFooter( rSrcDesc.GetLeft(), rDstDesc.GetLeft() );
2203 	else
2204         rDstDesc.GetLeft().SetFmtAttr( rDstDesc.GetMaster().GetFooter() );
2205 
2206 	if( bNotifyLayout && pTmpRoot )
2207 	{
2208 		std::set<SwRootFrm*> aAllLayouts = GetAllLayouts();//swmod 080225
2209 		std::for_each( aAllLayouts.begin(), aAllLayouts.end(),std::mem_fun(&SwRootFrm::AllCheckPageDescs));//swmod 080226
2210 	}
2211 
2212 	//Wenn sich FussnotenInfo veraendert, so werden die Seiten
2213 	//angetriggert.
2214 	if( !(rDstDesc.GetFtnInfo() == rSrcDesc.GetFtnInfo()) )
2215 	{
2216 		rDstDesc.SetFtnInfo( rSrcDesc.GetFtnInfo() );
2217 		SwMsgPoolItem  aInfo( RES_PAGEDESC_FTNINFO );
2218 		{
2219             rDstDesc.GetMaster().ModifyBroadcast( &aInfo, 0, TYPE(SwFrm) );
2220 		}
2221 		{
2222             rDstDesc.GetLeft().ModifyBroadcast( &aInfo, 0, TYPE(SwFrm) );
2223 		}
2224 	}
2225 }
2226 
ReplaceStyles(SwDoc & rSource)2227 void SwDoc::ReplaceStyles( SwDoc& rSource )
2228 {
2229     ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
2230 
2231 	CopyFmtArr( *rSource.pCharFmtTbl, *pCharFmtTbl,
2232 				&SwDoc::_MakeCharFmt, *pDfltCharFmt );
2233 	CopyFmtArr( *rSource.pFrmFmtTbl, *pFrmFmtTbl,
2234 				&SwDoc::_MakeFrmFmt, *pDfltFrmFmt );
2235 	CopyFmtArr( *rSource.pTxtFmtCollTbl, *pTxtFmtCollTbl,
2236 				&SwDoc::_MakeTxtFmtColl, *pDfltTxtFmtColl );
2237 
2238 	// und jetzt noch die Seiten-Vorlagen
2239 	sal_uInt16 nCnt = rSource.aPageDescs.Count();
2240 	if( nCnt )
2241 	{
2242 		// ein anderes Doc -> Numberformatter muessen gemergt werden
2243 		SwTblNumFmtMerge aTNFM( rSource, *this );
2244 
2245 		// 1. Schritt alle Formate anlegen (das 0. ueberspringen - Default!)
2246 		while( nCnt )
2247 		{
2248 			SwPageDesc *pSrc = rSource.aPageDescs[ --nCnt ];
2249 			if( 0 == ::lcl_FindPageDesc( aPageDescs, pSrc->GetName() ) )
2250 				MakePageDesc( pSrc->GetName() );
2251 		}
2252 
2253 		// 2. Schritt alle Attribute kopieren, richtige Parents setzen
2254 		for( nCnt = rSource.aPageDescs.Count(); nCnt; )
2255 		{
2256 			SwPageDesc *pSrc = rSource.aPageDescs[ --nCnt ];
2257 			CopyPageDesc( *pSrc, *::lcl_FindPageDesc( aPageDescs, pSrc->GetName() ));
2258 		}
2259 	}
2260 
2261 	//JP 08.04.99: und dann sind da noch die Numerierungs-Vorlagen
2262 	nCnt = rSource.GetNumRuleTbl().Count();
2263 	if( nCnt )
2264 	{
2265 		const SwNumRuleTbl& rArr = rSource.GetNumRuleTbl();
2266 		for( sal_uInt16 n = 0; n < nCnt; ++n )
2267 		{
2268 			const SwNumRule& rR = *rArr[ n ];
2269 			if( !rR.IsAutoRule() )
2270 			{
2271 				SwNumRule* pNew = FindNumRulePtr( rR.GetName());
2272 				if( pNew )
2273 					pNew->CopyNumRule( this, rR );
2274 				else
2275 					MakeNumRule( rR.GetName(), &rR );
2276 			}
2277 		}
2278 	}
2279 
2280     if (undoGuard.UndoWasEnabled())
2281     {
2282         // nodes array was modified!
2283         GetIDocumentUndoRedo().DelAllUndoObj();
2284     }
2285 
2286 	SetModified();
2287 }
2288 
FindFmtByName(const SvPtrarr & rFmtArr,const String & rName) const2289 SwFmt* SwDoc::FindFmtByName( const SvPtrarr& rFmtArr,
2290 									const String& rName ) const
2291 {
2292 	SwFmt* pFnd = 0;
2293 	for( sal_uInt16 n = 0; n < rFmtArr.Count(); n++ )
2294 	{
2295 		// ist die Vorlage schon im Doc vorhanden ??
2296 		if( ((SwFmt*)rFmtArr[n])->GetName() == rName )
2297 		{
2298 			pFnd = (SwFmt*)rFmtArr[n];
2299 			break;
2300 		}
2301 	}
2302 	return pFnd;
2303 }
2304 
MoveLeftMargin(const SwPaM & rPam,sal_Bool bRight,sal_Bool bModulus)2305 void SwDoc::MoveLeftMargin( const SwPaM& rPam, sal_Bool bRight, sal_Bool bModulus )
2306 {
2307 	SwHistory* pHistory = 0;
2308     if (GetIDocumentUndoRedo().DoesUndo())
2309     {
2310 		SwUndoMoveLeftMargin* pUndo = new SwUndoMoveLeftMargin( rPam, bRight,
2311 																bModulus );
2312         pHistory = &pUndo->GetHistory();
2313         GetIDocumentUndoRedo().AppendUndo( pUndo );
2314     }
2315 
2316 	const SvxTabStopItem& rTabItem = (SvxTabStopItem&)GetDefault( RES_PARATR_TABSTOP );
2317 	sal_uInt16 nDefDist = rTabItem.Count() ?
2318         static_cast<sal_uInt16>(rTabItem[0].GetTabPos()) : 1134;
2319 	const SwPosition &rStt = *rPam.Start(), &rEnd = *rPam.End();
2320 	SwNodeIndex aIdx( rStt.nNode );
2321 	while( aIdx <= rEnd.nNode )
2322 	{
2323 		SwTxtNode* pTNd = aIdx.GetNode().GetTxtNode();
2324 		if( pTNd )
2325 		{
2326             SvxLRSpaceItem aLS( (SvxLRSpaceItem&)pTNd->SwCntntNode::GetAttr( RES_LR_SPACE ) );
2327 
2328             // --> FME 2008-09-16 #i93873# See also lcl_MergeListLevelIndentAsLRSpaceItem in thints.cxx
2329             if ( pTNd->AreListLevelIndentsApplicable() )
2330             {
2331                 const SwNumRule* pRule = pTNd->GetNumRule();
2332                 if ( pRule )
2333                 {
2334                     const int nListLevel = pTNd->GetActualListLevel();
2335                     if ( nListLevel >= 0 )
2336                     {
2337                         const SwNumFmt& rFmt = pRule->Get(static_cast<sal_uInt16>(nListLevel));
2338                         if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
2339                         {
2340                             aLS.SetTxtLeft( rFmt.GetIndentAt() );
2341                             aLS.SetTxtFirstLineOfst( static_cast<short>(rFmt.GetFirstLineIndent()) );
2342                         }
2343                     }
2344                 }
2345             }
2346 
2347 			long nNext = aLS.GetTxtLeft();
2348 			if( bModulus )
2349 				nNext = ( nNext / nDefDist ) * nDefDist;
2350 
2351 			if( bRight )
2352 				nNext += nDefDist;
2353 			else
2354 				nNext -= nDefDist;
2355 
2356             aLS.SetTxtLeft( nNext );
2357 
2358 			SwRegHistory aRegH( pTNd, *pTNd, pHistory );
2359             pTNd->SetAttr( aLS );
2360 		}
2361 		aIdx++;
2362 	}
2363 	SetModified();
2364 }
2365 
DontExpandFmt(const SwPosition & rPos,sal_Bool bFlag)2366 sal_Bool SwDoc::DontExpandFmt( const SwPosition& rPos, sal_Bool bFlag )
2367 {
2368 	sal_Bool bRet = sal_False;
2369 	SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
2370 	if( pTxtNd )
2371 	{
2372 		bRet = pTxtNd->DontExpandFmt( rPos.nContent, bFlag );
2373         if( bRet && GetIDocumentUndoRedo().DoesUndo() )
2374         {
2375             GetIDocumentUndoRedo().AppendUndo( new SwUndoDontExpandFmt(rPos) );
2376         }
2377     }
2378 	return bRet;
2379 }
2380 
MakeTableBoxFmt()2381 SwTableBoxFmt* SwDoc::MakeTableBoxFmt()
2382 {
2383 	SwTableBoxFmt* pFmt = new SwTableBoxFmt( GetAttrPool(), aEmptyStr,
2384 												pDfltFrmFmt );
2385 	SetModified();
2386 	return pFmt;
2387 }
2388 
MakeTableLineFmt()2389 SwTableLineFmt* SwDoc::MakeTableLineFmt()
2390 {
2391 	SwTableLineFmt* pFmt = new SwTableLineFmt( GetAttrPool(), aEmptyStr,
2392 												pDfltFrmFmt );
2393 	SetModified();
2394 	return pFmt;
2395 }
2396 
_CreateNumberFormatter()2397 void SwDoc::_CreateNumberFormatter()
2398 {
2399 	RTL_LOGFILE_CONTEXT_AUTHOR( aLog, "SW", "JP93722",  "SwDoc::_CreateNumberFormatter" );
2400 
2401 	ASSERT( !pNumberFormatter, "ist doch schon vorhanden" );
2402 
2403 
2404 	LanguageType eLang = LANGUAGE_SYSTEM; //System::GetLanguage();
2405 /*				((const SvxLanguageItem&)GetAttrPool().
2406 					GetDefaultItem( RES_CHRATR_LANGUAGE )).GetLanguage();
2407 */
2408 	Reference< XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
2409 	pNumberFormatter = new SvNumberFormatter( xMSF, eLang );
2410 	pNumberFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_FORMAT_INTL );
2411 	pNumberFormatter->SetYear2000(static_cast<sal_uInt16>(::utl::MiscCfg().GetYear2000()));
2412 
2413 }
2414 
SwTblNumFmtMerge(const SwDoc & rSrc,SwDoc & rDest)2415 SwTblNumFmtMerge::SwTblNumFmtMerge( const SwDoc& rSrc, SwDoc& rDest )
2416 	: pNFmt( 0 )
2417 {
2418 	// ein anderes Doc -> Numberformatter muessen gemergt werden
2419 	SvNumberFormatter* pN;
2420 	if( &rSrc != &rDest && 0 != ( pN = ((SwDoc&)rSrc).GetNumberFormatter( sal_False ) ))
2421 		( pNFmt = rDest.GetNumberFormatter( sal_True ))->MergeFormatter( *pN );
2422 
2423 	if( &rSrc != &rDest )
2424 		((SwGetRefFieldType*)rSrc.GetSysFldType( RES_GETREFFLD ))->
2425 			MergeWithOtherDoc( rDest );
2426 }
2427 
~SwTblNumFmtMerge()2428 SwTblNumFmtMerge::~SwTblNumFmtMerge()
2429 {
2430 	if( pNFmt )
2431 		pNFmt->ClearMergeTable();
2432 }
2433 
2434 
SetTxtFmtCollByAutoFmt(const SwPosition & rPos,sal_uInt16 nPoolId,const SfxItemSet * pSet)2435 void SwDoc::SetTxtFmtCollByAutoFmt( const SwPosition& rPos, sal_uInt16 nPoolId,
2436 									const SfxItemSet* pSet )
2437 {
2438 	SwPaM aPam( rPos );
2439 	SwTxtNode* pTNd = rPos.nNode.GetNode().GetTxtNode();
2440 
2441 	if( mbIsAutoFmtRedline && pTNd )
2442 	{
2443 		// dann das Redline Object anlegen
2444 		const SwTxtFmtColl& rColl = *pTNd->GetTxtColl();
2445 		SwRedline* pRedl = new SwRedline( nsRedlineType_t::REDLINE_FMTCOLL, aPam );
2446 		pRedl->SetMark();
2447 
2448 		// interressant sind nur die Items, die vom Set NICHT wieder
2449 		// in den Node gesetzt werden. Also muss man die Differenz nehmen
2450 		SwRedlineExtraData_FmtColl aExtraData( rColl.GetName(),
2451 												rColl.GetPoolFmtId() );
2452         if( pSet && pTNd->HasSwAttrSet() )
2453 		{
2454 			SfxItemSet aTmp( *pTNd->GetpSwAttrSet() );
2455 			aTmp.Differentiate( *pSet );
2456 			// das Adjust Item behalten wir extra
2457 			const SfxPoolItem* pItem;
2458 			if( SFX_ITEM_SET == pTNd->GetpSwAttrSet()->GetItemState(
2459 					RES_PARATR_ADJUST, sal_False, &pItem ))
2460 				aTmp.Put( *pItem );
2461 			aExtraData.SetItemSet( aTmp );
2462 		}
2463 		pRedl->SetExtraData( &aExtraData );
2464 
2465 // !!!!!!!!! Undo fehlt noch !!!!!!!!!!!!!!!!!!
2466 		AppendRedline( pRedl, true );
2467 	}
2468 
2469 	SetTxtFmtColl( aPam, GetTxtCollFromPool( nPoolId ) );
2470 
2471 	if( pSet && pTNd && pSet->Count() )
2472 	{
2473 		aPam.SetMark();
2474 		aPam.GetMark()->nContent.Assign( pTNd, pTNd->GetTxt().Len() );
2475         InsertItemSet( aPam, *pSet, 0 );
2476     }
2477 }
2478 
SetFmtItemByAutoFmt(const SwPaM & rPam,const SfxItemSet & rSet)2479 void SwDoc::SetFmtItemByAutoFmt( const SwPaM& rPam, const SfxItemSet& rSet )
2480 {
2481 	SwTxtNode* pTNd = rPam.GetPoint()->nNode.GetNode().GetTxtNode();
2482 
2483 	RedlineMode_t eOld = GetRedlineMode();
2484 
2485 	if( mbIsAutoFmtRedline && pTNd )
2486 	{
2487 		// dann das Redline Object anlegen
2488 		SwRedline* pRedl = new SwRedline( nsRedlineType_t::REDLINE_FORMAT, rPam );
2489 		if( !pRedl->HasMark() )
2490 			pRedl->SetMark();
2491 
2492 		// interressant sind nur die Items, die vom Set NICHT wieder
2493 		// in den Node gesetzt werden. Also muss man die Differenz nehmen
2494 		SwRedlineExtraData_Format aExtraData( rSet );
2495 
2496 /*
2497         if( pSet && pTNd->HasSwAttrSet() )
2498 		{
2499 			SfxItemSet aTmp( *pTNd->GetpSwAttrSet() );
2500 			aTmp.Differentiate( *pSet );
2501 			// das Adjust Item behalten wir extra
2502 			const SfxPoolItem* pItem;
2503 			if( SFX_ITEM_SET == pTNd->GetpSwAttrSet()->GetItemState(
2504 					RES_PARATR_ADJUST, sal_False, &pItem ))
2505 				aTmp.Put( *pItem );
2506 			aExtraData.SetItemSet( aTmp );
2507 		}
2508 */
2509 		pRedl->SetExtraData( &aExtraData );
2510 
2511 // !!!!!!!!! Undo fehlt noch !!!!!!!!!!!!!!!!!!
2512 		AppendRedline( pRedl, true );
2513 
2514 		SetRedlineMode_intern( (RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
2515 	}
2516 
2517     InsertItemSet( rPam, rSet, nsSetAttrMode::SETATTR_DONTEXPAND );
2518 	SetRedlineMode_intern( eOld );
2519 }
2520 
ChgFmt(SwFmt & rFmt,const SfxItemSet & rSet)2521 void SwDoc::ChgFmt(SwFmt & rFmt, const SfxItemSet & rSet)
2522 {
2523     if (GetIDocumentUndoRedo().DoesUndo())
2524     {
2525         // copying <rSet> to <aSet>
2526         SfxItemSet aSet(rSet);
2527         // remove from <aSet> all items, which are already set at the format
2528         aSet.Differentiate(rFmt.GetAttrSet());
2529         // <aSet> contains now all *new* items for the format
2530 
2531         // copying current format item set to <aOldSet>
2532         SfxItemSet aOldSet(rFmt.GetAttrSet());
2533         // insert new items into <aOldSet>
2534         aOldSet.Put(aSet);
2535         // invalidate all new items in <aOldSet> in order to clear these items,
2536         // if the undo action is triggered.
2537         {
2538             SfxItemIter aIter(aSet);
2539 
2540             const SfxPoolItem * pItem = aIter.FirstItem();
2541             while (pItem != NULL)
2542             {
2543                 aOldSet.InvalidateItem(pItem->Which());
2544 
2545                 pItem = aIter.NextItem();
2546             }
2547         }
2548 
2549         SwUndo * pUndo = new SwUndoFmtAttr(aOldSet, rFmt);
2550 
2551         GetIDocumentUndoRedo().AppendUndo(pUndo);
2552     }
2553 
2554     rFmt.SetFmtAttr(rSet);
2555 }
2556 
RenameFmt(SwFmt & rFmt,const String & sNewName,sal_Bool bBroadcast)2557 void SwDoc::RenameFmt(SwFmt & rFmt, const String & sNewName,
2558                       sal_Bool bBroadcast)
2559 {
2560     SfxStyleFamily eFamily = SFX_STYLE_FAMILY_ALL;
2561 
2562     if (GetIDocumentUndoRedo().DoesUndo())
2563     {
2564         SwUndo * pUndo = NULL;
2565 
2566         switch (rFmt.Which())
2567         {
2568         case RES_CHRFMT:
2569             pUndo = new SwUndoRenameCharFmt(rFmt.GetName(), sNewName, this);
2570             eFamily = SFX_STYLE_FAMILY_PARA;
2571             break;
2572         case RES_TXTFMTCOLL:
2573             pUndo = new SwUndoRenameFmtColl(rFmt.GetName(), sNewName, this);
2574             eFamily = SFX_STYLE_FAMILY_CHAR;
2575             break;
2576         case RES_FRMFMT:
2577             pUndo = new SwUndoRenameFrmFmt(rFmt.GetName(), sNewName, this);
2578             eFamily = SFX_STYLE_FAMILY_FRAME;
2579             break;
2580 
2581         default:
2582             break;
2583         }
2584 
2585         if (pUndo)
2586         {
2587             GetIDocumentUndoRedo().AppendUndo(pUndo);
2588         }
2589     }
2590 
2591     rFmt.SetName(sNewName);
2592 
2593     if (bBroadcast)
2594         BroadcastStyleOperation(sNewName, eFamily, SFX_STYLESHEET_MODIFIED);
2595 }
2596 
2597 // --> OD 2006-09-27 #i69627#
2598 namespace docfunc
2599 {
HasOutlineStyleToBeWrittenAsNormalListStyle(SwDoc & rDoc)2600     bool HasOutlineStyleToBeWrittenAsNormalListStyle( SwDoc& rDoc )
2601     {
2602         // If a parent paragraph style of one of the parargraph styles, which
2603         // are assigned to the list levels of the outline style, has a list style
2604         // set or inherits a list style from its parent style, the outline style
2605         // has to be written as a normal list style to the OpenDocument file
2606         // format or the OpenOffice.org file format.
2607         bool bRet( false );
2608 
2609         const SwTxtFmtColls* pTxtFmtColls( rDoc.GetTxtFmtColls() );
2610         if ( pTxtFmtColls )
2611         {
2612             const sal_uInt16 nCount = pTxtFmtColls->Count();
2613             for ( sal_uInt16 i = 0; i < nCount; ++i )
2614             {
2615                 SwTxtFmtColl* pTxtFmtColl = (*pTxtFmtColls)[i];
2616 
2617                 if ( pTxtFmtColl->IsDefault() ||
2618                    //  pTxtFmtColl->GetOutlineLevel() == NO_NUMBERING ) //#outline level,zhaojianwei
2619 					! pTxtFmtColl->IsAssignedToListLevelOfOutlineStyle() )	//<-end,zhaojianwei
2620                 {
2621                     continue;
2622                 }
2623 
2624                 const SwTxtFmtColl* pParentTxtFmtColl =
2625                    dynamic_cast<const SwTxtFmtColl*>( pTxtFmtColl->DerivedFrom());
2626                 if ( !pParentTxtFmtColl )
2627                     continue;
2628 
2629                 if ( SFX_ITEM_SET == pParentTxtFmtColl->GetItemState( RES_PARATR_NUMRULE ) )
2630                 {
2631                     // --> OD 2009-11-12 #i106218#
2632                     // consider that the outline style is set
2633                     const SwNumRuleItem& rDirectItem = pParentTxtFmtColl->GetNumRule();
2634                     if ( rDirectItem.GetValue() != rDoc.GetOutlineNumRule()->GetName() )
2635                     {
2636                         bRet = true;
2637                         break;
2638                     }
2639                     // <--
2640                 }
2641             }
2642 
2643         }
2644         return bRet;
2645     }
2646 }
2647 // <--
2648