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