xref: /aoo4110/main/sd/source/core/stlsheet.cxx (revision b1cdbd2c)
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 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 
27 #include <com/sun/star/beans/PropertyAttribute.hpp>
28 #include <com/sun/star/lang/DisposedException.hpp>
29 #include <com/sun/star/style/XStyle.hpp>
30 
31 #include <osl/mutex.hxx>
32 #include <vos/mutex.hxx>
33 #include <vcl/svapp.hxx>
34 #include <comphelper/serviceinfohelper.hxx>
35 #include <boost/bind.hpp>
36 
37 #include "eetext.hxx"
38 #include <editeng/eeitem.hxx>
39 #include <editeng/fhgtitem.hxx>
40 #include <svx/svdoattr.hxx>
41 #include <editeng/ulspitem.hxx>
42 #include <svl/smplhint.hxx>
43 #include <svl/itemset.hxx>
44 
45 #include <svx/xflbmtit.hxx>
46 #include <svx/xflbstit.hxx>
47 #include <editeng/bulitem.hxx>
48 #include <editeng/lrspitem.hxx>
49 #include <svx/unoshprp.hxx>
50 #include <svx/unoshape.hxx>
51 #include <svx/svdpool.hxx>
52 #include "stlsheet.hxx"
53 #include "sdresid.hxx"
54 #include "sdpage.hxx"
55 #include "drawdoc.hxx"
56 #include "stlpool.hxx"
57 #include "glob.hrc"
58 #include "app.hrc"
59 #include "glob.hxx"
60 #include "helpids.h"
61 #include "../ui/inc/DrawViewShell.hxx"
62 #include "../ui/inc/ViewShellBase.hxx"
63 #include <editeng/boxitem.hxx>
64 
65 using ::rtl::OUString;
66 using ::osl::MutexGuard;
67 using ::osl::ClearableMutexGuard;
68 using ::cppu::OInterfaceContainerHelper;
69 using ::com::sun::star::table::BorderLine;
70 using namespace ::vos;
71 using namespace ::com::sun::star::uno;
72 using namespace ::com::sun::star::util;
73 using namespace ::com::sun::star::lang;
74 using namespace ::com::sun::star::style;
75 using namespace ::com::sun::star::beans;
76 using namespace ::com::sun::star::container;
77 using namespace ::com::sun::star::drawing;
78 
79 #define WID_STYLE_DISPNAME	7998
80 #define WID_STYLE_FAMILY	7999
81 
GetStylePropertySet()82 static SvxItemPropertySet& GetStylePropertySet()
83 {
84 	static const SfxItemPropertyMapEntry aFullPropertyMap_Impl[] =
85 	{
86 		{ RTL_CONSTASCII_STRINGPARAM("Family"),					WID_STYLE_FAMILY,		&::getCppuType((const OUString*)0),	PropertyAttribute::READONLY,	0},
87 		{ RTL_CONSTASCII_STRINGPARAM("UserDefinedAttributes"),	SDRATTR_XMLATTRIBUTES,	&XNameContainer::static_type(), 0,     0},
88 		{ RTL_CONSTASCII_STRINGPARAM("DisplayName"),			WID_STYLE_DISPNAME,		&::getCppuType((const OUString*)0),	PropertyAttribute::READONLY,	0},
89 
90 		SVX_UNOEDIT_NUMBERING_PROPERTIE,
91 		SHADOW_PROPERTIES
92 		LINE_PROPERTIES
93 		LINE_PROPERTIES_START_END
94 		FILL_PROPERTIES
95 		EDGERADIUS_PROPERTIES
96 		TEXT_PROPERTIES_DEFAULTS
97 		CONNECTOR_PROPERTIES
98 		SPECIAL_DIMENSIONING_PROPERTIES_DEFAULTS
99 		{ MAP_CHAR_LEN("TopBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, TOP_BORDER }, \
100 		{ MAP_CHAR_LEN("BottomBorder"), 				SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, BOTTOM_BORDER }, \
101 		{ MAP_CHAR_LEN("LeftBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, LEFT_BORDER }, \
102 		{ MAP_CHAR_LEN("RightBorder"),					SDRATTR_TABLE_BORDER,			&::getCppuType((const BorderLine*)0), 0, RIGHT_BORDER }, \
103 		{0,0,0,0,0,0}
104 	};
105 
106 	static SvxItemPropertySet aPropSet( aFullPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
107 	return aPropSet;
108 }
109 
110 class ModifyListenerForewarder : public SfxListener
111 {
112 public:
113 	ModifyListenerForewarder( SdStyleSheet* pStyleSheet );
114 
115 	virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint);
116 
117 private:
118 	SdStyleSheet* mpStyleSheet;
119 };
120 
ModifyListenerForewarder(SdStyleSheet * pStyleSheet)121 ModifyListenerForewarder::ModifyListenerForewarder( SdStyleSheet* pStyleSheet )
122 : mpStyleSheet( pStyleSheet )
123 {
124 	if( pStyleSheet )
125 	{
126 		SfxBroadcaster& rBC = static_cast< SfxBroadcaster& >( *pStyleSheet );
127 		StartListening( rBC );
128 	}
129 }
130 
Notify(SfxBroadcaster &,const SfxHint &)131 void ModifyListenerForewarder::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/)
132 {
133 	if( mpStyleSheet )
134 		mpStyleSheet->notifyModifyListener();
135 }
136 
SdStyleSheet(const OUString & rDisplayName,SfxStyleSheetBasePool & _rPool,SfxStyleFamily eFamily,sal_uInt16 _nMask)137 SdStyleSheet::SdStyleSheet(const OUString& rDisplayName, SfxStyleSheetBasePool& _rPool, SfxStyleFamily eFamily, sal_uInt16 _nMask)
138 : SdStyleSheetBase( UniString( rDisplayName ), _rPool, eFamily, _nMask)
139 , ::cppu::BaseMutex()
140 , msApiName( rDisplayName )
141 , mxPool( const_cast< SfxStyleSheetBasePool* >(&_rPool) )
142 , mrBHelper( m_aMutex )
143 {
144 }
145 
SdStyleSheet(const SdStyleSheet & r)146 SdStyleSheet::SdStyleSheet( const SdStyleSheet & r )
147 : SdStyleSheetBase( r )
148 , ::cppu::BaseMutex()
149 , msApiName( r.msApiName )
150 , mxPool( r.mxPool )
151 , mrBHelper( m_aMutex )
152 {
153 }
154 
~SdStyleSheet()155 SdStyleSheet::~SdStyleSheet()
156 {
157 	delete pSet;
158 	pSet = NULL;	// damit nachfolgende Destruktoren eine Chance haben
159 }
160 
SetApiName(const OUString & rApiName)161 void SdStyleSheet::SetApiName( const OUString& rApiName )
162 {
163 	msApiName = rApiName;
164 }
165 
GetApiName() const166 rtl::OUString SdStyleSheet::GetApiName() const
167 {
168     if( msApiName.getLength() )
169         return msApiName;
170     else
171         return GetName();
172 }
173 
174 
Load(SvStream & rIn,sal_uInt16 nVersion)175 void SdStyleSheet::Load (SvStream& rIn, sal_uInt16 nVersion)
176 {
177 	SfxStyleSheetBase::Load(rIn, nVersion);
178 
179 	// Die Default-Maske war frueher 0xAFFE.
180 	// Aus dieser Default-Maske wurden die benoetigten Flags ausmaskiert.
181 	// Nun wurde das Flag SFXSTYLEBIT_READONLY eingefuehrt, was dazu
182 	// das alle StyleSheets read-only waren.
183 	// Da im Draw kein StyleSheet read-only sein soll, wird an dieser Stelle
184 	// das Flag zurueckgesetzt.
185 	nMask &= ~SFXSTYLEBIT_READONLY;
186 }
187 
188 /*************************************************************************
189 |*
190 |* Store
191 |*
192 \************************************************************************/
193 
Store(SvStream & rOut)194 void SdStyleSheet::Store(SvStream& rOut)
195 {
196 	SfxStyleSheetBase::Store(rOut);
197 }
198 
199 /*************************************************************************
200 |*
201 |* Parent setzen
202 |*
203 \************************************************************************/
204 
SetParent(const String & rParentName)205 sal_Bool SdStyleSheet::SetParent(const String& rParentName)
206 {
207 	sal_Bool bResult = sal_False;
208 
209 	if (SfxStyleSheet::SetParent(rParentName))
210 	{
211 		// PseudoStyleSheets haben keine eigenen ItemSets
212 		if (nFamily != SD_STYLE_FAMILY_PSEUDO)
213 		{
214 			if( rParentName.Len() )
215 			{
216 				SfxStyleSheetBase* pStyle = rPool.Find(rParentName, nFamily);
217 				if (pStyle)
218 				{
219 					bResult = sal_True;
220 					SfxItemSet& rParentSet = pStyle->GetItemSet();
221 					GetItemSet().SetParent(&rParentSet);
222 					Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
223 				}
224 			}
225 			else
226 			{
227 				bResult = sal_True;
228 				GetItemSet().SetParent(NULL);
229 				Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
230 			}
231 		}
232 		else
233 		{
234 			bResult = sal_True;
235 		}
236 	}
237 	return bResult;
238 }
239 
240 /*************************************************************************
241 |*
242 |* ItemSet ggfs. erzeugen und herausreichen
243 |*
244 \************************************************************************/
245 
GetItemSet()246 SfxItemSet& SdStyleSheet::GetItemSet()
247 {
248 	if (nFamily == SD_STYLE_FAMILY_GRAPHICS || nFamily == SD_STYLE_FAMILY_MASTERPAGE)
249 	{
250 		// ggfs. das ItemSet 'on demand' anlegen
251 		if (!pSet)
252 		{
253 			sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, 				XATTR_LINE_LAST,
254 										 XATTR_FILL_FIRST, 				XATTR_FILL_LAST,
255 
256 										SDRATTR_SHADOW_FIRST, 			SDRATTR_SHADOW_LAST,
257 										SDRATTR_TEXT_MINFRAMEHEIGHT,	SDRATTR_TEXT_CONTOURFRAME,
258 
259 										SDRATTR_TEXT_WORDWRAP,			SDRATTR_TEXT_AUTOGROWSIZE,
260 
261 										SDRATTR_EDGE_FIRST,				SDRATTR_EDGE_LAST,
262 										SDRATTR_MEASURE_FIRST, 			SDRATTR_MEASURE_LAST,
263 
264 										EE_PARA_START, 					EE_CHAR_END,
265 
266 										SDRATTR_XMLATTRIBUTES,			SDRATTR_TEXT_USEFIXEDCELLHEIGHT,
267 
268 										SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
269 										0, 0 };
270 
271 			pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable);
272 		}
273 
274 		return *pSet;
275 	}
276 
277 	else if( nFamily == SD_STYLE_FAMILY_CELL )
278 	{
279 		if (!pSet)
280 		{
281 			sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, 				XATTR_LINE_LAST,
282 										 XATTR_FILL_FIRST, 				XATTR_FILL_LAST,
283 
284 										SDRATTR_SHADOW_FIRST, 			SDRATTR_SHADOW_LAST,
285 										SDRATTR_TEXT_MINFRAMEHEIGHT,	SDRATTR_TEXT_CONTOURFRAME,
286 
287 										SDRATTR_TEXT_WORDWRAP,			SDRATTR_TEXT_AUTOGROWSIZE,
288 
289 										EE_PARA_START, 					EE_CHAR_END,
290 
291 										SDRATTR_TABLE_FIRST,			SDRATTR_TABLE_LAST,
292 										SDRATTR_XMLATTRIBUTES,			SDRATTR_XMLATTRIBUTES,
293 
294 										0, 0 };
295 
296 			pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable);
297 		}
298 
299 		return *pSet;
300 	}
301 
302 	// dies ist eine Stellvertretervorlage fuer die interne Vorlage des
303 	// aktuellen Praesentationslayouts: dessen ItemSet returnieren
304 	else
305 	{
306 //        return (GetRealStyleSheet()->GetItemSet());
307 
308 		SdStyleSheet* pSdSheet = GetRealStyleSheet();
309 
310 		if (pSdSheet)
311 		{
312 			return(pSdSheet->GetItemSet());
313 		}
314 		else
315 		{
316 			if (!pSet)
317 			{
318 				sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST,              XATTR_LINE_LAST,
319 											 XATTR_FILL_FIRST,              XATTR_FILL_LAST,
320 
321 											 SDRATTR_SHADOW_FIRST,          SDRATTR_SHADOW_LAST,
322 											 SDRATTR_TEXT_MINFRAMEHEIGHT,   SDRATTR_TEXT_CONTOURFRAME,
323 
324 											 SDRATTR_TEXT_WORDWRAP,			SDRATTR_TEXT_AUTOGROWSIZE,
325 
326 											 SDRATTR_EDGE_FIRST,            SDRATTR_EDGE_LAST,
327 											 SDRATTR_MEASURE_FIRST,         SDRATTR_MEASURE_LAST,
328 
329 											 EE_PARA_START,                 EE_CHAR_END,
330 
331 											SDRATTR_XMLATTRIBUTES,			SDRATTR_TEXT_USEFIXEDCELLHEIGHT,
332 
333 											SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
334 											 0, 0 };
335 
336 				pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable);
337 			}
338 
339 			return(*pSet);
340 		}
341 	}
342 }
343 
344 /*************************************************************************
345 |*
346 |* IsUsed(), eine Vorlage gilt als benutzt, wenn sie von eingefuegten Objekten
347 |*			 oder von benutzten Vorlagen referenziert wird
348 |*
349 \************************************************************************/
350 
IsUsed() const351 sal_Bool SdStyleSheet::IsUsed() const
352 {
353 	sal_Bool bResult = sal_False;
354 
355 	sal_uInt16 nListenerCount = GetListenerCount();
356 	if (nListenerCount > 0)
357 	{
358 		for (sal_uInt16 n = 0; n < nListenerCount; n++)
359 		{
360 			SfxListener* pListener = GetListener(n);
361 			if( pListener == this )
362 				continue;
363 
364 			// NULL-Pointer ist im Listener-Array erlaubt
365 			if (pListener && pListener->ISA(SdrAttrObj))
366 			{
367 				bResult = ((SdrAttrObj*)pListener)->IsInserted();
368 			}
369 			else if (pListener && pListener->ISA(SfxStyleSheet))
370 			{
371 				bResult = ((SfxStyleSheet*)pListener)->IsUsed();
372 			}
373 			if (bResult)
374 				break;
375 		}
376 	}
377 
378 	if( !bResult )
379 	{
380 		MutexGuard aGuard( mrBHelper.rMutex );
381 
382 		OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( XModifyListener::static_type() );
383 		if( pContainer )
384 		{
385 			Sequence< Reference< XInterface > > aModifyListeners( pContainer->getElements() );
386 			Reference< XInterface > *p = aModifyListeners.getArray();
387 			sal_Int32 nCount = aModifyListeners.getLength();
388 			while( nCount-- && !bResult )
389 			{
390 				Reference< XStyle > xStyle( *p++, UNO_QUERY );
391 				if( xStyle.is() )
392 					bResult = xStyle->isInUse();
393 			}
394 		}
395 	}
396 	return bResult;
397 }
398 
399 /*************************************************************************
400 |*
401 |* das StyleSheet ermitteln, fuer das dieses StyleSheet steht
402 |*
403 \************************************************************************/
404 
GetRealStyleSheet() const405 SdStyleSheet* SdStyleSheet::GetRealStyleSheet() const
406 {
407 	String aRealStyle;
408 	String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR ));
409 	SdStyleSheet* pRealStyle = NULL;
410 	SdDrawDocument* pDoc = ((SdStyleSheetPool&) rPool).GetDoc();
411 
412     ::sd::DrawViewShell* pDrawViewShell = 0;
413 
414     ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase* >( SfxViewShell::Current() );
415     if( pBase )
416         pDrawViewShell = dynamic_cast< ::sd::DrawViewShell* >( pBase->GetMainViewShell().get() );
417 
418     if (pDrawViewShell && pDrawViewShell->GetDoc() == pDoc)
419     {
420         SdPage* pPage = pDrawViewShell->getCurrentPage();
421 		if( pPage )
422 		{
423 	        aRealStyle = pPage->GetLayoutName();
424 		    // cut after seperator string
425 			aRealStyle.Erase(aRealStyle.Search(aSep) + aSep.Len());
426 		}
427     }
428 
429 	if (aRealStyle.Len() == 0)
430 	{
431 		SdPage* pPage = pDoc->GetSdPage(0, PK_STANDARD);
432 
433 		if (pPage)
434 		{
435 			aRealStyle = pDoc->GetSdPage(0, PK_STANDARD)->GetLayoutName();
436 		}
437 		else
438 		{
439 			// Noch keine Seite vorhanden
440 			// Dieses kann beim Aktualisieren vonDokumentvorlagen vorkommen
441 			SfxStyleSheetIterator aIter(&rPool, SD_STYLE_FAMILY_MASTERPAGE);
442 			SfxStyleSheetBase* pSheet = aIter.First();
443 			if( pSheet )
444 				aRealStyle = pSheet->GetName();
445 		}
446 
447 		aRealStyle.Erase(aRealStyle.Search(aSep) + aSep.Len());
448 	}
449 
450 	// jetzt vom Namen (landessprachlich angepasst) auf den internen
451 	// Namen (unabhaengig von der Landessprache) mappen
452 	String aInternalName;
453 
454 	if (aName == String(SdResId(STR_PSEUDOSHEET_TITLE)))
455 	{
456 		aInternalName = String(SdResId(STR_LAYOUT_TITLE));
457 	}
458 	else if (aName == String(SdResId(STR_PSEUDOSHEET_SUBTITLE)))
459 	{
460 		aInternalName = String(SdResId(STR_LAYOUT_SUBTITLE));
461 	}
462 	else if (aName == String(SdResId(STR_PSEUDOSHEET_BACKGROUND)))
463 	{
464 		aInternalName = String(SdResId(STR_LAYOUT_BACKGROUND));
465 	}
466 	else if (aName == String(SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS)))
467 	{
468 		aInternalName = String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS));
469 	}
470 	else if (aName == String(SdResId(STR_PSEUDOSHEET_NOTES)))
471 	{
472 		aInternalName = String(SdResId(STR_LAYOUT_NOTES));
473 	}
474 	else
475 	{
476 		String aOutlineStr(SdResId(STR_PSEUDOSHEET_OUTLINE));
477 		sal_uInt16 nPos = aName.Search(aOutlineStr);
478 		if (nPos != STRING_NOTFOUND)
479 		{
480 			String aNumStr(aName.Copy(aOutlineStr.Len()));
481 			aInternalName = String(SdResId(STR_LAYOUT_OUTLINE));
482 			aInternalName += aNumStr;
483 		}
484 	}
485 
486 	aRealStyle += aInternalName;
487 	pRealStyle = static_cast< SdStyleSheet* >( rPool.Find(aRealStyle, SD_STYLE_FAMILY_MASTERPAGE) );
488 
489 #ifdef DBG_UTIL
490 	if( !pRealStyle )
491 	{
492 		SfxStyleSheetIterator aIter(&rPool, SD_STYLE_FAMILY_MASTERPAGE);
493 		if( aIter.Count() > 0 )
494 			// StyleSheet not found, but pool already loaded
495 			DBG_ASSERT(pRealStyle, "Internal StyleSheet not found");
496 	}
497 #endif
498 
499 	return pRealStyle;
500 }
501 
502 /*************************************************************************
503 |*
504 |* das PseudoStyleSheet ermitteln, durch das dieses StyleSheet vertreten wird
505 |*
506 \************************************************************************/
507 
GetPseudoStyleSheet() const508 SdStyleSheet* SdStyleSheet::GetPseudoStyleSheet() const
509 {
510 	SdStyleSheet* pPseudoStyle = NULL;
511 	String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR ));
512 	String aStyleName(aName);
513 		// ohne Layoutnamen und Separator
514 	aStyleName.Erase(0, aStyleName.Search(aSep) + aSep.Len());
515 
516 	if (aStyleName == String(SdResId(STR_LAYOUT_TITLE)))
517 	{
518 		aStyleName = String(SdResId(STR_PSEUDOSHEET_TITLE));
519 	}
520 	else if (aStyleName == String(SdResId(STR_LAYOUT_SUBTITLE)))
521 	{
522 		aStyleName = String(SdResId(STR_PSEUDOSHEET_SUBTITLE));
523 	}
524 	else if (aStyleName == String(SdResId(STR_LAYOUT_BACKGROUND)))
525 	{
526 		aStyleName = String(SdResId(STR_PSEUDOSHEET_BACKGROUND));
527 	}
528 	else if (aStyleName == String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS)))
529 	{
530 		aStyleName = String(SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS));
531 	}
532 	else if (aStyleName == String(SdResId(STR_LAYOUT_NOTES)))
533 	{
534 		aStyleName = String(SdResId(STR_PSEUDOSHEET_NOTES));
535 	}
536 	else
537 	{
538 		String aOutlineStr((SdResId(STR_LAYOUT_OUTLINE)));
539 		sal_uInt16 nPos = aStyleName.Search(aOutlineStr);
540 		if (nPos != STRING_NOTFOUND)
541 		{
542 			String aNumStr(aStyleName.Copy(aOutlineStr.Len()));
543 			aStyleName = String(SdResId(STR_PSEUDOSHEET_OUTLINE));
544 			aStyleName += aNumStr;
545 		}
546 	}
547 
548 	pPseudoStyle = static_cast<SdStyleSheet*>(rPool.Find(aStyleName, SD_STYLE_FAMILY_PSEUDO));
549 	DBG_ASSERT(pPseudoStyle, "PseudoStyleSheet nicht gefunden");
550 
551 	return pPseudoStyle;
552 }
553 
554 
555 /*************************************************************************
556 |*
557 |* Notify
558 |*
559 \************************************************************************/
560 
Notify(SfxBroadcaster & rBC,const SfxHint & rHint)561 void SdStyleSheet::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
562 {
563 	// erstmal die Basisklassenfunktionalitaet
564 	SfxStyleSheet::Notify(rBC, rHint);
565 
566 	// wenn der Stellvertreter ein Notify bezueglich geaenderter Attribute
567 	// bekommt, sorgt er dafuer, dass das eigentlich gemeinte StyleSheet
568 	// broadcastet
569 	SfxSimpleHint* pSimple = PTR_CAST(SfxSimpleHint, &rHint);
570 	sal_uLong nId = pSimple == NULL ? 0 : pSimple->GetId();
571 	if (nId == SFX_HINT_DATACHANGED && nFamily == SD_STYLE_FAMILY_PSEUDO)
572 	{
573 		SdStyleSheet* pRealStyle = GetRealStyleSheet();
574 		if (pRealStyle)
575 			pRealStyle->Broadcast(rHint);
576 	}
577 }
578 
579 /*************************************************************************
580 |* AdjustToFontHeight passt die Bulletbreite und den linken Texteinzug
581 |* des uebergebenen ItemSets dessen Fonthoehe an. Die neuen Werte werden so
582 |* berechnet, dass das Verhaeltnis zur Fonthoehe so ist wie im StyleSheet.
583 |*
584 |* bOnlyMissingItems legt fest, ob lediglich nicht gesetzte Items ergaenzt
585 |* (sal_True) oder explizit gesetzte Items ueberschreiben werden sollen (sal_False)
586 |*
587 \************************************************************************/
588 
AdjustToFontHeight(SfxItemSet & rSet,sal_Bool bOnlyMissingItems)589 void SdStyleSheet::AdjustToFontHeight(SfxItemSet& rSet, sal_Bool bOnlyMissingItems)
590 {
591 	// Bulletbreite und Texteinzug an neue Fonthoehe
592 	// anpassen, wenn sie nicht explizit gesetzt wurden
593 	SfxStyleFamily eFamily = nFamily;
594 	String aStyleName(aName);
595 	if (eFamily == SD_STYLE_FAMILY_PSEUDO)
596 	{
597 		SfxStyleSheet* pRealStyle = GetRealStyleSheet();
598 		eFamily = pRealStyle->GetFamily();
599 		aStyleName = pRealStyle->GetName();
600 	}
601 
602 	if (eFamily == SD_STYLE_FAMILY_MASTERPAGE &&
603 		aStyleName.Search(String(SdResId(STR_LAYOUT_OUTLINE))) != STRING_NOTFOUND &&
604 		rSet.GetItemState(EE_CHAR_FONTHEIGHT) == SFX_ITEM_SET)
605 	{
606 		const SfxItemSet* pCurSet = &GetItemSet();
607 		sal_uInt32 nNewHeight = ((SvxFontHeightItem&)rSet.Get(EE_CHAR_FONTHEIGHT)).GetHeight();
608 		sal_uInt32 nOldHeight = ((SvxFontHeightItem&)pCurSet->Get(EE_CHAR_FONTHEIGHT)).GetHeight();
609 
610 		if (rSet.GetItemState(EE_PARA_BULLET) != SFX_ITEM_SET || !bOnlyMissingItems)
611 		{
612 			const SvxBulletItem& rBItem = (const SvxBulletItem&)pCurSet->Get(EE_PARA_BULLET);
613 			double fBulletFraction = double(rBItem.GetWidth()) / nOldHeight;
614 			SvxBulletItem aNewBItem(rBItem);
615 			aNewBItem.SetWidth((sal_uInt32)(fBulletFraction * nNewHeight));
616 			rSet.Put(aNewBItem);
617 		}
618 
619 		if (rSet.GetItemState(EE_PARA_LRSPACE) != SFX_ITEM_SET || !bOnlyMissingItems)
620 		{
621 			const SvxLRSpaceItem& rLRItem = (const SvxLRSpaceItem&)pCurSet->Get(EE_PARA_LRSPACE);
622 			double fIndentFraction = double(rLRItem.GetTxtLeft()) / nOldHeight;
623 			SvxLRSpaceItem aNewLRItem(rLRItem);
624 			aNewLRItem.SetTxtLeft((sal_uInt16)(fIndentFraction * nNewHeight));
625 			double fFirstIndentFraction = double(rLRItem.GetTxtFirstLineOfst()) / nOldHeight;
626 			aNewLRItem.SetTxtFirstLineOfst((short)(fFirstIndentFraction * nNewHeight));
627 			rSet.Put(aNewLRItem);
628 		}
629 
630 		if (rSet.GetItemState(EE_PARA_ULSPACE) != SFX_ITEM_SET || !bOnlyMissingItems)
631 		{
632 			const SvxULSpaceItem& rULItem = (const SvxULSpaceItem&)pCurSet->Get(EE_PARA_ULSPACE);
633 			SvxULSpaceItem aNewULItem(rULItem);
634 			double fLowerFraction = double(rULItem.GetLower()) / nOldHeight;
635 			aNewULItem.SetLower((sal_uInt16)(fLowerFraction * nNewHeight));
636 			double fUpperFraction = double(rULItem.GetUpper()) / nOldHeight;
637 			aNewULItem.SetUpper((sal_uInt16)(fUpperFraction * nNewHeight));
638 			rSet.Put(aNewULItem);
639 		}
640 	}
641 }
642 
643 // --------------------------------------------------------------------
644 
HasFollowSupport() const645 sal_Bool SdStyleSheet::HasFollowSupport() const
646 {
647 	return sal_False;
648 }
649 
650 // --------------------------------------------------------------------
651 
HasParentSupport() const652 sal_Bool SdStyleSheet::HasParentSupport() const
653 {
654 	return sal_True;
655 }
656 
657 // --------------------------------------------------------------------
658 
HasClearParentSupport() const659 sal_Bool SdStyleSheet::HasClearParentSupport() const
660 {
661 	return sal_True;
662 }
663 
664 // --------------------------------------------------------------------
665 
SetName(const UniString & rName)666 sal_Bool SdStyleSheet::SetName( const UniString& rName )
667 {
668 	return SfxStyleSheet::SetName( rName );
669 }
670 
671 // --------------------------------------------------------------------
672 
SetHelpId(const String & r,sal_uLong nId)673 void SdStyleSheet::SetHelpId( const String& r, sal_uLong nId )
674 {
675 	SfxStyleSheet::SetHelpId( r, nId );
676 
677 	if( (nId >= HID_PSEUDOSHEET_OUTLINE1) && ( nId <= HID_PSEUDOSHEET_OUTLINE9 ) )
678 	{
679 		msApiName = OUString( RTL_CONSTASCII_USTRINGPARAM("outline") );
680 		msApiName += OUString( (sal_Unicode)( '1' + (nId - HID_PSEUDOSHEET_OUTLINE1) ) );
681 	}
682 	else
683 	{
684 		static struct ApiNameMap
685 		{
686 			const sal_Char* mpApiName;
687 			sal_uInt32		mnApiNameLength;
688 			sal_uInt32		mnHelpId;
689 		}
690 		pApiNameMap[] =
691 		{
692 			{ RTL_CONSTASCII_STRINGPARAM( "title" ),			HID_PSEUDOSHEET_TITLE },
693 			{ RTL_CONSTASCII_STRINGPARAM( "subtitle" ),			HID_PSEUDOSHEET_SUBTITLE },
694 			{ RTL_CONSTASCII_STRINGPARAM( "background" ),		HID_PSEUDOSHEET_BACKGROUND },
695 			{ RTL_CONSTASCII_STRINGPARAM( "backgroundobjects" ),HID_PSEUDOSHEET_BACKGROUNDOBJECTS },
696 			{ RTL_CONSTASCII_STRINGPARAM( "notes" ),			HID_PSEUDOSHEET_NOTES },
697 			{ RTL_CONSTASCII_STRINGPARAM( "standard" ),			HID_STANDARD_STYLESHEET_NAME },
698 			{ RTL_CONSTASCII_STRINGPARAM( "objectwitharrow" ),	HID_POOLSHEET_OBJWITHARROW },
699 			{ RTL_CONSTASCII_STRINGPARAM( "objectwithshadow" ),	HID_POOLSHEET_OBJWITHSHADOW },
700 			{ RTL_CONSTASCII_STRINGPARAM( "objectwithoutfill" ),HID_POOLSHEET_OBJWITHOUTFILL },
701 			{ RTL_CONSTASCII_STRINGPARAM( "text" ),				HID_POOLSHEET_TEXT },
702 			{ RTL_CONSTASCII_STRINGPARAM( "textbody" ),			HID_POOLSHEET_TEXTBODY },
703 			{ RTL_CONSTASCII_STRINGPARAM( "textbodyjustfied" ),	HID_POOLSHEET_TEXTBODY_JUSTIFY },
704 			{ RTL_CONSTASCII_STRINGPARAM( "textbodyindent" ),	HID_POOLSHEET_TEXTBODY_INDENT },
705 			{ RTL_CONSTASCII_STRINGPARAM( "title" ),			HID_POOLSHEET_TITLE },
706 			{ RTL_CONSTASCII_STRINGPARAM( "title1" ),			HID_POOLSHEET_TITLE1 },
707 			{ RTL_CONSTASCII_STRINGPARAM( "title2" ),			HID_POOLSHEET_TITLE2 },
708 			{ RTL_CONSTASCII_STRINGPARAM( "headline" ),			HID_POOLSHEET_HEADLINE },
709 			{ RTL_CONSTASCII_STRINGPARAM( "headline1" ),		HID_POOLSHEET_HEADLINE1 },
710 			{ RTL_CONSTASCII_STRINGPARAM( "headline2" ),		HID_POOLSHEET_HEADLINE2 },
711 			{ RTL_CONSTASCII_STRINGPARAM( "measure" ),			HID_POOLSHEET_MEASURE },
712 			{ 0, 0, 0 }
713 		};
714 
715 		ApiNameMap* p = pApiNameMap;
716 		while( p->mpApiName )
717 		{
718 			if( nId == p->mnHelpId )
719 			{
720 				msApiName = OUString( p->mpApiName, p->mnApiNameLength, RTL_TEXTENCODING_ASCII_US );
721 				break;
722 			}
723 			p++;
724 		}
725 	}
726 }
727 
728 // --------------------------------------------------------------------
729 
GetFamilyString(SfxStyleFamily eFamily)730 OUString SdStyleSheet::GetFamilyString( SfxStyleFamily eFamily )
731 {
732 	switch( eFamily )
733 	{
734 	case SD_STYLE_FAMILY_CELL:
735 		return OUString( RTL_CONSTASCII_USTRINGPARAM( "cell" ) );
736 	default:
737 		DBG_ERROR( "SdStyleSheet::GetFamilyString(), illegal family!" );
738 	case SD_STYLE_FAMILY_GRAPHICS:
739 		return OUString( RTL_CONSTASCII_USTRINGPARAM( "graphics" ) );
740 	}
741 }
742 
743 // --------------------------------------------------------------------
744 
throwIfDisposed()745 void SdStyleSheet::throwIfDisposed() throw (RuntimeException)
746 {
747 	if( !mxPool.is() )
748 		throw DisposedException();
749 }
750 
751 // --------------------------------------------------------------------
752 
CreateEmptyUserStyle(SfxStyleSheetBasePool & rPool,SfxStyleFamily eFamily)753 SdStyleSheet* SdStyleSheet::CreateEmptyUserStyle( SfxStyleSheetBasePool& rPool, SfxStyleFamily eFamily )
754 {
755 	OUString aPrefix( RTL_CONSTASCII_USTRINGPARAM("user") );
756 	OUString aName;
757 	sal_Int32 nIndex = 1;
758 	do
759 	{
760 		aName = aPrefix + OUString::valueOf( nIndex++ );
761 	}
762 	while( rPool.Find( aName, eFamily ) != 0 );
763 
764 	return new SdStyleSheet(aName, rPool, eFamily, SFXSTYLEBIT_USERDEF);
765 }
766 
767 // --------------------------------------------------------------------
768 // XInterface
769 // --------------------------------------------------------------------
770 
771 /*
772 Any SAL_CALL SdStyleSheet::queryInterface( const ::com::sun::star::uno::Type& aType ) throw (RuntimeException)
773 {
774 	return SdStyleSheetBase::queryInterface( aType );
775 }
776 
777 // --------------------------------------------------------------------
778 
779 void SAL_CALL SdStyleSheet::acquire(  ) throw ()
780 {
781 	SdStyleSheetBase::acquire();
782 }
783 
784 // --------------------------------------------------------------------
785 */
release()786 void SAL_CALL SdStyleSheet::release(  ) throw ()
787 {
788     if (osl_decrementInterlockedCount( &m_refCount ) == 0)
789 	{
790         // restore reference count:
791         osl_incrementInterlockedCount( &m_refCount );
792         if (! mrBHelper.bDisposed) try
793 		{
794             dispose();
795         }
796         catch (RuntimeException const& exc)
797 		{ // don't break throw ()
798             OSL_ENSURE(
799                 false, OUStringToOString(
800                     exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
801             static_cast<void>(exc);
802         }
803         OSL_ASSERT( mrBHelper.bDisposed );
804         SdStyleSheetBase::release();
805     }
806 }
807 
808 // --------------------------------------------------------------------
809 // XWeak
810 // --------------------------------------------------------------------
811 /*
812 Reference< XAdapter > SAL_CALL SdStyleSheet::queryAdapter(  ) throw (RuntimeException)
813 {
814 	return SdStyleSheetBase::queryAdapter();
815 }
816 
817 // --------------------------------------------------------------------
818 // XTypeProvider
819 // --------------------------------------------------------------------
820 
821 Sequence< Type > SAL_CALL SdStyleSheet::getTypes(  ) throw (RuntimeException)
822 {
823 	return SdStyleSheetBase::getTypes();
824 }
825 
826 // --------------------------------------------------------------------
827 
828 Sequence< ::sal_Int8 > SAL_CALL SdStyleSheet::getImplementationId(  ) throw (RuntimeException)
829 {
830 	return SdStyleSheetBase::getImplementationId();
831 }
832 */
833 // --------------------------------------------------------------------
834 // XComponent
835 // --------------------------------------------------------------------
836 
dispose()837 void SAL_CALL SdStyleSheet::dispose(  ) throw (RuntimeException)
838 {
839 	ClearableMutexGuard aGuard( mrBHelper.rMutex );
840     if (!mrBHelper.bDisposed && !mrBHelper.bInDispose)
841     {
842         mrBHelper.bInDispose = sal_True;
843         aGuard.clear();
844         try
845         {
846             // side effect: keeping a reference to this
847             EventObject aEvt( static_cast< OWeakObject * >( this ) );
848             try
849             {
850                 mrBHelper.aLC.disposeAndClear( aEvt );
851                 disposing();
852             }
853             catch (...)
854             {
855                 MutexGuard aGuard2( mrBHelper.rMutex );
856                 // bDisposed and bInDispose must be set in this order:
857                 mrBHelper.bDisposed = sal_True;
858                 mrBHelper.bInDispose = sal_False;
859                 throw;
860             }
861             MutexGuard aGuard2( mrBHelper.rMutex );
862             // bDisposed and bInDispose must be set in this order:
863             mrBHelper.bDisposed = sal_True;
864             mrBHelper.bInDispose = sal_False;
865         }
866         catch (RuntimeException &)
867         {
868             throw;
869         }
870         catch (Exception & exc)
871         {
872             throw RuntimeException(
873                 OUString( RTL_CONSTASCII_USTRINGPARAM(
874                               "unexpected UNO exception caught: ") ) +
875                 exc.Message, Reference< XInterface >() );
876         }
877     }
878 }
879 
880 // --------------------------------------------------------------------
881 
disposing()882 void SdStyleSheet::disposing()
883 {
884 	mxPool.clear();
885 }
886 
887 // --------------------------------------------------------------------
888 
addEventListener(const Reference<XEventListener> & xListener)889 void SAL_CALL SdStyleSheet::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException)
890 {
891     ClearableMutexGuard aGuard( mrBHelper.rMutex );
892 	if (mrBHelper.bDisposed || mrBHelper.bInDispose)
893 	{
894         aGuard.clear();
895         EventObject aEvt( static_cast< OWeakObject * >( this ) );
896 		xListener->disposing( aEvt );
897 	}
898     else
899     {
900         mrBHelper.addListener( ::getCppuType( &xListener ), xListener );
901     }
902 }
903 
904 // --------------------------------------------------------------------
905 
removeEventListener(const Reference<XEventListener> & xListener)906 void SAL_CALL SdStyleSheet::removeEventListener( const Reference< XEventListener >& xListener  ) throw (RuntimeException)
907 {
908     mrBHelper.removeListener( ::getCppuType( &xListener ), xListener );
909 }
910 
911 //------------------------------------------------------------------------
912 // XModifyBroadcaster
913 //------------------------------------------------------------------------
914 
addModifyListener(const Reference<XModifyListener> & xListener)915 void SAL_CALL SdStyleSheet::addModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException)
916 {
917 	ClearableMutexGuard aGuard( mrBHelper.rMutex );
918 	if (mrBHelper.bDisposed || mrBHelper.bInDispose)
919 	{
920 		aGuard.clear();
921 		EventObject aEvt( static_cast< OWeakObject * >( this ) );
922 		xListener->disposing( aEvt );
923 	}
924 	else
925 	{
926 		if( !mpModifyListenerForewarder.get() )
927 			mpModifyListenerForewarder.reset( new ModifyListenerForewarder( this ) );
928 		mrBHelper.addListener( XModifyListener::static_type(), xListener );
929 	}
930 }
931 
932 //------------------------------------------------------------------------
933 
removeModifyListener(const Reference<XModifyListener> & xListener)934 void SAL_CALL SdStyleSheet::removeModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException)
935 {
936 	mrBHelper.removeListener( XModifyListener::static_type(), xListener );
937 }
938 
939 //------------------------------------------------------------------------
940 
notifyModifyListener()941 void SdStyleSheet::notifyModifyListener()
942 {
943 	MutexGuard aGuard( mrBHelper.rMutex );
944 
945 	OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( XModifyListener::static_type() );
946 	if( pContainer )
947 	{
948 		EventObject aEvt( static_cast< OWeakObject * >( this ) );
949 		pContainer->forEach<XModifyListener>( boost::bind( &XModifyListener::modified, _1, boost::cref( aEvt ) ) );
950 	}
951 }
952 
953 
954 // --------------------------------------------------------------------
955 // XServiceInfo
956 // --------------------------------------------------------------------
957 
getImplementationName()958 OUString SAL_CALL SdStyleSheet::getImplementationName() throw(RuntimeException)
959 {
960 	return OUString::createFromAscii( "SdStyleSheet" );
961 }
962 
963 // --------------------------------------------------------------------
964 
supportsService(const OUString & ServiceName)965 sal_Bool SAL_CALL SdStyleSheet::supportsService( const OUString& ServiceName ) throw(RuntimeException)
966 {
967 	return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
968 }
969 
970 // --------------------------------------------------------------------
971 
getSupportedServiceNames()972 Sequence< OUString > SAL_CALL SdStyleSheet::getSupportedServiceNames() throw(RuntimeException)
973 {
974 	Sequence< OUString > aNameSequence( 10 );
975 	OUString* pStrings = aNameSequence.getArray();
976 
977 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.Style" ) );
978 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.FillProperties" ) );
979 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.LineProperties" ) );
980 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.ShadowProperties" ) );
981 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.ConnectorProperties" ) );
982 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.MeasureProperties" ) );
983 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.ParagraphProperties" ) );
984 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.CharacterProperties" ) );
985 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.TextProperties" ) );
986 	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.Text" ) );
987 
988 	return aNameSequence;
989 }
990 
991 // --------------------------------------------------------------------
992 // XNamed
993 // --------------------------------------------------------------------
994 
getName()995 OUString SAL_CALL SdStyleSheet::getName() throw(RuntimeException)
996 {
997 	OGuard aGuard( Application::GetSolarMutex() );
998 	throwIfDisposed();
999 	return GetApiName();
1000 }
1001 
1002 // --------------------------------------------------------------------
1003 
setName(const OUString & rName)1004 void SAL_CALL SdStyleSheet::setName( const OUString& rName  ) throw(RuntimeException)
1005 {
1006 	OGuard aGuard( Application::GetSolarMutex() );
1007 	throwIfDisposed();
1008 
1009 	if( SetName( rName ) )
1010 	{
1011 		msApiName = rName;
1012 		Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
1013 	}
1014 }
1015 
1016 // --------------------------------------------------------------------
1017 // XStyle
1018 // --------------------------------------------------------------------
1019 
isUserDefined()1020 sal_Bool SAL_CALL SdStyleSheet::isUserDefined() throw(RuntimeException)
1021 {
1022 	OGuard aGuard( Application::GetSolarMutex() );
1023 	throwIfDisposed();
1024 	return IsUserDefined() ? sal_True : sal_False;
1025 }
1026 
1027 // --------------------------------------------------------------------
1028 
isInUse()1029 sal_Bool SAL_CALL SdStyleSheet::isInUse() throw(RuntimeException)
1030 {
1031 	OGuard aGuard( Application::GetSolarMutex() );
1032 	throwIfDisposed();
1033 	return IsUsed() ? sal_True : sal_False;
1034 }
1035 
1036 // --------------------------------------------------------------------
1037 
getParentStyle()1038 OUString SAL_CALL SdStyleSheet::getParentStyle() throw(RuntimeException)
1039 {
1040 	OGuard aGuard( Application::GetSolarMutex() );
1041 	throwIfDisposed();
1042 
1043 	if( GetParent().Len() )
1044 	{
1045 		SdStyleSheet* pParentStyle = static_cast< SdStyleSheet* >( mxPool->Find( GetParent(), nFamily ) );
1046 		if( pParentStyle )
1047 			return pParentStyle->msApiName;
1048 	}
1049 	return OUString();
1050 }
1051 
1052 // --------------------------------------------------------------------
1053 
setParentStyle(const OUString & rParentName)1054 void SAL_CALL SdStyleSheet::setParentStyle( const OUString& rParentName  ) throw(NoSuchElementException, RuntimeException)
1055 {
1056 	OGuard aGuard( Application::GetSolarMutex() );
1057 	throwIfDisposed();
1058 
1059 	if( rParentName.getLength() )
1060 	{
1061 		const SfxStyles& rStyles = mxPool->GetStyles();
1062 
1063 		for( SfxStyles::const_iterator iter( rStyles.begin() ); iter != rStyles.end(); iter++ )
1064 		{
1065 			SdStyleSheet* pStyle = static_cast< SdStyleSheet* >( (*iter).get() );
1066 			if( pStyle && (pStyle->nFamily == nFamily) && (pStyle->msApiName == rParentName) )
1067 			{
1068 				if( pStyle != this )
1069 					SetParent( pStyle->GetName() );
1070 				return;
1071 			}
1072 		}
1073 		throw NoSuchElementException();
1074 	}
1075 	else
1076 	{
1077 		SetParent( rParentName );
1078 	}
1079 }
1080 
1081 // --------------------------------------------------------------------
1082 // XPropertySet
1083 // --------------------------------------------------------------------
1084 
getPropertySetInfo()1085 Reference< XPropertySetInfo > SdStyleSheet::getPropertySetInfo() throw(RuntimeException)
1086 {
1087 	throwIfDisposed();
1088     static Reference< XPropertySetInfo > xInfo;
1089     if( !xInfo.is() )
1090         xInfo = GetStylePropertySet().getPropertySetInfo();
1091 	return xInfo;
1092 }
1093 
1094 // --------------------------------------------------------------------
1095 
setPropertyValue(const OUString & aPropertyName,const Any & aValue)1096 void SAL_CALL SdStyleSheet::setPropertyValue( const OUString& aPropertyName, const Any& aValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
1097 {
1098 	OGuard aGuard( Application::GetSolarMutex() );
1099 	throwIfDisposed();
1100 
1101 	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
1102 	if( pEntry == NULL )
1103 	{
1104 		throw UnknownPropertyException();
1105 	}
1106 	else
1107 	{
1108 		if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1109 			return; // not yet implemented for styles
1110 
1111 		if( pEntry->nWID == WID_STYLE_FAMILY )
1112 			throw PropertyVetoException();
1113 
1114 		if( (pEntry->nWID == EE_PARA_NUMBULLET) && (GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) )
1115 		{
1116 			String aStr;
1117 			const sal_uInt32 nTempHelpId = GetHelpId( aStr );
1118 
1119 			if( (nTempHelpId >= HID_PSEUDOSHEET_OUTLINE2) && (nTempHelpId <= HID_PSEUDOSHEET_OUTLINE9) )
1120 				return;
1121 		}
1122 
1123 		SfxItemSet &rStyleSet = GetItemSet();
1124 
1125 		if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1126 		{
1127 			BitmapMode eMode;
1128 			if( aValue >>= eMode )
1129 			{
1130 				rStyleSet.Put( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) );
1131 				rStyleSet.Put( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) );
1132 				return;
1133 			}
1134 			throw IllegalArgumentException();
1135 		}
1136 
1137 		SfxItemSet aSet( GetPool().GetPool(),	pEntry->nWID, pEntry->nWID);
1138 		aSet.Put( rStyleSet );
1139 
1140 		if( !aSet.Count() )
1141 		{
1142 			if( EE_PARA_NUMBULLET == pEntry->nWID )
1143 			{
1144 				Font aBulletFont;
1145 				SdStyleSheetPool::PutNumBulletItem( this, aBulletFont );
1146 				aSet.Put( rStyleSet );
1147 			}
1148 			else
1149 			{
1150 				aSet.Put( GetPool().GetPool().GetDefaultItem( pEntry->nWID ) );
1151 			}
1152 		}
1153 
1154 		if( pEntry->nMemberId == MID_NAME &&
1155 			( pEntry->nWID == XATTR_FILLBITMAP || pEntry->nWID == XATTR_FILLGRADIENT ||
1156 			  pEntry->nWID == XATTR_FILLHATCH || pEntry->nWID == XATTR_FILLFLOATTRANSPARENCE ||
1157 			  pEntry->nWID == XATTR_LINESTART || pEntry->nWID == XATTR_LINEEND || pEntry->nWID == XATTR_LINEDASH) )
1158 		{
1159 			OUString aTempName;
1160 			if(!(aValue >>= aTempName ))
1161 				throw IllegalArgumentException();
1162 
1163 			SvxShape::SetFillAttribute( pEntry->nWID, aTempName, aSet );
1164 		}
1165 		else if(!SvxUnoTextRangeBase::SetPropertyValueHelper( aSet, pEntry, aValue, aSet ))
1166 		{
1167 			SvxItemPropertySet_setPropertyValue( GetStylePropertySet(), pEntry, aValue, aSet );
1168 		}
1169 
1170 		rStyleSet.Put( aSet );
1171 		Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
1172 	}
1173 }
1174 
1175 // --------------------------------------------------------------------
1176 
getPropertyValue(const OUString & PropertyName)1177 Any SAL_CALL SdStyleSheet::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1178 {
1179 	OGuard aGuard( Application::GetSolarMutex() );
1180 
1181 	throwIfDisposed();
1182 
1183 	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
1184 	if( pEntry == NULL )
1185 	{
1186 		throw UnknownPropertyException();
1187 	}
1188 	else
1189 	{
1190 		Any aAny;
1191 
1192 		if( pEntry->nWID == WID_STYLE_FAMILY )
1193 		{
1194 			if( nFamily == SD_STYLE_FAMILY_MASTERPAGE )
1195 			{
1196 				const OUString aLayoutName( GetName() );
1197 				aAny <<= aLayoutName.copy( 0, aLayoutName.indexOf(OUString( RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR) ) ) );
1198 			}
1199 			else
1200 			{
1201 				aAny <<= GetFamilyString(nFamily);
1202 			}
1203 		}
1204 		else if( pEntry->nWID == WID_STYLE_DISPNAME )
1205 		{
1206 			aAny <<= maDisplayName;
1207 		}
1208 		else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1209 		{
1210 			aAny <<= sal_False;
1211 		}
1212 		else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1213 		{
1214 			SfxItemSet &rStyleSet = GetItemSet();
1215 
1216 			XFillBmpStretchItem* pStretchItem = (XFillBmpStretchItem*)rStyleSet.GetItem(XATTR_FILLBMP_STRETCH);
1217 			XFillBmpTileItem* pTileItem = (XFillBmpTileItem*)rStyleSet.GetItem(XATTR_FILLBMP_TILE);
1218 
1219 			if( pStretchItem && pTileItem )
1220 			{
1221 				if( pTileItem->GetValue() )
1222 					aAny <<= BitmapMode_REPEAT;
1223 				else if( pStretchItem->GetValue() )
1224 					aAny <<= BitmapMode_STRETCH;
1225 				else
1226 					aAny <<= BitmapMode_NO_REPEAT;
1227 			}
1228 		}
1229 		else
1230 		{
1231 			SfxItemSet aSet( GetPool().GetPool(),	pEntry->nWID, pEntry->nWID);
1232 
1233 			const SfxPoolItem* pItem;
1234 			SfxItemSet& rStyleSet = GetItemSet();
1235 
1236 			if( rStyleSet.GetItemState(	pEntry->nWID, sal_True, &pItem ) == SFX_ITEM_SET )
1237 				aSet.Put(  *pItem );
1238 
1239 			if( !aSet.Count() )
1240 				aSet.Put( GetPool().GetPool().GetDefaultItem( pEntry->nWID ) );
1241 
1242 			if(SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pEntry, aAny ))
1243 				return aAny;
1244 
1245 			// Hole Wert aus ItemSet
1246 			aAny = SvxItemPropertySet_getPropertyValue( GetStylePropertySet(),pEntry, aSet );
1247 		}
1248 
1249 		if( *pEntry->pType != aAny.getValueType() )
1250 		{
1251 			// since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
1252 			if( ( *pEntry->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) )
1253 			{
1254 				sal_Int32 nValue = 0;
1255 				aAny >>= nValue;
1256 				aAny <<= (sal_Int16)nValue;
1257 			}
1258 			else
1259 			{
1260 				DBG_ERROR("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" );
1261 			}
1262 		}
1263 
1264 		return aAny;
1265 	}
1266 }
1267 
1268 // --------------------------------------------------------------------
1269 
addPropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)1270 void SAL_CALL SdStyleSheet::addPropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
removePropertyChangeListener(const OUString &,const Reference<XPropertyChangeListener> &)1271 void SAL_CALL SdStyleSheet::removePropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
addVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)1272 void SAL_CALL SdStyleSheet::addVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
removeVetoableChangeListener(const OUString &,const Reference<XVetoableChangeListener> &)1273 void SAL_CALL SdStyleSheet::removeVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
1274 
1275 // --------------------------------------------------------------------
1276 // XPropertyState
1277 // --------------------------------------------------------------------
1278 
getPropertyState(const OUString & PropertyName)1279 PropertyState SAL_CALL SdStyleSheet::getPropertyState( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
1280 {
1281 	OGuard aGuard( Application::GetSolarMutex() );
1282 
1283 	throwIfDisposed();
1284 
1285 	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
1286 
1287 	if( pEntry == NULL )
1288 		throw UnknownPropertyException();
1289 
1290 	if( pEntry->nWID == WID_STYLE_FAMILY )
1291 	{
1292 		return PropertyState_DIRECT_VALUE;
1293 	}
1294 	else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1295 	{
1296 		return PropertyState_DEFAULT_VALUE;
1297 	}
1298 	else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1299 	{
1300 		const SfxItemSet& rSet = GetItemSet();
1301 
1302 		if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET ||
1303 			rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET )
1304 		{
1305 			return PropertyState_DIRECT_VALUE;
1306 		}
1307 		else
1308 		{
1309 			return PropertyState_AMBIGUOUS_VALUE;
1310 		}
1311 	}
1312 	else
1313 	{
1314 		SfxItemSet &rStyleSet = GetItemSet();
1315 
1316 		PropertyState eState;
1317 
1318 		switch( rStyleSet.GetItemState( pEntry->nWID, sal_False ) )
1319 		{
1320 		case SFX_ITEM_READONLY:
1321 		case SFX_ITEM_SET:
1322 			eState = PropertyState_DIRECT_VALUE;
1323 			break;
1324 		case SFX_ITEM_DEFAULT:
1325 			eState = PropertyState_DEFAULT_VALUE;
1326 			break;
1327 //		case SFX_ITEM_DONTCARE:
1328 //		case SFX_ITEM_DISABLED:
1329 		default:
1330 			eState = PropertyState_AMBIGUOUS_VALUE;
1331 			break;
1332 		}
1333 
1334 		// if a item is set, this doesn't mean we want it :)
1335 		if( ( PropertyState_DIRECT_VALUE == eState ) )
1336 		{
1337 			switch( pEntry->nWID )
1338 			{
1339 			case XATTR_FILLBITMAP:
1340 			case XATTR_FILLGRADIENT:
1341 			case XATTR_FILLHATCH:
1342 			case XATTR_FILLFLOATTRANSPARENCE:
1343 			case XATTR_LINEEND:
1344 			case XATTR_LINESTART:
1345 			case XATTR_LINEDASH:
1346 				{
1347 					NameOrIndex* pItem = (NameOrIndex*)rStyleSet.GetItem((sal_uInt16)pEntry->nWID);
1348 					if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) )
1349 						eState = PropertyState_DEFAULT_VALUE;
1350 				}
1351 			}
1352 		}
1353 
1354 		return eState;
1355 	}
1356 }
1357 
1358 // --------------------------------------------------------------------
1359 
getPropertyStates(const Sequence<OUString> & aPropertyName)1360 Sequence< PropertyState > SAL_CALL SdStyleSheet::getPropertyStates( const Sequence< OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException)
1361 {
1362 	OGuard aGuard( Application::GetSolarMutex() );
1363 
1364 	throwIfDisposed();
1365 
1366 	sal_Int32 nCount = aPropertyName.getLength();
1367 	const OUString* pNames = aPropertyName.getConstArray();
1368 
1369 	Sequence< PropertyState > aPropertyStateSequence( nCount );
1370 	PropertyState* pState = aPropertyStateSequence.getArray();
1371 
1372 	while( nCount-- )
1373 		*pState++ = getPropertyState( *pNames++ );
1374 
1375 	return aPropertyStateSequence;
1376 }
1377 
1378 // --------------------------------------------------------------------
1379 
setPropertyToDefault(const OUString & PropertyName)1380 void SAL_CALL SdStyleSheet::setPropertyToDefault( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
1381 {
1382 	OGuard aGuard( Application::GetSolarMutex() );
1383 
1384 	throwIfDisposed();
1385 
1386 	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
1387 	if( pEntry == NULL )
1388 		throw UnknownPropertyException();
1389 
1390 	SfxItemSet &rStyleSet = GetItemSet();
1391 
1392 	if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1393 	{
1394 		rStyleSet.ClearItem( XATTR_FILLBMP_STRETCH );
1395 		rStyleSet.ClearItem( XATTR_FILLBMP_TILE );
1396 	}
1397 	else
1398 	{
1399 		rStyleSet.ClearItem( pEntry->nWID );
1400 	}
1401 	Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
1402 }
1403 
1404 // --------------------------------------------------------------------
1405 
getPropertyDefault(const OUString & aPropertyName)1406 Any SAL_CALL SdStyleSheet::getPropertyDefault( const OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
1407 {
1408 	OGuard aGuard( Application::GetSolarMutex() );
1409 
1410 	throwIfDisposed();
1411 
1412 	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
1413 	if( pEntry == NULL )
1414 		throw UnknownPropertyException();
1415     Any aRet;
1416 	if( pEntry->nWID == WID_STYLE_FAMILY )
1417 	{
1418 		aRet <<= GetFamilyString(nFamily);
1419 	}
1420 	else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1421 	{
1422 		aRet <<= sal_False;
1423 	}
1424 	else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1425 	{
1426 		aRet <<= BitmapMode_REPEAT;
1427 	}
1428 	else
1429 	{
1430 		SfxItemPool& rMyPool = GetPool().GetPool();
1431 		SfxItemSet aSet( rMyPool,	pEntry->nWID, pEntry->nWID);
1432 		aSet.Put( rMyPool.GetDefaultItem( pEntry->nWID ) );
1433         aRet = SvxItemPropertySet_getPropertyValue( GetStylePropertySet(), pEntry, aSet );
1434 	}
1435     return aRet;
1436 }
1437 
1438 // --------------------------------------------------------------------
1439 
1440 /** this is used because our property map is not sorted yet */
getPropertyMapEntry(const OUString & rPropertyName) const1441 const SfxItemPropertySimpleEntry* SdStyleSheet::getPropertyMapEntry( const OUString& rPropertyName ) const throw()
1442 {
1443 	return GetStylePropertySet().getPropertyMapEntry(rPropertyName);
1444 }
1445 
1446