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