svl/source/config/cjkoptions.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 <svl/cjkoptions.hxx>
  21
  22 #include <o3tl/any.hxx>
  23 #include <svl/languageoptions.hxx>
  24 #include <i18nlangtag/lang.h>
  25 #include <unotools/configitem.hxx>
  26 #include <tools/solar.h>
  27 #include <com/sun/star/uno/Any.h>
  28 #include <com/sun/star/uno/Sequence.hxx>
  29 #include <osl/mutex.hxx>
  30 #include <rtl/instance.hxx>
  31
  32 #include "itemholder2.hxx"
  33
  34 using namespace ::com::sun::star::uno;
  35
  36 #define CFG_READONLY_DEFAULT false
  37
  38 class SvtCJKOptions_Impl : public utl::ConfigItem
  39 {
  40     bool        bIsLoaded;
  41     bool        bCJKFont;
  42     bool        bVerticalText;
  43     bool        bAsianTypography;
  44     bool        bJapaneseFind;
  45     bool        bRuby;
  46     bool        bChangeCaseMap;
  47     bool        bDoubleLines;
  48     bool        bEmphasisMarks;
  49     bool        bVerticalCallOut;
  50
  51     bool        bROCJKFont;
  52     bool        bROVerticalText;
  53     bool        bROAsianTypography;
  54     bool        bROJapaneseFind;
  55     bool        bRORuby;
  56     bool        bROChangeCaseMap;
  57     bool        bRODoubleLines;
  58     bool        bROEmphasisMarks;
  59     bool        bROVerticalCallOut;
  60
  61     virtual void    ImplCommit() override;
  62
  63 public:
  64     SvtCJKOptions_Impl();
  65
  66     virtual void    Notify( const css::uno::Sequence< OUString >& rPropertyNames ) override;
  67     void            Load();
  68
  69     bool IsLoaded() const                   { return bIsLoaded;         }
  70
  71     bool IsCJKFontEnabled() const           { return bCJKFont;          }
  72     bool IsVerticalTextEnabled() const      { return bVerticalText;     }
  73     bool IsAsianTypographyEnabled() const   { return bAsianTypography;  }
  74     bool IsJapaneseFindEnabled() const      { return bJapaneseFind;     }
  75     bool IsRubyEnabled() const              { return bRuby;             }
  76     bool IsChangeCaseMapEnabled() const     { return bChangeCaseMap;    }
  77     bool IsDoubleLinesEnabled() const       { return bDoubleLines;      }
  78
  79     bool IsAnyEnabled() const {
  80         return  bCJKFont||bVerticalText||bAsianTypography||bJapaneseFind||
  81                 bRuby||bChangeCaseMap||bDoubleLines||bEmphasisMarks||bVerticalCallOut;   }
  82     void    SetAll(bool bSet);
  83     bool IsReadOnly(SvtCJKOptions::EOption eOption) const;
  84 };
  85
  86 namespace
  87 {
  88     struct PropertyNames
  89         : public rtl::Static< Sequence<OUString>, PropertyNames > {};
  90 }
  91
  92 SvtCJKOptions_Impl::SvtCJKOptions_Impl() :
  93     utl::ConfigItem("Office.Common/I18N/CJK"),
  94     bIsLoaded(false),
  95     bCJKFont(true),
  96     bVerticalText(true),
  97     bAsianTypography(true),
  98     bJapaneseFind(true),
  99     bRuby(true),
 100     bChangeCaseMap(true),
 101     bDoubleLines(true),
 102     bEmphasisMarks(true),
 103     bVerticalCallOut(true),
 104     bROCJKFont(CFG_READONLY_DEFAULT),
 105     bROVerticalText(CFG_READONLY_DEFAULT),
 106     bROAsianTypography(CFG_READONLY_DEFAULT),
 107     bROJapaneseFind(CFG_READONLY_DEFAULT),
 108     bRORuby(CFG_READONLY_DEFAULT),
 109     bROChangeCaseMap(CFG_READONLY_DEFAULT),
 110     bRODoubleLines(CFG_READONLY_DEFAULT),
 111     bROEmphasisMarks(CFG_READONLY_DEFAULT),
 112     bROVerticalCallOut(CFG_READONLY_DEFAULT)
 113 {
 114 }
 115
 116 void    SvtCJKOptions_Impl::SetAll(bool bSet)
 117 {
 118     if (
 119         bROCJKFont          ||
 120         bROVerticalText     ||
 121         bROAsianTypography  ||
 122         bROJapaneseFind     ||
 123         bRORuby             ||
 124         bROChangeCaseMap    ||
 125         bRODoubleLines      ||
 126         bROEmphasisMarks    ||
 127         bROVerticalCallOut
 128        )
 129         return;
 130
 131     bCJKFont=bSet;
 132     bVerticalText=bSet;
 133     bAsianTypography=bSet;
 134     bJapaneseFind=bSet;
 135     bRuby=bSet;
 136     bChangeCaseMap=bSet;
 137     bDoubleLines=bSet;
 138     bEmphasisMarks=bSet;
 139     bVerticalCallOut=bSet;
 140
 141     SetModified();
 142     Commit();
 143     NotifyListeners(ConfigurationHints::NONE);
 144 }
 145
 146 void SvtCJKOptions_Impl::Load()
 147 {
 148     Sequence<OUString> &rPropertyNames = PropertyNames::get();
 149     if(!rPropertyNames.hasElements())
 150     {
 151         rPropertyNames.realloc(9);
 152         OUString* pNames = rPropertyNames.getArray();
 153
 154         pNames[0] = "CJKFont";
 155         pNames[1] = "VerticalText";
 156         pNames[2] = "AsianTypography";
 157         pNames[3] = "JapaneseFind";
 158         pNames[4] = "Ruby";
 159         pNames[5] = "ChangeCaseMap";
 160         pNames[6] = "DoubleLines";
 161         pNames[7] = "EmphasisMarks";
 162         pNames[8] = "VerticalCallOut";
 163
 164         EnableNotification( rPropertyNames );
 165     }
 166     Sequence< Any > aValues = GetProperties(rPropertyNames);
 167     Sequence< sal_Bool > aROStates = GetReadOnlyStates(rPropertyNames);
 168     const Any* pValues = aValues.getConstArray();
 169     const sal_Bool* pROStates = aROStates.getConstArray();
 170     assert(aValues.getLength() == rPropertyNames.getLength() && "GetProperties failed");
 171     assert(aROStates.getLength() == rPropertyNames.getLength() && "GetReadOnlyStates failed");
 172     if ( aValues.getLength() == rPropertyNames.getLength() && aROStates.getLength() == rPropertyNames.getLength() )
 173     {
 174         for ( int nProp = 0; nProp < rPropertyNames.getLength(); nProp++ )
 175         {
 176             if( pValues[nProp].hasValue() )
 177             {
 178                 bool bValue = *o3tl::doAccess<bool>(pValues[nProp]);
 179                 switch ( nProp )
 180                 {
 181                     case 0: { bCJKFont = bValue; bROCJKFont = pROStates[nProp]; } break;
 182                     case 1: { bVerticalText = bValue; bROVerticalText = pROStates[nProp]; } break;
 183                     case 2: { bAsianTypography = bValue; bROAsianTypography = pROStates[nProp]; } break;
 184                     case 3: { bJapaneseFind = bValue; bROJapaneseFind = pROStates[nProp]; } break;
 185                     case 4: { bRuby = bValue; bRORuby = pROStates[nProp]; } break;
 186                     case 5: { bChangeCaseMap = bValue; bROChangeCaseMap = pROStates[nProp]; } break;
 187                     case 6: { bDoubleLines = bValue; bRODoubleLines = pROStates[nProp]; } break;
 188                     case 7: { bEmphasisMarks = bValue; bROEmphasisMarks = pROStates[nProp]; } break;
 189                     case 8: { bVerticalCallOut = bValue; bROVerticalCallOut = pROStates[nProp]; } break;
 190                 }
 191             }
 192         }
 193     }
 194
 195     if (!bCJKFont)
 196     {
 197         SvtScriptType nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage(LANGUAGE_SYSTEM);
 198         //system locale is CJK
 199         bool bAutoEnableCJK = bool(nScriptType & SvtScriptType::ASIAN);
 200
 201         if (!bAutoEnableCJK)
 202         {
 203             SvtSystemLanguageOptions aSystemLocaleSettings;
 204
 205             //windows secondary system locale is CJK
 206             LanguageType eSystemLanguage = aSystemLocaleSettings.GetWin16SystemLanguage();
 207             if (eSystemLanguage != LANGUAGE_SYSTEM)
 208             {
 209                 SvtScriptType nWinScript = SvtLanguageOptions::GetScriptTypeOfLanguage( eSystemLanguage );
 210                 bAutoEnableCJK = bool(nWinScript & SvtScriptType::ASIAN);
 211             }
 212
 213             //CJK keyboard is installed
 214             if (!bAutoEnableCJK)
 215                 bAutoEnableCJK = aSystemLocaleSettings.isCJKKeyboardLayoutInstalled();
 216         }
 217
 218         if (bAutoEnableCJK)
 219         {
 220             SetAll(true);
 221         }
 222     }
 223     bIsLoaded = true;
 224 }
 225
 226 void    SvtCJKOptions_Impl::Notify( const Sequence< OUString >& )
 227 {
 228     Load();
 229     NotifyListeners(ConfigurationHints::NONE);
 230 }
 231
 232 void    SvtCJKOptions_Impl::ImplCommit()
 233 {
 234     Sequence<OUString> &rPropertyNames = PropertyNames::get();
 235     OUString* pOrgNames = rPropertyNames.getArray();
 236     sal_Int32 nOrgCount = rPropertyNames.getLength();
 237
 238     Sequence< OUString > aNames(nOrgCount);
 239     Sequence< Any > aValues(nOrgCount);
 240
 241     OUString* pNames = aNames.getArray();
 242     Any* pValues = aValues.getArray();
 243     sal_Int32 nRealCount = 0;
 244
 245     for(int nProp = 0; nProp < nOrgCount; nProp++)
 246     {
 247         switch(nProp)
 248         {
 249             case  0:
 250                 {
 251                     if (!bROCJKFont)
 252                     {
 253                         pNames[nRealCount] = pOrgNames[nProp];
 254                         pValues[nRealCount] <<= bCJKFont;
 255                         ++nRealCount;
 256                     }
 257                 }
 258                 break;
 259
 260             case  1:
 261                 {
 262                     if (!bROVerticalText)
 263                     {
 264                         pNames[nRealCount] = pOrgNames[nProp];
 265                         pValues[nRealCount] <<= bVerticalText;
 266                         ++nRealCount;
 267                     }
 268                 }
 269                 break;
 270
 271             case  2:
 272                 {
 273                     if (!bROAsianTypography)
 274                     {
 275                         pNames[nRealCount] = pOrgNames[nProp];
 276                         pValues[nRealCount] <<= bAsianTypography;
 277                         ++nRealCount;
 278                     }
 279                 }
 280                 break;
 281
 282             case  3:
 283                 {
 284                     if (!bROJapaneseFind)
 285                     {
 286                         pNames[nRealCount] = pOrgNames[nProp];
 287                         pValues[nRealCount] <<= bJapaneseFind;
 288                         ++nRealCount;
 289                     }
 290                 }
 291                 break;
 292
 293             case  4:
 294                 {
 295                     if (!bRORuby)
 296                     {
 297                         pNames[nRealCount] = pOrgNames[nProp];
 298                         pValues[nRealCount] <<= bRuby;
 299                         ++nRealCount;
 300                     }
 301                 }
 302                 break;
 303
 304             case  5:
 305                 {
 306                     if (!bROChangeCaseMap)
 307                     {
 308                         pNames[nRealCount] = pOrgNames[nProp];
 309                         pValues[nRealCount] <<= bChangeCaseMap;
 310                         ++nRealCount;
 311                     }
 312                 }
 313                 break;
 314
 315             case  6:
 316                 {
 317                     if (!bRODoubleLines)
 318                     {
 319                         pNames[nRealCount] = pOrgNames[nProp];
 320                         pValues[nRealCount] <<= bDoubleLines;
 321                         ++nRealCount;
 322                     }
 323                 }
 324                 break;
 325
 326             case  7:
 327                 {
 328                     if (!bROEmphasisMarks)
 329                     {
 330                         pNames[nRealCount] = pOrgNames[nProp];
 331                         pValues[nRealCount] <<= bEmphasisMarks;
 332                         ++nRealCount;
 333                     }
 334                 }
 335                 break;
 336
 337             case  8:
 338                 {
 339                     if (!bROVerticalCallOut)
 340                     {
 341                         pNames[nRealCount] = pOrgNames[nProp];
 342                         pValues[nRealCount] <<= bVerticalCallOut;
 343                         ++nRealCount;
 344                     }
 345                 }
 346                 break;
 347         }
 348     }
 349     aNames.realloc(nRealCount);
 350     aValues.realloc(nRealCount);
 351     PutProperties(aNames, aValues);
 352 }
 353
 354 bool SvtCJKOptions_Impl::IsReadOnly(SvtCJKOptions::EOption eOption) const
 355 {
 356     bool bReadOnly = CFG_READONLY_DEFAULT;
 357     switch(eOption)
 358     {
 359         case SvtCJKOptions::E_CJKFONT : bReadOnly = bROCJKFont; break;
 360         case SvtCJKOptions::E_VERTICALTEXT : bReadOnly = bROVerticalText; break;
 361         case SvtCJKOptions::E_ASIANTYPOGRAPHY : bReadOnly = bROAsianTypography; break;
 362         case SvtCJKOptions::E_JAPANESEFIND : bReadOnly = bROJapaneseFind; break;
 363         case SvtCJKOptions::E_RUBY : bReadOnly = bRORuby; break;
 364         case SvtCJKOptions::E_CHANGECASEMAP : bReadOnly = bROChangeCaseMap; break;
 365         case SvtCJKOptions::E_DOUBLELINES : bReadOnly = bRODoubleLines; break;
 366         case SvtCJKOptions::E_EMPHASISMARKS : bReadOnly = bROEmphasisMarks; break;
 367         case SvtCJKOptions::E_VERTICALCALLOUT : bReadOnly = bROVerticalCallOut; break;
 368         case SvtCJKOptions::E_ALL : if (bROCJKFont || bROVerticalText || bROAsianTypography || bROJapaneseFind || bRORuby || bROChangeCaseMap || bRODoubleLines || bROEmphasisMarks || bROVerticalCallOut)
 369                                         bReadOnly = true;
 370                                 break;
 371     }
 372     return bReadOnly;
 373 }
 374
 375 namespace {
 376
 377     // global
 378     std::weak_ptr<SvtCJKOptions_Impl> g_pCJKOptions;
 379
 380     struct theCJKOptionsMutex : public rtl::Static< ::osl::Mutex , theCJKOptionsMutex >{};
 381 }
 382
 383 SvtCJKOptions::SvtCJKOptions(bool bDontLoad)
 384 {
 385     // Global access, must be guarded (multithreading)
 386     ::osl::MutexGuard aGuard( theCJKOptionsMutex::get() );
 387     pImpl = g_pCJKOptions.lock();
 388     if ( !pImpl )
 389     {
 390         pImpl = std::make_shared<SvtCJKOptions_Impl>();
 391         g_pCJKOptions = pImpl;
 392         ItemHolder2::holdConfigItem(EItem::CJKOptions);
 393     }
 394
 395     if( !bDontLoad && !pImpl->IsLoaded())
 396         pImpl->Load();
 397 }
 398
 399
 400 SvtCJKOptions::~SvtCJKOptions()
 401 {
 402     // Global access, must be guarded (multithreading)
 403     ::osl::MutexGuard aGuard( theCJKOptionsMutex::get() );
 404
 405     // pImpl needs to be cleared before the mutex is dropped
 406     pImpl.reset();
 407 }
 408
 409 bool SvtCJKOptions::IsCJKFontEnabled() const
 410 {
 411     assert(pImpl->IsLoaded());
 412     return pImpl->IsCJKFontEnabled();
 413 }
 414
 415 bool SvtCJKOptions::IsVerticalTextEnabled() const
 416 {
 417     assert(pImpl->IsLoaded());
 418     return pImpl->IsVerticalTextEnabled();
 419 }
 420
 421 bool SvtCJKOptions::IsAsianTypographyEnabled() const
 422 {
 423     assert(pImpl->IsLoaded());
 424     return pImpl->IsAsianTypographyEnabled();
 425 }
 426
 427 bool SvtCJKOptions::IsJapaneseFindEnabled() const
 428 {
 429     assert(pImpl->IsLoaded());
 430     return pImpl->IsJapaneseFindEnabled();
 431 }
 432
 433 bool SvtCJKOptions::IsRubyEnabled() const
 434 {
 435     assert(pImpl->IsLoaded());
 436     return pImpl->IsRubyEnabled();
 437 }
 438
 439 bool SvtCJKOptions::IsChangeCaseMapEnabled() const
 440 {
 441     assert(pImpl->IsLoaded());
 442     return pImpl->IsChangeCaseMapEnabled();
 443 }
 444
 445 bool SvtCJKOptions::IsDoubleLinesEnabled() const
 446 {
 447     assert(pImpl->IsLoaded());
 448     return pImpl->IsDoubleLinesEnabled();
 449 }
 450
 451 void        SvtCJKOptions::SetAll(bool bSet)
 452 {
 453     assert(pImpl->IsLoaded());
 454     pImpl->SetAll(bSet);
 455 }
 456
 457 bool    SvtCJKOptions::IsAnyEnabled() const
 458 {
 459     assert(pImpl->IsLoaded());
 460     return pImpl->IsAnyEnabled();
 461 }
 462
 463 bool    SvtCJKOptions::IsReadOnly(EOption eOption) const
 464 {
 465     assert(pImpl->IsLoaded());
 466     return pImpl->IsReadOnly(eOption);
 467 }
 468
 469 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */