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 : explicit SwImplShellAction( SwDoc& rDoc );
89 : ~SwImplShellAction();
90 : };
91 :
92 360379 : SwImplShellAction::SwImplShellAction( SwDoc& rDoc )
93 360379 : : pCurrSh( 0 )
94 : {
95 360379 : if( rDoc.GetDocShell() )
96 360379 : pSh = rDoc.GetDocShell()->GetWrtShell();
97 : else
98 0 : pSh = 0;
99 :
100 360379 : if( pSh )
101 : {
102 2708 : pCurrSh = new CurrShell( pSh );
103 2708 : pSh->StartAllAction();
104 : }
105 360379 : }
106 :
107 360379 : SwImplShellAction::~SwImplShellAction()
108 : {
109 360379 : if( pCurrSh )
110 : {
111 2708 : pSh->EndAllAction();
112 2708 : delete pCurrSh;
113 : }
114 360379 : }
115 :
116 : // find/create SwCharFormate
117 : // possibly fill Style
118 158397 : static SwCharFormat* lcl_FindCharFormat( SwDoc& rDoc,
119 : const OUString& rName,
120 : SwDocStyleSheet* pStyle = 0,
121 : bool bCreate = true )
122 : {
123 158397 : SwCharFormat* pFormat = 0;
124 158397 : if (!rName.isEmpty())
125 : {
126 156047 : pFormat = rDoc.FindCharFormatByName( rName );
127 212546 : if( !pFormat && rName == SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
128 56499 : RES_POOLCOLL_TEXT_BEGIN ] )
129 : {
130 : // Standard-Character template
131 221 : pFormat = rDoc.GetDfltCharFormat();
132 : }
133 :
134 156047 : if( !pFormat && bCreate )
135 : { // explore Pool
136 12774 : const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT);
137 12774 : if(nId != USHRT_MAX)
138 963 : pFormat = rDoc.getIDocumentStylePoolAccess().GetCharFormatFromPool(nId);
139 : }
140 : }
141 158397 : if(pStyle)
142 : {
143 134136 : if(pFormat)
144 : {
145 88282 : pStyle->SetPhysical(true);
146 88282 : SwFormat* p = pFormat->DerivedFrom();
147 88282 : if( p && !p->IsDefault() )
148 43248 : pStyle->PresetParent( p->GetName() );
149 : else
150 45034 : pStyle->PresetParent( OUString() );
151 : }
152 : else
153 45854 : pStyle->SetPhysical(false);
154 : }
155 158397 : return pFormat;
156 : }
157 :
158 : // find/create ParaFormats
159 : // fill Style
160 524680 : static SwTextFormatColl* lcl_FindParaFormat( SwDoc& rDoc,
161 : const OUString& rName,
162 : SwDocStyleSheet* pStyle = 0,
163 : bool bCreate = true )
164 : {
165 524680 : SwTextFormatColl* pColl = 0;
166 :
167 524680 : if (!rName.isEmpty())
168 : {
169 524680 : pColl = rDoc.FindTextFormatCollByName( rName );
170 524680 : if( !pColl && bCreate )
171 : { // explore Pool
172 19149 : const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL);
173 19149 : if(nId != USHRT_MAX)
174 9345 : pColl = rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool(nId);
175 : }
176 : }
177 :
178 524680 : if(pStyle)
179 : {
180 488315 : if(pColl)
181 : {
182 385531 : pStyle->SetPhysical(true);
183 385531 : if( pColl->DerivedFrom() && !pColl->DerivedFrom()->IsDefault() )
184 263422 : pStyle->PresetParent( pColl->DerivedFrom()->GetName() );
185 : else
186 122109 : pStyle->PresetParent( OUString() );
187 :
188 385531 : SwTextFormatColl& rNext = pColl->GetNextTextFormatColl();
189 385531 : pStyle->PresetFollow(rNext.GetName());
190 : }
191 : else
192 102784 : pStyle->SetPhysical(false);
193 : }
194 524680 : return pColl;
195 : }
196 :
197 : // Border formats
198 8534 : static SwFrameFormat* lcl_FindFrameFormat( SwDoc& rDoc,
199 : const OUString& rName,
200 : SwDocStyleSheet* pStyle = 0,
201 : bool bCreate = true )
202 : {
203 8534 : SwFrameFormat* pFormat = 0;
204 8534 : if( !rName.isEmpty() )
205 : {
206 8534 : pFormat = rDoc.FindFrameFormatByName( rName );
207 8534 : if( !pFormat && bCreate )
208 : { // explore Pool
209 299 : const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT);
210 299 : if(nId != USHRT_MAX)
211 261 : pFormat = rDoc.getIDocumentStylePoolAccess().GetFrameFormatFromPool(nId);
212 : }
213 : }
214 :
215 8534 : if(pStyle)
216 : {
217 8486 : if(pFormat)
218 : {
219 5084 : pStyle->SetPhysical(true);
220 5084 : if( pFormat->DerivedFrom() && !pFormat->DerivedFrom()->IsDefault() )
221 60 : pStyle->PresetParent( pFormat->DerivedFrom()->GetName() );
222 : else
223 5024 : pStyle->PresetParent( OUString() );
224 : }
225 : else
226 3402 : pStyle->SetPhysical(false);
227 : }
228 8534 : return pFormat;
229 : }
230 :
231 : // Page descriptors
232 31676 : static const SwPageDesc* lcl_FindPageDesc( SwDoc& rDoc,
233 : const OUString& rName,
234 : SwDocStyleSheet* pStyle = 0,
235 : bool bCreate = true )
236 : {
237 31676 : const SwPageDesc* pDesc = 0;
238 :
239 31676 : if (!rName.isEmpty())
240 : {
241 31595 : pDesc = rDoc.FindPageDesc(rName);
242 31595 : if( !pDesc && bCreate )
243 : {
244 768 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC);
245 768 : if(nId != USHRT_MAX)
246 332 : pDesc = rDoc.getIDocumentStylePoolAccess().GetPageDescFromPool(nId);
247 : }
248 : }
249 :
250 31676 : if(pStyle)
251 : {
252 31191 : if(pDesc)
253 : {
254 25018 : pStyle->SetPhysical(true);
255 25018 : if(pDesc->GetFollow())
256 25018 : pStyle->PresetFollow(pDesc->GetFollow()->GetName());
257 : else
258 0 : pStyle->PresetParent( OUString() );
259 : }
260 : else
261 6173 : pStyle->SetPhysical(false);
262 : }
263 31676 : return pDesc;
264 : }
265 :
266 266912 : static const SwNumRule* lcl_FindNumRule( SwDoc& rDoc,
267 : const OUString& rName,
268 : SwDocStyleSheet* pStyle = 0,
269 : bool bCreate = true )
270 : {
271 266912 : const SwNumRule* pRule = 0;
272 :
273 266912 : if (!rName.isEmpty())
274 : {
275 266912 : pRule = rDoc.FindNumRulePtr( rName );
276 266912 : if( !pRule && bCreate )
277 : {
278 18924 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE);
279 18924 : if(nId != USHRT_MAX)
280 81 : pRule = rDoc.getIDocumentStylePoolAccess().GetNumRuleFromPool(nId);
281 : }
282 : }
283 :
284 266912 : if(pStyle)
285 : {
286 248069 : if(pRule)
287 : {
288 193833 : pStyle->SetPhysical(true);
289 193833 : pStyle->PresetParent( OUString() );
290 : }
291 : else
292 54236 : pStyle->SetPhysical(false);
293 : }
294 266912 : return pRule;
295 : }
296 :
297 1 : sal_uInt32 SwStyleSheetIterator::SwPoolFormatList::FindName(SfxStyleFamily eFam,
298 : const OUString &rName)
299 : {
300 1 : if(!maImpl.empty())
301 : {
302 1 : sal_Unicode cStyle(0);
303 1 : switch( eFam )
304 : {
305 : case SFX_STYLE_FAMILY_CHAR:
306 1 : cStyle = cCHAR;
307 1 : 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 1 : const OUString sSrch = OUString(cStyle) + rName;
325 :
326 1 : UniqueHash::const_iterator it = maUnique.find(sSrch);
327 1 : 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 1 : }
334 : }
335 1 : return SAL_MAX_UINT32;
336 : }
337 :
338 1 : void SwStyleSheetIterator::SwPoolFormatList::rehash()
339 : {
340 1 : maUnique.clear();
341 123 : for (size_t i = 0; i < maImpl.size(); i++)
342 122 : maUnique[maImpl[i]] = i;
343 : assert (maImpl.size() == maUnique.size());
344 1 : }
345 :
346 1 : void SwStyleSheetIterator::SwPoolFormatList::RemoveName(SfxStyleFamily eFam,
347 : const OUString &rName)
348 : {
349 1 : sal_uInt32 nTmpPos = FindName( eFam, rName );
350 1 : if( nTmpPos < maImpl.size() )
351 0 : maImpl.erase(maImpl.begin() + nTmpPos);
352 :
353 : // assumption: this seldom occurs, the iterator is built, then emptied.
354 1 : rehash();
355 : assert (maImpl.size() == maUnique.size());
356 1 : }
357 :
358 : // Add Strings to the list of templates
359 4860095 : void SwStyleSheetIterator::SwPoolFormatList::Append( char cChar, const OUString& rStr )
360 : {
361 4860095 : const OUString aStr = OUString(cChar) + rStr;
362 :
363 4860095 : UniqueHash::const_iterator it = maUnique.find(aStr);
364 4860095 : if (it != maUnique.end())
365 5312850 : return;
366 :
367 4407340 : maUnique[aStr] = (sal_uInt32)maImpl.size();
368 4407340 : maImpl.push_back(aStr);
369 : }
370 :
371 : // UI-sided implementation of StyleSheets
372 : // uses the Core-Engine
373 48420 : 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 : pCharFormat(0),
381 : pColl(0),
382 : pFrameFormat(0),
383 : pDesc(0),
384 : pNumRule(0),
385 :
386 : rDoc(rDocument),
387 48420 : 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 96840 : bPhysical(false)
417 : {
418 48420 : nHelpId = UCHAR_MAX;
419 48420 : }
420 :
421 497167 : SwDocStyleSheet::SwDocStyleSheet( const SwDocStyleSheet& rOrg) :
422 : SfxStyleSheetBase(rOrg),
423 : pCharFormat(rOrg.pCharFormat),
424 : pColl(rOrg.pColl),
425 : pFrameFormat(rOrg.pFrameFormat),
426 : pDesc(rOrg.pDesc),
427 : pNumRule(rOrg.pNumRule),
428 : rDoc(rOrg.rDoc),
429 : aCoreSet(rOrg.aCoreSet),
430 497167 : bPhysical(rOrg.bPhysical)
431 : {
432 497167 : }
433 :
434 1091156 : SwDocStyleSheet::~SwDocStyleSheet()
435 : {
436 1091156 : }
437 :
438 48662 : void SwDocStyleSheet::Reset()
439 : {
440 48662 : aName.clear();
441 48662 : aFollow.clear();
442 48662 : aParent.clear();
443 48662 : SetPhysical(false);
444 48662 : }
445 :
446 39437 : void SwDocStyleSheet::SetGrabBagItem(const uno::Any& rVal)
447 : {
448 39437 : bool bChg = false;
449 39437 : if (!bPhysical)
450 0 : FillStyleSheet(FillPhysical);
451 :
452 39437 : SwFormat* pFormat = 0;
453 39437 : switch (nFamily)
454 : {
455 : case SFX_STYLE_FAMILY_CHAR:
456 9622 : pFormat = rDoc.FindCharFormatByName(aName);
457 9622 : if (pFormat)
458 : {
459 9622 : pFormat->SetGrabBagItem(rVal);
460 9622 : bChg = true;
461 : }
462 9622 : break;
463 : case SFX_STYLE_FAMILY_PARA:
464 16244 : pFormat = rDoc.FindTextFormatCollByName(aName);
465 16244 : if (pFormat)
466 : {
467 16244 : pFormat->SetGrabBagItem(rVal);
468 16244 : bChg = true;
469 : }
470 16244 : break;
471 : case SFX_STYLE_FAMILY_PSEUDO:
472 : {
473 13571 : SwNumRule* pRule = rDoc.FindNumRulePtr(aName);
474 13571 : if (pRule)
475 : {
476 13571 : pRule->SetGrabBagItem(rVal);
477 13571 : bChg = true;
478 : }
479 : }
480 13571 : break;
481 : default:
482 0 : break;
483 : }
484 :
485 39437 : if (bChg)
486 : {
487 39437 : dynamic_cast<SwDocStyleSheetPool&>(*pPool).InvalidateIterator();
488 39437 : pPool->Broadcast(SfxStyleSheetHint(SfxStyleSheetHintId::MODIFIED, *this));
489 39437 : SwEditShell* pSh = rDoc.GetEditShell();
490 39437 : if (pSh)
491 2 : pSh->CallChgLnk();
492 : }
493 39437 : }
494 :
495 9 : void SwDocStyleSheet::GetGrabBagItem(uno::Any& rVal) const
496 : {
497 9 : SwFormat* pFormat = 0;
498 9 : switch (nFamily)
499 : {
500 : case SFX_STYLE_FAMILY_CHAR:
501 7 : pFormat = rDoc.FindCharFormatByName(aName);
502 7 : if (pFormat)
503 7 : pFormat->GetGrabBagItem(rVal);
504 7 : break;
505 : case SFX_STYLE_FAMILY_PARA:
506 2 : pFormat = rDoc.FindTextFormatCollByName(aName);
507 2 : if (pFormat)
508 2 : pFormat->GetGrabBagItem(rVal);
509 2 : 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 9 : }
521 : // virtual methods
522 5853 : void SwDocStyleSheet::SetHidden( bool bValue )
523 : {
524 5853 : bool bChg = false;
525 5853 : if(!bPhysical)
526 0 : FillStyleSheet( FillPhysical );
527 :
528 5853 : SwFormat* pFormat = 0;
529 5853 : switch(nFamily)
530 : {
531 : case SFX_STYLE_FAMILY_CHAR:
532 1081 : pFormat = rDoc.FindCharFormatByName( aName );
533 1081 : if ( pFormat )
534 : {
535 1081 : pFormat->SetHidden( bValue );
536 1081 : bChg = true;
537 : }
538 1081 : break;
539 :
540 : case SFX_STYLE_FAMILY_PARA:
541 3665 : pFormat = rDoc.FindTextFormatCollByName( aName );
542 3665 : if ( pFormat )
543 : {
544 3665 : pFormat->SetHidden( bValue );
545 3665 : bChg = true;
546 : }
547 3665 : break;
548 :
549 : case SFX_STYLE_FAMILY_FRAME:
550 214 : pFormat = rDoc.FindFrameFormatByName( aName );
551 214 : if ( pFormat )
552 : {
553 214 : pFormat->SetHidden( bValue );
554 214 : bChg = true;
555 : }
556 214 : break;
557 :
558 : case SFX_STYLE_FAMILY_PAGE:
559 : {
560 547 : SwPageDesc* pPgDesc = rDoc.FindPageDesc(aName);
561 547 : if ( pPgDesc )
562 : {
563 547 : pPgDesc->SetHidden( bValue );
564 547 : bChg = true;
565 : }
566 : }
567 547 : break;
568 :
569 : case SFX_STYLE_FAMILY_PSEUDO:
570 : {
571 346 : SwNumRule* pRule = rDoc.FindNumRulePtr( aName );
572 346 : if ( pRule )
573 : {
574 346 : pRule->SetHidden( bValue );
575 346 : bChg = true;
576 : }
577 : }
578 : default:;
579 : }
580 :
581 5853 : if( bChg )
582 : {
583 : // calling pPool->First() here would be quite slow...
584 5853 : dynamic_cast<SwDocStyleSheetPool&>(*pPool).InvalidateIterator(); // internal list has to be updated
585 5853 : pPool->Broadcast( SfxStyleSheetHint( SfxStyleSheetHintId::MODIFIED, *this ) );
586 5853 : SwEditShell* pSh = rDoc.GetEditShell();
587 5853 : if( pSh )
588 667 : pSh->CallChgLnk();
589 : }
590 5853 : }
591 :
592 1179 : bool SwDocStyleSheet::IsHidden( ) const
593 : {
594 1179 : bool bRet = false;
595 :
596 1179 : SwFormat* pFormat = 0;
597 1179 : switch(nFamily)
598 : {
599 : case SFX_STYLE_FAMILY_CHAR:
600 229 : pFormat = rDoc.FindCharFormatByName( aName );
601 229 : bRet = pFormat && pFormat->IsHidden( );
602 229 : break;
603 :
604 : case SFX_STYLE_FAMILY_PARA:
605 747 : pFormat = rDoc.FindTextFormatCollByName( aName );
606 747 : bRet = pFormat && pFormat->IsHidden( );
607 747 : break;
608 :
609 : case SFX_STYLE_FAMILY_FRAME:
610 31 : pFormat = rDoc.FindFrameFormatByName( aName );
611 31 : bRet = pFormat && pFormat->IsHidden( );
612 31 : break;
613 :
614 : case SFX_STYLE_FAMILY_PAGE:
615 : {
616 97 : SwPageDesc* pPgDesc = rDoc.FindPageDesc(aName);
617 97 : bRet = pPgDesc && pPgDesc->IsHidden( );
618 : }
619 97 : break;
620 : case SFX_STYLE_FAMILY_PSEUDO:
621 : {
622 75 : SwNumRule* pRule = rDoc.FindNumRulePtr( aName );
623 75 : bRet = pRule && pRule->IsHidden( );
624 : }
625 : default:;
626 : }
627 :
628 1179 : return bRet;
629 : }
630 :
631 23868 : const OUString& SwDocStyleSheet::GetParent() const
632 : {
633 23868 : if( !bPhysical )
634 : {
635 : // check if it's already in document
636 570 : SwFormat* pFormat = 0;
637 : SwGetPoolIdFromName eGetType;
638 570 : switch(nFamily)
639 : {
640 : case SFX_STYLE_FAMILY_CHAR:
641 56 : pFormat = rDoc.FindCharFormatByName( aName );
642 56 : eGetType = nsSwGetPoolIdFromName::GET_POOLID_CHRFMT;
643 56 : break;
644 :
645 : case SFX_STYLE_FAMILY_PARA:
646 492 : pFormat = rDoc.FindTextFormatCollByName( aName );
647 492 : eGetType = nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL;
648 492 : break;
649 :
650 : case SFX_STYLE_FAMILY_FRAME:
651 0 : pFormat = rDoc.FindFrameFormatByName( 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 22 : return aEmptyOUStr; // there's no parent
659 : }
660 :
661 548 : OUString sTmp;
662 548 : if( !pFormat ) // not yet there, so default Parent
663 : {
664 492 : sal_uInt16 i = SwStyleNameMapper::GetPoolIdFromUIName( aName, eGetType );
665 492 : i = ::GetPoolParent( i );
666 492 : if( i && USHRT_MAX != i )
667 440 : SwStyleNameMapper::FillUIName( i, sTmp );
668 : }
669 : else
670 : {
671 56 : SwFormat* p = pFormat->DerivedFrom();
672 56 : if( p && !p->IsDefault() )
673 50 : sTmp = p->GetName();
674 : }
675 548 : SwDocStyleSheet* pThis = const_cast<SwDocStyleSheet*>(this);
676 548 : pThis->aParent = sTmp;
677 : }
678 23846 : return aParent;
679 : }
680 :
681 : // Follower
682 5386 : const OUString& SwDocStyleSheet::GetFollow() const
683 : {
684 5386 : if( !bPhysical )
685 : {
686 0 : SwDocStyleSheet* pThis = const_cast<SwDocStyleSheet*>(this);
687 0 : pThis->FillStyleSheet( FillAllInfo );
688 : }
689 5386 : 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 8 : bool SwDocStyleSheet::SetName(const OUString& rStr, bool bReindexNow)
946 : {
947 8 : if( rStr.isEmpty() )
948 0 : return false;
949 :
950 8 : if( aName != rStr )
951 : {
952 8 : if( !SfxStyleSheetBase::SetName(rStr, bReindexNow))
953 0 : return false;
954 : }
955 0 : else if(!bPhysical)
956 0 : FillStyleSheet( FillPhysical );
957 :
958 8 : bool bChg = false;
959 8 : switch(nFamily)
960 : {
961 : case SFX_STYLE_FAMILY_CHAR :
962 : {
963 : OSL_ENSURE(pCharFormat, "SwCharFormat missing!");
964 2 : if( pCharFormat && pCharFormat->GetName() != rStr )
965 : {
966 2 : if (!pCharFormat->GetName().isEmpty())
967 2 : rDoc.RenameFormat(*pCharFormat, rStr);
968 : else
969 0 : pCharFormat->SetName(rStr);
970 :
971 2 : bChg = true;
972 : }
973 2 : break;
974 : }
975 : case SFX_STYLE_FAMILY_PARA :
976 : {
977 : OSL_ENSURE(pColl, "Collection missing!");
978 4 : if( pColl && pColl->GetName() != rStr )
979 : {
980 4 : if (!pColl->GetName().isEmpty())
981 4 : rDoc.RenameFormat(*pColl, rStr);
982 : else
983 0 : pColl->SetName(rStr);
984 :
985 4 : bChg = true;
986 : }
987 4 : break;
988 : }
989 : case SFX_STYLE_FAMILY_FRAME:
990 : {
991 : OSL_ENSURE(pFrameFormat, "FrameFormat missing!");
992 0 : if( pFrameFormat && pFrameFormat->GetName() != rStr )
993 : {
994 0 : if (!pFrameFormat->GetName().isEmpty())
995 0 : rDoc.RenameFormat(*pFrameFormat, rStr);
996 : else
997 0 : pFrameFormat->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 2 : 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 2 : SwPageDesc aPageDesc(*const_cast<SwPageDesc*>(pDesc));
1011 4 : const OUString aOldName(aPageDesc.GetName());
1012 :
1013 2 : aPageDesc.SetName( rStr );
1014 2 : bool const bDoesUndo = rDoc.GetIDocumentUndoRedo().DoesUndo();
1015 :
1016 2 : rDoc.GetIDocumentUndoRedo().DoUndo(!aOldName.isEmpty());
1017 2 : rDoc.ChgPageDesc(aOldName, aPageDesc);
1018 2 : rDoc.GetIDocumentUndoRedo().DoUndo(bDoesUndo);
1019 :
1020 2 : rDoc.getIDocumentState().SetModified();
1021 4 : bChg = true;
1022 : }
1023 2 : 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 : const_cast<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 8 : if( bChg )
1059 : {
1060 8 : pPool->First(); // internal list has to be updated
1061 8 : pPool->Broadcast( SfxStyleSheetHint( SfxStyleSheetHintId::MODIFIED, *this ) );
1062 8 : SwEditShell* pSh = rDoc.GetEditShell();
1063 8 : if( pSh )
1064 8 : pSh->CallChgLnk();
1065 : }
1066 8 : return true;
1067 : }
1068 :
1069 : // hierarchy of deduction
1070 9764 : bool SwDocStyleSheet::SetParent( const OUString& rStr)
1071 : {
1072 9764 : SwFormat* pFormat = 0, *pParent = 0;
1073 9764 : switch(nFamily)
1074 : {
1075 : case SFX_STYLE_FAMILY_CHAR :
1076 : OSL_ENSURE( pCharFormat, "SwCharFormat missing!" );
1077 478 : if( 0 != ( pFormat = pCharFormat ) && !rStr.isEmpty() )
1078 478 : pParent = lcl_FindCharFormat(rDoc, rStr);
1079 478 : break;
1080 :
1081 : case SFX_STYLE_FAMILY_PARA :
1082 : OSL_ENSURE( pColl, "Collektion missing!");
1083 9276 : if( 0 != ( pFormat = pColl ) && !rStr.isEmpty() )
1084 6560 : pParent = lcl_FindParaFormat( rDoc, rStr );
1085 9276 : break;
1086 :
1087 : case SFX_STYLE_FAMILY_FRAME:
1088 : OSL_ENSURE(pFrameFormat, "FrameFormat missing!");
1089 10 : if( 0 != ( pFormat = pFrameFormat ) && !rStr.isEmpty() )
1090 10 : pParent = lcl_FindFrameFormat( rDoc, rStr );
1091 10 : 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 9764 : bool bRet = false;
1101 39056 : if( pFormat && pFormat->DerivedFrom() &&
1102 39056 : pFormat->DerivedFrom()->GetName() != rStr )
1103 : {
1104 : {
1105 9764 : SwImplShellAction aTmp( rDoc );
1106 9764 : bRet = pFormat->SetDerivedFrom( pParent );
1107 : }
1108 :
1109 9764 : if( bRet )
1110 : {
1111 9759 : aParent = rStr;
1112 : pPool->Broadcast( SfxStyleSheetHint( SfxStyleSheetHintId::MODIFIED,
1113 9759 : *this ) );
1114 : }
1115 : }
1116 :
1117 9764 : return bRet;
1118 : }
1119 :
1120 : // Set Follower
1121 5706 : bool SwDocStyleSheet::SetFollow( const OUString& rStr)
1122 : {
1123 5706 : if( !rStr.isEmpty() && !SfxStyleSheetBase::SetFollow( rStr ))
1124 1322 : return false;
1125 :
1126 4384 : SwImplShellAction aTmpSh( rDoc );
1127 4384 : switch(nFamily)
1128 : {
1129 : case SFX_STYLE_FAMILY_PARA :
1130 : {
1131 : OSL_ENSURE(pColl, "Collection missing!");
1132 4335 : if( pColl )
1133 : {
1134 4335 : SwTextFormatColl* pFollow = pColl;
1135 4335 : if( !rStr.isEmpty() && 0 == (pFollow = lcl_FindParaFormat(rDoc, rStr) ))
1136 0 : pFollow = pColl;
1137 :
1138 4335 : pColl->SetNextTextFormatColl(*pFollow);
1139 : }
1140 4335 : break;
1141 : }
1142 : case SFX_STYLE_FAMILY_PAGE :
1143 : {
1144 : OSL_ENSURE(pDesc, "PageDesc missing!");
1145 49 : if( pDesc )
1146 : {
1147 49 : const SwPageDesc* pFollowDesc = !rStr.isEmpty()
1148 49 : ? lcl_FindPageDesc(rDoc, rStr)
1149 98 : : 0;
1150 49 : size_t nId = 0;
1151 49 : if (pFollowDesc != pDesc->GetFollow() && rDoc.FindPageDesc(pDesc->GetName(), &nId))
1152 : {
1153 49 : SwPageDesc aDesc( *pDesc );
1154 49 : aDesc.SetFollow( pFollowDesc );
1155 49 : rDoc.ChgPageDesc( nId, aDesc );
1156 49 : pDesc = &rDoc.GetPageDesc( nId );
1157 : }
1158 : }
1159 49 : 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, "unknown style family");
1167 : }
1168 :
1169 4384 : return true;
1170 : }
1171 :
1172 : // extract ItemSet to Name and Family, Mask
1173 :
1174 456323 : SfxItemSet& SwDocStyleSheet::GetItemSet()
1175 : {
1176 456323 : if(!bPhysical)
1177 41072 : FillStyleSheet( FillPhysical );
1178 :
1179 456323 : switch(nFamily)
1180 : {
1181 : case SFX_STYLE_FAMILY_CHAR:
1182 : case SFX_STYLE_FAMILY_PARA:
1183 : case SFX_STYLE_FAMILY_FRAME:
1184 : {
1185 270046 : SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
1186 270046 : aBoxInfo.SetTable( false );
1187 270046 : aBoxInfo.SetDist( true ); // always show gap field
1188 270046 : aBoxInfo.SetMinDist( true );// set minimum size in tables and paragraphs
1189 270046 : aBoxInfo.SetDefDist( MIN_BORDER_DIST );// always set Default-Gap
1190 : // Single lines can only have DontCare-Status in tables
1191 270046 : aBoxInfo.SetValid( SvxBoxInfoItemValidFlags::DISABLE, true );
1192 :
1193 270046 : if( nFamily == SFX_STYLE_FAMILY_CHAR )
1194 : {
1195 : SAL_WARN_IF(!pCharFormat, "sw.ui", "Where's SwCharFormat");
1196 71071 : aCoreSet.Put(pCharFormat->GetAttrSet());
1197 71071 : aCoreSet.Put( aBoxInfo );
1198 :
1199 71071 : if(pCharFormat->DerivedFrom())
1200 71071 : aCoreSet.SetParent(&pCharFormat->DerivedFrom()->GetAttrSet());
1201 : }
1202 198975 : else if ( nFamily == SFX_STYLE_FAMILY_PARA )
1203 : {
1204 : OSL_ENSURE(pColl, "Where's Collection");
1205 196362 : aCoreSet.Put(pColl->GetAttrSet());
1206 196362 : aCoreSet.Put( aBoxInfo );
1207 196362 : aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pColl->IsAutoUpdateFormat()));
1208 :
1209 196362 : if(pColl->DerivedFrom())
1210 196362 : aCoreSet.SetParent(&pColl->DerivedFrom()->GetAttrSet());
1211 : }
1212 : else
1213 : {
1214 : OSL_ENSURE(pFrameFormat, "Where's FrameFormat");
1215 2613 : aCoreSet.Put(pFrameFormat->GetAttrSet());
1216 2613 : aCoreSet.Put( aBoxInfo );
1217 2613 : aCoreSet.Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, pFrameFormat->IsAutoUpdateFormat()));
1218 :
1219 2613 : if(pFrameFormat->DerivedFrom())
1220 2613 : aCoreSet.SetParent(&pFrameFormat->DerivedFrom()->GetAttrSet());
1221 :
1222 : //UUUU create needed items for XPropertyList entries from the DrawModel so that
1223 : // the Area TabPage can access them
1224 2613 : const SwDrawModel* pDrawModel = rDoc.getIDocumentDrawModelAccess().GetDrawModel();
1225 :
1226 2613 : aCoreSet.Put(SvxColorListItem(pDrawModel->GetColorList(), SID_COLOR_TABLE));
1227 2613 : aCoreSet.Put(SvxGradientListItem(pDrawModel->GetGradientList(), SID_GRADIENT_LIST));
1228 2613 : aCoreSet.Put(SvxHatchListItem(pDrawModel->GetHatchList(), SID_HATCH_LIST));
1229 2613 : aCoreSet.Put(SvxBitmapListItem(pDrawModel->GetBitmapList(), SID_BITMAP_LIST));
1230 270046 : }
1231 : }
1232 270046 : break;
1233 :
1234 : case SFX_STYLE_FAMILY_PAGE :
1235 : {
1236 : //UUUU set correct parent to get the drawing::FillStyle_NONE FillStyle as needed
1237 16811 : if(!aCoreSet.GetParent())
1238 : {
1239 16264 : aCoreSet.SetParent(&rDoc.GetDfltFrameFormat()->GetAttrSet());
1240 : }
1241 :
1242 : OSL_ENSURE(pDesc, "No PageDescriptor");
1243 16811 : ::PageDescToItemSet(*const_cast<SwPageDesc*>(pDesc), aCoreSet);
1244 : }
1245 16811 : break;
1246 :
1247 : case SFX_STYLE_FAMILY_PSEUDO:
1248 : {
1249 : OSL_ENSURE(pNumRule, "No NumRule");
1250 169466 : SvxNumRule aRule = pNumRule->MakeSvxNumRule();
1251 169466 : aCoreSet.Put(SvxNumBulletItem(aRule));
1252 : }
1253 169466 : break;
1254 :
1255 : default:
1256 : OSL_ENSURE(false, "unknown style family");
1257 : }
1258 : // Member of Baseclass
1259 456323 : pSet = &aCoreSet;
1260 :
1261 456323 : 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 SwNumFormat& rFormat = pRule->Get( 0 );
1283 0 : if ( rFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
1284 : {
1285 0 : SvxLRSpaceItem aLR( RES_LR_SPACE );
1286 0 : aLR.SetTextLeft( rFormat.GetIndentAt() );
1287 0 : aLR.SetTextFirstLineOfst( static_cast<short>(rFormat.GetFirstLineIndent()) );
1288 0 : rSet.Put( aLR );
1289 : }
1290 : }
1291 0 : }
1292 : }
1293 : }
1294 :
1295 : // handling of parameter <bResetIndentAttrsAtParagraphStyle>
1296 332370 : void SwDocStyleSheet::SetItemSet( const SfxItemSet& rSet,
1297 : const bool bResetIndentAttrsAtParagraphStyle )
1298 : {
1299 : // if applicable determine format first
1300 332370 : if(!bPhysical)
1301 0 : FillStyleSheet( FillPhysical );
1302 :
1303 332370 : SwImplShellAction aTmpSh( rDoc );
1304 :
1305 : OSL_ENSURE( &rSet != &aCoreSet, "SetItemSet with own Set is not allowed" );
1306 :
1307 332370 : if (rDoc.GetIDocumentUndoRedo().DoesUndo())
1308 : {
1309 1794 : SwRewriter aRewriter;
1310 1794 : aRewriter.AddRule( UndoArg1, GetName() );
1311 1794 : rDoc.GetIDocumentUndoRedo().StartUndo( UNDO_INSFMTATTR, &aRewriter );
1312 : }
1313 :
1314 332370 : SwFormat* pFormat = 0;
1315 332370 : SwPageDesc* pNewDsc = 0;
1316 332370 : size_t nPgDscPos = 0;
1317 :
1318 332370 : switch(nFamily)
1319 : {
1320 : case SFX_STYLE_FAMILY_CHAR :
1321 : {
1322 : OSL_ENSURE(pCharFormat, "Where's CharFormat");
1323 57295 : pFormat = pCharFormat;
1324 : }
1325 57295 : break;
1326 :
1327 : case SFX_STYLE_FAMILY_PARA :
1328 : {
1329 : OSL_ENSURE(pColl, "Where's Collection");
1330 : const SfxPoolItem* pAutoUpdate;
1331 111537 : if(SfxItemState::SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,false, &pAutoUpdate ))
1332 : {
1333 111537 : pColl->SetAutoUpdateFormat(static_cast<const SfxBoolItem*>(pAutoUpdate)->GetValue());
1334 : }
1335 :
1336 : const SwCondCollItem* pCondItem;
1337 111537 : if( SfxItemState::SET != rSet.GetItemState( FN_COND_COLL, false,
1338 111537 : reinterpret_cast<const SfxPoolItem**>(&pCondItem) ))
1339 111537 : pCondItem = 0;
1340 :
1341 111537 : 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 : static_cast<SwConditionTextFormatColl*>(pColl)->RemoveCondition( aCond );
1348 0 : const OUString sStyle = pCondItem->GetStyle( i );
1349 0 : if (sStyle.isEmpty())
1350 0 : continue;
1351 0 : SwFormat *const pFindFormat = lcl_FindParaFormat( rDoc, sStyle, 0, true );
1352 0 : if (pFindFormat)
1353 : {
1354 0 : aCond.RegisterToFormat( *pFindFormat );
1355 0 : static_cast<SwConditionTextFormatColl*>(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 111537 : else if( pCondItem && !pColl->HasWriterListeners() )
1364 : {
1365 : // no conditional template, then first create and adopt
1366 : // all important values
1367 : SwConditionTextFormatColl* pCColl = rDoc.MakeCondTextFormatColl(
1368 0 : pColl->GetName(), static_cast<SwTextFormatColl*>(pColl->DerivedFrom()) );
1369 0 : if( pColl != &pColl->GetNextTextFormatColl() )
1370 0 : pCColl->SetNextTextFormatColl( pColl->GetNextTextFormatColl() );
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 : SwTextFormatColl *const pFindFormat = lcl_FindParaFormat( rDoc, sStyle, 0, true );
1384 0 : if (pFindFormat)
1385 : {
1386 : pCColl->InsertCondition( SwCollCondition( pFindFormat,
1387 0 : pCmds[ i ].nCnd, pCmds[ i ].nSubCond ) );
1388 : }
1389 0 : }
1390 :
1391 0 : rDoc.DelTextFormatColl( pColl );
1392 0 : pColl = pCColl;
1393 : }
1394 111537 : if ( bResetIndentAttrsAtParagraphStyle &&
1395 0 : rSet.GetItemState( RES_PARATR_NUMRULE, false, 0 ) == SfxItemState::SET &&
1396 111537 : 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 111537 : const SfxPoolItem* pNumRuleItem = 0;
1407 111537 : if( SfxItemState::SET == rSet.GetItemState( RES_PARATR_NUMRULE, false, &pNumRuleItem ) )
1408 : { // Setting a numbering rule?
1409 128 : const OUString sNumRule = static_cast<const SwNumRuleItem*>(pNumRuleItem)->GetValue();
1410 128 : if (!sNumRule.isEmpty())
1411 : {
1412 87 : SwNumRule* pRule = rDoc.FindNumRulePtr( sNumRule );
1413 87 : 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 128 : }
1422 : }
1423 :
1424 111537 : pFormat = pColl;
1425 :
1426 111537 : sal_uInt16 nId = pColl->GetPoolFormatId() &
1427 111537 : ~ ( COLL_GET_RANGE_BITS | POOLGRP_NOCOLLID );
1428 111537 : switch( GetMask() & ( 0x0fff & ~SWSTYLEBIT_CONDCOLL ) )
1429 : {
1430 : case SWSTYLEBIT_TEXT:
1431 12786 : nId |= COLL_TEXT_BITS;
1432 12786 : break;
1433 : case SWSTYLEBIT_CHAPTER:
1434 748 : nId |= COLL_DOC_BITS;
1435 748 : break;
1436 : case SWSTYLEBIT_LIST:
1437 2225 : nId |= COLL_LISTS_BITS;
1438 2225 : break;
1439 : case SWSTYLEBIT_IDX:
1440 5757 : nId |= COLL_REGISTER_BITS;
1441 5757 : break;
1442 : case SWSTYLEBIT_EXTRA:
1443 6338 : nId |= COLL_EXTRA_BITS;
1444 6338 : break;
1445 : case SWSTYLEBIT_HTML:
1446 154 : nId |= COLL_HTML_BITS;
1447 154 : break;
1448 : }
1449 111537 : pColl->SetPoolFormatId( nId );
1450 111537 : break;
1451 : }
1452 : case SFX_STYLE_FAMILY_FRAME:
1453 : {
1454 : OSL_ENSURE(pFrameFormat, "Where's FrameFormat");
1455 : const SfxPoolItem* pAutoUpdate;
1456 642 : if(SfxItemState::SET == rSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE,false, &pAutoUpdate ))
1457 : {
1458 642 : pFrameFormat->SetAutoUpdateFormat(static_cast<const SfxBoolItem*>(pAutoUpdate)->GetValue());
1459 : }
1460 642 : pFormat = pFrameFormat;
1461 : }
1462 642 : break;
1463 :
1464 : case SFX_STYLE_FAMILY_PAGE :
1465 : {
1466 : OSL_ENSURE(pDesc, "Where's PageDescriptor");
1467 :
1468 7365 : if (rDoc.FindPageDesc(pDesc->GetName(), &nPgDscPos))
1469 : {
1470 7365 : pNewDsc = new SwPageDesc( *pDesc );
1471 : // #i48949# - no undo actions for the
1472 : // copy of the page style
1473 7365 : ::sw::UndoGuard const ug(rDoc.GetIDocumentUndoRedo());
1474 7365 : rDoc.CopyPageDesc(*pDesc, *pNewDsc); // #i7983#
1475 :
1476 7365 : pFormat = &pNewDsc->GetMaster();
1477 : }
1478 : }
1479 7365 : break;
1480 :
1481 : case SFX_STYLE_FAMILY_PSEUDO:
1482 : {
1483 : OSL_ENSURE(pNumRule, "Where's NumRule");
1484 :
1485 155531 : if (!pNumRule)
1486 0 : break;
1487 :
1488 : const SfxPoolItem* pItem;
1489 155531 : switch( rSet.GetItemState( SID_ATTR_NUMBERING_RULE, false, &pItem ))
1490 : {
1491 : case SfxItemState::SET:
1492 : {
1493 155531 : SvxNumRule* pSetRule = static_cast<const SvxNumBulletItem*>(pItem)->GetNumRule();
1494 155531 : pSetRule->UnLinkGraphics();
1495 155531 : SwNumRule aSetRule(*pNumRule);
1496 155531 : aSetRule.SetSvxRule(*pSetRule, &rDoc);
1497 155531 : rDoc.ChgNumRuleFormats( aSetRule );
1498 : }
1499 155531 : 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.ChgNumRuleFormats( aRule );
1508 : }
1509 0 : break;
1510 0 : default: break;
1511 : }
1512 : }
1513 155531 : break;
1514 :
1515 : default:
1516 : OSL_ENSURE(false, "unknown style family");
1517 : }
1518 :
1519 332370 : if( pFormat && rSet.Count())
1520 : {
1521 176839 : SfxItemIter aIter( rSet );
1522 176839 : const SfxPoolItem* pItem = aIter.GetCurItem();
1523 : while( true )
1524 : {
1525 1292173 : 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 : *pFormat );
1531 : }
1532 :
1533 1292173 : if( aIter.IsAtEnd() )
1534 176839 : break;
1535 1115334 : pItem = aIter.NextItem();
1536 : }
1537 353678 : SfxItemSet aSet(rSet);
1538 176839 : aSet.ClearInvalidItems();
1539 :
1540 176839 : 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 642 : rDoc.CheckForUniqueItemForLineFillNameOrIndex(aSet);
1546 : }
1547 :
1548 176839 : aCoreSet.ClearItem();
1549 :
1550 176839 : if( pNewDsc )
1551 : {
1552 7365 : ::ItemSetToPageDesc( aSet, *pNewDsc );
1553 7365 : rDoc.ChgPageDesc( nPgDscPos, *pNewDsc );
1554 7365 : pDesc = &rDoc.GetPageDesc( nPgDscPos );
1555 7365 : rDoc.PreDelPageDesc(pNewDsc); // #i7983#
1556 7365 : delete pNewDsc;
1557 : }
1558 : else
1559 346313 : rDoc.ChgFormat(*pFormat, aSet); // put all that is set
1560 : }
1561 : else
1562 : {
1563 155531 : aCoreSet.ClearItem();
1564 155531 : if( pNewDsc ) // we still need to delete it
1565 : {
1566 0 : rDoc.PreDelPageDesc(pNewDsc); // #i7983#
1567 0 : delete pNewDsc;
1568 : }
1569 : }
1570 :
1571 332370 : if (rDoc.GetIDocumentUndoRedo().DoesUndo())
1572 : {
1573 1794 : rDoc.GetIDocumentUndoRedo().EndUndo(UNDO_END, 0);
1574 332370 : }
1575 332370 : }
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 SwCharFormats& rTable = *rDoc.GetCharFormats();
1584 0 : for( size_t n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1585 : {
1586 0 : rArr.push_back( rTable[ n ] );
1587 : }
1588 : }
1589 0 : break;
1590 : case SFX_STYLE_FAMILY_PARA:
1591 : {
1592 0 : const SwTextFormatColls& rTable = *rDoc.GetTextFormatColls();
1593 0 : for( size_t n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1594 : {
1595 0 : rArr.push_back( rTable[ n ] );
1596 : }
1597 : }
1598 0 : break;
1599 : case SFX_STYLE_FAMILY_FRAME:
1600 : {
1601 0 : const SwFrameFormats& rTable = *rDoc.GetFrameFormats();
1602 0 : for( size_t n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1603 : {
1604 0 : rArr.push_back( rTable[ n ] );
1605 : }
1606 : }
1607 0 : break;
1608 :
1609 : case SFX_STYLE_FAMILY_PAGE:
1610 : {
1611 0 : for( size_t 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 SwNumRuleTable& rTable = rDoc.GetNumRuleTable();
1621 0 : for( size_t n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1622 : {
1623 0 : rArr.push_back( rTable[ 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 : size_t n, nCnt;
1638 0 : switch( nFamily )
1639 : {
1640 : case SFX_STYLE_FAMILY_CHAR:
1641 : {
1642 0 : std::deque<sal_uInt16> aDelArr;
1643 0 : const SwCharFormats& rTable = *rDoc.GetCharFormats();
1644 0 : for( n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1645 : {
1646 0 : if( !lcl_Contains( rArr, rTable[ n ] ))
1647 0 : aDelArr.push_front( n );
1648 : }
1649 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1650 0 : rDoc.DelCharFormat( aDelArr[ n ] );
1651 : }
1652 0 : break;
1653 :
1654 : case SFX_STYLE_FAMILY_PARA :
1655 : {
1656 0 : std::deque<sal_uInt16> aDelArr;
1657 0 : const SwTextFormatColls& rTable = *rDoc.GetTextFormatColls();
1658 0 : for( n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1659 : {
1660 0 : if( !lcl_Contains( rArr, rTable[ n ] ))
1661 0 : aDelArr.push_front( n );
1662 : }
1663 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1664 0 : rDoc.DelTextFormatColl( aDelArr[ n ] );
1665 : }
1666 0 : break;
1667 :
1668 : case SFX_STYLE_FAMILY_FRAME:
1669 : {
1670 0 : std::deque<SwFrameFormat*> aDelArr;
1671 0 : const SwFrameFormats& rTable = *rDoc.GetFrameFormats();
1672 0 : for( n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1673 : {
1674 0 : if( !lcl_Contains( rArr, rTable[ n ] ))
1675 0 : aDelArr.push_front( rTable[ n ] );
1676 : }
1677 0 : for( n = 0, nCnt = aDelArr.size(); n < nCnt; ++n )
1678 0 : rDoc.DelFrameFormat( aDelArr[ n ] );
1679 : }
1680 0 : break;
1681 :
1682 : case SFX_STYLE_FAMILY_PAGE:
1683 : {
1684 0 : std::deque<size_t> 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 SwNumRuleTable& rTable = rDoc.GetNumRuleTable();
1699 0 : for( n = 0, nCnt = rTable.size(); n < nCnt; ++n )
1700 : {
1701 0 : if( !lcl_Contains( rArr, rTable[ n ] ))
1702 0 : aDelArr.push_front( rTable[ 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 910197 : bool SwDocStyleSheet::FillStyleSheet( FillStyleType eFType )
1713 : {
1714 910197 : bool bRet = false;
1715 910197 : sal_uInt16 nPoolId = USHRT_MAX;
1716 910197 : SwFormat* pFormat = 0;
1717 :
1718 910197 : bool bCreate = FillPhysical == eFType;
1719 910197 : bool bDeleteInfo = false;
1720 910197 : bool bFillOnlyInfo = FillAllInfo == eFType;
1721 910197 : std::vector<void*> aDelArr;
1722 :
1723 910197 : switch(nFamily)
1724 : {
1725 : case SFX_STYLE_FAMILY_CHAR:
1726 134136 : pCharFormat = lcl_FindCharFormat(rDoc, aName, this, bCreate );
1727 134136 : bPhysical = 0 != pCharFormat;
1728 134136 : if( bFillOnlyInfo && !bPhysical )
1729 : {
1730 0 : bDeleteInfo = true;
1731 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1732 0 : pCharFormat = lcl_FindCharFormat(rDoc, aName, this, true );
1733 : }
1734 :
1735 134136 : pFormat = pCharFormat;
1736 134136 : if( !bCreate && !pFormat )
1737 : {
1738 91708 : if( aName == SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
1739 45854 : RES_POOLCOLL_TEXT_BEGIN ] )
1740 0 : nPoolId = 0;
1741 : else
1742 45854 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
1743 : }
1744 :
1745 134136 : bRet = 0 != pCharFormat || USHRT_MAX != nPoolId;
1746 :
1747 134136 : if( bDeleteInfo )
1748 0 : pCharFormat = 0;
1749 134136 : break;
1750 :
1751 : case SFX_STYLE_FAMILY_PARA:
1752 : {
1753 488315 : pColl = lcl_FindParaFormat(rDoc, aName, this, bCreate);
1754 488315 : bPhysical = 0 != pColl;
1755 488315 : if( bFillOnlyInfo && !bPhysical )
1756 : {
1757 0 : bDeleteInfo = true;
1758 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1759 0 : pColl = lcl_FindParaFormat(rDoc, aName, this, true );
1760 : }
1761 :
1762 488315 : pFormat = pColl;
1763 488315 : if( pColl )
1764 385531 : PresetFollow( pColl->GetNextTextFormatColl().GetName() );
1765 102784 : else if( !bCreate )
1766 102784 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
1767 :
1768 488315 : bRet = 0 != pColl || USHRT_MAX != nPoolId;
1769 :
1770 488315 : if( bDeleteInfo )
1771 0 : pColl = 0;
1772 : }
1773 488315 : break;
1774 :
1775 : case SFX_STYLE_FAMILY_FRAME:
1776 8486 : pFrameFormat = lcl_FindFrameFormat(rDoc, aName, this, bCreate);
1777 8486 : bPhysical = 0 != pFrameFormat;
1778 8486 : if( bFillOnlyInfo && bPhysical )
1779 : {
1780 0 : bDeleteInfo = true;
1781 0 : ::lcl_SaveStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1782 0 : pFrameFormat = lcl_FindFrameFormat(rDoc, aName, this, true );
1783 : }
1784 8486 : pFormat = pFrameFormat;
1785 8486 : if( !bCreate && !pFormat )
1786 3402 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT );
1787 :
1788 8486 : bRet = 0 != pFrameFormat || USHRT_MAX != nPoolId;
1789 :
1790 8486 : if( bDeleteInfo )
1791 0 : pFrameFormat = 0;
1792 8486 : break;
1793 :
1794 : case SFX_STYLE_FAMILY_PAGE:
1795 31191 : pDesc = lcl_FindPageDesc(rDoc, aName, this, bCreate);
1796 31191 : bPhysical = 0 != pDesc;
1797 31191 : 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 31191 : if( pDesc )
1805 : {
1806 25018 : nPoolId = pDesc->GetPoolFormatId();
1807 25018 : nHelpId = pDesc->GetPoolHelpId();
1808 25018 : if( pDesc->GetPoolHlpFileId() != UCHAR_MAX )
1809 0 : aHelpFile = *rDoc.GetDocPattern( pDesc->GetPoolHlpFileId() );
1810 : else
1811 25018 : aHelpFile.clear();
1812 : }
1813 6173 : else if( !bCreate )
1814 6173 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC );
1815 31191 : SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );
1816 :
1817 31191 : bRet = 0 != pDesc || USHRT_MAX != nPoolId;
1818 31191 : if( bDeleteInfo )
1819 0 : pDesc = 0;
1820 31191 : break;
1821 :
1822 : case SFX_STYLE_FAMILY_PSEUDO:
1823 248069 : pNumRule = lcl_FindNumRule(rDoc, aName, this, bCreate);
1824 248069 : bPhysical = 0 != pNumRule;
1825 248069 : 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 248069 : if( pNumRule )
1833 : {
1834 193833 : nPoolId = pNumRule->GetPoolFormatId();
1835 193833 : nHelpId = pNumRule->GetPoolHelpId();
1836 193833 : if( pNumRule->GetPoolHlpFileId() != UCHAR_MAX )
1837 0 : aHelpFile = *rDoc.GetDocPattern( pNumRule->GetPoolHlpFileId() );
1838 : else
1839 193833 : aHelpFile.clear();
1840 : }
1841 54236 : else if( !bCreate )
1842 54236 : nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( aName, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE );
1843 248069 : SetMask( USER_FMT & nPoolId ? SFXSTYLEBIT_USERDEF : 0 );
1844 :
1845 248069 : bRet = 0 != pNumRule || USHRT_MAX != nPoolId;
1846 :
1847 248069 : if( bDeleteInfo )
1848 0 : pNumRule = 0;
1849 248069 : break;
1850 : default:; //prevent warning
1851 : }
1852 :
1853 1686258 : if( SFX_STYLE_FAMILY_CHAR == nFamily ||
1854 1063807 : SFX_STYLE_FAMILY_PARA == nFamily ||
1855 287746 : SFX_STYLE_FAMILY_FRAME == nFamily )
1856 : {
1857 630937 : if( pFormat )
1858 478897 : nPoolId = pFormat->GetPoolFormatId();
1859 :
1860 630937 : sal_uInt16 _nMask = 0;
1861 630937 : if( pFormat == rDoc.GetDfltCharFormat() )
1862 221 : _nMask |= SFXSTYLEBIT_READONLY;
1863 630716 : else if( USER_FMT & nPoolId )
1864 255425 : _nMask |= SFXSTYLEBIT_USERDEF;
1865 :
1866 630937 : switch ( COLL_GET_RANGE_BITS & nPoolId )
1867 : {
1868 202750 : case COLL_TEXT_BITS: _nMask |= SWSTYLEBIT_TEXT; break;
1869 14939 : case COLL_DOC_BITS : _nMask |= SWSTYLEBIT_CHAPTER; break;
1870 31203 : case COLL_LISTS_BITS: _nMask |= SWSTYLEBIT_LIST; break;
1871 44617 : case COLL_REGISTER_BITS: _nMask |= SWSTYLEBIT_IDX; break;
1872 57663 : case COLL_EXTRA_BITS: _nMask |= SWSTYLEBIT_EXTRA; break;
1873 7701 : case COLL_HTML_BITS: _nMask |= SWSTYLEBIT_HTML; break;
1874 : }
1875 :
1876 630937 : if( pFormat )
1877 : {
1878 : OSL_ENSURE( bPhysical, "Format not found" );
1879 :
1880 478897 : nHelpId = pFormat->GetPoolHelpId();
1881 478897 : if( pFormat->GetPoolHlpFileId() != UCHAR_MAX )
1882 0 : aHelpFile = *rDoc.GetDocPattern( pFormat->GetPoolHlpFileId() );
1883 : else
1884 478897 : aHelpFile.clear();
1885 :
1886 478897 : if( RES_CONDTXTFMTCOLL == pFormat->Which() )
1887 22759 : _nMask |= SWSTYLEBIT_CONDCOLL;
1888 : }
1889 :
1890 630937 : SetMask( _nMask );
1891 : }
1892 910197 : if( bDeleteInfo && bFillOnlyInfo )
1893 0 : ::lcl_DeleteInfoStyles( static_cast< sal_uInt16 >(nFamily), aDelArr, rDoc );
1894 910197 : return bRet;
1895 : }
1896 :
1897 : // Create new format in Core
1898 40849 : void SwDocStyleSheet::Create()
1899 : {
1900 40849 : switch(nFamily)
1901 : {
1902 : case SFX_STYLE_FAMILY_CHAR :
1903 11806 : pCharFormat = lcl_FindCharFormat( rDoc, aName );
1904 11806 : if( !pCharFormat )
1905 : pCharFormat = rDoc.MakeCharFormat(aName,
1906 11806 : rDoc.GetDfltCharFormat());
1907 11806 : pCharFormat->SetAuto( false );
1908 11806 : break;
1909 :
1910 : case SFX_STYLE_FAMILY_PARA :
1911 9726 : pColl = lcl_FindParaFormat( rDoc, aName );
1912 9726 : if( !pColl )
1913 : {
1914 9726 : SwTextFormatColl *pPar = (*rDoc.GetTextFormatColls())[0];
1915 9726 : if( nMask & SWSTYLEBIT_CONDCOLL )
1916 2 : pColl = rDoc.MakeCondTextFormatColl( aName, pPar );
1917 : else
1918 9724 : pColl = rDoc.MakeTextFormatColl( aName, pPar );
1919 : }
1920 9726 : break;
1921 :
1922 : case SFX_STYLE_FAMILY_FRAME:
1923 38 : pFrameFormat = lcl_FindFrameFormat( rDoc, aName );
1924 38 : if( !pFrameFormat )
1925 38 : pFrameFormat = rDoc.MakeFrameFormat(aName, rDoc.GetDfltFrameFormat(), false, false);
1926 :
1927 38 : break;
1928 :
1929 : case SFX_STYLE_FAMILY_PAGE :
1930 436 : pDesc = lcl_FindPageDesc( rDoc, aName );
1931 436 : if( !pDesc )
1932 : {
1933 436 : pDesc = rDoc.MakePageDesc(aName);
1934 : }
1935 436 : break;
1936 :
1937 : case SFX_STYLE_FAMILY_PSEUDO:
1938 18843 : pNumRule = lcl_FindNumRule( rDoc, aName );
1939 18843 : if( !pNumRule )
1940 : {
1941 18843 : const OUString sTmpNm( aName.isEmpty() ? rDoc.GetUniqueNumRuleName() : aName );
1942 18843 : SwNumRule* pRule = rDoc.GetNumRuleTable()[
1943 : rDoc.MakeNumRule( sTmpNm, 0, false,
1944 : // #i89178#
1945 37686 : numfunc::GetDefaultPositionAndSpaceMode() ) ];
1946 18843 : pRule->SetAutoRule( false );
1947 18843 : if( aName.isEmpty() )
1948 : {
1949 : // #i91400#
1950 0 : pRule->SetName( aName, rDoc.getIDocumentListsAccess() );
1951 : }
1952 18843 : pNumRule = pRule;
1953 : }
1954 18843 : break;
1955 : default:; //prevent warning
1956 : }
1957 40849 : bPhysical = true;
1958 40849 : aCoreSet.ClearItem();
1959 40849 : }
1960 :
1961 97622 : SwCharFormat* SwDocStyleSheet::GetCharFormat()
1962 : {
1963 97622 : if(!bPhysical)
1964 308 : FillStyleSheet( FillPhysical );
1965 97622 : return pCharFormat;
1966 : }
1967 :
1968 495064 : SwTextFormatColl* SwDocStyleSheet::GetCollection()
1969 : {
1970 495064 : if(!bPhysical)
1971 2473 : FillStyleSheet( FillPhysical );
1972 495064 : return pColl;
1973 : }
1974 :
1975 25241 : const SwPageDesc* SwDocStyleSheet::GetPageDesc()
1976 : {
1977 25241 : if(!bPhysical)
1978 65 : FillStyleSheet( FillPhysical );
1979 25241 : return pDesc;
1980 : }
1981 :
1982 212712 : const SwNumRule * SwDocStyleSheet::GetNumRule()
1983 : {
1984 212712 : if(!bPhysical)
1985 1 : FillStyleSheet( FillPhysical );
1986 212712 : return pNumRule;
1987 : }
1988 :
1989 141614 : void SwDocStyleSheet::SetNumRule(const SwNumRule& rRule)
1990 : {
1991 : OSL_ENSURE(pNumRule, "Wo ist die NumRule");
1992 141614 : rDoc.ChgNumRuleFormats( rRule );
1993 141614 : }
1994 :
1995 : // re-generate Name AND Family from String
1996 : // First() and Next() (see below) insert an identification letter at Pos.1
1997 :
1998 408778 : void SwDocStyleSheet::PresetNameAndFamily(const OUString& rName)
1999 : {
2000 408778 : switch( rName[0] )
2001 : {
2002 344177 : case cPARA: nFamily = SFX_STYLE_FAMILY_PARA; break;
2003 17110 : case cFRAME: nFamily = SFX_STYLE_FAMILY_FRAME; break;
2004 5117 : case cPAGE: nFamily = SFX_STYLE_FAMILY_PAGE; break;
2005 0 : case cNUMRULE: nFamily = SFX_STYLE_FAMILY_PSEUDO; break;
2006 42374 : default: nFamily = SFX_STYLE_FAMILY_CHAR; break;
2007 : }
2008 408778 : aName = rName.copy(1);
2009 408778 : }
2010 :
2011 : // Is the format physically present yet
2012 2274588 : void SwDocStyleSheet::SetPhysical(bool bPhys)
2013 : {
2014 2274588 : bPhysical = bPhys;
2015 :
2016 2274588 : if(!bPhys)
2017 : {
2018 1535991 : pCharFormat = 0;
2019 1535991 : pColl = 0;
2020 1535991 : pFrameFormat = 0;
2021 1535991 : pDesc = 0;
2022 : }
2023 2274588 : }
2024 :
2025 5648 : SwFrameFormat* SwDocStyleSheet::GetFrameFormat()
2026 : {
2027 5648 : if(!bPhysical)
2028 176 : FillStyleSheet( FillPhysical );
2029 5648 : return pFrameFormat;
2030 : }
2031 :
2032 15 : bool SwDocStyleSheet::IsUsed() const
2033 : {
2034 15 : if( !bPhysical )
2035 : {
2036 0 : SwDocStyleSheet* pThis = const_cast<SwDocStyleSheet*>(this);
2037 0 : pThis->FillStyleSheet( FillOnlyName );
2038 : }
2039 :
2040 15 : if( !bPhysical )
2041 0 : return false;
2042 :
2043 : const SwModify* pMod;
2044 15 : switch( nFamily )
2045 : {
2046 1 : case SFX_STYLE_FAMILY_CHAR : pMod = pCharFormat; break;
2047 2 : case SFX_STYLE_FAMILY_PARA : pMod = pColl; break;
2048 0 : case SFX_STYLE_FAMILY_FRAME: pMod = pFrameFormat; break;
2049 12 : case SFX_STYLE_FAMILY_PAGE : pMod = pDesc; break;
2050 :
2051 : case SFX_STYLE_FAMILY_PSEUDO:
2052 0 : return pNumRule && SwDoc::IsUsed( *pNumRule );
2053 :
2054 : default:
2055 : OSL_ENSURE(false, "unknown style family");
2056 0 : return false;
2057 : }
2058 15 : 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 SwFormat* pTmpFormat = 0;
2070 0 : switch( nFamily )
2071 : {
2072 : case SFX_STYLE_FAMILY_CHAR :
2073 0 : if( !pCharFormat &&
2074 0 : 0 == (pCharFormat = lcl_FindCharFormat( 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 : pTmpFormat = pCharFormat;
2080 0 : break;
2081 :
2082 : case SFX_STYLE_FAMILY_PARA:
2083 0 : if( !pColl &&
2084 0 : 0 == ( pColl = lcl_FindParaFormat( 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 : pTmpFormat = pColl;
2090 0 : break;
2091 :
2092 : case SFX_STYLE_FAMILY_FRAME:
2093 0 : if( !pFrameFormat &&
2094 0 : 0 == ( pFrameFormat = lcl_FindFrameFormat( 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 : pTmpFormat = pFrameFormat;
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->GetPoolFormatId();
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->GetPoolFormatId();
2126 0 : break;
2127 :
2128 : default:
2129 : OSL_ENSURE(false, "unknown style family");
2130 0 : return 0;
2131 : }
2132 :
2133 0 : if( pTmpFormat )
2134 : {
2135 0 : nId = pTmpFormat->GetPoolHelpId();
2136 0 : nFileId = pTmpFormat->GetPoolHlpFileId();
2137 0 : nPoolId = pTmpFormat->GetPoolFormatId();
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( !IsPoolUserFormat( 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 : SwFormat* pTmpFormat = 0;
2166 0 : switch( nFamily )
2167 : {
2168 0 : case SFX_STYLE_FAMILY_CHAR : pTmpFormat = pCharFormat; break;
2169 0 : case SFX_STYLE_FAMILY_PARA : pTmpFormat = pColl; break;
2170 0 : case SFX_STYLE_FAMILY_FRAME: pTmpFormat = pFrameFormat; break;
2171 : case SFX_STYLE_FAMILY_PAGE :
2172 0 : const_cast<SwPageDesc*>(pDesc)->SetPoolHelpId( nHId );
2173 0 : const_cast<SwPageDesc*>(pDesc)->SetPoolHlpFileId( nFileId );
2174 0 : break;
2175 :
2176 : case SFX_STYLE_FAMILY_PSEUDO:
2177 0 : const_cast<SwNumRule*>(pNumRule)->SetPoolHelpId( nHId );
2178 0 : const_cast<SwNumRule*>(pNumRule)->SetPoolHlpFileId( nFileId );
2179 0 : break;
2180 :
2181 : default:
2182 : OSL_ENSURE(false, "unknown style family");
2183 0 : return ;
2184 : }
2185 0 : if( pTmpFormat )
2186 : {
2187 0 : pTmpFormat->SetPoolHelpId( nHId );
2188 0 : pTmpFormat->SetPoolHlpFileId( nFileId );
2189 : }
2190 : }
2191 :
2192 : // methods for DocStyleSheetPool
2193 2952 : SwDocStyleSheetPool::SwDocStyleSheetPool( SwDoc& rDocument, bool bOrg )
2194 2952 : : SfxStyleSheetBasePool( rDocument.GetAttrPool() )
2195 2952 : , mxStyleSheet( new SwDocStyleSheet( rDocument, OUString(), this, SFX_STYLE_FAMILY_CHAR, 0 ) )
2196 5904 : , rDoc( rDocument )
2197 : {
2198 2952 : bOrganizer = bOrg;
2199 2952 : }
2200 :
2201 5894 : SwDocStyleSheetPool::~SwDocStyleSheetPool()
2202 : {
2203 5894 : }
2204 :
2205 2952 : void SAL_CALL SwDocStyleSheetPool::acquire( ) throw ()
2206 : {
2207 2952 : comphelper::OWeakTypeObject::acquire();
2208 2952 : }
2209 :
2210 2947 : void SAL_CALL SwDocStyleSheetPool::release( ) throw ()
2211 : {
2212 2947 : comphelper::OWeakTypeObject::release();
2213 2947 : }
2214 :
2215 40849 : SfxStyleSheetBase& SwDocStyleSheetPool::Make( const OUString& rName,
2216 : SfxStyleFamily eFam,
2217 : sal_uInt16 _nMask)
2218 : {
2219 40849 : mxStyleSheet->PresetName(rName);
2220 40849 : mxStyleSheet->PresetParent(OUString());
2221 40849 : mxStyleSheet->PresetFollow(OUString());
2222 40849 : mxStyleSheet->SetMask(_nMask) ;
2223 40849 : mxStyleSheet->SetFamily(eFam);
2224 40849 : mxStyleSheet->SetPhysical(true);
2225 40849 : mxStyleSheet->Create();
2226 :
2227 40849 : 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 : const_cast<SwPageDesc*>(static_cast<SwDocStyleSheet&>(rTarget).GetPageDesc());
2276 : SwPageDesc* pCpyDsc =
2277 0 : const_cast<SwPageDesc*>(static_cast<SwDocStyleSheet&>(rSource).GetPageDesc());
2278 0 : rDoc.CopyPageDesc( *pCpyDsc, *pDestDsc );
2279 : }
2280 : else
2281 : {
2282 0 : const SwFormat *pSourceFormat = 0;
2283 0 : SwFormat *pTargetFormat = 0;
2284 0 : size_t nPgDscPos = SIZE_MAX;
2285 0 : switch( eFamily )
2286 : {
2287 : case SFX_STYLE_FAMILY_CHAR :
2288 0 : if( bSwSrcPool )
2289 0 : pSourceFormat = static_cast<SwDocStyleSheet&>(rSource).GetCharFormat();
2290 0 : pTargetFormat = static_cast<SwDocStyleSheet&>(rTarget).GetCharFormat();
2291 0 : break;
2292 : case SFX_STYLE_FAMILY_PARA :
2293 0 : if( bSwSrcPool )
2294 0 : pSourceFormat = static_cast<SwDocStyleSheet&>(rSource).GetCollection();
2295 0 : pTargetFormat = static_cast<SwDocStyleSheet&>(rTarget).GetCollection();
2296 0 : break;
2297 : case SFX_STYLE_FAMILY_FRAME:
2298 0 : if( bSwSrcPool )
2299 0 : pSourceFormat = static_cast<SwDocStyleSheet&>(rSource).GetFrameFormat();
2300 0 : pTargetFormat = static_cast<SwDocStyleSheet&>(rTarget).GetFrameFormat();
2301 0 : break;
2302 : case SFX_STYLE_FAMILY_PAGE:
2303 : {
2304 : SwPageDesc *pDesc = rDoc.FindPageDesc(
2305 : static_cast<SwDocStyleSheet&>(rTarget).GetPageDesc()->GetName(),
2306 0 : &nPgDscPos );
2307 :
2308 0 : if( pDesc )
2309 0 : pTargetFormat = &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( pTargetFormat )
2319 : {
2320 0 : if( pSourceFormat )
2321 0 : pTargetFormat->DelDiffs( *pSourceFormat );
2322 0 : else if( SIZE_MAX != nPgDscPos )
2323 0 : pTargetFormat->ResetFormatAttr( RES_PAGEDESC, RES_FRMATR_END-1 );
2324 : else
2325 : {
2326 : // #i73790# - method renamed
2327 0 : pTargetFormat->ResetAllFormatAttr();
2328 : }
2329 0 : if( SIZE_MAX != nPgDscPos )
2330 : rDoc.ChgPageDesc( nPgDscPos,
2331 0 : rDoc.GetPageDesc(nPgDscPos) );
2332 : }
2333 0 : static_cast<SwDocStyleSheet&>(rTarget).SetItemSet( rSource.GetItemSet() );
2334 0 : }
2335 0 : }
2336 :
2337 22734 : SfxStyleSheetIteratorPtr SwDocStyleSheetPool::CreateIterator( SfxStyleFamily eFam, sal_uInt16 _nMask )
2338 : {
2339 22734 : return SfxStyleSheetIteratorPtr(new SwStyleSheetIterator( this, eFam, _nMask ));
2340 : }
2341 :
2342 2947 : void SwDocStyleSheetPool::dispose()
2343 : {
2344 2947 : mxStyleSheet.clear();
2345 2947 : }
2346 :
2347 1 : void SwDocStyleSheetPool::Remove( SfxStyleSheetBase* pStyle)
2348 : {
2349 1 : if( !pStyle )
2350 1 : return;
2351 :
2352 1 : bool bBroadcast = true;
2353 1 : SwImplShellAction aTmpSh( rDoc );
2354 2 : const OUString sName = pStyle->GetName();
2355 1 : switch( pStyle->GetFamily() )
2356 : {
2357 : case SFX_STYLE_FAMILY_CHAR:
2358 : {
2359 1 : SwCharFormat* pFormat = lcl_FindCharFormat(rDoc, sName, 0, false );
2360 1 : if(pFormat)
2361 1 : rDoc.DelCharFormat(pFormat);
2362 : }
2363 1 : break;
2364 : case SFX_STYLE_FAMILY_PARA:
2365 : {
2366 0 : SwTextFormatColl* pColl = lcl_FindParaFormat(rDoc, sName, 0, false );
2367 0 : if(pColl)
2368 0 : rDoc.DelTextFormatColl(pColl);
2369 : }
2370 0 : break;
2371 : case SFX_STYLE_FAMILY_FRAME:
2372 : {
2373 0 : SwFrameFormat* pFormat = lcl_FindFrameFormat(rDoc, sName, 0, false );
2374 0 : if(pFormat)
2375 0 : rDoc.DelFrameFormat(pFormat);
2376 : }
2377 0 : break;
2378 : case SFX_STYLE_FAMILY_PAGE :
2379 : {
2380 0 : rDoc.DelPageDesc(sName);
2381 : }
2382 0 : break;
2383 :
2384 : case SFX_STYLE_FAMILY_PSEUDO:
2385 : {
2386 0 : if( !rDoc.DelNumRule( sName ) )
2387 : // Only send Broadcast, when something was deleted
2388 0 : bBroadcast = false;
2389 : }
2390 0 : break;
2391 :
2392 : default:
2393 : OSL_ENSURE(false, "unknown style family");
2394 0 : bBroadcast = false;
2395 : }
2396 :
2397 1 : if( bBroadcast )
2398 2 : Broadcast( SfxStyleSheetHint( SfxStyleSheetHintId::ERASED, *pStyle ) );
2399 : }
2400 :
2401 13860 : bool SwDocStyleSheetPool::SetParent( SfxStyleFamily eFam,
2402 : const OUString &rStyle, const OUString &rParent )
2403 : {
2404 13860 : SwFormat* pFormat = 0, *pParent = 0;
2405 13860 : switch( eFam )
2406 : {
2407 : case SFX_STYLE_FAMILY_CHAR :
2408 5988 : if( 0 != ( pFormat = lcl_FindCharFormat( rDoc, rStyle ) ) && !rParent.isEmpty() )
2409 5988 : pParent = lcl_FindCharFormat(rDoc, rParent );
2410 5988 : break;
2411 :
2412 : case SFX_STYLE_FAMILY_PARA :
2413 7872 : if( 0 != ( pFormat = lcl_FindParaFormat( rDoc, rStyle ) ) && !rParent.isEmpty() )
2414 7872 : pParent = lcl_FindParaFormat( rDoc, rParent );
2415 7872 : break;
2416 :
2417 : case SFX_STYLE_FAMILY_FRAME:
2418 0 : if( 0 != ( pFormat = lcl_FindFrameFormat( rDoc, rStyle ) ) && !rParent.isEmpty() )
2419 0 : pParent = lcl_FindFrameFormat( rDoc, rParent );
2420 0 : break;
2421 :
2422 : case SFX_STYLE_FAMILY_PAGE:
2423 : case SFX_STYLE_FAMILY_PSEUDO:
2424 0 : break;
2425 :
2426 : default:
2427 : OSL_ENSURE(false, "unknown style family");
2428 : }
2429 :
2430 13860 : bool bRet = false;
2431 55440 : if( pFormat && pFormat->DerivedFrom() &&
2432 55440 : pFormat->DerivedFrom()->GetName() != rParent )
2433 : {
2434 : {
2435 13860 : SwImplShellAction aTmpSh( rDoc );
2436 13860 : bRet = pFormat->SetDerivedFrom( pParent );
2437 : }
2438 :
2439 13860 : if( bRet )
2440 : {
2441 : // only for Broadcasting
2442 13860 : mxStyleSheet->PresetName( rStyle );
2443 13860 : mxStyleSheet->PresetParent( rParent );
2444 13860 : if( SFX_STYLE_FAMILY_PARA == eFam )
2445 : mxStyleSheet->PresetFollow( static_cast<SwTextFormatColl*>(pFormat)->
2446 7872 : GetNextTextFormatColl().GetName() );
2447 : else
2448 5988 : mxStyleSheet->PresetFollow( OUString() );
2449 :
2450 : Broadcast( SfxStyleSheetHint( SfxStyleSheetHintId::MODIFIED,
2451 13860 : *(mxStyleSheet.get()) ) );
2452 : }
2453 : }
2454 :
2455 13860 : return bRet;
2456 : }
2457 :
2458 866102 : SfxStyleSheetBase* SwDocStyleSheetPool::Find( const OUString& rName,
2459 : SfxStyleFamily eFam, sal_uInt16 n )
2460 : {
2461 866102 : sal_uInt16 nSMask = n;
2462 866102 : if( SFX_STYLE_FAMILY_PARA == eFam && rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE) )
2463 : {
2464 : // then only HTML-Templates are of interest
2465 0 : if( USHRT_MAX == nSMask )
2466 0 : nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF | SFXSTYLEBIT_USED;
2467 : else
2468 : nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
2469 0 : SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
2470 0 : if( !nSMask )
2471 0 : nSMask = SWSTYLEBIT_HTML;
2472 : }
2473 :
2474 866102 : const bool bSearchUsed = ( n != SFXSTYLEBIT_ALL && n & SFXSTYLEBIT_USED );
2475 866102 : const SwModify* pMod = 0;
2476 :
2477 866102 : mxStyleSheet->SetPhysical( false );
2478 866102 : mxStyleSheet->PresetName( rName );
2479 866102 : mxStyleSheet->SetFamily( eFam );
2480 866102 : bool bFnd = mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
2481 :
2482 866102 : if( mxStyleSheet->IsPhysical() )
2483 : {
2484 653653 : switch( eFam )
2485 : {
2486 : case SFX_STYLE_FAMILY_CHAR:
2487 87320 : pMod = mxStyleSheet->GetCharFormat();
2488 87320 : break;
2489 :
2490 : case SFX_STYLE_FAMILY_PARA:
2491 343074 : pMod = mxStyleSheet->GetCollection();
2492 343074 : break;
2493 :
2494 : case SFX_STYLE_FAMILY_FRAME:
2495 4820 : pMod = mxStyleSheet->GetFrameFormat();
2496 4820 : break;
2497 :
2498 : case SFX_STYLE_FAMILY_PAGE:
2499 24687 : pMod = mxStyleSheet->GetPageDesc();
2500 24687 : break;
2501 :
2502 : case SFX_STYLE_FAMILY_PSEUDO:
2503 : {
2504 193752 : const SwNumRule* pRule = mxStyleSheet->GetNumRule();
2505 387504 : if( pRule &&
2506 387504 : !bSearchUsed &&
2507 193752 : (( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2508 0 : ? !(pRule->GetPoolFormatId() & USER_FMT)
2509 : // searched for used and found none
2510 : : bSearchUsed ))
2511 0 : bFnd = false;
2512 : }
2513 193752 : break;
2514 :
2515 : default:
2516 : OSL_ENSURE(false, "unknown style family");
2517 : }
2518 : }
2519 :
2520 : // then evaluate the mask:
2521 866102 : if( pMod && !bSearchUsed )
2522 : {
2523 : const sal_uInt16 nId = SFX_STYLE_FAMILY_PAGE == eFam
2524 : ? static_cast<const SwPageDesc*>(pMod)->GetPoolFormatId()
2525 459886 : : static_cast<const SwFormat*>(pMod)->GetPoolFormatId();
2526 :
2527 459886 : if( ( nSMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2528 0 : ? !(nId & USER_FMT)
2529 : // searched for used and found none
2530 : : bSearchUsed )
2531 0 : bFnd = false;
2532 : }
2533 866102 : return bFnd ? mxStyleSheet.get() : 0;
2534 : }
2535 :
2536 22734 : SwStyleSheetIterator::SwStyleSheetIterator( SwDocStyleSheetPool* pBase,
2537 : SfxStyleFamily eFam, sal_uInt16 n )
2538 : : SfxStyleSheetIterator( pBase, eFam, n ),
2539 22734 : mxIterSheet( new SwDocStyleSheet( pBase->GetDoc(), OUString(), pBase, SFX_STYLE_FAMILY_CHAR, 0 ) ),
2540 45468 : mxStyleSheet( new SwDocStyleSheet( pBase->GetDoc(), OUString(), pBase, SFX_STYLE_FAMILY_CHAR, 0 ) )
2541 : {
2542 22734 : bFirstCalled = false;
2543 22734 : nLastPos = 0;
2544 22734 : StartListening( *pBase );
2545 22734 : }
2546 :
2547 68196 : SwStyleSheetIterator::~SwStyleSheetIterator()
2548 : {
2549 22732 : EndListening( mxIterSheet->GetPool() );
2550 45464 : }
2551 :
2552 4703 : sal_uInt16 SwStyleSheetIterator::Count()
2553 : {
2554 : // let the list fill correctly!!
2555 4703 : if( !bFirstCalled )
2556 353 : First();
2557 4703 : return aLst.size();
2558 : }
2559 :
2560 0 : SfxStyleSheetBase* SwStyleSheetIterator::operator[]( sal_uInt16 nIdx )
2561 : {
2562 : // found
2563 0 : if( !bFirstCalled )
2564 0 : First();
2565 0 : mxStyleSheet->PresetNameAndFamily( aLst[ nIdx ] );
2566 0 : mxStyleSheet->SetPhysical( false );
2567 0 : mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
2568 :
2569 0 : return mxStyleSheet.get();
2570 : }
2571 :
2572 48662 : SfxStyleSheetBase* SwStyleSheetIterator::First()
2573 : {
2574 : // Delete old list
2575 48662 : bFirstCalled = true;
2576 48662 : nLastPos = 0;
2577 48662 : aLst.clear();
2578 :
2579 : // Delete current
2580 48662 : mxIterSheet->Reset();
2581 :
2582 48662 : SwDoc& rDoc = static_cast<SwDocStyleSheetPool*>(pBasePool)->GetDoc();
2583 48662 : const sal_uInt16 nSrchMask = nMask;
2584 48662 : const bool bIsSearchUsed = SearchUsed();
2585 :
2586 48662 : bool bSearchHidden = ( nMask & SFXSTYLEBIT_HIDDEN );
2587 48662 : bool bOnlyHidden = nMask == SFXSTYLEBIT_HIDDEN;
2588 :
2589 48662 : const bool bOrganizer = static_cast<SwDocStyleSheetPool*>(pBasePool)->IsOrganizerMode();
2590 48662 : bool bAll = ( nSrchMask & SFXSTYLEBIT_ALL_VISIBLE ) == SFXSTYLEBIT_ALL_VISIBLE;
2591 :
2592 48662 : if( nSearchFamily == SFX_STYLE_FAMILY_CHAR
2593 47842 : || nSearchFamily == SFX_STYLE_FAMILY_ALL )
2594 : {
2595 820 : const size_t nArrLen = rDoc.GetCharFormats()->size();
2596 23032 : for( size_t i = 0; i < nArrLen; i++ )
2597 : {
2598 22212 : SwCharFormat* pFormat = (*rDoc.GetCharFormats())[ i ];
2599 :
2600 22212 : const bool bUsed = bIsSearchUsed && (bOrganizer || rDoc.IsUsed(*pFormat));
2601 22212 : if( ( !bSearchHidden && pFormat->IsHidden() && !bUsed ) || ( pFormat->IsDefault() && pFormat != rDoc.GetDfltCharFormat() ) )
2602 0 : continue;
2603 :
2604 22212 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !pFormat->IsHidden( ) )
2605 0 : continue;
2606 :
2607 22212 : if( !bUsed )
2608 : {
2609 : // Standard is no User template
2610 22212 : const sal_uInt16 nId = rDoc.GetDfltCharFormat() == pFormat ?
2611 : sal_uInt16( RES_POOLCHR_INET_NORMAL ):
2612 22212 : pFormat->GetPoolFormatId();
2613 22212 : if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2614 0 : ? !(nId & USER_FMT)
2615 : // searched for used and found none
2616 : : bIsSearchUsed )
2617 : {
2618 0 : continue;
2619 : }
2620 :
2621 44424 : if( rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE) && !(nId & USER_FMT) &&
2622 : !( RES_POOLCHR_HTML_BEGIN <= nId &&
2623 0 : nId < RES_POOLCHR_HTML_END ) &&
2624 0 : RES_POOLCHR_INET_NORMAL != nId &&
2625 0 : RES_POOLCHR_INET_VISIT != nId &&
2626 22212 : RES_POOLCHR_FOOTNOTE != nId &&
2627 : RES_POOLCHR_ENDNOTE != nId )
2628 0 : continue;
2629 : }
2630 :
2631 22212 : aLst.Append( cCHAR, pFormat == rDoc.GetDfltCharFormat()
2632 820 : ? SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD -
2633 820 : RES_POOLCOLL_TEXT_BEGIN ]
2634 23032 : : pFormat->GetName() );
2635 : }
2636 :
2637 : // PoolFormate
2638 820 : if( bAll )
2639 : {
2640 820 : if( ! rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE) )
2641 820 : AppendStyleList(SwStyleNameMapper::GetChrFormatUINameArray(),
2642 : bIsSearchUsed, bSearchHidden, bOnlyHidden,
2643 1640 : nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
2644 : else
2645 : {
2646 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFormatUINameArray()[
2647 0 : RES_POOLCHR_INET_NORMAL - RES_POOLCHR_BEGIN ] );
2648 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFormatUINameArray()[
2649 0 : RES_POOLCHR_INET_VISIT - RES_POOLCHR_BEGIN ] );
2650 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFormatUINameArray()[
2651 0 : RES_POOLCHR_ENDNOTE - RES_POOLCHR_BEGIN ] );
2652 0 : aLst.Append( cCHAR, SwStyleNameMapper::GetChrFormatUINameArray()[
2653 0 : RES_POOLCHR_FOOTNOTE - RES_POOLCHR_BEGIN ] );
2654 : }
2655 820 : AppendStyleList(SwStyleNameMapper::GetHTMLChrFormatUINameArray(),
2656 : bIsSearchUsed, bSearchHidden, bOnlyHidden,
2657 1640 : nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, cCHAR);
2658 : }
2659 : }
2660 :
2661 53022 : if( nSearchFamily == SFX_STYLE_FAMILY_PARA ||
2662 4360 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2663 : {
2664 44302 : sal_uInt16 nSMask = nSrchMask;
2665 44302 : if( rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE) )
2666 : {
2667 : // then only HTML-Template are of interest
2668 97 : if( SFXSTYLEBIT_ALL_VISIBLE == ( nSMask & SFXSTYLEBIT_ALL_VISIBLE ) )
2669 : nSMask = SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF |
2670 71 : SFXSTYLEBIT_USED;
2671 : else
2672 : nSMask &= SFXSTYLEBIT_USED | SFXSTYLEBIT_USERDEF |
2673 26 : SWSTYLEBIT_CONDCOLL | SWSTYLEBIT_HTML;
2674 97 : if( !nSMask )
2675 26 : nSMask = SWSTYLEBIT_HTML;
2676 : }
2677 :
2678 44302 : const size_t nArrLen = rDoc.GetTextFormatColls()->size();
2679 606212 : for( size_t i = 0; i < nArrLen; i++ )
2680 : {
2681 561910 : SwTextFormatColl* pColl = (*rDoc.GetTextFormatColls())[ i ];
2682 :
2683 561910 : const bool bUsed = bOrganizer || rDoc.IsUsed(*pColl);
2684 561910 : if ( ( !bSearchHidden && pColl->IsHidden( ) && !bUsed ) || pColl->IsDefault() )
2685 44302 : continue;
2686 :
2687 517608 : if ( nSMask == SFXSTYLEBIT_HIDDEN && !pColl->IsHidden( ) )
2688 0 : continue;
2689 :
2690 517608 : if( !(bIsSearchUsed && bUsed ))
2691 : {
2692 508324 : const sal_uInt16 nId = pColl->GetPoolFormatId();
2693 508324 : switch ( (nSMask & ~SFXSTYLEBIT_USED) )
2694 : {
2695 : case SFXSTYLEBIT_USERDEF:
2696 0 : if(!IsPoolUserFormat(nId)) continue;
2697 0 : break;
2698 : case SWSTYLEBIT_TEXT:
2699 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_TEXT_BITS) continue;
2700 0 : break;
2701 : case SWSTYLEBIT_CHAPTER:
2702 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_DOC_BITS) continue;
2703 0 : break;
2704 : case SWSTYLEBIT_LIST:
2705 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_LISTS_BITS) continue;
2706 0 : break;
2707 : case SWSTYLEBIT_IDX:
2708 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_REGISTER_BITS) continue;
2709 0 : break;
2710 : case SWSTYLEBIT_EXTRA:
2711 0 : if((nId & COLL_GET_RANGE_BITS) != COLL_EXTRA_BITS) continue;
2712 0 : break;
2713 : case SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF:
2714 877 : if(IsPoolUserFormat(nId))
2715 0 : break;
2716 : // otherwise move on
2717 : case SWSTYLEBIT_HTML:
2718 1145 : if( (nId & COLL_GET_RANGE_BITS) != COLL_HTML_BITS)
2719 : {
2720 : // but some we also want to see in this section
2721 1015 : bool bContinue = true;
2722 1015 : switch( nId )
2723 : {
2724 : case RES_POOLCOLL_SENDADRESS: // --> ADDRESS
2725 : case RES_POOLCOLL_TABLE_HDLN: // --> TH
2726 : case RES_POOLCOLL_TABLE: // --> TD
2727 : case RES_POOLCOLL_TEXT: // --> P
2728 : case RES_POOLCOLL_HEADLINE_BASE:// --> H
2729 : case RES_POOLCOLL_HEADLINE1: // --> H1
2730 : case RES_POOLCOLL_HEADLINE2: // --> H2
2731 : case RES_POOLCOLL_HEADLINE3: // --> H3
2732 : case RES_POOLCOLL_HEADLINE4: // --> H4
2733 : case RES_POOLCOLL_HEADLINE5: // --> H5
2734 : case RES_POOLCOLL_HEADLINE6: // --> H6
2735 : case RES_POOLCOLL_STANDARD: // --> P
2736 : case RES_POOLCOLL_FOOTNOTE:
2737 : case RES_POOLCOLL_ENDNOTE:
2738 530 : bContinue = false;
2739 530 : break;
2740 : }
2741 1015 : if( bContinue )
2742 485 : continue;
2743 : }
2744 660 : break;
2745 : case SWSTYLEBIT_CONDCOLL:
2746 0 : if( RES_CONDTXTFMTCOLL != pColl->Which() ) continue;
2747 0 : break;
2748 : default:
2749 : // searched for used and found none
2750 507179 : if( bIsSearchUsed )
2751 91714 : continue;
2752 : }
2753 : }
2754 425409 : aLst.Append( cPARA, pColl->GetName() );
2755 : }
2756 :
2757 44302 : bAll = ( nSMask & SFXSTYLEBIT_ALL_VISIBLE ) == SFXSTYLEBIT_ALL_VISIBLE;
2758 44302 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_TEXT )
2759 35503 : AppendStyleList(SwStyleNameMapper::GetTextUINameArray(),
2760 71006 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA );
2761 44302 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CHAPTER )
2762 35503 : AppendStyleList(SwStyleNameMapper::GetDocUINameArray(),
2763 71006 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2764 44302 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_LIST )
2765 35503 : AppendStyleList(SwStyleNameMapper::GetListsUINameArray(),
2766 71006 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2767 44302 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_IDX )
2768 35503 : AppendStyleList(SwStyleNameMapper::GetRegisterUINameArray(),
2769 71006 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2770 44302 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_EXTRA )
2771 35503 : AppendStyleList(SwStyleNameMapper::GetExtraUINameArray(),
2772 71006 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2773 44302 : if ( bAll || (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_CONDCOLL )
2774 : {
2775 35503 : if( !bIsSearchUsed ||
2776 0 : rDoc.getIDocumentStylePoolAccess().IsPoolTextCollUsed( RES_POOLCOLL_TEXT ))
2777 35503 : aLst.Append( cPARA, SwStyleNameMapper::GetTextUINameArray()[
2778 35503 : RES_POOLCOLL_TEXT - RES_POOLCOLL_TEXT_BEGIN ] );
2779 : }
2780 53101 : if ( bAll ||
2781 17572 : (nSMask & ~SFXSTYLEBIT_USED) == SWSTYLEBIT_HTML ||
2782 8773 : (nSMask & ~SFXSTYLEBIT_USED) ==
2783 : (SWSTYLEBIT_HTML | SFXSTYLEBIT_USERDEF) )
2784 : {
2785 35600 : AppendStyleList(SwStyleNameMapper::GetHTMLUINameArray(),
2786 71200 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, cPARA ) ;
2787 35600 : if( !bAll )
2788 : {
2789 : // then also the ones, that we are mapping:
2790 : static sal_uInt16 aPoolIds[] = {
2791 : RES_POOLCOLL_SENDADRESS, // --> ADDRESS
2792 : RES_POOLCOLL_TABLE_HDLN, // --> TH
2793 : RES_POOLCOLL_TABLE, // --> TD
2794 : RES_POOLCOLL_STANDARD, // --> P
2795 : RES_POOLCOLL_TEXT, // --> P
2796 : RES_POOLCOLL_HEADLINE_BASE, // --> H
2797 : RES_POOLCOLL_HEADLINE1, // --> H1
2798 : RES_POOLCOLL_HEADLINE2, // --> H2
2799 : RES_POOLCOLL_HEADLINE3, // --> H3
2800 : RES_POOLCOLL_HEADLINE4, // --> H4
2801 : RES_POOLCOLL_HEADLINE5, // --> H5
2802 : RES_POOLCOLL_HEADLINE6, // --> H6
2803 : RES_POOLCOLL_FOOTNOTE,
2804 : RES_POOLCOLL_ENDNOTE,
2805 : 0
2806 : };
2807 :
2808 97 : sal_uInt16* pPoolIds = aPoolIds;
2809 97 : OUString s;
2810 1552 : while( *pPoolIds )
2811 : {
2812 1358 : if( !bIsSearchUsed || rDoc.getIDocumentStylePoolAccess().IsPoolTextCollUsed( *pPoolIds ) )
2813 : aLst.Append( cPARA,
2814 1046 : s = SwStyleNameMapper::GetUIName( *pPoolIds, s ));
2815 1358 : ++pPoolIds;
2816 97 : }
2817 : }
2818 : }
2819 : }
2820 :
2821 94197 : if( nSearchFamily == SFX_STYLE_FAMILY_FRAME ||
2822 45535 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2823 : {
2824 3127 : const size_t nArrLen = rDoc.GetFrameFormats()->size();
2825 9469 : for( size_t i = 0; i < nArrLen; i++ )
2826 : {
2827 6342 : const SwFrameFormat* pFormat = (*rDoc.GetFrameFormats())[ i ];
2828 :
2829 6342 : bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(*pFormat));
2830 6342 : if( ( !bSearchHidden && pFormat->IsHidden( ) && !bUsed ) || pFormat->IsDefault() || pFormat->IsAuto() )
2831 6255 : continue;
2832 :
2833 87 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !pFormat->IsHidden( ) )
2834 0 : continue;
2835 :
2836 87 : const sal_uInt16 nId = pFormat->GetPoolFormatId();
2837 87 : if( !bUsed )
2838 : {
2839 81 : if( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2840 0 : ? !(nId & USER_FMT)
2841 : // searched for used and found none
2842 : : bIsSearchUsed )
2843 : {
2844 6 : continue;
2845 : }
2846 : }
2847 :
2848 81 : aLst.Append( cFRAME, pFormat->GetName() );
2849 : }
2850 :
2851 : // PoolFormate
2852 3127 : if ( bAll )
2853 2449 : AppendStyleList(SwStyleNameMapper::GetFrameFormatUINameArray(),
2854 4898 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_FRMFMT, cFRAME);
2855 : }
2856 :
2857 96911 : if( nSearchFamily == SFX_STYLE_FAMILY_PAGE ||
2858 48249 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2859 : {
2860 413 : const size_t nCount = rDoc.GetPageDescCnt();
2861 1943 : for(size_t i = 0; i < nCount; ++i)
2862 : {
2863 1530 : const SwPageDesc& rDesc = rDoc.GetPageDesc(i);
2864 1530 : const sal_uInt16 nId = rDesc.GetPoolFormatId();
2865 1530 : bool bUsed = bIsSearchUsed && ( bOrganizer || rDoc.IsUsed(rDesc));
2866 1530 : if( !bUsed )
2867 : {
2868 3060 : if ( ( !bSearchHidden && rDesc.IsHidden() ) ||
2869 1530 : ( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2870 0 : ? !(nId & USER_FMT)
2871 : // searched for used and found none
2872 : : bIsSearchUsed ) )
2873 0 : continue;
2874 : }
2875 :
2876 1530 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !rDesc.IsHidden( ) )
2877 0 : continue;
2878 :
2879 1530 : aLst.Append( cPAGE, rDesc.GetName() );
2880 : }
2881 413 : if ( bAll )
2882 413 : AppendStyleList(SwStyleNameMapper::GetPageDescUINameArray(),
2883 826 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, cPAGE);
2884 : }
2885 :
2886 97324 : if( nSearchFamily == SFX_STYLE_FAMILY_PSEUDO ||
2887 48662 : nSearchFamily == SFX_STYLE_FAMILY_ALL )
2888 : {
2889 0 : const SwNumRuleTable& rNumTable = rDoc.GetNumRuleTable();
2890 0 : for(size_t i = 0; i < rNumTable.size(); ++i)
2891 : {
2892 0 : const SwNumRule& rRule = *rNumTable[ i ];
2893 0 : if( !rRule.IsAutoRule() )
2894 : {
2895 0 : if ( nSrchMask == SFXSTYLEBIT_HIDDEN && !rRule.IsHidden( ) )
2896 0 : continue;
2897 :
2898 0 : bool bUsed = bIsSearchUsed && ( bOrganizer || SwDoc::IsUsed(rRule) );
2899 0 : if( !bUsed )
2900 : {
2901 0 : if( ( !bSearchHidden && rRule.IsHidden() ) ||
2902 0 : ( (nSrchMask & ~SFXSTYLEBIT_USED) == SFXSTYLEBIT_USERDEF
2903 0 : ? !(rRule.GetPoolFormatId() & USER_FMT)
2904 : // searched for used and found none
2905 : : bIsSearchUsed ) )
2906 0 : continue;
2907 : }
2908 :
2909 0 : aLst.Append( cNUMRULE, rRule.GetName() );
2910 : }
2911 : }
2912 0 : if ( bAll )
2913 0 : AppendStyleList(SwStyleNameMapper::GetNumRuleUINameArray(),
2914 0 : bIsSearchUsed, bSearchHidden, bOnlyHidden, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, cNUMRULE);
2915 : }
2916 :
2917 48662 : if(!aLst.empty())
2918 : {
2919 47986 : nLastPos = SAL_MAX_UINT32;
2920 47986 : return Next();
2921 : }
2922 676 : return 0;
2923 : }
2924 :
2925 416884 : SfxStyleSheetBase* SwStyleSheetIterator::Next()
2926 : {
2927 : assert(bFirstCalled);
2928 416884 : ++nLastPos;
2929 416884 : if(nLastPos < aLst.size())
2930 : {
2931 408778 : mxIterSheet->PresetNameAndFamily(aLst[nLastPos]);
2932 408778 : mxIterSheet->SetPhysical( false );
2933 408778 : mxIterSheet->SetMask( nMask );
2934 408778 : if(mxIterSheet->pSet)
2935 : {
2936 30793 : mxIterSheet->pSet->ClearItem(0);
2937 30793 : mxIterSheet->pSet= 0;
2938 : }
2939 408778 : return mxIterSheet.get();
2940 : }
2941 8106 : return 0;
2942 : }
2943 :
2944 0 : SfxStyleSheetBase* SwStyleSheetIterator::Find(const OUString& rName)
2945 : {
2946 : // searching
2947 0 : if( !bFirstCalled )
2948 0 : First();
2949 :
2950 0 : nLastPos = aLst.FindName( nSearchFamily, rName );
2951 0 : if( SAL_MAX_UINT32 != nLastPos )
2952 : {
2953 : // found
2954 0 : mxStyleSheet->PresetNameAndFamily(aLst[nLastPos]);
2955 : // new name is set, so determine its Data
2956 0 : mxStyleSheet->FillStyleSheet( SwDocStyleSheet::FillOnlyName );
2957 0 : if( !mxStyleSheet->IsPhysical() )
2958 0 : mxStyleSheet->SetPhysical( false );
2959 :
2960 0 : return mxStyleSheet.get();
2961 : }
2962 0 : return 0;
2963 : }
2964 :
2965 217617 : void SwStyleSheetIterator::AppendStyleList(const ::std::vector<OUString>& rList,
2966 : bool bTestUsed, bool bTestHidden, bool bOnlyHidden,
2967 : sal_uInt16 nSection, char cType )
2968 : {
2969 217617 : SwDoc& rDoc = static_cast<SwDocStyleSheetPool*>(pBasePool)->GetDoc();
2970 217617 : bool bUsed = false;
2971 4592061 : for ( size_t i=0; i < rList.size(); ++i )
2972 : {
2973 4374444 : bool bHidden = false;
2974 4374444 : sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(rList[i], (SwGetPoolIdFromName)nSection);
2975 4374444 : switch ( nSection )
2976 : {
2977 : case nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL:
2978 : {
2979 4331851 : bUsed = rDoc.getIDocumentStylePoolAccess().IsPoolTextCollUsed( nId );
2980 4331851 : SwFormat* pFormat = rDoc.FindTextFormatCollByName( rList[i] );
2981 4331851 : bHidden = pFormat && pFormat->IsHidden( );
2982 : }
2983 4331851 : break;
2984 : case nsSwGetPoolIdFromName::GET_POOLID_CHRFMT:
2985 : {
2986 21320 : bUsed = rDoc.getIDocumentStylePoolAccess().IsPoolFormatUsed( nId );
2987 21320 : SwFormat* pFormat = rDoc.FindCharFormatByName( rList[i] );
2988 21320 : bHidden = pFormat && pFormat->IsHidden( );
2989 : }
2990 21320 : break;
2991 : case nsSwGetPoolIdFromName::GET_POOLID_FRMFMT:
2992 : {
2993 17143 : bUsed = rDoc.getIDocumentStylePoolAccess().IsPoolFormatUsed( nId );
2994 17143 : SwFormat* pFormat = rDoc.FindFrameFormatByName( rList[i] );
2995 17143 : bHidden = pFormat && pFormat->IsHidden( );
2996 : }
2997 17143 : break;
2998 : case nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC:
2999 : {
3000 4130 : bUsed = rDoc.getIDocumentStylePoolAccess().IsPoolPageDescUsed( nId );
3001 4130 : SwPageDesc* pPgDesc = rDoc.FindPageDesc(rList[i]);
3002 4130 : bHidden = pPgDesc && pPgDesc->IsHidden( );
3003 : }
3004 4130 : break;
3005 : case nsSwGetPoolIdFromName::GET_POOLID_NUMRULE:
3006 : {
3007 0 : SwNumRule* pRule = rDoc.FindNumRulePtr( rList[i] );
3008 0 : bUsed = pRule && SwDoc::IsUsed( *pRule );
3009 0 : bHidden = pRule && pRule->IsHidden( );
3010 : }
3011 0 : break;
3012 : default:
3013 : OSL_ENSURE( false, "unknown PoolFormat-Id" );
3014 : }
3015 :
3016 4374444 : bool bMatchHidden = ( bTestHidden && ( bHidden || !bOnlyHidden ) ) || ( !bTestHidden && ( !bHidden || bUsed ) );
3017 4374444 : if ( ( !bTestUsed && bMatchHidden ) || ( bTestUsed && bUsed ) )
3018 4374314 : aLst.Append( cType, rList[i] );
3019 : }
3020 217617 : }
3021 :
3022 45290 : void SwDocStyleSheetPool::InvalidateIterator()
3023 : {
3024 45290 : dynamic_cast<SwStyleSheetIterator&>(GetIterator_Impl()).InvalidateIterator();
3025 45290 : }
3026 :
3027 45290 : void SwStyleSheetIterator::InvalidateIterator()
3028 : {
3029 : // potentially we could send an SfxHint to Notify but currently it's
3030 : // iterating over the vector anyway so would still be slow - why does
3031 : // this iterator not use a map?
3032 45290 : bFirstCalled = false;
3033 45290 : nLastPos = 0;
3034 45290 : aLst.clear();
3035 45290 : }
3036 :
3037 72308 : void SwStyleSheetIterator::Notify( SfxBroadcaster&, const SfxHint& rHint )
3038 : {
3039 : // search and remove from View-List!!
3040 72308 : const SfxStyleSheetHint* pStyleSheetHint = dynamic_cast<const SfxStyleSheetHint*>(&rHint);
3041 142483 : if( pStyleSheetHint &&
3042 70175 : SfxStyleSheetHintId::ERASED == pStyleSheetHint->GetHint() )
3043 : {
3044 1 : SfxStyleSheetBase* pStyle = pStyleSheetHint->GetStyleSheet();
3045 :
3046 1 : if (pStyle)
3047 1 : aLst.RemoveName(pStyle->GetFamily(), pStyle->GetName());
3048 : }
3049 72485 : }
3050 :
3051 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
