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 :
22 : #include <sal/macros.h>
23 : #include <hintids.hxx>
24 : #include <editeng/ulspitem.hxx>
25 : #include <editeng/lrspitem.hxx>
26 : #include <editeng/fhgtitem.hxx>
27 : #include <doc.hxx>
28 : #include <fmtcol.hxx>
29 : #include <fmtcolfunc.hxx>
30 : #include <hints.hxx>
31 : #include <calc.hxx>
32 : #include <node.hxx>
33 : #include <numrule.hxx>
34 : #include <paratr.hxx>
35 : #include <calbck.hxx>
36 : #include <svl/intitem.hxx>
37 :
38 121876 : TYPEINIT1( SwTextFormatColl, SwFormatColl );
39 0 : TYPEINIT1( SwGrfFormatColl, SwFormatColl );
40 21 : TYPEINIT1( SwConditionTextFormatColl, SwTextFormatColl );
41 0 : TYPEINIT1( SwCollCondition, SwClient );
42 :
43 : namespace TextFormatCollFunc
44 : {
45 : // #i71574#
46 120204 : void CheckTextFormatCollForDeletionOfAssignmentToOutlineStyle(
47 : SwFormat* pFormat,
48 : const SwNumRuleItem* pNewNumRuleItem )
49 : {
50 120204 : SwTextFormatColl* pTextFormatColl = dynamic_cast<SwTextFormatColl*>(pFormat);
51 120204 : if ( !pTextFormatColl )
52 : {
53 : OSL_FAIL( "<TextFormatCollFunc::CheckTextFormatCollFuncForDeletionOfAssignmentToOutlineStyle> - misuse of method - it's only for instances of <SwTextFormatColl>" );
54 120204 : return;
55 : }
56 :
57 : // #i73790#
58 240286 : if ( !pTextFormatColl->StayAssignedToListLevelOfOutlineStyle() &&
59 120082 : pTextFormatColl->IsAssignedToListLevelOfOutlineStyle() )
60 : {
61 3112 : if ( !pNewNumRuleItem )
62 : {
63 2996 : pTextFormatColl->GetItemState( RES_PARATR_NUMRULE, false, reinterpret_cast<const SfxPoolItem**>(&pNewNumRuleItem) );
64 : }
65 3112 : if ( pNewNumRuleItem )
66 : {
67 3111 : OUString sNumRuleName = pNewNumRuleItem->GetValue();
68 12444 : if ( sNumRuleName.isEmpty() ||
69 12444 : sNumRuleName != pTextFormatColl->GetDoc()->GetOutlineNumRule()->GetName() )
70 : {
71 : // delete assignment of paragraph style to list level of outline style.
72 0 : pTextFormatColl->DeleteAssignmentToListLevelOfOutlineStyle();
73 3111 : }
74 : }
75 : }
76 : }
77 :
78 4082 : SwNumRule* GetNumRule( SwTextFormatColl& rTextFormatColl )
79 : {
80 4082 : SwNumRule* pNumRule( 0 );
81 :
82 4082 : const SwNumRuleItem* pNumRuleItem( 0 );
83 4082 : rTextFormatColl.GetItemState( RES_PARATR_NUMRULE, false, reinterpret_cast<const SfxPoolItem**>(&pNumRuleItem) );
84 4082 : if ( pNumRuleItem )
85 : {
86 2075 : const OUString sNumRuleName = pNumRuleItem->GetValue();
87 2075 : if ( !sNumRuleName.isEmpty() )
88 : {
89 1909 : pNumRule = rTextFormatColl.GetDoc()->FindNumRulePtr( sNumRuleName );
90 2075 : }
91 : }
92 :
93 4082 : return pNumRule;
94 : }
95 :
96 2041 : void AddToNumRule( SwTextFormatColl& rTextFormatColl )
97 : {
98 2041 : SwNumRule* pNumRule = GetNumRule( rTextFormatColl );
99 2041 : if ( pNumRule )
100 : {
101 1902 : pNumRule->AddParagraphStyle( rTextFormatColl );
102 : }
103 2041 : }
104 :
105 2041 : void RemoveFromNumRule( SwTextFormatColl& rTextFormatColl )
106 : {
107 2041 : SwNumRule* pNumRule = GetNumRule( rTextFormatColl );
108 2041 : if ( pNumRule )
109 : {
110 7 : pNumRule->RemoveParagraphStyle( rTextFormatColl );
111 : }
112 2041 : }
113 : } // end of namespace TextFormatCollFunc
114 :
115 434145 : void SwTextFormatColl::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
116 : {
117 434145 : if( GetDoc()->IsInDtor() )
118 : {
119 11521 : SwFormatColl::Modify( pOld, pNew );
120 445666 : return;
121 : }
122 :
123 422624 : bool bNewParent( false ); // #i66431# - adjust type of <bNewParent>
124 422624 : const SvxULSpaceItem *pNewULSpace = 0, *pOldULSpace = 0;
125 422624 : const SvxLRSpaceItem *pNewLRSpace = 0, *pOldLRSpace = 0;
126 422624 : const SvxFontHeightItem* aFontSizeArr[3] = {0,0,0};
127 : // #i70223#
128 422624 : const bool bAssignedToListLevelOfOutlineStyle(IsAssignedToListLevelOfOutlineStyle());
129 422624 : const SwNumRuleItem* pNewNumRuleItem( 0L );
130 :
131 422624 : const SwAttrSetChg *pNewChgSet = 0, *pOldChgSet = 0;
132 :
133 422624 : switch( pOld ? pOld->Which() : pNew ? pNew->Which() : 0 )
134 : {
135 : case RES_ATTRSET_CHG:
136 : // Only recalculate if we're not the sender!
137 385771 : pNewChgSet = static_cast<const SwAttrSetChg*>(pNew);
138 385771 : pOldChgSet = static_cast<const SwAttrSetChg*>(pOld);
139 385771 : pNewChgSet->GetChgSet()->GetItemState(
140 385771 : RES_LR_SPACE, false, reinterpret_cast<const SfxPoolItem**>(&pNewLRSpace) );
141 385771 : pNewChgSet->GetChgSet()->GetItemState(
142 385771 : RES_UL_SPACE, false, reinterpret_cast<const SfxPoolItem**>(&pNewULSpace) );
143 385771 : pNewChgSet->GetChgSet()->GetItemState( RES_CHRATR_FONTSIZE,
144 385771 : false, reinterpret_cast<const SfxPoolItem**>(&(aFontSizeArr[0])) );
145 385771 : pNewChgSet->GetChgSet()->GetItemState( RES_CHRATR_CJK_FONTSIZE,
146 385771 : false, reinterpret_cast<const SfxPoolItem**>(&(aFontSizeArr[1])) );
147 385771 : pNewChgSet->GetChgSet()->GetItemState( RES_CHRATR_CTL_FONTSIZE,
148 385771 : false, reinterpret_cast<const SfxPoolItem**>(&(aFontSizeArr[2])) );
149 : // #i70223#, #i84745#
150 : // check, if attribute set is applied to this paragraph style
151 389455 : if ( bAssignedToListLevelOfOutlineStyle &&
152 3684 : pNewChgSet->GetTheChgdSet() == &GetAttrSet() )
153 : {
154 238 : pNewChgSet->GetChgSet()->GetItemState( RES_PARATR_NUMRULE, false,
155 238 : reinterpret_cast<const SfxPoolItem**>(&pNewNumRuleItem) );
156 : }
157 :
158 385771 : break;
159 :
160 : case RES_FMT_CHG:
161 36832 : if( GetAttrSet().GetParent() )
162 : {
163 32037 : const SfxItemSet* pParent = GetAttrSet().GetParent();
164 32037 : pNewLRSpace = static_cast<const SvxLRSpaceItem*>(&pParent->Get( RES_LR_SPACE ));
165 32037 : pNewULSpace = static_cast<const SvxULSpaceItem*>(&pParent->Get( RES_UL_SPACE ));
166 32037 : aFontSizeArr[0] = static_cast<const SvxFontHeightItem*>(&pParent->Get( RES_CHRATR_FONTSIZE ));
167 32037 : aFontSizeArr[1] = static_cast<const SvxFontHeightItem*>(&pParent->Get( RES_CHRATR_CJK_FONTSIZE ));
168 32037 : aFontSizeArr[2] = static_cast<const SvxFontHeightItem*>(&pParent->Get( RES_CHRATR_CTL_FONTSIZE ));
169 : // #i66431# - modify has to be propagated, because of new parent format.
170 32037 : bNewParent = true;
171 : }
172 36832 : break;
173 :
174 : case RES_LR_SPACE:
175 0 : pNewLRSpace = static_cast<const SvxLRSpaceItem*>(pNew);
176 0 : break;
177 : case RES_UL_SPACE:
178 0 : pNewULSpace = static_cast<const SvxULSpaceItem*>(pNew);
179 0 : break;
180 : case RES_CHRATR_FONTSIZE:
181 0 : aFontSizeArr[0] = static_cast<const SvxFontHeightItem*>(pNew);
182 0 : break;
183 : case RES_CHRATR_CJK_FONTSIZE:
184 0 : aFontSizeArr[1] = static_cast<const SvxFontHeightItem*>(pNew);
185 0 : break;
186 : case RES_CHRATR_CTL_FONTSIZE:
187 0 : aFontSizeArr[2] = static_cast<const SvxFontHeightItem*>(pNew);
188 0 : break;
189 : // #i70223#
190 : case RES_PARATR_NUMRULE:
191 0 : if (bAssignedToListLevelOfOutlineStyle)
192 : {
193 0 : pNewNumRuleItem = static_cast<const SwNumRuleItem*>(pNew);
194 : }
195 0 : break;
196 : default:
197 21 : break;
198 : }
199 :
200 : // #i70223#
201 422624 : if ( bAssignedToListLevelOfOutlineStyle && pNewNumRuleItem )
202 : {
203 : TextFormatCollFunc::CheckTextFormatCollForDeletionOfAssignmentToOutlineStyle(
204 238 : this, pNewNumRuleItem );
205 : }
206 :
207 422624 : bool bContinue = true;
208 :
209 : // Check against the own attributes
210 455936 : if( pNewLRSpace && SfxItemState::SET == GetItemState( RES_LR_SPACE, false,
211 33312 : reinterpret_cast<const SfxPoolItem**>(&pOldLRSpace) ))
212 : {
213 1079 : if( pOldLRSpace != pNewLRSpace ) // Avoid recursion (SetAttr!)
214 : {
215 743 : bool bChg = false;
216 743 : SvxLRSpaceItem aNew( *pOldLRSpace );
217 : // We had a relative value -> recalculate
218 743 : if( 100 != aNew.GetPropLeft() )
219 : {
220 1 : long nTmp = aNew.GetLeft(); // keep so that we can compare
221 1 : aNew.SetLeft( pNewLRSpace->GetLeft(), aNew.GetPropLeft() );
222 1 : bChg |= nTmp != aNew.GetLeft();
223 : }
224 : // We had a relative value -> recalculate
225 743 : if( 100 != aNew.GetPropRight() )
226 : {
227 1 : long nTmp = aNew.GetRight(); // keep so that we can compare
228 1 : aNew.SetRight( pNewLRSpace->GetRight(), aNew.GetPropRight() );
229 1 : bChg |= nTmp != aNew.GetRight();
230 : }
231 : // We had a relative value -> recalculate
232 743 : if( 100 != aNew.GetPropTextFirstLineOfst() )
233 : {
234 0 : short nTmp = aNew.GetTextFirstLineOfst(); // keep so that we can compare
235 0 : aNew.SetTextFirstLineOfst( pNewLRSpace->GetTextFirstLineOfst(),
236 0 : aNew.GetPropTextFirstLineOfst() );
237 0 : bChg |= nTmp != aNew.GetTextFirstLineOfst();
238 : }
239 743 : if( bChg )
240 : {
241 0 : SetFormatAttr( aNew );
242 0 : bContinue = 0 != pOldChgSet || bNewParent;
243 : }
244 : // We set it to absolute -> do not propagate it further, unless
245 : // we set it!
246 743 : else if( pNewChgSet )
247 0 : bContinue = pNewChgSet->GetTheChgdSet() == &GetAttrSet();
248 : }
249 : }
250 :
251 471748 : if( pNewULSpace && SfxItemState::SET == GetItemState(
252 438589 : RES_UL_SPACE, false, reinterpret_cast<const SfxPoolItem**>(&pOldULSpace) ) &&
253 15965 : pOldULSpace != pNewULSpace ) // Avoid recursion (SetAttr!)
254 : {
255 11122 : SvxULSpaceItem aNew( *pOldULSpace );
256 11122 : bool bChg = false;
257 : // We had a relative value -> recalculate
258 11122 : if( 100 != aNew.GetPropUpper() )
259 : {
260 1 : sal_uInt16 nTmp = aNew.GetUpper(); // keep so that we can compare
261 1 : aNew.SetUpper( pNewULSpace->GetUpper(), aNew.GetPropUpper() );
262 1 : bChg |= nTmp != aNew.GetUpper();
263 : }
264 : // We had a relative value -> recalculate
265 11122 : if( 100 != aNew.GetPropLower() )
266 : {
267 1 : sal_uInt16 nTmp = aNew.GetLower(); // keep so that we can compare
268 1 : aNew.SetLower( pNewULSpace->GetLower(), aNew.GetPropLower() );
269 1 : bChg |= nTmp != aNew.GetLower();
270 : }
271 11122 : if( bChg )
272 : {
273 1 : SetFormatAttr( aNew );
274 1 : bContinue = 0 != pOldChgSet || bNewParent;
275 : }
276 : // We set it to absolute -> do not propagate it further, unless
277 : // we set it!
278 11121 : else if( pNewChgSet )
279 4058 : bContinue = pNewChgSet->GetTheChgdSet() == &GetAttrSet();
280 : }
281 :
282 1690496 : for( int nC = 0, nArrLen = sizeof(aFontSizeArr) / sizeof( aFontSizeArr[0]);
283 : nC < nArrLen; ++nC )
284 : {
285 1267872 : const SvxFontHeightItem *pFSize = aFontSizeArr[ nC ], *pOldFSize;
286 1444630 : if( pFSize && SfxItemState::SET == GetItemState(
287 1311945 : pFSize->Which(), false, reinterpret_cast<const SfxPoolItem**>(&pOldFSize) ) &&
288 : // Avoid recursion (SetAttr!)
289 44073 : pFSize != pOldFSize )
290 : {
291 73057 : if( 100 == pOldFSize->GetProp() &&
292 36342 : SFX_MAPUNIT_RELATIVE == pOldFSize->GetPropUnit() )
293 : {
294 : // We set it to absolute -> do not propagate it further, unless
295 : // we set it!
296 36342 : if( pNewChgSet )
297 18169 : bContinue = pNewChgSet->GetTheChgdSet() == &GetAttrSet();
298 : }
299 : else
300 : {
301 : // We had a relative value -> recalculate
302 373 : sal_uInt32 nTmp = pOldFSize->GetHeight(); // keep so that we can compare
303 373 : SvxFontHeightItem aNew(240 , 100, pFSize->Which());
304 373 : aNew.SetHeight( pFSize->GetHeight(), pOldFSize->GetProp(),
305 746 : pOldFSize->GetPropUnit() );
306 373 : if( nTmp != aNew.GetHeight() )
307 : {
308 336 : SetFormatAttr( aNew );
309 336 : bContinue = 0 != pOldChgSet || bNewParent;
310 : }
311 : // We set it to absolute -> do not propagate it further, unless
312 : // we set it!
313 37 : else if( pNewChgSet )
314 0 : bContinue = pNewChgSet->GetTheChgdSet() == &GetAttrSet();
315 : }
316 : }
317 : }
318 :
319 422624 : if( bContinue )
320 404085 : SwFormatColl::Modify( pOld, pNew );
321 : }
322 :
323 0 : bool SwTextFormatColl::IsAtDocNodeSet() const
324 : {
325 0 : SwIterator<SwContentNode,SwFormatColl> aIter( *this );
326 0 : const SwNodes& rNds = GetDoc()->GetNodes();
327 0 : for( SwContentNode* pNode = aIter.First(); pNode; pNode = aIter.Next() )
328 0 : if( &(pNode->GetNodes()) == &rNds )
329 0 : return true;
330 :
331 0 : return false;
332 : }
333 :
334 55940 : bool SwTextFormatColl::SetFormatAttr( const SfxPoolItem& rAttr )
335 : {
336 55940 : const bool bIsNumRuleItem = rAttr.Which() == RES_PARATR_NUMRULE;
337 55940 : if ( bIsNumRuleItem )
338 : {
339 1912 : TextFormatCollFunc::RemoveFromNumRule( *this );
340 : }
341 :
342 55940 : const bool bRet = SwFormatColl::SetFormatAttr( rAttr );
343 :
344 55940 : if ( bIsNumRuleItem )
345 : {
346 1912 : TextFormatCollFunc::AddToNumRule( *this );
347 : }
348 :
349 55940 : return bRet;
350 : }
351 :
352 127399 : bool SwTextFormatColl::SetFormatAttr( const SfxItemSet& rSet )
353 : {
354 : const bool bIsNumRuleItemAffected =
355 127399 : rSet.GetItemState( RES_PARATR_NUMRULE, false ) == SfxItemState::SET;
356 127399 : if ( bIsNumRuleItemAffected )
357 : {
358 129 : TextFormatCollFunc::RemoveFromNumRule( *this );
359 : }
360 :
361 127399 : const bool bRet = SwFormatColl::SetFormatAttr( rSet );
362 :
363 127399 : if ( bIsNumRuleItemAffected )
364 : {
365 129 : TextFormatCollFunc::AddToNumRule( *this );
366 : }
367 :
368 127399 : return bRet;
369 : }
370 :
371 90998 : bool SwTextFormatColl::ResetFormatAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 )
372 : {
373 : const bool bIsNumRuleItemAffected =
374 0 : ( nWhich2 != 0 && nWhich2 > nWhich1 )
375 0 : ? ( nWhich1 <= RES_PARATR_NUMRULE &&
376 : RES_PARATR_NUMRULE <= nWhich2 )
377 90998 : : nWhich1 == RES_PARATR_NUMRULE;
378 90998 : if ( bIsNumRuleItemAffected )
379 : {
380 0 : TextFormatCollFunc::RemoveFromNumRule( *this );
381 : }
382 :
383 90998 : const bool bRet = SwFormatColl::ResetFormatAttr( nWhich1, nWhich2 );
384 :
385 90998 : return bRet;
386 : }
387 :
388 : // #i73790#
389 4388 : sal_uInt16 SwTextFormatColl::ResetAllFormatAttr()
390 : {
391 4388 : const bool bOldState( mbStayAssignedToListLevelOfOutlineStyle );
392 4388 : mbStayAssignedToListLevelOfOutlineStyle = true;
393 : // #i70748#
394 : // Outline level is no longer a member, it is a attribute now.
395 : // Thus, it needs to be restored, if the paragraph style is assigned
396 : // to the outline style
397 4388 : const int nAssignedOutlineStyleLevel = IsAssignedToListLevelOfOutlineStyle()
398 : ? GetAssignedOutlineStyleLevel()
399 4388 : : -1;
400 :
401 4388 : sal_uInt16 nRet = SwFormatColl::ResetAllFormatAttr();
402 :
403 : // #i70748#
404 4388 : if ( nAssignedOutlineStyleLevel != -1 )
405 : {
406 122 : AssignToListLevelOfOutlineStyle( nAssignedOutlineStyleLevel );
407 : }
408 :
409 4388 : mbStayAssignedToListLevelOfOutlineStyle = bOldState;
410 :
411 4388 : return nRet;
412 : }
413 :
414 0 : bool SwTextFormatColl::AreListLevelIndentsApplicable() const
415 : {
416 0 : bool bAreListLevelIndentsApplicable( true );
417 :
418 0 : if ( GetItemState( RES_PARATR_NUMRULE ) != SfxItemState::SET )
419 : {
420 : // no list style applied to paragraph style
421 0 : bAreListLevelIndentsApplicable = false;
422 : }
423 0 : else if ( GetItemState( RES_LR_SPACE, false ) == SfxItemState::SET )
424 : {
425 : // paragraph style has hard-set indent attributes
426 0 : bAreListLevelIndentsApplicable = false;
427 : }
428 0 : else if ( GetItemState( RES_PARATR_NUMRULE, false ) == SfxItemState::SET )
429 : {
430 : // list style is directly applied to paragraph style and paragraph
431 : // style has no hard-set indent attributes
432 0 : bAreListLevelIndentsApplicable = true;
433 : }
434 : else
435 : {
436 : // list style is applied through one of the parent paragraph styles and
437 : // paragraph style has no hard-set indent attributes
438 :
439 : // check parent paragraph styles
440 0 : const SwTextFormatColl* pColl = dynamic_cast<const SwTextFormatColl*>(DerivedFrom());
441 0 : while ( pColl )
442 : {
443 0 : if ( pColl->GetAttrSet().GetItemState( RES_LR_SPACE, false ) == SfxItemState::SET )
444 : {
445 : // indent attributes found in the paragraph style hierarchy.
446 0 : bAreListLevelIndentsApplicable = false;
447 0 : break;
448 : }
449 :
450 0 : if ( pColl->GetAttrSet().GetItemState( RES_PARATR_NUMRULE, false ) == SfxItemState::SET )
451 : {
452 : // paragraph style with the list style found and until now no
453 : // indent attributes are found in the paragraph style hierarchy.
454 0 : bAreListLevelIndentsApplicable = true;
455 0 : break;
456 : }
457 :
458 0 : pColl = dynamic_cast<const SwTextFormatColl*>(pColl->DerivedFrom());
459 : OSL_ENSURE( pColl,
460 : "<SwTextFormatColl::AreListLevelIndentsApplicable()> - something wrong in paragraph style hierarchy. The applied list style is not found." );
461 : }
462 : }
463 :
464 0 : return bAreListLevelIndentsApplicable;
465 : }
466 :
467 0 : void SwTextFormatColl::dumpAsXml(xmlTextWriterPtr pWriter) const
468 : {
469 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swTextFormatColl"));
470 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("name"), BAD_CAST(GetName().toUtf8().getStr()));
471 0 : GetAttrSet().dumpAsXml(pWriter);
472 0 : xmlTextWriterEndElement(pWriter);
473 0 : }
474 :
475 0 : void SwTextFormatColls::dumpAsXml(xmlTextWriterPtr pWriter) const
476 : {
477 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swTextFormatColls"));
478 0 : for (size_t i = 0; i < size(); ++i)
479 0 : GetFormat(i)->dumpAsXml(pWriter);
480 0 : xmlTextWriterEndElement(pWriter);
481 0 : }
482 :
483 : //FEATURE::CONDCOLL
484 :
485 646 : SwCollCondition::SwCollCondition( SwTextFormatColl* pColl, sal_uLong nMasterCond,
486 : sal_uLong nSubCond )
487 646 : : SwClient( pColl ), nCondition( nMasterCond )
488 : {
489 646 : aSubCondition.nSubCondition = nSubCond;
490 646 : }
491 :
492 0 : SwCollCondition::SwCollCondition( SwTextFormatColl* pColl, sal_uLong nMasterCond,
493 : const OUString& rSubExp )
494 0 : : SwClient( pColl ), nCondition( nMasterCond )
495 : {
496 0 : if( USRFLD_EXPRESSION & nCondition )
497 0 : aSubCondition.pFieldExpression = new OUString( rSubExp );
498 : else
499 0 : aSubCondition.nSubCondition = 0;
500 0 : }
501 :
502 2 : SwCollCondition::SwCollCondition( const SwCollCondition& rCopy )
503 2 : : SwClient( const_cast<SwModify*>(rCopy.GetRegisteredIn()) ), nCondition( rCopy.nCondition )
504 : {
505 2 : if( USRFLD_EXPRESSION & rCopy.nCondition )
506 0 : aSubCondition.pFieldExpression = new OUString( *rCopy.GetFieldExpression() );
507 : else
508 2 : aSubCondition.nSubCondition = rCopy.aSubCondition.nSubCondition;
509 2 : }
510 :
511 1298 : SwCollCondition::~SwCollCondition()
512 : {
513 648 : if( USRFLD_EXPRESSION & nCondition )
514 0 : delete aSubCondition.pFieldExpression;
515 650 : }
516 :
517 0 : void SwCollCondition::RegisterToFormat( SwFormat& rFormat )
518 : {
519 0 : rFormat.Add( this );
520 0 : }
521 :
522 1 : bool SwCollCondition::operator==( const SwCollCondition& rCmp ) const
523 : {
524 1 : bool nRet = false;
525 1 : if( nCondition == rCmp.nCondition )
526 : {
527 0 : if( USRFLD_EXPRESSION & nCondition )
528 : {
529 : // The SubCondition contains the expression for the UserField
530 0 : const OUString* pTmp = aSubCondition.pFieldExpression;
531 0 : if( !pTmp )
532 0 : pTmp = rCmp.aSubCondition.pFieldExpression;
533 0 : if( pTmp )
534 : {
535 0 : SwTextFormatColl* pColl = GetTextFormatColl();
536 0 : if( !pColl )
537 0 : pColl = rCmp.GetTextFormatColl();
538 :
539 0 : if( pColl )
540 : {
541 0 : SwCalc aCalc( *pColl->GetDoc() );
542 0 : nRet = aCalc.Calculate( *pTmp ).GetBool();
543 : }
544 : }
545 : }
546 0 : else if( aSubCondition.nSubCondition ==
547 : rCmp.aSubCondition.nSubCondition )
548 0 : nRet = true;
549 : }
550 1 : return nRet;
551 : }
552 :
553 334 : void SwCollCondition::SetCondition( sal_uLong nCond, sal_uLong nSubCond )
554 : {
555 334 : if( USRFLD_EXPRESSION & nCondition )
556 0 : delete aSubCondition.pFieldExpression;
557 334 : nCondition = nCond;
558 334 : aSubCondition.nSubCondition = nSubCond;
559 334 : }
560 :
561 5892 : SwConditionTextFormatColl::~SwConditionTextFormatColl()
562 : {
563 5892 : }
564 :
565 390 : const SwCollCondition* SwConditionTextFormatColl::HasCondition(
566 : const SwCollCondition& rCond ) const
567 : {
568 390 : for( const auto &rFnd : aCondColls )
569 0 : if( rFnd == rCond )
570 0 : return &rFnd;
571 :
572 390 : return nullptr;
573 : }
574 :
575 2 : void SwConditionTextFormatColl::InsertCondition( const SwCollCondition& rCond )
576 : {
577 3 : for( SwFormatCollConditions::size_type n = 0; n < aCondColls.size(); ++n )
578 1 : if( aCondColls[ n ] == rCond )
579 : {
580 0 : aCondColls.erase( aCondColls.begin() + n );
581 0 : break;
582 : }
583 :
584 : // Not found -> so insert it
585 2 : SwCollCondition* pNew = new SwCollCondition( rCond );
586 2 : aCondColls.push_back( pNew );
587 2 : }
588 :
589 0 : bool SwConditionTextFormatColl::RemoveCondition( const SwCollCondition& rCond )
590 : {
591 0 : bool bRet = false;
592 0 : for( SwFormatCollConditions::size_type n = 0; n < aCondColls.size(); ++n )
593 0 : if( aCondColls[ n ] == rCond )
594 : {
595 0 : aCondColls.erase( aCondColls.begin() + n );
596 0 : bRet = true;
597 : }
598 :
599 0 : return bRet;
600 : }
601 :
602 70 : void SwConditionTextFormatColl::SetConditions( const SwFormatCollConditions& rCndClls )
603 : {
604 : // Copy the Conditions, but first delete the old ones
605 70 : aCondColls.clear();
606 70 : SwDoc& rDoc = *GetDoc();
607 70 : for( const auto &rFnd : rCndClls )
608 : {
609 0 : SwTextFormatColl* pTmpColl = rFnd.GetTextFormatColl()
610 0 : ? rDoc.CopyTextColl( *rFnd.GetTextFormatColl() )
611 0 : : 0;
612 : SwCollCondition* pNew;
613 0 : if( USRFLD_EXPRESSION & rFnd.GetCondition() )
614 : pNew = new SwCollCondition( pTmpColl, rFnd.GetCondition(),
615 0 : *rFnd.GetFieldExpression() );
616 : else
617 : pNew = new SwCollCondition( pTmpColl, rFnd.GetCondition(),
618 0 : rFnd.GetSubCondition() );
619 0 : aCondColls.push_back( pNew );
620 : }
621 70 : }
622 :
623 : // FEATURE::CONDCOLL
624 21735 : void SwTextFormatColl::SetAttrOutlineLevel( int nLevel)
625 : {
626 : OSL_ENSURE( 0 <= nLevel && nLevel <= MAXLEVEL ,"SwTextFormatColl: Level Out Of Range" );
627 : SetFormatAttr( SfxUInt16Item( RES_PARATR_OUTLINELEVEL,
628 21735 : static_cast<sal_uInt16>(nLevel) ) );
629 21735 : }
630 :
631 10979 : int SwTextFormatColl::GetAttrOutlineLevel() const
632 : {
633 10979 : return static_cast<const SfxUInt16Item &>(GetFormatAttr(RES_PARATR_OUTLINELEVEL)).GetValue();
634 : }
635 :
636 10867 : int SwTextFormatColl::GetAssignedOutlineStyleLevel() const
637 : {
638 : OSL_ENSURE( IsAssignedToListLevelOfOutlineStyle(),
639 : "<SwTextFormatColl::GetAssignedOutlineStyleLevel()> - misuse of method");
640 10867 : return GetAttrOutlineLevel() - 1;
641 : }
642 :
643 2305 : void SwTextFormatColl::AssignToListLevelOfOutlineStyle(const int nAssignedListLevel)
644 : {
645 2305 : mbAssignedToOutlineStyle = true;
646 2305 : SetAttrOutlineLevel(nAssignedListLevel+1);
647 :
648 : // #i100277#
649 2305 : SwIterator<SwTextFormatColl,SwFormatColl> aIter( *this );
650 2305 : SwTextFormatColl* pDerivedTextFormatColl = aIter.First();
651 5118 : while ( pDerivedTextFormatColl != 0 )
652 : {
653 508 : if ( !pDerivedTextFormatColl->IsAssignedToListLevelOfOutlineStyle() )
654 : {
655 435 : if ( pDerivedTextFormatColl->GetItemState( RES_PARATR_NUMRULE, false ) == SfxItemState::DEFAULT )
656 : {
657 93 : SwNumRuleItem aItem(aEmptyOUStr);
658 93 : pDerivedTextFormatColl->SetFormatAttr( aItem );
659 : }
660 435 : if ( pDerivedTextFormatColl->GetItemState( RES_PARATR_OUTLINELEVEL, false ) == SfxItemState::DEFAULT )
661 : {
662 13 : pDerivedTextFormatColl->SetAttrOutlineLevel( 0 );
663 : }
664 : }
665 :
666 508 : pDerivedTextFormatColl = aIter.Next();
667 2305 : }
668 2305 : }
669 :
670 3702 : void SwTextFormatColl::DeleteAssignmentToListLevelOfOutlineStyle(
671 : const bool bResetOutlineLevel)
672 : {
673 3702 : mbAssignedToOutlineStyle = false;
674 3702 : if (bResetOutlineLevel)
675 : {
676 3694 : ResetFormatAttr(RES_PARATR_OUTLINELEVEL);
677 : }
678 3879 : }
679 :
680 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
