xref: /aoo41x/main/sd/source/core/stlsheet.cxx (revision 5b190011)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sd.hxx"

#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/style/XStyle.hpp>

#include <osl/mutex.hxx>
#include <vos/mutex.hxx>
#include <vcl/svapp.hxx>
#include <comphelper/serviceinfohelper.hxx>
#include <boost/bind.hpp>

#include "eetext.hxx"
#include <editeng/eeitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <svx/svdoattr.hxx>
#include <editeng/ulspitem.hxx>
#include <svl/smplhint.hxx>
#include <svl/itemset.hxx>

#include <svx/xflbmtit.hxx>
#include <svx/xflbstit.hxx>
#include <editeng/bulitem.hxx>
#include <editeng/lrspitem.hxx>
#include <svx/unoshprp.hxx>
#include <svx/unoshape.hxx>
#include <svx/svdpool.hxx>
#include "stlsheet.hxx"
#include "sdresid.hxx"
#include "sdpage.hxx"
#include "drawdoc.hxx"
#include "stlpool.hxx"
#include "glob.hrc"
#include "app.hrc"
#include "glob.hxx"
#include "helpids.h"
#include "../ui/inc/DrawViewShell.hxx"
#include "../ui/inc/ViewShellBase.hxx"

using ::rtl::OUString;
using ::osl::MutexGuard;
using ::osl::ClearableMutexGuard;
using ::cppu::OInterfaceContainerHelper;
using namespace ::vos;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::style;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::drawing;

#define WID_STYLE_DISPNAME	7998
#define WID_STYLE_FAMILY	7999

static SvxItemPropertySet& GetStylePropertySet()
{
	static const SfxItemPropertyMapEntry aFullPropertyMap_Impl[] =
	{
		{ RTL_CONSTASCII_STRINGPARAM("Family"),					WID_STYLE_FAMILY,		&::getCppuType((const OUString*)0),	PropertyAttribute::READONLY,	0},
		{ RTL_CONSTASCII_STRINGPARAM("UserDefinedAttributes"),	SDRATTR_XMLATTRIBUTES,	&XNameContainer::static_type(), 0,     0},
		{ RTL_CONSTASCII_STRINGPARAM("DisplayName"),			WID_STYLE_DISPNAME,		&::getCppuType((const OUString*)0),	PropertyAttribute::READONLY,	0},

		SVX_UNOEDIT_NUMBERING_PROPERTIE,
		SHADOW_PROPERTIES
		LINE_PROPERTIES
		LINE_PROPERTIES_START_END
		FILL_PROPERTIES
		EDGERADIUS_PROPERTIES
		TEXT_PROPERTIES_DEFAULTS
		CONNECTOR_PROPERTIES
		SPECIAL_DIMENSIONING_PROPERTIES_DEFAULTS
		{0,0,0,0,0,0}
	};

	static SvxItemPropertySet aPropSet( aFullPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
	return aPropSet;
}

class ModifyListenerForewarder : public SfxListener
{
public:
	ModifyListenerForewarder( SdStyleSheet* pStyleSheet );

	virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint);

private:
	SdStyleSheet* mpStyleSheet;
};

ModifyListenerForewarder::ModifyListenerForewarder( SdStyleSheet* pStyleSheet )
: mpStyleSheet( pStyleSheet )
{
	if( pStyleSheet )
	{
		SfxBroadcaster& rBC = static_cast< SfxBroadcaster& >( *pStyleSheet );
		StartListening( rBC );
	}
}

void ModifyListenerForewarder::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/)
{
	if( mpStyleSheet )
		mpStyleSheet->notifyModifyListener();
}

SdStyleSheet::SdStyleSheet(const OUString& rDisplayName, SfxStyleSheetBasePool& _rPool, SfxStyleFamily eFamily, sal_uInt16 _nMask)
: SdStyleSheetBase( UniString( rDisplayName ), _rPool, eFamily, _nMask)
, ::cppu::BaseMutex()
, msApiName( rDisplayName )
, mxPool( const_cast< SfxStyleSheetBasePool* >(&_rPool) )
, mrBHelper( m_aMutex )
{
}

SdStyleSheet::SdStyleSheet( const SdStyleSheet & r )
: SdStyleSheetBase( r )
, ::cppu::BaseMutex()
, msApiName( r.msApiName )
, mxPool( r.mxPool )
, mrBHelper( m_aMutex )
{
}

SdStyleSheet::~SdStyleSheet()
{
	delete pSet;
	pSet = NULL;	// damit nachfolgende Destruktoren eine Chance haben
}

void SdStyleSheet::SetApiName( const OUString& rApiName )
{
	msApiName = rApiName;
}

rtl::OUString SdStyleSheet::GetApiName() const
{
    if( msApiName.getLength() )
        return msApiName;
    else
        return GetName();
}


void SdStyleSheet::Load (SvStream& rIn, sal_uInt16 nVersion)
{
	SfxStyleSheetBase::Load(rIn, nVersion);

	// Die Default-Maske war frueher 0xAFFE.
	// Aus dieser Default-Maske wurden die benoetigten Flags ausmaskiert.
	// Nun wurde das Flag SFXSTYLEBIT_READONLY eingefuehrt, was dazu
	// das alle StyleSheets read-only waren.
	// Da im Draw kein StyleSheet read-only sein soll, wird an dieser Stelle
	// das Flag zurueckgesetzt.
	nMask &= ~SFXSTYLEBIT_READONLY;
}

/*************************************************************************
|*
|* Store
|*
\************************************************************************/

void SdStyleSheet::Store(SvStream& rOut)
{
	SfxStyleSheetBase::Store(rOut);
}

/*************************************************************************
|*
|* Parent setzen
|*
\************************************************************************/

