Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 :
22 : #include <string.h>
23 : #include <vcl/font.hxx>
24 : #include <editeng/brushitem.hxx>
25 : #include <editeng/lrspitem.hxx>
26 : #include <editeng/numitem.hxx>
27 : #include <svl/grabbagitem.hxx>
28 : #include <fmtornt.hxx>
29 : #include <doc.hxx>
30 : #include <pam.hxx>
31 : #include <charfmt.hxx>
32 : #include <paratr.hxx>
33 : #include <frmfmt.hxx>
34 : #include <ndtxt.hxx>
35 : #include <docary.hxx>
36 : #include <docsh.hxx>
37 : #include <SwStyleNameMapper.hxx>
38 :
39 : // Needed to load default bullet list configuration
40 : #include <unotools/configitem.hxx>
41 :
42 : #include <numrule.hxx>
43 : #include <SwNodeNum.hxx>
44 :
45 : #include <list.hxx>
46 :
47 : #include <algorithm>
48 : #include <unordered_map>
49 : #include <libxml/xmlwriter.h>
50 :
51 : #include <unotools/saveopt.hxx>
52 :
53 : #include <IDocumentListsAccess.hxx>
54 : #include <IDocumentStylePoolAccess.hxx>
55 : #include <IDocumentState.hxx>
56 :
57 : using namespace ::com::sun::star;
58 :
59 : sal_uInt16 SwNumRule::mnRefCount = 0;
60 : SwNumFormat* SwNumRule::maBaseFormats[ RULE_END ][ MAXLEVEL ] = {
61 : {0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
62 :
63 : SwNumFormat* SwNumRule::maLabelAlignmentBaseFormats[ RULE_END ][ MAXLEVEL ] = {
64 : {0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
65 :
66 : const sal_uInt16 SwNumRule::maDefNumIndents[ MAXLEVEL ] = {
67 : //inch: 0,5 1,0 1,5 2,0 2,5 3,0 3,5 4,0 4,5 5,0
68 : 1440/4, 1440/2, 1440*3/4, 1440, 1440*5/4, 1440*3/2, 1440*7/4, 1440*2,
69 : 1440*9/4, 1440*5/2
70 : };
71 :
72 10615 : OUString SwNumRule::GetOutlineRuleName()
73 : {
74 10615 : return OUString("Outline");
75 : }
76 :
77 8451540 : const SwNumFormat& SwNumRule::Get( sal_uInt16 i ) const
78 : {
79 : OSL_ASSERT( i < MAXLEVEL && meRuleType < RULE_END );
80 8451540 : return maFormats[ i ]
81 5357404 : ? *maFormats[ i ]
82 3094136 : : ( meDefaultNumberFormatPositionAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION
83 0 : ? *maBaseFormats[ meRuleType ][ i ]
84 25354620 : : *maLabelAlignmentBaseFormats[ meRuleType ][ i ] );
85 : }
86 :
87 5703959 : const SwNumFormat* SwNumRule::GetNumFormat( sal_uInt16 i ) const
88 : {
89 5703959 : const SwNumFormat * pResult = NULL;
90 :
91 : OSL_ASSERT( i < MAXLEVEL && meRuleType < RULE_END );
92 5703959 : if ( i < MAXLEVEL && meRuleType < RULE_END)
93 : {
94 5703959 : pResult = maFormats[ i ];
95 : }
96 :
97 5703959 : return pResult;
98 : }
99 :
100 : // #i91400#
101 6826 : void SwNumRule::SetName( const OUString & rName,
102 : IDocumentListsAccess& rDocListAccess)
103 : {
104 6826 : if ( msName != rName )
105 : {
106 15 : if (mpNumRuleMap)
107 : {
108 0 : mpNumRuleMap->erase(msName);
109 0 : (*mpNumRuleMap)[rName] = this;
110 :
111 0 : if ( !GetDefaultListId().isEmpty() )
112 : {
113 0 : rDocListAccess.trackChangeOfListStyleName( msName, rName );
114 : }
115 : }
116 :
117 15 : msName = rName;
118 : }
119 6826 : }
120 :
121 189749 : void SwNumRule::GetTextNodeList( SwNumRule::tTextNodeList& rTextNodeList ) const
122 : {
123 189749 : rTextNodeList = maTextNodeList;
124 189749 : }
125 :
126 1331 : SwNumRule::tTextNodeList::size_type SwNumRule::GetTextNodeListSize() const
127 : {
128 1331 : return maTextNodeList.size();
129 : }
130 :
131 6187 : void SwNumRule::AddTextNode( SwTextNode& rTextNode )
132 : {
133 : tTextNodeList::iterator aIter =
134 6187 : std::find( maTextNodeList.begin(), maTextNodeList.end(), &rTextNode );
135 :
136 6187 : if ( aIter == maTextNodeList.end() )
137 : {
138 6187 : maTextNodeList.push_back( &rTextNode );
139 : }
140 6187 : }
141 :
142 6187 : void SwNumRule::RemoveTextNode( SwTextNode& rTextNode )
143 : {
144 : tTextNodeList::iterator aIter =
145 6187 : std::find( maTextNodeList.begin(), maTextNodeList.end(), &rTextNode );
146 :
147 6187 : if ( aIter != maTextNodeList.end() )
148 : {
149 6187 : maTextNodeList.erase( aIter );
150 : }
151 6187 : }
152 :
153 22610 : void SwNumRule::SetNumRuleMap(std::unordered_map<OUString, SwNumRule *, OUStringHash> *
154 : pNumRuleMap)
155 : {
156 22610 : mpNumRuleMap = pNumRuleMap;
157 22610 : }
158 :
159 25658 : sal_uInt16 SwNumRule::GetNumIndent( sal_uInt8 nLvl )
160 : {
161 : OSL_ENSURE( MAXLEVEL > nLvl, "NumLevel is out of range" );
162 25658 : return maDefNumIndents[ nLvl ];
163 : }
164 :
165 62 : sal_uInt16 SwNumRule::GetBullIndent( sal_uInt8 nLvl )
166 : {
167 : OSL_ENSURE( MAXLEVEL > nLvl, "NumLevel is out of range" );
168 62 : return maDefNumIndents[ nLvl ];
169 : }
170 :
171 21321 : static void lcl_SetRuleChgd( SwTextNode& rNd, sal_uInt8 nLevel )
172 : {
173 21321 : if( rNd.GetActualListLevel() == nLevel )
174 2530 : rNd.NumRuleChgd();
175 21321 : }
176 :
177 102482 : SwNumFormat::SwNumFormat() :
178 : SvxNumberFormat(SVX_NUM_ARABIC),
179 : SwClient( 0 ),
180 102482 : pVertOrient(new SwFormatVertOrient( 0, text::VertOrientation::NONE))
181 204964 : ,cGrfBulletCP(USHRT_MAX)//For i120928,record the cp info of graphic within bullet
182 : {
183 102482 : }
184 :
185 5121953 : SwNumFormat::SwNumFormat( const SwNumFormat& rFormat) :
186 : SvxNumberFormat(rFormat),
187 : SwClient( rFormat.GetRegisteredInNonConst() ),
188 10243906 : pVertOrient(new SwFormatVertOrient( 0, rFormat.GetVertOrient()))
189 15365859 : ,cGrfBulletCP(rFormat.cGrfBulletCP)//For i120928,record the cp info of graphic within bullet
190 : {
191 5121953 : sal_Int16 eMyVertOrient = rFormat.GetVertOrient();
192 5121953 : SetGraphicBrush( rFormat.GetBrush(), &rFormat.GetGraphicSize(),
193 5121953 : &eMyVertOrient);
194 5121953 : }
195 :
196 1555310 : SwNumFormat::SwNumFormat(const SvxNumberFormat& rNumFormat, SwDoc* pDoc)
197 : : SvxNumberFormat(rNumFormat)
198 3110620 : , pVertOrient(new SwFormatVertOrient( 0, rNumFormat.GetVertOrient()))
199 4665930 : , cGrfBulletCP(USHRT_MAX)
200 : {
201 1555310 : sal_Int16 eMyVertOrient = rNumFormat.GetVertOrient();
202 1555310 : SetGraphicBrush( rNumFormat.GetBrush(), &rNumFormat.GetGraphicSize(),
203 1555310 : &eMyVertOrient);
204 1555310 : const OUString rCharStyleName = rNumFormat.SvxNumberFormat::GetCharFormatName();
205 1555310 : if( !rCharStyleName.isEmpty() )
206 : {
207 12213 : SwCharFormat* pCFormat = pDoc->FindCharFormatByName( rCharStyleName );
208 12213 : if( !pCFormat )
209 : {
210 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( rCharStyleName,
211 0 : nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
212 : pCFormat = nId != USHRT_MAX
213 0 : ? pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( nId )
214 0 : : pDoc->MakeCharFormat( rCharStyleName, 0 );
215 : }
216 12213 : pCFormat->Add( this );
217 : }
218 1543097 : else if( GetRegisteredIn() )
219 0 : GetRegisteredInNonConst()->Remove( this );
220 1555310 : }
221 :
222 17377439 : SwNumFormat::~SwNumFormat()
223 : {
224 6779335 : delete pVertOrient;
225 10598104 : }
226 :
227 0 : void SwNumFormat::NotifyGraphicArrived()
228 : {
229 0 : if( GetCharFormat() )
230 0 : UpdateNumNodes( GetCharFormat()->GetDoc() );
231 0 : }
232 :
233 : // #i22362#
234 4046 : bool SwNumFormat::IsEnumeration() const
235 : {
236 : // #i30655# native numbering did not work any longer
237 : // using this code. Therefore HBRINKM and I agreed upon defining
238 : // IsEnumeration() as !IsItemize()
239 4046 : return !IsItemize();
240 : }
241 :
242 5065 : bool SwNumFormat::IsItemize() const
243 : {
244 : bool bResult;
245 :
246 5065 : switch(GetNumberingType())
247 : {
248 : case SVX_NUM_CHAR_SPECIAL:
249 : case SVX_NUM_BITMAP:
250 705 : bResult = true;
251 :
252 705 : break;
253 :
254 : default:
255 4360 : bResult = false;
256 : }
257 :
258 5065 : return bResult;
259 :
260 : }
261 :
262 13203 : SwNumFormat& SwNumFormat::operator=( const SwNumFormat& rNumFormat)
263 : {
264 13203 : SvxNumberFormat::operator=(rNumFormat);
265 13203 : if( rNumFormat.GetRegisteredIn() )
266 13198 : rNumFormat.GetRegisteredInNonConst()->Add( this );
267 5 : else if( GetRegisteredIn() )
268 0 : GetRegisteredInNonConst()->Remove( this );
269 : //For i120928,record the cp info of graphic within bullet
270 13203 : cGrfBulletCP = rNumFormat.cGrfBulletCP;
271 13203 : return *this;
272 : }
273 :
274 3880721 : bool SwNumFormat::operator==( const SwNumFormat& rNumFormat) const
275 : {
276 7558317 : bool bRet = SvxNumberFormat::operator==(rNumFormat) &&
277 7558317 : GetRegisteredIn() == rNumFormat.GetRegisteredIn();
278 3880721 : return bRet;
279 : }
280 :
281 20355 : void SwNumFormat::SetCharFormat( SwCharFormat* pChFormat)
282 : {
283 20355 : if( pChFormat )
284 15252 : pChFormat->Add( this );
285 5103 : else if( GetRegisteredIn() )
286 0 : GetRegisteredInNonConst()->Remove( this );
287 20355 : }
288 :
289 33678 : void SwNumFormat::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
290 : {
291 : // Look for the NumRules object in the Doc where this NumFormat is set.
292 : // The format does not need to exist!
293 33678 : const SwCharFormat* pFormat = 0;
294 33678 : sal_uInt16 nWhich = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
295 33678 : switch( nWhich )
296 : {
297 : case RES_ATTRSET_CHG:
298 : case RES_FMT_CHG:
299 33648 : pFormat = GetCharFormat();
300 33648 : break;
301 : }
302 :
303 33678 : if( pFormat && !pFormat->GetDoc()->IsInDtor() )
304 18267 : UpdateNumNodes( const_cast<SwDoc*>(pFormat->GetDoc()) );
305 : else
306 15411 : CheckRegistration( pOld, pNew );
307 33678 : }
308 :
309 13023 : void SwNumFormat::SetCharFormatName(const OUString& rSet)
310 : {
311 13023 : SvxNumberFormat::SetCharFormatName(rSet);
312 13023 : }
313 :
314 0 : OUString SwNumFormat::GetCharFormatName() const
315 : {
316 0 : if(static_cast<const SwCharFormat*>(GetRegisteredIn()))
317 0 : return static_cast<const SwCharFormat*>(GetRegisteredIn())->GetName();
318 :
319 0 : return OUString();
320 : }
321 :
322 6677303 : void SwNumFormat::SetGraphicBrush( const SvxBrushItem* pBrushItem, const Size* pSize,
323 : const sal_Int16* pOrient)
324 : {
325 6677303 : if(pOrient)
326 6677264 : pVertOrient->SetVertOrient( *pOrient );
327 6677303 : SvxNumberFormat::SetGraphicBrush( pBrushItem, pSize, pOrient);
328 6677303 : }
329 :
330 0 : void SwNumFormat::SetVertOrient(sal_Int16 eSet)
331 : {
332 0 : SvxNumberFormat::SetVertOrient(eSet);
333 0 : }
334 :
335 10243906 : sal_Int16 SwNumFormat::GetVertOrient() const
336 : {
337 10243906 : return SvxNumberFormat::GetVertOrient();
338 : }
339 :
340 18267 : void SwNumFormat::UpdateNumNodes( SwDoc* pDoc )
341 : {
342 18267 : bool bDocIsModified = pDoc->getIDocumentState().IsModified();
343 18267 : bool bFnd = false;
344 454933 : for( SwNumRuleTable::size_type n = pDoc->GetNumRuleTable().size(); !bFnd && n; )
345 : {
346 418399 : const SwNumRule* pRule = pDoc->GetNumRuleTable()[ --n ];
347 4497883 : for( sal_uInt8 i = 0; i < MAXLEVEL; ++i )
348 4096143 : if( pRule->GetNumFormat( i ) == this )
349 : {
350 16659 : SwNumRule::tTextNodeList aTextNodeList;
351 16659 : pRule->GetTextNodeList( aTextNodeList );
352 113940 : for ( SwNumRule::tTextNodeList::iterator aIter = aTextNodeList.begin();
353 75960 : aIter != aTextNodeList.end(); ++aIter )
354 : {
355 21321 : lcl_SetRuleChgd( *(*aIter), i );
356 : }
357 16659 : bFnd = true;
358 16659 : break;
359 : }
360 : }
361 :
362 18267 : if( bFnd && !bDocIsModified )
363 0 : pDoc->getIDocumentState().ResetModified();
364 18267 : }
365 :
366 323 : const SwFormatVertOrient* SwNumFormat::GetGraphicOrientation() const
367 : {
368 323 : sal_Int16 eOrient = SvxNumberFormat::GetVertOrient();
369 323 : if(text::VertOrientation::NONE == eOrient)
370 323 : return 0;
371 : else
372 : {
373 0 : pVertOrient->SetVertOrient(eOrient);
374 0 : return pVertOrient;
375 : }
376 : }
377 :
378 22590 : SwNumRule::SwNumRule( const OUString& rNm,
379 : const SvxNumberFormat::SvxNumPositionAndSpaceMode eDefaultNumberFormatPositionAndSpaceMode,
380 : SwNumRuleType eType,
381 : bool bAutoFlg )
382 : : maTextNodeList(),
383 : maParagraphStyleList(),
384 : mpNumRuleMap(0),
385 : msName( rNm ),
386 : meRuleType( eType ),
387 : mnPoolFormatId( USHRT_MAX ),
388 : mnPoolHelpId( USHRT_MAX ),
389 : mnPoolHlpFileId( UCHAR_MAX ),
390 : mbAutoRuleFlag( bAutoFlg ),
391 : mbInvalidRuleFlag( true ),
392 : mbContinusNum( false ),
393 : mbAbsSpaces( false ),
394 : mbHidden( false ),
395 : mbCountPhantoms( true ),
396 : meDefaultNumberFormatPositionAndSpaceMode( eDefaultNumberFormatPositionAndSpaceMode ),
397 22590 : msDefaultListId()
398 : {
399 22590 : if( !mnRefCount++ ) // for the first time, initialize
400 : {
401 : SwNumFormat* pFormat;
402 : sal_uInt8 n;
403 :
404 : // numbering:
405 : // position-and-space mode LABEL_WIDTH_AND_POSITION:
406 28160 : for( n = 0; n < MAXLEVEL; ++n )
407 : {
408 25600 : pFormat = new SwNumFormat;
409 25600 : pFormat->SetIncludeUpperLevels( 1 );
410 25600 : pFormat->SetStart( 1 );
411 25600 : pFormat->SetAbsLSpace( lNumIndent + SwNumRule::GetNumIndent( n ) );
412 25600 : pFormat->SetFirstLineOffset( lNumFirstLineOffset );
413 25600 : pFormat->SetSuffix( "." );
414 25600 : pFormat->SetBulletChar( numfunc::GetBulletChar(n));
415 25600 : SwNumRule::maBaseFormats[ NUM_RULE ][ n ] = pFormat;
416 : }
417 : // position-and-space mode LABEL_ALIGNMENT
418 : // first line indent of general numbering in inch: -0,25 inch
419 2560 : const long cFirstLineIndent = -1440/4;
420 : // indent values of general numbering in inch:
421 : // 0,5 0,75 1,0 1,25 1,5
422 : // 1,75 2,0 2,25 2,5 2,75
423 : const long cIndentAt[ MAXLEVEL ] = {
424 : 1440/2, 1440*3/4, 1440, 1440*5/4, 1440*3/2,
425 2560 : 1440*7/4, 1440*2, 1440*9/4, 1440*5/2, 1440*11/4 };
426 28160 : for( n = 0; n < MAXLEVEL; ++n )
427 : {
428 25600 : pFormat = new SwNumFormat;
429 25600 : pFormat->SetIncludeUpperLevels( 1 );
430 25600 : pFormat->SetStart( 1 );
431 25600 : pFormat->SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT );
432 25600 : pFormat->SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
433 25600 : pFormat->SetListtabPos( cIndentAt[ n ] );
434 25600 : pFormat->SetFirstLineIndent( cFirstLineIndent );
435 25600 : pFormat->SetIndentAt( cIndentAt[ n ] );
436 25600 : pFormat->SetSuffix( "." );
437 25600 : pFormat->SetBulletChar( numfunc::GetBulletChar(n));
438 25600 : SwNumRule::maLabelAlignmentBaseFormats[ NUM_RULE ][ n ] = pFormat;
439 : }
440 :
441 : // outline:
442 : // position-and-space mode LABEL_WIDTH_AND_POSITION:
443 28160 : for( n = 0; n < MAXLEVEL; ++n )
444 : {
445 25600 : pFormat = new SwNumFormat;
446 25600 : pFormat->SetNumberingType(SVX_NUM_NUMBER_NONE);
447 25600 : pFormat->SetIncludeUpperLevels( MAXLEVEL );
448 25600 : pFormat->SetStart( 1 );
449 25600 : pFormat->SetCharTextDistance( lOutlineMinTextDistance );
450 25600 : pFormat->SetBulletChar( numfunc::GetBulletChar(n));
451 25600 : SwNumRule::maBaseFormats[ OUTLINE_RULE ][ n ] = pFormat;
452 : }
453 : // position-and-space mode LABEL_ALIGNMENT:
454 : // indent values of default outline numbering in inch:
455 : // 0,3 0,4 0,5 0,6 0,7
456 : // 0,8 0,9 1,0 1,1 1,2
457 : const long cOutlineIndentAt[ MAXLEVEL ] = {
458 : 1440*3/10, 1440*2/5, 1440/2, 1440*3/5, 1440*7/10,
459 2560 : 1440*4/5, 1440*9/10, 1440, 1440*11/10, 1440*6/5 };
460 28160 : for( n = 0; n < MAXLEVEL; ++n )
461 : {
462 25600 : pFormat = new SwNumFormat;
463 25600 : pFormat->SetNumberingType(SVX_NUM_NUMBER_NONE);
464 25600 : pFormat->SetIncludeUpperLevels( MAXLEVEL );
465 25600 : pFormat->SetStart( 1 );
466 25600 : pFormat->SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT );
467 25600 : pFormat->SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
468 25600 : pFormat->SetListtabPos( cOutlineIndentAt[ n ] );
469 25600 : pFormat->SetFirstLineIndent( -cOutlineIndentAt[ n ] );
470 25600 : pFormat->SetIndentAt( cOutlineIndentAt[ n ] );
471 25600 : pFormat->SetBulletChar( numfunc::GetBulletChar(n));
472 25600 : SwNumRule::maLabelAlignmentBaseFormats[ OUTLINE_RULE ][ n ] = pFormat;
473 : }
474 : }
475 22590 : memset( maFormats, 0, sizeof( maFormats ));
476 : OSL_ENSURE( !msName.isEmpty(), "NumRule without a name!" );
477 22590 : }
478 :
479 325902 : SwNumRule::SwNumRule( const SwNumRule& rNumRule )
480 : : maTextNodeList(),
481 : maParagraphStyleList(),
482 : mpNumRuleMap(0),
483 : msName( rNumRule.msName ),
484 : meRuleType( rNumRule.meRuleType ),
485 325902 : mnPoolFormatId( rNumRule.GetPoolFormatId() ),
486 325902 : mnPoolHelpId( rNumRule.GetPoolHelpId() ),
487 325902 : mnPoolHlpFileId( rNumRule.GetPoolHlpFileId() ),
488 : mbAutoRuleFlag( rNumRule.mbAutoRuleFlag ),
489 : mbInvalidRuleFlag( true ),
490 : mbContinusNum( rNumRule.mbContinusNum ),
491 : mbAbsSpaces( rNumRule.mbAbsSpaces ),
492 : mbHidden( rNumRule.mbHidden ),
493 : mbCountPhantoms( true ),
494 : meDefaultNumberFormatPositionAndSpaceMode( rNumRule.meDefaultNumberFormatPositionAndSpaceMode ),
495 1303608 : msDefaultListId( rNumRule.msDefaultListId )
496 : {
497 325902 : ++mnRefCount;
498 325902 : memset( maFormats, 0, sizeof( maFormats ));
499 3584922 : for( sal_uInt16 n = 0; n < MAXLEVEL; ++n )
500 3259020 : if( rNumRule.maFormats[ n ] )
501 1792292 : Set( n, *rNumRule.maFormats[ n ] );
502 325902 : }
503 :
504 696954 : SwNumRule::~SwNumRule()
505 : {
506 3833247 : for( sal_uInt16 n = 0; n < MAXLEVEL; ++n )
507 3484770 : delete maFormats[ n ];
508 :
509 348477 : if (mpNumRuleMap)
510 : {
511 22601 : mpNumRuleMap->erase(GetName());
512 : }
513 :
514 348477 : if( !--mnRefCount ) // the last one closes the door (?)
515 : {
516 : // Numbering:
517 2552 : SwNumFormat** ppFormats = &SwNumRule::maBaseFormats[0][0];
518 : int n;
519 :
520 28072 : for( n = 0; n < MAXLEVEL; ++n, ++ppFormats )
521 25520 : delete *ppFormats, *ppFormats = 0;
522 :
523 : // Outline:
524 28072 : for( n = 0; n < MAXLEVEL; ++n, ++ppFormats )
525 25520 : delete *ppFormats, *ppFormats = 0;
526 :
527 2552 : ppFormats = &SwNumRule::maLabelAlignmentBaseFormats[0][0];
528 28072 : for( n = 0; n < MAXLEVEL; ++n, ++ppFormats )
529 25520 : delete *ppFormats, *ppFormats = 0;
530 28072 : for( n = 0; n < MAXLEVEL; ++n, ++ppFormats )
531 25520 : delete *ppFormats, *ppFormats = 0;
532 : }
533 :
534 348477 : maTextNodeList.clear();
535 348477 : maParagraphStyleList.clear();
536 348477 : }
537 :
538 304152 : void SwNumRule::CheckCharFormats( SwDoc* pDoc )
539 : {
540 3345672 : for( sal_uInt8 n = 0; n < MAXLEVEL; ++n )
541 : {
542 : SwCharFormat* pFormat;
543 3067498 : if( maFormats[ n ] && 0 != ( pFormat = maFormats[ n ]->GetCharFormat() ) &&
544 25978 : pFormat->GetDoc() != pDoc )
545 : {
546 : // copy
547 110 : SwNumFormat* pNew = new SwNumFormat( *maFormats[ n ] );
548 110 : pNew->SetCharFormat( pDoc->CopyCharFormat( *pFormat ) );
549 110 : delete maFormats[ n ];
550 110 : maFormats[ n ] = pNew;
551 : }
552 : }
553 304152 : }
554 :
555 6812 : SwNumRule& SwNumRule::operator=( const SwNumRule& rNumRule )
556 : {
557 6812 : if( this != &rNumRule )
558 : {
559 74932 : for( sal_uInt16 n = 0; n < MAXLEVEL; ++n )
560 68120 : Set( n, rNumRule.maFormats[ n ] );
561 :
562 6812 : meRuleType = rNumRule.meRuleType;
563 6812 : msName = rNumRule.msName;
564 6812 : mbAutoRuleFlag = rNumRule.mbAutoRuleFlag;
565 6812 : mbInvalidRuleFlag = true;
566 6812 : mbContinusNum = rNumRule.mbContinusNum;
567 6812 : mbAbsSpaces = rNumRule.mbAbsSpaces;
568 6812 : mbHidden = rNumRule.mbHidden;
569 6812 : mnPoolFormatId = rNumRule.GetPoolFormatId();
570 6812 : mnPoolHelpId = rNumRule.GetPoolHelpId();
571 6812 : mnPoolHlpFileId = rNumRule.GetPoolHlpFileId();
572 : }
573 6812 : return *this;
574 : }
575 :
576 2681 : bool SwNumRule::operator==( const SwNumRule& rRule ) const
577 : {
578 5362 : bool bRet = meRuleType == rRule.meRuleType &&
579 5362 : msName == rRule.msName &&
580 5362 : mbAutoRuleFlag == rRule.mbAutoRuleFlag &&
581 5362 : mbContinusNum == rRule.mbContinusNum &&
582 5362 : mbAbsSpaces == rRule.mbAbsSpaces &&
583 5362 : mnPoolFormatId == rRule.GetPoolFormatId() &&
584 8043 : mnPoolHelpId == rRule.GetPoolHelpId() &&
585 5362 : mnPoolHlpFileId == rRule.GetPoolHlpFileId();
586 2681 : if( bRet )
587 : {
588 27753 : for( sal_uInt8 n = 0; n < MAXLEVEL; ++n )
589 25253 : if( !( rRule.Get( n ) == Get( n ) ))
590 : {
591 181 : bRet = false;
592 181 : break;
593 : }
594 : }
595 2681 : return bRet;
596 : }
597 :
598 2007533 : void SwNumRule::Set( sal_uInt16 i, const SwNumFormat& rNumFormat )
599 : {
600 : OSL_ENSURE( i < MAXLEVEL, "Serious defect, please inform OD" );
601 2007533 : if( i < MAXLEVEL )
602 : {
603 2007533 : if( !maFormats[ i ] || !(rNumFormat == Get( i )) )
604 : {
605 1982032 : delete maFormats[ i ];
606 1982032 : maFormats[ i ] = new SwNumFormat( rNumFormat );
607 1982032 : mbInvalidRuleFlag = true;
608 : }
609 : }
610 2007533 : }
611 :
612 1048191 : void SwNumRule::Set( sal_uInt16 i, const SwNumFormat* pNumFormat )
613 : {
614 : OSL_ENSURE( i < MAXLEVEL, "Serious defect, please inform OD" );
615 1048191 : if( i >= MAXLEVEL )
616 1048191 : return;
617 1048191 : SwNumFormat* pOld = maFormats[ i ];
618 1048191 : if( !pOld )
619 : {
620 195118 : if( pNumFormat )
621 : {
622 179327 : maFormats[ i ] = new SwNumFormat( *pNumFormat );
623 179327 : mbInvalidRuleFlag = true;
624 : }
625 : }
626 853073 : else if( !pNumFormat )
627 0 : delete pOld, maFormats[ i ] = 0, mbInvalidRuleFlag = true;
628 853073 : else if( *pOld != *pNumFormat )
629 13203 : *pOld = *pNumFormat, mbInvalidRuleFlag = true;
630 : }
631 :
632 1534 : OUString SwNumRule::MakeNumString( const SwNodeNum& rNum, bool bInclStrings,
633 : bool bOnlyArabic ) const
634 : {
635 1534 : if (rNum.IsCounted())
636 : return MakeNumString(rNum.GetNumberVector(),
637 1534 : bInclStrings, bOnlyArabic, MAXLEVEL);
638 :
639 0 : return OUString();
640 : }
641 :
642 9931 : OUString SwNumRule::MakeNumString( const SwNumberTree::tNumberVector & rNumVector,
643 : const bool bInclStrings,
644 : const bool bOnlyArabic,
645 : const unsigned int _nRestrictToThisLevel,
646 : SwNumRule::Extremities* pExtremities ) const
647 : {
648 9931 : OUString aStr;
649 :
650 9931 : unsigned int nLevel = rNumVector.size() - 1;
651 :
652 9931 : if ( pExtremities )
653 1749 : pExtremities->nPrefixChars = pExtremities->nSuffixChars = 0;
654 :
655 9931 : if ( nLevel > _nRestrictToThisLevel )
656 : {
657 651 : nLevel = _nRestrictToThisLevel;
658 : }
659 :
660 9931 : if (nLevel < MAXLEVEL)
661 : {
662 9931 : const SwNumFormat& rMyNFormat = Get( static_cast<sal_uInt16>(nLevel) );
663 :
664 : {
665 9931 : sal_uInt8 i = static_cast<sal_uInt8>(nLevel);
666 :
667 29227 : if( !IsContinusNum() &&
668 : // - do not include upper levels, if level isn't numbered.
669 17317 : rMyNFormat.GetNumberingType() != SVX_NUM_NUMBER_NONE &&
670 7386 : rMyNFormat.GetIncludeUpperLevels() ) // Just the own level?
671 : {
672 7386 : sal_uInt8 n = rMyNFormat.GetIncludeUpperLevels();
673 7386 : if( 1 < n )
674 : {
675 391 : if( i+1 >= n )
676 391 : i -= n - 1;
677 : else
678 0 : i = 0;
679 : }
680 : }
681 :
682 20729 : for( ; i <= nLevel; ++i )
683 : {
684 10798 : const SwNumFormat& rNFormat = Get( i );
685 10798 : if( SVX_NUM_NUMBER_NONE == rNFormat.GetNumberingType() )
686 : {
687 : // Should 1.1.1 --> 2. NoNum --> 1..1 or 1.1 ??
688 : // if( i != rNum.nMyLevel )
689 : // aStr += ".";
690 2002 : continue;
691 : }
692 :
693 8796 : if( rNumVector[ i ] )
694 : {
695 8570 : if( bOnlyArabic )
696 985 : aStr += OUString::number( rNumVector[ i ] );
697 : else
698 7585 : aStr += rNFormat.GetNumStr( rNumVector[ i ] );
699 : }
700 : else
701 226 : aStr += "0"; // all 0 level are a 0
702 8796 : if( i != nLevel && !aStr.isEmpty() )
703 844 : aStr += ".";
704 : }
705 :
706 : // The type doesn't have any number, so don't append
707 : // the post-/prefix string
708 28337 : if( bInclStrings && !bOnlyArabic &&
709 28337 : SVX_NUM_CHAR_SPECIAL != rMyNFormat.GetNumberingType() &&
710 9203 : SVX_NUM_BITMAP != rMyNFormat.GetNumberingType() )
711 : {
712 9203 : const OUString sPrefix = rMyNFormat.GetPrefix();
713 18406 : const OUString sSuffix = rMyNFormat.GetSuffix();
714 :
715 9203 : aStr = sPrefix + aStr + sSuffix;
716 9203 : if ( pExtremities )
717 : {
718 1749 : pExtremities->nPrefixChars = sPrefix.getLength();
719 1749 : pExtremities->nSuffixChars = sSuffix.getLength();
720 9203 : }
721 : }
722 : }
723 : }
724 :
725 9931 : return aStr;
726 : }
727 :
728 919 : OUString SwNumRule::MakeRefNumString( const SwNodeNum& rNodeNum,
729 : const bool bInclSuperiorNumLabels,
730 : const sal_uInt8 nRestrictInclToThisLevel ) const
731 : {
732 919 : OUString aRefNumStr;
733 :
734 919 : if ( rNodeNum.GetLevelInListTree() >= 0 )
735 : {
736 919 : bool bOldHadPrefix = true;
737 :
738 919 : const SwNodeNum* pWorkingNodeNum( &rNodeNum );
739 1050 : do
740 : {
741 1947 : bool bMakeNumStringForPhantom( false );
742 1947 : if ( pWorkingNodeNum->IsPhantom() )
743 : {
744 0 : int nListLevel = pWorkingNodeNum->GetLevelInListTree();
745 :
746 0 : if (nListLevel < 0)
747 0 : nListLevel = 0;
748 :
749 0 : if (nListLevel >= MAXLEVEL)
750 0 : nListLevel = MAXLEVEL - 1;
751 :
752 0 : SwNumFormat aFormat( Get( static_cast<sal_uInt16>(nListLevel) ) );
753 0 : bMakeNumStringForPhantom = aFormat.IsEnumeration() &&
754 0 : SVX_NUM_NUMBER_NONE != aFormat.GetNumberingType();
755 :
756 : }
757 5643 : if ( bMakeNumStringForPhantom ||
758 3894 : ( !pWorkingNodeNum->IsPhantom() &&
759 3894 : pWorkingNodeNum->GetTextNode() &&
760 1947 : pWorkingNodeNum->GetTextNode()->HasNumber() ) )
761 : {
762 : Extremities aExtremities;
763 : OUString aPrevStr = MakeNumString( pWorkingNodeNum->GetNumberVector(),
764 : true, false, MAXLEVEL,
765 1749 : &aExtremities);
766 1749 : sal_Int32 nStrip = 0;
767 3878 : while ( nStrip < aExtremities.nPrefixChars )
768 : {
769 1344 : const sal_Unicode c = aPrevStr[nStrip];
770 1344 : if ( c!='\t' && c!=' ')
771 964 : break;
772 380 : ++nStrip;
773 : }
774 :
775 1749 : if (nStrip)
776 : {
777 380 : aPrevStr = aPrevStr.copy( nStrip );
778 380 : aExtremities.nPrefixChars -= nStrip;
779 : }
780 :
781 1749 : if (bOldHadPrefix &&
782 1566 : aExtremities.nSuffixChars &&
783 1566 : !aExtremities.nPrefixChars
784 : )
785 : {
786 1216 : aPrevStr = aPrevStr.copy(0,
787 1216 : aPrevStr.getLength() - aExtremities.nSuffixChars);
788 : }
789 :
790 1749 : bOldHadPrefix = ( aExtremities.nPrefixChars > 0);
791 :
792 1749 : aRefNumStr = aPrevStr + aRefNumStr;
793 : }
794 :
795 1947 : if ( bInclSuperiorNumLabels && pWorkingNodeNum->GetLevelInListTree() > 0 )
796 : {
797 1050 : sal_uInt8 n = Get( static_cast<sal_uInt16>(pWorkingNodeNum->GetLevelInListTree()) ).GetIncludeUpperLevels();
798 1050 : pWorkingNodeNum = dynamic_cast<SwNodeNum*>(pWorkingNodeNum->GetParent());
799 : // skip parents, whose list label is already contained in the actual list label.
800 2100 : while ( pWorkingNodeNum && n > 1 )
801 : {
802 0 : pWorkingNodeNum = dynamic_cast<SwNodeNum*>(pWorkingNodeNum->GetParent());
803 0 : --n;
804 : }
805 : }
806 : else
807 : {
808 897 : break;
809 : }
810 1050 : } while ( pWorkingNodeNum &&
811 2100 : pWorkingNodeNum->GetLevelInListTree() >= 0 &&
812 1050 : static_cast<sal_uInt8>(pWorkingNodeNum->GetLevelInListTree()) >= nRestrictInclToThisLevel );
813 : }
814 :
815 919 : return aRefNumStr;
816 : }
817 :
818 : /** Copy method of SwNumRule
819 :
820 : A kind of copy constructor, so that the num formats are attached to the
821 : right CharFormats of a Document.
822 : Copies the NumFormats and returns itself. */
823 70 : SwNumRule& SwNumRule::CopyNumRule( SwDoc* pDoc, const SwNumRule& rNumRule )
824 : {
825 770 : for( sal_uInt16 n = 0; n < MAXLEVEL; ++n )
826 : {
827 700 : Set( n, rNumRule.maFormats[ n ] );
828 700 : if( maFormats[ n ] && maFormats[ n ]->GetCharFormat() &&
829 0 : !pDoc->GetCharFormats()->Contains( maFormats[n]->GetCharFormat() ))
830 : // If we copy across different Documents, then copy the
831 : // corresponding CharFormat into the new Document.
832 0 : maFormats[n]->SetCharFormat( pDoc->CopyCharFormat( *maFormats[n]->
833 0 : GetCharFormat() ) );
834 : }
835 70 : meRuleType = rNumRule.meRuleType;
836 70 : msName = rNumRule.msName;
837 70 : mbAutoRuleFlag = rNumRule.mbAutoRuleFlag;
838 70 : mnPoolFormatId = rNumRule.GetPoolFormatId();
839 70 : mnPoolHelpId = rNumRule.GetPoolHelpId();
840 70 : mnPoolHlpFileId = rNumRule.GetPoolHlpFileId();
841 70 : mbInvalidRuleFlag = true;
842 70 : return *this;
843 : }
844 :
845 155531 : void SwNumRule::SetSvxRule(const SvxNumRule& rNumRule, SwDoc* pDoc)
846 : {
847 1710841 : for( sal_uInt16 n = 0; n < MAXLEVEL; ++n )
848 : {
849 1555310 : const SvxNumberFormat* pSvxFormat = rNumRule.Get(n);
850 1555310 : delete maFormats[n];
851 1555310 : maFormats[n] = pSvxFormat ? new SwNumFormat(*pSvxFormat, pDoc) : 0;
852 : }
853 :
854 155531 : mbInvalidRuleFlag = true;
855 155531 : mbContinusNum = rNumRule.IsContinuousNumbering();
856 155531 : }
857 :
858 169466 : SvxNumRule SwNumRule::MakeSvxNumRule() const
859 : {
860 : SvxNumRule aRule(SvxNumRuleFlags::CONTINUOUS | SvxNumRuleFlags::CHAR_TEXT_DISTANCE | SvxNumRuleFlags::CHAR_STYLE |
861 338932 : SvxNumRuleFlags::ENABLE_LINKED_BMP | SvxNumRuleFlags::ENABLE_EMBEDDED_BMP,
862 : MAXLEVEL, mbContinusNum,
863 338932 : meRuleType == NUM_RULE ? SvxNumRuleType::NUMBERING : SvxNumRuleType::OUTLINE_NUMBERING );
864 1864126 : for( sal_uInt16 n = 0; n < MAXLEVEL; ++n )
865 : {
866 1694660 : SwNumFormat aNumFormat = Get(n);
867 1694660 : if(aNumFormat.GetCharFormat())
868 13023 : aNumFormat.SetCharFormatName(aNumFormat.GetCharFormat()->GetName());
869 1694660 : aRule.SetLevel(n, aNumFormat, maFormats[n] != 0);
870 1694660 : }
871 169466 : return aRule;
872 : }
873 :
874 309284 : void SwNumRule::SetInvalidRule(bool bFlag)
875 : {
876 309284 : if (bFlag)
877 : {
878 153011 : std::set< SwList* > aLists;
879 153011 : tTextNodeList::iterator aIter;
880 156449 : for ( aIter = maTextNodeList.begin(); aIter != maTextNodeList.end(); ++aIter )
881 : {
882 3438 : const SwTextNode* pTextNode = *aIter;
883 : // #i111681# - applying patch from cmc
884 3438 : SwList* pList = pTextNode->GetDoc()->getIDocumentListsAccess().getListByName( pTextNode->GetListId() );
885 : OSL_ENSURE( pList, "<SwNumRule::SetInvalidRule(..)> - list at which the text node is registered at does not exist. This is a serious issue --> please inform OD.");
886 3438 : if ( pList )
887 : {
888 3438 : aLists.insert( pList );
889 : }
890 : }
891 : std::for_each( aLists.begin(), aLists.end(),
892 153011 : std::mem_fun( &SwList::InvalidateListTree ) );
893 : }
894 :
895 309284 : mbInvalidRuleFlag = bFlag;
896 309284 : }
897 :
898 : /// change indent of all list levels by given difference
899 0 : void SwNumRule::ChangeIndent( const short nDiff )
900 : {
901 0 : for ( sal_uInt16 i = 0; i < MAXLEVEL; ++i )
902 : {
903 0 : SwNumFormat aTmpNumFormat( Get(i) );
904 :
905 : const SvxNumberFormat::SvxNumPositionAndSpaceMode ePosAndSpaceMode(
906 0 : aTmpNumFormat.GetPositionAndSpaceMode() );
907 0 : if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
908 : {
909 : short nNewIndent = nDiff +
910 0 : aTmpNumFormat.GetAbsLSpace();
911 0 : if ( nNewIndent < 0 )
912 : {
913 0 : nNewIndent = 0;
914 : }
915 0 : aTmpNumFormat.SetAbsLSpace( nNewIndent );
916 : }
917 0 : else if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
918 : {
919 : // adjust also the list tab position, if a list tab stop is applied
920 0 : if ( aTmpNumFormat.GetLabelFollowedBy() == SvxNumberFormat::LISTTAB )
921 : {
922 0 : const long nNewListTab = aTmpNumFormat.GetListtabPos() + nDiff;
923 0 : aTmpNumFormat.SetListtabPos( nNewListTab );
924 : }
925 :
926 0 : const long nNewIndent = nDiff +
927 0 : aTmpNumFormat.GetIndentAt();
928 0 : aTmpNumFormat.SetIndentAt( nNewIndent );
929 : }
930 :
931 0 : Set( i, aTmpNumFormat );
932 0 : }
933 :
934 0 : SetInvalidRule( true );
935 0 : }
936 :
937 : /// set indent of certain list level to given value
938 0 : void SwNumRule::SetIndent( const short nNewIndent,
939 : const sal_uInt16 nListLevel )
940 : {
941 0 : SwNumFormat aTmpNumFormat( Get(nListLevel) );
942 :
943 : const SvxNumberFormat::SvxNumPositionAndSpaceMode ePosAndSpaceMode(
944 0 : aTmpNumFormat.GetPositionAndSpaceMode() );
945 0 : if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
946 : {
947 0 : aTmpNumFormat.SetAbsLSpace( nNewIndent );
948 : }
949 0 : else if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
950 : {
951 : // adjust also the list tab position, if a list tab stop is applied
952 0 : if ( aTmpNumFormat.GetLabelFollowedBy() == SvxNumberFormat::LISTTAB )
953 : {
954 0 : const long nNewListTab = aTmpNumFormat.GetListtabPos() +
955 0 : ( nNewIndent - aTmpNumFormat.GetIndentAt() );
956 0 : aTmpNumFormat.SetListtabPos( nNewListTab );
957 : }
958 :
959 0 : aTmpNumFormat.SetIndentAt( nNewIndent );
960 : }
961 :
962 0 : SetInvalidRule( true );
963 0 : }
964 :
965 : /// set indent of first list level to given value and change other list level's
966 : /// indents accordingly
967 0 : void SwNumRule::SetIndentOfFirstListLevelAndChangeOthers( const short nNewIndent )
968 : {
969 0 : SwNumFormat aTmpNumFormat( Get(0) );
970 :
971 0 : short nDiff( 0 );
972 : const SvxNumberFormat::SvxNumPositionAndSpaceMode ePosAndSpaceMode(
973 0 : aTmpNumFormat.GetPositionAndSpaceMode() );
974 0 : if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
975 : {
976 : nDiff = nNewIndent
977 0 : - aTmpNumFormat.GetFirstLineOffset()
978 0 : - aTmpNumFormat.GetAbsLSpace();
979 : }
980 0 : else if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
981 : {
982 : nDiff = static_cast<short>(nNewIndent
983 0 : - aTmpNumFormat.GetIndentAt());
984 : }
985 0 : if ( nDiff != 0 )
986 : {
987 0 : ChangeIndent( nDiff );
988 0 : }
989 0 : }
990 :
991 156273 : void SwNumRule::Validate()
992 : {
993 156273 : std::set< SwList* > aLists;
994 156273 : tTextNodeList::iterator aIter;
995 158665 : for ( aIter = maTextNodeList.begin(); aIter != maTextNodeList.end(); ++aIter )
996 : {
997 2392 : const SwTextNode* pTextNode = *aIter;
998 2392 : aLists.insert( pTextNode->GetDoc()->getIDocumentListsAccess().getListByName( pTextNode->GetListId() ) );
999 : }
1000 : std::for_each( aLists.begin(), aLists.end(),
1001 156273 : std::mem_fun( &SwList::ValidateListTree ) );
1002 :
1003 156273 : SetInvalidRule(false);
1004 156273 : }
1005 :
1006 2989 : void SwNumRule::SetCountPhantoms(bool bCountPhantoms)
1007 : {
1008 2989 : mbCountPhantoms = bCountPhantoms;
1009 2989 : }
1010 :
1011 1189 : SwNumRule::tParagraphStyleList::size_type SwNumRule::GetParagraphStyleListSize() const
1012 : {
1013 1189 : return maParagraphStyleList.size();
1014 : }
1015 :
1016 1902 : void SwNumRule::AddParagraphStyle( SwTextFormatColl& rTextFormatColl )
1017 : {
1018 : tParagraphStyleList::iterator aIter =
1019 1902 : std::find( maParagraphStyleList.begin(), maParagraphStyleList.end(), &rTextFormatColl );
1020 :
1021 1902 : if ( aIter == maParagraphStyleList.end() )
1022 : {
1023 1693 : maParagraphStyleList.push_back( &rTextFormatColl );
1024 : }
1025 1902 : }
1026 :
1027 7 : void SwNumRule::RemoveParagraphStyle( SwTextFormatColl& rTextFormatColl )
1028 : {
1029 : tParagraphStyleList::iterator aIter =
1030 7 : std::find( maParagraphStyleList.begin(), maParagraphStyleList.end(), &rTextFormatColl );
1031 :
1032 7 : if ( aIter != maParagraphStyleList.end() )
1033 : {
1034 7 : maParagraphStyleList.erase( aIter );
1035 : }
1036 7 : }
1037 :
1038 0 : void SwNumRule::dumpAsXml(xmlTextWriterPtr pWriter) const
1039 : {
1040 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swNumRule"));
1041 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("msName"), BAD_CAST(msName.toUtf8().getStr()));
1042 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mnPoolFormatId"), BAD_CAST(OString::number(mnPoolFormatId).getStr()));
1043 0 : xmlTextWriterWriteAttribute(pWriter, BAD_CAST("mbAutoRuleFlag"), BAD_CAST(OString::boolean(mbAutoRuleFlag).getStr()));
1044 0 : xmlTextWriterEndElement(pWriter);
1045 0 : }
1046 :
1047 4641 : void SwNumRule::GetGrabBagItem(uno::Any& rVal) const
1048 : {
1049 4641 : if (mpGrabBagItem.get())
1050 4437 : mpGrabBagItem->QueryValue(rVal);
1051 : else
1052 : {
1053 204 : uno::Sequence<beans::PropertyValue> aValue(0);
1054 204 : rVal = uno::makeAny(aValue);
1055 : }
1056 4641 : }
1057 :
1058 13571 : void SwNumRule::SetGrabBagItem(const uno::Any& rVal)
1059 : {
1060 13571 : if (!mpGrabBagItem.get())
1061 13571 : mpGrabBagItem.reset(new SfxGrabBagItem);
1062 :
1063 13571 : mpGrabBagItem->PutValue(rVal);
1064 13571 : }
1065 :
1066 : namespace numfunc
1067 : {
1068 : /** class containing default bullet list configuration data */
1069 : class SwDefBulletConfig : private utl::ConfigItem
1070 : {
1071 : public:
1072 : static SwDefBulletConfig& getInstance();
1073 :
1074 1 : inline OUString GetFontname() const
1075 : {
1076 1 : return msFontname;
1077 : }
1078 :
1079 0 : inline bool IsFontnameUserDefined() const
1080 : {
1081 0 : return mbUserDefinedFontname;
1082 : }
1083 :
1084 153 : inline const vcl::Font& GetFont() const
1085 : {
1086 153 : return *mpFont;
1087 : }
1088 :
1089 102400 : inline sal_Unicode GetChar( sal_uInt8 p_nListLevel ) const
1090 : {
1091 102400 : if (p_nListLevel >= MAXLEVEL)
1092 : {
1093 0 : p_nListLevel = MAXLEVEL - 1;
1094 : }
1095 :
1096 102400 : return mnLevelChars[p_nListLevel];
1097 : }
1098 :
1099 : SwDefBulletConfig();
1100 : virtual ~SwDefBulletConfig();
1101 :
1102 : private:
1103 : /** sets internal default bullet configuration data to default values */
1104 : void SetToDefault();
1105 :
1106 : /** returns sequence of default bullet configuration property names */
1107 : static uno::Sequence<OUString> GetPropNames();
1108 :
1109 : /** loads default bullet configuration properties and applies
1110 : values to internal data */
1111 : void LoadConfig();
1112 :
1113 : /** initialize font instance for default bullet list */
1114 : void InitFont();
1115 :
1116 : /** catches notification about changed default bullet configuration data */
1117 : virtual void Notify( const uno::Sequence<OUString>& aPropertyNames ) SAL_OVERRIDE;
1118 : virtual void ImplCommit() SAL_OVERRIDE;
1119 :
1120 : // default bullet list configuration data
1121 : OUString msFontname;
1122 : bool mbUserDefinedFontname;
1123 : FontWeight meFontWeight;
1124 : FontItalic meFontItalic;
1125 : sal_Unicode mnLevelChars[MAXLEVEL];
1126 :
1127 : // default bullet list font instance
1128 : vcl::Font* mpFont;
1129 : };
1130 :
1131 : namespace
1132 : {
1133 : class theSwDefBulletConfig
1134 : : public rtl::Static<SwDefBulletConfig, theSwDefBulletConfig>{};
1135 : }
1136 :
1137 102554 : SwDefBulletConfig& SwDefBulletConfig::getInstance()
1138 : {
1139 102554 : return theSwDefBulletConfig::get();
1140 : }
1141 :
1142 58 : SwDefBulletConfig::SwDefBulletConfig()
1143 : : ConfigItem( OUString("Office.Writer/Numbering/DefaultBulletList") ),
1144 : // default bullet font is now OpenSymbol
1145 : msFontname( OUString("OpenSymbol") ),
1146 : mbUserDefinedFontname( false ),
1147 : meFontWeight( WEIGHT_DONTKNOW ),
1148 : meFontItalic( ITALIC_NONE ),
1149 58 : mpFont( 0 )
1150 : {
1151 58 : SetToDefault();
1152 58 : LoadConfig();
1153 58 : InitFont();
1154 :
1155 : // enable notification for changes on default bullet configuration change
1156 58 : EnableNotification( GetPropNames() );
1157 58 : }
1158 :
1159 116 : SwDefBulletConfig::~SwDefBulletConfig()
1160 : {
1161 58 : delete mpFont;
1162 58 : }
1163 :
1164 58 : void SwDefBulletConfig::SetToDefault()
1165 : {
1166 58 : msFontname = "OpenSymbol";
1167 58 : mbUserDefinedFontname = false;
1168 58 : meFontWeight = WEIGHT_DONTKNOW;
1169 58 : meFontItalic = ITALIC_NONE;
1170 :
1171 58 : mnLevelChars[0] = 0x2022;
1172 58 : mnLevelChars[1] = 0x25e6;
1173 58 : mnLevelChars[2] = 0x25aa;
1174 58 : mnLevelChars[3] = 0x2022;
1175 58 : mnLevelChars[4] = 0x25e6;
1176 58 : mnLevelChars[5] = 0x25aa;
1177 58 : mnLevelChars[6] = 0x2022;
1178 58 : mnLevelChars[7] = 0x25e6;
1179 58 : mnLevelChars[8] = 0x25aa;
1180 58 : mnLevelChars[9] = 0x2022;
1181 58 : }
1182 :
1183 116 : uno::Sequence<OUString> SwDefBulletConfig::GetPropNames()
1184 : {
1185 116 : uno::Sequence<OUString> aPropNames(13);
1186 116 : OUString* pNames = aPropNames.getArray();
1187 116 : pNames[0] = "BulletFont/FontFamilyname";
1188 116 : pNames[1] = "BulletFont/FontWeight";
1189 116 : pNames[2] = "BulletFont/FontItalic";
1190 116 : pNames[3] = "BulletCharLvl1";
1191 116 : pNames[4] = "BulletCharLvl2";
1192 116 : pNames[5] = "BulletCharLvl3";
1193 116 : pNames[6] = "BulletCharLvl4";
1194 116 : pNames[7] = "BulletCharLvl5";
1195 116 : pNames[8] = "BulletCharLvl6";
1196 116 : pNames[9] = "BulletCharLvl7";
1197 116 : pNames[10] = "BulletCharLvl8";
1198 116 : pNames[11] = "BulletCharLvl9";
1199 116 : pNames[12] = "BulletCharLvl10";
1200 :
1201 116 : return aPropNames;
1202 : }
1203 :
1204 58 : void SwDefBulletConfig::LoadConfig()
1205 : {
1206 58 : uno::Sequence<OUString> aPropNames = GetPropNames();
1207 : uno::Sequence<uno::Any> aValues =
1208 116 : GetProperties( aPropNames );
1209 58 : const uno::Any* pValues = aValues.getConstArray();
1210 : OSL_ENSURE( aValues.getLength() == aPropNames.getLength(),
1211 : "<SwDefBulletConfig::SwDefBulletConfig()> - GetProperties failed");
1212 58 : if ( aValues.getLength() == aPropNames.getLength() )
1213 : {
1214 812 : for ( int nProp = 0; nProp < aPropNames.getLength(); ++nProp )
1215 : {
1216 754 : if ( pValues[nProp].hasValue() )
1217 : {
1218 0 : switch ( nProp )
1219 : {
1220 : case 0:
1221 : {
1222 0 : OUString aStr;
1223 0 : pValues[nProp] >>= aStr;
1224 0 : msFontname = aStr;
1225 0 : mbUserDefinedFontname = true;
1226 : }
1227 0 : break;
1228 : case 1:
1229 : case 2:
1230 : {
1231 0 : sal_uInt8 nTmp = 0;
1232 0 : pValues[nProp] >>= nTmp;
1233 0 : if ( nProp == 1 )
1234 0 : meFontWeight = static_cast<FontWeight>(nTmp);
1235 0 : else if ( nProp == 2 )
1236 0 : meFontItalic = static_cast<FontItalic>(nTmp);
1237 : }
1238 0 : break;
1239 : case 3:
1240 : case 4:
1241 : case 5:
1242 : case 6:
1243 : case 7:
1244 : case 8:
1245 : case 9:
1246 : case 10:
1247 : case 11:
1248 : case 12:
1249 : {
1250 0 : sal_Unicode cChar = sal_Unicode();
1251 0 : pValues[nProp] >>= cChar;
1252 0 : mnLevelChars[nProp-3] = cChar;
1253 : }
1254 0 : break;
1255 : }
1256 : }
1257 : }
1258 58 : }
1259 :
1260 58 : }
1261 :
1262 58 : void SwDefBulletConfig::InitFont()
1263 : {
1264 58 : delete mpFont;
1265 :
1266 58 : mpFont = new vcl::Font( msFontname, OUString(), Size( 0, 14 ) );
1267 58 : mpFont->SetWeight( meFontWeight );
1268 58 : mpFont->SetItalic( meFontItalic );
1269 58 : mpFont->SetCharSet( RTL_TEXTENCODING_SYMBOL );
1270 58 : }
1271 :
1272 0 : void SwDefBulletConfig::Notify( const uno::Sequence<OUString>& )
1273 : {
1274 0 : SetToDefault();
1275 0 : LoadConfig();
1276 0 : InitFont();
1277 0 : }
1278 :
1279 0 : void SwDefBulletConfig::ImplCommit()
1280 : {
1281 0 : }
1282 :
1283 1 : OUString GetDefBulletFontname()
1284 : {
1285 1 : return SwDefBulletConfig::getInstance().GetFontname();
1286 : }
1287 :
1288 0 : bool IsDefBulletFontUserDefined()
1289 : {
1290 0 : return SwDefBulletConfig::getInstance().IsFontnameUserDefined();
1291 : }
1292 :
1293 153 : const vcl::Font& GetDefBulletFont()
1294 : {
1295 153 : return SwDefBulletConfig::getInstance().GetFont();
1296 : }
1297 :
1298 102400 : sal_Unicode GetBulletChar( sal_uInt8 nLevel )
1299 : {
1300 102400 : return SwDefBulletConfig::getInstance().GetChar( nLevel );
1301 : }
1302 :
1303 : /** class containing configuration data about user interface behavior
1304 : regarding lists and list items.
1305 : configuration item about behavior of <TAB>/<SHIFT-TAB>-key at first
1306 : position of first list item
1307 : */
1308 0 : class SwNumberingUIBehaviorConfig : private utl::ConfigItem
1309 : {
1310 : public:
1311 : static SwNumberingUIBehaviorConfig& getInstance();
1312 :
1313 0 : inline bool ChangeIndentOnTabAtFirstPosOfFirstListItem() const
1314 : {
1315 0 : return mbChangeIndentOnTabAtFirstPosOfFirstListItem;
1316 : }
1317 :
1318 : SwNumberingUIBehaviorConfig();
1319 :
1320 : private:
1321 :
1322 : /** sets internal configuration data to default values */
1323 : void SetToDefault();
1324 :
1325 : /** returns sequence of configuration property names */
1326 : static com::sun::star::uno::Sequence<OUString> GetPropNames();
1327 :
1328 : /** loads configuration properties and applies values to internal data */
1329 : void LoadConfig();
1330 :
1331 : /** catches notification about changed configuration data */
1332 : virtual void Notify( const com::sun::star::uno::Sequence<OUString>& aPropertyNames ) SAL_OVERRIDE;
1333 : virtual void ImplCommit() SAL_OVERRIDE;
1334 :
1335 : // configuration data
1336 : bool mbChangeIndentOnTabAtFirstPosOfFirstListItem;
1337 : };
1338 :
1339 : namespace
1340 : {
1341 : class theSwNumberingUIBehaviorConfig : public rtl::Static<SwNumberingUIBehaviorConfig, theSwNumberingUIBehaviorConfig>{};
1342 : }
1343 :
1344 0 : SwNumberingUIBehaviorConfig& SwNumberingUIBehaviorConfig::getInstance()
1345 : {
1346 0 : return theSwNumberingUIBehaviorConfig::get();
1347 : }
1348 :
1349 0 : SwNumberingUIBehaviorConfig::SwNumberingUIBehaviorConfig()
1350 : : ConfigItem( OUString("Office.Writer/Numbering/UserInterfaceBehavior") ),
1351 0 : mbChangeIndentOnTabAtFirstPosOfFirstListItem( true )
1352 : {
1353 0 : SetToDefault();
1354 0 : LoadConfig();
1355 :
1356 : // enable notification for changes on configuration change
1357 0 : EnableNotification( GetPropNames() );
1358 0 : }
1359 :
1360 0 : void SwNumberingUIBehaviorConfig::SetToDefault()
1361 : {
1362 0 : mbChangeIndentOnTabAtFirstPosOfFirstListItem = true;
1363 0 : }
1364 :
1365 0 : com::sun::star::uno::Sequence<OUString> SwNumberingUIBehaviorConfig::GetPropNames()
1366 : {
1367 0 : com::sun::star::uno::Sequence<OUString> aPropNames(1);
1368 0 : OUString* pNames = aPropNames.getArray();
1369 0 : pNames[0] = "ChangeIndentOnTabAtFirstPosOfFirstListItem";
1370 :
1371 0 : return aPropNames;
1372 : }
1373 :
1374 0 : void SwNumberingUIBehaviorConfig::ImplCommit() {}
1375 :
1376 0 : void SwNumberingUIBehaviorConfig::LoadConfig()
1377 : {
1378 0 : com::sun::star::uno::Sequence<OUString> aPropNames = GetPropNames();
1379 : com::sun::star::uno::Sequence<com::sun::star::uno::Any> aValues =
1380 0 : GetProperties( aPropNames );
1381 0 : const com::sun::star::uno::Any* pValues = aValues.getConstArray();
1382 : OSL_ENSURE( aValues.getLength() == aPropNames.getLength(),
1383 : "<SwNumberingUIBehaviorConfig::LoadConfig()> - GetProperties failed");
1384 0 : if ( aValues.getLength() == aPropNames.getLength() )
1385 : {
1386 0 : for ( int nProp = 0; nProp < aPropNames.getLength(); ++nProp )
1387 : {
1388 0 : if ( pValues[nProp].hasValue() )
1389 : {
1390 0 : switch ( nProp )
1391 : {
1392 : case 0:
1393 : {
1394 0 : pValues[nProp] >>= mbChangeIndentOnTabAtFirstPosOfFirstListItem;
1395 : }
1396 0 : break;
1397 : default:
1398 : {
1399 : OSL_FAIL( "<SwNumberingUIBehaviorConfig::LoadConfig()> - unknown configuration property");
1400 : }
1401 : }
1402 : }
1403 : }
1404 0 : }
1405 0 : }
1406 :
1407 0 : void SwNumberingUIBehaviorConfig::Notify( const com::sun::star::uno::Sequence<OUString>& aPropertyNames )
1408 : {
1409 : (void) aPropertyNames;
1410 0 : SetToDefault();
1411 0 : LoadConfig();
1412 0 : }
1413 :
1414 0 : bool ChangeIndentOnTabAtFirstPosOfFirstListItem()
1415 : {
1416 0 : return SwNumberingUIBehaviorConfig::getInstance().ChangeIndentOnTabAtFirstPosOfFirstListItem();
1417 : }
1418 :
1419 21949 : SvxNumberFormat::SvxNumPositionAndSpaceMode GetDefaultPositionAndSpaceMode()
1420 : {
1421 : SvxNumberFormat::SvxNumPositionAndSpaceMode ePosAndSpaceMode;
1422 21949 : SvtSaveOptions aSaveOptions;
1423 21949 : switch ( aSaveOptions.GetODFDefaultVersion() )
1424 : {
1425 : case SvtSaveOptions::ODFVER_010:
1426 : case SvtSaveOptions::ODFVER_011:
1427 : {
1428 0 : ePosAndSpaceMode = SvxNumberFormat::LABEL_WIDTH_AND_POSITION;
1429 : }
1430 0 : break;
1431 : default: // ODFVER_UNKNOWN or ODFVER_012
1432 : {
1433 21949 : ePosAndSpaceMode = SvxNumberFormat::LABEL_ALIGNMENT;
1434 : }
1435 : }
1436 :
1437 21949 : return ePosAndSpaceMode;
1438 : }
1439 : }
1440 :
1441 0 : void SwNumRuleTable::dumpAsXml(xmlTextWriterPtr pWriter) const
1442 : {
1443 0 : xmlTextWriterStartElement(pWriter, BAD_CAST("swNumRuleTable"));
1444 0 : for (SwNumRule* pNumRule : *this)
1445 0 : pNumRule->dumpAsXml(pWriter);
1446 0 : xmlTextWriterEndElement(pWriter);
1447 177 : }
1448 :
1449 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
