Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include <svl/itemiter.hxx>
22 : #include <sfx2/app.hxx>
23 : #include <editeng/tstpitem.hxx>
24 : #include <editeng/eeitem.hxx>
25 : #include <editeng/langitem.hxx>
26 : #include <editeng/lrspitem.hxx>
27 : #include <editeng/formatbreakitem.hxx>
28 : #include <editeng/rsiditem.hxx>
29 : #include <editeng/colritem.hxx>
30 : #include <svl/whiter.hxx>
31 : #include <svl/zforlist.hxx>
32 : #include <comphelper/processfactory.hxx>
33 : #include <unotools/misccfg.hxx>
34 : #include <com/sun/star/i18n/WordType.hpp>
35 : #include <fmtpdsc.hxx>
36 : #include <fmthdft.hxx>
37 : #include <fmtcntnt.hxx>
38 : #include <frmatr.hxx>
39 : #include <doc.hxx>
40 : #include <IDocumentUndoRedo.hxx>
41 : #include <DocumentContentOperationsManager.hxx>
42 : #include <IDocumentFieldsAccess.hxx>
43 : #include <IDocumentState.hxx>
44 : #include <IDocumentLayoutAccess.hxx>
45 : #include <IDocumentStylePoolAccess.hxx>
46 : #include <rootfrm.hxx>
47 : #include <pagefrm.hxx>
48 : #include <hints.hxx>
49 : #include <ndtxt.hxx>
50 : #include <pam.hxx>
51 : #include <UndoCore.hxx>
52 : #include <UndoAttribute.hxx>
53 : #include <UndoInsert.hxx>
54 : #include <ndgrf.hxx>
55 : #include <pagedesc.hxx>
56 : #include <rolbck.hxx>
57 : #include <mvsave.hxx>
58 : #include <txatbase.hxx>
59 : #include <swtable.hxx>
60 : #include <swtblfmt.hxx>
61 : #include <charfmt.hxx>
62 : #include <docary.hxx>
63 : #include <paratr.hxx>
64 : #include <redline.hxx>
65 : #include <reffld.hxx>
66 : #include <txtinet.hxx>
67 : #include <fmtinfmt.hxx>
68 : #include <breakit.hxx>
69 : #include <SwStyleNameMapper.hxx>
70 : #include <fmtautofmt.hxx>
71 : #include <istyleaccess.hxx>
72 : #include <SwUndoFmt.hxx>
73 : #include <UndoManager.hxx>
74 : #include <docsh.hxx>
75 : #include <boost/scoped_ptr.hpp>
76 :
77 : using namespace ::com::sun::star::i18n;
78 : using namespace ::com::sun::star::lang;
79 : using namespace ::com::sun::star::uno;
80 :
81 : /*
82 : * Internal functions
83 : */
84 :
85 0 : static void SetTxtFmtCollNext( SwTxtFmtColl* pTxtColl, const SwTxtFmtColl* pDel )
86 : {
87 0 : if ( &pTxtColl->GetNextTxtFmtColl() == pDel )
88 : {
89 0 : pTxtColl->SetNextTxtFmtColl( *pTxtColl );
90 : }
91 0 : }
92 :
93 120306 : static bool lcl_RstAttr( const SwNodePtr& rpNd, void* pArgs )
94 : {
95 120306 : const sw::DocumentContentOperationsManager::ParaRstFmt* pPara = (sw::DocumentContentOperationsManager::ParaRstFmt*)pArgs;
96 120306 : SwCntntNode* pNode = (SwCntntNode*)rpNd->GetCntntNode();
97 120306 : if( pNode && pNode->HasSwAttrSet() )
98 : {
99 5508 : const bool bLocked = pNode->IsModifyLocked();
100 5508 : pNode->LockModify();
101 :
102 5508 : SwDoc* pDoc = pNode->GetDoc();
103 :
104 : // remove unused attribute RES_LR_SPACE
105 : // add list attributes
106 5508 : SfxItemSet aSavedAttrsSet(pDoc->GetAttrPool(), RES_PAGEDESC, RES_BREAK,
107 : RES_PARATR_NUMRULE, RES_PARATR_NUMRULE,
108 : RES_PARATR_LIST_BEGIN,
109 5508 : RES_PARATR_LIST_END - 1, 0);
110 5508 : const SfxItemSet* pAttrSetOfNode = pNode->GetpSwAttrSet();
111 :
112 11016 : std::vector<sal_uInt16> aClearWhichIds;
113 : // restoring all paragraph list attributes
114 : {
115 5508 : SfxItemSet aListAttrSet( pDoc->GetAttrPool(), RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END - 1 );
116 5508 : aListAttrSet.Set(*pAttrSetOfNode);
117 5508 : if ( aListAttrSet.Count() )
118 : {
119 2648 : aSavedAttrsSet.Put(aListAttrSet);
120 2648 : SfxItemIter aIter( aListAttrSet );
121 2648 : const SfxPoolItem* pItem = aIter.GetCurItem();
122 7944 : while( pItem )
123 : {
124 2648 : aClearWhichIds.push_back( pItem->Which() );
125 2648 : pItem = aIter.NextItem();
126 2648 : }
127 5508 : }
128 : }
129 :
130 : const SfxPoolItem* pItem;
131 :
132 5508 : sal_uInt16 const aSavIds[3] = { RES_PAGEDESC, RES_BREAK, RES_PARATR_NUMRULE };
133 22032 : for (sal_uInt16 n = 0; n < 3; ++n)
134 : {
135 16524 : if (SfxItemState::SET == pAttrSetOfNode->GetItemState(aSavIds[n], false, &pItem))
136 : {
137 1248 : bool bSave = false;
138 1248 : switch( aSavIds[ n ] )
139 : {
140 : case RES_PAGEDESC:
141 68 : bSave = 0 != ((SwFmtPageDesc*)pItem)->GetPageDesc();
142 68 : break;
143 : case RES_BREAK:
144 362 : bSave = SVX_BREAK_NONE != ((SvxFmtBreakItem*)pItem)->GetBreak();
145 362 : break;
146 : case RES_PARATR_NUMRULE:
147 818 : bSave = !((SwNumRuleItem*)pItem)->GetValue().isEmpty();
148 818 : break;
149 : }
150 1248 : if( bSave )
151 : {
152 1174 : aSavedAttrsSet.Put(*pItem);
153 1174 : aClearWhichIds.push_back(aSavIds[n]);
154 : }
155 : }
156 : }
157 :
158 : // do not clear items directly from item set and only clear to be kept
159 : // attributes, if no deletion item set is found.
160 : const bool bKeepAttributes =
161 5508 : !pPara || !pPara->pDelSet || pPara->pDelSet->Count() == 0;
162 5508 : if ( bKeepAttributes )
163 : {
164 5220 : pNode->ResetAttr( aClearWhichIds );
165 : }
166 :
167 5508 : if( !bLocked )
168 5508 : pNode->UnlockModify();
169 :
170 5508 : if( pPara )
171 : {
172 5508 : SwRegHistory aRegH( pNode, *pNode, pPara->pHistory );
173 :
174 5508 : if( pPara->pDelSet && pPara->pDelSet->Count() )
175 : {
176 : OSL_ENSURE( !bKeepAttributes,
177 : "<lcl_RstAttr(..)> - certain attributes are kept, but not needed. -> please inform OD" );
178 288 : SfxItemIter aIter( *pPara->pDelSet );
179 288 : pItem = aIter.FirstItem();
180 : while( true )
181 : {
182 4672 : if ( ( pItem->Which() != RES_PAGEDESC &&
183 3110 : pItem->Which() != RES_BREAK &&
184 3118 : pItem->Which() != RES_PARATR_NUMRULE ) ||
185 6 : ( aSavedAttrsSet.GetItemState( pItem->Which(), false ) != SfxItemState::SET ) )
186 : {
187 1558 : pNode->ResetAttr( pItem->Which() );
188 : }
189 1558 : if (aIter.IsAtEnd())
190 288 : break;
191 1270 : pItem = aIter.NextItem();
192 288 : }
193 : }
194 5220 : else if( pPara->bResetAll )
195 5220 : pNode->ResetAllAttr();
196 : else
197 0 : pNode->ResetAttr( RES_PARATR_BEGIN, POOLATTR_END - 1 );
198 : }
199 : else
200 0 : pNode->ResetAllAttr();
201 :
202 : // only restore saved attributes, if needed
203 5508 : if (bKeepAttributes && aSavedAttrsSet.Count())
204 : {
205 2788 : pNode->LockModify();
206 :
207 2788 : pNode->SetAttr(aSavedAttrsSet);
208 :
209 2788 : if( !bLocked )
210 2788 : pNode->UnlockModify();
211 5508 : }
212 : }
213 120306 : return true;
214 : }
215 :
216 0 : void SwDoc::RstTxtAttrs(const SwPaM &rRg, bool bInclRefToxMark )
217 : {
218 0 : SwHistory* pHst = 0;
219 0 : SwDataChanged aTmp( rRg );
220 0 : if (GetIDocumentUndoRedo().DoesUndo())
221 : {
222 0 : SwUndoResetAttr* pUndo = new SwUndoResetAttr( rRg, RES_CHRFMT );
223 0 : pHst = &pUndo->GetHistory();
224 0 : GetIDocumentUndoRedo().AppendUndo(pUndo);
225 : }
226 0 : const SwPosition *pStt = rRg.Start(), *pEnd = rRg.End();
227 0 : sw::DocumentContentOperationsManager::ParaRstFmt aPara( pStt, pEnd, pHst );
228 0 : aPara.bInclRefToxMark = bInclRefToxMark;
229 0 : GetNodes().ForEach( pStt->nNode.GetIndex(), pEnd->nNode.GetIndex()+1,
230 0 : sw::DocumentContentOperationsManager::lcl_RstTxtAttr, &aPara );
231 0 : getIDocumentState().SetModified();
232 0 : }
233 :
234 49304 : void SwDoc::ResetAttrs( const SwPaM &rRg,
235 : bool bTxtAttr,
236 : const std::set<sal_uInt16> &rAttrs,
237 : const bool bSendDataChangedEvents )
238 : {
239 49304 : SwPaM* pPam = (SwPaM*)&rRg;
240 49304 : if( !bTxtAttr && !rAttrs.empty() && RES_TXTATR_END > *(rAttrs.begin()) )
241 0 : bTxtAttr = true;
242 :
243 49304 : if( !rRg.HasMark() )
244 : {
245 47920 : SwTxtNode* pTxtNd = rRg.GetPoint()->nNode.GetNode().GetTxtNode();
246 47920 : if( !pTxtNd )
247 0 : return ;
248 :
249 47920 : pPam = new SwPaM( *rRg.GetPoint() );
250 :
251 47920 : SwIndex& rSt = pPam->GetPoint()->nContent;
252 47920 : sal_Int32 nMkPos, nPtPos = rSt.GetIndex();
253 :
254 : // Special case: if the Crsr is located within a URL attribute, we take over it's area
255 : SwTxtAttr const*const pURLAttr(
256 47920 : pTxtNd->GetTxtAttrAt(rSt.GetIndex(), RES_TXTATR_INETFMT));
257 47920 : if (pURLAttr && !pURLAttr->GetINetFmt().GetValue().isEmpty())
258 : {
259 0 : nMkPos = pURLAttr->GetStart();
260 0 : nPtPos = *pURLAttr->End();
261 : }
262 : else
263 : {
264 47920 : Boundary aBndry;
265 47920 : if( g_pBreakIt->GetBreakIter().is() )
266 95840 : aBndry = g_pBreakIt->GetBreakIter()->getWordBoundary(
267 47920 : pTxtNd->GetTxt(), nPtPos,
268 47920 : g_pBreakIt->GetLocale( pTxtNd->GetLang( nPtPos ) ),
269 : WordType::ANY_WORD /*ANYWORD_IGNOREWHITESPACES*/,
270 95840 : sal_True );
271 :
272 47920 : if( aBndry.startPos < nPtPos && nPtPos < aBndry.endPos )
273 : {
274 0 : nMkPos = aBndry.startPos;
275 0 : nPtPos = aBndry.endPos;
276 : }
277 : else
278 : {
279 47920 : nPtPos = nMkPos = rSt.GetIndex();
280 47920 : if( bTxtAttr )
281 47632 : pTxtNd->DontExpandFmt( rSt, true );
282 : }
283 : }
284 :
285 47920 : rSt = nMkPos;
286 47920 : pPam->SetMark();
287 47920 : pPam->GetPoint()->nContent = nPtPos;
288 : }
289 :
290 : // #i96644#
291 49304 : boost::scoped_ptr< SwDataChanged > pDataChanged;
292 49304 : if ( bSendDataChangedEvents )
293 : {
294 49016 : pDataChanged.reset( new SwDataChanged( *pPam ) );
295 : }
296 49304 : SwHistory* pHst = 0;
297 49304 : if (GetIDocumentUndoRedo().DoesUndo())
298 : {
299 : SwUndoResetAttr* pUndo = new SwUndoResetAttr( rRg,
300 22 : static_cast<sal_uInt16>(bTxtAttr ? RES_CONDTXTFMTCOLL : RES_TXTFMTCOLL ));
301 22 : if( !rAttrs.empty() )
302 : {
303 6 : pUndo->SetAttrs( rAttrs );
304 : }
305 22 : pHst = &pUndo->GetHistory();
306 22 : GetIDocumentUndoRedo().AppendUndo(pUndo);
307 : }
308 :
309 49304 : const SwPosition *pStt = pPam->Start(), *pEnd = pPam->End();
310 49304 : sw::DocumentContentOperationsManager::ParaRstFmt aPara( pStt, pEnd, pHst );
311 :
312 : // mst: not including META here; it seems attrs with CH_TXTATR are omitted
313 : sal_uInt16 aResetableSetRange[] = {
314 : RES_FRMATR_BEGIN, RES_FRMATR_END-1,
315 : RES_CHRATR_BEGIN, RES_CHRATR_END-1,
316 : RES_PARATR_BEGIN, RES_PARATR_END-1,
317 : RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END-1,
318 : RES_TXTATR_INETFMT, RES_TXTATR_INETFMT,
319 : RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT,
320 : RES_TXTATR_CJK_RUBY, RES_TXTATR_CJK_RUBY,
321 : RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER,
322 : RES_UNKNOWNATR_BEGIN, RES_UNKNOWNATR_END-1,
323 : 0
324 49304 : };
325 :
326 98608 : SfxItemSet aDelSet( GetAttrPool(), aResetableSetRange );
327 49304 : if( !rAttrs.empty() )
328 : {
329 1948 : for( std::set<sal_uInt16>::const_reverse_iterator it = rAttrs.rbegin(); it != rAttrs.rend(); ++it )
330 : {
331 1656 : if( POOLATTR_END > *it )
332 1656 : aDelSet.Put( *GetDfltAttr( *it ));
333 : }
334 292 : if( aDelSet.Count() )
335 292 : aPara.pDelSet = &aDelSet;
336 : }
337 :
338 49304 : bool bAdd = true;
339 98608 : SwNodeIndex aTmpStt( pStt->nNode );
340 98608 : SwNodeIndex aTmpEnd( pEnd->nNode );
341 49304 : if( pStt->nContent.GetIndex() ) // just one part
342 : {
343 : // set up a later, and all CharFmtAttr -> TxtFmtAttr
344 1352 : SwTxtNode* pTNd = aTmpStt.GetNode().GetTxtNode();
345 1352 : if( pTNd && pTNd->HasSwAttrSet() && pTNd->GetpSwAttrSet()->Count() )
346 : {
347 96 : if (pHst)
348 : {
349 10 : SwRegHistory history(pTNd, *pTNd, pHst);
350 10 : pTNd->FmtToTxtAttr(pTNd);
351 : }
352 : else
353 : {
354 86 : pTNd->FmtToTxtAttr(pTNd);
355 : }
356 : }
357 :
358 1352 : ++aTmpStt;
359 : }
360 49304 : if( pEnd->nContent.GetIndex() == pEnd->nNode.GetNode().GetCntntNode()->Len() )
361 : // set up a later, and all CharFmtAttr -> TxtFmtAttr
362 49144 : aTmpEnd++, bAdd = false;
363 160 : else if( pStt->nNode != pEnd->nNode || !pStt->nContent.GetIndex() )
364 : {
365 160 : SwTxtNode* pTNd = aTmpEnd.GetNode().GetTxtNode();
366 160 : if( pTNd && pTNd->HasSwAttrSet() && pTNd->GetpSwAttrSet()->Count() )
367 : {
368 160 : if (pHst)
369 : {
370 2 : SwRegHistory history(pTNd, *pTNd, pHst);
371 2 : pTNd->FmtToTxtAttr(pTNd);
372 : }
373 : else
374 : {
375 158 : pTNd->FmtToTxtAttr(pTNd);
376 : }
377 : }
378 : }
379 :
380 49304 : if( aTmpStt < aTmpEnd )
381 49142 : GetNodes().ForEach( pStt->nNode, aTmpEnd, lcl_RstAttr, &aPara );
382 162 : else if( !rRg.HasMark() )
383 : {
384 162 : aPara.bResetAll = false ;
385 162 : ::lcl_RstAttr( &pStt->nNode.GetNode(), &aPara );
386 162 : aPara.bResetAll = true ;
387 : }
388 :
389 49304 : if( bTxtAttr )
390 : {
391 49016 : if( bAdd )
392 0 : ++aTmpEnd;
393 49016 : GetNodes().ForEach( pStt->nNode, aTmpEnd, sw::DocumentContentOperationsManager::lcl_RstTxtAttr, &aPara );
394 : }
395 :
396 49304 : if( pPam != &rRg )
397 47920 : delete pPam;
398 :
399 98608 : getIDocumentState().SetModified();
400 : }
401 :
402 : /// Set the rsid of the next nLen symbols of rRg to the current session number
403 572 : bool SwDoc::UpdateRsid( const SwPaM &rRg, const sal_Int32 nLen )
404 : {
405 572 : SwTxtNode *pTxtNode = rRg.GetPoint()->nNode.GetNode().GetTxtNode();
406 572 : if (!pTxtNode)
407 : {
408 0 : return false;
409 : }
410 572 : const sal_Int32 nStart(rRg.GetPoint()->nContent.GetIndex() - nLen);
411 572 : SvxRsidItem aRsid( mnRsid, RES_CHRATR_RSID );
412 :
413 1144 : SfxItemSet aSet(GetAttrPool(), RES_CHRATR_RSID, RES_CHRATR_RSID);
414 572 : aSet.Put(aRsid);
415 : bool const bRet(pTxtNode->SetAttr(aSet, nStart,
416 572 : rRg.GetPoint()->nContent.GetIndex(), nsSetAttrMode::SETATTR_DEFAULT));
417 :
418 572 : if (bRet && GetIDocumentUndoRedo().DoesUndo())
419 : {
420 18 : SwUndo *const pLastUndo = GetUndoManager().GetLastUndo();
421 18 : SwUndoInsert *const pUndoInsert(dynamic_cast<SwUndoInsert*>(pLastUndo));
422 : // this function is called after Insert so expects to find SwUndoInsert
423 : assert(pUndoInsert);
424 18 : if (pUndoInsert)
425 : {
426 18 : pUndoInsert->SetWithRsid();
427 : }
428 : }
429 1144 : return bRet;
430 : }
431 :
432 764 : bool SwDoc::UpdateParRsid( SwTxtNode *pTxtNode, sal_uInt32 nVal )
433 : {
434 764 : if (!pTxtNode)
435 : {
436 0 : return false;
437 : }
438 :
439 764 : SvxRsidItem aRsid( nVal ? nVal : mnRsid, RES_PARATR_RSID );
440 764 : return pTxtNode->SetAttr( aRsid );
441 : }
442 :
443 : /// Set the attribute according to the stated format.
444 : /// If Undo is enabled, the old values is added to the Undo history.
445 18288 : void SwDoc::SetAttr( const SfxPoolItem& rAttr, SwFmt& rFmt )
446 : {
447 18288 : SfxItemSet aSet( GetAttrPool(), rAttr.Which(), rAttr.Which() );
448 18288 : aSet.Put( rAttr );
449 18288 : SetAttr( aSet, rFmt );
450 18288 : }
451 :
452 : /// Set the attribute according to the stated format.
453 : /// If Undo is enabled, the old values is added to the Undo history.
454 166126 : void SwDoc::SetAttr( const SfxItemSet& rSet, SwFmt& rFmt )
455 : {
456 166126 : if (GetIDocumentUndoRedo().DoesUndo())
457 : {
458 116 : SwUndoFmtAttrHelper aTmp( rFmt );
459 116 : rFmt.SetFmtAttr( rSet );
460 116 : if ( aTmp.GetUndo() )
461 : {
462 106 : GetIDocumentUndoRedo().AppendUndo( aTmp.ReleaseUndo() );
463 : }
464 : else
465 : {
466 10 : GetIDocumentUndoRedo().ClearRedo();
467 116 : }
468 : }
469 : else
470 : {
471 166010 : rFmt.SetFmtAttr( rSet );
472 : }
473 166126 : getIDocumentState().SetModified();
474 166126 : }
475 :
476 0 : void SwDoc::ResetAttrAtFormat( const sal_uInt16 nWhichId,
477 : SwFmt& rChangedFormat )
478 : {
479 0 : SwUndo *const pUndo = (GetIDocumentUndoRedo().DoesUndo())
480 0 : ? new SwUndoFmtResetAttr( rChangedFormat, nWhichId )
481 0 : : 0;
482 :
483 0 : const bool bAttrReset = rChangedFormat.ResetFmtAttr( nWhichId );
484 :
485 0 : if ( bAttrReset )
486 : {
487 0 : if ( pUndo )
488 : {
489 0 : GetIDocumentUndoRedo().AppendUndo( pUndo );
490 : }
491 :
492 0 : getIDocumentState().SetModified();
493 : }
494 : else
495 0 : delete pUndo;
496 0 : }
497 :
498 17294 : static int lcl_SetNewDefTabStops( SwTwips nOldWidth, SwTwips nNewWidth,
499 : SvxTabStopItem& rChgTabStop )
500 : {
501 : // Set the default values of all TabStops to the new value.
502 : // Attention: we always work with the PoolAttribut here, so that
503 : // we don't calculate the same value on the same TabStop (pooled!) for all sets.
504 : // We send a FmtChg to modify.
505 :
506 17294 : sal_uInt16 nOldCnt = rChgTabStop.Count();
507 17294 : if( !nOldCnt || nOldWidth == nNewWidth )
508 524 : return sal_False;
509 :
510 : // Find the default's beginning
511 : sal_uInt16 n;
512 33526 : for( n = nOldCnt; n ; --n )
513 16770 : if( SVX_TAB_ADJUST_DEFAULT != rChgTabStop[n - 1].GetAdjustment() )
514 14 : break;
515 16770 : ++n;
516 16770 : if( n < nOldCnt ) // delete the DefTabStops
517 0 : rChgTabStop.Remove( n, nOldCnt - n );
518 16770 : return sal_True;
519 : }
520 :
521 : /// Set the attribute as new default attribute in this document.
522 : /// If Undo is enabled, the old value is added to the Undo history.
523 98034 : void SwDoc::SetDefault( const SfxPoolItem& rAttr )
524 : {
525 98034 : SfxItemSet aSet( GetAttrPool(), rAttr.Which(), rAttr.Which() );
526 98034 : aSet.Put( rAttr );
527 98034 : SetDefault( aSet );
528 98034 : }
529 :
530 102790 : void SwDoc::SetDefault( const SfxItemSet& rSet )
531 : {
532 102790 : if( !rSet.Count() )
533 102790 : return;
534 :
535 102790 : SwModify aCallMod( 0 );
536 205580 : SwAttrSet aOld( GetAttrPool(), rSet.GetRanges() ),
537 205580 : aNew( GetAttrPool(), rSet.GetRanges() );
538 205580 : SfxItemIter aIter( rSet );
539 : sal_uInt16 nWhich;
540 102790 : const SfxPoolItem* pItem = aIter.GetCurItem();
541 102790 : SfxItemPool* pSdrPool = GetAttrPool().GetSecondaryPool();
542 : while( true )
543 : {
544 126556 : bool bCheckSdrDflt = false;
545 126556 : nWhich = pItem->Which();
546 126556 : aOld.Put( GetAttrPool().GetDefaultItem( nWhich ) );
547 126556 : GetAttrPool().SetPoolDefaultItem( *pItem );
548 126556 : aNew.Put( GetAttrPool().GetDefaultItem( nWhich ) );
549 :
550 126556 : if (isCHRATR(nWhich) || isTXTATR(nWhich))
551 : {
552 92009 : aCallMod.Add( mpDfltTxtFmtColl );
553 92009 : aCallMod.Add( mpDfltCharFmt );
554 92009 : bCheckSdrDflt = 0 != pSdrPool;
555 : }
556 45967 : else if ( isPARATR(nWhich) ||
557 11420 : isPARATR_LIST(nWhich) )
558 : {
559 23127 : aCallMod.Add( mpDfltTxtFmtColl );
560 23127 : bCheckSdrDflt = 0 != pSdrPool;
561 : }
562 11420 : else if (isGRFATR(nWhich))
563 : {
564 0 : aCallMod.Add( mpDfltGrfFmtColl );
565 : }
566 11420 : else if (isFRMATR(nWhich) || isDrawingLayerAttribute(nWhich) ) //UUUU
567 : {
568 11420 : aCallMod.Add( mpDfltGrfFmtColl );
569 11420 : aCallMod.Add( mpDfltTxtFmtColl );
570 11420 : aCallMod.Add( mpDfltFrmFmt );
571 : }
572 0 : else if (isBOXATR(nWhich))
573 : {
574 0 : aCallMod.Add( mpDfltFrmFmt );
575 : }
576 :
577 : // also copy the defaults
578 126556 : if( bCheckSdrDflt )
579 : {
580 : sal_uInt16 nEdtWhich, nSlotId;
581 345408 : if( 0 != (nSlotId = GetAttrPool().GetSlotId( nWhich ) ) &&
582 110051 : nSlotId != nWhich &&
583 335238 : 0 != (nEdtWhich = pSdrPool->GetWhich( nSlotId )) &&
584 : nSlotId != nEdtWhich )
585 : {
586 99022 : SfxPoolItem* pCpy = pItem->Clone();
587 99022 : pCpy->SetWhich( nEdtWhich );
588 99022 : pSdrPool->SetPoolDefaultItem( *pCpy );
589 99022 : delete pCpy;
590 : }
591 : }
592 :
593 126556 : if( aIter.IsAtEnd() )
594 102790 : break;
595 23766 : pItem = aIter.NextItem();
596 : }
597 :
598 102790 : if( aNew.Count() && aCallMod.GetDepends() )
599 : {
600 102790 : if (GetIDocumentUndoRedo().DoesUndo())
601 : {
602 750 : GetIDocumentUndoRedo().AppendUndo( new SwUndoDefaultAttr( aOld ) );
603 : }
604 :
605 : const SfxPoolItem* pTmpItem;
606 102790 : if( ( SfxItemState::SET ==
607 111434 : aNew.GetItemState( RES_PARATR_TABSTOP, false, &pTmpItem ) ) &&
608 8644 : ((SvxTabStopItem*)pTmpItem)->Count() )
609 : {
610 : // Set the default values of all TabStops to the new value.
611 : // Attention: we always work with the PoolAttribut here, so that
612 : // we don't calculate the same value on the same TabStop (pooled!) for all sets.
613 : // We send a FmtChg to modify.
614 8644 : SwTwips nNewWidth = (*(SvxTabStopItem*)pTmpItem)[ 0 ].GetTabPos(),
615 8644 : nOldWidth = ((SvxTabStopItem&)aOld.Get(RES_PARATR_TABSTOP))[ 0 ].GetTabPos();
616 :
617 8644 : int bChg = sal_False;
618 8644 : sal_uInt32 nMaxItems = GetAttrPool().GetItemCount2( RES_PARATR_TABSTOP );
619 26026 : for( sal_uInt32 n = 0; n < nMaxItems; ++n )
620 17382 : if( 0 != (pTmpItem = GetAttrPool().GetItem2( RES_PARATR_TABSTOP, n ) ))
621 : bChg |= lcl_SetNewDefTabStops( nOldWidth, nNewWidth,
622 17294 : *(SvxTabStopItem*)pTmpItem );
623 :
624 8644 : aNew.ClearItem( RES_PARATR_TABSTOP );
625 8644 : aOld.ClearItem( RES_PARATR_TABSTOP );
626 8644 : if( bChg )
627 : {
628 8378 : SwFmtChg aChgFmt( mpDfltCharFmt );
629 : // notify the frames
630 8378 : aCallMod.ModifyNotification( &aChgFmt, &aChgFmt );
631 : }
632 : }
633 : }
634 :
635 102790 : if( aNew.Count() && aCallMod.GetDepends() )
636 : {
637 98892 : SwAttrSetChg aChgOld( aOld, aOld );
638 197784 : SwAttrSetChg aChgNew( aNew, aNew );
639 197784 : aCallMod.ModifyNotification( &aChgOld, &aChgNew ); // all changed are sent
640 : }
641 :
642 : // remove the default formats from the object again
643 : SwClient* pDep;
644 408903 : while( 0 != ( pDep = (SwClient*)aCallMod.GetDepends()) )
645 203323 : aCallMod.Remove( pDep );
646 :
647 205580 : getIDocumentState().SetModified();
648 : }
649 :
650 : /// Get the default attribute in this document
651 382006 : const SfxPoolItem& SwDoc::GetDefault( sal_uInt16 nFmtHint ) const
652 : {
653 382006 : return GetAttrPool().GetDefaultItem( nFmtHint );
654 : }
655 :
656 : /// Delete the formats
657 78 : void SwDoc::DelCharFmt(sal_uInt16 nFmt, bool bBroadcast)
658 : {
659 78 : SwCharFmt * pDel = (*mpCharFmtTbl)[nFmt];
660 :
661 78 : if (bBroadcast)
662 : BroadcastStyleOperation(pDel->GetName(), SFX_STYLE_FAMILY_CHAR,
663 0 : SFX_STYLESHEET_ERASED);
664 :
665 78 : if (GetIDocumentUndoRedo().DoesUndo())
666 : {
667 : SwUndo * pUndo =
668 2 : new SwUndoCharFmtDelete(pDel, this);
669 :
670 2 : GetIDocumentUndoRedo().AppendUndo(pUndo);
671 : }
672 :
673 78 : delete (*mpCharFmtTbl)[nFmt];
674 78 : mpCharFmtTbl->erase(mpCharFmtTbl->begin() + nFmt);
675 :
676 78 : getIDocumentState().SetModified();
677 78 : }
678 :
679 2 : void SwDoc::DelCharFmt( SwCharFmt *pFmt, bool bBroadcast )
680 : {
681 2 : sal_uInt16 nFmt = mpCharFmtTbl->GetPos( pFmt );
682 : OSL_ENSURE( USHRT_MAX != nFmt, "Fmt not found," );
683 2 : DelCharFmt( nFmt, bBroadcast );
684 2 : }
685 :
686 9852 : void SwDoc::DelFrmFmt( SwFrmFmt *pFmt, bool bBroadcast )
687 : {
688 9852 : if( pFmt->ISA( SwTableBoxFmt ) || pFmt->ISA( SwTableLineFmt ))
689 : {
690 : OSL_ENSURE( false, "Format is not in the DocArray any more, "
691 : "so it can be deleted with delete" );
692 0 : delete pFmt;
693 : }
694 : else
695 : {
696 :
697 : // The format has to be in the one or the other, we'll see in which one.
698 9852 : SwFrmFmts::iterator it = std::find( mpFrmFmtTbl->begin(), mpFrmFmtTbl->end(), pFmt );
699 9852 : if ( it != mpFrmFmtTbl->end() )
700 : {
701 5638 : if (bBroadcast)
702 : BroadcastStyleOperation(pFmt->GetName(),
703 : SFX_STYLE_FAMILY_FRAME,
704 0 : SFX_STYLESHEET_ERASED);
705 :
706 5638 : if (GetIDocumentUndoRedo().DoesUndo())
707 : {
708 5070 : SwUndo * pUndo = new SwUndoFrmFmtDelete(pFmt, this);
709 :
710 5070 : GetIDocumentUndoRedo().AppendUndo(pUndo);
711 : }
712 :
713 5638 : delete *it;
714 5638 : mpFrmFmtTbl->erase(it);
715 : }
716 : else
717 : {
718 4214 : SwFrmFmts::iterator it2 = std::find( GetSpzFrmFmts()->begin(), GetSpzFrmFmts()->end(), pFmt );
719 : OSL_ENSURE( it2 != GetSpzFrmFmts()->end(), "FrmFmt not found." );
720 4214 : if( it2 != GetSpzFrmFmts()->end() )
721 : {
722 4214 : delete *it2;
723 4214 : GetSpzFrmFmts()->erase( it2 );
724 : }
725 : }
726 : }
727 9852 : }
728 :
729 1814 : void SwDoc::DelTblFrmFmt( SwTableFmt *pFmt )
730 : {
731 1814 : SwFrmFmts::iterator it = std::find( mpTblFrmFmtTbl->begin(), mpTblFrmFmtTbl->end(), pFmt );
732 : OSL_ENSURE( it != mpTblFrmFmtTbl->end(), "Fmt not found," );
733 1814 : delete *it;
734 1814 : mpTblFrmFmtTbl->erase(it);
735 1814 : }
736 :
737 : /// Create the formats
738 3916 : SwFlyFrmFmt *SwDoc::MakeFlyFrmFmt( const OUString &rFmtName,
739 : SwFrmFmt *pDerivedFrom )
740 : {
741 3916 : SwFlyFrmFmt *pFmt = new SwFlyFrmFmt( GetAttrPool(), rFmtName, pDerivedFrom );
742 3916 : GetSpzFrmFmts()->push_back(pFmt);
743 3916 : getIDocumentState().SetModified();
744 3916 : return pFmt;
745 : }
746 :
747 4470 : SwDrawFrmFmt *SwDoc::MakeDrawFrmFmt( const OUString &rFmtName,
748 : SwFrmFmt *pDerivedFrom )
749 : {
750 4470 : SwDrawFrmFmt *pFmt = new SwDrawFrmFmt( GetAttrPool(), rFmtName, pDerivedFrom);
751 4470 : GetSpzFrmFmts()->push_back(pFmt);
752 4470 : getIDocumentState().SetModified();
753 4470 : return pFmt;
754 : }
755 :
756 464 : sal_uInt16 SwDoc::GetTblFrmFmtCount(bool bUsed) const
757 : {
758 464 : sal_uInt16 nCount = mpTblFrmFmtTbl->size();
759 464 : if(bUsed)
760 : {
761 464 : SwAutoFmtGetDocNode aGetHt( &GetNodes() );
762 1302 : for ( sal_uInt16 i = nCount; i; )
763 : {
764 374 : if((*mpTblFrmFmtTbl)[--i]->GetInfo( aGetHt ))
765 0 : --nCount;
766 464 : }
767 : }
768 464 : return nCount;
769 : }
770 :
771 180 : SwFrmFmt& SwDoc::GetTblFrmFmt(sal_uInt16 nFmt, bool bUsed ) const
772 : {
773 180 : sal_uInt16 nRemoved = 0;
774 180 : if(bUsed)
775 : {
776 180 : SwAutoFmtGetDocNode aGetHt( &GetNodes() );
777 418 : for ( sal_uInt16 i = 0; i <= nFmt; i++ )
778 : {
779 476 : while ( (*mpTblFrmFmtTbl)[ i + nRemoved]->GetInfo( aGetHt ))
780 : {
781 0 : nRemoved++;
782 : }
783 180 : }
784 : }
785 180 : return *((*mpTblFrmFmtTbl)[nRemoved + nFmt]);
786 : }
787 :
788 1816 : SwTableFmt* SwDoc::MakeTblFrmFmt( const OUString &rFmtName,
789 : SwFrmFmt *pDerivedFrom )
790 : {
791 1816 : SwTableFmt* pFmt = new SwTableFmt( GetAttrPool(), rFmtName, pDerivedFrom );
792 1816 : mpTblFrmFmtTbl->push_back( pFmt );
793 1816 : getIDocumentState().SetModified();
794 :
795 1816 : return pFmt;
796 : }
797 :
798 8378 : SwFrmFmt *SwDoc::MakeFrmFmt(const OUString &rFmtName,
799 : SwFrmFmt *pDerivedFrom,
800 : bool bBroadcast, bool bAuto)
801 : {
802 8378 : SwFrmFmt *pFmt = new SwFrmFmt( GetAttrPool(), rFmtName, pDerivedFrom );
803 :
804 8378 : pFmt->SetAuto(bAuto);
805 8378 : mpFrmFmtTbl->push_back( pFmt );
806 8378 : getIDocumentState().SetModified();
807 :
808 8378 : if (GetIDocumentUndoRedo().DoesUndo())
809 : {
810 44 : SwUndo * pUndo = new SwUndoFrmFmtCreate(pFmt, pDerivedFrom, this);
811 :
812 44 : GetIDocumentUndoRedo().AppendUndo(pUndo);
813 : }
814 :
815 8378 : if (bBroadcast)
816 : {
817 : BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_FRAME,
818 0 : SFX_STYLESHEET_CREATED);
819 : }
820 :
821 8378 : return pFmt;
822 : }
823 :
824 2692 : SwFmt *SwDoc::_MakeFrmFmt(const OUString &rFmtName,
825 : SwFmt *pDerivedFrom,
826 : bool bBroadcast, bool bAuto)
827 : {
828 2692 : SwFrmFmt *pFrmFmt = dynamic_cast<SwFrmFmt*>(pDerivedFrom);
829 2692 : pFrmFmt = MakeFrmFmt( rFmtName, pFrmFmt, bBroadcast, bAuto );
830 2692 : return dynamic_cast<SwFmt*>(pFrmFmt);
831 : }
832 :
833 : // #i40550# - add parameter <bAuto> - not relevant
834 25280 : SwCharFmt *SwDoc::MakeCharFmt( const OUString &rFmtName,
835 : SwCharFmt *pDerivedFrom,
836 : bool bBroadcast,
837 : bool )
838 : {
839 25280 : SwCharFmt *pFmt = new SwCharFmt( GetAttrPool(), rFmtName, pDerivedFrom );
840 25280 : mpCharFmtTbl->push_back( pFmt );
841 25280 : pFmt->SetAuto( false );
842 25280 : getIDocumentState().SetModified();
843 :
844 25280 : if (GetIDocumentUndoRedo().DoesUndo())
845 : {
846 430 : SwUndo * pUndo = new SwUndoCharFmtCreate(pFmt, pDerivedFrom, this);
847 :
848 430 : GetIDocumentUndoRedo().AppendUndo(pUndo);
849 : }
850 :
851 25280 : if (bBroadcast)
852 : {
853 : BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_CHAR,
854 0 : SFX_STYLESHEET_CREATED);
855 : }
856 :
857 25280 : return pFmt;
858 : }
859 :
860 2140 : SwFmt *SwDoc::_MakeCharFmt(const OUString &rFmtName,
861 : SwFmt *pDerivedFrom,
862 : bool bBroadcast, bool bAuto)
863 : {
864 2140 : SwCharFmt *pCharFmt = dynamic_cast<SwCharFmt*>(pDerivedFrom);
865 2140 : pCharFmt = MakeCharFmt( rFmtName, pCharFmt, bBroadcast, bAuto );
866 2140 : return dynamic_cast<SwFmt*>(pCharFmt);
867 : }
868 :
869 : /// Create the FormatCollections
870 18334 : SwTxtFmtColl* SwDoc::MakeTxtFmtColl( const OUString &rFmtName,
871 : SwTxtFmtColl *pDerivedFrom,
872 : bool bBroadcast,
873 : bool )
874 : {
875 : SwTxtFmtColl *pFmtColl = new SwTxtFmtColl( GetAttrPool(), rFmtName,
876 18334 : pDerivedFrom );
877 18334 : mpTxtFmtCollTbl->push_back(pFmtColl);
878 18334 : pFmtColl->SetAuto( false );
879 18334 : getIDocumentState().SetModified();
880 :
881 18334 : if (GetIDocumentUndoRedo().DoesUndo())
882 : {
883 : SwUndo * pUndo = new SwUndoTxtFmtCollCreate(pFmtColl, pDerivedFrom,
884 16 : this);
885 16 : GetIDocumentUndoRedo().AppendUndo(pUndo);
886 : }
887 :
888 18334 : if (bBroadcast)
889 : BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_PARA,
890 0 : SFX_STYLESHEET_CREATED);
891 :
892 18334 : return pFmtColl;
893 : }
894 :
895 234 : SwFmt *SwDoc::_MakeTxtFmtColl(const OUString &rFmtName,
896 : SwFmt *pDerivedFrom,
897 : bool bBroadcast, bool bAuto)
898 : {
899 234 : SwTxtFmtColl *pTxtFmtColl = dynamic_cast<SwTxtFmtColl*>(pDerivedFrom);
900 234 : pTxtFmtColl = MakeTxtFmtColl( rFmtName, pTxtFmtColl, bBroadcast, bAuto );
901 234 : return dynamic_cast<SwFmt*>(pTxtFmtColl);
902 : }
903 :
904 : //FEATURE::CONDCOLL
905 10 : SwConditionTxtFmtColl* SwDoc::MakeCondTxtFmtColl( const OUString &rFmtName,
906 : SwTxtFmtColl *pDerivedFrom,
907 : bool bBroadcast)
908 : {
909 : SwConditionTxtFmtColl*pFmtColl = new SwConditionTxtFmtColl( GetAttrPool(),
910 10 : rFmtName, pDerivedFrom );
911 10 : mpTxtFmtCollTbl->push_back(pFmtColl);
912 10 : pFmtColl->SetAuto( false );
913 10 : getIDocumentState().SetModified();
914 :
915 10 : if (GetIDocumentUndoRedo().DoesUndo())
916 : {
917 : SwUndo * pUndo = new SwUndoCondTxtFmtCollCreate(pFmtColl, pDerivedFrom,
918 4 : this);
919 4 : GetIDocumentUndoRedo().AppendUndo(pUndo);
920 : }
921 :
922 10 : if (bBroadcast)
923 : BroadcastStyleOperation(rFmtName, SFX_STYLE_FAMILY_PARA,
924 0 : SFX_STYLESHEET_CREATED);
925 :
926 10 : return pFmtColl;
927 : }
928 : //FEATURE::CONDCOLL
929 :
930 : // GRF
931 0 : SwGrfFmtColl* SwDoc::MakeGrfFmtColl( const OUString &rFmtName,
932 : SwGrfFmtColl *pDerivedFrom )
933 : {
934 : SwGrfFmtColl *pFmtColl = new SwGrfFmtColl( GetAttrPool(), rFmtName,
935 0 : pDerivedFrom );
936 0 : mpGrfFmtCollTbl->push_back( pFmtColl );
937 0 : pFmtColl->SetAuto( false );
938 0 : getIDocumentState().SetModified();
939 0 : return pFmtColl;
940 : }
941 :
942 0 : void SwDoc::DelTxtFmtColl(sal_uInt16 nFmtColl, bool bBroadcast)
943 : {
944 : OSL_ENSURE( nFmtColl, "Remove fuer Coll 0." );
945 :
946 : // Who has the to-be-deleted as their Next?
947 0 : SwTxtFmtColl *pDel = (*mpTxtFmtCollTbl)[nFmtColl];
948 0 : if( mpDfltTxtFmtColl == pDel )
949 0 : return; // never delete default!
950 :
951 0 : if (bBroadcast)
952 : BroadcastStyleOperation(pDel->GetName(), SFX_STYLE_FAMILY_PARA,
953 0 : SFX_STYLESHEET_ERASED);
954 :
955 0 : if (GetIDocumentUndoRedo().DoesUndo())
956 : {
957 : SwUndoTxtFmtCollDelete * pUndo;
958 0 : if (RES_CONDTXTFMTCOLL == pDel->Which())
959 : {
960 0 : pUndo = new SwUndoCondTxtFmtCollDelete(pDel, this);
961 : }
962 : else
963 : {
964 0 : pUndo = new SwUndoTxtFmtCollDelete(pDel, this);
965 : }
966 :
967 0 : GetIDocumentUndoRedo().AppendUndo(pUndo);
968 : }
969 :
970 : // Remove the FmtColl
971 0 : mpTxtFmtCollTbl->erase(mpTxtFmtCollTbl->begin() + nFmtColl);
972 : // Correct next
973 0 : for( SwTxtFmtColls::const_iterator it = mpTxtFmtCollTbl->begin() + 1; it != mpTxtFmtCollTbl->end(); ++it )
974 0 : SetTxtFmtCollNext( *it, pDel );
975 0 : delete pDel;
976 0 : getIDocumentState().SetModified();
977 : }
978 :
979 0 : void SwDoc::DelTxtFmtColl( SwTxtFmtColl *pColl, bool bBroadcast )
980 : {
981 0 : sal_uInt16 nFmt = mpTxtFmtCollTbl->GetPos( pColl );
982 : OSL_ENSURE( USHRT_MAX != nFmt, "Collection not found," );
983 0 : DelTxtFmtColl( nFmt, bBroadcast );
984 0 : }
985 :
986 69624 : static bool lcl_SetTxtFmtColl( const SwNodePtr& rpNode, void* pArgs )
987 : {
988 69624 : SwCntntNode* pCNd = static_cast<SwCntntNode*>(rpNode->GetTxtNode());
989 :
990 69624 : if( pCNd == NULL)
991 0 : return true;
992 :
993 69624 : sw::DocumentContentOperationsManager::ParaRstFmt* pPara = reinterpret_cast<sw::DocumentContentOperationsManager::ParaRstFmt*>(pArgs);
994 :
995 69624 : SwTxtFmtColl* pFmt = static_cast<SwTxtFmtColl*>(pPara->pFmtColl);
996 69624 : if ( pPara->bReset )
997 : {
998 69624 : lcl_RstAttr(pCNd, pPara);
999 :
1000 : // #i62675# check, if paragraph style has changed
1001 69624 : if ( pPara->bResetListAttrs &&
1002 69624 : pFmt != pCNd->GetFmtColl() &&
1003 0 : pFmt->GetItemState( RES_PARATR_NUMRULE ) == SfxItemState::SET )
1004 : {
1005 : // Check, if the list style of the paragraph will change.
1006 0 : bool bChangeOfListStyleAtParagraph( true );
1007 0 : SwTxtNode* pTNd( dynamic_cast<SwTxtNode*>(pCNd) );
1008 : OSL_ENSURE( pTNd, "<lcl_SetTxtFmtColl(..)> - text node expected -> crash" );
1009 : {
1010 0 : SwNumRule* pNumRuleAtParagraph( pTNd->GetNumRule() );
1011 0 : if ( pNumRuleAtParagraph )
1012 : {
1013 : const SwNumRuleItem& rNumRuleItemAtParagraphStyle =
1014 0 : pFmt->GetNumRule();
1015 0 : if ( rNumRuleItemAtParagraphStyle.GetValue() ==
1016 : pNumRuleAtParagraph->GetName() )
1017 : {
1018 0 : bChangeOfListStyleAtParagraph = false;
1019 : }
1020 : }
1021 : }
1022 :
1023 0 : if ( bChangeOfListStyleAtParagraph )
1024 : {
1025 0 : boost::scoped_ptr< SwRegHistory > pRegH;
1026 0 : if ( pPara->pHistory )
1027 : {
1028 0 : pRegH.reset( new SwRegHistory( pTNd, *pTNd, pPara->pHistory ) );
1029 : }
1030 :
1031 0 : pCNd->ResetAttr( RES_PARATR_NUMRULE );
1032 :
1033 : // reset all list attributes
1034 0 : pCNd->ResetAttr( RES_PARATR_LIST_LEVEL );
1035 0 : pCNd->ResetAttr( RES_PARATR_LIST_ISRESTART );
1036 0 : pCNd->ResetAttr( RES_PARATR_LIST_RESTARTVALUE );
1037 0 : pCNd->ResetAttr( RES_PARATR_LIST_ISCOUNTED );
1038 0 : pCNd->ResetAttr( RES_PARATR_LIST_ID );
1039 : }
1040 : }
1041 : }
1042 :
1043 : // add to History so that old data is saved, if necessary
1044 69624 : if( pPara->pHistory )
1045 : pPara->pHistory->Add( pCNd->GetFmtColl(), pCNd->GetIndex(),
1046 3970 : ND_TEXTNODE );
1047 :
1048 69624 : pCNd->ChgFmtColl( pFmt );
1049 :
1050 69624 : pPara->nWhich++;
1051 :
1052 69624 : return true;
1053 : }
1054 :
1055 69520 : bool SwDoc::SetTxtFmtColl(const SwPaM &rRg,
1056 : SwTxtFmtColl *pFmt,
1057 : const bool bReset,
1058 : const bool bResetListAttrs)
1059 : {
1060 69520 : SwDataChanged aTmp( rRg );
1061 69520 : const SwPosition *pStt = rRg.Start(), *pEnd = rRg.End();
1062 69520 : SwHistory* pHst = 0;
1063 69520 : bool bRet = true;
1064 :
1065 69520 : if (GetIDocumentUndoRedo().DoesUndo())
1066 : {
1067 : SwUndoFmtColl* pUndo = new SwUndoFmtColl( rRg, pFmt,
1068 : bReset,
1069 3866 : bResetListAttrs );
1070 3866 : pHst = pUndo->GetHistory();
1071 3866 : GetIDocumentUndoRedo().AppendUndo(pUndo);
1072 : }
1073 :
1074 69520 : sw::DocumentContentOperationsManager::ParaRstFmt aPara( pStt, pEnd, pHst );
1075 69520 : aPara.pFmtColl = pFmt;
1076 69520 : aPara.bReset = bReset;
1077 : // #i62675#
1078 69520 : aPara.bResetListAttrs = bResetListAttrs;
1079 :
1080 139040 : GetNodes().ForEach( pStt->nNode.GetIndex(), pEnd->nNode.GetIndex()+1,
1081 139040 : lcl_SetTxtFmtColl, &aPara );
1082 69520 : if( !aPara.nWhich )
1083 0 : bRet = false; // didn't find a valid Node
1084 :
1085 69520 : if (bRet)
1086 : {
1087 69520 : getIDocumentState().SetModified();
1088 : }
1089 :
1090 69520 : return bRet;
1091 : }
1092 :
1093 : /// Copy the formats to itself
1094 708 : SwFmt* SwDoc::CopyFmt( const SwFmt& rFmt,
1095 : const SwFmtsBase& rFmtArr,
1096 : FNCopyFmt fnCopyFmt, const SwFmt& rDfltFmt )
1097 : {
1098 : // It's no autoformat, default format or collection format,
1099 : // then search for it.
1100 708 : if( !rFmt.IsAuto() || !rFmt.GetRegisteredIn() )
1101 1654 : for( sal_uInt16 n = 0; n < rFmtArr.GetFmtCount(); n++ )
1102 : {
1103 : // Does the Doc already contain the template?
1104 1652 : if( rFmtArr.GetFmt(n)->GetName()==rFmt.GetName() )
1105 706 : return (SwFmt*)rFmtArr.GetFmt(n);
1106 : }
1107 :
1108 : // Search for the "parent" first
1109 2 : SwFmt* pParent = (SwFmt*)&rDfltFmt;
1110 2 : if( rFmt.DerivedFrom() && pParent != rFmt.DerivedFrom() )
1111 2 : pParent = CopyFmt( *rFmt.DerivedFrom(), rFmtArr,
1112 2 : fnCopyFmt, rDfltFmt );
1113 :
1114 : // Create the format and copy the attributes
1115 : // #i40550#
1116 2 : SwFmt* pNewFmt = (this->*fnCopyFmt)( rFmt.GetName(), pParent, false, true );
1117 2 : pNewFmt->SetAuto( rFmt.IsAuto() );
1118 2 : pNewFmt->CopyAttrs( rFmt, true ); // copy the attributes
1119 :
1120 2 : pNewFmt->SetPoolFmtId( rFmt.GetPoolFmtId() );
1121 2 : pNewFmt->SetPoolHelpId( rFmt.GetPoolHelpId() );
1122 :
1123 : // Always set the HelpFile Id to default!
1124 2 : pNewFmt->SetPoolHlpFileId( UCHAR_MAX );
1125 :
1126 2 : return pNewFmt;
1127 : }
1128 :
1129 : /// copy the frame format
1130 706 : SwFrmFmt* SwDoc::CopyFrmFmt( const SwFrmFmt& rFmt )
1131 : {
1132 :
1133 706 : return (SwFrmFmt*)CopyFmt( rFmt, *GetFrmFmts(), &SwDoc::_MakeFrmFmt,
1134 1412 : *GetDfltFrmFmt() );
1135 : }
1136 :
1137 : /// copy the char format
1138 0 : SwCharFmt* SwDoc::CopyCharFmt( const SwCharFmt& rFmt )
1139 : {
1140 0 : return (SwCharFmt*)CopyFmt( rFmt, *GetCharFmts(),
1141 : &SwDoc::_MakeCharFmt,
1142 0 : *GetDfltCharFmt() );
1143 : }
1144 :
1145 : /// copy TextNodes
1146 10516 : SwTxtFmtColl* SwDoc::CopyTxtColl( const SwTxtFmtColl& rColl )
1147 : {
1148 10516 : SwTxtFmtColl* pNewColl = FindTxtFmtCollByName( rColl.GetName() );
1149 10516 : if( pNewColl )
1150 10514 : return pNewColl;
1151 :
1152 : // search for the "parent" first
1153 2 : SwTxtFmtColl* pParent = mpDfltTxtFmtColl;
1154 2 : if( pParent != rColl.DerivedFrom() )
1155 2 : pParent = CopyTxtColl( *(SwTxtFmtColl*)rColl.DerivedFrom() );
1156 :
1157 : //FEATURE::CONDCOLL
1158 2 : if( RES_CONDTXTFMTCOLL == rColl.Which() )
1159 : {
1160 : pNewColl = new SwConditionTxtFmtColl( GetAttrPool(), rColl.GetName(),
1161 0 : pParent);
1162 0 : mpTxtFmtCollTbl->push_back( pNewColl );
1163 0 : pNewColl->SetAuto( false );
1164 0 : getIDocumentState().SetModified();
1165 :
1166 : // copy the conditions
1167 : ((SwConditionTxtFmtColl*)pNewColl)->SetConditions(
1168 0 : ((SwConditionTxtFmtColl&)rColl).GetCondColls() );
1169 : }
1170 : else
1171 : //FEATURE::CONDCOLL
1172 2 : pNewColl = MakeTxtFmtColl( rColl.GetName(), pParent );
1173 :
1174 : // copy the auto formats or the attributes
1175 2 : pNewColl->CopyAttrs( rColl, true );
1176 :
1177 2 : if(rColl.IsAssignedToListLevelOfOutlineStyle())
1178 0 : pNewColl->AssignToListLevelOfOutlineStyle(rColl.GetAssignedOutlineStyleLevel());
1179 2 : pNewColl->SetPoolFmtId( rColl.GetPoolFmtId() );
1180 2 : pNewColl->SetPoolHelpId( rColl.GetPoolHelpId() );
1181 :
1182 : // Always set the HelpFile Id to default!
1183 2 : pNewColl->SetPoolHlpFileId( UCHAR_MAX );
1184 :
1185 2 : if( &rColl.GetNextTxtFmtColl() != &rColl )
1186 0 : pNewColl->SetNextTxtFmtColl( *CopyTxtColl( rColl.GetNextTxtFmtColl() ));
1187 :
1188 : // create the NumRule if necessary
1189 2 : if( this != rColl.GetDoc() )
1190 : {
1191 : const SfxPoolItem* pItem;
1192 2 : if( SfxItemState::SET == pNewColl->GetItemState( RES_PARATR_NUMRULE,
1193 2 : false, &pItem ))
1194 : {
1195 : const SwNumRule* pRule;
1196 0 : const OUString& rName = ((SwNumRuleItem*)pItem)->GetValue();
1197 0 : if( !rName.isEmpty() &&
1198 0 : 0 != ( pRule = rColl.GetDoc()->FindNumRulePtr( rName )) &&
1199 0 : !pRule->IsAutoRule() )
1200 : {
1201 0 : SwNumRule* pDestRule = FindNumRulePtr( rName );
1202 0 : if( pDestRule )
1203 0 : pDestRule->SetInvalidRule( true );
1204 : else
1205 0 : MakeNumRule( rName, pRule );
1206 : }
1207 : }
1208 : }
1209 2 : return pNewColl;
1210 : }
1211 :
1212 : /// copy the graphic nodes
1213 278 : SwGrfFmtColl* SwDoc::CopyGrfColl( const SwGrfFmtColl& rColl )
1214 : {
1215 278 : SwGrfFmtColl* pNewColl = FindGrfFmtCollByName( rColl.GetName() );
1216 278 : if( pNewColl )
1217 278 : return pNewColl;
1218 :
1219 : // Search for the "parent" first
1220 0 : SwGrfFmtColl* pParent = mpDfltGrfFmtColl;
1221 0 : if( pParent != rColl.DerivedFrom() )
1222 0 : pParent = CopyGrfColl( *(SwGrfFmtColl*)rColl.DerivedFrom() );
1223 :
1224 : // if not, copy them
1225 0 : pNewColl = MakeGrfFmtColl( rColl.GetName(), pParent );
1226 :
1227 : // copy the attributes
1228 0 : pNewColl->CopyAttrs( rColl );
1229 :
1230 0 : pNewColl->SetPoolFmtId( rColl.GetPoolFmtId() );
1231 0 : pNewColl->SetPoolHelpId( rColl.GetPoolHelpId() );
1232 :
1233 : // Always set the HelpFile Id to default!
1234 0 : pNewColl->SetPoolHlpFileId( UCHAR_MAX );
1235 :
1236 0 : return pNewColl;
1237 : }
1238 :
1239 2260 : static SwPageDesc* lcl_FindPageDesc( const SwPageDescs& rArr, const OUString& rName )
1240 : {
1241 7148 : for( sal_uInt16 n = rArr.size(); n; )
1242 : {
1243 4850 : SwPageDesc* pDesc = rArr[ --n ];
1244 4850 : if( pDesc->GetName() == rName )
1245 2222 : return pDesc;
1246 : }
1247 38 : return 0;
1248 : }
1249 :
1250 120 : void SwDoc::CopyFmtArr( const SwFmtsBase& rSourceArr,
1251 : SwFmtsBase& rDestArr,
1252 : FNCopyFmt fnCopyFmt,
1253 : SwFmt& rDfltFmt )
1254 : {
1255 : sal_uInt16 nSrc;
1256 : SwFmt* pSrc, *pDest;
1257 :
1258 : // 1st step: Create all formats (skip the 0th - it's the default one)
1259 766 : for( nSrc = rSourceArr.GetFmtCount(); nSrc > 1; )
1260 : {
1261 526 : pSrc = (SwFmt*)rSourceArr.GetFmt( --nSrc );
1262 526 : if( pSrc->IsDefault() || pSrc->IsAuto() )
1263 16 : continue;
1264 :
1265 510 : if( 0 == FindFmtByName( rDestArr, pSrc->GetName() ) )
1266 : {
1267 300 : if( RES_CONDTXTFMTCOLL == pSrc->Which() )
1268 6 : MakeCondTxtFmtColl( pSrc->GetName(), (SwTxtFmtColl*)&rDfltFmt );
1269 : else
1270 : // #i40550#
1271 294 : (this->*fnCopyFmt)( pSrc->GetName(), &rDfltFmt, false, true );
1272 : }
1273 : }
1274 :
1275 : // 2nd step: Copy all attributes, set the right parents
1276 766 : for( nSrc = rSourceArr.GetFmtCount(); nSrc > 1; )
1277 : {
1278 526 : pSrc = (SwFmt*)rSourceArr.GetFmt( --nSrc );
1279 526 : if( pSrc->IsDefault() || pSrc->IsAuto() )
1280 16 : continue;
1281 :
1282 510 : pDest = FindFmtByName( rDestArr, pSrc->GetName() );
1283 510 : pDest->SetAuto( false );
1284 510 : pDest->DelDiffs( *pSrc );
1285 :
1286 : // #i94285#: existing <SwFmtPageDesc> instance, before copying attributes
1287 : const SfxPoolItem* pItem;
1288 1530 : if( &GetAttrPool() != pSrc->GetAttrSet().GetPool() &&
1289 510 : SfxItemState::SET == pSrc->GetAttrSet().GetItemState(
1290 1020 : RES_PAGEDESC, false, &pItem ) &&
1291 0 : ((SwFmtPageDesc*)pItem)->GetPageDesc() )
1292 : {
1293 0 : SwFmtPageDesc aPageDesc( *(SwFmtPageDesc*)pItem );
1294 0 : const OUString& rNm = aPageDesc.GetPageDesc()->GetName();
1295 0 : SwPageDesc* pPageDesc = ::lcl_FindPageDesc( maPageDescs, rNm );
1296 0 : if( !pPageDesc )
1297 : {
1298 0 : pPageDesc = MakePageDesc(rNm);
1299 : }
1300 0 : aPageDesc.RegisterToPageDesc( *pPageDesc );
1301 0 : SwAttrSet aTmpAttrSet( pSrc->GetAttrSet() );
1302 0 : aTmpAttrSet.Put( aPageDesc );
1303 0 : pDest->SetFmtAttr( aTmpAttrSet );
1304 : }
1305 : else
1306 : {
1307 510 : pDest->SetFmtAttr( pSrc->GetAttrSet() );
1308 : }
1309 :
1310 510 : pDest->SetPoolFmtId( pSrc->GetPoolFmtId() );
1311 510 : pDest->SetPoolHelpId( pSrc->GetPoolHelpId() );
1312 :
1313 : // Always set the HelpFile Id to default!
1314 510 : pDest->SetPoolHlpFileId( UCHAR_MAX );
1315 :
1316 510 : if( pSrc->DerivedFrom() )
1317 : pDest->SetDerivedFrom( FindFmtByName( rDestArr,
1318 510 : pSrc->DerivedFrom()->GetName() ) );
1319 610 : if( RES_TXTFMTCOLL == pSrc->Which() ||
1320 100 : RES_CONDTXTFMTCOLL == pSrc->Which() )
1321 : {
1322 450 : SwTxtFmtColl* pSrcColl = (SwTxtFmtColl*)pSrc,
1323 450 : * pDstColl = (SwTxtFmtColl*)pDest;
1324 450 : if( &pSrcColl->GetNextTxtFmtColl() != pSrcColl )
1325 : pDstColl->SetNextTxtFmtColl( *(SwTxtFmtColl*)FindFmtByName(
1326 90 : rDestArr, pSrcColl->GetNextTxtFmtColl().GetName() ) );
1327 :
1328 450 : if(pSrcColl->IsAssignedToListLevelOfOutlineStyle())
1329 0 : pDstColl->AssignToListLevelOfOutlineStyle(pSrcColl->GetAssignedOutlineStyleLevel());
1330 :
1331 : //FEATURE::CONDCOLL
1332 450 : if( RES_CONDTXTFMTCOLL == pSrc->Which() )
1333 : // Copy the conditions, but delete the old ones first!
1334 : ((SwConditionTxtFmtColl*)pDstColl)->SetConditions(
1335 40 : ((SwConditionTxtFmtColl*)pSrc)->GetCondColls() );
1336 : //FEATURE::CONDCOLL
1337 : }
1338 : }
1339 120 : }
1340 :
1341 22162 : void SwDoc::CopyPageDescHeaderFooterImpl( bool bCpyHeader,
1342 : const SwFrmFmt& rSrcFmt, SwFrmFmt& rDestFmt )
1343 : {
1344 : // Treat the header and footer attributes in the right way:
1345 : // Copy content nodes across documents!
1346 22162 : sal_uInt16 nAttr = static_cast<sal_uInt16>( bCpyHeader ? RES_HEADER : RES_FOOTER );
1347 : const SfxPoolItem* pItem;
1348 22162 : if( SfxItemState::SET != rSrcFmt.GetAttrSet().GetItemState( nAttr, false, &pItem ))
1349 30996 : return ;
1350 :
1351 : // The header only contains the reference to the format from the other document!
1352 13328 : SfxPoolItem* pNewItem = pItem->Clone();
1353 :
1354 : SwFrmFmt* pOldFmt;
1355 13328 : if( bCpyHeader )
1356 6830 : pOldFmt = ((SwFmtHeader*)pNewItem)->GetHeaderFmt();
1357 : else
1358 6498 : pOldFmt = ((SwFmtFooter*)pNewItem)->GetFooterFmt();
1359 :
1360 13328 : if( pOldFmt )
1361 : {
1362 : SwFrmFmt* pNewFmt = new SwFrmFmt( GetAttrPool(), "CpyDesc",
1363 6216 : GetDfltFrmFmt() );
1364 6216 : pNewFmt->CopyAttrs( *pOldFmt, true );
1365 :
1366 12432 : if( SfxItemState::SET == pNewFmt->GetAttrSet().GetItemState(
1367 6216 : RES_CNTNT, false, &pItem ))
1368 : {
1369 6216 : SwFmtCntnt* pCntnt = (SwFmtCntnt*)pItem;
1370 6216 : if( pCntnt->GetCntntIdx() )
1371 : {
1372 6216 : SwNodeIndex aTmpIdx( GetNodes().GetEndOfAutotext() );
1373 6216 : const SwNodes& rSrcNds = rSrcFmt.GetDoc()->GetNodes();
1374 6216 : SwStartNode* pSttNd = GetNodes().MakeEmptySection( aTmpIdx,
1375 : bCpyHeader
1376 : ? SwHeaderStartNode
1377 12432 : : SwFooterStartNode );
1378 6216 : const SwNode& rCSttNd = pCntnt->GetCntntIdx()->GetNode();
1379 12432 : SwNodeRange aRg( rCSttNd, 0, *rCSttNd.EndOfSectionNode() );
1380 6216 : aTmpIdx = *pSttNd->EndOfSectionNode();
1381 6216 : rSrcNds._Copy( aRg, aTmpIdx );
1382 6216 : aTmpIdx = *pSttNd;
1383 6216 : rSrcFmt.GetDoc()->GetDocumentContentOperationsManager().CopyFlyInFlyImpl( aRg, 0, aTmpIdx );
1384 12432 : pNewFmt->SetFmtAttr( SwFmtCntnt( pSttNd ));
1385 : }
1386 : else
1387 0 : pNewFmt->ResetFmtAttr( RES_CNTNT );
1388 : }
1389 6216 : if( bCpyHeader )
1390 4050 : ((SwFmtHeader*)pNewItem)->RegisterToFormat(*pNewFmt);
1391 : else
1392 2166 : ((SwFmtFooter*)pNewItem)->RegisterToFormat(*pNewFmt);
1393 6216 : rDestFmt.SetFmtAttr( *pNewItem );
1394 : }
1395 13328 : delete pNewItem;
1396 : }
1397 :
1398 10596 : void SwDoc::CopyPageDesc( const SwPageDesc& rSrcDesc, SwPageDesc& rDstDesc,
1399 : bool bCopyPoolIds )
1400 : {
1401 10596 : bool bNotifyLayout = false;
1402 10596 : SwRootFrm* pTmpRoot = getIDocumentLayoutAccess().GetCurrentLayout();
1403 :
1404 10596 : rDstDesc.SetLandscape( rSrcDesc.GetLandscape() );
1405 10596 : rDstDesc.SetNumType( rSrcDesc.GetNumType() );
1406 10596 : if( rDstDesc.ReadUseOn() != rSrcDesc.ReadUseOn() )
1407 : {
1408 0 : rDstDesc.WriteUseOn( rSrcDesc.ReadUseOn() );
1409 0 : bNotifyLayout = true;
1410 : }
1411 :
1412 10596 : if( bCopyPoolIds )
1413 : {
1414 10594 : rDstDesc.SetPoolFmtId( rSrcDesc.GetPoolFmtId() );
1415 10594 : rDstDesc.SetPoolHelpId( rSrcDesc.GetPoolHelpId() );
1416 : // Always set the HelpFile Id to default!
1417 10594 : rDstDesc.SetPoolHlpFileId( UCHAR_MAX );
1418 : }
1419 :
1420 10596 : if( rSrcDesc.GetFollow() != &rSrcDesc )
1421 : {
1422 : SwPageDesc* pFollow = ::lcl_FindPageDesc( maPageDescs,
1423 2108 : rSrcDesc.GetFollow()->GetName() );
1424 2108 : if( !pFollow )
1425 : {
1426 : // copy
1427 0 : pFollow = MakePageDesc(rSrcDesc.GetFollow()->GetName());
1428 0 : CopyPageDesc( *rSrcDesc.GetFollow(), *pFollow );
1429 : }
1430 2108 : rDstDesc.SetFollow( pFollow );
1431 2108 : bNotifyLayout = true;
1432 : }
1433 :
1434 : // the header and footer attributes are copied separately
1435 : // the content sections have to be copied in their entirety
1436 : {
1437 10596 : SfxItemSet aAttrSet( rSrcDesc.GetMaster().GetAttrSet() );
1438 10596 : aAttrSet.ClearItem( RES_HEADER );
1439 10596 : aAttrSet.ClearItem( RES_FOOTER );
1440 :
1441 10596 : rDstDesc.GetMaster().DelDiffs( aAttrSet );
1442 10596 : rDstDesc.GetMaster().SetFmtAttr( aAttrSet );
1443 :
1444 10596 : aAttrSet.ClearItem();
1445 10596 : aAttrSet.Put( rSrcDesc.GetLeft().GetAttrSet() );
1446 10596 : aAttrSet.ClearItem( RES_HEADER );
1447 10596 : aAttrSet.ClearItem( RES_FOOTER );
1448 :
1449 10596 : rDstDesc.GetLeft().DelDiffs( aAttrSet );
1450 10596 : rDstDesc.GetLeft().SetFmtAttr( aAttrSet );
1451 :
1452 10596 : aAttrSet.ClearItem();
1453 10596 : aAttrSet.Put( rSrcDesc.GetFirstMaster().GetAttrSet() );
1454 10596 : aAttrSet.ClearItem( RES_HEADER );
1455 10596 : aAttrSet.ClearItem( RES_FOOTER );
1456 :
1457 10596 : rDstDesc.GetFirstMaster().DelDiffs( aAttrSet );
1458 10596 : rDstDesc.GetFirstMaster().SetFmtAttr( aAttrSet );
1459 :
1460 10596 : aAttrSet.ClearItem();
1461 10596 : aAttrSet.Put( rSrcDesc.GetFirstLeft().GetAttrSet() );
1462 10596 : aAttrSet.ClearItem( RES_HEADER );
1463 10596 : aAttrSet.ClearItem( RES_FOOTER );
1464 :
1465 10596 : rDstDesc.GetFirstLeft().DelDiffs( aAttrSet );
1466 10596 : rDstDesc.GetFirstLeft().SetFmtAttr( aAttrSet );
1467 : }
1468 :
1469 10596 : CopyHeader( rSrcDesc.GetMaster(), rDstDesc.GetMaster() );
1470 10596 : CopyFooter( rSrcDesc.GetMaster(), rDstDesc.GetMaster() );
1471 10596 : if( !rDstDesc.IsHeaderShared() )
1472 550 : CopyHeader( rSrcDesc.GetLeft(), rDstDesc.GetLeft() );
1473 : else
1474 10046 : rDstDesc.GetLeft().SetFmtAttr( rDstDesc.GetMaster().GetHeader() );
1475 10596 : if( !rDstDesc.IsFirstShared() )
1476 : {
1477 80 : CopyHeader( rSrcDesc.GetFirstMaster(), rDstDesc.GetFirstMaster() );
1478 80 : rDstDesc.GetFirstLeft().SetFmtAttr(rDstDesc.GetFirstMaster().GetHeader());
1479 : }
1480 : else
1481 : {
1482 10516 : rDstDesc.GetFirstMaster().SetFmtAttr( rDstDesc.GetMaster().GetHeader() );
1483 10516 : rDstDesc.GetFirstLeft().SetFmtAttr(rDstDesc.GetLeft().GetHeader());
1484 : }
1485 :
1486 10596 : if( !rDstDesc.IsFooterShared() )
1487 228 : CopyFooter( rSrcDesc.GetLeft(), rDstDesc.GetLeft() );
1488 : else
1489 10368 : rDstDesc.GetLeft().SetFmtAttr( rDstDesc.GetMaster().GetFooter() );
1490 10596 : if( !rDstDesc.IsFirstShared() )
1491 : {
1492 80 : CopyFooter( rSrcDesc.GetFirstMaster(), rDstDesc.GetFirstMaster() );
1493 80 : rDstDesc.GetFirstLeft().SetFmtAttr(rDstDesc.GetFirstMaster().GetFooter());
1494 : }
1495 : else
1496 : {
1497 10516 : rDstDesc.GetFirstMaster().SetFmtAttr( rDstDesc.GetMaster().GetFooter() );
1498 10516 : rDstDesc.GetFirstLeft().SetFmtAttr(rDstDesc.GetLeft().GetFooter());
1499 : }
1500 :
1501 10596 : if( bNotifyLayout && pTmpRoot )
1502 : {
1503 32 : std::set<SwRootFrm*> aAllLayouts = GetAllLayouts();
1504 32 : std::for_each( aAllLayouts.begin(), aAllLayouts.end(),std::mem_fun(&SwRootFrm::AllCheckPageDescs));
1505 : }
1506 :
1507 : // If foot notes change the pages have to be triggered
1508 10596 : if( !(rDstDesc.GetFtnInfo() == rSrcDesc.GetFtnInfo()) )
1509 : {
1510 14 : rDstDesc.SetFtnInfo( rSrcDesc.GetFtnInfo() );
1511 14 : SwMsgPoolItem aInfo( RES_PAGEDESC_FTNINFO );
1512 : {
1513 14 : rDstDesc.GetMaster().ModifyBroadcast( &aInfo, 0, TYPE(SwFrm) );
1514 : }
1515 : {
1516 14 : rDstDesc.GetLeft().ModifyBroadcast( &aInfo, 0, TYPE(SwFrm) );
1517 : }
1518 : {
1519 14 : rDstDesc.GetFirstMaster().ModifyBroadcast( &aInfo, 0, TYPE(SwFrm) );
1520 : }
1521 : {
1522 14 : rDstDesc.GetFirstLeft().ModifyBroadcast( &aInfo, 0, TYPE(SwFrm) );
1523 14 : }
1524 : }
1525 10596 : }
1526 :
1527 40 : void SwDoc::ReplaceStyles( const SwDoc& rSource, bool bIncludePageStyles )
1528 : {
1529 40 : ::sw::UndoGuard const undoGuard(GetIDocumentUndoRedo());
1530 :
1531 : CopyFmtArr( *rSource.mpCharFmtTbl, *mpCharFmtTbl,
1532 40 : &SwDoc::_MakeCharFmt, *mpDfltCharFmt );
1533 : CopyFmtArr( *rSource.mpFrmFmtTbl, *mpFrmFmtTbl,
1534 40 : &SwDoc::_MakeFrmFmt, *mpDfltFrmFmt );
1535 : CopyFmtArr( *rSource.mpTxtFmtCollTbl, *mpTxtFmtCollTbl,
1536 40 : &SwDoc::_MakeTxtFmtColl, *mpDfltTxtFmtColl );
1537 :
1538 : sal_uInt16 nCnt;
1539 :
1540 : //To-Do:
1541 : // a) in rtf export don't export our hideous pgdsctbl
1542 : // extension to rtf anymore
1543 : // b) in sd rtf import (View::InsertData) don't use
1544 : // a super-fragile test for mere presence of \trowd to
1545 : // indicate import of rtf into a table
1546 : // c) then drop use of bIncludePageStyles
1547 40 : if (bIncludePageStyles)
1548 : {
1549 : // and now the page templates
1550 38 : nCnt = rSource.maPageDescs.size();
1551 38 : if( nCnt )
1552 : {
1553 : // a different Doc -> Number formatter needs to be merged
1554 38 : SwTblNumFmtMerge aTNFM( rSource, *this );
1555 :
1556 : // 1st step: Create all formats (skip the 0th - it's the default!)
1557 152 : while( nCnt )
1558 : {
1559 76 : SwPageDesc *pSrc = rSource.maPageDescs[ --nCnt ];
1560 76 : if( 0 == ::lcl_FindPageDesc( maPageDescs, pSrc->GetName() ) )
1561 38 : MakePageDesc( pSrc->GetName() );
1562 : }
1563 :
1564 : // 2nd step: Copy all attributes, set the right parents
1565 152 : for( nCnt = rSource.maPageDescs.size(); nCnt; )
1566 : {
1567 76 : SwPageDesc *pSrc = rSource.maPageDescs[ --nCnt ];
1568 76 : CopyPageDesc( *pSrc, *::lcl_FindPageDesc( maPageDescs, pSrc->GetName() ));
1569 38 : }
1570 : }
1571 : }
1572 :
1573 : // then there are the numbering templates
1574 40 : nCnt = rSource.GetNumRuleTbl().size();
1575 40 : if( nCnt )
1576 : {
1577 40 : const SwNumRuleTbl& rArr = rSource.GetNumRuleTbl();
1578 80 : for( sal_uInt16 n = 0; n < nCnt; ++n )
1579 : {
1580 40 : const SwNumRule& rR = *rArr[ n ];
1581 40 : SwNumRule* pNew = FindNumRulePtr( rR.GetName());
1582 40 : if( pNew )
1583 40 : pNew->CopyNumRule( this, rR );
1584 : else
1585 : {
1586 0 : if( !rR.IsAutoRule() )
1587 0 : MakeNumRule( rR.GetName(), &rR );
1588 : else
1589 : {
1590 : // as we reset all styles, there shouldn't be any unknown
1591 : // automatic SwNumRules, because all should have been
1592 : // created by the style copying!
1593 : // So just warn and ignore.
1594 : SAL_WARN( "sw.styles", "Found unknown auto SwNumRule during reset!" );
1595 : }
1596 : }
1597 : }
1598 : }
1599 :
1600 40 : if (undoGuard.UndoWasEnabled())
1601 : {
1602 : // nodes array was modified!
1603 4 : GetIDocumentUndoRedo().DelAllUndoObj();
1604 : }
1605 :
1606 40 : getIDocumentState().SetModified();
1607 40 : }
1608 :
1609 1390820 : SwFmt* SwDoc::FindFmtByName( const SwFmtsBase& rFmtArr,
1610 : const OUString& rName ) const
1611 : {
1612 1390820 : SwFmt* pFnd = 0;
1613 28240971 : for( sal_uInt16 n = 0; n < rFmtArr.GetFmtCount(); n++ )
1614 : {
1615 : // Does the Doc already contain the template?
1616 27729228 : if( rFmtArr.GetFmt(n)->GetName() == rName )
1617 : {
1618 879077 : pFnd = (SwFmt*)rFmtArr.GetFmt(n);
1619 879077 : break;
1620 : }
1621 : }
1622 1390820 : return pFnd;
1623 : }
1624 :
1625 0 : void SwDoc::MoveLeftMargin( const SwPaM& rPam, bool bRight, bool bModulus )
1626 : {
1627 0 : SwHistory* pHistory = 0;
1628 0 : if (GetIDocumentUndoRedo().DoesUndo())
1629 : {
1630 : SwUndoMoveLeftMargin* pUndo = new SwUndoMoveLeftMargin( rPam, bRight,
1631 0 : bModulus );
1632 0 : pHistory = &pUndo->GetHistory();
1633 0 : GetIDocumentUndoRedo().AppendUndo( pUndo );
1634 : }
1635 :
1636 0 : const SvxTabStopItem& rTabItem = (SvxTabStopItem&)GetDefault( RES_PARATR_TABSTOP );
1637 0 : sal_uInt16 nDefDist = rTabItem.Count() ?
1638 0 : static_cast<sal_uInt16>(rTabItem[0].GetTabPos()) : 1134;
1639 0 : const SwPosition &rStt = *rPam.Start(), &rEnd = *rPam.End();
1640 0 : SwNodeIndex aIdx( rStt.nNode );
1641 0 : while( aIdx <= rEnd.nNode )
1642 : {
1643 0 : SwTxtNode* pTNd = aIdx.GetNode().GetTxtNode();
1644 0 : if( pTNd )
1645 : {
1646 0 : SvxLRSpaceItem aLS( (SvxLRSpaceItem&)pTNd->SwCntntNode::GetAttr( RES_LR_SPACE ) );
1647 :
1648 : // #i93873# See also lcl_MergeListLevelIndentAsLRSpaceItem in thints.cxx
1649 0 : if ( pTNd->AreListLevelIndentsApplicable() )
1650 : {
1651 0 : const SwNumRule* pRule = pTNd->GetNumRule();
1652 0 : if ( pRule )
1653 : {
1654 0 : const int nListLevel = pTNd->GetActualListLevel();
1655 0 : if ( nListLevel >= 0 )
1656 : {
1657 0 : const SwNumFmt& rFmt = pRule->Get(static_cast<sal_uInt16>(nListLevel));
1658 0 : if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
1659 : {
1660 0 : aLS.SetTxtLeft( rFmt.GetIndentAt() );
1661 0 : aLS.SetTxtFirstLineOfst( static_cast<short>(rFmt.GetFirstLineIndent()) );
1662 : }
1663 : }
1664 : }
1665 : }
1666 :
1667 0 : long nNext = aLS.GetTxtLeft();
1668 0 : if( bModulus )
1669 0 : nNext = ( nNext / nDefDist ) * nDefDist;
1670 :
1671 0 : if( bRight )
1672 0 : nNext += nDefDist;
1673 : else
1674 0 : if(nNext >0) // fdo#75936 set limit for decreasing indent
1675 0 : nNext -= nDefDist;
1676 :
1677 0 : aLS.SetTxtLeft( nNext );
1678 :
1679 0 : SwRegHistory aRegH( pTNd, *pTNd, pHistory );
1680 0 : pTNd->SetAttr( aLS );
1681 : }
1682 0 : ++aIdx;
1683 : }
1684 0 : getIDocumentState().SetModified();
1685 0 : }
1686 :
1687 87112 : bool SwDoc::DontExpandFmt( const SwPosition& rPos, bool bFlag )
1688 : {
1689 87112 : bool bRet = false;
1690 87112 : SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
1691 87112 : if( pTxtNd )
1692 : {
1693 87112 : bRet = pTxtNd->DontExpandFmt( rPos.nContent, bFlag );
1694 87112 : if( bRet && GetIDocumentUndoRedo().DoesUndo() )
1695 : {
1696 2 : GetIDocumentUndoRedo().AppendUndo( new SwUndoDontExpandFmt(rPos) );
1697 : }
1698 : }
1699 87112 : return bRet;
1700 : }
1701 :
1702 19810 : SwTableBoxFmt* SwDoc::MakeTableBoxFmt()
1703 : {
1704 : SwTableBoxFmt* pFmt = new SwTableBoxFmt( GetAttrPool(), aEmptyOUStr,
1705 19810 : mpDfltFrmFmt );
1706 19810 : getIDocumentState().SetModified();
1707 19810 : return pFmt;
1708 : }
1709 :
1710 6808 : SwTableLineFmt* SwDoc::MakeTableLineFmt()
1711 : {
1712 : SwTableLineFmt* pFmt = new SwTableLineFmt( GetAttrPool(), aEmptyOUStr,
1713 6808 : mpDfltFrmFmt );
1714 6808 : getIDocumentState().SetModified();
1715 6808 : return pFmt;
1716 : }
1717 :
1718 4740 : void SwDoc::_CreateNumberFormatter()
1719 : {
1720 : OSL_ENSURE( !mpNumberFormatter, "is already there" );
1721 :
1722 4740 : LanguageType eLang = LANGUAGE_SYSTEM;
1723 :
1724 4740 : mpNumberFormatter = new SvNumberFormatter( comphelper::getProcessComponentContext(), eLang );
1725 4740 : mpNumberFormatter->SetEvalDateFormat( NF_EVALDATEFORMAT_FORMAT_INTL );
1726 4740 : mpNumberFormatter->SetYear2000(static_cast<sal_uInt16>(::utl::MiscCfg().GetYear2000()));
1727 4740 : }
1728 :
1729 444 : SwTblNumFmtMerge::SwTblNumFmtMerge( const SwDoc& rSrc, SwDoc& rDest )
1730 444 : : pNFmt( 0 )
1731 : {
1732 : // a different Doc -> Number formatter needs to be merged
1733 : SvNumberFormatter* pN;
1734 444 : if( &rSrc != &rDest && 0 != ( pN = ((SwDoc&)rSrc).GetNumberFormatter( false ) ))
1735 56 : ( pNFmt = rDest.GetNumberFormatter( true ))->MergeFormatter( *pN );
1736 :
1737 444 : if( &rSrc != &rDest )
1738 74 : ((SwGetRefFieldType*)rSrc.getIDocumentFieldsAccess().GetSysFldType( RES_GETREFFLD ))->
1739 74 : MergeWithOtherDoc( rDest );
1740 444 : }
1741 :
1742 444 : SwTblNumFmtMerge::~SwTblNumFmtMerge()
1743 : {
1744 444 : if( pNFmt )
1745 56 : pNFmt->ClearMergeTable();
1746 444 : }
1747 :
1748 0 : void SwDoc::SetTxtFmtCollByAutoFmt( const SwPosition& rPos, sal_uInt16 nPoolId,
1749 : const SfxItemSet* pSet )
1750 : {
1751 0 : SwPaM aPam( rPos );
1752 0 : SwTxtNode* pTNd = rPos.nNode.GetNode().GetTxtNode();
1753 : assert(pTNd);
1754 :
1755 0 : if (mbIsAutoFmtRedline)
1756 : {
1757 : // create the redline object
1758 0 : const SwTxtFmtColl& rColl = *pTNd->GetTxtColl();
1759 0 : SwRangeRedline* pRedl = new SwRangeRedline( nsRedlineType_t::REDLINE_FMTCOLL, aPam );
1760 0 : pRedl->SetMark();
1761 :
1762 : // Only those items that are not set by the Set again in the Node
1763 : // are of interest. Thus, we take the difference.
1764 : SwRedlineExtraData_FmtColl aExtraData( rColl.GetName(),
1765 0 : rColl.GetPoolFmtId() );
1766 0 : if( pSet && pTNd->HasSwAttrSet() )
1767 : {
1768 0 : SfxItemSet aTmp( *pTNd->GetpSwAttrSet() );
1769 0 : aTmp.Differentiate( *pSet );
1770 : // we handle the adjust item separately
1771 : const SfxPoolItem* pItem;
1772 0 : if( SfxItemState::SET == pTNd->GetpSwAttrSet()->GetItemState(
1773 0 : RES_PARATR_ADJUST, false, &pItem ))
1774 0 : aTmp.Put( *pItem );
1775 0 : aExtraData.SetItemSet( aTmp );
1776 : }
1777 0 : pRedl->SetExtraData( &aExtraData );
1778 :
1779 : //TODO: Undo is still missing!
1780 0 : getIDocumentRedlineAccess().AppendRedline( pRedl, true );
1781 : }
1782 :
1783 0 : SetTxtFmtColl( aPam, getIDocumentStylePoolAccess().GetTxtCollFromPool( nPoolId ) );
1784 :
1785 0 : if (pSet && pSet->Count())
1786 : {
1787 0 : aPam.SetMark();
1788 0 : aPam.GetMark()->nContent.Assign(pTNd, pTNd->GetTxt().getLength());
1789 0 : getIDocumentContentOperations().InsertItemSet( aPam, *pSet, 0 );
1790 0 : }
1791 0 : }
1792 :
1793 0 : void SwDoc::SetFmtItemByAutoFmt( const SwPaM& rPam, const SfxItemSet& rSet )
1794 : {
1795 0 : SwTxtNode* pTNd = rPam.GetPoint()->nNode.GetNode().GetTxtNode();
1796 : assert(pTNd);
1797 :
1798 0 : RedlineMode_t eOld = getIDocumentRedlineAccess().GetRedlineMode();
1799 :
1800 0 : if (mbIsAutoFmtRedline)
1801 : {
1802 : // create the redline object
1803 0 : SwRangeRedline* pRedl = new SwRangeRedline( nsRedlineType_t::REDLINE_FORMAT, rPam );
1804 0 : if( !pRedl->HasMark() )
1805 0 : pRedl->SetMark();
1806 :
1807 : // Only those items that are not set by the Set again in the Node
1808 : // are of interest. Thus, we take the difference.
1809 0 : SwRedlineExtraData_Format aExtraData( rSet );
1810 :
1811 0 : pRedl->SetExtraData( &aExtraData );
1812 :
1813 : //TODO: Undo is still missing!
1814 0 : getIDocumentRedlineAccess().AppendRedline( pRedl, true );
1815 :
1816 0 : getIDocumentRedlineAccess().SetRedlineMode_intern( (RedlineMode_t)(eOld | nsRedlineMode_t::REDLINE_IGNORE));
1817 : }
1818 :
1819 0 : const sal_Int32 nEnd(rPam.End()->nContent.GetIndex());
1820 0 : std::vector<sal_uInt16> whichIds;
1821 0 : SfxItemIter iter(rSet);
1822 0 : for (SfxPoolItem const* pItem = iter.FirstItem();
1823 : pItem; pItem = iter.NextItem())
1824 : {
1825 0 : whichIds.push_back(pItem->Which());
1826 0 : whichIds.push_back(pItem->Which());
1827 : }
1828 0 : whichIds.push_back(0);
1829 0 : SfxItemSet currentSet(GetAttrPool(), &whichIds[0]);
1830 0 : pTNd->GetAttr(currentSet, nEnd, nEnd, false, true, false);
1831 0 : for (size_t i = 0; whichIds[i]; i += 2)
1832 : { // yuk - want to explicitly set the pool defaults too :-/
1833 0 : currentSet.Put(currentSet.Get(whichIds[i], true));
1834 : }
1835 :
1836 0 : getIDocumentContentOperations().InsertItemSet( rPam, rSet, nsSetAttrMode::SETATTR_DONTEXPAND );
1837 :
1838 : // fdo#62536: DONTEXPAND does not work when there is already an AUTOFMT
1839 : // here, so insert the old attributes as an empty hint to stop expand
1840 0 : SwPaM endPam(*pTNd, nEnd);
1841 0 : endPam.SetMark();
1842 0 : getIDocumentContentOperations().InsertItemSet(endPam, currentSet, nsSetAttrMode::SETATTR_DEFAULT);
1843 :
1844 0 : getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
1845 0 : }
1846 :
1847 295916 : void SwDoc::ChgFmt(SwFmt & rFmt, const SfxItemSet & rSet)
1848 : {
1849 295916 : if (GetIDocumentUndoRedo().DoesUndo())
1850 : {
1851 : // copying <rSet> to <aSet>
1852 3484 : SfxItemSet aSet(rSet);
1853 : // remove from <aSet> all items, which are already set at the format
1854 3484 : aSet.Differentiate(rFmt.GetAttrSet());
1855 : // <aSet> contains now all *new* items for the format
1856 :
1857 : // copying current format item set to <aOldSet>
1858 6968 : SfxItemSet aOldSet(rFmt.GetAttrSet());
1859 : // insert new items into <aOldSet>
1860 3484 : aOldSet.Put(aSet);
1861 : // invalidate all new items in <aOldSet> in order to clear these items,
1862 : // if the undo action is triggered.
1863 : {
1864 3484 : SfxItemIter aIter(aSet);
1865 :
1866 3484 : const SfxPoolItem * pItem = aIter.FirstItem();
1867 14220 : while (pItem != NULL)
1868 : {
1869 7252 : aOldSet.InvalidateItem(pItem->Which());
1870 :
1871 7252 : pItem = aIter.NextItem();
1872 3484 : }
1873 : }
1874 :
1875 3484 : SwUndo * pUndo = new SwUndoFmtAttr(aOldSet, rFmt);
1876 :
1877 6968 : GetIDocumentUndoRedo().AppendUndo(pUndo);
1878 : }
1879 :
1880 295916 : rFmt.SetFmtAttr(rSet);
1881 295916 : }
1882 :
1883 12 : void SwDoc::RenameFmt(SwFmt & rFmt, const OUString & sNewName,
1884 : bool bBroadcast)
1885 : {
1886 12 : SfxStyleFamily eFamily = SFX_STYLE_FAMILY_ALL;
1887 :
1888 12 : if (GetIDocumentUndoRedo().DoesUndo())
1889 : {
1890 12 : SwUndo * pUndo = NULL;
1891 :
1892 12 : switch (rFmt.Which())
1893 : {
1894 : case RES_CHRFMT:
1895 4 : pUndo = new SwUndoRenameCharFmt(rFmt.GetName(), sNewName, this);
1896 4 : eFamily = SFX_STYLE_FAMILY_CHAR;
1897 4 : break;
1898 : case RES_TXTFMTCOLL:
1899 4 : pUndo = new SwUndoRenameFmtColl(rFmt.GetName(), sNewName, this);
1900 4 : eFamily = SFX_STYLE_FAMILY_PARA;
1901 4 : break;
1902 : case RES_FRMFMT:
1903 0 : pUndo = new SwUndoRenameFrmFmt(rFmt.GetName(), sNewName, this);
1904 0 : eFamily = SFX_STYLE_FAMILY_FRAME;
1905 0 : break;
1906 :
1907 : default:
1908 4 : break;
1909 : }
1910 :
1911 12 : if (pUndo)
1912 : {
1913 8 : GetIDocumentUndoRedo().AppendUndo(pUndo);
1914 : }
1915 : }
1916 :
1917 12 : rFmt.SetName(sNewName);
1918 :
1919 12 : if (bBroadcast)
1920 0 : BroadcastStyleOperation(sNewName, eFamily, SFX_STYLESHEET_MODIFIED);
1921 12 : }
1922 :
1923 :
1924 0 : std::vector<Color> SwDoc::GetDocColors()
1925 : {
1926 0 : std::vector<Color> docColors;
1927 :
1928 0 : for(unsigned int i = 0; i < m_pNodes->Count(); ++i)
1929 : {
1930 0 : const SwNode* pNode = (*m_pNodes)[i];
1931 0 : if( ! pNode->IsTxtNode() )
1932 0 : continue;
1933 :
1934 0 : const SfxItemSet* pItemSet = pNode->GetTxtNode()->GetpSwAttrSet();
1935 0 : if( pItemSet == 0 )
1936 0 : continue;
1937 :
1938 0 : SfxWhichIter aIter( *pItemSet );
1939 0 : sal_uInt16 nWhich = aIter.FirstWhich();
1940 0 : while( nWhich )
1941 : {
1942 : const SfxPoolItem *pItem;
1943 0 : if( SfxItemState::SET == pItemSet->GetItemState( nWhich, false, &pItem ) )
1944 : {
1945 0 : sal_uInt16 aWhich = pItem->Which();
1946 0 : switch (aWhich)
1947 : {
1948 : // list of color attributes to collect
1949 : case RES_CHRATR_COLOR:
1950 : case RES_CHRATR_HIGHLIGHT:
1951 : case RES_BACKGROUND:
1952 : {
1953 0 : Color aColor( ((SvxColorItem*)pItem)->GetValue() );
1954 0 : if( COL_AUTO != aColor.GetColor() &&
1955 0 : std::find(docColors.begin(), docColors.end(), aColor) == docColors.end() )
1956 : {
1957 0 : docColors.push_back( aColor );
1958 : }
1959 : }
1960 0 : break;
1961 : default:
1962 0 : break;
1963 : }
1964 : }
1965 :
1966 0 : nWhich = aIter.NextWhich();
1967 : }
1968 0 : }
1969 0 : return docColors;
1970 : }
1971 :
1972 : // #i69627#
1973 : namespace docfunc
1974 : {
1975 60 : bool HasOutlineStyleToBeWrittenAsNormalListStyle( SwDoc& rDoc )
1976 : {
1977 : // If a parent paragraph style of one of the parargraph styles, which
1978 : // are assigned to the list levels of the outline style, has a list style
1979 : // set or inherits a list style from its parent style, the outline style
1980 : // has to be written as a normal list style to the OpenDocument file
1981 : // format or the OpenOffice.org file format.
1982 60 : bool bRet( false );
1983 :
1984 60 : const SwTxtFmtColls* pTxtFmtColls( rDoc.GetTxtFmtColls() );
1985 60 : if ( pTxtFmtColls )
1986 : {
1987 60 : const sal_uInt16 nCount = pTxtFmtColls->size();
1988 624 : for ( sal_uInt16 i = 0; i < nCount; ++i )
1989 : {
1990 564 : SwTxtFmtColl* pTxtFmtColl = (*pTxtFmtColls)[i];
1991 :
1992 1068 : if ( pTxtFmtColl->IsDefault() ||
1993 504 : ! pTxtFmtColl->IsAssignedToListLevelOfOutlineStyle() )
1994 : {
1995 564 : continue;
1996 : }
1997 :
1998 : const SwTxtFmtColl* pParentTxtFmtColl =
1999 0 : dynamic_cast<const SwTxtFmtColl*>( pTxtFmtColl->DerivedFrom());
2000 0 : if ( !pParentTxtFmtColl )
2001 0 : continue;
2002 :
2003 0 : if ( SfxItemState::SET == pParentTxtFmtColl->GetItemState( RES_PARATR_NUMRULE ) )
2004 : {
2005 : // #i106218# consider that the outline style is set
2006 0 : const SwNumRuleItem& rDirectItem = pParentTxtFmtColl->GetNumRule();
2007 0 : if ( rDirectItem.GetValue() != rDoc.GetOutlineNumRule()->GetName() )
2008 : {
2009 0 : bRet = true;
2010 0 : break;
2011 : }
2012 : }
2013 : }
2014 :
2015 : }
2016 60 : return bRet;
2017 : }
2018 : }
2019 :
2020 41725 : SwFmtsBase::~SwFmtsBase() {}
2021 :
2022 336 : sal_uInt16 SwFrmFmts::GetPos(const SwFrmFmt* p) const
2023 : {
2024 336 : const_iterator it = std::find(begin(), end(), p);
2025 336 : return it == end() ? USHRT_MAX : it - begin();
2026 : }
2027 :
2028 228 : bool SwFrmFmts::Contains(const SwFrmFmt* p) const
2029 : {
2030 228 : return std::find(begin(), end(), p) != end();
2031 : }
2032 :
2033 58205 : SwFrmFmts::~SwFrmFmts()
2034 : {
2035 24265 : for(const_iterator it = begin(); it != end(); ++it)
2036 2730 : delete *it;
2037 36670 : }
2038 :
2039 2 : sal_uInt16 SwCharFmts::GetPos(const SwCharFmt* p) const
2040 : {
2041 2 : const_iterator it = std::find(begin(), end(), p);
2042 2 : return it == end() ? USHRT_MAX : it - begin();
2043 : }
2044 :
2045 0 : bool SwCharFmts::Contains(const SwCharFmt* p) const
2046 : {
2047 0 : return std::find(begin(), end(), p) != end();
2048 : }
2049 :
2050 15135 : SwCharFmts::~SwCharFmts()
2051 : {
2052 30239 : for(const_iterator it = begin(); it != end(); ++it)
2053 25194 : delete *it;
2054 10360 : }
2055 :
2056 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