sal_Bool SdStyleSheet::SetParent(const String& rParentName)
{
	sal_Bool bResult = sal_False;

	if (SfxStyleSheet::SetParent(rParentName))
	{
		// PseudoStyleSheets haben keine eigenen ItemSets
		if (nFamily != SD_STYLE_FAMILY_PSEUDO)
		{
			if( rParentName.Len() )
			{
				SfxStyleSheetBase* pStyle = rPool.Find(rParentName, nFamily);
				if (pStyle)
				{
					bResult = sal_True;
					SfxItemSet& rParentSet = pStyle->GetItemSet();
					GetItemSet().SetParent(&rParentSet);
					Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
				}
			}
			else
			{
				bResult = sal_True;
				GetItemSet().SetParent(NULL);
				Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) );
			}
		}
		else
		{
			bResult = sal_True;
		}
	}
	return bResult;
}

/*************************************************************************
|*
|* ItemSet ggfs. erzeugen und herausreichen
|*
\************************************************************************/

SfxItemSet& SdStyleSheet::GetItemSet()
{
	if (nFamily == SD_STYLE_FAMILY_GRAPHICS || nFamily == SD_STYLE_FAMILY_MASTERPAGE)
	{
		// ggfs. das ItemSet 'on demand' anlegen
		if (!pSet)
		{
			sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, 				XATTR_LINE_LAST,
										 XATTR_FILL_FIRST, 				XATTR_FILL_LAST,

										SDRATTR_SHADOW_FIRST, 			SDRATTR_SHADOW_LAST,
										SDRATTR_TEXT_MINFRAMEHEIGHT,	SDRATTR_TEXT_CONTOURFRAME,

										SDRATTR_TEXT_WORDWRAP,			SDRATTR_TEXT_AUTOGROWSIZE,

										SDRATTR_EDGE_FIRST,				SDRATTR_EDGE_LAST,
										SDRATTR_MEASURE_FIRST, 			SDRATTR_MEASURE_LAST,

										EE_PARA_START, 					EE_CHAR_END,

										SDRATTR_XMLATTRIBUTES,			SDRATTR_TEXT_USEFIXEDCELLHEIGHT,

										SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
										0, 0 };

			pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable);
		}

		return *pSet;
	}

	else if( nFamily == SD_STYLE_FAMILY_CELL )
	{
		if (!pSet)
		{
			sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, 				XATTR_LINE_LAST,
										 XATTR_FILL_FIRST, 				XATTR_FILL_LAST,

										SDRATTR_SHADOW_FIRST, 			SDRATTR_SHADOW_LAST,
										SDRATTR_TEXT_MINFRAMEHEIGHT,	SDRATTR_TEXT_CONTOURFRAME,

										SDRATTR_TEXT_WORDWRAP,			SDRATTR_TEXT_AUTOGROWSIZE,

										EE_PARA_START, 					EE_CHAR_END,

										SDRATTR_TABLE_FIRST,			SDRATTR_TABLE_LAST,
										SDRATTR_XMLATTRIBUTES,			SDRATTR_XMLATTRIBUTES,

										0, 0 };

			pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable);
		}

		return *pSet;
	}

	// dies ist eine Stellvertretervorlage fuer die interne Vorlage des
	// aktuellen Praesentationslayouts: dessen ItemSet returnieren
	else
	{
//        return (GetRealStyleSheet()->GetItemSet());

		SdStyleSheet* pSdSheet = GetRealStyleSheet();

		if (pSdSheet)
		{
			return(pSdSheet->GetItemSet());
		}
		else
		{
			if (!pSet)
			{
				sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST,              XATTR_LINE_LAST,
											 XATTR_FILL_FIRST,              XATTR_FILL_LAST,

											 SDRATTR_SHADOW_FIRST,          SDRATTR_SHADOW_LAST,
											 SDRATTR_TEXT_MINFRAMEHEIGHT,   SDRATTR_TEXT_CONTOURFRAME,

											 SDRATTR_TEXT_WORDWRAP,			SDRATTR_TEXT_AUTOGROWSIZE,

											 SDRATTR_EDGE_FIRST,            SDRATTR_EDGE_LAST,
											 SDRATTR_MEASURE_FIRST,         SDRATTR_MEASURE_LAST,

											 EE_PARA_START,                 EE_CHAR_END,

											SDRATTR_XMLATTRIBUTES,			SDRATTR_TEXT_USEFIXEDCELLHEIGHT,

											SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
											 0, 0 };

				pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable);
			}

			return(*pSet);
		}
	}
}

/*************************************************************************
|*
|* IsUsed(), eine Vorlage gilt als benutzt, wenn sie von eingefuegten Objekten
|*			 oder von benutzten Vorlagen referenziert wird
|*
\************************************************************************/

sal_Bool SdStyleSheet::IsUsed() const
{
	sal_Bool bResult = sal_False;

	sal_uInt16 nListenerCount = GetListenerCount();
	if (nListenerCount > 0)
	{
		for (sal_uInt16 n = 0; n < nListenerCount; n++)
		{
			SfxListener* pListener = GetListener(n);
			if( pListener == this )
				continue;

			// NULL-Pointer ist im Listener-Array erlaubt
			if (pListener && pListener->ISA(SdrAttrObj))
			{
				bResult = ((SdrAttrObj*)pListener)->IsInserted();
			}
			else if (pListener && pListener->ISA(SfxStyleSheet))
			{
				bResult = ((SfxStyleSheet*)pListener)->IsUsed();
			}
			if (bResult)
				break;
		}
	}

	if( !bResult )
	{
		MutexGuard aGuard( mrBHelper.rMutex );

		OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( XModifyListener::static_type() );
		if( pContainer )
		{
			Sequence< Reference< XInterface > > aModifyListeners( pContainer->getElements() );
			Reference< XInterface > *p = aModifyListeners.getArray();
			sal_Int32 nCount = aModifyListeners.getLength();
			while( nCount-- && !bResult )
			{
				Reference< XStyle > xStyle( *p++, UNO_QUERY );
				if( xStyle.is() )
					bResult = xStyle->isInUse();
			}
		}
	}
	return bResult;
}

/*************************************************************************
|*
|* das StyleSheet ermitteln, fuer das dieses StyleSheet steht
|*
\************************************************************************/

SdStyleSheet* SdStyleSheet::GetRealStyleSheet() const
{
	String aRealStyle;
	String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR ));
	SdStyleSheet* pRealStyle = NULL;
	SdDrawDocument* pDoc = ((SdStyleSheetPool&) rPool).GetDoc();

    ::sd::DrawViewShell* pDrawViewShell = 0;

    ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase* >( SfxViewShell::Current() );
    if( pBase )
        pDrawViewShell = dynamic_cast< ::sd::DrawViewShell* >( pBase->GetMainViewShell().get() );

    if (pDrawViewShell && pDrawViewShell->GetDoc() == pDoc)
    {
        SdPage* pPage = pDrawViewShell->getCurrentPage();
		if( pPage )
		{
	        aRealStyle = pPage->GetLayoutName();
		    // cut after seperator string
			aRealStyle.Erase(aRealStyle.Search(aSep) + aSep.Len());
		}
    }

	if (aRealStyle.Len() == 0)
	{
		SdPage* pPage = pDoc->GetSdPage(0, PK_STANDARD);

		if (pPage)
		{
			aRealStyle = pDoc->GetSdPage(0, PK_STANDARD)->GetLayoutName();
		}
		else
		{
			// Noch keine Seite vorhanden
			// Dieses kann beim Aktualisieren vonDokumentvorlagen vorkommen
			SfxStyleSheetIterator aIter(&rPool, SD_STYLE_FAMILY_MASTERPAGE);
			SfxStyleSheetBase* pSheet = aIter.First();
			if( pSheet )
				aRealStyle = pSheet->GetName();
		}

		aRealStyle.Erase(aRealStyle.Search(aSep) + aSep.Len());
	}

	// jetzt vom Namen (landessprachlich angepasst) auf den internen
	// Namen (unabhaengig von der Landessprache) mappen
	String aInternalName;

	if (aName == String(SdResId(STR_PSEUDOSHEET_TITLE)))
	{
		aInternalName = String(SdResId(STR_LAYOUT_TITLE));
	}
	else if (aName == String(SdResId(STR_PSEUDOSHEET_SUBTITLE)))
	{
		aInternalName = String(SdResId(STR_LAYOUT_SUBTITLE));
	}
	else if (aName == String(SdResId(STR_PSEUDOSHEET_BACKGROUND)))
	{
		aInternalName = String(SdResId(STR_LAYOUT_BACKGROUND));
	}
	else if (aName == String(SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS)))
	{
		aInternalName = String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS));
	}
	else if (aName == String(SdResId(STR_PSEUDOSHEET_NOTES)))
	{
		aInternalName = String(SdResId(STR_LAYOUT_NOTES));
	}
	else
	{
		String aOutlineStr(SdResId(STR_PSEUDOSHEET_OUTLINE));
		sal_uInt16 nPos = aName.Search(aOutlineStr);
		if (nPos != STRING_NOTFOUND)
		{
			String aNumStr(aName.Copy(aOutlineStr.Len()));
			aInternalName = String(SdResId(STR_LAYOUT_OUTLINE));
			aInternalName += aNumStr;
		}
	}

	aRealStyle += aInternalName;
	pRealStyle = static_cast< SdStyleSheet* >( rPool.Find(aRealStyle, SD_STYLE_FAMILY_MASTERPAGE) );

#ifdef DBG_UTIL
	if( !pRealStyle )
	{
		SfxStyleSheetIterator aIter(&rPool, SD_STYLE_FAMILY_MASTERPAGE);
		if( aIter.Count() > 0 )
			// StyleSheet not found, but pool already loaded
			DBG_ASSERT(pRealStyle, "Internal StyleSheet not found");
	}
#endif

	return pRealStyle;
}

/*************************************************************************
|*
|* das PseudoStyleSheet ermitteln, durch das dieses StyleSheet vertreten wird
|*
\************************************************************************/

SdStyleSheet* SdStyleSheet::GetPseudoStyleSheet() const
{
	SdStyleSheet* pPseudoStyle = NULL;
	String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR ));
	String aStyleName(aName);
		// ohne Layoutnamen und Separator
	aStyleName.Erase(0, aStyleName.Search(aSep) + aSep.Len());

	if (aStyleName == String(SdResId(STR_LAYOUT_TITLE)))
	{
		aStyleName = String(SdResId(STR_PSEUDOSHEET_TITLE));
	}
	else if (aStyleName == String(SdResId(STR_LAYOUT_SUBTITLE)))
	{
		aStyleName = String(SdResId(STR_PSEUDOSHEET_SUBTITLE));
	}
	else if (aStyleName == String(SdResId(STR_LAYOUT_BACKGROUND)))
	{
		aStyleName = String(SdResId(STR_PSEUDOSHEET_BACKGROUND));
	}
	else if (aStyleName == String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS)))
	{
		aStyleName = String(SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS));
	}
	else if (aStyleName == String(SdResId(STR_LAYOUT_NOTES)))
	{
		aStyleName = String(SdResId(STR_PSEUDOSHEET_NOTES));
	}
	else
	{
		String aOutlineStr((SdResId(STR_LAYOUT_OUTLINE)));
		sal_uInt16 nPos = aStyleName.Search(aOutlineStr);
		if (nPos != STRING_NOTFOUND)
		{
			String aNumStr(aStyleName.Copy(aOutlineStr.Len()));
			aStyleName = String(SdResId(STR_PSEUDOSHEET_OUTLINE));
			aStyleName += aNumStr;
		}
	}

	pPseudoStyle = static_cast<SdStyleSheet*>(rPool.Find(aStyleName, SD_STYLE_FAMILY_PSEUDO));
	DBG_ASSERT(pPseudoStyle, "PseudoStyleSheet nicht gefunden");

	return pPseudoStyle;
}


/*************************************************************************
|*
|* Notify
|*
\************************************************************************/

void SdStyleSheet::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
{
	// erstmal die Basisklassenfunktionalitaet
	SfxStyleSheet::Notify(rBC, rHint);

	// wenn der Stellvertreter ein Notify bezueglich geaenderter Attribute
	// bekommt, sorgt er dafuer, dass das eigentlich gemeinte StyleSheet
	// broadcastet
	SfxSimpleHint* pSimple = PTR_CAST(SfxSimpleHint, &rHint);
	sal_uLong nId = pSimple == NULL ? 0 : pSimple->GetId();
	if (nId == SFX_HINT_DATACHANGED && nFamily == SD_STYLE_FAMILY_PSEUDO)
	{
		SdStyleSheet* pRealStyle = GetRealStyleSheet();
		if (pRealStyle)
			pRealStyle->Broadcast(rHint);
	}
}

/*************************************************************************
|* AdjustToFontHeight passt die Bulletbreite und den linken Texteinzug
|* des uebergebenen ItemSets dessen Fonthoehe an. Die neuen Werte werden so
|* berechnet, dass das Verhaeltnis zur Fonthoehe so ist wie im StyleSheet.
|*
|* bOnlyMissingItems legt fest, ob lediglich nicht gesetzte Items ergaenzt
|* (sal_True) oder explizit gesetzte Items ueberschreiben werden sollen (sal_False)
|*
\************************************************************************/

void SdStyleSheet::AdjustToFontHeight(SfxItemSet& rSet, sal_Bool bOnlyMissingItems)
{
	// Bulletbreite und Texteinzug an neue Fonthoehe
	// anpassen, wenn sie nicht explizit gesetzt wurden
	SfxStyleFamily eFamily = nFamily;
	String aStyleName(aName);
	if (eFamily == SD_STYLE_FAMILY_PSEUDO)
	{
		SfxStyleSheet* pRealStyle = GetRealStyleSheet();
		eFamily = pRealStyle->GetFamily();
		aStyleName = pRealStyle->GetName();
	}

	if (eFamily == SD_STYLE_FAMILY_MASTERPAGE &&
		aStyleName.Search(String(SdResId(STR_LAYOUT_OUTLINE))) != STRING_NOTFOUND &&
		rSet.GetItemState(EE_CHAR_FONTHEIGHT) == SFX_ITEM_SET)
	{
		const SfxItemSet* pCurSet = &GetItemSet();
		sal_uInt32 nNewHeight = ((SvxFontHeightItem&)rSet.Get(EE_CHAR_FONTHEIGHT)).GetHeight();
		sal_uInt32 nOldHeight = ((SvxFontHeightItem&)pCurSet->Get(EE_CHAR_FONTHEIGHT)).GetHeight();

		if (rSet.GetItemState(EE_PARA_BULLET) != SFX_ITEM_SET || !bOnlyMissingItems)
		{
			const SvxBulletItem& rBItem = (const SvxBulletItem&)pCurSet->Get(EE_PARA_BULLET);
			double fBulletFraction = double(rBItem.GetWidth()) / nOldHeight;
			SvxBulletItem aNewBItem(rBItem);
			aNewBItem.SetWidth((sal_uInt32)(fBulletFraction * nNewHeight));
			rSet.Put(aNewBItem);
		}

		if (rSet.GetItemState(EE_PARA_LRSPACE) != SFX_ITEM_SET || !bOnlyMissingItems)
		{
			const SvxLRSpaceItem& rLRItem = (const SvxLRSpaceItem&)pCurSet->Get(EE_PARA_LRSPACE);
			double fIndentFraction = double(rLRItem.GetTxtLeft()) / nOldHeight;
			SvxLRSpaceItem aNewLRItem(rLRItem);
			aNewLRItem.SetTxtLeft((sal_uInt16)(fIndentFraction * nNewHeight));
			double fFirstIndentFraction = double(rLRItem.GetTxtFirstLineOfst()) / nOldHeight;
			aNewLRItem.SetTxtFirstLineOfst((short)(fFirstIndentFraction * nNewHeight));
			rSet.Put(aNewLRItem);
		}

		if (rSet.GetItemState(EE_PARA_ULSPACE) != SFX_ITEM_SET || !bOnlyMissingItems)
		{
			const SvxULSpaceItem& rULItem = (const SvxULSpaceItem&)pCurSet->Get(EE_PARA_ULSPACE);
			SvxULSpaceItem aNewULItem(rULItem);
			double fLowerFraction = double(rULItem.GetLower()) / nOldHeight;
			aNewULItem.SetLower((sal_uInt16)(fLowerFraction * nNewHeight));
			double fUpperFraction = double(rULItem.GetUpper()) / nOldHeight;
			aNewULItem.SetUpper((sal_uInt16)(fUpperFraction * nNewHeight));
			rSet.Put(aNewULItem);
		}
	}
}

// --------------------------------------------------------------------

sal_Bool SdStyleSheet::HasFollowSupport() const
{
	return sal_False;
}

// --------------------------------------------------------------------

sal_Bool SdStyleSheet::HasParentSupport() const
{
	return sal_True;
}

// --------------------------------------------------------------------

sal_Bool SdStyleSheet::HasClearParentSupport() const
{
	return sal_True;
}

// --------------------------------------------------------------------

sal_Bool SdStyleSheet::SetName( const UniString& rName )
{
	return SfxStyleSheet::SetName( rName );
}

// --------------------------------------------------------------------

void SdStyleSheet::SetHelpId( const String& r, sal_uLong nId )
{
	SfxStyleSheet::SetHelpId( r, nId );

	if( (nId >= HID_PSEUDOSHEET_OUTLINE1) && ( nId <= HID_PSEUDOSHEET_OUTLINE9 ) )
	{
		msApiName = OUString( RTL_CONSTASCII_USTRINGPARAM("outline") );
		msApiName += OUString( (sal_Unicode)( '1' + (nId - HID_PSEUDOSHEET_OUTLINE1) ) );
	}
	else
	{
		static struct ApiNameMap
		{
			const sal_Char* mpApiName;
			sal_uInt32		mnApiNameLength;
			sal_uInt32		mnHelpId;
		}
		pApiNameMap[] =
		{
			{ RTL_CONSTASCII_STRINGPARAM( "title" ),			HID_PSEUDOSHEET_TITLE },
			{ RTL_CONSTASCII_STRINGPARAM( "subtitle" ),			HID_PSEUDOSHEET_SUBTITLE },
			{ RTL_CONSTASCII_STRINGPARAM( "background" ),		HID_PSEUDOSHEET_BACKGROUND },
			{ RTL_CONSTASCII_STRINGPARAM( "backgroundobjects" ),HID_PSEUDOSHEET_BACKGROUNDOBJECTS },
			{ RTL_CONSTASCII_STRINGPARAM( "notes" ),			HID_PSEUDOSHEET_NOTES },
			{ RTL_CONSTASCII_STRINGPARAM( "standard" ),			HID_STANDARD_STYLESHEET_NAME },
			{ RTL_CONSTASCII_STRINGPARAM( "objectwitharrow" ),	HID_POOLSHEET_OBJWITHARROW },
			{ RTL_CONSTASCII_STRINGPARAM( "objectwithshadow" ),	HID_POOLSHEET_OBJWITHSHADOW },
			{ RTL_CONSTASCII_STRINGPARAM( "objectwithoutfill" ),HID_POOLSHEET_OBJWITHOUTFILL },
			{ RTL_CONSTASCII_STRINGPARAM( "text" ),				HID_POOLSHEET_TEXT },
			{ RTL_CONSTASCII_STRINGPARAM( "textbody" ),			HID_POOLSHEET_TEXTBODY },
			{ RTL_CONSTASCII_STRINGPARAM( "textbodyjustfied" ),	HID_POOLSHEET_TEXTBODY_JUSTIFY },
			{ RTL_CONSTASCII_STRINGPARAM( "textbodyindent" ),	HID_POOLSHEET_TEXTBODY_INDENT },
			{ RTL_CONSTASCII_STRINGPARAM( "title" ),			HID_POOLSHEET_TITLE },
			{ RTL_CONSTASCII_STRINGPARAM( "title1" ),			HID_POOLSHEET_TITLE1 },
			{ RTL_CONSTASCII_STRINGPARAM( "title2" ),			HID_POOLSHEET_TITLE2 },
			{ RTL_CONSTASCII_STRINGPARAM( "headline" ),			HID_POOLSHEET_HEADLINE },
			{ RTL_CONSTASCII_STRINGPARAM( "headline1" ),		HID_POOLSHEET_HEADLINE1 },
			{ RTL_CONSTASCII_STRINGPARAM( "headline2" ),		HID_POOLSHEET_HEADLINE2 },
			{ RTL_CONSTASCII_STRINGPARAM( "measure" ),			HID_POOLSHEET_MEASURE },
			{ 0, 0, 0 }
		};

		ApiNameMap* p = pApiNameMap;
		while( p->mpApiName )
		{
			if( nId == p->mnHelpId )
			{
				msApiName = OUString( p->mpApiName, p->mnApiNameLength, RTL_TEXTENCODING_ASCII_US );
				break;
			}
			p++;
		}
	}
}

// --------------------------------------------------------------------

OUString SdStyleSheet::GetFamilyString( SfxStyleFamily eFamily )
{
	switch( eFamily )
	{
	case SD_STYLE_FAMILY_CELL:
		return OUString( RTL_CONSTASCII_USTRINGPARAM( "cell" ) );
	default:
		DBG_ERROR( "SdStyleSheet::GetFamilyString(), illegal family!" );
	case SD_STYLE_FAMILY_GRAPHICS:
		return OUString( RTL_CONSTASCII_USTRINGPARAM( "graphics" ) );
	}
}

// --------------------------------------------------------------------

void SdStyleSheet::throwIfDisposed() throw (RuntimeException)
{
	if( !mxPool.is() )
		throw DisposedException();
}

// --------------------------------------------------------------------

SdStyleSheet* SdStyleSheet::CreateEmptyUserStyle( SfxStyleSheetBasePool& rPool, SfxStyleFamily eFamily )
{
	OUString aPrefix( RTL_CONSTASCII_USTRINGPARAM("user") );
	OUString aName;
	sal_Int32 nIndex = 1;
	do
	{
		aName = aPrefix + OUString::valueOf( nIndex++ );
	}
	while( rPool.Find( aName, eFamily ) != 0 );

	return new SdStyleSheet(aName, rPool, eFamily, SFXSTYLEBIT_USERDEF);
}

// --------------------------------------------------------------------
// XInterface
// --------------------------------------------------------------------

/*
Any SAL_CALL SdStyleSheet::queryInterface( const ::com::sun::star::uno::Type& aType ) throw (RuntimeException)
{
	return SdStyleSheetBase::queryInterface( aType );
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::acquire(  ) throw ()
{
	SdStyleSheetBase::acquire();
}

// --------------------------------------------------------------------
*/
void SAL_CALL SdStyleSheet::release(  ) throw ()
{
    if (osl_decrementInterlockedCount( &m_refCount ) == 0)
	{
        // restore reference count:
        osl_incrementInterlockedCount( &m_refCount );
        if (! mrBHelper.bDisposed) try
		{
            dispose();
        }
        catch (RuntimeException const& exc)
		{ // don't break throw ()
            OSL_ENSURE(
                false, OUStringToOString(
                    exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
            static_cast<void>(exc);
        }
        OSL_ASSERT( mrBHelper.bDisposed );
        SdStyleSheetBase::release();
    }
}

// --------------------------------------------------------------------
// XWeak
// --------------------------------------------------------------------
/*
Reference< XAdapter > SAL_CALL SdStyleSheet::queryAdapter(  ) throw (RuntimeException)
{
	return SdStyleSheetBase::queryAdapter();
}

// --------------------------------------------------------------------
// XTypeProvider
// --------------------------------------------------------------------

Sequence< Type > SAL_CALL SdStyleSheet::getTypes(  ) throw (RuntimeException)
{
	return SdStyleSheetBase::getTypes();
}

// --------------------------------------------------------------------

Sequence< ::sal_Int8 > SAL_CALL SdStyleSheet::getImplementationId(  ) throw (RuntimeException)
{
	return SdStyleSheetBase::getImplementationId();
}
*/
// --------------------------------------------------------------------
// XComponent
// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::dispose(  ) throw (RuntimeException)
{
	ClearableMutexGuard aGuard( mrBHelper.rMutex );
    if (!mrBHelper.bDisposed && !mrBHelper.bInDispose)
    {
        mrBHelper.bInDispose = sal_True;
        aGuard.clear();
        try
        {
            // side effect: keeping a reference to this
            EventObject aEvt( static_cast< OWeakObject * >( this ) );
            try
            {
                mrBHelper.aLC.disposeAndClear( aEvt );
                disposing();
            }
            catch (...)
            {
                MutexGuard aGuard2( mrBHelper.rMutex );
                // bDisposed and bInDispose must be set in this order:
                mrBHelper.bDisposed = sal_True;
                mrBHelper.bInDispose = sal_False;
                throw;
            }
            MutexGuard aGuard2( mrBHelper.rMutex );
            // bDisposed and bInDispose must be set in this order:
            mrBHelper.bDisposed = sal_True;
            mrBHelper.bInDispose = sal_False;
        }
        catch (RuntimeException &)
        {
            throw;
        }
        catch (Exception & exc)
        {
            throw RuntimeException(
                OUString( RTL_CONSTASCII_USTRINGPARAM(
                              "unexpected UNO exception caught: ") ) +
                exc.Message, Reference< XInterface >() );
        }
    }
}

// --------------------------------------------------------------------

void SdStyleSheet::disposing()
{
	mxPool.clear();
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException)
{
    ClearableMutexGuard aGuard( mrBHelper.rMutex );
	if (mrBHelper.bDisposed || mrBHelper.bInDispose)
	{
        aGuard.clear();
        EventObject aEvt( static_cast< OWeakObject * >( this ) );
		xListener->disposing( aEvt );
	}
    else
    {
        mrBHelper.addListener( ::getCppuType( &xListener ), xListener );
    }
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::removeEventListener( const Reference< XEventListener >& xListener  ) throw (RuntimeException)
{
    mrBHelper.removeListener( ::getCppuType( &xListener ), xListener );
}

//------------------------------------------------------------------------
// XModifyBroadcaster
//------------------------------------------------------------------------

void SAL_CALL SdStyleSheet::addModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException)
{
	ClearableMutexGuard aGuard( mrBHelper.rMutex );
	if (mrBHelper.bDisposed || mrBHelper.bInDispose)
	{
		aGuard.clear();
		EventObject aEvt( static_cast< OWeakObject * >( this ) );
		xListener->disposing( aEvt );
	}
	else
	{
		if( !mpModifyListenerForewarder.get() )
			mpModifyListenerForewarder.reset( new ModifyListenerForewarder( this ) );
		mrBHelper.addListener( XModifyListener::static_type(), xListener );
	}
}

//------------------------------------------------------------------------

void SAL_CALL SdStyleSheet::removeModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException)
{
	mrBHelper.removeListener( XModifyListener::static_type(), xListener );
}

//------------------------------------------------------------------------

void SdStyleSheet::notifyModifyListener()
{
	MutexGuard aGuard( mrBHelper.rMutex );

	OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( XModifyListener::static_type() );
	if( pContainer )
	{
		EventObject aEvt( static_cast< OWeakObject * >( this ) );
		pContainer->forEach<XModifyListener>( boost::bind( &XModifyListener::modified, _1, boost::cref( aEvt ) ) );
	}
}


// --------------------------------------------------------------------
// XServiceInfo
// --------------------------------------------------------------------

OUString SAL_CALL SdStyleSheet::getImplementationName() throw(RuntimeException)
{
	return OUString::createFromAscii( "SdStyleSheet" );
}

// --------------------------------------------------------------------

sal_Bool SAL_CALL SdStyleSheet::supportsService( const OUString& ServiceName ) throw(RuntimeException)
{
	return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
}

// --------------------------------------------------------------------

Sequence< OUString > SAL_CALL SdStyleSheet::getSupportedServiceNames() throw(RuntimeException)
{
	Sequence< OUString > aNameSequence( 10 );
	OUString* pStrings = aNameSequence.getArray();

	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.Style" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.FillProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.LineProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.ShadowProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.ConnectorProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.MeasureProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.ParagraphProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.CharacterProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.TextProperties" ) );
	*pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.Text" ) );

	return aNameSequence;
}

// --------------------------------------------------------------------
// XNamed
// --------------------------------------------------------------------

OUString SAL_CALL SdStyleSheet::getName() throw(RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();
	return GetApiName();
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::setName( const OUString& rName  ) throw(RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();

	if( SetName( rName ) )
	{
		msApiName = rName;
		Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
	}
}

// --------------------------------------------------------------------
// XStyle
// --------------------------------------------------------------------

sal_Bool SAL_CALL SdStyleSheet::isUserDefined() throw(RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();
	return IsUserDefined() ? sal_True : sal_False;
}

// --------------------------------------------------------------------

sal_Bool SAL_CALL SdStyleSheet::isInUse() throw(RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();
	return IsUsed() ? sal_True : sal_False;
}

// --------------------------------------------------------------------

OUString SAL_CALL SdStyleSheet::getParentStyle() throw(RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();

	if( GetParent().Len() )
	{
		SdStyleSheet* pParentStyle = static_cast< SdStyleSheet* >( mxPool->Find( GetParent(), nFamily ) );
		if( pParentStyle )
			return pParentStyle->msApiName;
	}
	return OUString();
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::setParentStyle( const OUString& rParentName  ) throw(NoSuchElementException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();

	if( rParentName.getLength() )
	{
		const SfxStyles& rStyles = mxPool->GetStyles();

		for( SfxStyles::const_iterator iter( rStyles.begin() ); iter != rStyles.end(); iter++ )
		{
			SdStyleSheet* pStyle = static_cast< SdStyleSheet* >( (*iter).get() );
			if( pStyle && (pStyle->nFamily == nFamily) && (pStyle->msApiName == rParentName) )
			{
				if( pStyle != this )
					SetParent( pStyle->GetName() );
				return;
			}
		}
		throw NoSuchElementException();
	}
	else
	{
		SetParent( rParentName );
	}
}

// --------------------------------------------------------------------
// XPropertySet
// --------------------------------------------------------------------

Reference< XPropertySetInfo > SdStyleSheet::getPropertySetInfo() throw(RuntimeException)
{
	throwIfDisposed();
    static Reference< XPropertySetInfo > xInfo;
    if( !xInfo.is() )
        xInfo = GetStylePropertySet().getPropertySetInfo();
	return xInfo;
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::setPropertyValue( const OUString& aPropertyName, const Any& aValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );
	throwIfDisposed();

	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
	if( pEntry == NULL )
	{
		throw UnknownPropertyException();
	}
	else
	{
		if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
			return; // not yet implemented for styles

		if( pEntry->nWID == WID_STYLE_FAMILY )
			throw PropertyVetoException();

		if( (pEntry->nWID == EE_PARA_NUMBULLET) && (GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) )
		{
			String aStr;
			const sal_uInt32 nTempHelpId = GetHelpId( aStr );

			if( (nTempHelpId >= HID_PSEUDOSHEET_OUTLINE2) && (nTempHelpId <= HID_PSEUDOSHEET_OUTLINE9) )
				return;
		}

		SfxItemSet &rStyleSet = GetItemSet();

		if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
		{
			BitmapMode eMode;
			if( aValue >>= eMode )
			{
				rStyleSet.Put( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) );
				rStyleSet.Put( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) );
				return;
			}
			throw IllegalArgumentException();
		}

		SfxItemSet aSet( GetPool().GetPool(),	pEntry->nWID, pEntry->nWID);
		aSet.Put( rStyleSet );

		if( !aSet.Count() )
		{
			if( EE_PARA_NUMBULLET == pEntry->nWID )
			{
				Font aBulletFont;
				SdStyleSheetPool::PutNumBulletItem( this, aBulletFont );
				aSet.Put( rStyleSet );
			}
			else
			{
				aSet.Put( GetPool().GetPool().GetDefaultItem( pEntry->nWID ) );
			}
		}

		if( pEntry->nMemberId == MID_NAME &&
			( pEntry->nWID == XATTR_FILLBITMAP || pEntry->nWID == XATTR_FILLGRADIENT ||
			  pEntry->nWID == XATTR_FILLHATCH || pEntry->nWID == XATTR_FILLFLOATTRANSPARENCE ||
			  pEntry->nWID == XATTR_LINESTART || pEntry->nWID == XATTR_LINEEND || pEntry->nWID == XATTR_LINEDASH) )
		{
			OUString aTempName;
			if(!(aValue >>= aTempName ))
				throw IllegalArgumentException();

			SvxShape::SetFillAttribute( pEntry->nWID, aTempName, aSet );
		}
		else if(!SvxUnoTextRangeBase::SetPropertyValueHelper( aSet, pEntry, aValue, aSet ))
		{
			SvxItemPropertySet_setPropertyValue( GetStylePropertySet(), pEntry, aValue, aSet );
		}

		rStyleSet.Put( aSet );
		Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
	}
}

// --------------------------------------------------------------------

Any SAL_CALL SdStyleSheet::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	throwIfDisposed();

	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
	if( pEntry == NULL )
	{
		throw UnknownPropertyException();
	}
	else
	{
		Any aAny;

		if( pEntry->nWID == WID_STYLE_FAMILY )
		{
			if( nFamily == SD_STYLE_FAMILY_MASTERPAGE )
			{
				const OUString aLayoutName( GetName() );
				aAny <<= aLayoutName.copy( 0, aLayoutName.indexOf(OUString( RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR) ) ) );
			}
			else
			{
				aAny <<= GetFamilyString(nFamily);
			}
		}
		else if( pEntry->nWID == WID_STYLE_DISPNAME )
		{
			aAny <<= maDisplayName;
		}
		else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
		{
			aAny <<= sal_False;
		}
		else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
		{
			SfxItemSet &rStyleSet = GetItemSet();

			XFillBmpStretchItem* pStretchItem = (XFillBmpStretchItem*)rStyleSet.GetItem(XATTR_FILLBMP_STRETCH);
			XFillBmpTileItem* pTileItem = (XFillBmpTileItem*)rStyleSet.GetItem(XATTR_FILLBMP_TILE);

			if( pStretchItem && pTileItem )
			{
				if( pTileItem->GetValue() )
					aAny <<= BitmapMode_REPEAT;
				else if( pStretchItem->GetValue() )
					aAny <<= BitmapMode_STRETCH;
				else
					aAny <<= BitmapMode_NO_REPEAT;
			}
		}
		else
		{
			SfxItemSet aSet( GetPool().GetPool(),	pEntry->nWID, pEntry->nWID);

			const SfxPoolItem* pItem;
			SfxItemSet& rStyleSet = GetItemSet();

			if( rStyleSet.GetItemState(	pEntry->nWID, sal_True, &pItem ) == SFX_ITEM_SET )
				aSet.Put(  *pItem );

			if( !aSet.Count() )
				aSet.Put( GetPool().GetPool().GetDefaultItem( pEntry->nWID ) );

			if(SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pEntry, aAny ))
				return aAny;

			// Hole Wert aus ItemSet
			aAny = SvxItemPropertySet_getPropertyValue( GetStylePropertySet(),pEntry, aSet );
		}

		if( *pEntry->pType != aAny.getValueType() )
		{
			// since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
			if( ( *pEntry->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) )
			{
				sal_Int32 nValue = 0;
				aAny >>= nValue;
				aAny <<= (sal_Int16)nValue;
			}
			else
			{
				DBG_ERROR("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" );
			}
		}

		return aAny;
	}
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::addPropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
void SAL_CALL SdStyleSheet::removePropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
void SAL_CALL SdStyleSheet::addVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}
void SAL_CALL SdStyleSheet::removeVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {}

