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