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