// --------------------------------------------------------------------
// XPropertyState
// --------------------------------------------------------------------

PropertyState SAL_CALL SdStyleSheet::getPropertyState( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	throwIfDisposed();

	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );

	if( pEntry == NULL )
		throw UnknownPropertyException();

	if( pEntry->nWID == WID_STYLE_FAMILY )
	{
		return PropertyState_DIRECT_VALUE;
	}
	else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
	{
		return PropertyState_DEFAULT_VALUE;
	}
	else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
	{
		const SfxItemSet& rSet = GetItemSet();

		if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET ||
			rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET )
		{
			return PropertyState_DIRECT_VALUE;
		}
		else
		{
			return PropertyState_AMBIGUOUS_VALUE;
		}
	}
	else
	{
		SfxItemSet &rStyleSet = GetItemSet();

		PropertyState eState;

		switch( rStyleSet.GetItemState( pEntry->nWID, sal_False ) )
		{
		case SFX_ITEM_READONLY:
		case SFX_ITEM_SET:
			eState = PropertyState_DIRECT_VALUE;
			break;
		case SFX_ITEM_DEFAULT:
			eState = PropertyState_DEFAULT_VALUE;
			break;
//		case SFX_ITEM_DONTCARE:
//		case SFX_ITEM_DISABLED:
		default:
			eState = PropertyState_AMBIGUOUS_VALUE;
			break;
		}

		// if a item is set, this doesn't mean we want it :)
		if( ( PropertyState_DIRECT_VALUE == eState ) )
		{
			switch( pEntry->nWID )
			{
			case XATTR_FILLBITMAP:
			case XATTR_FILLGRADIENT:
			case XATTR_FILLHATCH:
			case XATTR_FILLFLOATTRANSPARENCE:
			case XATTR_LINEEND:
			case XATTR_LINESTART:
			case XATTR_LINEDASH:
				{
					NameOrIndex* pItem = (NameOrIndex*)rStyleSet.GetItem((sal_uInt16)pEntry->nWID);
					if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) )
						eState = PropertyState_DEFAULT_VALUE;
				}
			}
		}

		return eState;
	}
}

// --------------------------------------------------------------------

Sequence< PropertyState > SAL_CALL SdStyleSheet::getPropertyStates( const Sequence< OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	throwIfDisposed();

	sal_Int32 nCount = aPropertyName.getLength();
	const OUString* pNames = aPropertyName.getConstArray();

	Sequence< PropertyState > aPropertyStateSequence( nCount );
	PropertyState* pState = aPropertyStateSequence.getArray();

	while( nCount-- )
		*pState++ = getPropertyState( *pNames++ );

	return aPropertyStateSequence;
}

// --------------------------------------------------------------------

void SAL_CALL SdStyleSheet::setPropertyToDefault( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	throwIfDisposed();

	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
	if( pEntry == NULL )
		throw UnknownPropertyException();

	SfxItemSet &rStyleSet = GetItemSet();

	if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
	{
		rStyleSet.ClearItem( XATTR_FILLBMP_STRETCH );
		rStyleSet.ClearItem( XATTR_FILLBMP_TILE );
	}
	else
	{
		rStyleSet.ClearItem( pEntry->nWID );
	}
	Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED));
}

// --------------------------------------------------------------------

Any SAL_CALL SdStyleSheet::getPropertyDefault( const OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
{
	OGuard aGuard( Application::GetSolarMutex() );

	throwIfDisposed();

	const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
	if( pEntry == NULL )
		throw UnknownPropertyException();
    Any aRet;
	if( pEntry->nWID == WID_STYLE_FAMILY )
	{
		aRet <<= GetFamilyString(nFamily);
	}
	else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
	{
		aRet <<= sal_False;
	}
	else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
	{
		aRet <<= BitmapMode_REPEAT;
	}
	else
	{
		SfxItemPool& rMyPool = GetPool().GetPool();
		SfxItemSet aSet( rMyPool,	pEntry->nWID, pEntry->nWID);
		aSet.Put( rMyPool.GetDefaultItem( pEntry->nWID ) );
        aRet = SvxItemPropertySet_getPropertyValue( GetStylePropertySet(), pEntry, aSet );
	}
    return aRet;
}

// --------------------------------------------------------------------

/** this is used because our property map is not sorted yet */
const SfxItemPropertySimpleEntry* SdStyleSheet::getPropertyMapEntry( const OUString& rPropertyName ) const throw()
{
	return GetStylePropertySet().getPropertyMapEntry(rPropertyName);
}