unotools/source/config/lingucfg.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 <sal/config.h>
  21
  22 #include <com/sun/star/lang/Locale.hpp>
  23 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  24 #include <com/sun/star/beans/PropertyValue.hpp>
  25 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  26 #include <com/sun/star/container/XNameAccess.hpp>
  27 #include <com/sun/star/util/XChangesBatch.hpp>
  28 #include <rtl/instance.hxx>
  29 #include <sal/log.hxx>
  30 #include <osl/mutex.hxx>
  31 #include <tools/diagnose_ex.h>
  32 #include <i18nlangtag/mslangid.hxx>
  33 #include <i18nlangtag/languagetag.hxx>
  34 #include <tools/debug.hxx>
  35 #include <unotools/configitem.hxx>
  36 #include <unotools/lingucfg.hxx>
  37 #include <unotools/linguprops.hxx>
  38 #include <sal/macros.h>
  39 #include <comphelper/getexpandeduri.hxx>
  40 #include <comphelper/processfactory.hxx>
  41
  42 #include "itemholder1.hxx"
  43
  44 using namespace com::sun::star;
  45
  46 #define FILE_PROTOCOL       "file:///"
  47
  48 namespace
  49 {
  50     class theSvtLinguConfigItemMutex :
  51         public rtl::Static< osl::Mutex, theSvtLinguConfigItemMutex > {};
  52 }
  53
  54 static bool lcl_SetLocale( LanguageType &rLanguage, const uno::Any &rVal )
  55 {
  56     bool bSucc = false;
  57
  58     lang::Locale aNew;
  59     if (rVal >>= aNew)  // conversion successful?
  60     {
  61         LanguageType nNew = LanguageTag::convertToLanguageType( aNew, false);
  62         if (nNew != rLanguage)
  63         {
  64             rLanguage = nNew;
  65             bSucc = true;
  66         }
  67     }
  68     return bSucc;
  69 }
  70
  71 static OUString lcl_LanguageToCfgLocaleStr( LanguageType nLanguage )
  72 {
  73     OUString aRes;
  74     if (LANGUAGE_SYSTEM != nLanguage)
  75         aRes = LanguageTag::convertToBcp47( nLanguage );
  76     return aRes;
  77 }
  78
  79 static LanguageType lcl_CfgAnyToLanguage( const uno::Any &rVal )
  80 {
  81     OUString aTmp;
  82     rVal >>= aTmp;
  83     return (aTmp.isEmpty()) ? LANGUAGE_SYSTEM : LanguageTag::convertToLanguageTypeWithFallback( aTmp );
  84 }
  85
  86 SvtLinguOptions::SvtLinguOptions()
  87     : bROActiveDics(false)
  88     , bROActiveConvDics(false)
  89     , nHyphMinLeading(2)
  90     , nHyphMinTrailing(2)
  91     , nHyphMinWordLength(0)
  92     , bROHyphMinLeading(false)
  93     , bROHyphMinTrailing(false)
  94     , bROHyphMinWordLength(false)
  95     , nDefaultLanguage(LANGUAGE_NONE)
  96     , nDefaultLanguage_CJK(LANGUAGE_NONE)
  97     , nDefaultLanguage_CTL(LANGUAGE_NONE)
  98     , bRODefaultLanguage(false)
  99     , bRODefaultLanguage_CJK(false)
 100     , bRODefaultLanguage_CTL(false)
 101     , bIsSpellSpecial(true)
 102     , bIsSpellAuto(false)
 103     , bIsSpellReverse(false)
 104     , bROIsSpellSpecial(false)
 105     , bROIsSpellAuto(false)
 106     , bROIsSpellReverse(false)
 107     , bIsHyphSpecial(true)
 108     , bIsHyphAuto(false)
 109     , bROIsHyphSpecial(false)
 110     , bROIsHyphAuto(false)
 111     , bIsUseDictionaryList(true)
 112     , bIsIgnoreControlCharacters(true)
 113     , bROIsUseDictionaryList(false)
 114     , bROIsIgnoreControlCharacters(false)
 115     , bIsSpellWithDigits(false)
 116     , bIsSpellUpperCase(false)
 117     , bIsSpellCapitalization(true)
 118     , bROIsSpellWithDigits(false)
 119     , bROIsSpellUpperCase(false)
 120     , bROIsSpellCapitalization(false)
 121     , bIsIgnorePostPositionalWord(true)
 122     , bIsAutoCloseDialog(false)
 123     , bIsShowEntriesRecentlyUsedFirst(false)
 124     , bIsAutoReplaceUniqueEntries(false)
 125     , bIsDirectionToSimplified(true)
 126     , bIsUseCharacterVariants(false)
 127     , bIsTranslateCommonTerms(false)
 128     , bIsReverseMapping(false)
 129     , bROIsIgnorePostPositionalWord(false)
 130     , bROIsAutoCloseDialog(false)
 131     , bROIsShowEntriesRecentlyUsedFirst(false)
 132     , bROIsAutoReplaceUniqueEntries(false)
 133     , bROIsDirectionToSimplified(false)
 134     , bROIsUseCharacterVariants(false)
 135     , bROIsTranslateCommonTerms(false)
 136     , bROIsReverseMapping(false)
 137     , nDataFilesChangedCheckValue(0)
 138     , bRODataFilesChangedCheckValue(false)
 139     , bIsGrammarAuto(false)
 140     , bIsGrammarInteractive(false)
 141     , bROIsGrammarAuto(false)
 142     , bROIsGrammarInteractive(false)
 143 {
 144 }
 145
 146 class SvtLinguConfigItem : public utl::ConfigItem
 147 {
 148     SvtLinguOptions     aOpt;
 149
 150     static bool GetHdlByName( sal_Int32 &rnHdl, const OUString &rPropertyName, bool bFullPropName = false );
 151     static uno::Sequence< OUString > GetPropertyNames();
 152     void                LoadOptions( const uno::Sequence< OUString > &rProperyNames );
 153     bool                SaveOptions( const uno::Sequence< OUString > &rProperyNames );
 154
 155     SvtLinguConfigItem(const SvtLinguConfigItem&) = delete;
 156     SvtLinguConfigItem& operator=(const SvtLinguConfigItem&) = delete;
 157     virtual void    ImplCommit() override;
 158
 159 public:
 160     SvtLinguConfigItem();
 161
 162     // utl::ConfigItem
 163     virtual void    Notify( const css::uno::Sequence< OUString > &rPropertyNames ) override;
 164
 165     // make some protected functions of utl::ConfigItem public
 166     using utl::ConfigItem::GetNodeNames;
 167     using utl::ConfigItem::GetProperties;
 168     //using utl::ConfigItem::PutProperties;
 169     //using utl::ConfigItem::SetSetProperties;
 170     using utl::ConfigItem::ReplaceSetProperties;
 171     //using utl::ConfigItem::GetReadOnlyStates;
 172
 173     css::uno::Any
 174             GetProperty( const OUString &rPropertyName ) const;
 175     css::uno::Any
 176             GetProperty( sal_Int32 nPropertyHandle ) const;
 177
 178     bool    SetProperty( const OUString &rPropertyName,
 179                          const css::uno::Any &rValue );
 180     bool    SetProperty( sal_Int32 nPropertyHandle,
 181                          const css::uno::Any &rValue );
 182
 183     const SvtLinguOptions& GetOptions() const;
 184
 185     bool    IsReadOnly( const OUString &rPropertyName ) const;
 186     bool    IsReadOnly( sal_Int32 nPropertyHandle ) const;
 187 };
 188
 189 SvtLinguConfigItem::SvtLinguConfigItem() :
 190     utl::ConfigItem( "Office.Linguistic" )
 191 {
 192     const uno::Sequence< OUString > &rPropertyNames = GetPropertyNames();
 193     LoadOptions( rPropertyNames );
 194     ClearModified();
 195
 196     // request notify events when properties change
 197     EnableNotification( rPropertyNames );
 198 }
 199
 200 void SvtLinguConfigItem::Notify( const uno::Sequence< OUString > &rPropertyNames )
 201 {
 202     LoadOptions( rPropertyNames );
 203     NotifyListeners(ConfigurationHints::NONE);
 204 }
 205
 206 void SvtLinguConfigItem::ImplCommit()
 207 {
 208     SaveOptions( GetPropertyNames() );
 209 }
 210
 211 static struct NamesToHdl
 212 {
 213     const char   *pFullPropName;      // full qualified name as used in configuration
 214     const char   *pPropName;          // property name only (atom) of above
 215     sal_Int32 const   nHdl;               // numeric handle representing the property
 216 } const aNamesToHdl[] =
 217 {
 218 {/*  0 */    "General/DefaultLocale",                         UPN_DEFAULT_LOCALE,                    UPH_DEFAULT_LOCALE},
 219 {/*  1 */    "General/DictionaryList/ActiveDictionaries",     UPN_ACTIVE_DICTIONARIES,               UPH_ACTIVE_DICTIONARIES},
 220 {/*  2 */    "General/DictionaryList/IsUseDictionaryList",    UPN_IS_USE_DICTIONARY_LIST,            UPH_IS_USE_DICTIONARY_LIST},
 221 {/*  3 */    "General/IsIgnoreControlCharacters",             UPN_IS_IGNORE_CONTROL_CHARACTERS,      UPH_IS_IGNORE_CONTROL_CHARACTERS},
 222 {/*  5 */    "General/DefaultLocale_CJK",                     UPN_DEFAULT_LOCALE_CJK,                UPH_DEFAULT_LOCALE_CJK},
 223 {/*  6 */    "General/DefaultLocale_CTL",                     UPN_DEFAULT_LOCALE_CTL,                UPH_DEFAULT_LOCALE_CTL},
 224
 225 {/*  7 */    "SpellChecking/IsSpellUpperCase",                UPN_IS_SPELL_UPPER_CASE,               UPH_IS_SPELL_UPPER_CASE},
 226 {/*  8 */    "SpellChecking/IsSpellWithDigits",               UPN_IS_SPELL_WITH_DIGITS,              UPH_IS_SPELL_WITH_DIGITS},
 227 {/*  9 */    "SpellChecking/IsSpellCapitalization",           UPN_IS_SPELL_CAPITALIZATION,           UPH_IS_SPELL_CAPITALIZATION},
 228 {/* 10 */    "SpellChecking/IsSpellAuto",                     UPN_IS_SPELL_AUTO,                     UPH_IS_SPELL_AUTO},
 229 {/* 11 */    "SpellChecking/IsSpellSpecial",                  UPN_IS_SPELL_SPECIAL,                  UPH_IS_SPELL_SPECIAL},
 230 {/* 14 */    "SpellChecking/IsReverseDirection",              UPN_IS_WRAP_REVERSE,                   UPH_IS_WRAP_REVERSE},
 231
 232 {/* 15 */    "Hyphenation/MinLeading",                        UPN_HYPH_MIN_LEADING,                  UPH_HYPH_MIN_LEADING},
 233 {/* 16 */    "Hyphenation/MinTrailing",                       UPN_HYPH_MIN_TRAILING,                 UPH_HYPH_MIN_TRAILING},
 234 {/* 17 */    "Hyphenation/MinWordLength",                     UPN_HYPH_MIN_WORD_LENGTH,              UPH_HYPH_MIN_WORD_LENGTH},
 235 {/* 18 */    "Hyphenation/IsHyphSpecial",                     UPN_IS_HYPH_SPECIAL,                   UPH_IS_HYPH_SPECIAL},
 236 {/* 19 */    "Hyphenation/IsHyphAuto",                        UPN_IS_HYPH_AUTO,                      UPH_IS_HYPH_AUTO},
 237
 238 {/* 20 */    "TextConversion/ActiveConversionDictionaries",   UPN_ACTIVE_CONVERSION_DICTIONARIES,        UPH_ACTIVE_CONVERSION_DICTIONARIES},
 239 {/* 21 */    "TextConversion/IsIgnorePostPositionalWord",     UPN_IS_IGNORE_POST_POSITIONAL_WORD,        UPH_IS_IGNORE_POST_POSITIONAL_WORD},
 240 {/* 22 */    "TextConversion/IsAutoCloseDialog",              UPN_IS_AUTO_CLOSE_DIALOG,                  UPH_IS_AUTO_CLOSE_DIALOG},
 241 {/* 23 */    "TextConversion/IsShowEntriesRecentlyUsedFirst", UPN_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST,   UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST},
 242 {/* 24 */    "TextConversion/IsAutoReplaceUniqueEntries",     UPN_IS_AUTO_REPLACE_UNIQUE_ENTRIES,        UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES},
 243 {/* 25 */    "TextConversion/IsDirectionToSimplified",        UPN_IS_DIRECTION_TO_SIMPLIFIED,            UPH_IS_DIRECTION_TO_SIMPLIFIED},
 244 {/* 26 */    "TextConversion/IsUseCharacterVariants",         UPN_IS_USE_CHARACTER_VARIANTS,             UPH_IS_USE_CHARACTER_VARIANTS},
 245 {/* 27 */    "TextConversion/IsTranslateCommonTerms",         UPN_IS_TRANSLATE_COMMON_TERMS,             UPH_IS_TRANSLATE_COMMON_TERMS},
 246 {/* 28 */    "TextConversion/IsReverseMapping",               UPN_IS_REVERSE_MAPPING,                    UPH_IS_REVERSE_MAPPING},
 247
 248 {/* 29 */    "ServiceManager/DataFilesChangedCheckValue",     UPN_DATA_FILES_CHANGED_CHECK_VALUE,        UPH_DATA_FILES_CHANGED_CHECK_VALUE},
 249
 250 {/* 30 */    "GrammarChecking/IsAutoCheck",                   UPN_IS_GRAMMAR_AUTO,                      UPH_IS_GRAMMAR_AUTO},
 251 {/* 31 */    "GrammarChecking/IsInteractiveCheck",            UPN_IS_GRAMMAR_INTERACTIVE,               UPH_IS_GRAMMAR_INTERACTIVE},
 252
 253             /* similar to entry 0 (thus no own configuration entry) but with different property name and type */
 254 {            nullptr,                                           UPN_DEFAULT_LANGUAGE,                      UPH_DEFAULT_LANGUAGE},
 255
 256 {            nullptr,                                            nullptr,                                      -1}
 257 };
 258
 259 uno::Sequence< OUString > SvtLinguConfigItem::GetPropertyNames()
 260 {
 261     uno::Sequence< OUString > aNames;
 262
 263     sal_Int32 nMax = SAL_N_ELEMENTS(aNamesToHdl);
 264
 265     aNames.realloc( nMax );
 266     OUString *pNames = aNames.getArray();
 267     sal_Int32 nIdx = 0;
 268     for (sal_Int32 i = 0; i < nMax;  ++i)
 269     {
 270         const sal_Char *pFullPropName = aNamesToHdl[i].pFullPropName;
 271         if (pFullPropName)
 272             pNames[ nIdx++ ] = OUString::createFromAscii( pFullPropName );
 273     }
 274     aNames.realloc( nIdx );
 275
 276     return aNames;
 277 }
 278
 279 bool SvtLinguConfigItem::GetHdlByName(
 280     sal_Int32 &rnHdl,
 281     const OUString &rPropertyName,
 282     bool bFullPropName )
 283 {
 284     NamesToHdl const *pEntry = &aNamesToHdl[0];
 285
 286     if (bFullPropName)
 287     {
 288         while (pEntry && pEntry->pFullPropName != nullptr)
 289         {
 290             if (rPropertyName.equalsAscii( pEntry->pFullPropName ))
 291             {
 292                 rnHdl = pEntry->nHdl;
 293                 break;
 294             }
 295             ++pEntry;
 296         }
 297         return pEntry && pEntry->pFullPropName != nullptr;
 298     }
 299     else
 300     {
 301         while (pEntry && pEntry->pPropName != nullptr)
 302         {
 303             if (rPropertyName.equalsAscii( pEntry->pPropName ))
 304             {
 305                 rnHdl = pEntry->nHdl;
 306                 break;
 307             }
 308             ++pEntry;
 309         }
 310         return pEntry && pEntry->pPropName != nullptr;
 311     }
 312 }
 313
 314 uno::Any SvtLinguConfigItem::GetProperty( const OUString &rPropertyName ) const
 315 {
 316     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 317
 318     sal_Int32 nHdl;
 319     return GetHdlByName( nHdl, rPropertyName ) ? GetProperty( nHdl ) : uno::Any();
 320 }
 321
 322 uno::Any SvtLinguConfigItem::GetProperty( sal_Int32 nPropertyHandle ) const
 323 {
 324     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 325
 326     uno::Any aRes;
 327
 328     const sal_Int16 *pnVal = nullptr;
 329     const LanguageType *plVal = nullptr;
 330     const bool  *pbVal = nullptr;
 331     const sal_Int32 *pnInt32Val = nullptr;
 332
 333     const SvtLinguOptions &rOpt = const_cast< SvtLinguConfigItem * >(this)->aOpt;
 334     switch (nPropertyHandle)
 335     {
 336         case UPH_IS_USE_DICTIONARY_LIST :   pbVal = &rOpt.bIsUseDictionaryList; break;
 337         case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &rOpt.bIsIgnoreControlCharacters;   break;
 338         case UPH_IS_HYPH_AUTO :             pbVal = &rOpt.bIsHyphAuto;  break;
 339         case UPH_IS_HYPH_SPECIAL :          pbVal = &rOpt.bIsHyphSpecial;   break;
 340         case UPH_IS_SPELL_AUTO :            pbVal = &rOpt.bIsSpellAuto; break;
 341         case UPH_IS_SPELL_SPECIAL :         pbVal = &rOpt.bIsSpellSpecial;  break;
 342         case UPH_IS_WRAP_REVERSE :          pbVal = &rOpt.bIsSpellReverse;  break;
 343         case UPH_DEFAULT_LANGUAGE :         plVal = &rOpt.nDefaultLanguage; break;
 344         case UPH_IS_SPELL_CAPITALIZATION :  pbVal = &rOpt.bIsSpellCapitalization;       break;
 345         case UPH_IS_SPELL_WITH_DIGITS :     pbVal = &rOpt.bIsSpellWithDigits;   break;
 346         case UPH_IS_SPELL_UPPER_CASE :      pbVal = &rOpt.bIsSpellUpperCase;        break;
 347         case UPH_HYPH_MIN_LEADING :         pnVal = &rOpt.nHyphMinLeading;      break;
 348         case UPH_HYPH_MIN_TRAILING :        pnVal = &rOpt.nHyphMinTrailing; break;
 349         case UPH_HYPH_MIN_WORD_LENGTH :     pnVal = &rOpt.nHyphMinWordLength;   break;
 350         case UPH_ACTIVE_DICTIONARIES :
 351         {
 352             aRes <<= rOpt.aActiveDics;
 353             break;
 354         }
 355         case UPH_ACTIVE_CONVERSION_DICTIONARIES :
 356         {
 357             aRes <<= rOpt.aActiveConvDics;
 358             break;
 359         }
 360         case UPH_DEFAULT_LOCALE :
 361         {
 362             aRes <<= LanguageTag::convertToLocale( rOpt.nDefaultLanguage, false);
 363             break;
 364         }
 365         case UPH_DEFAULT_LOCALE_CJK :
 366         {
 367             aRes <<= LanguageTag::convertToLocale( rOpt.nDefaultLanguage_CJK, false);
 368             break;
 369         }
 370         case UPH_DEFAULT_LOCALE_CTL :
 371         {
 372             aRes <<= LanguageTag::convertToLocale( rOpt.nDefaultLanguage_CTL, false);
 373             break;
 374         }
 375         case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       pbVal = &rOpt.bIsIgnorePostPositionalWord; break;
 376         case UPH_IS_AUTO_CLOSE_DIALOG :                 pbVal = &rOpt.bIsAutoCloseDialog; break;
 377         case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  pbVal = &rOpt.bIsShowEntriesRecentlyUsedFirst; break;
 378         case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       pbVal = &rOpt.bIsAutoReplaceUniqueEntries; break;
 379
 380         case UPH_IS_DIRECTION_TO_SIMPLIFIED:            pbVal = &rOpt.bIsDirectionToSimplified; break;
 381         case UPH_IS_USE_CHARACTER_VARIANTS :            pbVal = &rOpt.bIsUseCharacterVariants; break;
 382         case UPH_IS_TRANSLATE_COMMON_TERMS :            pbVal = &rOpt.bIsTranslateCommonTerms; break;
 383         case UPH_IS_REVERSE_MAPPING :                   pbVal = &rOpt.bIsReverseMapping; break;
 384
 385         case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       pnInt32Val = &rOpt.nDataFilesChangedCheckValue; break;
 386         case UPH_IS_GRAMMAR_AUTO:                       pbVal = &rOpt.bIsGrammarAuto; break;
 387         case UPH_IS_GRAMMAR_INTERACTIVE:                pbVal = &rOpt.bIsGrammarInteractive; break;
 388         default :
 389             SAL_WARN( "unotools.config", "unexpected property handle" );
 390     }
 391
 392     if (pbVal)
 393         aRes <<= *pbVal;
 394     else if (pnVal)
 395         aRes <<= *pnVal;
 396     else if (plVal)
 397         aRes <<= static_cast<sal_Int16>(static_cast<sal_uInt16>(*plVal));
 398     else if (pnInt32Val)
 399         aRes <<= *pnInt32Val;
 400
 401     return aRes;
 402 }
 403
 404 bool SvtLinguConfigItem::SetProperty( const OUString &rPropertyName, const uno::Any &rValue )
 405 {
 406     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 407
 408     bool bSucc = false;
 409     sal_Int32 nHdl;
 410     if (GetHdlByName( nHdl, rPropertyName ))
 411         bSucc = SetProperty( nHdl, rValue );
 412     return bSucc;
 413 }
 414
 415 bool SvtLinguConfigItem::SetProperty( sal_Int32 nPropertyHandle, const uno::Any &rValue )
 416 {
 417     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 418
 419     bool bSucc = false;
 420     if (!rValue.hasValue())
 421         return bSucc;
 422
 423     bool bMod = false;
 424
 425     sal_Int16 *pnVal = nullptr;
 426     LanguageType *plVal = nullptr;
 427     bool  *pbVal = nullptr;
 428     sal_Int32 *pnInt32Val = nullptr;
 429
 430     SvtLinguOptions &rOpt = aOpt;
 431     switch (nPropertyHandle)
 432     {
 433         case UPH_IS_USE_DICTIONARY_LIST :   pbVal = &rOpt.bIsUseDictionaryList;    break;
 434         case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &rOpt.bIsIgnoreControlCharacters;  break;
 435         case UPH_IS_HYPH_AUTO :             pbVal = &rOpt.bIsHyphAuto; break;
 436         case UPH_IS_HYPH_SPECIAL :          pbVal = &rOpt.bIsHyphSpecial;  break;
 437         case UPH_IS_SPELL_AUTO :            pbVal = &rOpt.bIsSpellAuto;    break;
 438         case UPH_IS_SPELL_SPECIAL :         pbVal = &rOpt.bIsSpellSpecial; break;
 439         case UPH_IS_WRAP_REVERSE :          pbVal = &rOpt.bIsSpellReverse; break;
 440         case UPH_DEFAULT_LANGUAGE :         plVal = &rOpt.nDefaultLanguage;    break;
 441         case UPH_IS_SPELL_CAPITALIZATION :  pbVal = &rOpt.bIsSpellCapitalization;      break;
 442         case UPH_IS_SPELL_WITH_DIGITS :     pbVal = &rOpt.bIsSpellWithDigits;  break;
 443         case UPH_IS_SPELL_UPPER_CASE :      pbVal = &rOpt.bIsSpellUpperCase;       break;
 444         case UPH_HYPH_MIN_LEADING :         pnVal = &rOpt.nHyphMinLeading;     break;
 445         case UPH_HYPH_MIN_TRAILING :        pnVal = &rOpt.nHyphMinTrailing;    break;
 446         case UPH_HYPH_MIN_WORD_LENGTH :     pnVal = &rOpt.nHyphMinWordLength;  break;
 447         case UPH_ACTIVE_DICTIONARIES :
 448         {
 449             rValue >>= rOpt.aActiveDics;
 450             bMod = true;
 451             break;
 452         }
 453         case UPH_ACTIVE_CONVERSION_DICTIONARIES :
 454         {
 455             rValue >>= rOpt.aActiveConvDics;
 456             bMod = true;
 457             break;
 458         }
 459         case UPH_DEFAULT_LOCALE :
 460         {
 461             bSucc = lcl_SetLocale( rOpt.nDefaultLanguage, rValue );
 462             bMod = bSucc;
 463             break;
 464         }
 465         case UPH_DEFAULT_LOCALE_CJK :
 466         {
 467             bSucc = lcl_SetLocale( rOpt.nDefaultLanguage_CJK, rValue );
 468             bMod = bSucc;
 469             break;
 470         }
 471         case UPH_DEFAULT_LOCALE_CTL :
 472         {
 473             bSucc = lcl_SetLocale( rOpt.nDefaultLanguage_CTL, rValue );
 474             bMod = bSucc;
 475             break;
 476         }
 477         case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       pbVal = &rOpt.bIsIgnorePostPositionalWord; break;
 478         case UPH_IS_AUTO_CLOSE_DIALOG :                 pbVal = &rOpt.bIsAutoCloseDialog; break;
 479         case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  pbVal = &rOpt.bIsShowEntriesRecentlyUsedFirst; break;
 480         case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       pbVal = &rOpt.bIsAutoReplaceUniqueEntries; break;
 481
 482         case UPH_IS_DIRECTION_TO_SIMPLIFIED :           pbVal = &rOpt.bIsDirectionToSimplified; break;
 483         case UPH_IS_USE_CHARACTER_VARIANTS :            pbVal = &rOpt.bIsUseCharacterVariants; break;
 484         case UPH_IS_TRANSLATE_COMMON_TERMS :            pbVal = &rOpt.bIsTranslateCommonTerms; break;
 485         case UPH_IS_REVERSE_MAPPING :                   pbVal = &rOpt.bIsReverseMapping; break;
 486
 487         case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       pnInt32Val = &rOpt.nDataFilesChangedCheckValue; break;
 488         case UPH_IS_GRAMMAR_AUTO:                       pbVal = &rOpt.bIsGrammarAuto; break;
 489         case UPH_IS_GRAMMAR_INTERACTIVE:                pbVal = &rOpt.bIsGrammarInteractive; break;
 490         default :
 491             SAL_WARN( "unotools.config", "unexpected property handle" );
 492     }
 493
 494     if (pbVal)
 495     {
 496         bool bNew = bool();
 497         if (rValue >>= bNew)
 498         {
 499             if (bNew != *pbVal)
 500             {
 501                 *pbVal = bNew;
 502                 bMod = true;
 503             }
 504             bSucc = true;
 505         }
 506     }
 507     else if (pnVal)
 508     {
 509         sal_Int16 nNew = sal_Int16();
 510         if (rValue >>= nNew)
 511         {
 512             if (nNew != *pnVal)
 513             {
 514                 *pnVal = nNew;
 515                 bMod = true;
 516             }
 517             bSucc = true;
 518         }
 519     }
 520     else if (plVal)
 521     {
 522         sal_Int16 nNew = sal_Int16();
 523         if (rValue >>= nNew)
 524         {
 525             if (nNew != static_cast<sal_uInt16>(*plVal))
 526             {
 527                 *plVal = LanguageType(static_cast<sal_uInt16>(nNew));
 528                 bMod = true;
 529             }
 530             bSucc = true;
 531         }
 532     }
 533     else if (pnInt32Val)
 534     {
 535         sal_Int32 nNew = sal_Int32();
 536         if (rValue >>= nNew)
 537         {
 538             if (nNew != *pnInt32Val)
 539             {
 540                 *pnInt32Val = nNew;
 541                 bMod = true;
 542             }
 543             bSucc = true;
 544         }
 545     }
 546
 547     if (bMod)
 548         SetModified();
 549
 550     NotifyListeners(ConfigurationHints::NONE);
 551     return bSucc;
 552 }
 553
 554 const SvtLinguOptions& SvtLinguConfigItem::GetOptions() const
 555 {
 556     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 557     return aOpt;
 558 }
 559
 560 void SvtLinguConfigItem::LoadOptions( const uno::Sequence< OUString > &rProperyNames )
 561 {
 562     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 563
 564     bool bRes = false;
 565
 566     const OUString *pProperyNames = rProperyNames.getConstArray();
 567     sal_Int32 nProps = rProperyNames.getLength();
 568
 569     const uno::Sequence< uno::Any > aValues = GetProperties( rProperyNames );
 570     const uno::Sequence< sal_Bool > aROStates = GetReadOnlyStates( rProperyNames );
 571
 572     if (nProps  &&  aValues.getLength() == nProps &&  aROStates.getLength() == nProps)
 573     {
 574         SvtLinguOptions &rOpt = aOpt;
 575
 576         const uno::Any *pValue = aValues.getConstArray();
 577         const sal_Bool *pROStates = aROStates.getConstArray();
 578         for (sal_Int32 i = 0;  i < nProps;  ++i)
 579         {
 580             const uno::Any &rVal = pValue[i];
 581             sal_Int32 nPropertyHandle(0);
 582             GetHdlByName( nPropertyHandle, pProperyNames[i], true );
 583             switch ( nPropertyHandle )
 584             {
 585                 case UPH_DEFAULT_LOCALE :
 586                     { rOpt.bRODefaultLanguage = pROStates[i]; rOpt.nDefaultLanguage = lcl_CfgAnyToLanguage( rVal ); } break;
 587                 case UPH_ACTIVE_DICTIONARIES :
 588                     { rOpt.bROActiveDics = pROStates[i]; rVal >>= rOpt.aActiveDics;   } break;
 589                 case UPH_IS_USE_DICTIONARY_LIST :
 590                     { rOpt.bROIsUseDictionaryList = pROStates[i]; rVal >>= rOpt.bIsUseDictionaryList;  } break;
 591                 case UPH_IS_IGNORE_CONTROL_CHARACTERS :
 592                     { rOpt.bROIsIgnoreControlCharacters = pROStates[i]; rVal >>= rOpt.bIsIgnoreControlCharacters;    } break;
 593                 case UPH_DEFAULT_LOCALE_CJK :
 594                     { rOpt.bRODefaultLanguage_CJK = pROStates[i]; rOpt.nDefaultLanguage_CJK = lcl_CfgAnyToLanguage( rVal );    } break;
 595                 case UPH_DEFAULT_LOCALE_CTL :
 596                     { rOpt.bRODefaultLanguage_CTL = pROStates[i]; rOpt.nDefaultLanguage_CTL = lcl_CfgAnyToLanguage( rVal );    } break;
 597
 598                 case UPH_IS_SPELL_UPPER_CASE :
 599                     { rOpt.bROIsSpellUpperCase = pROStates[i]; rVal >>= rOpt.bIsSpellUpperCase; } break;
 600                 case UPH_IS_SPELL_WITH_DIGITS :
 601                     { rOpt.bROIsSpellWithDigits = pROStates[i]; rVal >>= rOpt.bIsSpellWithDigits;    } break;
 602                 case UPH_IS_SPELL_CAPITALIZATION :
 603                     { rOpt.bROIsSpellCapitalization = pROStates[i]; rVal >>= rOpt.bIsSpellCapitalization;    } break;
 604                 case UPH_IS_SPELL_AUTO :
 605                     { rOpt.bROIsSpellAuto = pROStates[i]; rVal >>= rOpt.bIsSpellAuto;  } break;
 606                 case UPH_IS_SPELL_SPECIAL :
 607                     { rOpt.bROIsSpellSpecial = pROStates[i]; rVal >>= rOpt.bIsSpellSpecial;   } break;
 608                 case UPH_IS_WRAP_REVERSE :
 609                     { rOpt.bROIsSpellReverse = pROStates[i]; rVal >>= rOpt.bIsSpellReverse;   } break;
 610
 611                 case UPH_HYPH_MIN_LEADING :
 612                     { rOpt.bROHyphMinLeading = pROStates[i]; rVal >>= rOpt.nHyphMinLeading;   } break;
 613                 case UPH_HYPH_MIN_TRAILING :
 614                     { rOpt.bROHyphMinTrailing = pROStates[i]; rVal >>= rOpt.nHyphMinTrailing;  } break;
 615                 case UPH_HYPH_MIN_WORD_LENGTH :
 616                     { rOpt.bROHyphMinWordLength = pROStates[i]; rVal >>= rOpt.nHyphMinWordLength;    } break;
 617                 case UPH_IS_HYPH_SPECIAL :
 618                     { rOpt.bROIsHyphSpecial = pROStates[i]; rVal >>= rOpt.bIsHyphSpecial;    } break;
 619                 case UPH_IS_HYPH_AUTO :
 620                     { rOpt.bROIsHyphAuto = pROStates[i]; rVal >>= rOpt.bIsHyphAuto;   } break;
 621
 622                 case UPH_ACTIVE_CONVERSION_DICTIONARIES : { rOpt.bROActiveConvDics = pROStates[i]; rVal >>= rOpt.aActiveConvDics;   } break;
 623
 624                 case UPH_IS_IGNORE_POST_POSITIONAL_WORD :
 625                     { rOpt.bROIsIgnorePostPositionalWord = pROStates[i]; rVal >>= rOpt.bIsIgnorePostPositionalWord;  } break;
 626                 case UPH_IS_AUTO_CLOSE_DIALOG :
 627                     { rOpt.bROIsAutoCloseDialog = pROStates[i]; rVal >>= rOpt.bIsAutoCloseDialog;  } break;
 628                 case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :
 629                     { rOpt.bROIsShowEntriesRecentlyUsedFirst = pROStates[i]; rVal >>= rOpt.bIsShowEntriesRecentlyUsedFirst;  } break;
 630                 case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :
 631                     { rOpt.bROIsAutoReplaceUniqueEntries = pROStates[i]; rVal >>= rOpt.bIsAutoReplaceUniqueEntries;  } break;
 632
 633                 case UPH_IS_DIRECTION_TO_SIMPLIFIED :
 634                     {
 635                         rOpt.bROIsDirectionToSimplified = pROStates[i];
 636                         if( ! (rVal >>= rOpt.bIsDirectionToSimplified) )
 637                         {
 638                             //default is locale dependent:
 639                             if (MsLangId::isTraditionalChinese(rOpt.nDefaultLanguage_CJK))
 640                             {
 641                                 rOpt.bIsDirectionToSimplified = false;
 642                             }
 643                             else
 644                             {
 645                                 rOpt.bIsDirectionToSimplified = true;
 646                             }
 647                         }
 648                     } break;
 649                 case UPH_IS_USE_CHARACTER_VARIANTS :
 650                     { rOpt.bROIsUseCharacterVariants = pROStates[i]; rVal >>= rOpt.bIsUseCharacterVariants;  } break;
 651                 case UPH_IS_TRANSLATE_COMMON_TERMS :
 652                     { rOpt.bROIsTranslateCommonTerms = pROStates[i]; rVal >>= rOpt.bIsTranslateCommonTerms;  } break;
 653                 case UPH_IS_REVERSE_MAPPING :
 654                     { rOpt.bROIsReverseMapping = pROStates[i]; rVal >>= rOpt.bIsReverseMapping;  } break;
 655
 656                 case UPH_DATA_FILES_CHANGED_CHECK_VALUE :
 657                     { rOpt.bRODataFilesChangedCheckValue = pROStates[i]; rVal >>= rOpt.nDataFilesChangedCheckValue;  } break;
 658
 659                 case UPH_IS_GRAMMAR_AUTO:
 660                     { rOpt.bROIsGrammarAuto = pROStates[i]; rVal >>= rOpt.bIsGrammarAuto; }
 661                 break;
 662                 case UPH_IS_GRAMMAR_INTERACTIVE:
 663                     { rOpt.bROIsGrammarInteractive = pROStates[i]; rVal >>= rOpt.bIsGrammarInteractive; }
 664                 break;
 665
 666                 default:
 667                     SAL_WARN( "unotools.config", "unexpected case" );
 668             }
 669         }
 670
 671         bRes = true;
 672     }
 673     DBG_ASSERT( bRes, "LoadOptions failed" );
 674 }
 675
 676 bool SvtLinguConfigItem::SaveOptions( const uno::Sequence< OUString > &rProperyNames )
 677 {
 678     if (!IsModified())
 679         return true;
 680
 681     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 682
 683     bool bRet = false;
 684
 685     sal_Int32 nProps = rProperyNames.getLength();
 686     uno::Sequence< uno::Any > aValues( nProps );
 687     uno::Any *pValue = aValues.getArray();
 688
 689     if (nProps  &&  aValues.getLength() == nProps)
 690     {
 691         const SvtLinguOptions &rOpt = aOpt;
 692
 693         OUString aTmp( lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage ) );
 694         *pValue++ <<= aTmp;                               //   0
 695         *pValue++ <<= rOpt.aActiveDics;                   //   1
 696         *pValue++ <<= rOpt.bIsUseDictionaryList;        //   2
 697         *pValue++ <<= rOpt.bIsIgnoreControlCharacters;  //   3
 698         aTmp = lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage_CJK );
 699         *pValue++ <<= aTmp;                               //   5
 700         aTmp = lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage_CTL );
 701         *pValue++ <<= aTmp;                               //   6
 702
 703         *pValue++ <<= rOpt.bIsSpellUpperCase;          //   7
 704         *pValue++ <<= rOpt.bIsSpellWithDigits;         //   8
 705         *pValue++ <<= rOpt.bIsSpellCapitalization;     //   9
 706         *pValue++ <<= rOpt.bIsSpellAuto;               //  10
 707         *pValue++ <<= rOpt.bIsSpellSpecial;            //  11
 708         *pValue++ <<= rOpt.bIsSpellReverse;            //  14
 709
 710         *pValue++ <<= rOpt.nHyphMinLeading;            //  15
 711         *pValue++ <<= rOpt.nHyphMinTrailing;           //  16
 712         *pValue++ <<= rOpt.nHyphMinWordLength;         //  17
 713         *pValue++ <<= rOpt.bIsHyphSpecial;             //  18
 714         *pValue++ <<= rOpt.bIsHyphAuto;                //  19
 715
 716         *pValue++ <<= rOpt.aActiveConvDics;               //   20
 717
 718         *pValue++ <<= rOpt.bIsIgnorePostPositionalWord; //  21
 719         *pValue++ <<= rOpt.bIsAutoCloseDialog;          //  22
 720         *pValue++ <<= rOpt.bIsShowEntriesRecentlyUsedFirst; //  23
 721         *pValue++ <<= rOpt.bIsAutoReplaceUniqueEntries; //  24
 722
 723         *pValue++ <<= rOpt.bIsDirectionToSimplified; //  25
 724         *pValue++ <<= rOpt.bIsUseCharacterVariants; //  26
 725         *pValue++ <<= rOpt.bIsTranslateCommonTerms; //  27
 726         *pValue++ <<= rOpt.bIsReverseMapping; //  28
 727
 728         *pValue++ <<= rOpt.nDataFilesChangedCheckValue; //  29
 729         *pValue++ <<= rOpt.bIsGrammarAuto; //  30
 730         *pValue++ <<= rOpt.bIsGrammarInteractive; // 31
 731
 732         bRet |= PutProperties( rProperyNames, aValues );
 733     }
 734
 735     if (bRet)
 736         ClearModified();
 737
 738     return bRet;
 739 }
 740
 741 bool SvtLinguConfigItem::IsReadOnly( const OUString &rPropertyName ) const
 742 {
 743     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 744
 745     bool bReadOnly = false;
 746     sal_Int32 nHdl;
 747     if (GetHdlByName( nHdl, rPropertyName ))
 748         bReadOnly = IsReadOnly( nHdl );
 749     return bReadOnly;
 750 }
 751
 752 bool SvtLinguConfigItem::IsReadOnly( sal_Int32 nPropertyHandle ) const
 753 {
 754     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 755
 756     bool bReadOnly = false;
 757
 758     const SvtLinguOptions &rOpt = const_cast< SvtLinguConfigItem * >(this)->aOpt;
 759     switch(nPropertyHandle)
 760     {
 761         case UPH_IS_USE_DICTIONARY_LIST         : bReadOnly = rOpt.bROIsUseDictionaryList; break;
 762         case UPH_IS_IGNORE_CONTROL_CHARACTERS   : bReadOnly = rOpt.bROIsIgnoreControlCharacters; break;
 763         case UPH_IS_HYPH_AUTO                   : bReadOnly = rOpt.bROIsHyphAuto; break;
 764         case UPH_IS_HYPH_SPECIAL                : bReadOnly = rOpt.bROIsHyphSpecial; break;
 765         case UPH_IS_SPELL_AUTO                  : bReadOnly = rOpt.bROIsSpellAuto; break;
 766         case UPH_IS_SPELL_SPECIAL               : bReadOnly = rOpt.bROIsSpellSpecial; break;
 767         case UPH_IS_WRAP_REVERSE                : bReadOnly = rOpt.bROIsSpellReverse; break;
 768         case UPH_DEFAULT_LANGUAGE               : bReadOnly = rOpt.bRODefaultLanguage; break;
 769         case UPH_IS_SPELL_CAPITALIZATION        : bReadOnly = rOpt.bROIsSpellCapitalization; break;
 770         case UPH_IS_SPELL_WITH_DIGITS           : bReadOnly = rOpt.bROIsSpellWithDigits; break;
 771         case UPH_IS_SPELL_UPPER_CASE            : bReadOnly = rOpt.bROIsSpellUpperCase; break;
 772         case UPH_HYPH_MIN_LEADING               : bReadOnly = rOpt.bROHyphMinLeading; break;
 773         case UPH_HYPH_MIN_TRAILING              : bReadOnly = rOpt.bROHyphMinTrailing; break;
 774         case UPH_HYPH_MIN_WORD_LENGTH           : bReadOnly = rOpt.bROHyphMinWordLength; break;
 775         case UPH_ACTIVE_DICTIONARIES            : bReadOnly = rOpt.bROActiveDics; break;
 776         case UPH_ACTIVE_CONVERSION_DICTIONARIES : bReadOnly = rOpt.bROActiveConvDics; break;
 777         case UPH_DEFAULT_LOCALE                 : bReadOnly = rOpt.bRODefaultLanguage; break;
 778         case UPH_DEFAULT_LOCALE_CJK             : bReadOnly = rOpt.bRODefaultLanguage_CJK; break;
 779         case UPH_DEFAULT_LOCALE_CTL             : bReadOnly = rOpt.bRODefaultLanguage_CTL; break;
 780         case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       bReadOnly = rOpt.bROIsIgnorePostPositionalWord; break;
 781         case UPH_IS_AUTO_CLOSE_DIALOG :                 bReadOnly = rOpt.bROIsAutoCloseDialog; break;
 782         case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  bReadOnly = rOpt.bROIsShowEntriesRecentlyUsedFirst; break;
 783         case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       bReadOnly = rOpt.bROIsAutoReplaceUniqueEntries; break;
 784         case UPH_IS_DIRECTION_TO_SIMPLIFIED : bReadOnly = rOpt.bROIsDirectionToSimplified; break;
 785         case UPH_IS_USE_CHARACTER_VARIANTS : bReadOnly = rOpt.bROIsUseCharacterVariants; break;
 786         case UPH_IS_TRANSLATE_COMMON_TERMS : bReadOnly = rOpt.bROIsTranslateCommonTerms; break;
 787         case UPH_IS_REVERSE_MAPPING :        bReadOnly = rOpt.bROIsReverseMapping; break;
 788         case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       bReadOnly = rOpt.bRODataFilesChangedCheckValue; break;
 789         case UPH_IS_GRAMMAR_AUTO:                       bReadOnly = rOpt.bROIsGrammarAuto; break;
 790         case UPH_IS_GRAMMAR_INTERACTIVE:                bReadOnly = rOpt.bROIsGrammarInteractive; break;
 791         default :
 792             SAL_WARN( "unotools.config", "unexpected property handle" );
 793     }
 794     return bReadOnly;
 795 }
 796
 797 static SvtLinguConfigItem *pCfgItem = nullptr;
 798 static sal_Int32           nCfgItemRefCount = 0;
 799
 800 static const char aG_Dictionaries[] = "Dictionaries";
 801
 802 SvtLinguConfig::SvtLinguConfig()
 803 {
 804     // Global access, must be guarded (multithreading)
 805     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 806     ++nCfgItemRefCount;
 807 }
 808
 809 SvtLinguConfig::~SvtLinguConfig()
 810 {
 811     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 812
 813     if (pCfgItem && pCfgItem->IsModified())
 814         pCfgItem->Commit();
 815
 816     if (--nCfgItemRefCount <= 0)
 817     {
 818         delete pCfgItem;
 819         pCfgItem = nullptr;
 820     }
 821 }
 822
 823 SvtLinguConfigItem & SvtLinguConfig::GetConfigItem()
 824 {
 825     // Global access, must be guarded (multithreading)
 826     osl::MutexGuard aGuard(theSvtLinguConfigItemMutex::get());
 827     if (!pCfgItem)
 828     {
 829         pCfgItem = new SvtLinguConfigItem;
 830         ItemHolder1::holdConfigItem(EItem::LinguConfig);
 831     }
 832     return *pCfgItem;
 833 }
 834
 835 uno::Sequence< OUString > SvtLinguConfig::GetNodeNames( const OUString &rNode ) const
 836 {
 837     return GetConfigItem().GetNodeNames( rNode );
 838 }
 839
 840 uno::Sequence< uno::Any > SvtLinguConfig::GetProperties( const uno::Sequence< OUString > &rNames ) const
 841 {
 842     return GetConfigItem().GetProperties(rNames);
 843 }
 844
 845 bool SvtLinguConfig::ReplaceSetProperties(
 846         const OUString &rNode, const uno::Sequence< beans::PropertyValue >& rValues )
 847 {
 848     return GetConfigItem().ReplaceSetProperties( rNode, rValues );
 849 }
 850
 851 uno::Any SvtLinguConfig::GetProperty( const OUString &rPropertyName ) const
 852 {
 853     return GetConfigItem().GetProperty( rPropertyName );
 854 }
 855
 856 uno::Any SvtLinguConfig::GetProperty( sal_Int32 nPropertyHandle ) const
 857 {
 858     return GetConfigItem().GetProperty( nPropertyHandle );
 859 }
 860
 861 bool SvtLinguConfig::SetProperty( const OUString &rPropertyName, const uno::Any &rValue )
 862 {
 863     return GetConfigItem().SetProperty( rPropertyName, rValue );
 864 }
 865
 866 bool SvtLinguConfig::SetProperty( sal_Int32 nPropertyHandle, const uno::Any &rValue )
 867 {
 868     return GetConfigItem().SetProperty( nPropertyHandle, rValue );
 869 }
 870
 871 void SvtLinguConfig::GetOptions( SvtLinguOptions &rOptions ) const
 872 {
 873     rOptions = GetConfigItem().GetOptions();
 874 }
 875
 876 bool SvtLinguConfig::IsReadOnly( const OUString &rPropertyName ) const
 877 {
 878     return GetConfigItem().IsReadOnly( rPropertyName );
 879 }
 880
 881 bool SvtLinguConfig::GetElementNamesFor(
 882      const OUString &rNodeName,
 883      uno::Sequence< OUString > &rElementNames ) const
 884 {
 885     bool bSuccess = false;
 886     try
 887     {
 888         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
 889         xNA.set( xNA->getByName("ServiceManager"), uno::UNO_QUERY_THROW );
 890         xNA.set( xNA->getByName( rNodeName ), uno::UNO_QUERY_THROW );
 891         rElementNames = xNA->getElementNames();
 892         bSuccess = true;
 893     }
 894     catch (uno::Exception &)
 895     {
 896     }
 897     return bSuccess;
 898 }
 899
 900 bool SvtLinguConfig::GetSupportedDictionaryFormatsFor(
 901     const OUString &rSetName,
 902     const OUString &rSetEntry,
 903     uno::Sequence< OUString > &rFormatList ) const
 904 {
 905     if (rSetName.isEmpty() || rSetEntry.isEmpty())
 906         return false;
 907     bool bSuccess = false;
 908     try
 909     {
 910         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
 911         xNA.set( xNA->getByName("ServiceManager"), uno::UNO_QUERY_THROW );
 912         xNA.set( xNA->getByName( rSetName ), uno::UNO_QUERY_THROW );
 913         xNA.set( xNA->getByName( rSetEntry ), uno::UNO_QUERY_THROW );
 914         if (xNA->getByName( "SupportedDictionaryFormats" ) >>= rFormatList)
 915             bSuccess = true;
 916         DBG_ASSERT( rFormatList.hasElements(), "supported dictionary format list is empty" );
 917     }
 918     catch (uno::Exception &)
 919     {
 920     }
 921     return bSuccess;
 922 }
 923
 924 static bool lcl_GetFileUrlFromOrigin(
 925     OUString /*out*/ &rFileUrl,
 926     const OUString &rOrigin )
 927 {
 928     OUString aURL(
 929         comphelper::getExpandedUri(
 930             comphelper::getProcessComponentContext(), rOrigin));
 931     if (aURL.startsWith( FILE_PROTOCOL ))
 932     {
 933         rFileUrl = aURL;
 934         return true;
 935     }
 936     else
 937     {
 938         SAL_WARN(
 939             "unotools.config", "not a file URL, <" << aURL << ">" );
 940         return false;
 941     }
 942 }
 943
 944 bool SvtLinguConfig::GetDictionaryEntry(
 945     const OUString &rNodeName,
 946     SvtLinguConfigDictionaryEntry &rDicEntry ) const
 947 {
 948     if (rNodeName.isEmpty())
 949         return false;
 950     bool bSuccess = false;
 951     try
 952     {
 953         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
 954         xNA.set( xNA->getByName("ServiceManager"), uno::UNO_QUERY_THROW );
 955         xNA.set( xNA->getByName( aG_Dictionaries ), uno::UNO_QUERY_THROW );
 956         xNA.set( xNA->getByName( rNodeName ), uno::UNO_QUERY_THROW );
 957
 958         // read group data...
 959         uno::Sequence< OUString >  aLocations;
 960         OUString                   aFormatName;
 961         uno::Sequence< OUString >  aLocaleNames;
 962         bSuccess =  (xNA->getByName( "Locations" ) >>= aLocations)  &&
 963                     (xNA->getByName( "Format" )    >>= aFormatName) &&
 964                     (xNA->getByName( "Locales" )   >>= aLocaleNames);
 965         DBG_ASSERT( aLocations.hasElements(), "Dictionary locations not set" );
 966         DBG_ASSERT( !aFormatName.isEmpty(), "Dictionary format name not set" );
 967         DBG_ASSERT( aLocaleNames.hasElements(), "No locales set for the dictionary" );
 968
 969         // if successful continue
 970         if (bSuccess)
 971         {
 972             // get file URL's for the locations
 973             for (OUString& rLocation : aLocations)
 974             {
 975                 if (!lcl_GetFileUrlFromOrigin( rLocation, rLocation ))
 976                     bSuccess = false;
 977             }
 978
 979             // if everything was fine return the result
 980             if (bSuccess)
 981             {
 982                 rDicEntry.aLocations    = aLocations;
 983                 rDicEntry.aFormatName   = aFormatName;
 984                 rDicEntry.aLocaleNames  = aLocaleNames;
 985             }
 986         }
 987     }
 988     catch (uno::Exception &)
 989     {
 990     }
 991     return bSuccess;
 992 }
 993
 994 uno::Sequence< OUString > SvtLinguConfig::GetDisabledDictionaries() const
 995 {
 996     uno::Sequence< OUString > aResult;
 997     try
 998     {
 999         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1000         xNA.set( xNA->getByName("ServiceManager"), uno::UNO_QUERY_THROW );
1001         xNA->getByName( "DisabledDictionaries" ) >>= aResult;
1002     }
1003     catch (uno::Exception &)
1004     {
1005     }
1006     return aResult;
1007 }
1008
1009 std::vector< SvtLinguConfigDictionaryEntry > SvtLinguConfig::GetActiveDictionariesByFormat(
1010     const OUString &rFormatName ) const
1011 {
1012     std::vector< SvtLinguConfigDictionaryEntry > aRes;
1013     if (rFormatName.isEmpty())
1014         return aRes;
1015
1016     try
1017     {
1018         uno::Sequence< OUString > aElementNames;
1019         GetElementNamesFor( aG_Dictionaries, aElementNames );
1020
1021         const uno::Sequence< OUString > aDisabledDics( GetDisabledDictionaries() );
1022
1023         SvtLinguConfigDictionaryEntry aDicEntry;
1024         for (const OUString& rElementName : std::as_const(aElementNames))
1025         {
1026             // does dictionary match the format we are looking for?
1027             if (GetDictionaryEntry( rElementName, aDicEntry ) &&
1028                 aDicEntry.aFormatName == rFormatName)
1029             {
1030                 // check if it is active or not
1031                 bool bDicIsActive = std::none_of(aDisabledDics.begin(), aDisabledDics.end(),
1032                     [&rElementName](const OUString& rDic) { return rDic == rElementName; });
1033
1034                 if (bDicIsActive)
1035                 {
1036                     DBG_ASSERT( !aDicEntry.aFormatName.isEmpty(),
1037                             "FormatName not set" );
1038                     DBG_ASSERT( aDicEntry.aLocations.hasElements(),
1039                             "Locations not set" );
1040                     DBG_ASSERT( aDicEntry.aLocaleNames.hasElements(),
1041                             "Locales not set" );
1042                     aRes.push_back( aDicEntry );
1043                 }
1044             }
1045         }
1046     }
1047     catch (uno::Exception &)
1048     {
1049     }
1050
1051     return aRes;
1052 }
1053
1054 uno::Reference< util::XChangesBatch > const & SvtLinguConfig::GetMainUpdateAccess() const
1055 {
1056     if (!m_xMainUpdateAccess.is())
1057     {
1058         try
1059         {
1060             // get configuration provider
1061             uno::Reference< uno::XComponentContext > xContext = comphelper::getProcessComponentContext();
1062             uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider =
1063                     configuration::theDefaultProvider::get( xContext );
1064
1065             // get configuration update access
1066             beans::PropertyValue aValue;
1067             aValue.Name  = "nodepath";
1068             aValue.Value <<= OUString("org.openoffice.Office.Linguistic");
1069             uno::Sequence< uno::Any > aProps(1);
1070             aProps[0] <<= aValue;
1071             m_xMainUpdateAccess.set(
1072                     xConfigurationProvider->createInstanceWithArguments(
1073                         "com.sun.star.configuration.ConfigurationUpdateAccess", aProps),
1074                         uno::UNO_QUERY_THROW );
1075         }
1076         catch (uno::Exception &)
1077         {
1078         }
1079     }
1080
1081     return m_xMainUpdateAccess;
1082 }
1083
1084 OUString SvtLinguConfig::GetVendorImageUrl_Impl(
1085     const OUString &rServiceImplName,
1086     const OUString &rImageName ) const
1087 {
1088     OUString aRes;
1089     try
1090     {
1091         uno::Reference< container::XNameAccess > xImagesNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1092         xImagesNA.set( xImagesNA->getByName("Images"), uno::UNO_QUERY_THROW );
1093
1094         uno::Reference< container::XNameAccess > xNA( xImagesNA->getByName("ServiceNameEntries"), uno::UNO_QUERY_THROW );
1095         xNA.set( xNA->getByName( rServiceImplName ), uno::UNO_QUERY_THROW );
1096         uno::Any aAny(xNA->getByName("VendorImagesNode"));
1097         OUString aVendorImagesNode;
1098         if (aAny >>= aVendorImagesNode)
1099         {
1100             xNA = xImagesNA;
1101             xNA.set( xNA->getByName("VendorImages"), uno::UNO_QUERY_THROW );
1102             xNA.set( xNA->getByName( aVendorImagesNode ), uno::UNO_QUERY_THROW );
1103             aAny = xNA->getByName( rImageName );
1104             OUString aTmp;
1105             if (aAny >>= aTmp)
1106             {
1107                 if (lcl_GetFileUrlFromOrigin( aTmp, aTmp ))
1108                     aRes = aTmp;
1109             }
1110         }
1111     }
1112     catch (uno::Exception &)
1113     {
1114         DBG_UNHANDLED_EXCEPTION("unotools");
1115     }
1116     return aRes;
1117 }
1118
1119 OUString SvtLinguConfig::GetSpellAndGrammarContextSuggestionImage(
1120     const OUString &rServiceImplName
1121 ) const
1122 {
1123     OUString   aRes;
1124     if (!rServiceImplName.isEmpty())
1125     {
1126         aRes = GetVendorImageUrl_Impl( rServiceImplName, "SpellAndGrammarContextMenuSuggestionImage" );
1127     }
1128     return aRes;
1129 }
1130
1131 OUString SvtLinguConfig::GetSpellAndGrammarContextDictionaryImage(
1132     const OUString &rServiceImplName
1133 ) const
1134 {
1135     OUString   aRes;
1136     if (!rServiceImplName.isEmpty())
1137     {
1138         aRes = GetVendorImageUrl_Impl( rServiceImplName, "SpellAndGrammarContextMenuDictionaryImage" );
1139     }
1140     return aRes;
1141 }
1142
1143 OUString SvtLinguConfig::GetSynonymsContextImage(
1144     const OUString &rServiceImplName
1145 ) const
1146 {
1147     OUString   aRes;
1148     if (!rServiceImplName.isEmpty())
1149     {
1150         OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, "SynonymsContextMenuImage" ) );
1151         aRes = aPath;
1152     }
1153     return aRes;
1154 }
1155
1156 bool SvtLinguConfig::HasGrammarChecker() const
1157 {
1158     bool bRes = false;
1159
1160     try
1161     {
1162         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1163         xNA.set( xNA->getByName("ServiceManager"), uno::UNO_QUERY_THROW );
1164         xNA.set( xNA->getByName("GrammarCheckerList"), uno::UNO_QUERY_THROW );
1165
1166         uno::Sequence< OUString > aElementNames( xNA->getElementNames() );
1167         bRes = aElementNames.hasElements();
1168     }
1169     catch (const uno::Exception&)
1170     {
1171     }
1172
1173     return bRes;
1174 }
1175
1176 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */