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