LCOV - code coverage report
Current view: top level - svl/source/config - cjkoptions.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 63 205 30.7 %
Date: 2015-06-13 12:38:46 Functions: 12 30 40.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11