/************************************************************** * * 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_svtools.hxx" #include #include #include #include #include #include #include #include #include #include #include "itemholder2.hxx" using namespace utl; using namespace rtl; using namespace com::sun::star::uno; using namespace com::sun::star; static SvtHelpOptions_Impl* pOptions = NULL; static sal_Int32 nRefCount = 0; #define EXTENDEDHELP 0 #define HELPTIPS 1 #define AGENT_ENABLED 2 #define AGENT_TIMEOUT 3 #define AGENT_RETRYLIMIT 4 #define LOCALE 5 #define SYSTEM 6 #define STYLESHEET 7 class SvtHelpOptions_Impl : public utl::ConfigItem { IdList* pList; sal_Int32 nHelpAgentTimeoutPeriod; sal_Int32 nHelpAgentRetryLimit; sal_Bool bExtendedHelp; sal_Bool bHelpTips; sal_Bool bHelpAgentEnabled; sal_Bool bWelcomeScreen; String aLocale; String aSystem; String sHelpStyleSheet; DECLARE_STL_USTRINGACCESS_MAP( sal_Int32, MapString2Int ); MapString2Int aURLIgnoreCounters; ::osl::Mutex aIgnoreCounterSafety; Sequence< OUString > GetPropertyNames(); public: SvtHelpOptions_Impl(); virtual void Notify( const com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames ); void Load( const ::com::sun::star::uno::Sequence< ::rtl::OUString>& aPropertyNames); virtual void Commit(); void SetExtendedHelp( sal_Bool b ) { bExtendedHelp= b; SetModified(); } sal_Bool IsExtendedHelp() const { return bExtendedHelp; } void SetHelpTips( sal_Bool b ) { bHelpTips = b; SetModified(); } sal_Bool IsHelpTips() const { return bHelpTips; } void SetHelpAgentEnabled( sal_Bool b ) { bHelpAgentEnabled = b; SetModified(); } sal_Bool IsHelpAgentEnabled() const { return bHelpAgentEnabled; } void SetHelpAgentTimeoutPeriod( sal_Int32 _nSeconds ) { nHelpAgentTimeoutPeriod = _nSeconds; SetModified(); } sal_Int32 GetHelpAgentTimeoutPeriod( ) const { return nHelpAgentTimeoutPeriod; } void SetHelpAgentRetryLimit( sal_Int32 _nTrials ) { nHelpAgentRetryLimit = _nTrials; SetModified(); } sal_Int32 GetHelpAgentRetryLimit( ) const { return nHelpAgentRetryLimit; } sal_Int32 getAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ); void decAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ); void resetAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ); void resetAgentIgnoreURLCounter(); void SetWelcomeScreen( sal_Bool b ) { bWelcomeScreen = b; SetModified(); } sal_Bool IsWelcomeScreen() const { return bWelcomeScreen; } IdList* GetPIStarterList() { return pList; } void AddToPIStarterList( sal_Int32 nId ); void RemoveFromPIStarterList( sal_Int32 nId ); String GetLocale() const { return aLocale; } String GetSystem() const { return aSystem; } const String& GetHelpStyleSheet()const{return sHelpStyleSheet;} void SetHelpStyleSheet(const String& rStyleSheet){sHelpStyleSheet = rStyleSheet; SetModified();} static ::osl::Mutex & getInitMutex(); protected: void implLoadURLCounters(); void implSaveURLCounters(); // to be called with aIgnoreCounterSafety locked void implGetURLCounters( Sequence< ::rtl::OUString >& _rNodeNames, Sequence< Any >& _rURLs, Sequence< Any >& _rCounter ); }; Sequence< OUString > SvtHelpOptions_Impl::GetPropertyNames() { static const char* aPropNames[] = { "ExtendedTip", "Tip", "HelpAgent/Enabled", "HelpAgent/Timeout", "HelpAgent/RetryLimit", "Locale", "System", "HelpStyleSheet", // "HowTo/Show" }; const int nCount = sizeof( aPropNames ) / sizeof( const char* ); Sequence< OUString > aNames( nCount ); OUString* pNames = aNames.getArray(); for ( int i = 0; i < nCount; i++ ) pNames[i] = OUString::createFromAscii( aPropNames[i] ); return aNames; } ::osl::Mutex & SvtHelpOptions_Impl::getInitMutex() { static ::osl::Mutex *pMutex = 0; if( ! pMutex ) { ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() ); if( ! pMutex ) { static ::osl::Mutex mutex; pMutex = &mutex; } } return *pMutex; } // ----------------------------------------------------------------------- SvtHelpOptions_Impl::SvtHelpOptions_Impl() : ConfigItem( OUString::createFromAscii("Office.Common/Help") ) , pList( 0 ) , bExtendedHelp( sal_False ) , bHelpTips( sal_True ) , bHelpAgentEnabled( sal_False ) , bWelcomeScreen( sal_False ) { Sequence< OUString > aNames = GetPropertyNames(); Load( aNames ); EnableNotification( aNames ); implLoadURLCounters(); } // ----------------------------------------------------------------------- static int lcl_MapPropertyName( const ::rtl::OUString rCompare, const uno::Sequence< ::rtl::OUString>& aInternalPropertyNames) { for(int nProp = 0; nProp < aInternalPropertyNames.getLength(); ++nProp) { if( aInternalPropertyNames[nProp] == rCompare ) return nProp; } return -1; } void SvtHelpOptions_Impl::Load(const uno::Sequence< ::rtl::OUString>& rPropertyNames) { const uno::Sequence< ::rtl::OUString> aInternalPropertyNames( GetPropertyNames()); Sequence< Any > aValues = GetProperties( rPropertyNames ); const Any* pValues = aValues.getConstArray(); DBG_ASSERT( aValues.getLength() == rPropertyNames.getLength(), "GetProperties failed" ); if ( aValues.getLength() == rPropertyNames.getLength() ) { for ( int nProp = 0; nProp < rPropertyNames.getLength(); nProp++ ) { DBG_ASSERT( pValues[nProp].hasValue(), "property value missing" ); if ( pValues[nProp].hasValue() ) { sal_Bool bTmp = sal_Bool(); ::rtl::OUString aTmpStr; sal_Int32 nTmpInt = 0; if ( pValues[nProp] >>= bTmp ) { switch ( lcl_MapPropertyName(rPropertyNames[nProp], aInternalPropertyNames) ) { case EXTENDEDHELP : bExtendedHelp = bTmp; break; case HELPTIPS : bHelpTips = bTmp; break; case AGENT_ENABLED : bHelpAgentEnabled = bTmp; break; default: DBG_ERRORFILE( "Wrong Member!" ); break; } } else if ( pValues[nProp] >>= aTmpStr ) { switch ( nProp ) { case LOCALE: aLocale = aTmpStr; break; case SYSTEM: aSystem = aTmpStr; break; case STYLESHEET : sHelpStyleSheet = aTmpStr; break; default: DBG_ERRORFILE( "Wrong Member!" ); break; } } else if ( pValues[nProp] >>= nTmpInt ) { switch ( nProp ) { case AGENT_TIMEOUT: nHelpAgentTimeoutPeriod = nTmpInt; break; case AGENT_RETRYLIMIT: nHelpAgentRetryLimit = nTmpInt; break; default: DBG_ERRORFILE( "Wrong Member!" ); break; } } else { DBG_ERRORFILE( "Wrong Type!" ); } } } if ( IsHelpTips() != Help::IsQuickHelpEnabled() ) IsHelpTips() ? Help::EnableQuickHelp() : Help::DisableQuickHelp(); if ( IsExtendedHelp() != Help::IsBalloonHelpEnabled() ) IsExtendedHelp() ? Help::EnableBalloonHelp() : Help::DisableBalloonHelp(); } } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::implGetURLCounters( Sequence< ::rtl::OUString >& _rNodeNames, Sequence< Any >& _rURLs, Sequence< Any >& _rCounters ) { // the ignore counters for the help agent URLs const ::rtl::OUString sIgnoreListNodePath = ::rtl::OUString::createFromAscii("HelpAgent/IgnoreList"); const ::rtl::OUString sPathSeparator = ::rtl::OUString::createFromAscii("/"); const ::rtl::OUString sURLLocalPath = ::rtl::OUString::createFromAscii("/Name"); const ::rtl::OUString sCounterLocalPath = ::rtl::OUString::createFromAscii("/Counter"); // get the names of all the nodes containing ignore counters // collect the node names we have to ask // first get the node names of all children of HelpAgent/IgnoreList _rNodeNames = GetNodeNames(sIgnoreListNodePath); const ::rtl::OUString* pIgnoredURLsNodes = _rNodeNames.getConstArray(); const ::rtl::OUString* pIgnoredURLsNodesEnd = pIgnoredURLsNodes + _rNodeNames.getLength(); // then assemble the two lists (of node paths) for the URLs and the counters Sequence< ::rtl::OUString > aIgnoredURLs(_rNodeNames.getLength()); Sequence< ::rtl::OUString > aIgnoredURLsCounter(_rNodeNames.getLength()); ::rtl::OUString* pIgnoredURLs = aIgnoredURLs.getArray(); ::rtl::OUString* pIgnoredURLsCounter = aIgnoredURLsCounter.getArray(); for (;pIgnoredURLsNodes != pIgnoredURLsNodesEnd; ++pIgnoredURLsNodes, ++pIgnoredURLs, ++pIgnoredURLsCounter) { ::rtl::OUString sLocalURLAccess = sIgnoreListNodePath; sLocalURLAccess += sPathSeparator; sLocalURLAccess += *pIgnoredURLsNodes; // the path to the URL of this specific entry *pIgnoredURLs = sLocalURLAccess; *pIgnoredURLs += sURLLocalPath; // the path of the counter for that URL *pIgnoredURLsCounter = sLocalURLAccess; *pIgnoredURLsCounter += sCounterLocalPath; } // now collect the values _rURLs = GetProperties(aIgnoredURLs); _rCounters = GetProperties(aIgnoredURLsCounter); sal_Int32 nURLs = _rURLs.getLength(); sal_Int32 nCounters = _rCounters.getLength(); DBG_ASSERT(nURLs == nCounters, "SvtHelpOptions_Impl::implGetURLCounters: inconsistence while retrieving the visited URLs!"); // normalize in case something went wrong sal_Int32 nKnownURLs = nURLs < nCounters ? nURLs : nCounters; if (nURLs < nCounters) { _rCounters.realloc(nKnownURLs); _rNodeNames.realloc(nKnownURLs); } else if (nURLs > nCounters) { _rURLs.realloc(nKnownURLs); _rNodeNames.realloc(nKnownURLs); } } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::implSaveURLCounters() { ::osl::MutexGuard aGuard(aIgnoreCounterSafety); const ::rtl::OUString sIgnoreListNodePath = ::rtl::OUString::createFromAscii("HelpAgent/IgnoreList"); const ::rtl::OUString sPathSeparator = ::rtl::OUString::createFromAscii("/"); const ::rtl::OUString sURLLocalPath = ::rtl::OUString::createFromAscii("/Name"); const ::rtl::OUString sCounterLocalPath = ::rtl::OUString::createFromAscii("/Counter"); // get the current URL/counter pairs (as they're persistent at the moment) Sequence< ::rtl::OUString > aNodeNames; Sequence< Any > aURLs; Sequence< Any > aCounters; implGetURLCounters(aNodeNames, aURLs, aCounters); sal_Int32 nKnownURLs = aURLs.getLength(); const ::rtl::OUString* pNodeNames = aNodeNames.getConstArray(); const Any* pURLs = aURLs.getConstArray(); const Any* pCounters = aCounters.getConstArray(); // check which of them must be deleted/modified Sequence< ::rtl::OUString > aDeleteFromConfig(nKnownURLs); // names of nodes to be deleted ::rtl::OUString* pDeleteFromConfig = aDeleteFromConfig.getArray(); ::std::set< ::rtl::OUString > aAlreadyPresent; // URLs currently persistent // for modifying already existent nodes Sequence< ::rtl::OUString > aNewCounterNodePaths(nKnownURLs); Sequence< Any > aNewCounterValues(nKnownURLs); ::rtl::OUString* pNewCounterNodePaths = aNewCounterNodePaths.getArray(); Any* pNewCounterValues = aNewCounterValues.getArray(); // temporaries needed inside the loop ::rtl::OUString sCurrentURL, sCurrentURLNodeName; for (sal_Int32 i=0; i>= sCurrentURL)) continue; ConstMapString2IntIterator aThisURLNewCounter = aURLIgnoreCounters.find(sCurrentURL); if (aURLIgnoreCounters.end() == aThisURLNewCounter) { // we do not know anything about this URL anymore. // -> have to removed it from the configuration later on *pDeleteFromConfig = *pNodeNames; ++pDeleteFromConfig; } else { // we know this URL sCurrentURLNodeName = sIgnoreListNodePath; sCurrentURLNodeName += sPathSeparator; sCurrentURLNodeName += *pNodeNames; // -> remember this (so we don't need to add a new node for this URL later on) aAlreadyPresent.insert(sCurrentURL); sal_Int32 nThisURLPersistentCounter = 0; (*pCounters) >>= nThisURLPersistentCounter; if (aThisURLNewCounter->second != nThisURLPersistentCounter) { // the counter changed // -> remember the path and the new counter for the adjustment below *pNewCounterNodePaths = sCurrentURLNodeName; *pNewCounterNodePaths += sCounterLocalPath; ++pNewCounterNodePaths; (*pNewCounterValues) <<= aThisURLNewCounter->second; ++pNewCounterValues; } } } // delete the nodes which are flagged so ... aDeleteFromConfig.realloc(pDeleteFromConfig - aDeleteFromConfig.getArray()); if (0 != aDeleteFromConfig.getLength()) { ClearNodeElements(sIgnoreListNodePath, aDeleteFromConfig); } // modify the nodes which need to be aNewCounterNodePaths.realloc(pNewCounterNodePaths - aNewCounterNodePaths.getArray()); aNewCounterValues.realloc(pNewCounterValues - aNewCounterValues.getArray()); if (0 != aNewCounterNodePaths.getLength()) { PutProperties(aNewCounterNodePaths, aNewCounterValues); } // and for the new ones ... ::rtl::OUString sNewNodeName; Sequence< ::rtl::OUString > aNewCounterDataNodeNames(2); Sequence< Any > aNewCounterDataValues(2); const ::rtl::OUString sNodeNameBase = ::rtl::OUString::createFromAscii("URL"); for ( ConstMapString2IntIterator aCollectNew = aURLIgnoreCounters.begin(); aCollectNew != aURLIgnoreCounters.end(); ++aCollectNew ) { if (aAlreadyPresent.end() == aAlreadyPresent.find(aCollectNew->first)) { // this URL is not persistent, yet // -> add a new node sNewNodeName = sNodeNameBase; if (!getUniqueSetElementName(sIgnoreListNodePath, sNewNodeName)) { DBG_ERRORFILE( "SvtHelpOptions_Impl::implSaveURLCounters: could not get a free name!" ); continue; } AddNode(sIgnoreListNodePath, sNewNodeName); // and set the URL/counter pair aNewCounterDataNodeNames[0] = sIgnoreListNodePath; aNewCounterDataNodeNames[0] += sPathSeparator; aNewCounterDataNodeNames[0] += sNewNodeName; aNewCounterDataNodeNames[0] += sURLLocalPath; aNewCounterDataValues[0] <<= aCollectNew->first; aNewCounterDataNodeNames[1] = sIgnoreListNodePath; aNewCounterDataNodeNames[1] += sPathSeparator; aNewCounterDataNodeNames[1] += sNewNodeName; aNewCounterDataNodeNames[1] += sCounterLocalPath; aNewCounterDataValues[1] <<= aCollectNew->second; PutProperties(aNewCounterDataNodeNames, aNewCounterDataValues); } } } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::implLoadURLCounters() { ::osl::MutexGuard aGuard(aIgnoreCounterSafety); Sequence< ::rtl::OUString > aNodeNames; Sequence< Any > aURLs; Sequence< Any > aCounters; implGetURLCounters(aNodeNames, aURLs, aCounters); sal_Int32 nKnownURLs = aURLs.getLength(); const Any* pURLs = aURLs.getConstArray(); const Any* pCounters = aCounters.getConstArray(); ::rtl::OUString sCurrentURL; sal_Int32 nCurrentCounter; for (sal_Int32 i=0; i>= sCurrentURL; nCurrentCounter = 0; (*pCounters) >>= nCurrentCounter; aURLIgnoreCounters[sCurrentURL] = nCurrentCounter; } } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::Commit() { Sequence< OUString > aNames = GetPropertyNames(); Sequence< Any > aValues( aNames.getLength() ); Any* pValues = aValues.getArray(); for ( int nProp = 0; nProp < aNames.getLength(); nProp++ ) { switch ( nProp ) { case EXTENDEDHELP : pValues[nProp] <<= bExtendedHelp; break; case HELPTIPS : pValues[nProp] <<= bHelpTips; break; case AGENT_ENABLED : pValues[nProp] <<= bHelpAgentEnabled; break; case AGENT_TIMEOUT: pValues[nProp] <<= nHelpAgentTimeoutPeriod; break; case AGENT_RETRYLIMIT: pValues[nProp] <<= nHelpAgentRetryLimit; break; case LOCALE: pValues[nProp] <<= ::rtl::OUString(aLocale); break; case SYSTEM: pValues[nProp] <<= ::rtl::OUString(aSystem); break; case STYLESHEET : pValues[nProp] <<= ::rtl::OUString(sHelpStyleSheet); break; } } PutProperties( aNames, aValues ); implSaveURLCounters(); } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::Notify( const Sequence& aPropertyNames ) { Load( aPropertyNames ); } SvtHelpOptions::SvtHelpOptions() { // Global access, must be guarded (multithreading) ::osl::MutexGuard aGuard( SvtHelpOptions_Impl::getInitMutex() ); ++nRefCount; if ( !pOptions ) { RTL_LOGFILE_CONTEXT(aLog, "svtools ( ??? ) ::SvtHelpOptions_Impl::ctor()"); pOptions = new SvtHelpOptions_Impl; ItemHolder2::holdConfigItem(E_HELPOPTIONS); } pImp = pOptions; } // ----------------------------------------------------------------------- sal_Int32 SvtHelpOptions_Impl::getAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ) { ::osl::MutexGuard aGuard(aIgnoreCounterSafety); ConstMapString2IntIterator aMapPos = aURLIgnoreCounters.find(_rURL); if (aURLIgnoreCounters.end() == aMapPos) return GetHelpAgentRetryLimit(); return aMapPos->second; } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::decAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ) { ::osl::MutexGuard aGuard(aIgnoreCounterSafety); MapString2IntIterator aMapPos = aURLIgnoreCounters.find(_rURL); if (aURLIgnoreCounters.end() == aMapPos) { // nothing known about this URL 'til now sal_Int32 nLimit = GetHelpAgentRetryLimit(); sal_Int32 nIgnoreAgain = nLimit > 0 ? nLimit - 1 : 0; aURLIgnoreCounters[_rURL] = nIgnoreAgain; } else { sal_Int32& rCounter = aMapPos->second; if (rCounter) --rCounter; } SetModified(); } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::resetAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ) { ::osl::MutexGuard aGuard(aIgnoreCounterSafety); MapString2IntIterator aMapPos = aURLIgnoreCounters.find(_rURL); if (aURLIgnoreCounters.end() != aMapPos) { aURLIgnoreCounters.erase(aMapPos); SetModified(); } } // ----------------------------------------------------------------------- void SvtHelpOptions_Impl::resetAgentIgnoreURLCounter() { ::osl::MutexGuard aGuard(aIgnoreCounterSafety); aURLIgnoreCounters.clear(); SetModified(); } // ----------------------------------------------------------------------- SvtHelpOptions::~SvtHelpOptions() { // Global access, must be guarded (multithreading) ::osl::MutexGuard aGuard( SvtHelpOptions_Impl::getInitMutex() ); if ( !--nRefCount ) { if ( pOptions->IsModified() ) pOptions->Commit(); DELETEZ( pOptions ); } } void SvtHelpOptions::SetExtendedHelp( sal_Bool b ) { pImp->SetExtendedHelp( b ); } sal_Bool SvtHelpOptions::IsExtendedHelp() const { return pImp->IsExtendedHelp(); } void SvtHelpOptions::SetHelpTips( sal_Bool b ) { pImp->SetHelpTips( b ); } sal_Bool SvtHelpOptions::IsHelpTips() const { return pImp->IsHelpTips(); } // ----------------------------------------------------------------------- void SvtHelpOptions::SetHelpAgentRetryLimit( sal_Int32 _nTrials ) { pImp->SetHelpAgentRetryLimit( _nTrials ); } // ----------------------------------------------------------------------- sal_Int32 SvtHelpOptions::GetHelpAgentRetryLimit( ) const { return pImp->GetHelpAgentRetryLimit( ); } // ----------------------------------------------------------------------- void SvtHelpOptions::SetHelpAgentTimeoutPeriod( sal_Int32 _nSeconds ) { pImp->SetHelpAgentTimeoutPeriod( _nSeconds ); } // ----------------------------------------------------------------------- sal_Int32 SvtHelpOptions::GetHelpAgentTimeoutPeriod( ) const { return pImp->GetHelpAgentTimeoutPeriod( ); } // ----------------------------------------------------------------------- void SvtHelpOptions::SetHelpAgentAutoStartMode( sal_Bool b ) { pImp->SetHelpAgentEnabled( b ); } // ----------------------------------------------------------------------- sal_Bool SvtHelpOptions::IsHelpAgentAutoStartMode() const { return pImp->IsHelpAgentEnabled(); } // ----------------------------------------------------------------------- sal_Int32 SvtHelpOptions::getAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ) { return pImp->getAgentIgnoreURLCounter( _rURL ); } // ----------------------------------------------------------------------- void SvtHelpOptions::decAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ) { pImp->decAgentIgnoreURLCounter( _rURL ); } // ----------------------------------------------------------------------- void SvtHelpOptions::resetAgentIgnoreURLCounter( const ::rtl::OUString& _rURL ) { pImp->resetAgentIgnoreURLCounter( _rURL ); } // ----------------------------------------------------------------------- void SvtHelpOptions::resetAgentIgnoreURLCounter() { pImp->resetAgentIgnoreURLCounter(); } // ----------------------------------------------------------------------- void SvtHelpOptions::SetWelcomeScreen( sal_Bool b ) { pImp->SetWelcomeScreen( b ); } sal_Bool SvtHelpOptions::IsWelcomeScreen() const { return pImp->IsWelcomeScreen(); } IdList* SvtHelpOptions::GetPIStarterList() { return pImp->GetPIStarterList(); } void SvtHelpOptions::AddToPIStarterList( sal_Int32 ) { } void SvtHelpOptions::RemoveFromPIStarterList( sal_Int32 ) { } String SvtHelpOptions::GetLocale() const { return pImp->GetLocale(); } String SvtHelpOptions::GetSystem() const { return pImp->GetSystem(); } const String& SvtHelpOptions::GetHelpStyleSheet()const { return pImp->GetHelpStyleSheet(); } void SvtHelpOptions::SetHelpStyleSheet(const String& rStyleSheet) { pImp->SetHelpStyleSheet(rStyleSheet); }