svtools/source/config/syslocaleoptions.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: syslocaleoptions.cxx,v $
  10  * $Revision: 1.23 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #ifdef  SVL_DLLIMPLEMENTATION
  35 #undef  SVL_DLLIMPLEMENTATION
  36 #endif
  37 #define SVT_DLLIMPLEMENTATION
  38
  39 #include <svtools/syslocaleoptions.hxx>
  40 #include <broadcast.hxx>
  41 #include <listener.hxx>
  42 #include <svtools/smplhint.hxx>
  43 #include <i18npool/mslangid.hxx>
  44 #include <tools/string.hxx>
  45 #include <rtl/ustrbuf.hxx>
  46 #include <rtl/instance.hxx>
  47 #include <unotools/configmgr.hxx>
  48 #include <unotools/configitem.hxx>
  49 #include <tools/debug.hxx>
  50 #include <com/sun/star/uno/Any.hxx>
  51 #include <com/sun/star/uno/Sequence.hxx>
  52 #include <vcl/settings.hxx>
  53 #include <vcl/svapp.hxx>
  54
  55 #include <rtl/logfile.hxx>
  56
  57 #include "itemholder2.hxx"
  58
  59
  60 #define CFG_READONLY_DEFAULT    sal_False
  61
  62 using namespace osl;
  63 using namespace utl;
  64 using namespace rtl;
  65 using namespace com::sun::star::uno;
  66 using namespace com::sun::star::lang;
  67
  68
  69 SvtSysLocaleOptions_Impl*   SvtSysLocaleOptions::pOptions = NULL;
  70 sal_Int32                   SvtSysLocaleOptions::nRefCount = 0;
  71 namespace
  72 {
  73     struct CurrencyChangeLink
  74         : public rtl::Static<Link, CurrencyChangeLink> {};
  75 }
  76
  77 class SvtSysLocaleOptions_Impl : public utl::ConfigItem
  78 {
  79         OUString                m_aLocaleString;    // en-US or de-DE or empty for SYSTEM
  80         LanguageType            m_eLocaleLanguageType;  // same for convenience access
  81         OUString                m_aCurrencyString;  // USD-en-US or EUR-de-DE
  82         SvtBroadcaster          m_aBroadcaster;
  83         ULONG                   m_nBlockedHint;     // pending hints
  84         sal_Int32               m_nBroadcastBlocked;     // broadcast only if this is 0
  85         sal_Bool                m_bDecimalSeparator; //use decimal separator same as locale
  86
  87
  88         sal_Bool                m_bROLocale;
  89         sal_Bool                m_bROCurrency;
  90         sal_Bool                m_bRODecimalSeparator;
  91
  92     static  const Sequence< /* const */ OUString >  GetPropertyNames();
  93
  94             void                UpdateMiscSettings_Impl();
  95             ULONG               ChangeLocaleSettings();
  96             void                ChangeDefaultCurrency() const;
  97             void                Broadcast( ULONG nHint );
  98
  99 public:
 100                                 SvtSysLocaleOptions_Impl();
 101     virtual                     ~SvtSysLocaleOptions_Impl();
 102
 103     virtual void                Notify( const com::sun::star::uno::Sequence< rtl::OUString >& aPropertyNames );
 104     virtual void                Commit();
 105
 106             const OUString&     GetLocaleString() const
 107                                     { return m_aLocaleString; }
 108             void                SetLocaleString( const OUString& rStr );
 109             LanguageType        GetLocaleLanguageType() const
 110                                     { return m_eLocaleLanguageType; }
 111
 112             const OUString&     GetCurrencyString() const
 113                                     { return m_aCurrencyString; }
 114             void                SetCurrencyString( const OUString& rStr );
 115
 116             sal_Bool            IsDecimalSeparatorAsLocale() const { return m_bDecimalSeparator;}
 117             void                SetDecimalSeparatorAsLocale( sal_Bool bSet);
 118
 119             SvtBroadcaster&     GetBroadcaster()
 120                                     { return m_aBroadcaster; }
 121             void                BlockBroadcasts( BOOL bBlock );
 122             sal_Bool            IsReadOnly( SvtSysLocaleOptions::EOption eOption ) const;
 123 };
 124
 125
 126 #define ROOTNODE_SYSLOCALE  OUString(RTL_CONSTASCII_USTRINGPARAM("Setup/L10N"))
 127
 128 #define PROPERTYNAME_LOCALE         OUString(RTL_CONSTASCII_USTRINGPARAM("ooSetupSystemLocale"))
 129 #define PROPERTYNAME_CURRENCY       OUString(RTL_CONSTASCII_USTRINGPARAM("ooSetupCurrency"))
 130 #define PROPERTYNAME_DECIMALSEPARATOR OUString(RTL_CONSTASCII_USTRINGPARAM("DecimalSeparatorAsLocale"))
 131
 132 #define PROPERTYHANDLE_LOCALE       0
 133 #define PROPERTYHANDLE_CURRENCY     1
 134 #define PROPERTYHANDLE_DECIMALSEPARATOR 2
 135
 136 #define PROPERTYCOUNT               3
 137
 138 const Sequence< OUString > SvtSysLocaleOptions_Impl::GetPropertyNames()
 139 {
 140     static const OUString pProperties[] =
 141     {
 142         PROPERTYNAME_LOCALE,
 143         PROPERTYNAME_CURRENCY,
 144         PROPERTYNAME_DECIMALSEPARATOR
 145     };
 146     static const Sequence< OUString > seqPropertyNames( pProperties, PROPERTYCOUNT );
 147     return seqPropertyNames;
 148 }
 149
 150
 151 // -----------------------------------------------------------------------
 152
 153 SvtSysLocaleOptions_Impl::SvtSysLocaleOptions_Impl()
 154     : ConfigItem( ROOTNODE_SYSLOCALE )
 155     , m_nBlockedHint( 0 )
 156     , m_nBroadcastBlocked( 0 )
 157     , m_bDecimalSeparator( sal_True )
 158     , m_bROLocale(CFG_READONLY_DEFAULT)
 159     , m_bROCurrency(CFG_READONLY_DEFAULT)
 160     , m_bRODecimalSeparator(sal_False)
 161
 162 {
 163     if ( !IsValidConfigMgr() )
 164         ChangeLocaleSettings();     // assume SYSTEM defaults during Setup
 165     else
 166     {
 167         const Sequence< OUString > aNames = GetPropertyNames();
 168         Sequence< Any > aValues = GetProperties( aNames );
 169         Sequence< sal_Bool > aROStates = GetReadOnlyStates( aNames );
 170         const Any* pValues = aValues.getConstArray();
 171         const sal_Bool* pROStates = aROStates.getConstArray();
 172         DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
 173         DBG_ASSERT( aROStates.getLength() == aNames.getLength(), "GetReadOnlyStates failed" );
 174         if ( aValues.getLength() == aNames.getLength() && aROStates.getLength() == aNames.getLength() )
 175         {
 176             for ( sal_Int32 nProp = 0; nProp < aNames.getLength(); nProp++ )
 177             {
 178                 DBG_ASSERT( pValues[nProp].hasValue(), "property value missing" );
 179                 if ( pValues[nProp].hasValue() )
 180                 {
 181                     switch ( nProp )
 182                     {
 183                         case PROPERTYHANDLE_LOCALE :
 184                             {
 185                                 OUString aStr;
 186                                 if ( pValues[nProp] >>= aStr )
 187                                     m_aLocaleString = aStr;
 188                                 else
 189                                 {
 190                                     DBG_ERRORFILE( "Wrong property type!" );
 191                                 }
 192                                 m_bROLocale = pROStates[nProp];
 193                             }
 194                             break;
 195                         case PROPERTYHANDLE_CURRENCY :
 196                             {
 197                                 OUString aStr;
 198                                 if ( pValues[nProp] >>= aStr )
 199                                     m_aCurrencyString = aStr;
 200                                 else
 201                                 {
 202                                     DBG_ERRORFILE( "Wrong property type!" );
 203                                 }
 204                                 m_bROCurrency = pROStates[nProp];
 205                             }
 206                         break;
 207                         case  PROPERTYHANDLE_DECIMALSEPARATOR:
 208                         {
 209                                     sal_Bool bValue = sal_Bool();
 210                             if ( pValues[nProp] >>= bValue )
 211                                 m_bDecimalSeparator = bValue;
 212                             else
 213                             {
 214                                 DBG_ERRORFILE( "Wrong property type!" );
 215                             }
 216                             m_bRODecimalSeparator = pROStates[nProp];
 217                         }
 218                         break;
 219                         default:
 220                             DBG_ERRORFILE( "Wrong property type!" );
 221                     }
 222                 }
 223             }
 224         }
 225         UpdateMiscSettings_Impl();
 226         ChangeLocaleSettings();
 227         EnableNotification( aNames );
 228     }
 229 }
 230
 231
 232 SvtSysLocaleOptions_Impl::~SvtSysLocaleOptions_Impl()
 233 {
 234     if ( IsModified() )
 235         Commit();
 236 }
 237
 238
 239 void SvtSysLocaleOptions_Impl::BlockBroadcasts( BOOL bBlock )
 240 {
 241     if ( bBlock )
 242         ++m_nBroadcastBlocked;
 243     else if ( m_nBroadcastBlocked )
 244     {
 245         if ( --m_nBroadcastBlocked == 0 )
 246             Broadcast( 0 );
 247     }
 248 }
 249
 250 sal_Bool SvtSysLocaleOptions_Impl::IsReadOnly( SvtSysLocaleOptions::EOption eOption ) const
 251 {
 252     sal_Bool bReadOnly = CFG_READONLY_DEFAULT;
 253     switch(eOption)
 254     {
 255         case SvtSysLocaleOptions::E_LOCALE :
 256             {
 257                 bReadOnly = m_bROLocale;
 258                 break;
 259             }
 260         case SvtSysLocaleOptions::E_CURRENCY :
 261             {
 262                 bReadOnly = m_bROCurrency;
 263                 break;
 264             }
 265     }
 266     return bReadOnly;
 267 }
 268
 269
 270 void SvtSysLocaleOptions_Impl::Broadcast( ULONG nHint )
 271 {
 272     if ( m_nBroadcastBlocked )
 273         m_nBlockedHint |= nHint;
 274     else
 275     {
 276         nHint |= m_nBlockedHint;
 277         m_nBlockedHint = 0;
 278         if ( nHint )
 279         {
 280             if ( nHint & SYSLOCALEOPTIONS_HINT_CURRENCY )
 281                 ChangeDefaultCurrency();
 282             SfxSimpleHint aHint( nHint );
 283             GetBroadcaster().Broadcast( aHint );
 284         }
 285     }
 286 }
 287
 288
 289 void SvtSysLocaleOptions_Impl::Commit()
 290 {
 291     const Sequence< OUString > aOrgNames = GetPropertyNames();
 292     sal_Int32 nOrgCount = aOrgNames.getLength();
 293
 294     Sequence< OUString > aNames( nOrgCount );
 295     Sequence< Any > aValues( nOrgCount );
 296
 297     OUString* pNames = aNames.getArray();
 298     Any* pValues = aValues.getArray();
 299     sal_Int32 nRealCount = 0;
 300
 301     for ( sal_Int32 nProp = 0; nProp < nOrgCount; nProp++ )
 302     {
 303         switch ( nProp )
 304         {
 305             case PROPERTYHANDLE_LOCALE :
 306                 {
 307                     if (!m_bROLocale)
 308                     {
 309                         pNames[nRealCount] = aOrgNames[nProp];
 310                         pValues[nRealCount] <<= m_aLocaleString;
 311                         ++nRealCount;
 312                     }
 313                 }
 314                 break;
 315             case PROPERTYHANDLE_CURRENCY :
 316                 {
 317                     if (!m_bROLocale)
 318                     {
 319                         pNames[nRealCount] = aOrgNames[nProp];
 320                         pValues[nRealCount] <<= m_aCurrencyString;
 321                         ++nRealCount;
 322                     }
 323                 }
 324                 break;
 325             case  PROPERTYHANDLE_DECIMALSEPARATOR:
 326                 if( !m_bRODecimalSeparator )
 327                 {
 328                     pNames[nRealCount] = aOrgNames[nProp];
 329                     pValues[nRealCount] <<= m_bDecimalSeparator;
 330                     ++nRealCount;
 331                 }
 332             break;
 333             default:
 334                 DBG_ERRORFILE( "invalid index to save a path" );
 335         }
 336     }
 337     aNames.realloc(nRealCount);
 338     aValues.realloc(nRealCount);
 339     PutProperties( aNames, aValues );
 340     ClearModified();
 341 }
 342
 343
 344 void SvtSysLocaleOptions_Impl::SetLocaleString( const OUString& rStr )
 345 {
 346     if (!m_bROLocale && rStr != m_aLocaleString )
 347     {
 348         m_aLocaleString = rStr;
 349         SetModified();
 350         ULONG nHint = SYSLOCALEOPTIONS_HINT_LOCALE;
 351         nHint |= ChangeLocaleSettings();
 352         Broadcast( nHint );
 353     }
 354 }
 355
 356
 357 ULONG SvtSysLocaleOptions_Impl::ChangeLocaleSettings()
 358 {
 359     // An empty config value denotes SYSTEM locale
 360     if ( m_aLocaleString.getLength() )
 361         m_eLocaleLanguageType = MsLangId::convertIsoStringToLanguage( m_aLocaleString );
 362     else
 363         m_eLocaleLanguageType = LANGUAGE_SYSTEM;
 364     ULONG nHint = 0;
 365     // new locale and no fixed currency => locale default currency might change
 366     if ( !m_aCurrencyString.getLength() )
 367         nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY;
 368     return nHint;
 369 }
 370
 371
 372 void SvtSysLocaleOptions_Impl::SetCurrencyString( const OUString& rStr )
 373 {
 374     if (!m_bROCurrency && rStr != m_aCurrencyString )
 375     {
 376         m_aCurrencyString = rStr;
 377         SetModified();
 378         Broadcast( SYSLOCALEOPTIONS_HINT_CURRENCY );
 379     }
 380 }
 381
 382 void SvtSysLocaleOptions_Impl::SetDecimalSeparatorAsLocale( sal_Bool bSet)
 383 {
 384     if(bSet != m_bDecimalSeparator)
 385     {
 386         m_bDecimalSeparator = bSet;
 387         SetModified();
 388         UpdateMiscSettings_Impl();
 389     }
 390 }
 391
 392
 393 void SvtSysLocaleOptions_Impl::ChangeDefaultCurrency() const
 394 {
 395     const Link& rLink = SvtSysLocaleOptions::GetCurrencyChangeLink();
 396     if ( rLink.IsSet() )
 397         rLink.Call( NULL );
 398 }
 399
 400
 401 void SvtSysLocaleOptions_Impl::Notify( const Sequence< rtl::OUString >& seqPropertyNames )
 402 {
 403     ULONG nHint = 0;
 404     Sequence< Any > seqValues = GetProperties( seqPropertyNames );
 405     Sequence< sal_Bool > seqROStates = GetReadOnlyStates( seqPropertyNames );
 406     sal_Int32 nCount = seqPropertyNames.getLength();
 407     for( sal_Int32 nProp = 0; nProp < nCount; ++nProp )
 408     {
 409         if( seqPropertyNames[nProp] == PROPERTYNAME_LOCALE )
 410         {
 411             DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Locale property type" );
 412             seqValues[nProp] >>= m_aLocaleString;
 413             m_bROLocale = seqROStates[nProp];
 414             nHint |= SYSLOCALEOPTIONS_HINT_LOCALE;
 415             nHint |= ChangeLocaleSettings();
 416         }
 417         else if( seqPropertyNames[nProp] == PROPERTYNAME_CURRENCY )
 418         {
 419             DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Currency property type" );
 420             seqValues[nProp] >>= m_aCurrencyString;
 421             m_bROCurrency = seqROStates[nProp];
 422             nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY;
 423         }
 424         else if( seqPropertyNames[nProp] == PROPERTYNAME_DECIMALSEPARATOR )
 425         {
 426             seqValues[nProp] >>= m_bDecimalSeparator;
 427             m_bRODecimalSeparator = seqROStates[nProp];
 428             UpdateMiscSettings_Impl();
 429         }
 430     }
 431     if ( nHint )
 432         Broadcast( nHint );
 433 }
 434 /* -----------------10.02.2004 15:25-----------------
 435
 436  --------------------------------------------------*/
 437 void SvtSysLocaleOptions_Impl::UpdateMiscSettings_Impl()
 438 {
 439     AllSettings aAllSettings( Application::GetSettings() );
 440     MiscSettings aMiscSettings = aAllSettings.GetMiscSettings();
 441     aMiscSettings.SetEnableLocalizedDecimalSep(m_bDecimalSeparator);
 442     aAllSettings.SetMiscSettings( aMiscSettings );
 443     Application::SetSettings( aAllSettings );
 444 }
 445
 446 // ====================================================================
 447
 448 SvtSysLocaleOptions::SvtSysLocaleOptions()
 449 {
 450     MutexGuard aGuard( GetMutex() );
 451     if ( !pOptions )
 452     {
 453         RTL_LOGFILE_CONTEXT(aLog, "svtools ( ??? ) ::SvtSysLocaleOptions_Impl::ctor()");
 454         pOptions = new SvtSysLocaleOptions_Impl;
 455
 456         ItemHolder2::holdConfigItem(E_SYSLOCALEOPTIONS);
 457     }
 458     ++nRefCount;
 459 }
 460
 461
 462 SvtSysLocaleOptions::~SvtSysLocaleOptions()
 463 {
 464     MutexGuard aGuard( GetMutex() );
 465     if ( !--nRefCount )
 466     {
 467         delete pOptions;
 468         pOptions = NULL;
 469     }
 470 }
 471
 472
 473 // static
 474 Mutex& SvtSysLocaleOptions::GetMutex()
 475 {
 476     static Mutex* pMutex = NULL;
 477     if( !pMutex )
 478     {
 479         MutexGuard aGuard( Mutex::getGlobalMutex() );
 480         if( !pMutex )
 481         {
 482             // #i77768# Due to a static reference in the toolkit lib
 483             // we need a mutex that lives longer than the svtools library.
 484             // Otherwise the dtor would use a destructed mutex!!
 485             pMutex = new Mutex;
 486         }
 487     }
 488     return *pMutex;
 489 }
 490
 491
 492 sal_Bool SvtSysLocaleOptions::IsModified()
 493 {
 494     MutexGuard aGuard( GetMutex() );
 495     return pOptions->IsModified();
 496 }
 497
 498
 499 void SvtSysLocaleOptions::Commit()
 500 {
 501     MutexGuard aGuard( GetMutex() );
 502     pOptions->Commit();
 503 }
 504
 505
 506 BOOL SvtSysLocaleOptions::AddListener( SvtListener& rLst )
 507 {
 508     MutexGuard aGuard( GetMutex() );
 509     return rLst.StartListening( pOptions->GetBroadcaster() );
 510 }
 511
 512
 513 BOOL SvtSysLocaleOptions::RemoveListener( SvtListener& rLst )
 514 {
 515     MutexGuard aGuard( GetMutex() );
 516     return rLst.EndListening( pOptions->GetBroadcaster() );
 517 }
 518
 519
 520 void SvtSysLocaleOptions::BlockBroadcasts( BOOL bBlock )
 521 {
 522     MutexGuard aGuard( GetMutex() );
 523     pOptions->BlockBroadcasts( bBlock );
 524 }
 525
 526
 527 const OUString& SvtSysLocaleOptions::GetLocaleConfigString() const
 528 {
 529     MutexGuard aGuard( GetMutex() );
 530     return pOptions->GetLocaleString();
 531 }
 532
 533
 534 void SvtSysLocaleOptions::SetLocaleConfigString( const OUString& rStr )
 535 {
 536     MutexGuard aGuard( GetMutex() );
 537     pOptions->SetLocaleString( rStr );
 538 }
 539
 540
 541 const OUString& SvtSysLocaleOptions::GetCurrencyConfigString() const
 542 {
 543     MutexGuard aGuard( GetMutex() );
 544     return pOptions->GetCurrencyString();
 545 }
 546
 547
 548 void SvtSysLocaleOptions::SetCurrencyConfigString( const OUString& rStr )
 549 {
 550     MutexGuard aGuard( GetMutex() );
 551     pOptions->SetCurrencyString( rStr );
 552 }
 553
 554
 555 LanguageType SvtSysLocaleOptions::GetLocaleLanguageType() const
 556 {
 557     MutexGuard aGuard( GetMutex() );
 558     return pOptions->GetLocaleLanguageType();
 559 }
 560
 561 /*-- 11.02.2004 13:31:41---------------------------------------------------
 562
 563   -----------------------------------------------------------------------*/
 564 sal_Bool SvtSysLocaleOptions::IsDecimalSeparatorAsLocale() const
 565 {
 566     MutexGuard aGuard( GetMutex() );
 567     return pOptions->IsDecimalSeparatorAsLocale();
 568 }
 569 /*-- 11.02.2004 13:31:41---------------------------------------------------
 570
 571   -----------------------------------------------------------------------*/
 572 void SvtSysLocaleOptions::SetDecimalSeparatorAsLocale( sal_Bool bSet)
 573 {
 574     MutexGuard aGuard( GetMutex() );
 575     pOptions->SetDecimalSeparatorAsLocale(bSet);
 576 }
 577
 578
 579 sal_Bool SvtSysLocaleOptions::IsReadOnly( EOption eOption ) const
 580 {
 581     MutexGuard aGuard( GetMutex() );
 582     return pOptions->IsReadOnly( eOption );
 583 }
 584
 585 // static
 586 void SvtSysLocaleOptions::GetCurrencyAbbrevAndLanguage( String& rAbbrev,
 587         LanguageType& eLang, const ::rtl::OUString& rConfigString )
 588 {
 589     sal_Int32 nDelim = rConfigString.indexOf( '-' );
 590     if ( nDelim >= 0 )
 591     {
 592         rAbbrev = rConfigString.copy( 0, nDelim );
 593         String aIsoStr( rConfigString.copy( nDelim+1 ) );
 594         eLang = MsLangId::convertIsoStringToLanguage( aIsoStr );
 595     }
 596     else
 597     {
 598         rAbbrev = rConfigString;
 599         eLang = (rAbbrev.Len() ? LANGUAGE_NONE : LANGUAGE_SYSTEM);
 600     }
 601 }
 602
 603
 604 // static
 605 ::rtl::OUString SvtSysLocaleOptions::CreateCurrencyConfigString(
 606         const String& rAbbrev, LanguageType eLang )
 607 {
 608     String aIsoStr( MsLangId::convertLanguageToIsoString( eLang ) );
 609     if ( aIsoStr.Len() )
 610     {
 611         ::rtl::OUStringBuffer aStr( rAbbrev.Len() + 1 + aIsoStr.Len() );
 612         aStr.append( rAbbrev.GetBuffer(), rAbbrev.Len() );
 613         aStr.append( sal_Unicode('-') );
 614         aStr.append( aIsoStr.GetBuffer(), aIsoStr.Len() );
 615         return aStr.makeStringAndClear();
 616     }
 617     else
 618         return rAbbrev;
 619 }
 620
 621
 622 // static
 623 void SvtSysLocaleOptions::SetCurrencyChangeLink( const Link& rLink )
 624 {
 625     MutexGuard aGuard( GetMutex() );
 626     DBG_ASSERT( !CurrencyChangeLink::get().IsSet(), "SvtSysLocaleOptions::SetCurrencyChangeLink: already set" );
 627     CurrencyChangeLink::get() = rLink;
 628 }
 629
 630
 631 // static
 632 const Link& SvtSysLocaleOptions::GetCurrencyChangeLink()
 633 {
 634     MutexGuard aGuard( GetMutex() );
 635     return CurrencyChangeLink::get();
 636 }
 637