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