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 :
21 : #include <svl/smplhint.hxx>
22 : #include <hintids.hxx>
23 : #include <svl/itemiter.hxx>
24 : #include <svl/eitem.hxx>
25 : #include <unotools/syslocale.hxx>
26 : #include <editeng/boxitem.hxx>
27 : #include <editeng/numitem.hxx>
28 : #include <editeng/lrspitem.hxx>
29 : #include <fmtcol.hxx>
30 : #include <uitool.hxx>
31 : #include <swmodule.hxx>
32 : #include <wrtsh.hxx>
33 : #include <docsh.hxx>
34 : #include <frmfmt.hxx>
35 : #include <charfmt.hxx>
36 : #include <poolfmt.hxx>
37 : #include <pagedesc.hxx>
38 : #include <docstyle.hxx>
39 : #include <docary.hxx>
40 : #include <ccoll.hxx>
41 : #include <doc.hxx>
42 : #include <IDocumentUndoRedo.hxx>
43 : #include <cmdid.h>
44 : #include <swstyle.h>
45 : #include <app.hrc>
46 : #include <paratr.hxx>
47 : #include <SwStyleNameMapper.hxx>
48 : #include <svl/cjkoptions.hxx>
49 : #include <comphelper/processfactory.hxx>
50 : #include <unotools/localedatawrapper.hxx>
51 : #include <unotools/intlwrapper.hxx>
52 : #include <numrule.hxx>
53 : #include <fmthdft.hxx>
54 : #include <svx/svxids.hrc>
55 : #include <SwRewriter.hxx>
56 :
57 : // The Format names in the list of all names have the
58 : // following family as their first character:
59 :
60 : #define cCHAR (sal_Unicode)'c'
61 : #define cPARA (sal_Unicode)'p'
62 : #define cFRAME (sal_Unicode)'f'
63 : #define cPAGE (sal_Unicode)'g'
64 : #define cNUMRULE (sal_Unicode)'n'
65 :
66 : // At the names' publication, this character is removed again and the
67 : // family is newly generated.
68 :
69 : // In addition now there is the Bit bPhysical. In case this Bit is
70 : // TRUE, the Pool-Formatnames are not being submitted.
71 :
72 : class SwImplShellAction
73 : {
74 : SwWrtShell* pSh;
75 : CurrShell* pCurrSh;
76 : public:
77 : SwImplShellAction( SwDoc& rDoc );
78 : ~SwImplShellAction();
79 :
80 : SwWrtShell* GetSh() { return pSh; }
81 : };
82 :
83 3300 : SwImplShellAction::SwImplShellAction( SwDoc& rDoc )
84 3300 : : pCurrSh( 0 )
85 : {
86 3300 : if( rDoc.GetDocShell() )
87 3300 : pSh = rDoc.GetDocShell()->GetWrtShell();
88 : else
89 0 : pSh = 0;
90 :
91 3300 : if( pSh )
92 : {
93 1 : pCurrSh = new CurrShell( pSh );
94 1 : pSh->StartAllAction();
95 : }
96 3300 : }
97 :
98 3300 : SwImplShellAction::~SwImplShellAction()
99 : {
100 3300 : if( pCurrSh )
101 : {
102 1 : pSh->EndAllAction();
103 1 : delete pCurrSh;
104 : }
105 3300 : }
106 :
107 : /*--------------------------------------------------------------------
108 : Description: find/create SwCharFormate
109 : possibly fill Style
110 : --------------------------------------------------------------------*/
111 :
112 3191 : static SwCharFmt* lcl_FindCharFmt( SwDoc& rDoc,
113 : const String& rName,
114 : SwDocStyleSheet* pStyle = 0,
115 : sal_Bool bCreate = sal_True )
116 : {
117 3191 : SwCharFmt* pFmt = 0;
118 3191 : if( rName.Len() )
119 : {
120 3191 : pFmt = rDoc.FindCharFmtByName( rName );
121 4721 : if( !pFmt && rName == SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
122 1530 : RES_POOLCOLL_TEXT_BEGIN ] )
123 : {
124 : // Standard-Character template
125 25 : pFmt = (SwCharFmt*)rDoc.GetDfltCharFmt();
126 : }
127 :
128 3191 : if( !pFmt && bCreate )
129 : { // explore Pool
130 218 : const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT);
131 218 : if(nId != USHRT_MAX)
132 21 : pFmt = rDoc.GetCharFmtFromPool(nId);
133 : }
134 : }
135 3191 : if(pStyle)
136 : {
137 2768 : if(pFmt)
138 : {
139 1481 : pStyle->SetPhysical(sal_True);
140 1481 : SwFmt* p = pFmt->DerivedFrom();
141 1481 : if( p && !p->IsDefault() )
142 938 : pStyle->PresetParent( p->GetName() );
143 : else
144 543 : pStyle->PresetParent( aEmptyStr );
145 : }
146 : else
147 1287 : pStyle->SetPhysical(sal_False);
148 : }
149 3191 : return pFmt;
150 : }
151 :
152 :
153 : /*--------------------------------------------------------------------
154 : Description: find/create ParaFormats
155 : fill Style
156 : --------------------------------------------------------------------*/
157 :
158 9548 : static SwTxtFmtColl* lcl_FindParaFmt( SwDoc& rDoc,
159 : const String& rName,
160 : SwDocStyleSheet* pStyle = 0,
161 : sal_Bool bCreate = sal_True )
162 : {
163 9548 : SwTxtFmtColl* pColl = 0;
164 :
165 9548 : if( rName.Len() )
166 : {
167 9548 : pColl = rDoc.FindTxtFmtCollByName( rName );
168 9548 : if( !pColl && bCreate )
169 : { // explore Pool
170 271 : const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL);
171 271 : if(nId != USHRT_MAX)
172 174 : pColl = rDoc.GetTxtCollFromPool(nId);
173 : }
174 : }
175 :
176 9548 : if(pStyle)
177 : {
178 9132 : if(pColl)
179 : {
180 6889 : pStyle->SetPhysical(sal_True);
181 6889 : if( pColl->DerivedFrom() && !pColl->DerivedFrom()->IsDefault() )
182 4102 : pStyle->PresetParent( pColl->DerivedFrom()->GetName() );
183 : else
184 2787 : pStyle->PresetParent( aEmptyStr );
185 :
186 6889 : SwTxtFmtColl& rNext = pColl->GetNextTxtFmtColl();
187 6889 : pStyle->PresetFollow(rNext.GetName());
188 : }
189 : else
190 2243 : pStyle->SetPhysical(sal_False);
191 : }
192 9548 : return pColl;
193 : }
194 :
195 :
196 : /*--------------------------------------------------------------------
197 : Description: Border formats
198 : --------------------------------------------------------------------*/
199 :
200 :
201 300 : static SwFrmFmt* lcl_FindFrmFmt( SwDoc& rDoc,
202 : const String& rName,
203 : SwDocStyleSheet* pStyle = 0,
204 : sal_Bool bCreate = sal_True )
205 : {
206 300 : SwFrmFmt* pFmt = 0;
207 300 : if( rName.Len() )
208 : {
209 300 : pFmt = rDoc.FindFrmFmtByName( rName );
210 300 : if( !pFmt && bCreate )
211 : { // explore Pool
212 5 : const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT);
213 5 : if(nId != USHRT_MAX)
214 5 : pFmt = rDoc.GetFrmFmtFromPool(nId);
215 : }
216 : }
217 :
218 300 : if(pStyle)
219 : {
220 300 : if(pFmt)
221 : {
222 58 : pStyle->SetPhysical(sal_True);
223 58 : if( pFmt->DerivedFrom() && !pFmt->DerivedFrom()->IsDefault() )
224 0 : pStyle->PresetParent( pFmt->DerivedFrom()->GetName() );
225 : else
226 58 : pStyle->PresetParent( aEmptyStr );
227 : }
228 : else
229 242 : pStyle->SetPhysical(sal_False);
230 : }
231 300 : return pFmt;
232 : }
233 :
234 : /*--------------------------------------------------------------------
235 : Description: Page descriptors
236 : --------------------------------------------------------------------*/
237 :
238 :
239 2797 : static const SwPageDesc* lcl_FindPageDesc( SwDoc& rDoc,
240 : const String& rName,
241 : SwDocStyleSheet* pStyle = 0,
242 : sal_Bool bCreate = sal_True )
243 : {
244 2797 : const SwPageDesc* pDesc = 0;
245 :
246 2797 : if( rName.Len() )
247 : {
248 2797 : pDesc = rDoc.FindPageDescByName( rName );
249 2797 : if( !pDesc && bCreate )
250 : {
251 39 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC);
252 39 : if(nId != USHRT_MAX)
253 14 : pDesc = rDoc.GetPageDescFromPool(nId);
254 : }
255 : }
256 :
257 2797 : if(pStyle)
258 : {
259 2770 : if(pDesc)
260 : {
261 2241 : pStyle->SetPhysical(sal_True);
262 2241 : if(pDesc->GetFollow())
263 2241 : pStyle->PresetFollow(pDesc->GetFollow()->GetName());
264 : else
265 0 : pStyle->PresetParent( aEmptyStr );
266 : }
267 : else
268 529 : pStyle->SetPhysical(sal_False);
269 : }
270 2797 : return pDesc;
271 : }
272 :
273 526 : static const SwNumRule* lcl_FindNumRule( SwDoc& rDoc,
274 : const String& rName,
275 : SwDocStyleSheet* pStyle = 0,
276 : sal_Bool bCreate = sal_True )
277 : {
278 526 : const SwNumRule* pRule = 0;
279 :
280 526 : if( rName.Len() )
281 : {
282 526 : pRule = rDoc.FindNumRulePtr( rName );
283 526 : if( !pRule && bCreate )
284 : {
285 72 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE);
286 72 : if(nId != USHRT_MAX)
287 2 : pRule = rDoc.GetNumRuleFromPool(nId);
288 : }
289 : }
290 :
291 526 : if(pStyle)
292 : {
293 456 : if(pRule)
294 : {
295 242 : pStyle->SetPhysical(sal_True);
296 242 : pStyle->PresetParent( aEmptyStr );
297 : }
298 : else
299 214 : pStyle->SetPhysical(sal_False);
300 : }
301 526 : return pRule;
302 : }
303 :
304 :
305 0 : static sal_uInt16 lcl_FindName(const SwPoolFmtList& rLst, SfxStyleFamily eFam,
306 : const rtl::OUString& rName)
307 : {
308 0 : if(!rLst.empty())
309 : {
310 0 : String sSrch = rtl::OUString(' ');
311 0 : switch( eFam )
312 : {
313 0 : case SFX_STYLE_FAMILY_CHAR: sSrch = cCHAR; break;
314 0 : case SFX_STYLE_FAMILY_PARA: sSrch = cPARA; break;
315 0 : case SFX_STYLE_FAMILY_FRAME: sSrch = cFRAME; break;
316 0 : case SFX_STYLE_FAMILY_PAGE: sSrch = cPAGE; break;
317 0 : case SFX_STYLE_FAMILY_PSEUDO: sSrch = cNUMRULE; break;
318 : default:; //prevent warning
319 : }
320 0 : sSrch += rName;
321 0 : for(size_t i = 0; i < rLst.size(); ++i)
322 0 : if(rLst[i] == sSrch)
323 0 : return i;
324 : }
325 0 : return USHRT_MAX;
326 : }
327 :
328 0 : sal_Bool FindPhyStyle( SwDoc& rDoc, const String& rName, SfxStyleFamily eFam )
329 : {
330 0 : switch( eFam )
331 : {
332 : case SFX_STYLE_FAMILY_CHAR :
333 0 : return 0 != lcl_FindCharFmt( rDoc, rName, 0, sal_False );
334 : case SFX_STYLE_FAMILY_PARA :
335 0 : return 0 != lcl_FindParaFmt( rDoc, rName, 0, sal_False );
336 : case SFX_STYLE_FAMILY_FRAME:
337 0 : return 0 != lcl_FindFrmFmt( rDoc, rName, 0, sal_False );
338 : case SFX_STYLE_FAMILY_PAGE :
339 0 : return 0 != lcl_FindPageDesc( rDoc, rName, 0, sal_False );
340 : case SFX_STYLE_FAMILY_PSEUDO:
341 0 : return 0 != lcl_FindNumRule( rDoc, rName, 0, sal_False );
342 : default:; //prevent warning
343 : }
344 0 : return sal_False;
345 : }
346 :
347 :
348 : /*--------------------------------------------------------------------
349 : Description: Add Strings to the list of templates
350 : --------------------------------------------------------------------*/
351 :
352 :
353 23271 : void SwPoolFmtList::Append( char cChar, const String& rStr )
354 : {
355 23271 : String aStr = rtl::OUString(cChar);
356 23271 : aStr += rStr;
357 1282760 : for(std::vector<String>::const_iterator i = begin(); i != end(); ++i)
358 1261011 : if(*i == aStr)
359 23271 : return;
360 21749 : push_back(aStr);
361 : }
362 :
363 : /*--------------------------------------------------------------------
364 : Description: Erase the list completely
365 : --------------------------------------------------------------------*/
366 :
367 :
368 262 : void SwPoolFmtList::Erase()
369 : {
370 262 : clear();
371 262 : }
372 :
373 : /*--------------------------------------------------------------------
374 : Description: UI-sided implementation of StyleSheets
375 : uses the Core-Engine
376 : --------------------------------------------------------------------*/
377 :
378 453 : SwDocStyleSheet::SwDocStyleSheet( SwDoc& rDocument,
379 : const String& rName,
380 : SwDocStyleSheetPool* _rPool,
381 : SfxStyleFamily eFam,
382 : sal_uInt16 _nMask) :
383 :
384 : SfxStyleSheetBase( rName, _rPool, eFam, _nMask ),
385 : pCharFmt(0),
386 : pColl(0),
387 : pFrmFmt(0),
388 : pDesc(0),
389 : pNumRule(0),
390 :
391 : rDoc(rDocument),
392 453 : aCoreSet(GetPool().GetPool(),
393 : RES_CHRATR_BEGIN, RES_CHRATR_END - 1,
394 : RES_PARATR_BEGIN, RES_PARATR_END - 1,
395 : RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END - 1,
396 : RES_FRMATR_BEGIN, RES_FRMATR_END - 1,
397 : RES_UNKNOWNATR_BEGIN, RES_UNKNOWNATR_END-1,
398 : SID_ATTR_PAGE, SID_ATTR_PAGE_EXT1,
399 : SID_ATTR_PAGE_HEADERSET,SID_ATTR_PAGE_FOOTERSET,
400 : SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
401 : FN_PARAM_FTN_INFO, FN_PARAM_FTN_INFO,
402 : SID_ATTR_PARA_MODEL, SID_ATTR_PARA_MODEL,
403 : SID_ATTR_PARA_PAGENUM, SID_ATTR_PARA_PAGENUM,
404 : SID_SWREGISTER_MODE, SID_SWREGISTER_MODE,
405 : SID_SWREGISTER_COLLECTION, SID_SWREGISTER_COLLECTION,
406 : FN_COND_COLL, FN_COND_COLL,
407 : SID_ATTR_AUTO_STYLE_UPDATE, SID_ATTR_AUTO_STYLE_UPDATE,
408 : SID_ATTR_NUMBERING_RULE, SID_ATTR_NUMBERING_RULE,
409 : SID_PARA_BACKGRND_DESTINATION, SID_ATTR_BRUSH_CHAR,
410 : SID_ATTR_NUMBERING_RULE, SID_ATTR_NUMBERING_RULE,
411 : 0),
412 906 : bPhysical(sal_False)
413 : {
414 453 : nHelpId = UCHAR_MAX;
415 453 : }
416 :
417 :
418 5287 : SwDocStyleSheet::SwDocStyleSheet( const SwDocStyleSheet& rOrg) :
419 : SfxStyleSheetBase(rOrg),
420 : pCharFmt(rOrg.pCharFmt),
421 : pColl(rOrg.pColl),
422 : pFrmFmt(rOrg.pFrmFmt),
423 : pDesc(rOrg.pDesc),
424 : pNumRule(rOrg.pNumRule),
425 : rDoc(rOrg.rDoc),
426 : aCoreSet(rOrg.aCoreSet),
427 5287 : bPhysical(rOrg.bPhysical)
428 : {
429 5287 : }
430 :
431 :
432 11102 : SwDocStyleSheet::~SwDocStyleSheet()
433 : {
434 11102 : }
435 :
436 : /*--------------------------------------------------------------------
437 : Description: Reset
438 : --------------------------------------------------------------------*/
439 :
440 :
441 262 : void SwDocStyleSheet::Reset()
442 : {
443 262 : aName.Erase();
444 262 : aFollow.Erase();
445 262 : aParent.Erase();
446 262 : SetPhysical(sal_False);
447 262 : }
448 :
449 : /*--------------------------------------------------------------------
450 : Description: virtual methods
451 : --------------------------------------------------------------------*/
452 :
453 219 : void SwDocStyleSheet::SetHidden( sal_Bool bValue )
454 : {
455 219 : bool bChg = false;
456 219 : if(!bPhysical)
457 0 : FillStyleSheet( FillPhysical );
458 :
459 219 : SwFmt* pFmt = 0;
460 219 : switch(nFamily)
461 : {
462 : case SFX_STYLE_FAMILY_CHAR:
463 29 : pFmt = rDoc.FindCharFmtByName( aName );
464 29 : if ( pFmt )
465 : {
466 29 : pFmt->SetHidden( bValue );
467 29 : bChg = true;
468 : }
469 29 : break;
470 :
471 : case SFX_STYLE_FAMILY_PARA:
472 151 : pFmt = rDoc.FindTxtFmtCollByName( aName );
473 151 : if ( pFmt )
474 : {
475 151 : pFmt->SetHidden( bValue );
476 151 : bChg = true;
477 : }
478 151 : break;
479 :
480 : case SFX_STYLE_FAMILY_FRAME:
481 3 : pFmt = rDoc.FindFrmFmtByName( aName );
482 3 : if ( pFmt )
483 : {
484 3 : pFmt->SetHidden( bValue );
485 3 : bChg = true;
486 : }
487 3 : break;
488 :
489 : case SFX_STYLE_FAMILY_PAGE:
490 : {
491 28 : SwPageDesc* pPgDesc = rDoc.FindPageDescByName( aName );
492 28 : if ( pPgDesc )
493 : {
494 28 : pPgDesc->SetHidden( bValue );
495 28 : bChg = true;
496 : }
497 : }
498 28 : break;
499 :
500 : case SFX_STYLE_FAMILY_PSEUDO:
501 : {
502 8 : SwNumRule* pRule = rDoc.FindNumRulePtr( aName );
503 8 : if ( pRule )
504 : {
505 8 : pRule->SetHidden( bValue );
506 8 : bChg = true;
507 : }
508 : }
509 : default:;
510 : }
511 :
512 219 : if( bChg )
513 : {
514 219 : pPool->First(); // internal list has to be updated
515 219 : pPool->Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED, *this ) );
516 219 : SwEditShell* pSh = rDoc.GetEditShell();
517 219 : if( pSh )
518 0 : pSh->CallChgLnk();
519 : }
520 219 : }
521 :
522 26 : sal_Bool SwDocStyleSheet::IsHidden( ) const
523 : {
524 26 : sal_Bool bRet = sal_False;
525 :
526 26 : SwFmt* pFmt = 0;
527 26 : switch(nFamily)
528 : {
529 : case SFX_STYLE_FAMILY_CHAR:
530 5 : pFmt = rDoc.FindCharFmtByName( aName );
531 5 : bRet = pFmt && pFmt->IsHidden( );
532 5 : break;
533 :
534 : case SFX_STYLE_FAMILY_PARA:
535 17 : pFmt = rDoc.FindTxtFmtCollByName( aName );
536 17 : bRet = pFmt && pFmt->IsHidden( );
537 17 : break;
538 :
539 : case SFX_STYLE_FAMILY_FRAME:
540 0 : pFmt = rDoc.FindFrmFmtByName( aName );
541 0 : bRet = pFmt && pFmt->IsHidden( );
542 0 : break;
543 :
544 : case SFX_STYLE_FAMILY_PAGE:
545 : {
546 4 : SwPageDesc* pPgDesc = rDoc.FindPageDescByName( aName );
547 4 : bRet = pPgDesc && pPgDesc->IsHidden( );
548 : }
549 4 : break;
550 : case SFX_STYLE_FAMILY_PSEUDO:
551 : {
552 0 : SwNumRule* pRule = rDoc.FindNumRulePtr( aName );
553 0 : bRet = pRule && pRule->IsHidden( );
554 : }
555 : default:;
556 : }
557 :
558 26 : return bRet;
559 : }
560 :
561 1005 : const String& SwDocStyleSheet::GetParent() const
562 : {
563 1005 : if( !bPhysical )
564 : {
565 : // check if it's already in document
566 0 : SwFmt* pFmt = 0;
567 : SwGetPoolIdFromName eGetType;
568 0 : switch(nFamily)
569 : {
570 : case SFX_STYLE_FAMILY_CHAR:
571 0 : pFmt = rDoc.FindCharFmtByName( aName );
572 0 : eGetType = nsSwGetPoolIdFromName::GET_POOLID_CHRFMT;
573 0 : break;
574 :
575 : case SFX_STYLE_FAMILY_PARA:
576 0 : pFmt = rDoc.FindTxtFmtCollByName( aName );
577 0 : eGetType = nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL;
578 0 : break;
579 :
580 : case SFX_STYLE_FAMILY_FRAME:
581 0 : pFmt = rDoc.FindFrmFmtByName( aName );
582 0 : eGetType = nsSwGetPoolIdFromName::GET_POOLID_FRMFMT;
583 0 : break;
584 :
585 : case SFX_STYLE_FAMILY_PAGE:
586 : case SFX_STYLE_FAMILY_PSEUDO:
587 : default:
588 0 : return aEmptyStr; // there's no parent
589 : }
590 :
591 0 : String sTmp;
592 0 : if( !pFmt ) // not yet there, so default Parent
593 : {
594 0 : sal_uInt16 i = SwStyleNameMapper::GetPoolIdFromUIName( aName, eGetType );
595 0 : i = ::GetPoolParent( i );
596 0 : if( i && USHRT_MAX != i )
597 0 : SwStyleNameMapper::FillUIName( i, sTmp );
598 : }
599 : else
600 : {
601 0 : SwFmt* p = pFmt->DerivedFrom();
602 0 : if( p && !p->IsDefault() )
603 0 : sTmp = p->GetName();
604 : }
605 0 : SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
606 0 : pThis->aParent = sTmp;
607 : }
608 1005 : return aParent;
609 : }
610 :
611 : /*--------------------------------------------------------------------
612 : Description: Follower
613 : --------------------------------------------------------------------*/
614 :
615 :
616 200 : const String& SwDocStyleSheet::GetFollow() const
617 : {
618 200 : if( !bPhysical )
619 : {
620 0 : SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
621 0 : pThis->FillStyleSheet( FillAllInfo );
622 : }
623 200 : return aFollow;
624 : }
625 :
626 : /*--------------------------------------------------------------------
627 : Description: What Linkage is possible
628 : --------------------------------------------------------------------*/
629 :
630 :
631 0 : bool SwDocStyleSheet::HasFollowSupport() const
632 : {
633 0 : switch(nFamily)
634 : {
635 : case SFX_STYLE_FAMILY_PARA :
636 0 : case SFX_STYLE_FAMILY_PAGE : return true;
637 : case SFX_STYLE_FAMILY_FRAME:
638 : case SFX_STYLE_FAMILY_CHAR :
639 0 : case SFX_STYLE_FAMILY_PSEUDO: return false;
640 : default:
641 : OSL_ENSURE(!this, "unknown style family");
642 : }
643 0 : return false;
644 : }
645 :
646 : /*--------------------------------------------------------------------
647 : Description: Parent ?
648 : --------------------------------------------------------------------*/
649 :
650 :
651 0 : bool SwDocStyleSheet::HasParentSupport() const
652 : {
653 0 : bool bRet = false;
654 0 : switch(nFamily)
655 : {
656 : case SFX_STYLE_FAMILY_CHAR :
657 : case SFX_STYLE_FAMILY_PARA :
658 0 : case SFX_STYLE_FAMILY_FRAME: bRet = true;
659 : default:; //prevent warning
660 : }
661 0 : return bRet;
662 : }
663 :
664 :
665 0 : bool SwDocStyleSheet::HasClearParentSupport() const
666 : {
667 0 : bool bRet = false;
668 0 : switch(nFamily)
669 : {
670 : case SFX_STYLE_FAMILY_PARA :
671 : case SFX_STYLE_FAMILY_CHAR :
672 0 : case SFX_STYLE_FAMILY_FRAME: bRet = true;
673 : default:; //prevent warning
674 : }
675 0 : return bRet;
676 : }
677 :
678 : /*--------------------------------------------------------------------
679 : Description: determine textual description
680 : --------------------------------------------------------------------*/
681 0 : String SwDocStyleSheet::GetDescription(SfxMapUnit eUnit)
682 : {
683 0 : IntlWrapper aIntlWrapper( SvtSysLocale().GetLanguageTag() );
684 :
685 0 : rtl::OUString sPlus(" + ");
686 0 : if ( SFX_STYLE_FAMILY_PAGE == nFamily )
687 : {
688 0 : if( !pSet )
689 0 : GetItemSet();
690 :
691 0 : SfxItemIter aIter( *pSet );
692 0 : String aDesc;
693 0 : const SfxPoolItem* pItem = aIter.FirstItem();
694 :
695 0 : while ( pItem )
696 : {
697 0 : if(!IsInvalidItem(pItem))
698 0 : switch ( pItem->Which() )
699 : {
700 : case RES_LR_SPACE:
701 : case SID_ATTR_PAGE_SIZE:
702 : case SID_ATTR_PAGE_MAXSIZE:
703 : case SID_ATTR_PAGE_PAPERBIN:
704 : case SID_ATTR_PAGE_APP:
705 : case SID_ATTR_BORDER_INNER:
706 0 : break;
707 : default:
708 : {
709 0 : String aItemPresentation;
710 0 : if ( !IsInvalidItem( pItem ) &&
711 0 : pPool->GetPool().GetPresentation(
712 : *pItem, SFX_ITEM_PRESENTATION_COMPLETE,
713 0 : eUnit, aItemPresentation, &aIntlWrapper ) )
714 : {
715 0 : if ( aDesc.Len() && aItemPresentation.Len() )
716 0 : aDesc += sPlus;
717 0 : aDesc += aItemPresentation;
718 0 : }
719 : }
720 : }
721 0 : pItem = aIter.NextItem();
722 : }
723 0 : return aDesc;
724 : }
725 0 : else if ( SFX_STYLE_FAMILY_FRAME == nFamily ||
726 : SFX_STYLE_FAMILY_PARA == nFamily)
727 : {
728 0 : if( !pSet )
729 0 : GetItemSet();
730 :
731 0 : SfxItemIter aIter( *pSet );
732 0 : String aDesc;
733 0 : const SfxPoolItem* pItem = aIter.FirstItem();
734 :
735 0 : rtl::OUString sPageNum;
736 0 : String sModel, sBreak;
737 0 : sal_Bool bHasWesternFontPrefix = sal_False;
738 0 : sal_Bool bHasCJKFontPrefix = sal_False;
739 0 : SvtCJKOptions aCJKOptions;
740 :
741 0 : while ( pItem )
742 : {
743 0 : if(!IsInvalidItem(pItem))
744 0 : switch ( pItem->Which() )
745 : {
746 : case SID_ATTR_AUTO_STYLE_UPDATE:
747 : case SID_PARA_BACKGRND_DESTINATION:
748 : case RES_PAGEDESC:
749 : //CTL not yet supported
750 : case RES_CHRATR_CTL_FONT:
751 : case RES_CHRATR_CTL_FONTSIZE:
752 : case RES_CHRATR_CTL_LANGUAGE:
753 : case RES_CHRATR_CTL_POSTURE:
754 : case RES_CHRATR_CTL_WEIGHT:
755 0 : break;
756 : default:
757 : {
758 0 : String aItemPresentation;
759 0 : if ( !IsInvalidItem( pItem ) &&
760 0 : pPool->GetPool().GetPresentation(
761 : *pItem, SFX_ITEM_PRESENTATION_COMPLETE,
762 0 : eUnit, aItemPresentation, &aIntlWrapper ) )
763 : {
764 0 : sal_Bool bIsDefault = sal_False;
765 0 : switch ( pItem->Which() )
766 : {
767 : case SID_ATTR_PARA_PAGENUM:
768 0 : sPageNum = aItemPresentation;
769 0 : break;
770 : case SID_ATTR_PARA_MODEL:
771 0 : sModel = aItemPresentation;
772 0 : break;
773 : case RES_BREAK:
774 0 : sBreak = aItemPresentation;
775 0 : break;
776 : case RES_CHRATR_CJK_FONT:
777 : case RES_CHRATR_CJK_FONTSIZE:
778 : case RES_CHRATR_CJK_LANGUAGE:
779 : case RES_CHRATR_CJK_POSTURE:
780 : case RES_CHRATR_CJK_WEIGHT:
781 0 : if(aCJKOptions.IsCJKFontEnabled())
782 0 : bIsDefault = sal_True;
783 0 : if(!bHasCJKFontPrefix)
784 : {
785 0 : aItemPresentation.Insert(SW_RESSTR(STR_CJK_FONT), 0);
786 0 : bHasCJKFontPrefix = sal_True;
787 : }
788 0 : break;
789 : case RES_CHRATR_FONT:
790 : case RES_CHRATR_FONTSIZE:
791 : case RES_CHRATR_LANGUAGE:
792 : case RES_CHRATR_POSTURE:
793 : case RES_CHRATR_WEIGHT:
794 0 : if(!bHasWesternFontPrefix)
795 : {
796 0 : aItemPresentation.Insert(SW_RESSTR(STR_WESTERN_FONT), 0);
797 0 : bHasWesternFontPrefix = sal_True;
798 0 : bIsDefault = sal_True;
799 : }
800 : // no break;
801 : default:
802 0 : bIsDefault = sal_True;
803 : }
804 0 : if(bIsDefault)
805 : {
806 0 : if ( aDesc.Len() && aItemPresentation.Len() )
807 0 : aDesc += sPlus;
808 0 : aDesc += aItemPresentation;
809 : }
810 0 : }
811 : }
812 : }
813 0 : pItem = aIter.NextItem();
814 : }
815 : // Special treatment for Break, Page template and Site offset
816 0 : if(sBreak.Len() && !sModel.Len()) // when Model, break is invalid
817 : {
818 0 : if(aDesc.Len())
819 0 : aDesc += sPlus;
820 0 : aDesc += sBreak;
821 : }
822 0 : if(sModel.Len())
823 : {
824 0 : if(aDesc.Len())
825 0 : aDesc += sPlus;
826 0 : aDesc += SW_RESSTR(STR_PAGEBREAK);
827 0 : aDesc += sPlus;
828 0 : aDesc += sModel;
829 0 : if (sPageNum != "0")
830 : {
831 0 : aDesc += sPlus;
832 0 : aDesc += SW_RESSTR(STR_PAGEOFFSET);
833 0 : aDesc += sPageNum;
834 : }
835 : }
836 0 : return aDesc;
837 : }
838 0 : else if( SFX_STYLE_FAMILY_PSEUDO == nFamily )
839 : {
840 0 : return aEmptyStr;
841 : }
842 :
843 0 : return SfxStyleSheetBase::GetDescription(eUnit);
844 : }
845 :
846 :
847 0 : String SwDocStyleSheet::GetDescription()
848 : {
849 0 : return GetDescription(SFX_MAPUNIT_CM);
850 : }
851 :
852 : /*--------------------------------------------------------------------
853 : Description: Set names
854 : --------------------------------------------------------------------*/
855 :
856 :
857 0 : bool SwDocStyleSheet::SetName( const String& rStr)
858 : {
859 0 : if( !rStr.Len() )
860 0 : return false;
861 :
862 0 : if( aName != rStr )
863 : {
864 0 : if( !SfxStyleSheetBase::SetName( rStr ))
865 0 : return false;
866 : }
867 0 : else if(!bPhysical)
868 0 : FillStyleSheet( FillPhysical );
869 :
870 0 : int bChg = false;
871 0 : switch(nFamily)
872 : {
873 : case SFX_STYLE_FAMILY_CHAR :
874 : {
875 : OSL_ENSURE(pCharFmt, "SwCharFormat missing!");
876 0 : if( pCharFmt && pCharFmt->GetName() != rStr )
877 : {
878 0 : pCharFmt->SetName( rStr );
879 0 : bChg = true;
880 : }
881 0 : break;
882 : }
883 : case SFX_STYLE_FAMILY_PARA :
884 : {
885 : OSL_ENSURE(pColl, "Collection missing!");
886 0 : if( pColl && pColl->GetName() != rStr )
887 : {
888 0 : if (pColl->GetName().Len() > 0)
889 0 : rDoc.RenameFmt(*pColl, rStr);
890 : else
891 0 : pColl->SetName(rStr);
892 :
893 0 : bChg = true;
894 : }
895 0 : break;
896 : }
897 : case SFX_STYLE_FAMILY_FRAME:
898 : {
899 : OSL_ENSURE(pFrmFmt, "FrmFmt missing!");
900 0 : if( pFrmFmt && pFrmFmt->GetName() != rStr )
901 : {
902 0 : if (pFrmFmt->GetName().Len() > 0)
903 0 : rDoc.RenameFmt(*pFrmFmt, rStr);
904 : else
905 0 : pFrmFmt->SetName( rStr );
906 :
907 0 : bChg = true;
908 : }
909 0 : break;
910 : }
911 : case SFX_STYLE_FAMILY_PAGE :
912 : OSL_ENSURE(pDesc, "PageDesc missing!");
913 0 : if( pDesc && pDesc->GetName() != rStr )
914 : {
915 : // Set PageDesc - copy with earlier one - probably not
916 : // necessary for setting the name. So here we allow a
917 : // cast.
918 0 : SwPageDesc aPageDesc(*((SwPageDesc*)pDesc));
919 0 : String aOldName(aPageDesc.GetName());
920 :
921 0 : aPageDesc.SetName( rStr );
922 0 : bool const bDoesUndo = rDoc.GetIDocumentUndoRedo().DoesUndo();
923 :
924 0 : rDoc.GetIDocumentUndoRedo().DoUndo(aOldName.Len() > 0);
925 0 : rDoc.ChgPageDesc(aOldName, aPageDesc);
926 0 : rDoc.GetIDocumentUndoRedo().DoUndo(bDoesUndo);
927 :
928 0 : rDoc.SetModified();
929 0 : bChg = true;
930 : }
931 0 : break;
932 : case SFX_STYLE_FAMILY_PSEUDO:
933 : OSL_ENSURE(pNumRule, "NumRule missing!");
934 :
935 0 : if (pNumRule)
936 : {
937 0 : String aOldName = pNumRule->GetName();
938 :
939 0 : if (aOldName.Len() > 0)
940 : {
941 0 : if ( aOldName != rStr &&
942 0 : rDoc.RenameNumRule(aOldName, rStr))
943 : {
944 0 : pNumRule = rDoc.FindNumRulePtr(rStr);
945 0 : rDoc.SetModified();
946 :
947 0 : bChg = true;
948 : }
949 : }
950 : else
951 : {
952 : // #i91400#
953 0 : ((SwNumRule*)pNumRule)->SetName( rStr, rDoc );
954 0 : rDoc.SetModified();
955 :
956 0 : bChg = true;
957 0 : }
958 : }
959 :
960 0 : break;
961 :
962 : default:
963 : OSL_ENSURE(!this, "unknown style family");
964 : }
965 :
966 0 : if( bChg )
967 : {
968 0 : pPool->First(); // internal list has to be updated
969 0 : pPool->Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED, *this ) );
970 0 : SwEditShell* pSh = rDoc.GetEditShell();
971 0 : if( pSh )
972 0 : pSh->CallChgLnk();
973 : }
974 0 : return true;
975 : }
976 :
977 : /*--------------------------------------------------------------------
978 : Description: hierarchy of deduction
979 : --------------------------------------------------------------------*/
980 :
981 :
982 324 : bool SwDocStyleSheet::SetParent( const String& rStr)
983 : {
984 324 : SwFmt* pFmt = 0, *pParent = 0;
985 324 : switch(nFamily)
986 : {
987 : case SFX_STYLE_FAMILY_CHAR :
988 : OSL_ENSURE( pCharFmt, "SwCharFormat missing!" );
989 22 : if( 0 != ( pFmt = pCharFmt ) && rStr.Len() )
990 22 : pParent = lcl_FindCharFmt(rDoc, rStr);
991 22 : break;
992 :
993 : case SFX_STYLE_FAMILY_PARA :
994 : OSL_ENSURE( pColl, "Collektion missing!");
995 302 : if( 0 != ( pFmt = pColl ) && rStr.Len() )
996 195 : pParent = lcl_FindParaFmt( rDoc, rStr );
997 302 : break;
998 :
999 : case SFX_STYLE_FAMILY_FRAME:
1000 : OSL_ENSURE(pFrmFmt, "FrameFormat missing!");
1001 0 : if( 0 != ( pFmt = pFrmFmt ) && rStr.Len() )
1002 0 : pParent = lcl_FindFrmFmt( rDoc, rStr );
1003 0 : break;
1004 :
1005 : case SFX_STYLE_FAMILY_PAGE:
1006 : case SFX_STYLE_FAMILY_PSEUDO:
1007 0 : break;
1008 : default:
1009 : OSL_ENSURE(!this, "unknown style family");
1010 : }
1011 :
1012 324 : bool bRet = false;
1013 648 : if( pFmt && pFmt->DerivedFrom() &&
1014 324 : pFmt->DerivedFrom()->GetName() != rStr )
1015 : {
1016 : {
1017 324 : SwImplShellAction aTmp( rDoc );
1018 324 : bRet = pFmt->SetDerivedFrom( pParent );
1019 : }
1020 :
1021 324 : if( bRet )
1022 : {
1023 324 : aParent = rStr;
1024 : pPool->Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED,
1025 324 : *this ) );
1026 : }
1027 : }
1028 :
1029 324 : return bRet;
1030 : }
1031 :
1032 : /*--------------------------------------------------------------------
1033 : Description: Set Follower
1034 : --------------------------------------------------------------------*/
1035 :
1036 :
1037 6 : bool SwDocStyleSheet::SetFollow( const String& rStr)
1038 : {
1039 6 : if( rStr.Len() && !SfxStyleSheetBase::SetFollow( rStr ))
1040 0 : return false;
1041 :
1042 6 : SwImplShellAction aTmpSh( rDoc );
1043 6 : switch(nFamily)
1044 : {
1045 : case SFX_STYLE_FAMILY_PARA :
1046 : {
1047 : OSL_ENSURE(pColl, "Collection missing!");
1048 4 : if( pColl )
1049 : {
1050 4 : SwTxtFmtColl* pFollow = pColl;
1051 4 : if( rStr.Len() && 0 == (pFollow = lcl_FindParaFmt(rDoc, rStr) ))
1052 0 : pFollow = pColl;
1053 :
1054 4 : pColl->SetNextTxtFmtColl(*pFollow);
1055 : }
1056 4 : break;
1057 : }
1058 : case SFX_STYLE_FAMILY_PAGE :
1059 : {
1060 : OSL_ENSURE(pDesc, "PageDesc missing!");
1061 2 : if( pDesc )
1062 : {
1063 2 : const SwPageDesc* pFollowDesc = rStr.Len()
1064 2 : ? lcl_FindPageDesc(rDoc, rStr)
1065 4 : : 0;
1066 : sal_uInt16 nId;
1067 4 : if( pFollowDesc != pDesc->GetFollow() &&
1068 2 : rDoc.FindPageDescByName( pDesc->GetName(), &nId ) )
1069 : {
1070 2 : SwPageDesc aDesc( *pDesc );
1071 2 : aDesc.SetFollow( pFollowDesc );
1072 2 : rDoc.ChgPageDesc( nId, aDesc );
1073 2 : pDesc = &rDoc.GetPageDesc( nId );
1074 : }
1075 : }
1076 2 : break;
1077 : }
1078 : case SFX_STYLE_FAMILY_CHAR:
1079 : case SFX_STYLE_FAMILY_FRAME:
1080 : case SFX_STYLE_FAMILY_PSEUDO:
1081 0 : break;
1082 : default:
1083 : OSL_ENSURE(!this, "unknwown style family");
1084 : }
1085 :
1086 6 : return true;
1087 : }
1088 :
1089 : /*--------------------------------------------------------------------
1090 : Description: extract ItemSet to Name and Family, Mask
1091 : --------------------------------------------------------------------*/
1092 :
1093 4613 : SfxItemSet& SwDocStyleSheet::GetItemSet()
1094 : {
1095 4613 : if(!bPhysical)
1096 111 : FillStyleSheet( FillPhysical );
1097 :
1098 4613 : switch(nFamily)
1099 : {
1100 : case SFX_STYLE_FAMILY_CHAR:
1101 : {
1102 : OSL_ENSURE(pCharFmt, "Where's SwCharFmt");
1103 815 : aCoreSet.Put(pCharFmt->GetAttrSet());
1104 :
1105 815 : if(pCharFmt->DerivedFrom())
1106 815 : aCoreSet.SetParent(&pCharFmt->DerivedFrom()->GetAttrSet());
1107 : }
1108 815 : break;
1109 : case SFX_STYLE_FAMILY_PARA :
1110 : case SFX_STYLE_FAMILY_FRAME:
1111 : {
1112 2587 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
1113 2587 : aBoxInfo.SetTable( sal_False );
1114 2587 : aBoxInfo.SetDist( sal_True ); // always show gap field
1115 2587 : aBoxInfo.SetMinDist( sal_True );// set minimum size in tables and paragraphs
1116 2587 : aBoxInfo.SetDefDist( MIN_BORDER_DIST );// always set Default-Gap
1117 : // Single lines can only have DontCare-Status in tables
1118 2587 : aBoxInfo.SetValid( VALID_DISABLE, sal_True );
1119 2587 : if ( nFamily == SFX_STYLE_FAMILY_PARA )
1120 : {
1121 : OSL_ENSURE(pColl, "Where's Collection");
1122 2566 : aCoreSet.Put(pColl->GetAttrSet());
1123 2566 : aCoreSet.Put( aBoxInfo );
1124 2566 : aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pColl->IsAutoUpdateFmt()));
1125 :
1126 2566 : if(pColl->DerivedFrom())
1127 2566 : aCoreSet.SetParent(&pColl->DerivedFrom()->GetAttrSet());
1128 : }
1129 : else
1130 : {
1131 : OSL_ENSURE(pFrmFmt, "Where's FrmFmt");
1132 21 : aCoreSet.Put(pFrmFmt->GetAttrSet());
1133 21 : aCoreSet.Put( aBoxInfo );
1134 21 : aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pFrmFmt->IsAutoUpdateFmt()));
1135 :
1136 21 : if(pFrmFmt->DerivedFrom())
1137 21 : aCoreSet.SetParent(&pFrmFmt->DerivedFrom()->GetAttrSet());
1138 2587 : }
1139 : }
1140 2587 : break;
1141 :
1142 : case SFX_STYLE_FAMILY_PAGE :
1143 : {
1144 : OSL_ENSURE(pDesc, "No PageDescriptor");
1145 1123 : ::PageDescToItemSet(*((SwPageDesc*)pDesc), aCoreSet);
1146 : }
1147 1123 : break;
1148 :
1149 : case SFX_STYLE_FAMILY_PSEUDO:
1150 : {
1151 : OSL_ENSURE(pNumRule, "No NumRule");
1152 88 : SvxNumRule aRule = pNumRule->MakeSvxNumRule();
1153 88 : aCoreSet.Put(SvxNumBulletItem(aRule));
1154 : }
1155 88 : break;
1156 :
1157 : default:
1158 : OSL_ENSURE(!this, "unknown style family");
1159 : }
1160 : // Member of Baseclass
1161 4613 : pSet = &aCoreSet;
1162 :
1163 4613 : return aCoreSet;
1164 : }
1165 :
1166 0 : void SwDocStyleSheet::MergeIndentAttrsOfListStyle( SfxItemSet& rSet )
1167 : {
1168 0 : if ( nFamily != SFX_STYLE_FAMILY_PARA )
1169 : {
1170 0 : return;
1171 : }
1172 :
1173 : OSL_ENSURE( pColl, "<SwDocStyleSheet::MergeIndentAttrsOfListStyle(..)> - missing paragraph style");
1174 0 : if ( pColl->AreListLevelIndentsApplicable() )
1175 : {
1176 : OSL_ENSURE( pColl->GetItemState( RES_PARATR_NUMRULE ) == SFX_ITEM_SET,
1177 : "<SwDocStyleSheet::MergeIndentAttrsOfListStyle(..)> - list level indents are applicable at paragraph style, but no list style found. Serious defect -> please inform OD." );
1178 0 : const String sNumRule = pColl->GetNumRule().GetValue();
1179 0 : if( sNumRule.Len() )
1180 : {
1181 0 : const SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
1182 0 : if( pRule )
1183 : {
1184 0 : const SwNumFmt& rFmt = pRule->Get( 0 );
1185 0 : if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
1186 : {
1187 0 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1188 0 : aLR.SetTxtLeft( rFmt.GetIndentAt() );
1189 0 : aLR.SetTxtFirstLineOfst( static_cast<short>(rFmt.GetFirstLineIndent()) );
1190 0 : rSet.Put( aLR );
1191 : }
1192 : }
1193 0 : }
1194 : }
1195 : }
1196 :
1197 : // handling of parameter <bResetIndentAttrsAtParagraphStyle>
1198 2808 : void SwDocStyleSheet::SetItemSet( const SfxItemSet& rSet,
1199 : const bool bResetIndentAttrsAtParagraphStyle )
1200 : {
1201 : // if applicable determine format first
1202 2808 : if(!bPhysical)
1203 0 : FillStyleSheet( FillPhysical );
1204 :
1205 2808 : SwImplShellAction aTmpSh( rDoc );
1206 :
1207 : OSL_ENSURE( &rSet != &aCoreSet, "SetItemSet with own Set is not allowed" );
1208 :
1209 2808 : if (rDoc.GetIDocumentUndoRedo().DoesUndo())
1210 : {
1211 0 : SwRewriter aRewriter;
1212 0 : aRewriter.AddRule( UndoArg1, GetName() );
1213 0 : rDoc.GetIDocumentUndoRedo().StartUndo( UNDO_INSFMTATTR, &aRewriter );
1214 : }
1215 :
1216 2808 : SwFmt* pFmt = 0;
1217 2808 : SwPageDesc* pNewDsc = 0;
1218 2808 : sal_uInt16 nPgDscPos = 0;
1219 :
1220 2808 : switch(nFamily)
1221 : {
1222 : case SFX_STYLE_FAMILY_CHAR :
1223 : {
1224 : OSL_ENSURE(pCharFmt, "Where's CharFormat");
1225 726 : pFmt = pCharFmt;
1226 : }
1227 726 : break;
1228 :
1229 : case SFX_STYLE_FAMILY_PARA :
1230 : {
1231 : OSL_ENSURE(pColl, "Where's Collection");
1232 : const SfxPoolItem* pAutoUpdate;
1233 1582 : if(SFX_ITEM_SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,sal_False, &pAutoUpdate ))
1234 : {
1235 1582 : pColl->SetAutoUpdateFmt(((const SfxBoolItem*)pAutoUpdate)->GetValue());
1236 : }
1237 :
1238 : const SwCondCollItem* pCondItem;
1239 1582 : if( SFX_ITEM_SET != rSet.GetItemState( FN_COND_COLL, sal_False,
1240 1582 : (const SfxPoolItem**)&pCondItem ))
1241 1582 : pCondItem = 0;
1242 :
1243 1582 : if( RES_CONDTXTFMTCOLL == pColl->Which() && pCondItem )
1244 : {
1245 : SwFmt* pFindFmt;
1246 0 : const CommandStruct* pCmds = SwCondCollItem::GetCmds();
1247 0 : for(sal_uInt16 i = 0; i < COND_COMMAND_COUNT; i++)
1248 : {
1249 0 : SwCollCondition aCond( 0, pCmds[ i ].nCnd, pCmds[ i ].nSubCond );
1250 0 : ((SwConditionTxtFmtColl*)pColl)->RemoveCondition( aCond );
1251 0 : const String& rStyle = pCondItem->GetStyle( i );
1252 0 : if( rStyle.Len() &&
1253 0 : 0 != ( pFindFmt = lcl_FindParaFmt( rDoc, rStyle, 0, sal_True )))
1254 : {
1255 0 : aCond.RegisterToFormat( *pFindFmt );
1256 0 : ((SwConditionTxtFmtColl*)pColl)->InsertCondition( aCond );
1257 : }
1258 0 : }
1259 :
1260 : // Update document to new conditions
1261 0 : SwCondCollCondChg aMsg( pColl );
1262 0 : pColl->ModifyNotification( &aMsg, &aMsg );
1263 : }
1264 1582 : else if( pCondItem && !pColl->GetDepends() )
1265 : {
1266 : // no conditional template, then first create and adopt
1267 : // all important values
1268 : SwConditionTxtFmtColl* pCColl = rDoc.MakeCondTxtFmtColl(
1269 0 : pColl->GetName(), (SwTxtFmtColl*)pColl->DerivedFrom() );
1270 0 : if( pColl != &pColl->GetNextTxtFmtColl() )
1271 0 : pCColl->SetNextTxtFmtColl( pColl->GetNextTxtFmtColl() );
1272 :
1273 0 : if( pColl->IsAssignedToListLevelOfOutlineStyle())
1274 0 : pCColl->AssignToListLevelOfOutlineStyle(pColl->GetAssignedOutlineStyleLevel());
1275 : else
1276 0 : pCColl->DeleteAssignmentToListLevelOfOutlineStyle();
1277 :
1278 :
1279 :
1280 : SwTxtFmtColl* pFindFmt;
1281 0 : const CommandStruct* pCmds = SwCondCollItem::GetCmds();
1282 0 : for( sal_uInt16 i = 0; i < COND_COMMAND_COUNT; ++i )
1283 : {
1284 0 : const String& rStyle = pCondItem->GetStyle( i );
1285 0 : if( rStyle.Len() &&
1286 0 : 0 != ( pFindFmt = lcl_FindParaFmt( rDoc, rStyle, 0, sal_True )))
1287 : {
1288 : pCColl->InsertCondition( SwCollCondition( pFindFmt,
1289 0 : pCmds[ i ].nCnd, pCmds[ i ].nSubCond ) );
1290 : }
1291 : }
1292 :
1293 0 : rDoc.DelTxtFmtColl( pColl );
1294 0 : pColl = pCColl;
1295 : }
1296 1582 : if ( bResetIndentAttrsAtParagraphStyle &&
1297 0 : rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, 0 ) == SFX_ITEM_SET &&
1298 0 : rSet.GetItemState( RES_LR_SPACE, sal_False, 0 ) != SFX_ITEM_SET &&
1299 0 : pColl->GetItemState( RES_LR_SPACE, sal_False, 0 ) == SFX_ITEM_SET )
1300 : {
1301 0 : rDoc.ResetAttrAtFormat( RES_LR_SPACE, *pColl );
1302 : }
1303 :
1304 : // #i56252: If a standard numbering style is assigned to a standard paragraph style
1305 : // we have to create a physical instance of the numbering style. If we do not and
1306 : // neither the paragraph style nor the numbering style is used in the document
1307 : // the numbering style will not be saved with the document and the assignment got lost.
1308 1582 : const SfxPoolItem* pNumRuleItem = 0;
1309 1582 : if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, &pNumRuleItem ) )
1310 : { // Setting a numbering rule?
1311 29 : String sNumRule = ((SwNumRuleItem*)pNumRuleItem)->GetValue();
1312 29 : if( sNumRule.Len() )
1313 : {
1314 9 : SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
1315 9 : if( !pRule )
1316 : { // Numbering rule not in use yet.
1317 0 : sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( sNumRule, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
1318 0 : if( USHRT_MAX != nPoolId ) // It's a standard numbering rule
1319 : {
1320 0 : pRule = rDoc.GetNumRuleFromPool( nPoolId ); // Create numbering rule (physical)
1321 : }
1322 : }
1323 29 : }
1324 : }
1325 :
1326 1582 : pFmt = pColl;
1327 :
1328 1582 : sal_uInt16 nId = pColl->GetPoolFmtId() &
1329 1582 : ~ ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID );
1330 1582 : switch( GetMask() & ( 0x0fff & ~SWSTYLEBIT_CONDCOLL ) )
1331 : {
1332 : case SWSTYLEBIT_TEXT:
1333 515 : nId |= COLL_TEXT_BITS;
1334 515 : break;
1335 : case SWSTYLEBIT_CHAPTER:
1336 7 : nId |= COLL_DOC_BITS;
1337 7 : break;
1338 : case SWSTYLEBIT_LIST:
1339 127 : nId |= COLL_LISTS_BITS;
1340 127 : break;
1341 : case SWSTYLEBIT_IDX:
1342 145 : nId |= COLL_REGISTER_BITS;
1343 145 : break;
1344 : case SWSTYLEBIT_EXTRA:
1345 188 : nId |= COLL_EXTRA_BITS;
1346 188 : break;
1347 : case SWSTYLEBIT_HTML:
1348 0 : nId |= COLL_HTML_BITS;
1349 0 : break;
1350 : }
1351 1582 : pColl->SetPoolFmtId( nId );
1352 : break;
1353 : }
1354 : case SFX_STYLE_FAMILY_FRAME:
1355 : {
1356 : OSL_ENSURE(pFrmFmt, "Where's FrmFmt");
1357 : const SfxPoolItem* pAutoUpdate;
1358 9 : if(SFX_ITEM_SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,sal_False, &pAutoUpdate ))
1359 : {
1360 9 : pFrmFmt->SetAutoUpdateFmt(((const SfxBoolItem*)pAutoUpdate)->GetValue());
1361 : }
1362 9 : pFmt = pFrmFmt;
1363 : }
1364 9 : break;
1365 :
1366 : case SFX_STYLE_FAMILY_PAGE :
1367 : {
1368 : OSL_ENSURE(pDesc, "Where's PageDescriptor");
1369 :
1370 411 : if( rDoc.FindPageDescByName( pDesc->GetName(), &nPgDscPos ))
1371 : {
1372 411 : pNewDsc = new SwPageDesc( *pDesc );
1373 : // #i48949# - no undo actions for the
1374 : // copy of the page style
1375 411 : ::sw::UndoGuard const ug(rDoc.GetIDocumentUndoRedo());
1376 411 : rDoc.CopyPageDesc(*pDesc, *pNewDsc); // #i7983#
1377 :
1378 411 : pFmt = &pNewDsc->GetMaster();
1379 : }
1380 : }
1381 411 : break;
1382 :
1383 : case SFX_STYLE_FAMILY_PSEUDO:
1384 : {
1385 : OSL_ENSURE(pNumRule, "Where's NumRule");
1386 :
1387 80 : if (!pNumRule)
1388 : break;
1389 :
1390 : const SfxPoolItem* pItem;
1391 80 : switch( rSet.GetItemState( SID_ATTR_NUMBERING_RULE, sal_False, &pItem ))
1392 : {
1393 : case SFX_ITEM_SET:
1394 : {
1395 80 : SvxNumRule* pSetRule = ((SvxNumBulletItem*)pItem)->GetNumRule();
1396 80 : pSetRule->UnLinkGraphics();
1397 80 : SwNumRule aSetRule(*pNumRule);
1398 80 : aSetRule.SetSvxRule(*pSetRule, &rDoc);
1399 80 : rDoc.ChgNumRuleFmts( aSetRule );
1400 : }
1401 80 : break;
1402 : case SFX_ITEM_DONTCARE:
1403 : // set NumRule to default values
1404 : // what are the default values?
1405 : {
1406 0 : SwNumRule aRule( pNumRule->GetName(),
1407 : // #i89178#
1408 0 : numfunc::GetDefaultPositionAndSpaceMode() );
1409 0 : rDoc.ChgNumRuleFmts( aRule );
1410 : }
1411 0 : break;
1412 : }
1413 : }
1414 80 : break;
1415 :
1416 : default:
1417 : OSL_ENSURE(!this, "unknown style family");
1418 : }
1419 :
1420 2808 : if( pFmt && rSet.Count())
1421 : {
1422 2718 : SfxItemIter aIter( rSet );
1423 2718 : const SfxPoolItem* pItem = aIter.GetCurItem();
1424 17773 : while( sal_True )
1425 : {
1426 20491 : if( IsInvalidItem( pItem ) ) // Clear
1427 : {
1428 : // use method <SwDoc::ResetAttrAtFormat(..)> in order to
1429 : // create an Undo object for the attribute reset.
1430 0 : rDoc.ResetAttrAtFormat( rSet.GetWhichByPos(aIter.GetCurPos()),
1431 0 : *pFmt );
1432 : }
1433 :
1434 20491 : if( aIter.IsAtEnd() )
1435 2718 : break;
1436 17773 : pItem = aIter.NextItem();
1437 : }
1438 2718 : SfxItemSet aSet(rSet);
1439 2718 : aSet.ClearInvalidItems();
1440 :
1441 2718 : aCoreSet.ClearItem();
1442 :
1443 2718 : if( pNewDsc )
1444 : {
1445 411 : ::ItemSetToPageDesc( aSet, *pNewDsc );
1446 411 : rDoc.ChgPageDesc( nPgDscPos, *pNewDsc );
1447 411 : pDesc = &rDoc.GetPageDesc( nPgDscPos );
1448 411 : rDoc.PreDelPageDesc(pNewDsc); // #i7983#
1449 411 : delete pNewDsc;
1450 : }
1451 : else
1452 2307 : rDoc.ChgFmt(*pFmt, aSet); // put all that is set
1453 : }
1454 : else
1455 : {
1456 90 : aCoreSet.ClearItem();
1457 90 : if( pNewDsc ) // we still need to delete it
1458 : {
1459 0 : rDoc.PreDelPageDesc(pNewDsc); // #i7983#
1460 0 : delete pNewDsc;
1461 : }
1462 : }
1463 :
1464 2808 : if (rDoc.GetIDocumentUndoRedo().DoesUndo())
1465 : {
1466 0 : rDoc.GetIDocumentUndoRedo().EndUndo(UNDO_END, 0);
1467 2808 : }
1468 2808 : }
1469 :
1470 0 : static void lcl_SaveStyles( sal_uInt16 nFamily, std::vector<void*>& rArr, SwDoc& rDoc )
1471 : {
1472 0 : switch( nFamily )
1473 : {
1474 : case SFX_STYLE_FAMILY_CHAR:
1475 : {
1476 0 : const SwCharFmts& rTbl = *rDoc.GetCharFmts();
1477 0 : for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1478 : {
1479 0 : rArr.push_back( rTbl[ n ] );
1480 : }
1481 : }
1482 0 : break;
1483 : case SFX_STYLE_FAMILY_PARA:
1484 : {
1485 0 : const SwTxtFmtColls& rTbl = *rDoc.GetTxtFmtColls();
1486 0 : for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1487 : {
1488 0 : rArr.push_back( rTbl[ n ] );
1489 : }
1490 : }
1491 0 : break;
1492 : case SFX_STYLE_FAMILY_FRAME:
1493 : {
1494 0 : const SwFrmFmts& rTbl = *rDoc.GetFrmFmts();
1495 0 : for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1496 : {
1497 0 : rArr.push_back( rTbl[ n ] );
1498 : }
1499 : }
1500 0 : break;
1501 :
1502 : case SFX_STYLE_FAMILY_PAGE:
1503 : {
1504 0 : for( sal_uInt16 n = 0, nCnt = rDoc.GetPageDescCnt(); n < nCnt; ++n )
1505 : {
1506 0 : rArr.push_back( &rDoc.GetPageDesc( n ) );
1507 : }
1508 : }
1509 0 : break;
1510 :
1511 : case SFX_STYLE_FAMILY_PSEUDO:
1512 : {
1513 0 : const SwNumRuleTbl& rTbl = rDoc.GetNumRuleTbl();
1514 0 : for( sal_uInt16 n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1515 : {
1516 0 : rArr.push_back( rTbl[ n ] );
1517 : }
1518 : }
1519 0 : break;
1520 : }
1521 0 : }
1522 :
1523 0 : static bool lcl_Contains(const std::vector<void*>& rArr, const void* p)
1524 : {
1525 0 : return std::find( rArr.begin(), rArr.end(), p ) != rArr.end();
1526 : }
1527 :
1528 0 : static void lcl_DeleteInfoStyles( sal_uInt16 nFamily, std::vector<void*>& rArr, SwDoc& rDoc )
1529 : {
1530 : sal_uInt16 n, nCnt;
1531 0 : switch( nFamily )
1532 : {
1533 : case SFX_STYLE_FAMILY_CHAR:
1534 : {
1535 0 : std::deque<sal_uInt16> aDelArr;
1536 0 : const SwCharFmts& rTbl = *rDoc.GetCharFmts();
1537 0 : for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1538 : {
1539 0 : if( !lcl_Contains( rArr, rTbl[ n ] ))
1540 0 : aDelArr.push_front( n );
1541 : }
1542 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1543 0 : rDoc.DelCharFmt( aDelArr[ n ] );
1544 : }
1545 0 : break;
1546 :
1547 : case SFX_STYLE_FAMILY_PARA :
1548 : {
1549 0 : std::deque<sal_uInt16> aDelArr;
1550 0 : const SwTxtFmtColls& rTbl = *rDoc.GetTxtFmtColls();
1551 0 : for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1552 : {
1553 0 : if( !lcl_Contains( rArr, rTbl[ n ] ))
1554 0 : aDelArr.push_front( n );
1555 : }
1556 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1557 0 : rDoc.DelTxtFmtColl( aDelArr[ n ] );
1558 : }
1559 0 : break;
1560 :
1561 : case SFX_STYLE_FAMILY_FRAME:
1562 : {
1563 0 : std::deque<SwFrmFmt*> aDelArr;
1564 0 : const SwFrmFmts& rTbl = *rDoc.GetFrmFmts();
1565 0 : for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1566 : {
1567 0 : if( !lcl_Contains( rArr, rTbl[ n ] ))
1568 0 : aDelArr.push_front( rTbl[ n ] );
1569 : }
1570 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1571 0 : rDoc.DelFrmFmt( aDelArr[ n ] );
1572 : }
1573 0 : break;
1574 :
1575 : case SFX_STYLE_FAMILY_PAGE:
1576 : {
1577 0 : std::deque<sal_uInt16> aDelArr;
1578 0 : for( n = 0, nCnt = rDoc.GetPageDescCnt(); n < nCnt; ++n )
1579 : {
1580 0 : if( !lcl_Contains( rArr, &rDoc.GetPageDesc( n ) ))
1581 0 : aDelArr.push_front( n );
1582 : }
1583 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1584 0 : rDoc.DelPageDesc( aDelArr[ n ] );
1585 : }
1586 0 : break;
1587 :
1588 :
1589 : case SFX_STYLE_FAMILY_PSEUDO:
1590 : {
1591 0 : std::deque<SwNumRule*> aDelArr;
1592 0 : const SwNumRuleTbl& rTbl = rDoc.GetNumRuleTbl();
1593 0 : for( n = 0, nCnt = rTbl.size(); n < nCnt; ++n )
1594 : {
1595 0 : if( !lcl_Contains( rArr, rTbl[ n ] ))
1596 0 : aDelArr.push_front( rTbl[ n ] );
1597 : }
1598 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1599 0 : rDoc.DelNumRule( aDelArr[ n ]->GetName() );
1600 : }
1601 0 : break;
1602 : }
1603 0 : }
1604 :
1605 : /*--------------------------------------------------------------------
1606 : Description: determine the format
1607 : --------------------------------------------------------------------*/
1608 :
1609 15426 : sal_Bool SwDocStyleSheet::FillStyleSheet( FillStyleType eFType )
1610 : {
1611 15426 : sal_Bool bRet = sal_False;
1612 15426 : sal_uInt16 nPoolId = USHRT_MAX;
1613 15426 : SwFmt* pFmt = 0;
1614 :
1615 15426 : sal_Bool bCreate = FillPhysical == eFType;
1616 15426 : sal_Bool bDeleteInfo = sal_False;
1617 15426 : sal_Bool bFillOnlyInfo = FillAllInfo == eFType;
1618 15426 : std::vector<void*> aDelArr;
1619 :
1620 15426 : switch(nFamily)
1621 : {
1622 : case SFX_STYLE_FAMILY_CHAR:
1623 2768 : pCharFmt = lcl_FindCharFmt(rDoc, aName, this, bCreate );
1624 2768 : bPhysical = 0 != pCharFmt;
1625 2768 : if( bFillOnlyInfo && !bPhysical )
1626 : {
1627 0 : bDeleteInfo = sal_True;
1628 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1629 0 : pCharFmt = lcl_FindCharFmt(rDoc, aName, this, sal_True );
1630 : }
1631 :
1632 2768 : pFmt = pCharFmt;
1633 2768 : if( !bCreate && !pFmt )
1634 : {
1635 2574 : if( aName == SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
1636 1287 : RES_POOLCOLL_TEXT_BEGIN ] )
1637 0 : nPoolId = 0;
1638 : else
1639 1287 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
1640 : }
1641 :
1642 2768 : bRet = 0 != pCharFmt || USHRT_MAX != nPoolId;
1643 :
1644 2768 : if( bDeleteInfo )
1645 0 : pCharFmt = 0;
1646 2768 : break;
1647 :
1648 : case SFX_STYLE_FAMILY_PARA:
1649 : {
1650 9132 : pColl = lcl_FindParaFmt(rDoc, aName, this, bCreate);
1651 9132 : bPhysical = 0 != pColl;
1652 9132 : if( bFillOnlyInfo && !bPhysical )
1653 : {
1654 0 : bDeleteInfo = sal_True;
1655 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1656 0 : pColl = lcl_FindParaFmt(rDoc, aName, this, sal_True );
1657 : }
1658 :
1659 9132 : pFmt = pColl;
1660 9132 : if( pColl )
1661 6889 : PresetFollow( pColl->GetNextTxtFmtColl().GetName() );
1662 2243 : else if( !bCreate )
1663 2243 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
1664 :
1665 9132 : bRet = 0 != pColl || USHRT_MAX != nPoolId;
1666 :
1667 9132 : if( bDeleteInfo )
1668 0 : pColl = 0;
1669 : }
1670 9132 : break;
1671 :
1672 : case SFX_STYLE_FAMILY_FRAME:
1673 300 : pFrmFmt = lcl_FindFrmFmt(rDoc, aName, this, bCreate);
1674 300 : bPhysical = 0 != pFrmFmt;
1675 300 : if( bFillOnlyInfo && bPhysical )
1676 : {
1677 0 : bDeleteInfo = sal_True;
1678 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1679 0 : pFrmFmt = lcl_FindFrmFmt(rDoc, aName, this, sal_True );
1680 : }
1681 300 : pFmt = pFrmFmt;
1682 300 : if( !bCreate && !pFmt )
1683 242 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );
1684 :
1685 300 : bRet = 0 != pFrmFmt || USHRT_MAX != nPoolId;
1686 :
1687 300 : if( bDeleteInfo )
1688 0 : pFrmFmt = 0;
1689 300 : break;
1690 :
1691 : case SFX_STYLE_FAMILY_PAGE:
1692 2770 : pDesc = lcl_FindPageDesc(rDoc, aName, this, bCreate);
1693 2770 : bPhysical = 0 != pDesc;
1694 2770 : if( bFillOnlyInfo && !pDesc )
1695 : {
1696 0 : bDeleteInfo = sal_True;
1697 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1698 0 : pDesc = lcl_FindPageDesc( rDoc, aName, this, sal_True );
1699 : }
1700 :
1701 2770 : if( pDesc )
1702 : {
1703 2241 : nPoolId = pDesc->GetPoolFmtId();
1704 2241 : nHelpId = pDesc->GetPoolHelpId();
1705 2241 : if( pDesc->GetPoolHlpFileId() != UCHAR_MAX )
1706 0 : aHelpFile = *rDoc.GetDocPattern( pDesc->GetPoolHlpFileId() );
1707 : else
1708 2241 : aHelpFile.Erase();
1709 : }
1710 529 : else if( !bCreate )
1711 529 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
1712 2770 : SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );
1713 :
1714 2770 : bRet = 0 != pDesc || USHRT_MAX != nPoolId;
1715 2770 : if( bDeleteInfo )
1716 0 : pDesc = 0;
1717 2770 : break;
1718 :
1719 : case SFX_STYLE_FAMILY_PSEUDO:
1720 456 : pNumRule = lcl_FindNumRule(rDoc, aName, this, bCreate);
1721 456 : bPhysical = 0 != pNumRule;
1722 456 : if( bFillOnlyInfo && !pNumRule )
1723 : {
1724 0 : bDeleteInfo = sal_True;
1725 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1726 0 : pNumRule = lcl_FindNumRule( rDoc, aName, this, sal_True );
1727 : }
1728 :
1729 456 : if( pNumRule )
1730 : {
1731 242 : nPoolId = pNumRule->GetPoolFmtId();
1732 242 : nHelpId = pNumRule->GetPoolHelpId();
1733 242 : if( pNumRule->GetPoolHlpFileId() != UCHAR_MAX )
1734 0 : aHelpFile = *rDoc.GetDocPattern( pNumRule->GetPoolHlpFileId() );
1735 : else
1736 242 : aHelpFile.Erase();
1737 : }
1738 214 : else if( !bCreate )
1739 214 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
1740 456 : SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );
1741 :
1742 456 : bRet = 0 != pNumRule || USHRT_MAX != nPoolId;
1743 :
1744 456 : if( bDeleteInfo )
1745 0 : pNumRule = 0;
1746 456 : break;
1747 : default:; //prevent warning
1748 : }
1749 :
1750 15426 : if( SFX_STYLE_FAMILY_CHAR == nFamily ||
1751 : SFX_STYLE_FAMILY_PARA == nFamily ||
1752 : SFX_STYLE_FAMILY_FRAME == nFamily )
1753 : {
1754 12200 : if( pFmt )
1755 8428 : nPoolId = pFmt->GetPoolFmtId();
1756 :
1757 12200 : sal_uInt16 _nMask = 0;
1758 12200 : if( pFmt == rDoc.GetDfltCharFmt() )
1759 25 : _nMask |= SFXSTYLEBIT_READONLY;
1760 12175 : else if( USER_FMT & nPoolId )
1761 3147 : _nMask |= SFXSTYLEBIT_USERDEF;
1762 :
1763 12200 : switch ( COLL_GET_RANGE_BITS & nPoolId )
1764 : {
1765 4440 : case COLL_TEXT_BITS: _nMask |= SWSTYLEBIT_TEXT; break;
1766 65 : case COLL_DOC_BITS : _nMask |= SWSTYLEBIT_CHAPTER; break;
1767 1067 : case COLL_LISTS_BITS: _nMask |= SWSTYLEBIT_LIST; break;
1768 1125 : case COLL_REGISTER_BITS: _nMask |= SWSTYLEBIT_IDX; break;
1769 1499 : case COLL_EXTRA_BITS: _nMask |= SWSTYLEBIT_EXTRA; break;
1770 50 : case COLL_HTML_BITS: _nMask |= SWSTYLEBIT_HTML; break;
1771 : }
1772 :
1773 12200 : if( pFmt )
1774 : {
1775 : OSL_ENSURE( bPhysical, "Format not found" );
1776 :
1777 8428 : nHelpId = pFmt->GetPoolHelpId();
1778 8428 : if( pFmt->GetPoolHlpFileId() != UCHAR_MAX )
1779 0 : aHelpFile = *rDoc.GetDocPattern( pFmt->GetPoolHlpFileId() );
1780 : else
1781 8428 : aHelpFile.Erase();
1782 :
1783 8428 : if( RES_CONDTXTFMTCOLL == pFmt->Which() )
1784 723 : _nMask |= SWSTYLEBIT_CONDCOLL;
1785 : }
1786 :
1787 12200 : SetMask( _nMask );
1788 : }
1789 15426 : if( bDeleteInfo && bFillOnlyInfo )
1790 0 : ::lcl_DeleteInfoStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1791 15426 : return bRet;
1792 : }
1793 :
1794 : /*--------------------------------------------------------------------
1795 : Description: Create new format in Core
1796 : --------------------------------------------------------------------*/
1797 :
1798 :
1799 389 : void SwDocStyleSheet::Create()
1800 : {
1801 389 : switch(nFamily)
1802 : {
1803 : case SFX_STYLE_FAMILY_CHAR :
1804 197 : pCharFmt = lcl_FindCharFmt( rDoc, aName );
1805 197 : if( !pCharFmt )
1806 : pCharFmt = rDoc.MakeCharFmt(aName,
1807 197 : rDoc.GetDfltCharFmt());
1808 197 : pCharFmt->SetAuto( false );
1809 197 : break;
1810 :
1811 : case SFX_STYLE_FAMILY_PARA :
1812 97 : pColl = lcl_FindParaFmt( rDoc, aName );
1813 97 : if( !pColl )
1814 : {
1815 97 : SwTxtFmtColl *pPar = (*rDoc.GetTxtFmtColls())[0];
1816 97 : if( nMask & SWSTYLEBIT_CONDCOLL )
1817 0 : pColl = rDoc.MakeCondTxtFmtColl( aName, pPar );
1818 : else
1819 97 : pColl = rDoc.MakeTxtFmtColl( aName, pPar );
1820 : }
1821 97 : break;
1822 :
1823 : case SFX_STYLE_FAMILY_FRAME:
1824 0 : pFrmFmt = lcl_FindFrmFmt( rDoc, aName );
1825 0 : if( !pFrmFmt )
1826 0 : pFrmFmt = rDoc.MakeFrmFmt(aName, rDoc.GetDfltFrmFmt(), false, false);
1827 :
1828 0 : break;
1829 :
1830 : case SFX_STYLE_FAMILY_PAGE :
1831 25 : pDesc = lcl_FindPageDesc( rDoc, aName );
1832 25 : if( !pDesc )
1833 : {
1834 25 : sal_uInt16 nId = rDoc.MakePageDesc(aName);
1835 25 : pDesc = &rDoc.GetPageDesc(nId);
1836 : }
1837 25 : break;
1838 :
1839 : case SFX_STYLE_FAMILY_PSEUDO:
1840 70 : pNumRule = lcl_FindNumRule( rDoc, aName );
1841 70 : if( !pNumRule )
1842 : {
1843 70 : String sTmpNm( aName );
1844 70 : if( !aName.Len() )
1845 0 : sTmpNm = rDoc.GetUniqueNumRuleName();
1846 :
1847 70 : SwNumRule* pRule = rDoc.GetNumRuleTbl()[
1848 : rDoc.MakeNumRule( sTmpNm, 0, false,
1849 : // #i89178#
1850 140 : numfunc::GetDefaultPositionAndSpaceMode() ) ];
1851 70 : pRule->SetAutoRule( sal_False );
1852 70 : if( !aName.Len() )
1853 : {
1854 : // #i91400#
1855 0 : pRule->SetName( aName, rDoc );
1856 : }
1857 70 : pNumRule = pRule;
1858 : }
1859 70 : break;
1860 : default:; //prevent warning
1861 : }
1862 389 : bPhysical = sal_True;
1863 389 : aCoreSet.ClearItem();
1864 389 : }
1865 :
1866 1166 : SwCharFmt* SwDocStyleSheet::GetCharFmt()
1867 : {
1868 1166 : if(!bPhysical)
1869 8 : FillStyleSheet( FillPhysical );
1870 1166 : return pCharFmt;
1871 : }
1872 :
1873 9318 : SwTxtFmtColl* SwDocStyleSheet::GetCollection()
1874 : {
1875 9318 : if(!bPhysical)
1876 91 : FillStyleSheet( FillPhysical );
1877 9318 : return pColl;
1878 : }
1879 :
1880 2214 : const SwPageDesc* SwDocStyleSheet::GetPageDesc()
1881 : {
1882 2214 : if(!bPhysical)
1883 2 : FillStyleSheet( FillPhysical );
1884 2214 : return pDesc;
1885 : }
1886 :
1887 319 : const SwNumRule * SwDocStyleSheet::GetNumRule()
1888 : {
1889 319 : if(!bPhysical)
1890 0 : FillStyleSheet( FillPhysical );
1891 319 : return pNumRule;
1892 : }
1893 :
1894 72 : void SwDocStyleSheet::SetNumRule(const SwNumRule& rRule)
1895 : {
1896 : OSL_ENSURE(pNumRule, "Wo ist die NumRule");
1897 72 : rDoc.ChgNumRuleFmts( rRule );
1898 72 : }
1899 :
1900 : // re-generate Name AND Family from String
1901 : // First() and Next() (see below) insert an identification letter at Pos.1
1902 :
1903 1549 : void SwDocStyleSheet::PresetNameAndFamily(const String& rName)
1904 : {
1905 1549 : switch( rName.GetChar(0) )
1906 : {
1907 400 : case cPARA: nFamily = SFX_STYLE_FAMILY_PARA; break;
1908 19 : case cFRAME: nFamily = SFX_STYLE_FAMILY_FRAME; break;
1909 261 : case cPAGE: nFamily = SFX_STYLE_FAMILY_PAGE; break;
1910 8 : case cNUMRULE: nFamily = SFX_STYLE_FAMILY_PSEUDO; break;
1911 861 : default: nFamily = SFX_STYLE_FAMILY_CHAR; break;
1912 : }
1913 1549 : aName = rName;
1914 1549 : aName.Erase( 0, 1 );
1915 1549 : }
1916 :
1917 : /*--------------------------------------------------------------------
1918 : Description: Is the format physically present yet
1919 : --------------------------------------------------------------------*/
1920 :
1921 :
1922 31550 : void SwDocStyleSheet::SetPhysical(sal_Bool bPhys)
1923 : {
1924 31550 : bPhysical = bPhys;
1925 :
1926 31550 : if(!bPhys)
1927 : {
1928 20250 : pCharFmt = 0;
1929 20250 : pColl = 0;
1930 20250 : pFrmFmt = 0;
1931 20250 : pDesc = 0;
1932 : }
1933 31550 : }
1934 :
1935 63 : SwFrmFmt* SwDocStyleSheet::GetFrmFmt()
1936 : {
1937 63 : if(!bPhysical)
1938 3 : FillStyleSheet( FillPhysical );
1939 63 : return pFrmFmt;
1940 : }
1941 :
1942 0 : bool SwDocStyleSheet::IsUsed() const
1943 : {
1944 0 : if( !bPhysical )
1945 : {
1946 0 : SwDocStyleSheet* pThis = (SwDocStyleSheet*)this;
1947 0 : pThis->FillStyleSheet( FillOnlyName );
1948 : }
1949 :
1950 0 : if( !bPhysical )
1951 0 : return false;
1952 :
1953 : const SwModify* pMod;
1954 0 : switch( nFamily )
1955 : {
1956 0 : case SFX_STYLE_FAMILY_CHAR : pMod = pCharFmt; break;
1957 0 : case SFX_STYLE_FAMILY_PARA : pMod = pColl; break;
1958 0 : case SFX_STYLE_FAMILY_FRAME: pMod = pFrmFmt; break;
1959 0 : case SFX_STYLE_FAMILY_PAGE : pMod = pDesc; break;
1960 :
1961 : case SFX_STYLE_FAMILY_PSEUDO:
1962 0 : return pNumRule ? rDoc.IsUsed( *pNumRule ) : false;
1963 :
1964 : default:
1965 : OSL_ENSURE(!this, "unknown style family");
1966 0 : return false;
1967 : }
1968 0 : return rDoc.IsUsed( *pMod );
1969 : }
1970 :
1971 :
1972 0 : sal_uLong SwDocStyleSheet::GetHelpId( String& rFile )
1973 : {
1974 0 : sal_uInt16 nId = 0;
1975 0 : sal_uInt16 nPoolId = 0;
1976 0 : unsigned char nFileId = UCHAR_MAX;
1977 :
1978 0 : rFile = rtl::OUString("swrhlppi.hlp");
1979 :
1980 0 : const SwFmt* pTmpFmt = 0;
1981 0 : switch( nFamily )
1982 : {
1983 : case SFX_STYLE_FAMILY_CHAR :
1984 0 : if( !pCharFmt &&
1985 0 : 0 == (pCharFmt = lcl_FindCharFmt( rDoc, aName, 0, sal_False )) )
1986 : {
1987 0 : nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
1988 0 : return USHRT_MAX == nId ? 0 : nId;
1989 : }
1990 0 : pTmpFmt = pCharFmt;
1991 0 : break;
1992 :
1993 : case SFX_STYLE_FAMILY_PARA:
1994 0 : if( !pColl &&
1995 0 : 0 == ( pColl = lcl_FindParaFmt( rDoc, aName, 0, sal_False )) )
1996 : {
1997 0 : nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
1998 0 : return USHRT_MAX == nId ? 0 : nId;
1999 : }
2000 0 : pTmpFmt = pColl;
2001 0 : break;
2002 :
2003 : case SFX_STYLE_FAMILY_FRAME:
2004 0 : if( !pFrmFmt &&
2005 0 : 0 == ( pFrmFmt = lcl_FindFrmFmt( rDoc, aName, 0, sal_False ) ) )
2006 : {
2007 0 : nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );
2008 0 : return USHRT_MAX == nId ? 0 : nId;
2009 : }
2010 0 : pTmpFmt = pFrmFmt;
2011 0 : break;
2012 :
2013 : case SFX_STYLE_FAMILY_PAGE:
2014 0 : if( !pDesc &&
2015 0 : 0 == ( pDesc = lcl_FindPageDesc( rDoc, aName, 0, sal_False ) ) )
2016 : {
2017 0 : nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
2018 0 : return USHRT_MAX == nId ? 0 : nId;
2019 : }
2020 :
2021 0 : nId = pDesc->GetPoolHelpId();
2022 0 : nFileId = pDesc->GetPoolHlpFileId();
2023 0 : nPoolId = pDesc->GetPoolFmtId();
2024 0 : break;
2025 :
2026 : case SFX_STYLE_FAMILY_PSEUDO:
2027 0 : if( !pNumRule &&
2028 0 : 0 == ( pNumRule = lcl_FindNumRule( rDoc, aName, 0, sal_False ) ) )
2029 : {
2030 0 : nId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
2031 0 : return USHRT_MAX == nId ? 0 : nId;
2032 : }
2033 :
2034 0 : nId = pNumRule->GetPoolHelpId();
2035 0 : nFileId = pNumRule->GetPoolHlpFileId();
2036 0 : nPoolId = pNumRule->GetPoolFmtId();
2037 0 : break;
2038 :
2039 : default:
2040 : OSL_ENSURE(!this, "unknown style family");
2041 0 : return 0;
2042 : }
2043 :
2044 0 : if( pTmpFmt )
2045 : {
2046 0 : nId = pTmpFmt->GetPoolHelpId();
2047 0 : nFileId = pTmpFmt->GetPoolHlpFileId();
2048 0 : nPoolId = pTmpFmt->GetPoolFmtId();
2049 : }
2050 :
2051 0 : if( UCHAR_MAX != nFileId )
2052 : {
2053 0 : const String *pTemplate = rDoc.GetDocPattern( nFileId );
2054 0 : if( pTemplate )
2055 : {
2056 0 : rFile = *pTemplate;
2057 : }
2058 : }
2059 0 : else if( !IsPoolUserFmt( nPoolId ) )
2060 : {
2061 0 : nId = nPoolId;
2062 : }
2063 :
2064 : // because SFX acts like that, with HelpId:
2065 0 : if( USHRT_MAX == nId )
2066 0 : nId = 0; // don't show Help accordingly
2067 :
2068 0 : return nId;
2069 : }
2070 :
2071 :
2072 0 : void SwDocStyleSheet::SetHelpId( const String& r, sal_uLong nId )
2073 : {
2074 0 : sal_uInt8 nFileId = static_cast< sal_uInt8 >(rDoc.SetDocPattern( r ));
2075 0 : sal_uInt16 nHId = static_cast< sal_uInt16 >(nId); //!! SFX changed over to ULONG arbitrarily!
2076 :
2077 0 : SwFmt* pTmpFmt = 0;
2078 0 : switch( nFamily )
2079 : {
2080 0 : case SFX_STYLE_FAMILY_CHAR : pTmpFmt = pCharFmt; break;
2081 0 : case SFX_STYLE_FAMILY_PARA : pTmpFmt = pColl; break;
2082 0 : case SFX_STYLE_FAMILY_FRAME: pTmpFmt = pFrmFmt; break;
2083 : case SFX_STYLE_FAMILY_PAGE :
2084 0 : ((SwPageDesc*)pDesc)->SetPoolHelpId( nHId );
2085 0 : ((SwPageDesc*)pDesc)->SetPoolHlpFileId( nFileId );
2086 0 : break;
2087 :
2088 : case SFX_STYLE_FAMILY_PSEUDO:
2089 0 : ((SwNumRule*)pNumRule)->SetPoolHelpId( nHId );
2090 0 : ((SwNumRule*)pNumRule)->SetPoolHlpFileId( nFileId );
2091 0 : break;
2092 :
2093 : default:
2094 : OSL_ENSURE(!this, "unknown style family");
2095 0 : return ;
2096 : }
2097 0 : if( pTmpFmt )
2098 : {
2099 0 : pTmpFmt->SetPoolHelpId( nHId );
2100 0 : pTmpFmt->SetPoolHlpFileId( nFileId );
2101 : }
2102 : }
2103 :
2104 : /*--------------------------------------------------------------------
2105 : Description: methods for DocStyleSheetPool
2106 : --------------------------------------------------------------------*/
2107 :
2108 275 : SwDocStyleSheetPool::SwDocStyleSheetPool( SwDoc& rDocument, sal_Bool bOrg )
2109 275 : : SfxStyleSheetBasePool( rDocument.GetAttrPool() )
2110 275 : , mxStyleSheet( new SwDocStyleSheet( rDocument, aEmptyStr, this, SFX_STYLE_FAMILY_CHAR, 0 ) )
2111 550 : , rDoc( rDocument )
2112 : {
2113 275 : bOrganizer = bOrg;
2114 275 : }
2115 :
2116 188 : SwDocStyleSheetPool::~SwDocStyleSheetPool()
2117 : {
2118 188 : }
2119 :
2120 275 : void SAL_CALL SwDocStyleSheetPool::acquire( ) throw ()
2121 : {
2122 275 : comphelper::OWeakTypeObject::acquire();
2123 275 : }
2124 :
2125 94 : void SAL_CALL SwDocStyleSheetPool::release( ) throw ()
2126 : {
2127 94 : comphelper::OWeakTypeObject::release();
2128 94 : }
2129 :
2130 389 : SfxStyleSheetBase& SwDocStyleSheetPool::Make(
2131 : const String& rName,
2132 : SfxStyleFamily eFam,
2133 : sal_uInt16 _nMask,
2134 : sal_uInt16 /*nPos*/ )
2135 : {
2136 389 : mxStyleSheet->PresetName(rName);
2137 389 : mxStyleSheet->PresetParent(aEmptyStr);
2138 389 : mxStyleSheet->PresetFollow(aEmptyStr);
2139 389 : mxStyleSheet->SetMask(_nMask) ;
2140 389 : mxStyleSheet->SetFamily(eFam);
2141 389 : mxStyleSheet->SetPhysical(sal_True);
2142 389 : mxStyleSheet->Create();
2143 :
2144 389 : return *mxStyleSheet.get();
2145 : }
2146 :
2147 :
2148 0 : SfxStyleSheetBase* SwDocStyleSheetPool::Create( const SfxStyleSheetBase& /*rOrg*/)
2149 : {
2150 : OSL_ENSURE(!this , "Create im SW-Stylesheet-Pool geht nicht" );
2151 0 : return NULL;
2152 : }
2153 :
2154 :
2155 0 : SfxStyleSheetBase* SwDocStyleSheetPool::Create( const String &,
2156 : SfxStyleFamily, sal_uInt16 )
2157 : {
2158 : OSL_ENSURE( !this, "Create im SW-Stylesheet-Pool geht nicht" );
2159 0 : return NULL;
2160 : }
2161 :
2162 0 : void SwDocStyleSheetPool::Replace( SfxStyleSheetBase& rSource,
2163 : SfxStyleSheetBase& rTarget )
2164 : {
2165 0 : SfxStyleFamily eFamily( rSource.GetFamily() );
2166 0 : if( rSource.HasParentSupport())
2167 : {
2168 0 : const String& rParentName = rSource.GetParent();
2169 0 : if( 0 != rParentName.Len() )
2170 : {
2171 0 : SfxStyleSheetBase* pParentOfNew = Find( rParentName, eFamily );
2172 0 : if( pParentOfNew )
2173 0 : rTarget.SetParent( rParentName );
2174 : }
2175 : }
2176 0 : if( rSource.HasFollowSupport())
2177 : {
2178 0 : const String& rFollowName = rSource.GetFollow();
2179 0 : if( 0 != rFollowName.Len() )
2180 : {
2181 0 : SfxStyleSheetBase* pFollowOfNew = Find( rFollowName, eFamily );
2182 0 : if( pFollowOfNew )
2183 0 : rTarget.SetFollow( rFollowName );
2184 : }
2185 : }
2186 :
2187 0 : SwImplShellAction aTmpSh( rDoc );
2188 :
2189 0 : sal_Bool bSwSrcPool = GetAppName() == rSource.GetPool().GetAppName();
2190 0 : if( SFX_STYLE_FAMILY_PAGE == eFamily && bSwSrcPool )
2191 : {
2192 : // deal with separately!
2193 : SwPageDesc* pDestDsc =
2194 0 : (SwPageDesc*)((SwDocStyleSheet&)rTarget).GetPageDesc();
2195 : SwPageDesc* pCpyDsc =
2196 0 : (SwPageDesc*)((SwDocStyleSheet&)rSource).GetPageDesc();
2197 0 : rDoc.CopyPageDesc( *pCpyDsc, *pDestDsc );
2198 : }
2199 : else
2200 : {
2201 0 : const SwFmt *pSourceFmt = 0;
2202 0 : SwFmt *pTargetFmt = 0;
2203 0 : sal_uInt16 nPgDscPos = USHRT_MAX;
2204 0 : switch( eFamily )
2205 : {
2206 : case SFX_STYLE_FAMILY_CHAR :
2207 0 : if( bSwSrcPool )
2208 0 : pSourceFmt = ((SwDocStyleSheet&)rSource).GetCharFmt();
2209 0 : pTargetFmt = ((SwDocStyleSheet&)rTarget).GetCharFmt();
2210 0 : break;
2211 : case SFX_STYLE_FAMILY_PARA :
2212 0 : if( bSwSrcPool )
2213 0 : pSourceFmt = ((SwDocStyleSheet&)rSource).GetCollection();
2214 0 : pTargetFmt = ((SwDocStyleSheet&)rTarget).GetCollection();
2215 0 : break;
2216 : case SFX_STYLE_FAMILY_FRAME:
2217 0 : if( bSwSrcPool )
2218 0 : pSourceFmt = ((SwDocStyleSheet&)rSource).GetFrmFmt();
2219 0 : pTargetFmt = ((SwDocStyleSheet&)rTarget).GetFrmFmt();
2220 0 : break;
2221 : case SFX_STYLE_FAMILY_PAGE:
2222 0 : if( bSwSrcPool )
2223 : pSourceFmt = &((SwDocStyleSheet&)rSource).GetPageDesc()
2224 0 : ->GetMaster();
2225 : {
2226 : SwPageDesc *pDesc = rDoc.FindPageDescByName(
2227 0 : ((SwDocStyleSheet&)rTarget).GetPageDesc()->GetName(),
2228 0 : &nPgDscPos );
2229 :
2230 0 : if( pDesc )
2231 0 : pTargetFmt = &pDesc->GetMaster();
2232 : }
2233 0 : break;
2234 : case SFX_STYLE_FAMILY_PSEUDO:
2235 : // A NumRule only consists of one Item, so nothing has
2236 : // to be deleted here.
2237 0 : break;
2238 : default:; //prevent warning
2239 : }
2240 0 : if( pTargetFmt )
2241 : {
2242 0 : if( pSourceFmt )
2243 0 : pTargetFmt->DelDiffs( *pSourceFmt );
2244 0 : else if( USHRT_MAX != nPgDscPos )
2245 0 : pTargetFmt->ResetFmtAttr( RES_PAGEDESC, RES_FRMATR_END-1 );
2246 : else
2247 : {
2248 : // #i73790# - method renamed
2249 0 : pTargetFmt->ResetAllFmtAttr();
2250 : }
2251 :
2252 0 : if( USHRT_MAX != nPgDscPos )
2253 : rDoc.ChgPageDesc( nPgDscPos,
2254 0 : rDoc.GetPageDesc(nPgDscPos) );
2255 : }
2256 0 : ((SwDocStyleSheet&)rTarget).SetItemSet( rSource.GetItemSet() );
2257 0 : }
2258 0 : }
2259 :
2260 89 : SfxStyleSheetIterator* SwDocStyleSheetPool::CreateIterator(
2261 : SfxStyleFamily eFam, sal_uInt16 _nMask )
2262 : {
2263 89 : return new SwStyleSheetIterator( this, eFam, _nMask );
2264 : }
2265 :
2266 94 : void SwDocStyleSheetPool::dispose()
2267 : {
2268 94 : mxStyleSheet.clear();
2269 94 : }
2270 :
2271 0 : void SwDocStyleSheetPool::Remove( SfxStyleSheetBase* pStyle)
2272 : {
2273 0 : if( !pStyle )
2274 0 : return;
2275 :
2276 0 : sal_Bool bBroadcast = sal_True;
2277 0 : SwImplShellAction aTmpSh( rDoc );
2278 0 : const String& rName = pStyle->GetName();
2279 0 : switch( pStyle->GetFamily() )
2280 : {
2281 : case SFX_STYLE_FAMILY_CHAR:
2282 : {
2283 0 : SwCharFmt* pFmt = lcl_FindCharFmt(rDoc, rName, 0, sal_False );
2284 0 : if(pFmt)
2285 0 : rDoc.DelCharFmt(pFmt);
2286 : }
2287 0 : break;
2288 : case SFX_STYLE_FAMILY_PARA:
2289 : {
2290 0 : SwTxtFmtColl* pColl = lcl_FindParaFmt(rDoc, rName, 0, sal_False );
2291 0 : if(pColl)
2292 0 : rDoc.DelTxtFmtColl(pColl);
2293 : }
2294 0 : break;
2295 : case SFX_STYLE_FAMILY_FRAME:
2296 : {
2297 0 : SwFrmFmt* pFmt = lcl_FindFrmFmt(rDoc, rName, 0, sal_False );
2298 0 : if(pFmt)
2299 0 : rDoc.DelFrmFmt(pFmt);
2300 : }
2301 0 : break;
2302 : case SFX_STYLE_FAMILY_PAGE :
2303 : {
2304 : sal_uInt16 nPos;
2305 0 : if( rDoc.FindPageDescByName( rName, &nPos ))
2306 0 : rDoc.DelPageDesc( nPos );
2307 : }
2308 0 : break;
2309 :
2310 : case SFX_STYLE_FAMILY_PSEUDO:
2311 : {
2312 0 : if( !rDoc.DelNumRule( rName ) )
2313 : // Only send Broadcast, when something was deleted
2314 0 : bBroadcast = sal_False;
2315 : }
2316 0 : break;
2317 :
2318 : default:
2319 : OSL_ENSURE(!this, "unknown style family");
2320 0 : bBroadcast = sal_False;
2321 : }
2322 :
2323 0 : if( bBroadcast )
2324 0 : Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_ERASED, *pStyle ) );
2325 : }
2326 :
2327 :
2328 :
2329 162 : bool SwDocStyleSheetPool::SetParent( SfxStyleFamily eFam,
2330 : const String &rStyle, const String &rParent )
2331 : {
2332 162 : SwFmt* pFmt = 0, *pParent = 0;
2333 162 : switch( eFam )
2334 : {
2335 : case SFX_STYLE_FAMILY_CHAR :
2336 102 : if( 0 != ( pFmt = lcl_FindCharFmt( rDoc, rStyle ) ) && rParent.Len() )
2337 102 : pParent = lcl_FindCharFmt(rDoc, rParent );
2338 102 : break;
2339 :
2340 : case SFX_STYLE_FAMILY_PARA :
2341 60 : if( 0 != ( pFmt = lcl_FindParaFmt( rDoc, rStyle ) ) && rParent.Len() )
2342 60 : pParent = lcl_FindParaFmt( rDoc, rParent );
2343 60 : break;
2344 :
2345 : case SFX_STYLE_FAMILY_FRAME:
2346 0 : if( 0 != ( pFmt = lcl_FindFrmFmt( rDoc, rStyle ) ) && rParent.Len() )
2347 0 : pParent = lcl_FindFrmFmt( rDoc, rParent );
2348 0 : break;
2349 :
2350 : case SFX_STYLE_FAMILY_PAGE:
2351 : case SFX_STYLE_FAMILY_PSEUDO:
2352 0 : break;
2353 :
2354 : default:
2355 : OSL_ENSURE(!this, "unknown style family");
2356 : }
2357 :
2358 162 : bool bRet = false;
2359 324 : if( pFmt && pFmt->DerivedFrom() &&
2360 162 : pFmt->DerivedFrom()->GetName() != rParent )
2361 : {
2362 : {
2363 162 : SwImplShellAction aTmpSh( rDoc );
2364 162 : bRet = pFmt->SetDerivedFrom( pParent );
2365 : }
2366 :
2367 162 : if( bRet )
2368 : {
2369 : // only for Broadcasting
2370 162 : mxStyleSheet->PresetName( rStyle );
2371 162 : mxStyleSheet->PresetParent( rParent );
2372 162 : if( SFX_STYLE_FAMILY_PARA == eFam )
2373 : mxStyleSheet->PresetFollow( ((SwTxtFmtColl*)pFmt)->
2374 60 : GetNextTxtFmtColl().GetName() );
2375 : else
2376 102 : mxStyleSheet->PresetFollow( aEmptyStr );
2377 :
2378 : Broadcast( SfxStyleSheetHint( SFX_STYLESHEET_MODIFIED,
2379 162 : *(mxStyleSheet.get()) ) );
2380 : }
2381 : }
2382 :
2383 162 : return bRet;
2384 : }
2385 :
2386 13924 : SfxStyleSheetBase* SwDocStyleSheetPool::Find( const String& rName,
2387 : SfxStyleFamily eFam, sal_uInt16 n )
2388 : {
2389 13924 : sal_uInt16 nSMask = n;
2390 13924 : if( SFX_STYLE_FAMILY_PARA == eFam && rDoc.get(IDocumentSettingAccess::HTML_MODE) )
2391 : {
2392 : // then only HTML-Templates are of interest
2393 0 : if( USHRT_MAX == nSMask )
2394 0 : nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF | SFXSTYLEBIT_USED;
2395 : else
2396 : nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
2397 0 : SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
2398 0 : if( !nSMask )
2399 0 : nSMask = SWSTYLEBIT_HTML;
2400 : }
2401 :
2402 : const sal_Bool bSearchUsed = ( n != SFXSTYLEBIT_ALL &&
2403 13924 : n & SFXSTYLEBIT_USED ) ? sal_True : sal_False;
2404 13924 : const SwModify* pMod = 0;
2405 :
2406 13924 : mxStyleSheet->SetPhysical( sal_False );
2407 13924 : mxStyleSheet->PresetName( rName );
2408 13924 : mxStyleSheet->SetFamily( eFam );
2409 13924 : sal_Bool bFnd = mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
2410 :
2411 13924 : if( mxStyleSheet->IsPhysical() )
2412 : {
2413 10295 : switch( eFam )
2414 : {
2415 : case SFX_STYLE_FAMILY_CHAR:
2416 1117 : pMod = mxStyleSheet->GetCharFmt();
2417 1117 : break;
2418 :
2419 : case SFX_STYLE_FAMILY_PARA:
2420 6699 : pMod = mxStyleSheet->GetCollection();
2421 6699 : break;
2422 :
2423 : case SFX_STYLE_FAMILY_FRAME:
2424 53 : pMod = mxStyleSheet->GetFrmFmt();
2425 53 : break;
2426 :
2427 : case SFX_STYLE_FAMILY_PAGE:
2428 2186 : pMod = mxStyleSheet->GetPageDesc();
2429 2186 : break;
2430 :
2431 : case SFX_STYLE_FAMILY_PSEUDO:
2432 : {
2433 240 : const SwNumRule* pRule = mxStyleSheet->GetNumRule();
2434 240 : if( pRule &&
2435 : !bSearchUsed &&
2436 : (( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2437 0 : ? !(pRule->GetPoolFmtId() & USER_FMT)
2438 : // searched for used and found none
2439 240 : : bSearchUsed ))
2440 0 : bFnd = sal_False;
2441 : }
2442 240 : break;
2443 :
2444 : default:
2445 : OSL_ENSURE(!this, "unknown style family");
2446 : }
2447 : }
2448 :
2449 : // then evaluate the mask:
2450 13924 : if( pMod && !bSearchUsed )
2451 : {
2452 : const sal_uInt16 nId = SFX_STYLE_FAMILY_PAGE == eFam
2453 : ? ((SwPageDesc*)pMod)->GetPoolFmtId()
2454 10055 : : ((SwFmt*)pMod)->GetPoolFmtId();
2455 :
2456 10055 : if( ( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2457 : ? !(nId & USER_FMT)
2458 : // searched for used and found none
2459 10055 : : bSearchUsed )
2460 0 : bFnd = sal_False;
2461 : }
2462 13924 : return bFnd ? mxStyleSheet.get() : 0;
2463 : }
2464 :
2465 89 : SwStyleSheetIterator::SwStyleSheetIterator( SwDocStyleSheetPool* pBase,
2466 : SfxStyleFamily eFam, sal_uInt16 n )
2467 : : SfxStyleSheetIterator( pBase, eFam, n ),
2468 89 : mxIterSheet( new SwDocStyleSheet( pBase->GetDoc(), aEmptyStr, pBase, SFX_STYLE_FAMILY_CHAR, 0 ) ),
2469 178 : mxStyleSheet( new SwDocStyleSheet( pBase->GetDoc(), aEmptyStr, pBase, SFX_STYLE_FAMILY_CHAR, 0 ) )
2470 : {
2471 89 : bFirstCalled = sal_False;
2472 89 : nLastPos = 0;
2473 89 : StartListening( *pBase );
2474 89 : }
2475 :
2476 255 : SwStyleSheetIterator::~SwStyleSheetIterator()
2477 : {
2478 85 : EndListening( mxIterSheet->GetPool() );
2479 170 : }
2480 :
2481 43 : sal_uInt16 SwStyleSheetIterator::Count()
2482 : {
2483 : // let the list fill correctly!!
2484 43 : if( !bFirstCalled )
2485 43 : First();
2486 43 : return aLst.size();
2487 : }
2488 :
2489 1287 : SfxStyleSheetBase* SwStyleSheetIterator::operator[]( sal_uInt16 nIdx )
2490 : {
2491 : // found
2492 1287 : if( !bFirstCalled )
2493 0 : First();
2494 1287 : mxStyleSheet->PresetNameAndFamily( aLst[ nIdx ] );
2495 1287 : mxStyleSheet->SetPhysical( sal_False );
2496 1287 : mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
2497 :
2498 1287 : return mxStyleSheet.get();
2499 : }
2500 :
2501 262 : SfxStyleSheetBase* SwStyleSheetIterator::First()
2502 : {
2503 : // Delete old list
2504 262 : bFirstCalled = sal_True;
2505 262 : nLastPos = 0;
2506 262 : aLst.Erase();
2507 :
2508 : // Delete current
2509 262 : mxIterSheet->Reset();
2510 :
2511 262 : SwDoc& rDoc = ((SwDocStyleSheetPool*)pBasePool)->GetDoc();
2512 262 : const sal_uInt16 nSrchMask = nMask;
2513 262 : const sal_Bool bIsSearchUsed = SearchUsed();
2514 :
2515 262 : bool bSearchHidden = ( nMask & SFXSTYLEBIT_HIDDEN );
2516 262 : bool bOnlyHidden = nMask == SFXSTYLEBIT_HIDDEN;
2517 :
2518 262 : const sal_Bool bOrganizer = ((SwDocStyleSheetPool*)pBasePool)->IsOrganizerMode();
2519 262 : bool bAll = ( nSrchMask & SFXSTYLEBIT_ALL_VISIBLE ) == SFXSTYLEBIT_ALL_VISIBLE;
2520 :
2521 262 : if( nSearchFamily == SFX_STYLE_FAMILY_CHAR
2522 : || nSearchFamily == SFX_STYLE_FAMILY_ALL )
2523 : {
2524 48 : const sal_uInt16 nArrLen = rDoc.GetCharFmts()->size();
2525 595 : for( sal_uInt16 i = 0; i < nArrLen; i++ )
2526 : {
2527 547 : SwCharFmt* pFmt = (*rDoc.GetCharFmts())[ i ];
2528 :
2529 547 : const bool bUsed = bIsSearchUsed && (bOrganizer || rDoc.IsUsed(*pFmt));
2530 547 : if( ( !bSearchHidden && pFmt->IsHidden() && !bUsed ) || ( pFmt->IsDefault() && pFmt != rDoc.GetDfltCharFmt() ) )
2531 0 : continue;
2532 :
2533 547 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !pFmt->IsHidden( ) )
2534 0 : continue;
2535 :
2536 547 : if( !bUsed )
2537 : {
2538 : // Standard is no User template
2539 547 : const sal_uInt16 nId = rDoc.GetDfltCharFmt() == pFmt ?
2540 : sal_uInt16( RES_POOLCHR_INET_NORMAL ):
2541 547 : pFmt->GetPoolFmtId();
2542 547 : if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2543 : ? !(nId & USER_FMT)
2544 : // searched for used and found none
2545 547 : : bIsSearchUsed )
2546 : {
2547 0 : continue;
2548 : }
2549 :
2550 547 : if( rDoc.get(IDocumentSettingAccess::HTML_MODE) && !(nId & USER_FMT) &&
2551 : !( RES_POOLCHR_HTML_BEGIN <= nId &&
2552 0 : nId < RES_POOLCHR_HTML_END ) &&
2553 : RES_POOLCHR_INET_NORMAL != nId &&
2554 : RES_POOLCHR_INET_VISIT != nId &&
2555 : RES_POOLCHR_FOOTNOTE != nId &&
2556 : RES_POOLCHR_ENDNOTE != nId )
2557 0 : continue;
2558 : }
2559 :
2560 547 : aLst.Append( cCHAR, pFmt == rDoc.GetDfltCharFmt()
2561 48 : ? SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
2562 48 : RES_POOLCOLL_TEXT_BEGIN ]
2563 595 : : pFmt->GetName() );
2564 : }
2565 :
2566 : // PoolFormate
2567 : //
2568 48 : if( bAll )
2569 : {
2570 48 : if( !rDoc.get(IDocumentSettingAccess::HTML_MODE) )
2571 48 : AppendStyleList(SwStyleNameMapper::GetChrFmtUINameArray(),
2572 : bIsSearchUsed, bSearchHidden, bOnlyHidden,
2573 96 : nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
2574 : else
2575 : {
2576 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
2577 0 : RES_POOLCHR_INET_NORMAL - RES_POOLCHR_BEGIN ] );
2578 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
2579 0 : RES_POOLCHR_INET_VISIT - RES_POOLCHR_BEGIN ] );
2580 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
2581 0 : RES_POOLCHR_ENDNOTE - RES_POOLCHR_BEGIN ] );
2582 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFmtUINameArray()[
2583 0 : RES_POOLCHR_FOOTNOTE - RES_POOLCHR_BEGIN ] );
2584 : }
2585 48 : AppendStyleList(SwStyleNameMapper::GetHTMLChrFmtUINameArray(),
2586 : bIsSearchUsed, bSearchHidden, bOnlyHidden,
2587 96 : nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
2588 : }
2589 : }
2590 :
2591 262 : if( nSearchFamily == SFX_STYLE_FAMILY_PARA ||
2592 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2593 : {
2594 153 : sal_uInt16 nSMask = nSrchMask;
2595 153 : if( rDoc.get(IDocumentSettingAccess::HTML_MODE) )
2596 : {
2597 : // then only HTML-Template are of interest
2598 0 : if( SFXSTYLEBIT_ALL_VISIBLE == ( nSMask & SFXSTYLEBIT_ALL_VISIBLE ) )
2599 : nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF |
2600 0 : SFXSTYLEBIT_USED;
2601 : else
2602 : nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
2603 0 : SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
2604 0 : if( !nSMask )
2605 0 : nSMask = SWSTYLEBIT_HTML;
2606 : }
2607 :
2608 153 : const sal_uInt16 nArrLen = rDoc.GetTxtFmtColls()->size();
2609 2232 : for( sal_uInt16 i = 0; i < nArrLen; i++ )
2610 : {
2611 2079 : SwTxtFmtColl* pColl = (*rDoc.GetTxtFmtColls())[ i ];
2612 :
2613 2079 : const bool bUsed = bOrganizer || rDoc.IsUsed(*pColl);
2614 2079 : if ( ( !bSearchHidden && pColl->IsHidden( ) && !bUsed ) || pColl->IsDefault() )
2615 153 : continue;
2616 :
2617 1926 : if ( nSMask == SFXSTYLEBIT_HIDDEN && !pColl->IsHidden( ) )
2618 0 : continue;
2619 :
2620 1926 : if( !(bIsSearchUsed && bUsed ))
2621 : {
2622 1926 : const sal_uInt16 nId = pColl->GetPoolFmtId();
2623 1926 : switch ( (nSMask & ~SFXSTYLEBIT_USED) )
2624 : {
2625 : case SFXSTYLEBIT_USERDEF:
2626 0 : if(!IsPoolUserFmt(nId)) continue;
2627 0 : break;
2628 : case SWSTYLEBIT_TEXT:
2629 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_TEXT_BITS) continue;
2630 0 : break;
2631 : case SWSTYLEBIT_CHAPTER:
2632 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_DOC_BITS) continue;
2633 0 : break;
2634 : case SWSTYLEBIT_LIST:
2635 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_LISTS_BITS) continue;
2636 0 : break;
2637 : case SWSTYLEBIT_IDX:
2638 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_REGISTER_BITS) continue;
2639 0 : break;
2640 : case SWSTYLEBIT_EXTRA:
2641 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_EXTRA_BITS) continue;
2642 0 : break;
2643 : case SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF:
2644 0 : if(IsPoolUserFmt(nId))
2645 0 : break;
2646 : // otherwise move on
2647 : case SWSTYLEBIT_HTML:
2648 0 : if( (nId & COLL_GET_RANGE_BITS) != COLL_HTML_BITS)
2649 : {
2650 : // but some we also want to see in this section
2651 0 : sal_Bool bWeiter = sal_True;
2652 0 : switch( nId )
2653 : {
2654 : case RES_POOLCOLL_SENDADRESS: // --> ADDRESS
2655 : case RES_POOLCOLL_TABLE_HDLN: // --> TH
2656 : case RES_POOLCOLL_TABLE: // --> TD
2657 : case RES_POOLCOLL_TEXT: // --> P
2658 : case RES_POOLCOLL_HEADLINE_BASE:// --> H
2659 : case RES_POOLCOLL_HEADLINE1: // --> H1
2660 : case RES_POOLCOLL_HEADLINE2: // --> H2
2661 : case RES_POOLCOLL_HEADLINE3: // --> H3
2662 : case RES_POOLCOLL_HEADLINE4: // --> H4
2663 : case RES_POOLCOLL_HEADLINE5: // --> H5
2664 : case RES_POOLCOLL_HEADLINE6: // --> H6
2665 : case RES_POOLCOLL_STANDARD: // --> P
2666 : case RES_POOLCOLL_FOOTNOTE:
2667 : case RES_POOLCOLL_ENDNOTE:
2668 0 : bWeiter = sal_False;
2669 0 : break;
2670 : }
2671 0 : if( bWeiter )
2672 0 : continue;
2673 : }
2674 0 : break;
2675 : case SWSTYLEBIT_CONDCOLL:
2676 0 : if( RES_CONDTXTFMTCOLL != pColl->Which() ) continue;
2677 0 : break;
2678 : default:
2679 : // searched for used and found none
2680 1926 : if( bIsSearchUsed )
2681 0 : continue;
2682 : }
2683 : }
2684 1926 : aLst.Append( cPARA, pColl->GetName() );
2685 : }
2686 :
2687 153 : bAll = ( nSMask & SFXSTYLEBIT_ALL_VISIBLE ) == SFXSTYLEBIT_ALL_VISIBLE;
2688 153 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_TEXT )
2689 153 : AppendStyleList(SwStyleNameMapper::GetTextUINameArray(),
2690 306 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA );
2691 153 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CHAPTER )
2692 153 : AppendStyleList(SwStyleNameMapper::GetDocUINameArray(),
2693 306 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2694 153 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_LIST )
2695 153 : AppendStyleList(SwStyleNameMapper::GetListsUINameArray(),
2696 306 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2697 153 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_IDX )
2698 153 : AppendStyleList(SwStyleNameMapper::GetRegisterUINameArray(),
2699 306 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2700 153 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_EXTRA )
2701 153 : AppendStyleList(SwStyleNameMapper::GetExtraUINameArray(),
2702 306 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2703 153 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CONDCOLL )
2704 : {
2705 153 : if( !bIsSearchUsed ||
2706 0 : rDoc.IsPoolTxtCollUsed( RES_POOLCOLL_TEXT ))
2707 153 : aLst.Append( cPARA, SwStyleNameMapper::GetTextUINameArray()[
2708 153 : RES_POOLCOLL_TEXT - RES_POOLCOLL_TEXT_BEGIN ] );
2709 : }
2710 153 : if ( bAll ||
2711 : (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_HTML ||
2712 : (nSMask & ~SFXSTYLEBIT_USED) ==
2713 : (SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF) )
2714 : {
2715 153 : AppendStyleList(SwStyleNameMapper::GetHTMLUINameArray(),
2716 306 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2717 153 : if( !bAll )
2718 : {
2719 : // then also the ones, that we are mapping:
2720 : static sal_uInt16 aPoolIds[] = {
2721 : RES_POOLCOLL_SENDADRESS, // --> ADDRESS
2722 : RES_POOLCOLL_TABLE_HDLN, // --> TH
2723 : RES_POOLCOLL_TABLE, // --> TD
2724 : RES_POOLCOLL_STANDARD, // --> P
2725 : RES_POOLCOLL_TEXT, // --> P
2726 : RES_POOLCOLL_HEADLINE_BASE, // --> H
2727 : RES_POOLCOLL_HEADLINE1, // --> H1
2728 : RES_POOLCOLL_HEADLINE2, // --> H2
2729 : RES_POOLCOLL_HEADLINE3, // --> H3
2730 : RES_POOLCOLL_HEADLINE4, // --> H4
2731 : RES_POOLCOLL_HEADLINE5, // --> H5
2732 : RES_POOLCOLL_HEADLINE6, // --> H6
2733 : RES_POOLCOLL_FOOTNOTE,
2734 : RES_POOLCOLL_ENDNOTE,
2735 : 0
2736 : };
2737 :
2738 0 : sal_uInt16* pPoolIds = aPoolIds;
2739 0 : String s;
2740 0 : while( *pPoolIds )
2741 : {
2742 0 : if( !bIsSearchUsed || rDoc.IsPoolTxtCollUsed( *pPoolIds ) )
2743 : aLst.Append( cPARA,
2744 0 : s = SwStyleNameMapper::GetUIName( *pPoolIds, s ));
2745 0 : ++pPoolIds;
2746 0 : }
2747 : }
2748 : }
2749 : }
2750 :
2751 262 : if( nSearchFamily == SFX_STYLE_FAMILY_FRAME ||
2752 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2753 : {
2754 5 : const sal_uInt16 nArrLen = rDoc.GetFrmFmts()->size();
2755 15 : for( sal_uInt16 i = 0; i < nArrLen; i++ )
2756 : {
2757 10 : SwFrmFmt* pFmt = (*rDoc.GetFrmFmts())[ i ];
2758 :
2759 10 : bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(*pFmt));
2760 10 : if( ( !bSearchHidden && pFmt->IsHidden( ) && !bUsed ) || pFmt->IsDefault() || pFmt->IsAuto() )
2761 7 : continue;
2762 :
2763 3 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !pFmt->IsHidden( ) )
2764 0 : continue;
2765 :
2766 3 : const sal_uInt16 nId = pFmt->GetPoolFmtId();
2767 3 : if( !bUsed )
2768 : {
2769 3 : if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2770 : ? !(nId & USER_FMT)
2771 : // searched for used and found none
2772 3 : : bIsSearchUsed )
2773 : {
2774 0 : continue;
2775 : }
2776 : }
2777 :
2778 3 : aLst.Append( cFRAME, pFmt->GetName() );
2779 : }
2780 :
2781 : // PoolFormate
2782 : //
2783 5 : if ( bAll )
2784 5 : AppendStyleList(SwStyleNameMapper::GetFrmFmtUINameArray(),
2785 10 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, cFRAME);
2786 : }
2787 :
2788 262 : if( nSearchFamily == SFX_STYLE_FAMILY_PAGE ||
2789 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2790 : {
2791 48 : const sal_uInt16 nCount = rDoc.GetPageDescCnt();
2792 157 : for(sal_uInt16 i = 0; i < nCount; ++i)
2793 : {
2794 109 : const SwPageDesc& rDesc = rDoc.GetPageDesc(i);
2795 109 : const sal_uInt16 nId = rDesc.GetPoolFmtId();
2796 109 : bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rDesc));
2797 109 : if( !bUsed )
2798 : {
2799 109 : if ( ( !bSearchHidden && rDesc.IsHidden() ) ||
2800 : ( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2801 : ? !(nId & USER_FMT)
2802 : // searched for used and found none
2803 109 : : bIsSearchUsed ) )
2804 0 : continue;
2805 : }
2806 :
2807 109 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !rDesc.IsHidden( ) )
2808 0 : continue;
2809 :
2810 109 : aLst.Append( cPAGE, rDesc.GetName() );
2811 : }
2812 48 : if ( bAll )
2813 48 : AppendStyleList(SwStyleNameMapper::GetPageDescUINameArray(),
2814 96 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, cPAGE);
2815 : }
2816 :
2817 262 : if( nSearchFamily == SFX_STYLE_FAMILY_PSEUDO ||
2818 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2819 : {
2820 8 : const SwNumRuleTbl& rNumTbl = rDoc.GetNumRuleTbl();
2821 40 : for(sal_uInt16 i = 0; i < rNumTbl.size(); ++i)
2822 : {
2823 32 : const SwNumRule& rRule = *rNumTbl[ i ];
2824 32 : if( !rRule.IsAutoRule() )
2825 : {
2826 24 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !rRule.IsHidden( ) )
2827 0 : continue;
2828 :
2829 24 : bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rRule) );
2830 24 : if( !bUsed )
2831 : {
2832 24 : if( ( !bSearchHidden && rRule.IsHidden() ) ||
2833 : ( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2834 0 : ? !(rRule.GetPoolFmtId() & USER_FMT)
2835 : // searched for used and found none
2836 24 : : bIsSearchUsed ) )
2837 0 : continue;
2838 : }
2839 :
2840 24 : aLst.Append( cNUMRULE, rRule.GetName() );
2841 : }
2842 : }
2843 8 : if ( bAll )
2844 8 : AppendStyleList(SwStyleNameMapper::GetNumRuleUINameArray(),
2845 16 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, cNUMRULE);
2846 : }
2847 :
2848 262 : if(!aLst.empty())
2849 : {
2850 262 : nLastPos = USHRT_MAX;
2851 262 : return Next();
2852 : }
2853 0 : return 0;
2854 : }
2855 :
2856 262 : SfxStyleSheetBase* SwStyleSheetIterator::Next()
2857 : {
2858 262 : ++nLastPos;
2859 262 : if(!aLst.empty() && nLastPos < aLst.size())
2860 : {
2861 262 : mxIterSheet->PresetNameAndFamily(aLst[nLastPos]);
2862 262 : mxIterSheet->SetPhysical( sal_False );
2863 262 : mxIterSheet->SetMask( nMask );
2864 262 : if(mxIterSheet->pSet)
2865 : {
2866 0 : mxIterSheet->pSet->ClearItem(0);
2867 0 : mxIterSheet->pSet= 0;
2868 : }
2869 262 : return mxIterSheet.get();
2870 : }
2871 0 : return 0;
2872 : }
2873 :
2874 0 : SfxStyleSheetBase* SwStyleSheetIterator::Find(const rtl::OUString& rName)
2875 : {
2876 : // searching
2877 0 : if( !bFirstCalled )
2878 0 : First();
2879 :
2880 0 : nLastPos = lcl_FindName( aLst, nSearchFamily, rName );
2881 0 : if( USHRT_MAX != nLastPos )
2882 : {
2883 : // found
2884 0 : mxStyleSheet->PresetNameAndFamily(aLst[nLastPos]);
2885 : // new name is set, so determine its Data
2886 0 : mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
2887 0 : if( !mxStyleSheet->IsPhysical() )
2888 0 : mxStyleSheet->SetPhysical( sal_False );
2889 :
2890 0 : return mxStyleSheet.get();
2891 : }
2892 0 : return 0;
2893 : }
2894 :
2895 1075 : void SwStyleSheetIterator::AppendStyleList(const boost::ptr_vector<String>& rList,
2896 : sal_Bool bTestUsed, sal_Bool bTestHidden, bool bOnlyHidden,
2897 : sal_uInt16 nSection, char cType )
2898 : {
2899 1075 : SwDoc& rDoc = ((SwDocStyleSheetPool*)pBasePool)->GetDoc();
2900 1075 : sal_Bool bUsed = sal_False;
2901 21584 : for ( sal_uInt16 i=0; i < rList.size(); ++i )
2902 : {
2903 20509 : sal_Bool bHidden = sal_False;
2904 20509 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rList[i], (SwGetPoolIdFromName)nSection);
2905 20509 : switch ( nSection )
2906 : {
2907 : case nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL:
2908 : {
2909 18666 : bUsed = rDoc.IsPoolTxtCollUsed( nId );
2910 18666 : SwFmt* pFmt = rDoc.FindTxtFmtCollByName( rList[i] );
2911 18666 : bHidden = pFmt && pFmt->IsHidden( );
2912 : }
2913 18666 : break;
2914 : case nsSwGetPoolIdFromName::GET_POOLID_CHRFMT:
2915 : {
2916 1248 : bUsed = rDoc.IsPoolFmtUsed( nId );
2917 1248 : SwFmt* pFmt = rDoc.FindCharFmtByName( rList[i] );
2918 1248 : bHidden = pFmt && pFmt->IsHidden( );
2919 : }
2920 1248 : break;
2921 : case nsSwGetPoolIdFromName::GET_POOLID_FRMFMT:
2922 : {
2923 35 : bUsed = rDoc.IsPoolFmtUsed( nId );
2924 35 : SwFmt* pFmt = rDoc.FindFrmFmtByName( rList[i] );
2925 35 : bHidden = pFmt && pFmt->IsHidden( );
2926 : }
2927 35 : break;
2928 : case nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC:
2929 : {
2930 480 : bUsed = rDoc.IsPoolPageDescUsed( nId );
2931 480 : SwPageDesc* pPgDesc = rDoc.FindPageDescByName( rList[i] );
2932 480 : bHidden = pPgDesc && pPgDesc->IsHidden( );
2933 : }
2934 480 : break;
2935 : case nsSwGetPoolIdFromName::GET_POOLID_NUMRULE:
2936 : {
2937 80 : SwNumRule* pRule = rDoc.FindNumRulePtr( rList[i] );
2938 80 : bUsed = pRule && rDoc.IsUsed( *pRule );
2939 80 : bHidden = pRule && pRule->IsHidden( );
2940 : }
2941 80 : break;
2942 : default:
2943 : OSL_ENSURE( !this, "unknown PoolFmt-Id" );
2944 : }
2945 :
2946 20509 : bool bMatchHidden = ( bTestHidden && ( bHidden || !bOnlyHidden ) ) || ( !bTestHidden && ( !bHidden || bUsed ) );
2947 20509 : if ( ( !bTestUsed && bMatchHidden ) || ( bTestUsed && bUsed ) )
2948 20509 : aLst.Append( cType, rList[i] );
2949 : }
2950 1075 : }
2951 :
2952 389 : void SwStyleSheetIterator::Notify( SfxBroadcaster&, const SfxHint& rHint )
2953 : {
2954 : // search and remove from View-List!!
2955 765 : if( rHint.ISA( SfxStyleSheetHint ) &&
2956 376 : SFX_STYLESHEET_ERASED == ((SfxStyleSheetHint&) rHint).GetHint() )
2957 : {
2958 0 : SfxStyleSheetBase* pStyle = ((SfxStyleSheetHint&)rHint).GetStyleSheet();
2959 :
2960 0 : if (pStyle)
2961 : {
2962 : sal_uInt16 nTmpPos = lcl_FindName( aLst, pStyle->GetFamily(),
2963 0 : pStyle->GetName() );
2964 0 : if( nTmpPos < aLst.size() )
2965 0 : aLst.erase(aLst.begin() + nTmpPos);
2966 : }
2967 : }
2968 419 : }
2969 :
2970 :
2971 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
