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