svl/source/config/ctloptions.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
  21 #include <svl/ctloptions.hxx>
  22
  23 #include <svl/languageoptions.hxx>
  24 #include <i18nlangtag/mslangid.hxx>
  25 #include <unotools/configitem.hxx>
  26 #include <tools/debug.hxx>
  27 #include <com/sun/star/uno/Any.h>
  28 #include <com/sun/star/uno/Sequence.hxx>
  29 #include <osl/mutex.hxx>
  30 #include <svl/smplhint.hxx>
  31 #include <rtl/instance.hxx>
  32 #include <unotools/syslocale.hxx>
  33 #include <itemholder2.hxx>
  34
  35 using namespace ::com::sun::star;
  36 using namespace ::com::sun::star::uno;
  37
  38 #define CFG_READONLY_DEFAULT    sal_False
  39
  40 // SvtCJKOptions_Impl ----------------------------------------------------------
  41
  42 class SvtCTLOptions_Impl : public utl::ConfigItem
  43 {
  44 private:
  45     bool                        m_bIsLoaded;
  46     bool                        m_bCTLFontEnabled;
  47     bool                        m_bCTLSequenceChecking;
  48     bool                        m_bCTLRestricted;
  49     bool                        m_bCTLTypeAndReplace;
  50     SvtCTLOptions::CursorMovement   m_eCTLCursorMovement;
  51     SvtCTLOptions::TextNumerals     m_eCTLTextNumerals;
  52
  53     bool                        m_bROCTLFontEnabled;
  54     bool                        m_bROCTLSequenceChecking;
  55     bool                        m_bROCTLRestricted;
  56     bool                        m_bROCTLTypeAndReplace;
  57     bool                        m_bROCTLCursorMovement;
  58     bool                        m_bROCTLTextNumerals;
  59
  60 public:
  61     SvtCTLOptions_Impl();
  62     ~SvtCTLOptions_Impl();
  63
  64     virtual void    Notify( const Sequence< OUString >& _aPropertyNames );
  65     virtual void    Commit();
  66     void            Load();
  67
  68     bool            IsLoaded() { return m_bIsLoaded; }
  69     void            SetCTLFontEnabled( bool _bEnabled );
  70     bool            IsCTLFontEnabled() const { return m_bCTLFontEnabled; }
  71
  72     void            SetCTLSequenceChecking( bool _bEnabled );
  73     bool            IsCTLSequenceChecking() const { return m_bCTLSequenceChecking;}
  74
  75     void            SetCTLSequenceCheckingRestricted( bool _bEnable );
  76     bool            IsCTLSequenceCheckingRestricted( void ) const   { return m_bCTLRestricted; }
  77
  78     void            SetCTLSequenceCheckingTypeAndReplace( bool _bEnable );
  79     bool            IsCTLSequenceCheckingTypeAndReplace() const { return m_bCTLTypeAndReplace; }
  80
  81     void            SetCTLCursorMovement( SvtCTLOptions::CursorMovement _eMovement );
  82     SvtCTLOptions::CursorMovement
  83                     GetCTLCursorMovement() const { return m_eCTLCursorMovement; }
  84
  85     void            SetCTLTextNumerals( SvtCTLOptions::TextNumerals _eNumerals );
  86     SvtCTLOptions::TextNumerals
  87                     GetCTLTextNumerals() const { return m_eCTLTextNumerals; }
  88
  89     bool            IsReadOnly(SvtCTLOptions::EOption eOption) const;
  90 };
  91 namespace
  92 {
  93     struct PropertyNames
  94         : public rtl::Static< Sequence< OUString >, PropertyNames > {};
  95 }
  96 bool SvtCTLOptions_Impl::IsReadOnly(SvtCTLOptions::EOption eOption) const
  97 {
  98     bool bReadOnly = CFG_READONLY_DEFAULT;
  99     switch(eOption)
 100     {
 101         case SvtCTLOptions::E_CTLFONT             : bReadOnly = m_bROCTLFontEnabled       ; break;
 102         case SvtCTLOptions::E_CTLSEQUENCECHECKING : bReadOnly = m_bROCTLSequenceChecking  ; break;
 103         case SvtCTLOptions::E_CTLCURSORMOVEMENT   : bReadOnly = m_bROCTLCursorMovement    ; break;
 104         case SvtCTLOptions::E_CTLTEXTNUMERALS     : bReadOnly = m_bROCTLTextNumerals      ; break;
 105         case SvtCTLOptions::E_CTLSEQUENCECHECKINGRESTRICTED: bReadOnly = m_bROCTLRestricted  ; break;
 106         case SvtCTLOptions::E_CTLSEQUENCECHECKINGTYPEANDREPLACE: bReadOnly = m_bROCTLTypeAndReplace; break;
 107         default: OSL_FAIL(  "SvtCTLOptions_Impl::IsReadOnly() - invalid option" );
 108     }
 109     return bReadOnly;
 110 }
 111 SvtCTLOptions_Impl::SvtCTLOptions_Impl() :
 112
 113     utl::ConfigItem("Office.Common/I18N/CTL"),
 114
 115     m_bIsLoaded             ( sal_False ),
 116     m_bCTLFontEnabled       ( sal_False ),
 117     m_bCTLSequenceChecking  ( sal_False ),
 118     m_bCTLRestricted        ( sal_False ),
 119     m_bCTLTypeAndReplace    ( sal_False ),
 120     m_eCTLCursorMovement    ( SvtCTLOptions::MOVEMENT_LOGICAL ),
 121     m_eCTLTextNumerals      ( SvtCTLOptions::NUMERALS_ARABIC ),
 122
 123     m_bROCTLFontEnabled     ( CFG_READONLY_DEFAULT ),
 124     m_bROCTLSequenceChecking( CFG_READONLY_DEFAULT ),
 125     m_bROCTLRestricted      ( CFG_READONLY_DEFAULT ),
 126     m_bROCTLTypeAndReplace  ( CFG_READONLY_DEFAULT ),
 127     m_bROCTLCursorMovement  ( CFG_READONLY_DEFAULT ),
 128     m_bROCTLTextNumerals    ( CFG_READONLY_DEFAULT )
 129 {
 130 }
 131 SvtCTLOptions_Impl::~SvtCTLOptions_Impl()
 132 {
 133     if ( IsModified() == sal_True )
 134         Commit();
 135 }
 136 // -----------------------------------------------------------------------------
 137 void SvtCTLOptions_Impl::Notify( const Sequence< OUString >& )
 138 {
 139     Load();
 140     NotifyListeners(SFX_HINT_CTL_SETTINGS_CHANGED);
 141 }
 142 // -----------------------------------------------------------------------------
 143 void SvtCTLOptions_Impl::Commit()
 144 {
 145     Sequence< OUString > &rPropertyNames = PropertyNames::get();
 146     OUString* pOrgNames = rPropertyNames.getArray();
 147     sal_Int32 nOrgCount = rPropertyNames.getLength();
 148
 149     Sequence< OUString > aNames( nOrgCount );
 150     Sequence< Any > aValues( nOrgCount );
 151
 152     OUString* pNames = aNames.getArray();
 153     Any* pValues = aValues.getArray();
 154     sal_Int32 nRealCount = 0;
 155
 156     const uno::Type& rType = ::getBooleanCppuType();
 157
 158     for ( int nProp = 0; nProp < nOrgCount; nProp++ )
 159     {
 160         switch ( nProp )
 161         {
 162             case  0:
 163             {
 164                 if (!m_bROCTLFontEnabled)
 165                 {
 166                     pNames[nRealCount] = pOrgNames[nProp];
 167                     pValues[nRealCount].setValue( &m_bCTLFontEnabled, rType );
 168                     ++nRealCount;
 169                 }
 170             }
 171             break;
 172
 173             case  1:
 174             {
 175                 if (!m_bROCTLSequenceChecking)
 176                 {
 177                     pNames[nRealCount] = pOrgNames[nProp];
 178                     pValues[nRealCount].setValue( &m_bCTLSequenceChecking, rType );
 179                     ++nRealCount;
 180                 }
 181             }
 182             break;
 183
 184             case  2:
 185             {
 186                 if (!m_bROCTLCursorMovement)
 187                 {
 188                     pNames[nRealCount] = pOrgNames[nProp];
 189                     pValues[nRealCount] <<= (sal_Int32)m_eCTLCursorMovement;
 190                     ++nRealCount;
 191                 }
 192             }
 193             break;
 194
 195             case  3:
 196             {
 197                 if (!m_bROCTLTextNumerals)
 198                 {
 199                     pNames[nRealCount] = pOrgNames[nProp];
 200                     pValues[nRealCount] <<= (sal_Int32)m_eCTLTextNumerals;
 201                     ++nRealCount;
 202                 }
 203             }
 204             break;
 205
 206             case  4:
 207             {
 208                 if (!m_bROCTLRestricted)
 209                 {
 210                     pNames[nRealCount] = pOrgNames[nProp];
 211                     pValues[nRealCount].setValue( &m_bCTLRestricted, rType );
 212                     ++nRealCount;
 213                 }
 214             }
 215             break;
 216             case 5:
 217             {
 218                 if(!m_bROCTLTypeAndReplace)
 219                 {
 220                     pNames[nRealCount] = pOrgNames[nProp];
 221                     pValues[nRealCount].setValue( &m_bCTLTypeAndReplace, rType );
 222                     ++nRealCount;
 223                 }
 224             }
 225             break;
 226         }
 227     }
 228     aNames.realloc(nRealCount);
 229     aValues.realloc(nRealCount);
 230     PutProperties( aNames, aValues );
 231     //broadcast changes
 232     NotifyListeners(SFX_HINT_CTL_SETTINGS_CHANGED);
 233 }
 234 // -----------------------------------------------------------------------------
 235 void SvtCTLOptions_Impl::Load()
 236 {
 237     Sequence< OUString >& rPropertyNames = PropertyNames::get();
 238     if ( !rPropertyNames.getLength() )
 239     {
 240         rPropertyNames.realloc(6);
 241         OUString* pNames = rPropertyNames.getArray();
 242         pNames[0] = "CTLFont";
 243         pNames[1] = "CTLSequenceChecking";
 244         pNames[2] = "CTLCursorMovement";
 245         pNames[3] = "CTLTextNumerals";
 246         pNames[4] = "CTLSequenceCheckingRestricted";
 247         pNames[5] = "CTLSequenceCheckingTypeAndReplace";
 248         EnableNotification( rPropertyNames );
 249     }
 250     Sequence< Any > aValues = GetProperties( rPropertyNames );
 251     Sequence< sal_Bool > aROStates = GetReadOnlyStates( rPropertyNames );
 252     const Any* pValues = aValues.getConstArray();
 253     const sal_Bool* pROStates = aROStates.getConstArray();
 254     DBG_ASSERT( aValues.getLength() == rPropertyNames.getLength(), "GetProperties failed" );
 255     DBG_ASSERT( aROStates.getLength() == rPropertyNames.getLength(), "GetReadOnlyStates failed" );
 256     if ( aValues.getLength() == rPropertyNames.getLength() && aROStates.getLength() == rPropertyNames.getLength() )
 257     {
 258         sal_Bool bValue = sal_False;
 259         sal_Int32 nValue = 0;
 260
 261         for ( int nProp = 0; nProp < rPropertyNames.getLength(); nProp++ )
 262         {
 263             if ( pValues[nProp].hasValue() )
 264             {
 265                 if ( pValues[nProp] >>= bValue )
 266                 {
 267                     switch ( nProp )
 268                     {
 269                         case 0: { m_bCTLFontEnabled = bValue; m_bROCTLFontEnabled = pROStates[nProp]; } break;
 270                         case 1: { m_bCTLSequenceChecking = bValue; m_bROCTLSequenceChecking = pROStates[nProp]; } break;
 271                         case 4: { m_bCTLRestricted = bValue; m_bROCTLRestricted = pROStates[nProp]; } break;
 272                         case 5: { m_bCTLTypeAndReplace = bValue; m_bROCTLTypeAndReplace = pROStates[nProp]; } break;
 273                     }
 274                 }
 275                 else if ( pValues[nProp] >>= nValue )
 276                 {
 277                     switch ( nProp )
 278                     {
 279                         case 2: { m_eCTLCursorMovement = (SvtCTLOptions::CursorMovement)nValue; m_bROCTLCursorMovement = pROStates[nProp]; } break;
 280                         case 3: { m_eCTLTextNumerals = (SvtCTLOptions::TextNumerals)nValue; m_bROCTLTextNumerals = pROStates[nProp]; } break;
 281                     }
 282                 }
 283             }
 284         }
 285     }
 286
 287     if (!m_bCTLFontEnabled)
 288     {
 289         bool bAutoEnableCTL = false;
 290
 291         sal_uInt16 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage(LANGUAGE_SYSTEM);
 292         //system locale is CTL
 293         bAutoEnableCTL = (nScriptType & SCRIPTTYPE_COMPLEX);
 294
 295         LanguageType eSystemLanguage = LANGUAGE_SYSTEM;
 296
 297         if (!bAutoEnableCTL)
 298         {
 299             SvtSystemLanguageOptions aSystemLocaleSettings;
 300
 301             //windows secondary system locale is CTL
 302             eSystemLanguage = aSystemLocaleSettings.GetWin16SystemLanguage();
 303             if (eSystemLanguage != LANGUAGE_SYSTEM)
 304             {
 305                 sal_uInt16 nWinScript = SvtLanguageOptions::GetScriptTypeOfLanguage( eSystemLanguage );
 306                 bAutoEnableCTL = (nWinScript & SCRIPTTYPE_COMPLEX);
 307             }
 308
 309             //CTL keyboard is installed
 310             if (!bAutoEnableCTL)
 311                 bAutoEnableCTL = aSystemLocaleSettings.isCTLKeyboardLayoutInstalled();
 312         }
 313
 314         if (bAutoEnableCTL)
 315         {
 316             m_bCTLFontEnabled = sal_True;
 317             sal_uInt16 nLanguage = SvtSysLocale().GetLanguageTag().getLanguageType();
 318             //enable sequence checking for the appropriate languages
 319             m_bCTLSequenceChecking = m_bCTLRestricted = m_bCTLTypeAndReplace =
 320                 (MsLangId::needsSequenceChecking( nLanguage) ||
 321                  MsLangId::needsSequenceChecking( eSystemLanguage));
 322             Commit();
 323         }
 324     }
 325
 326     m_bIsLoaded = sal_True;
 327 }
 328 void SvtCTLOptions_Impl::SetCTLFontEnabled( bool _bEnabled )
 329 {
 330     if(!m_bROCTLFontEnabled && m_bCTLFontEnabled != _bEnabled)
 331     {
 332         m_bCTLFontEnabled = _bEnabled;
 333         SetModified();
 334         NotifyListeners(0);
 335     }
 336 }
 337 void SvtCTLOptions_Impl::SetCTLSequenceChecking( bool _bEnabled )
 338 {
 339     if(!m_bROCTLSequenceChecking && m_bCTLSequenceChecking != _bEnabled)
 340     {
 341         SetModified();
 342         m_bCTLSequenceChecking = _bEnabled;
 343         NotifyListeners(0);
 344     }
 345 }
 346 void SvtCTLOptions_Impl::SetCTLSequenceCheckingRestricted( bool _bEnabled )
 347 {
 348     if(!m_bROCTLRestricted && m_bCTLRestricted != _bEnabled)
 349     {
 350         SetModified();
 351         m_bCTLRestricted = _bEnabled;
 352         NotifyListeners(0);
 353     }
 354 }
 355 void  SvtCTLOptions_Impl::SetCTLSequenceCheckingTypeAndReplace( bool _bEnabled )
 356 {
 357     if(!m_bROCTLTypeAndReplace && m_bCTLTypeAndReplace != _bEnabled)
 358     {
 359         SetModified();
 360         m_bCTLTypeAndReplace = _bEnabled;
 361         NotifyListeners(0);
 362     }
 363 }
 364 void SvtCTLOptions_Impl::SetCTLCursorMovement( SvtCTLOptions::CursorMovement _eMovement )
 365 {
 366     if (!m_bROCTLCursorMovement && m_eCTLCursorMovement != _eMovement )
 367     {
 368         SetModified();
 369         m_eCTLCursorMovement = _eMovement;
 370         NotifyListeners(0);
 371     }
 372 }
 373 void SvtCTLOptions_Impl::SetCTLTextNumerals( SvtCTLOptions::TextNumerals _eNumerals )
 374 {
 375     if (!m_bROCTLTextNumerals && m_eCTLTextNumerals != _eNumerals )
 376     {
 377         SetModified();
 378         m_eCTLTextNumerals = _eNumerals;
 379         NotifyListeners(0);
 380     }
 381 }
 382 // global ----------------------------------------------------------------
 383
 384 static SvtCTLOptions_Impl*  pCTLOptions = NULL;
 385 static sal_Int32            nCTLRefCount = 0;
 386 namespace { struct CTLMutex : public rtl::Static< osl::Mutex, CTLMutex > {}; }
 387
 388 // class SvtCTLOptions --------------------------------------------------
 389
 390 SvtCTLOptions::SvtCTLOptions( bool bDontLoad )
 391 {
 392     // Global access, must be guarded (multithreading)
 393     ::osl::MutexGuard aGuard( CTLMutex::get() );
 394     if ( !pCTLOptions )
 395     {
 396         pCTLOptions = new SvtCTLOptions_Impl;
 397         ItemHolder2::holdConfigItem(E_CTLOPTIONS);
 398     }
 399     if( !bDontLoad && !pCTLOptions->IsLoaded() )
 400         pCTLOptions->Load();
 401
 402     ++nCTLRefCount;
 403     m_pImp = pCTLOptions;
 404     m_pImp->AddListener(this);
 405 }
 406
 407 // -----------------------------------------------------------------------
 408
 409 SvtCTLOptions::~SvtCTLOptions()
 410 {
 411     // Global access, must be guarded (multithreading)
 412     ::osl::MutexGuard aGuard( CTLMutex::get() );
 413
 414     m_pImp->RemoveListener(this);
 415     if ( !--nCTLRefCount )
 416         DELETEZ( pCTLOptions );
 417 }
 418 // -----------------------------------------------------------------------------
 419 void SvtCTLOptions::SetCTLFontEnabled( bool _bEnabled )
 420 {
 421     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 422     pCTLOptions->SetCTLFontEnabled( _bEnabled );
 423 }
 424 // -----------------------------------------------------------------------------
 425 bool SvtCTLOptions::IsCTLFontEnabled() const
 426 {
 427     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 428     return pCTLOptions->IsCTLFontEnabled();
 429 }
 430 // -----------------------------------------------------------------------------
 431 void SvtCTLOptions::SetCTLSequenceChecking( bool _bEnabled )
 432 {
 433     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 434     pCTLOptions->SetCTLSequenceChecking(_bEnabled);
 435 }
 436 // -----------------------------------------------------------------------------
 437 bool SvtCTLOptions::IsCTLSequenceChecking() const
 438 {
 439     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 440     return pCTLOptions->IsCTLSequenceChecking();
 441 }
 442 // -----------------------------------------------------------------------------
 443 void SvtCTLOptions::SetCTLSequenceCheckingRestricted( bool _bEnable )
 444 {
 445     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 446     pCTLOptions->SetCTLSequenceCheckingRestricted(_bEnable);
 447 }
 448 // -----------------------------------------------------------------------------
 449 bool SvtCTLOptions::IsCTLSequenceCheckingRestricted( void ) const
 450 {
 451     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 452     return pCTLOptions->IsCTLSequenceCheckingRestricted();
 453 }
 454 // -----------------------------------------------------------------------------
 455 void SvtCTLOptions::SetCTLSequenceCheckingTypeAndReplace( bool _bEnable )
 456 {
 457     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 458     pCTLOptions->SetCTLSequenceCheckingTypeAndReplace(_bEnable);
 459 }
 460 // -----------------------------------------------------------------------------
 461 bool SvtCTLOptions::IsCTLSequenceCheckingTypeAndReplace() const
 462 {
 463     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 464     return pCTLOptions->IsCTLSequenceCheckingTypeAndReplace();
 465 }
 466 // -----------------------------------------------------------------------------
 467 void SvtCTLOptions::SetCTLCursorMovement( SvtCTLOptions::CursorMovement _eMovement )
 468 {
 469     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 470     pCTLOptions->SetCTLCursorMovement( _eMovement );
 471 }
 472 // -----------------------------------------------------------------------------
 473 SvtCTLOptions::CursorMovement SvtCTLOptions::GetCTLCursorMovement() const
 474 {
 475     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 476     return pCTLOptions->GetCTLCursorMovement();
 477 }
 478 // -----------------------------------------------------------------------------
 479 void SvtCTLOptions::SetCTLTextNumerals( SvtCTLOptions::TextNumerals _eNumerals )
 480 {
 481     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 482     pCTLOptions->SetCTLTextNumerals( _eNumerals );
 483 }
 484 // -----------------------------------------------------------------------------
 485 SvtCTLOptions::TextNumerals SvtCTLOptions::GetCTLTextNumerals() const
 486 {
 487     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 488     return pCTLOptions->GetCTLTextNumerals();
 489 }
 490 // -----------------------------------------------------------------------------
 491 bool SvtCTLOptions::IsReadOnly(EOption eOption) const
 492 {
 493     DBG_ASSERT( pCTLOptions->IsLoaded(), "CTL options not loaded" );
 494     return pCTLOptions->IsReadOnly(eOption);
 495 }
 496 // -----------------------------------------------------------------------------
 497
 498 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */