/************************************************************** * * 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 #include #include #include #include #include #include #include #include "eetext.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #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" #include using ::rtl::OUString; using ::osl::MutexGuard; using ::osl::ClearableMutexGuard; using ::cppu::OInterfaceContainerHelper; using ::com::sun::star::table::BorderLine; 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 { MAP_CHAR_LEN("TopBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, TOP_BORDER }, \ { MAP_CHAR_LEN("BottomBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, BOTTOM_BORDER }, \ { MAP_CHAR_LEN("LeftBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, LEFT_BORDER }, \ { MAP_CHAR_LEN("RightBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, RIGHT_BORDER }, \ {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(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(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( 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); }