unotools/source/config/syslocaleoptions.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/uno/Sequence.hxx>
  21 #include <rtl/ustrbuf.hxx>
  22 #include <rtl/instance.hxx>
  23 #include <rtl/logfile.hxx>
  24 #include <i18nlangtag/mslangid.hxx>
  25 #include <i18nlangtag/languagetag.hxx>
  26 #include <tools/string.hxx>
  27 #include <tools/debug.hxx>
  28 #include <unotools/syslocaleoptions.hxx>
  29 #include <unotools/configmgr.hxx>
  30 #include <unotools/configitem.hxx>
  31 #include <com/sun/star/uno/Any.hxx>
  32
  33 #include "itemholder1.hxx"
  34
  35 #define CFG_READONLY_DEFAULT    sal_False
  36
  37 using namespace osl;
  38 using namespace utl;
  39 using namespace com::sun::star::uno;
  40 using namespace com::sun::star::lang;
  41
  42
  43 SvtSysLocaleOptions_Impl*   SvtSysLocaleOptions::pOptions = NULL;
  44 sal_Int32                   SvtSysLocaleOptions::nRefCount = 0;
  45 namespace
  46 {
  47     struct CurrencyChangeLink
  48         : public rtl::Static<Link, CurrencyChangeLink> {};
  49 }
  50
  51 class SvtSysLocaleOptions_Impl : public utl::ConfigItem
  52 {
  53         LanguageTag             m_aRealLocale;
  54         LanguageTag             m_aRealUILocale;
  55         OUString                m_aLocaleString;    // en-US or de-DE or empty for SYSTEM
  56         OUString                m_aUILocaleString;    // en-US or de-DE or empty for SYSTEM
  57         OUString                m_aCurrencyString;  // USD-en-US or EUR-de-DE
  58         OUString                m_aDatePatternsString;  // "Y-M-D;M-D"
  59         sal_Bool                m_bDecimalSeparator; //use decimal separator same as locale
  60         sal_Bool                m_bIgnoreLanguageChange; //OS language change doesn't affect LO document language
  61
  62         sal_Bool                m_bROLocale;
  63         sal_Bool                m_bROUILocale;
  64         sal_Bool                m_bROCurrency;
  65         sal_Bool                m_bRODatePatterns;
  66         sal_Bool                m_bRODecimalSeparator;
  67         sal_Bool                m_bROIgnoreLanguageChange;
  68
  69         static  const Sequence< /* const */ OUString >  GetPropertyNames();
  70         void                    MakeRealLocale();
  71         void                    MakeRealUILocale();
  72
  73 public:
  74                                 SvtSysLocaleOptions_Impl();
  75     virtual                     ~SvtSysLocaleOptions_Impl();
  76
  77     virtual void                Notify( const com::sun::star::uno::Sequence< OUString >& aPropertyNames );
  78     virtual void                Commit();
  79
  80             const OUString&     GetLocaleString() const
  81                                     { return m_aLocaleString; }
  82             void                SetLocaleString( const OUString& rStr );
  83
  84             const OUString&     GetUILocaleString() const
  85                                     { return m_aUILocaleString; }
  86             void                SetUILocaleString( const OUString& rStr );
  87
  88             const OUString&     GetCurrencyString() const
  89                                     { return m_aCurrencyString; }
  90             void                SetCurrencyString( const OUString& rStr );
  91
  92             const OUString&     GetDatePatternsString() const
  93                                     { return m_aDatePatternsString; }
  94             void                SetDatePatternsString( const OUString& rStr );
  95
  96             sal_Bool            IsDecimalSeparatorAsLocale() const { return m_bDecimalSeparator;}
  97             void                SetDecimalSeparatorAsLocale( sal_Bool bSet);
  98
  99             sal_Bool            IsIgnoreLanguageChange() const { return m_bIgnoreLanguageChange;}
 100             void                SetIgnoreLanguageChange( sal_Bool bSet);
 101
 102             sal_Bool            IsReadOnly( SvtSysLocaleOptions::EOption eOption ) const;
 103             const LanguageTag&  GetRealLocale() { return m_aRealLocale; }
 104             const LanguageTag&  GetRealUILocale() { return m_aRealUILocale; }
 105 };
 106
 107
 108 #define ROOTNODE_SYSLOCALE              OUString("Setup/L10N")
 109
 110 #define PROPERTYNAME_LOCALE             OUString("ooSetupSystemLocale")
 111 #define PROPERTYNAME_UILOCALE           OUString("ooLocale")
 112 #define PROPERTYNAME_CURRENCY           OUString("ooSetupCurrency")
 113 #define PROPERTYNAME_DECIMALSEPARATOR   OUString("DecimalSeparatorAsLocale")
 114 #define PROPERTYNAME_DATEPATTERNS       OUString("DateAcceptancePatterns")
 115 #define PROPERTYNAME_IGNORELANGCHANGE   OUString("IgnoreLanguageChange")
 116
 117 #define PROPERTYHANDLE_LOCALE           0
 118 #define PROPERTYHANDLE_UILOCALE         1
 119 #define PROPERTYHANDLE_CURRENCY         2
 120 #define PROPERTYHANDLE_DECIMALSEPARATOR 3
 121 #define PROPERTYHANDLE_DATEPATTERNS     4
 122 #define PROPERTYHANDLE_IGNORELANGCHANGE 5
 123
 124 //#define PROPERTYCOUNT                   5
 125 #define PROPERTYCOUNT                   6
 126
 127 const Sequence< OUString > SvtSysLocaleOptions_Impl::GetPropertyNames()
 128 {
 129     const OUString pProperties[] =
 130     {
 131         PROPERTYNAME_LOCALE,
 132         PROPERTYNAME_UILOCALE,
 133         PROPERTYNAME_CURRENCY,
 134         PROPERTYNAME_DECIMALSEPARATOR,
 135         PROPERTYNAME_DATEPATTERNS,
 136         PROPERTYNAME_IGNORELANGCHANGE
 137     };
 138     const Sequence< OUString > seqPropertyNames( pProperties, PROPERTYCOUNT );
 139     return seqPropertyNames;
 140 }
 141
 142 // -----------------------------------------------------------------------
 143
 144 SvtSysLocaleOptions_Impl::SvtSysLocaleOptions_Impl()
 145     : ConfigItem( ROOTNODE_SYSLOCALE )
 146     , m_aRealLocale( LANGUAGE_SYSTEM)
 147     , m_aRealUILocale( LANGUAGE_SYSTEM)
 148     , m_bDecimalSeparator( sal_True )
 149     , m_bROLocale(CFG_READONLY_DEFAULT)
 150     , m_bROUILocale(CFG_READONLY_DEFAULT)
 151     , m_bROCurrency(CFG_READONLY_DEFAULT)
 152     , m_bRODatePatterns(CFG_READONLY_DEFAULT)
 153     , m_bRODecimalSeparator(sal_False)
 154     , m_bROIgnoreLanguageChange(sal_False)
 155
 156 {
 157     if ( IsValidConfigMgr() )
 158     {
 159         const Sequence< OUString > aNames = GetPropertyNames();
 160         Sequence< Any > aValues = GetProperties( aNames );
 161         Sequence< sal_Bool > aROStates = GetReadOnlyStates( aNames );
 162         const Any* pValues = aValues.getConstArray();
 163         const sal_Bool* pROStates = aROStates.getConstArray();
 164         DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
 165         DBG_ASSERT( aROStates.getLength() == aNames.getLength(), "GetReadOnlyStates failed" );
 166         if ( aValues.getLength() == aNames.getLength() && aROStates.getLength() == aNames.getLength() )
 167         {
 168             for ( sal_Int32 nProp = 0; nProp < aNames.getLength(); nProp++ )
 169             {
 170                 if ( pValues[nProp].hasValue() )
 171                 {
 172                     switch ( nProp )
 173                     {
 174                         case PROPERTYHANDLE_LOCALE :
 175                             {
 176                                 OUString aStr;
 177                                 if ( pValues[nProp] >>= aStr )
 178                                     m_aLocaleString = aStr;
 179                                 else
 180                                 {
 181                                     SAL_WARN( "unotools.config", "Wrong property type!" );
 182                                 }
 183                                 m_bROLocale = pROStates[nProp];
 184                             }
 185                             break;
 186                         case PROPERTYHANDLE_UILOCALE :
 187                             {
 188                                 OUString aStr;
 189                                 if ( pValues[nProp] >>= aStr )
 190                                     m_aUILocaleString = aStr;
 191                                 else
 192                                 {
 193                                     SAL_WARN( "unotools.config", "Wrong property type!" );
 194                                 }
 195                                 m_bROUILocale = pROStates[nProp];
 196                             }
 197                             break;
 198                         case PROPERTYHANDLE_CURRENCY :
 199                             {
 200                                 OUString aStr;
 201                                 if ( pValues[nProp] >>= aStr )
 202                                     m_aCurrencyString = aStr;
 203                                 else
 204                                 {
 205                                     SAL_WARN( "unotools.config", "Wrong property type!" );
 206                                 }
 207                                 m_bROCurrency = pROStates[nProp];
 208                             }
 209                         break;
 210                         case  PROPERTYHANDLE_DECIMALSEPARATOR:
 211                         {
 212                                     sal_Bool bValue = sal_Bool();
 213                             if ( pValues[nProp] >>= bValue )
 214                                 m_bDecimalSeparator = bValue;
 215                             else
 216                             {
 217                                 SAL_WARN( "unotools.config", "Wrong property type!" );
 218                             }
 219                             m_bRODecimalSeparator = pROStates[nProp];
 220                         }
 221                         break;
 222                         case PROPERTYHANDLE_DATEPATTERNS :
 223                             {
 224                                 OUString aStr;
 225                                 if ( pValues[nProp] >>= aStr )
 226                                     m_aDatePatternsString = aStr;
 227                                 else
 228                                 {
 229                                     SAL_WARN( "unotools.config", "Wrong property type!" );
 230                                 }
 231                                 m_bRODatePatterns = pROStates[nProp];
 232                             }
 233                         break;
 234                         case PROPERTYHANDLE_IGNORELANGCHANGE :
 235                             {
 236                                 sal_Bool bValue = sal_Bool();
 237                                 if ( pValues[nProp] >>= bValue )
 238                                     m_bIgnoreLanguageChange = bValue;
 239                                 else
 240                                 {
 241                                     SAL_WARN( "unotools.config", "Wrong property type!" );
 242                                 }
 243                                 m_bROIgnoreLanguageChange = pROStates[nProp];
 244                             }
 245                         break;
 246                         default:
 247                             SAL_WARN( "unotools.config", "Wrong property type!" );
 248                     }
 249                 }
 250             }
 251         }
 252         EnableNotification( aNames );
 253     }
 254
 255     MakeRealLocale();
 256     MakeRealUILocale();
 257 }
 258
 259
 260 SvtSysLocaleOptions_Impl::~SvtSysLocaleOptions_Impl()
 261 {
 262     if ( IsModified() )
 263         Commit();
 264 }
 265
 266 void SvtSysLocaleOptions_Impl::MakeRealLocale()
 267 {
 268     if (m_aLocaleString.isEmpty())
 269     {
 270         LanguageType nLang = MsLangId::getSystemLanguage();
 271         m_aRealLocale.reset( nLang);
 272     }
 273     else
 274     {
 275         m_aRealLocale.reset( m_aLocaleString);
 276     }
 277 }
 278
 279 void SvtSysLocaleOptions_Impl::MakeRealUILocale()
 280 {
 281     if (m_aUILocaleString.isEmpty())
 282     {
 283         LanguageType nLang = MsLangId::getSystemUILanguage();
 284         m_aRealUILocale.reset( nLang);
 285     }
 286     else
 287     {
 288         m_aRealUILocale.reset( m_aUILocaleString);
 289     }
 290 }
 291
 292 sal_Bool SvtSysLocaleOptions_Impl::IsReadOnly( SvtSysLocaleOptions::EOption eOption ) const
 293 {
 294     sal_Bool bReadOnly = CFG_READONLY_DEFAULT;
 295     switch(eOption)
 296     {
 297         case SvtSysLocaleOptions::E_LOCALE :
 298             {
 299                 bReadOnly = m_bROLocale;
 300                 break;
 301             }
 302         case SvtSysLocaleOptions::E_UILOCALE :
 303             {
 304                 bReadOnly = m_bROUILocale;
 305                 break;
 306             }
 307         case SvtSysLocaleOptions::E_CURRENCY :
 308             {
 309                 bReadOnly = m_bROCurrency;
 310                 break;
 311             }
 312         case SvtSysLocaleOptions::E_DATEPATTERNS :
 313             {
 314                 bReadOnly = m_bRODatePatterns;
 315                 break;
 316             }
 317     }
 318     return bReadOnly;
 319 }
 320
 321
 322 void SvtSysLocaleOptions_Impl::Commit()
 323 {
 324     const Sequence< OUString > aOrgNames = GetPropertyNames();
 325     sal_Int32 nOrgCount = aOrgNames.getLength();
 326
 327     Sequence< OUString > aNames( nOrgCount );
 328     Sequence< Any > aValues( nOrgCount );
 329
 330     OUString* pNames = aNames.getArray();
 331     Any* pValues = aValues.getArray();
 332     sal_Int32 nRealCount = 0;
 333
 334     for ( sal_Int32 nProp = 0; nProp < nOrgCount; nProp++ )
 335     {
 336         switch ( nProp )
 337         {
 338             case PROPERTYHANDLE_LOCALE :
 339                 {
 340                     if (!m_bROLocale)
 341                     {
 342                         pNames[nRealCount] = aOrgNames[nProp];
 343                         pValues[nRealCount] <<= m_aLocaleString;
 344                         ++nRealCount;
 345                     }
 346                 }
 347                 break;
 348             case PROPERTYHANDLE_UILOCALE :
 349                 {
 350                     if (!m_bROUILocale)
 351                     {
 352                         pNames[nRealCount] = aOrgNames[nProp];
 353                         pValues[nRealCount] <<= m_aUILocaleString;
 354                         ++nRealCount;
 355                     }
 356                 }
 357                 break;
 358             case PROPERTYHANDLE_CURRENCY :
 359                 {
 360                     if (!m_bROCurrency)
 361                     {
 362                         pNames[nRealCount] = aOrgNames[nProp];
 363                         pValues[nRealCount] <<= m_aCurrencyString;
 364                         ++nRealCount;
 365                     }
 366                 }
 367                 break;
 368             case PROPERTYHANDLE_DECIMALSEPARATOR:
 369                 if( !m_bRODecimalSeparator )
 370                 {
 371                     pNames[nRealCount] = aOrgNames[nProp];
 372                     pValues[nRealCount] <<= m_bDecimalSeparator;
 373                     ++nRealCount;
 374                 }
 375             break;
 376             case PROPERTYHANDLE_DATEPATTERNS :
 377                 if (!m_bRODatePatterns)
 378                 {
 379                     pNames[nRealCount] = aOrgNames[nProp];
 380                     pValues[nRealCount] <<= m_aDatePatternsString;
 381                     ++nRealCount;
 382                 }
 383                 break;
 384             case PROPERTYHANDLE_IGNORELANGCHANGE :
 385                 if (!m_bROIgnoreLanguageChange)
 386                 {
 387                     pNames[nRealCount] = aOrgNames[nProp];
 388                     pValues[nRealCount] <<= m_bIgnoreLanguageChange;
 389                     ++nRealCount;
 390                 }
 391                 break;
 392             default:
 393                 SAL_WARN( "unotools.config", "invalid index to save a path" );
 394         }
 395     }
 396     aNames.realloc(nRealCount);
 397     aValues.realloc(nRealCount);
 398     PutProperties( aNames, aValues );
 399     ClearModified();
 400 }
 401
 402
 403 void SvtSysLocaleOptions_Impl::SetLocaleString( const OUString& rStr )
 404 {
 405     if (!m_bROLocale && rStr != m_aLocaleString )
 406     {
 407         m_aLocaleString = rStr;
 408         MakeRealLocale();
 409         MsLangId::setConfiguredSystemLanguage( m_aRealLocale.getLanguageType() );
 410         SetModified();
 411         sal_uLong nHint = SYSLOCALEOPTIONS_HINT_LOCALE;
 412         if ( m_aCurrencyString.isEmpty() )
 413             nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY;
 414         NotifyListeners( nHint );
 415     }
 416 }
 417
 418 void SvtSysLocaleOptions_Impl::SetUILocaleString( const OUString& rStr )
 419 {
 420     if (!m_bROUILocale && rStr != m_aUILocaleString )
 421     {
 422         m_aUILocaleString = rStr;
 423
 424         // as we can't switch UILocale at runtime, we only store changes in the configuration
 425         MakeRealUILocale();
 426         MsLangId::setConfiguredSystemLanguage( m_aRealUILocale.getLanguageType() );
 427         SetModified();
 428         NotifyListeners( SYSLOCALEOPTIONS_HINT_UILOCALE );
 429     }
 430 }
 431
 432 void SvtSysLocaleOptions_Impl::SetCurrencyString( const OUString& rStr )
 433 {
 434     if (!m_bROCurrency && rStr != m_aCurrencyString )
 435     {
 436         m_aCurrencyString = rStr;
 437         SetModified();
 438         NotifyListeners( SYSLOCALEOPTIONS_HINT_CURRENCY );
 439     }
 440 }
 441
 442 void SvtSysLocaleOptions_Impl::SetDatePatternsString( const OUString& rStr )
 443 {
 444     if (!m_bRODatePatterns && rStr != m_aDatePatternsString )
 445     {
 446         m_aDatePatternsString = rStr;
 447         SetModified();
 448         NotifyListeners( SYSLOCALEOPTIONS_HINT_DATEPATTERNS );
 449     }
 450 }
 451
 452 void SvtSysLocaleOptions_Impl::SetDecimalSeparatorAsLocale( sal_Bool bSet)
 453 {
 454     if(bSet != m_bDecimalSeparator)
 455     {
 456         m_bDecimalSeparator = bSet;
 457         SetModified();
 458         NotifyListeners( SYSLOCALEOPTIONS_HINT_DECSEP );
 459     }
 460 }
 461
 462 void SvtSysLocaleOptions_Impl::SetIgnoreLanguageChange( sal_Bool bSet)
 463 {
 464     if(bSet != m_bIgnoreLanguageChange)
 465     {
 466         m_bIgnoreLanguageChange = bSet;
 467         SetModified();
 468         NotifyListeners( SYSLOCALEOPTIONS_HINT_IGNORELANG );
 469     }
 470 }
 471
 472 void SvtSysLocaleOptions_Impl::Notify( const Sequence< OUString >& seqPropertyNames )
 473 {
 474     sal_uLong nHint = 0;
 475     Sequence< Any > seqValues = GetProperties( seqPropertyNames );
 476     Sequence< sal_Bool > seqROStates = GetReadOnlyStates( seqPropertyNames );
 477     sal_Int32 nCount = seqPropertyNames.getLength();
 478     for( sal_Int32 nProp = 0; nProp < nCount; ++nProp )
 479     {
 480         if( seqPropertyNames[nProp] == PROPERTYNAME_LOCALE )
 481         {
 482             DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Locale property type" );
 483             seqValues[nProp] >>= m_aLocaleString;
 484             m_bROLocale = seqROStates[nProp];
 485             nHint |= SYSLOCALEOPTIONS_HINT_LOCALE;
 486             if ( m_aCurrencyString.isEmpty() )
 487                 nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY;
 488             MakeRealLocale();
 489         }
 490         if( seqPropertyNames[nProp] == PROPERTYNAME_UILOCALE )
 491         {
 492             DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Locale property type" );
 493             seqValues[nProp] >>= m_aUILocaleString;
 494             m_bROUILocale = seqROStates[nProp];
 495             nHint |= SYSLOCALEOPTIONS_HINT_UILOCALE;
 496             MakeRealUILocale();
 497         }
 498         else if( seqPropertyNames[nProp] == PROPERTYNAME_CURRENCY )
 499         {
 500             DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "Currency property type" );
 501             seqValues[nProp] >>= m_aCurrencyString;
 502             m_bROCurrency = seqROStates[nProp];
 503             nHint |= SYSLOCALEOPTIONS_HINT_CURRENCY;
 504         }
 505         else if( seqPropertyNames[nProp] == PROPERTYNAME_DECIMALSEPARATOR )
 506         {
 507             seqValues[nProp] >>= m_bDecimalSeparator;
 508             m_bRODecimalSeparator = seqROStates[nProp];
 509         }
 510         else if( seqPropertyNames[nProp] == PROPERTYNAME_IGNORELANGCHANGE )
 511         {
 512             seqValues[nProp] >>= m_bIgnoreLanguageChange;
 513             m_bROIgnoreLanguageChange = seqROStates[nProp];
 514         }
 515         else if( seqPropertyNames[nProp] == PROPERTYNAME_DATEPATTERNS )
 516         {
 517             DBG_ASSERT( seqValues[nProp].getValueTypeClass() == TypeClass_STRING, "DatePatterns property type" );
 518             seqValues[nProp] >>= m_aDatePatternsString;
 519             m_bRODatePatterns = seqROStates[nProp];
 520             nHint |= SYSLOCALEOPTIONS_HINT_DATEPATTERNS;
 521         }
 522     }
 523     if ( nHint )
 524         NotifyListeners( nHint );
 525 }
 526
 527 // ====================================================================
 528
 529 SvtSysLocaleOptions::SvtSysLocaleOptions()
 530 {
 531     MutexGuard aGuard( GetMutex() );
 532     if ( !pOptions )
 533     {
 534         RTL_LOGFILE_CONTEXT(aLog, "svl ( ??? ) ::SvtSysLocaleOptions_Impl::ctor()");
 535         pOptions = new SvtSysLocaleOptions_Impl;
 536
 537         ItemHolder1::holdConfigItem(E_SYSLOCALEOPTIONS);
 538     }
 539     ++nRefCount;
 540     pOptions->AddListener(this);
 541 }
 542
 543
 544 SvtSysLocaleOptions::~SvtSysLocaleOptions()
 545 {
 546     MutexGuard aGuard( GetMutex() );
 547     pOptions->RemoveListener(this);
 548     if ( !--nRefCount )
 549     {
 550         delete pOptions;
 551         pOptions = NULL;
 552     }
 553 }
 554
 555
 556 // static
 557 Mutex& SvtSysLocaleOptions::GetMutex()
 558 {
 559     static Mutex* pMutex = NULL;
 560     if( !pMutex )
 561     {
 562         MutexGuard aGuard( Mutex::getGlobalMutex() );
 563         if( !pMutex )
 564         {
 565             // #i77768# Due to a static reference in the toolkit lib
 566             // we need a mutex that lives longer than the svl library.
 567             // Otherwise the dtor would use a destructed mutex!!
 568             pMutex = new Mutex;
 569         }
 570     }
 571     return *pMutex;
 572 }
 573
 574
 575 sal_Bool SvtSysLocaleOptions::IsModified()
 576 {
 577     MutexGuard aGuard( GetMutex() );
 578     return pOptions->IsModified();
 579 }
 580
 581
 582 void SvtSysLocaleOptions::Commit()
 583 {
 584     MutexGuard aGuard( GetMutex() );
 585     pOptions->Commit();
 586 }
 587
 588
 589 void SvtSysLocaleOptions::BlockBroadcasts( bool bBlock )
 590 {
 591     MutexGuard aGuard( GetMutex() );
 592     pOptions->BlockBroadcasts( bBlock );
 593 }
 594
 595
 596 const OUString& SvtSysLocaleOptions::GetLocaleConfigString() const
 597 {
 598     MutexGuard aGuard( GetMutex() );
 599     return pOptions->GetLocaleString();
 600 }
 601
 602 void SvtSysLocaleOptions::SetLocaleConfigString( const OUString& rStr )
 603 {
 604     MutexGuard aGuard( GetMutex() );
 605     pOptions->SetLocaleString( rStr );
 606 }
 607
 608 void SvtSysLocaleOptions::SetUILocaleConfigString( const OUString& rStr )
 609 {
 610     MutexGuard aGuard( GetMutex() );
 611     pOptions->SetUILocaleString( rStr );
 612 }
 613
 614 const OUString& SvtSysLocaleOptions::GetCurrencyConfigString() const
 615 {
 616     MutexGuard aGuard( GetMutex() );
 617     return pOptions->GetCurrencyString();
 618 }
 619
 620
 621 void SvtSysLocaleOptions::SetCurrencyConfigString( const OUString& rStr )
 622 {
 623     MutexGuard aGuard( GetMutex() );
 624     pOptions->SetCurrencyString( rStr );
 625 }
 626
 627 const OUString& SvtSysLocaleOptions::GetDatePatternsConfigString() const
 628 {
 629     MutexGuard aGuard( GetMutex() );
 630     return pOptions->GetDatePatternsString();
 631 }
 632
 633 void SvtSysLocaleOptions::SetDatePatternsConfigString( const OUString& rStr )
 634 {
 635     MutexGuard aGuard( GetMutex() );
 636     pOptions->SetDatePatternsString( rStr );
 637 }
 638
 639 sal_Bool SvtSysLocaleOptions::IsDecimalSeparatorAsLocale() const
 640 {
 641     MutexGuard aGuard( GetMutex() );
 642     return pOptions->IsDecimalSeparatorAsLocale();
 643 }
 644
 645 void SvtSysLocaleOptions::SetDecimalSeparatorAsLocale( sal_Bool bSet)
 646 {
 647     MutexGuard aGuard( GetMutex() );
 648     pOptions->SetDecimalSeparatorAsLocale(bSet);
 649 }
 650
 651 sal_Bool SvtSysLocaleOptions::IsIgnoreLanguageChange() const
 652 {
 653     MutexGuard aGuard( GetMutex() );
 654     return pOptions->IsIgnoreLanguageChange();
 655 }
 656
 657 void SvtSysLocaleOptions::SetIgnoreLanguageChange( sal_Bool bSet)
 658 {
 659     MutexGuard aGuard( GetMutex() );
 660     pOptions->SetIgnoreLanguageChange(bSet);
 661 }
 662
 663 sal_Bool SvtSysLocaleOptions::IsReadOnly( EOption eOption ) const
 664 {
 665     MutexGuard aGuard( GetMutex() );
 666     return pOptions->IsReadOnly( eOption );
 667 }
 668
 669 // static
 670 void SvtSysLocaleOptions::GetCurrencyAbbrevAndLanguage( String& rAbbrev,
 671         LanguageType& eLang, const OUString& rConfigString )
 672 {
 673     sal_Int32 nDelim = rConfigString.indexOf( '-' );
 674     if ( nDelim >= 0 )
 675     {
 676         rAbbrev = rConfigString.copy( 0, nDelim );
 677         String aIsoStr( rConfigString.copy( nDelim+1 ) );
 678         eLang = LanguageTag( aIsoStr ).getLanguageType();
 679     }
 680     else
 681     {
 682         rAbbrev = rConfigString;
 683         eLang = (rAbbrev.Len() ? LANGUAGE_NONE : LANGUAGE_SYSTEM);
 684     }
 685 }
 686
 687
 688 // static
 689 OUString SvtSysLocaleOptions::CreateCurrencyConfigString(
 690         const String& rAbbrev, LanguageType eLang )
 691 {
 692     String aIsoStr( LanguageTag( eLang ).getBcp47() );
 693     if ( aIsoStr.Len() )
 694     {
 695         OUStringBuffer aStr( rAbbrev.Len() + 1 + aIsoStr.Len() );
 696         aStr.append( rAbbrev );
 697         aStr.append( sal_Unicode('-') );
 698         aStr.append( aIsoStr );
 699         return aStr.makeStringAndClear();
 700     }
 701     else
 702         return rAbbrev;
 703 }
 704
 705
 706 // static
 707 void SvtSysLocaleOptions::SetCurrencyChangeLink( const Link& rLink )
 708 {
 709     MutexGuard aGuard( GetMutex() );
 710     DBG_ASSERT( !CurrencyChangeLink::get().IsSet(), "SvtSysLocaleOptions::SetCurrencyChangeLink: already set" );
 711     CurrencyChangeLink::get() = rLink;
 712 }
 713
 714
 715 // static
 716 const Link& SvtSysLocaleOptions::GetCurrencyChangeLink()
 717 {
 718     MutexGuard aGuard( GetMutex() );
 719     return CurrencyChangeLink::get();
 720 }
 721
 722
 723 void SvtSysLocaleOptions::ConfigurationChanged( utl::ConfigurationBroadcaster* p, sal_uInt32 nHint  )
 724 {
 725     if ( nHint & SYSLOCALEOPTIONS_HINT_CURRENCY )
 726     {
 727         const Link& rLink = GetCurrencyChangeLink();
 728         if ( rLink.IsSet() )
 729             rLink.Call( NULL );
 730     }
 731
 732     ::utl::detail::Options::ConfigurationChanged( p, nHint );
 733 }
 734
 735 LanguageTag SvtSysLocaleOptions::GetLanguageTag() const
 736 {
 737     return LanguageTag( GetLocaleConfigString() );
 738 }
 739
 740 const LanguageTag & SvtSysLocaleOptions::GetRealLanguageTag() const
 741 {
 742     return pOptions->GetRealLocale();
 743 }
 744
 745 const LanguageTag & SvtSysLocaleOptions::GetRealUILanguageTag() const
 746 {
 747     return pOptions->GetRealUILocale();
 748 }
 749
 750
 751 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */