| /************************************************************** |
| * |
| * 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_unotools.hxx" |
| |
| #include <com/sun/star/uno/Sequence.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/instance.hxx> |
| #include <rtl/logfile.hxx> |
| #include <i18npool/mslangid.hxx> |
| #include <tools/string.hxx> |
| #include <tools/debug.hxx> |
| #include <unotools/syslocaleoptions.hxx> |
| #include <unotools/configmgr.hxx> |
| #include <unotools/configitem.hxx> |
| #include <com/sun/star/uno/Any.hxx> |
| |
| #include "itemholder1.hxx" |
| |
| #define CFG_READONLY_DEFAULT sal_False |
| |
| using namespace osl; |
| using namespace utl; |
| using namespace rtl; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::lang; |
| |
| |
| SvtSysLocaleOptions_Impl* SvtSysLocaleOptions::pOptions = NULL; |
| sal_Int32 SvtSysLocaleOptions::nRefCount = 0; |
| namespace |
| { |
| struct CurrencyChangeLink |
| : public rtl::Static<Link, CurrencyChangeLink> {}; |
| } |
| |
| com::sun::star::lang::Locale lcl_str_to_locale( const ::rtl::OUString rStr ) |
| { |
| com::sun::star::lang::Locale aRet; |
| if ( rStr.getLength() ) |
| { |
| aRet = com::sun::star::lang::Locale(); |
| sal_Int32 nSep = rStr.indexOf('-'); |
| if (nSep < 0) |
| aRet.Language = rStr; |
| else |
| { |
| aRet.Language = rStr.copy(0, nSep); |
| if (nSep < rStr.getLength()) |
| aRet.Country = rStr.copy(nSep+1, rStr.getLength() - (nSep+1)); |
| } |
| } |
| |
| return aRet; |
| } |
| |
| class SvtSysLocaleOptions_Impl : public utl::ConfigItem |
| { |
| Locale m_aRealLocale; |
| Locale m_aRealUILocale; |
| LanguageType m_eRealLanguage; |
| LanguageType m_eRealUILanguage; |
| OUString m_aLocaleString; // en-US or de-DE or empty for SYSTEM |
| OUString m_aUILocaleString; // en-US or de-DE or empty for SYSTEM |
| OUString m_aCurrencyString; // USD-en-US or EUR-de-DE |
| sal_uLong m_nBlockedHint; // pending hints |
| sal_Bool m_bDecimalSeparator; //use decimal separator same as locale |
| |
| sal_Bool m_bROLocale; |
| sal_Bool m_bROUILocale; |
| sal_Bool m_bROCurrency; |
| sal_Bool m_bRODecimalSeparator; |
| |
| static const Sequence< /* const */ OUString > GetPropertyNames(); |
| void MakeRealLocale(); |
| void MakeRealUILocale(); |
| |
| public: |
| SvtSysLocaleOptions_Impl(); |
| virtual ~SvtSysLocaleOptions_Impl(); |
| |
| virtual void Notify( const com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames ); |
| virtual void Commit(); |
| |
| const OUString& GetLocaleString() const |
| { return m_aLocaleString; } |
| void SetLocaleString( const OUString& rStr ); |
| |
| const OUString& GetUILocaleString() const |
| { return m_aUILocaleString; } |
| void SetUILocaleString( const OUString& rStr ); |
| |
| const OUString& GetCurrencyString() const |
| { return m_aCurrencyString; } |
| void SetCurrencyString( const OUString& rStr ); |
| |
| sal_Bool IsDecimalSeparatorAsLocale() const { return m_bDecimalSeparator;} |
| void SetDecimalSeparatorAsLocale( sal_Bool bSet); |
| |
| sal_Bool IsReadOnly( SvtSysLocaleOptions::EOption eOption ) const; |
| const Locale& GetRealLocale() { return m_aRealLocale; } |
| const Locale& GetRealUILocale() { return m_aRealUILocale; } |
| LanguageType GetRealLanguage() { return m_eRealLanguage; } |
| LanguageType GetRealUILanguage() { return m_eRealUILanguage; } |
| }; |
| |
| |
| #define ROOTNODE_SYSLOCALE OUString(RTL_CONSTASCII_USTRINGPARAM("Setup/L10N")) |
| |
| #define PROPERTYNAME_LOCALE OUString(RTL_CONSTASCII_USTRINGPARAM("ooSetupSystemLocale")) |
| #define PROPERTYNAME_UILOCALE OUString(RTL_CONSTASCII_USTRINGPARAM("ooLocale")) |
| #define PROPERTYNAME_CURRENCY OUString(RTL_CONSTASCII_USTRINGPARAM("ooSetupCurrency")) |
| #define PROPERTYNAME_DECIMALSEPARATOR OUString(RTL_CONSTASCII_USTRINGPARAM("DecimalSeparatorAsLocale")) |
| |
| #define PROPERTYHANDLE_LOCALE 0 |
| #define PROPERTYHANDLE_UILOCALE 1 |
| #define PROPERTYHANDLE_CURRENCY 2 |
| #define PROPERTYHANDLE_DECIMALSEPARATOR 3 |
| |
| #define PROPERTYCOUNT 4 |
| |
| const Sequence< OUString > SvtSysLocaleOptions_Impl::GetPropertyNames() |
| { |
| static const OUString pProperties[] = |
| { |
| PROPERTYNAME_LOCALE, |
| PROPERTYNAME_UILOCALE, |
| PROPERTYNAME_CURRENCY, |
| PROPERTYNAME_DECIMALSEPARATOR |
| }; |
| static const Sequence< OUString > seqPropertyNames( pProperties, PROPERTYCOUNT ); |
| return seqPropertyNames; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SvtSysLocaleOptions_Impl::SvtSysLocaleOptions_Impl() |
| : ConfigItem( ROOTNODE_SYSLOCALE ) |
| , m_nBlockedHint( 0 ) |
| , m_bDecimalSeparator( sal_True ) |
| , m_bROLocale(CFG_READONLY_DEFAULT) |
| , m_bROUILocale(CFG_READONLY_DEFAULT) |
| , m_bROCurrency(CFG_READONLY_DEFAULT) |
| , m_bRODecimalSeparator(sal_False) |
| |
| { |
| if ( IsValidConfigMgr() ) |
| { |
| const Sequence< OUString > aNames = GetPropertyNames(); |
| Sequence< Any > aValues = GetProperties( aNames ); |
| Sequence< sal_Bool > aROStates = GetReadOnlyStates( aNames ); |
| const Any* pValues = aValues.getConstArray(); |
| const sal_Bool* pROStates = aROStates.getConstArray(); |
| DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" ); |
| DBG_ASSERT( aROStates.getLength() == aNames.getLength(), "GetReadOnlyStates failed" ); |
| if ( aValues.getLength() == aNames.getLength() && aROStates.getLength() == aNames.getLength() ) |
| { |
| for ( sal_Int32 nProp = 0; nProp < aNames.getLength(); nProp++ ) |
| { |
| DBG_ASSERT( pValues[nProp].hasValue(), "property value missing" ); |
| if ( pValues[nProp].hasValue() ) |
| { |
| switch ( nProp ) |
| { |
| case PROPERTYHANDLE_LOCALE : |
| { |
| OUString aStr; |
| if ( pValues[nProp] >>= aStr ) |
| m_aLocaleString = aStr; |
| else |
| { |
| DBG_ERRORFILE( "Wrong property type!" ); |
| } |
| m_bROLocale = pROStates[nProp]; |
| } |
| break; |
| case PROPERTYHANDLE_UILOCALE : |
| { |
| OUString aStr; |
| if ( pValues[nProp] >>= aStr ) |
| m_aUILocaleString = aStr; |
| else |
| { |
| DBG_ERRORFILE( "Wrong property type!" ); |
| } |
| m_bROUILocale = pROStates[nProp]; |
| } |
| break; |
| case PROPERTYHANDLE_CURRENCY : |
| { |
| OUString aStr; |
| if ( pValues[nProp] >>= aStr ) |
| m_aCurrencyString = aStr; |
| else |
| { |
| DBG_ERRORFILE( "Wrong property type!" ); |
| } |
| m_bROCurrency = pROStates[nProp]; |
| } |
| break; |
| case PROPERTYHANDLE_DECIMALSEPARATOR: |
| { |
| sal_Bool bValue = sal_Bool(); |
| if ( pValues[nProp] >>= bValue ) |
| m_bDecimalSeparator = bValue; |
| else |
| { |
| DBG_ERRORFILE( "Wrong property type!" ); |
| } |
| m_bRODecimalSeparator = pROStates[nProp]; |
| } |
| break; |
| default: |
| DBG_ERRORFILE( "Wrong property type!" ); |
| } |
| } |
| } |
| } |
| // UpdateMiscSettings_Impl(); |
| EnableNotification( aNames ); |
| } |
| |
| MakeRealLocale(); |
| MakeRealUILocale(); |
| } |
| |
| |
| SvtSysLocaleOptions_Impl::~SvtSysLocaleOptions_Impl() |
| { |
| if ( IsModified() ) |
| Commit(); |
| } |
| |
| void SvtSysLocaleOptions_Impl::MakeRealLocale() |
| { |
| m_aRealLocale = lcl_str_to_locale( m_aLocaleString ); |
| if ( m_aRealLocale.Language.getLength() ) |
| { |
| m_eRealLanguage = MsLangId::convertLocaleToLanguage( m_aRealLocale ); |
| } |
| else |
| { |
| m_eRealLanguage = MsLangId::getSystemLanguage(); |
| MsLangId::convertLanguageToLocale( m_eRealLanguage, m_aRealLocale ); |
| } |
| } |
| |
| void SvtSysLocaleOptions_Impl::MakeRealUILocale() |
| { |
| if ( !m_aRealUILocale.Language.getLength() ) |
| { |
| // as we can't switch UILocale at runtime, we only store changes in the configuration |
| m_aRealUILocale = lcl_str_to_locale( m_aUILocaleString ); |
| if ( m_aRealUILocale.Language.getLength() ) |
| { |
| m_eRealUILanguage = MsLangId::convertLocaleToLanguage( m_aRealUILocale ); |
| } |
| else |
| { |
| m_eRealUILanguage = MsLangId::getSystemUILanguage(); |
| MsLangId::convertLanguageToLocale( m_eRealUILanguage, m_aRealUILocale ); |
| } |
| } |
| } |
| |
| sal_Bool SvtSysLocaleOptions_Impl::IsReadOnly( SvtSysLocaleOptions::EOption eOption ) const |
| { |
| sal_Bool bReadOnly = CFG_READONLY_DEFAULT; |
| switch(eOption) |
| { |
| case SvtSysLocaleOptions::E_LOCALE : |
| { |
| bReadOnly = m_bROLocale; |
| break; |
| } |
| case SvtSysLocaleOptions::E_UILOCALE : |
| { |
| bReadOnly = m_bROUILocale; |
| break; |
| } |
| case SvtSysLocaleOptions::E_CURRENCY : |
| { |
| bReadOnly = m_bROCurrency; |
| break; |
| } |
| } |
| return bReadOnly; |
| } |
| |
| |
| void SvtSysLocaleOptions_Impl::Commit() |
| { |
| const Sequence< OUString > aOrgNames = GetPropertyNames(); |
| sal_Int32 nOrgCount = aOrgNames.getLength(); |
| |
| Sequence< OUString > aNames( nOrgCount ); |
| Sequence< Any > aValues( nOrgCount ); |
| |
| OUString* pNames = aNames.getArray(); |
| Any* pValues = aValues.getArray(); |
| sal_Int32 nRealCount = 0; |
| |
| for ( sal_Int32 nProp = 0; nProp < nOrgCount; nProp++ ) |
| { |
| switch ( nProp ) |
| { |
| case PROPERTYHANDLE_LOCALE : |
| { |
| if (!m_bROLocale) |
| { |
| pNames[nRealCount] = aOrgNames[nProp]; |
| pValues[nRealCount] <<= m_aLocaleString; |
| ++nRealCount; |
| } |
| } |
| break; |
| case PROPERTYHANDLE_UILOCALE : |
| { |
| if (!m_bROUILocale) |
| { |
| pNames[nRealCount] = aOrgNames[nProp]; |
| pValues[nRealCount] <<= m_aUILocaleString; |
| ++nRealCount; |
| } |
| } |
| break; |
| case PROPERTYHANDLE_CURRENCY : |
| { |
| if (!m_bROCurrency) |
| { |
| pNames[nRealCount] = aOrgNames[nProp]; |
| pValues[nRealCount] <<= m_aCurrencyString; |
| ++nRealCount; |
| } |
| } |
| break; |
| case PROPERTYHANDLE_DECIMALSEPARATOR: |
| if( !m_bRODecimalSeparator ) |
| { |
| pNames[nRealCount] = aOrgNames[nProp]; |
| pValues[nRealCount] <<= m_bDecimalSeparator; |
| ++nRealCount; |
| } |
| break; |
| default: |
| DBG_ERRORFILE( "invalid index to save a path" ); |
| } |
| } |
| aNames.realloc(nRealCount); |
| aValues.realloc(nRealCount); |
| PutProperties( aNames, aValues ); |
| ClearModified(); |
| } |
| |
| |
| void SvtSysLocaleOptions_Impl::SetLocaleString( const OUString& rStr ) |
| { |
| if (!m_bROLocale && rStr != m_aLocaleString ) |
| { |
| m_aLocaleString = rStr; |
| MakeRealLocale(); |
| MsLangId::setConfiguredSystemLanguage( m_eRealLanguage ); |
| SetModified(); |
| sal_uLong nHint = SYSLOCALEOPTIONS_HINT_LOCALE; |
| if ( !m_aCurrencyString.getLength() ) |
| nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY; |
| NotifyListeners( nHint ); |
| } |
| } |
| |
| void SvtSysLocaleOptions_Impl::SetUILocaleString( const OUString& rStr ) |
| { |
| if (!m_bROUILocale && rStr != m_aUILocaleString ) |
| { |
| m_aUILocaleString = rStr; |
| /* |
| // as we can't switch UILocale at runtime, we only store changes in the configuration |
| MakeRealUILocale(); |
| MsLangId::setConfiguredSystemLanguage( m_eRealUILanguage ); |
| SetModified(); |
| NotifyListeners( SYSLOCALEOPTIONS_HINT_UILOCALE ); |
| */ |
| } |
| } |
| |
| void SvtSysLocaleOptions_Impl::SetCurrencyString( const OUString& rStr ) |
| { |
| if (!m_bROCurrency && rStr != m_aCurrencyString ) |
| { |
| m_aCurrencyString = rStr; |
| SetModified(); |
| NotifyListeners( SYSLOCALEOPTIONS_HINT_CURRENCY ); |
| } |
| } |
| |
| void SvtSysLocaleOptions_Impl::SetDecimalSeparatorAsLocale( sal_Bool bSet) |
| { |
| if(bSet != m_bDecimalSeparator) |
| { |
| m_bDecimalSeparator = bSet; |
| SetModified(); |
| NotifyListeners( SYSLOCALEOPTIONS_HINT_DECSEP ); |
| } |
| } |
| |
| void SvtSysLocaleOptions_Impl::Notify( const Sequence< rtl::OUString >& seqPropertyNames ) |
| { |
| sal_uLong nHint = 0; |
| Sequence< Any > seqValues = GetProperties( seqPropertyNames ); |
| Sequence< sal_Bool > seqROStates = GetReadOnlyStates( seqPropertyNames ); |
| sal_Int32 nCount = seqPropertyNames.getLength(); |
| for( sal_Int32 nProp = 0; nProp < nCount; ++nProp ) |
| { |
| if( seqPropertyNames[nProp] == PROPERTYNAME_LOCALE ) |
| { |
| DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Locale property type" ); |
| seqValues[nProp] >>= m_aLocaleString; |
| m_bROLocale = seqROStates[nProp]; |
| nHint |= SYSLOCALEOPTIONS_HINT_LOCALE; |
| if ( !m_aCurrencyString.getLength() ) |
| nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY; |
| MakeRealLocale(); |
| } |
| if( seqPropertyNames[nProp] == PROPERTYNAME_UILOCALE ) |
| { |
| DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Locale property type" ); |
| seqValues[nProp] >>= m_aUILocaleString; |
| m_bROUILocale = seqROStates[nProp]; |
| nHint |= SYSLOCALEOPTIONS_HINT_UILOCALE; |
| MakeRealUILocale(); |
| } |
| else if( seqPropertyNames[nProp] == PROPERTYNAME_CURRENCY ) |
| { |
| DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Currency property type" ); |
| seqValues[nProp] >>= m_aCurrencyString; |
| m_bROCurrency = seqROStates[nProp]; |
| nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY; |
| } |
| else if( seqPropertyNames[nProp] == PROPERTYNAME_DECIMALSEPARATOR ) |
| { |
| seqValues[nProp] >>= m_bDecimalSeparator; |
| m_bRODecimalSeparator = seqROStates[nProp]; |
| } |
| } |
| if ( nHint ) |
| NotifyListeners( nHint ); |
| } |
| |
| // ==================================================================== |
| |
| SvtSysLocaleOptions::SvtSysLocaleOptions() |
| { |
| MutexGuard aGuard( GetMutex() ); |
| if ( !pOptions ) |
| { |
| RTL_LOGFILE_CONTEXT(aLog, "svl ( ??? ) ::SvtSysLocaleOptions_Impl::ctor()"); |
| pOptions = new SvtSysLocaleOptions_Impl; |
| |
| ItemHolder1::holdConfigItem(E_SYSLOCALEOPTIONS); |
| } |
| ++nRefCount; |
| pOptions->AddListener(this); |
| } |
| |
| |
| SvtSysLocaleOptions::~SvtSysLocaleOptions() |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->RemoveListener(this); |
| if ( !--nRefCount ) |
| { |
| delete pOptions; |
| pOptions = NULL; |
| } |
| } |
| |
| |
| // static |
| Mutex& SvtSysLocaleOptions::GetMutex() |
| { |
| static Mutex* pMutex = NULL; |
| if( !pMutex ) |
| { |
| MutexGuard aGuard( Mutex::getGlobalMutex() ); |
| if( !pMutex ) |
| { |
| // #i77768# Due to a static reference in the toolkit lib |
| // we need a mutex that lives longer than the svl library. |
| // Otherwise the dtor would use a destructed mutex!! |
| pMutex = new Mutex; |
| } |
| } |
| return *pMutex; |
| } |
| |
| |
| sal_Bool SvtSysLocaleOptions::IsModified() |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return pOptions->IsModified(); |
| } |
| |
| |
| void SvtSysLocaleOptions::Commit() |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->Commit(); |
| } |
| |
| |
| void SvtSysLocaleOptions::BlockBroadcasts( bool bBlock ) |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->BlockBroadcasts( bBlock ); |
| } |
| |
| |
| const OUString& SvtSysLocaleOptions::GetLocaleConfigString() const |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return pOptions->GetLocaleString(); |
| } |
| |
| void SvtSysLocaleOptions::SetLocaleConfigString( const OUString& rStr ) |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->SetLocaleString( rStr ); |
| } |
| |
| const OUString& SvtSysLocaleOptions::GetUILocaleConfigString() const |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return pOptions->GetUILocaleString(); |
| } |
| |
| void SvtSysLocaleOptions::SetUILocaleConfigString( const OUString& rStr ) |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->SetUILocaleString( rStr ); |
| } |
| |
| const OUString& SvtSysLocaleOptions::GetCurrencyConfigString() const |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return pOptions->GetCurrencyString(); |
| } |
| |
| |
| void SvtSysLocaleOptions::SetCurrencyConfigString( const OUString& rStr ) |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->SetCurrencyString( rStr ); |
| } |
| |
| |
| |
| /*-- 11.02.2004 13:31:41--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| sal_Bool SvtSysLocaleOptions::IsDecimalSeparatorAsLocale() const |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return pOptions->IsDecimalSeparatorAsLocale(); |
| } |
| /*-- 11.02.2004 13:31:41--------------------------------------------------- |
| |
| -----------------------------------------------------------------------*/ |
| void SvtSysLocaleOptions::SetDecimalSeparatorAsLocale( sal_Bool bSet) |
| { |
| MutexGuard aGuard( GetMutex() ); |
| pOptions->SetDecimalSeparatorAsLocale(bSet); |
| } |
| |
| |
| sal_Bool SvtSysLocaleOptions::IsReadOnly( EOption eOption ) const |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return pOptions->IsReadOnly( eOption ); |
| } |
| |
| // static |
| void SvtSysLocaleOptions::GetCurrencyAbbrevAndLanguage( String& rAbbrev, |
| LanguageType& eLang, const ::rtl::OUString& rConfigString ) |
| { |
| sal_Int32 nDelim = rConfigString.indexOf( '-' ); |
| if ( nDelim >= 0 ) |
| { |
| rAbbrev = rConfigString.copy( 0, nDelim ); |
| String aIsoStr( rConfigString.copy( nDelim+1 ) ); |
| eLang = MsLangId::convertIsoStringToLanguage( aIsoStr ); |
| } |
| else |
| { |
| rAbbrev = rConfigString; |
| eLang = (rAbbrev.Len() ? LANGUAGE_NONE : LANGUAGE_SYSTEM); |
| } |
| } |
| |
| |
| // static |
| ::rtl::OUString SvtSysLocaleOptions::CreateCurrencyConfigString( |
| const String& rAbbrev, LanguageType eLang ) |
| { |
| String aIsoStr( MsLangId::convertLanguageToIsoString( eLang ) ); |
| if ( aIsoStr.Len() ) |
| { |
| ::rtl::OUStringBuffer aStr( rAbbrev.Len() + 1 + aIsoStr.Len() ); |
| aStr.append( rAbbrev.GetBuffer(), rAbbrev.Len() ); |
| aStr.append( sal_Unicode('-') ); |
| aStr.append( aIsoStr.GetBuffer(), aIsoStr.Len() ); |
| return aStr.makeStringAndClear(); |
| } |
| else |
| return rAbbrev; |
| } |
| |
| |
| // static |
| void SvtSysLocaleOptions::SetCurrencyChangeLink( const Link& rLink ) |
| { |
| MutexGuard aGuard( GetMutex() ); |
| DBG_ASSERT( !CurrencyChangeLink::get().IsSet(), "SvtSysLocaleOptions::SetCurrencyChangeLink: already set" ); |
| CurrencyChangeLink::get() = rLink; |
| } |
| |
| |
| // static |
| const Link& SvtSysLocaleOptions::GetCurrencyChangeLink() |
| { |
| MutexGuard aGuard( GetMutex() ); |
| return CurrencyChangeLink::get(); |
| } |
| |
| |
| void SvtSysLocaleOptions::ConfigurationChanged( utl::ConfigurationBroadcaster* p, sal_uInt32 nHint ) |
| { |
| if ( nHint & SYSLOCALEOPTIONS_HINT_CURRENCY ) |
| { |
| const Link& rLink = GetCurrencyChangeLink(); |
| if ( rLink.IsSet() ) |
| rLink.Call( NULL ); |
| } |
| |
| ::utl::detail::Options::ConfigurationChanged( p, nHint ); |
| } |
| |
| com::sun::star::lang::Locale SvtSysLocaleOptions::GetLocale() const |
| { |
| return lcl_str_to_locale( GetLocaleConfigString() ); |
| } |
| |
| com::sun::star::lang::Locale SvtSysLocaleOptions::GetUILocale() const |
| { |
| return lcl_str_to_locale( GetUILocaleConfigString() ); |
| } |
| |
| com::sun::star::lang::Locale SvtSysLocaleOptions::GetRealLocale() const |
| { |
| return pOptions->GetRealLocale(); |
| } |
| |
| com::sun::star::lang::Locale SvtSysLocaleOptions::GetRealUILocale() const |
| { |
| return pOptions->GetRealUILocale(); |
| } |
| |
| LanguageType SvtSysLocaleOptions::GetRealLanguage() const |
| { |
| return pOptions->GetRealLanguage(); |
| } |
| |
| LanguageType SvtSysLocaleOptions::GetRealUILanguage() const |
| { |
| return pOptions->GetRealUILanguage(); |
| } |
| |
| |
