svtools/source/config/lingucfg.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: lingucfg.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34
  35 #include <com/sun/star/lang/Locale.hpp>
  36 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  37 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  38 #include <com/sun/star/container/XNameAccess.hpp>
  39 #include <com/sun/star/container/XNameContainer.hpp>
  40 #include <com/sun/star/container/XNameReplace.hpp>
  41 #include "com/sun/star/util/XMacroExpander.hpp"
  42 #include "com/sun/star/beans/XPropertySet.hpp"
  43 #include <rtl/uri.hxx>
  44 #include <vos/mutex.hxx>
  45 #include <i18npool/mslangid.hxx>
  46 #include <tools/debug.hxx>
  47 #include <vcl/svapp.hxx>
  48 #include <svtools/lingucfg.hxx>
  49 #include <linguprops.hxx>
  50
  51 #include <comphelper/processfactory.hxx>
  52
  53 #include <itemholder1.hxx>
  54
  55 using namespace rtl;
  56 using namespace com::sun::star;
  57
  58 #define A2OU(x)        ::rtl::OUString::createFromAscii( x )
  59 #define EXPAND_PROTOCOL     "vnd.sun.star.expand:"
  60 #define FILE_PROTOCOL       "file:///"
  61
  62 ///////////////////////////////////////////////////////////////////////////
  63
  64
  65 static osl::Mutex &  GetOwnMutex()
  66 {
  67     static osl::Mutex aMutex;
  68     return aMutex;
  69 }
  70
  71
  72 ///////////////////////////////////////////////////////////////////////////
  73
  74
  75 static BOOL lcl_SetLocale( INT16 &rLanguage, const uno::Any &rVal )
  76 {
  77     BOOL bSucc = FALSE;
  78
  79     lang::Locale aNew;
  80     if (rVal >>= aNew)  // conversion successful?
  81     {
  82         INT16 nNew = MsLangId::convertLocaleToLanguage( aNew );
  83         if (nNew != rLanguage)
  84         {
  85             rLanguage = nNew;
  86             bSucc = TRUE;
  87         }
  88     }
  89     return bSucc;
  90 }
  91
  92
  93 static inline const OUString lcl_LanguageToCfgLocaleStr( INT16 nLanguage )
  94 {
  95     OUString aRes;
  96     if (LANGUAGE_SYSTEM != nLanguage)
  97         aRes = MsLangId::convertLanguageToIsoString( nLanguage );
  98     return aRes;
  99 }
 100
 101
 102 static INT16 lcl_CfgAnyToLanguage( const uno::Any &rVal )
 103 {
 104     OUString aTmp;
 105     rVal >>= aTmp;
 106     return (aTmp.getLength() == 0) ? LANGUAGE_SYSTEM : MsLangId::convertIsoStringToLanguage( aTmp );
 107 }
 108
 109
 110 //////////////////////////////////////////////////////////////////////
 111
 112 SvtLinguOptions::SvtLinguOptions()
 113 {
 114     nDefaultLanguage = LANGUAGE_NONE;
 115     nDefaultLanguage_CJK = LANGUAGE_NONE;
 116     nDefaultLanguage_CTL = LANGUAGE_NONE;
 117
 118     // general options
 119     bIsUseDictionaryList        =
 120     bIsIgnoreControlCharacters  = TRUE;
 121
 122     // spelling options
 123     bIsSpellCapitalization      =
 124     bIsSpellSpecial                     = TRUE;
 125     bIsSpellAuto                        =
 126     bIsSpellReverse                     =
 127     bIsSpellWithDigits          =
 128     bIsSpellUpperCase           = FALSE;
 129
 130     // text conversion options
 131     bIsIgnorePostPositionalWord     = TRUE;
 132     bIsAutoCloseDialog              =
 133     bIsShowEntriesRecentlyUsedFirst =
 134     bIsAutoReplaceUniqueEntries     = FALSE;
 135     bIsDirectionToSimplified        = TRUE;
 136     bIsUseCharacterVariants         =
 137     bIsTranslateCommonTerms         =
 138     bIsReverseMapping               = FALSE;
 139
 140     bROIsDirectionToSimplified      =
 141     bROIsUseCharacterVariants       =
 142     bROIsTranslateCommonTerms       =
 143     bROIsReverseMapping             = FALSE;
 144
 145     // hyphenation options
 146     bIsHyphSpecial                      = TRUE;
 147     bIsHyphAuto                         = FALSE;
 148     nHyphMinLeading                     =
 149     nHyphMinTrailing            = 2;
 150     nHyphMinWordLength          = 0;
 151
 152     nDataFilesChangedCheckValue = 0;
 153
 154     //grammar options
 155     bIsGrammarAuto = sal_False,
 156     bIsGrammarInteractive = sal_False;
 157
 158 }
 159
 160
 161 //////////////////////////////////////////////////////////////////////
 162
 163
 164 class SvtLinguConfigItem : public utl::ConfigItem
 165 {
 166     SvtLinguOptions     aOpt;
 167
 168     // disallow copy-constructor and assignment-operator for now
 169     SvtLinguConfigItem( const SvtLinguConfigItem & );
 170     SvtLinguConfigItem & operator = ( const SvtLinguConfigItem & );
 171
 172     static BOOL GetHdlByName( INT32 &rnHdl, const OUString &rPropertyName, sal_Bool bFullPropName = sal_False );
 173     static const uno::Sequence< OUString > & GetPropertyNames();
 174     BOOL                LoadOptions( const uno::Sequence< OUString > &rProperyNames );
 175     BOOL                SaveOptions( const uno::Sequence< OUString > &rProperyNames );
 176
 177 public:
 178     SvtLinguConfigItem();
 179     virtual ~SvtLinguConfigItem();
 180
 181     // utl::ConfigItem
 182     virtual void    Notify( const com::sun::star::uno::Sequence< rtl::OUString > &rPropertyNames );
 183     virtual void    Commit();
 184
 185     // make some protected functions of utl::ConfigItem public
 186     using utl::ConfigItem::GetNodeNames;
 187     using utl::ConfigItem::GetProperties;
 188     //using utl::ConfigItem::PutProperties;
 189     //using utl::ConfigItem::SetSetProperties;
 190     using utl::ConfigItem::ReplaceSetProperties;
 191     //using utl::ConfigItem::GetReadOnlyStates;
 192
 193
 194     com::sun::star::uno::Any
 195             GetProperty( const rtl::OUString &rPropertyName ) const;
 196     com::sun::star::uno::Any
 197             GetProperty( INT32 nPropertyHandle ) const;
 198
 199     BOOL    SetProperty( const rtl::OUString &rPropertyName,
 200                          const com::sun::star::uno::Any &rValue );
 201     BOOL    SetProperty( INT32 nPropertyHandle,
 202                          const com::sun::star::uno::Any &rValue );
 203
 204     BOOL    GetOptions( SvtLinguOptions &rOptions ) const;
 205     BOOL    SetOptions( const SvtLinguOptions &rOptions );
 206
 207     BOOL    IsReadOnly( const rtl::OUString &rPropertyName ) const;
 208     BOOL    IsReadOnly( INT32 nPropertyHandle ) const;
 209 };
 210
 211
 212 SvtLinguConfigItem::SvtLinguConfigItem() :
 213     utl::ConfigItem( String::CreateFromAscii( "Office.Linguistic" ) )
 214 {
 215     LoadOptions( GetPropertyNames() );
 216     ClearModified();
 217
 218     // request notify events when properties change
 219     EnableNotification( GetPropertyNames() );
 220 }
 221
 222
 223 SvtLinguConfigItem::~SvtLinguConfigItem()
 224 {
 225     //! Commit (SaveOptions) will be called by the d-tor of the base called !
 226 }
 227
 228
 229 void SvtLinguConfigItem::Notify( const uno::Sequence< OUString > &rPropertyNames )
 230 {
 231     LoadOptions( rPropertyNames );
 232 }
 233
 234
 235 void SvtLinguConfigItem::Commit()
 236 {
 237     SaveOptions( GetPropertyNames() );
 238 }
 239
 240
 241 static struct NamesToHdl
 242 {
 243     const char   *pFullPropName;      // full qualified name as used in configuration
 244     const char   *pPropName;          // property name only (atom) of above
 245     INT32   nHdl;               // numeric handle representing the property
 246 }aNamesToHdl[] =
 247 {
 248 {/*  0 */    "General/DefaultLocale",                         UPN_DEFAULT_LOCALE,                    UPH_DEFAULT_LOCALE},
 249 {/*  1 */    "General/DictionaryList/ActiveDictionaries",     UPN_ACTIVE_DICTIONARIES,               UPH_ACTIVE_DICTIONARIES},
 250 {/*  2 */    "General/DictionaryList/IsUseDictionaryList",    UPN_IS_USE_DICTIONARY_LIST,            UPH_IS_USE_DICTIONARY_LIST},
 251 {/*  3 */    "General/IsIgnoreControlCharacters",             UPN_IS_IGNORE_CONTROL_CHARACTERS,      UPH_IS_IGNORE_CONTROL_CHARACTERS},
 252 {/*  5 */    "General/DefaultLocale_CJK",                     UPN_DEFAULT_LOCALE_CJK,                UPH_DEFAULT_LOCALE_CJK},
 253 {/*  6 */    "General/DefaultLocale_CTL",                     UPN_DEFAULT_LOCALE_CTL,                UPH_DEFAULT_LOCALE_CTL},
 254
 255 {/*  7 */    "SpellChecking/IsSpellUpperCase",                UPN_IS_SPELL_UPPER_CASE,               UPH_IS_SPELL_UPPER_CASE},
 256 {/*  8 */    "SpellChecking/IsSpellWithDigits",               UPN_IS_SPELL_WITH_DIGITS,              UPH_IS_SPELL_WITH_DIGITS},
 257 {/*  9 */    "SpellChecking/IsSpellCapitalization",           UPN_IS_SPELL_CAPITALIZATION,           UPH_IS_SPELL_CAPITALIZATION},
 258 {/* 10 */    "SpellChecking/IsSpellAuto",                     UPN_IS_SPELL_AUTO,                     UPH_IS_SPELL_AUTO},
 259 {/* 11 */    "SpellChecking/IsSpellSpecial",                  UPN_IS_SPELL_SPECIAL,                  UPH_IS_SPELL_SPECIAL},
 260 {/* 14 */    "SpellChecking/IsReverseDirection",              UPN_IS_WRAP_REVERSE,                   UPH_IS_WRAP_REVERSE},
 261
 262 {/* 15 */    "Hyphenation/MinLeading",                        UPN_HYPH_MIN_LEADING,                  UPH_HYPH_MIN_LEADING},
 263 {/* 16 */    "Hyphenation/MinTrailing",                       UPN_HYPH_MIN_TRAILING,                 UPH_HYPH_MIN_TRAILING},
 264 {/* 17 */    "Hyphenation/MinWordLength",                     UPN_HYPH_MIN_WORD_LENGTH,              UPH_HYPH_MIN_WORD_LENGTH},
 265 {/* 18 */    "Hyphenation/IsHyphSpecial",                     UPN_IS_HYPH_SPECIAL,                   UPH_IS_HYPH_SPECIAL},
 266 {/* 19 */    "Hyphenation/IsHyphAuto",                        UPN_IS_HYPH_AUTO,                      UPH_IS_HYPH_AUTO},
 267
 268 {/* 20 */    "TextConversion/ActiveConversionDictionaries",   UPN_ACTIVE_CONVERSION_DICTIONARIES,        UPH_ACTIVE_CONVERSION_DICTIONARIES},
 269 {/* 21 */    "TextConversion/IsIgnorePostPositionalWord",     UPN_IS_IGNORE_POST_POSITIONAL_WORD,        UPH_IS_IGNORE_POST_POSITIONAL_WORD},
 270 {/* 22 */    "TextConversion/IsAutoCloseDialog",              UPN_IS_AUTO_CLOSE_DIALOG,                  UPH_IS_AUTO_CLOSE_DIALOG},
 271 {/* 23 */    "TextConversion/IsShowEntriesRecentlyUsedFirst", UPN_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST,   UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST},
 272 {/* 24 */    "TextConversion/IsAutoReplaceUniqueEntries",     UPN_IS_AUTO_REPLACE_UNIQUE_ENTRIES,        UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES},
 273 {/* 25 */    "TextConversion/IsDirectionToSimplified",        UPN_IS_DIRECTION_TO_SIMPLIFIED,            UPH_IS_DIRECTION_TO_SIMPLIFIED},
 274 {/* 26 */    "TextConversion/IsUseCharacterVariants",         UPN_IS_USE_CHARACTER_VARIANTS,             UPH_IS_USE_CHARACTER_VARIANTS},
 275 {/* 27 */    "TextConversion/IsTranslateCommonTerms",         UPN_IS_TRANSLATE_COMMON_TERMS,             UPH_IS_TRANSLATE_COMMON_TERMS},
 276 {/* 28 */    "TextConversion/IsReverseMapping",               UPN_IS_REVERSE_MAPPING,                    UPH_IS_REVERSE_MAPPING},
 277
 278 {/* 29 */    "ServiceManager/DataFilesChangedCheckValue",     UPN_DATA_FILES_CHANGED_CHECK_VALUE,        UPH_DATA_FILES_CHANGED_CHECK_VALUE},
 279
 280 {/* 30 */    "GrammarChecking/IsAutoCheck",                   UPN_IS_GRAMMAR_AUTO,                      UPH_IS_GRAMMAR_AUTO},
 281 {/* 31 */    "GrammarChecking/IsInteractiveCheck",            UPN_IS_GRAMMAR_INTERACTIVE,               UPH_IS_GRAMMAR_INTERACTIVE},
 282
 283             /* similar to entry 0 (thus no own configuration entry) but with different property name and type */
 284 {            NULL,                                                                                       UPN_DEFAULT_LANGUAGE,                      UPH_DEFAULT_LANGUAGE},
 285
 286 {            NULL,                                            NULL,                                      -1}
 287 };
 288
 289
 290 const uno::Sequence< OUString > & SvtLinguConfigItem::GetPropertyNames()
 291 {
 292     static uno::Sequence< OUString > aNames;
 293     static sal_Bool bInitialized = sal_False;
 294
 295     if (!bInitialized)
 296     {
 297         INT32 nMax = sizeof(aNamesToHdl) / sizeof(aNamesToHdl[0]);
 298
 299         aNames.realloc( nMax );
 300         OUString *pNames = aNames.getArray();
 301         INT32 nIdx = 0;
 302         for (INT32 i = 0; i < nMax;  ++i)
 303         {
 304             const sal_Char *pFullPropName = aNamesToHdl[i].pFullPropName;
 305             if (pFullPropName)
 306                 pNames[ nIdx++ ] = A2OU( pFullPropName );
 307         }
 308         aNames.realloc( nIdx );
 309         bInitialized = sal_True;
 310     }
 311     return aNames;
 312 }
 313
 314
 315 BOOL SvtLinguConfigItem::GetHdlByName(
 316     INT32 &rnHdl,
 317     const OUString &rPropertyName,
 318     sal_Bool bFullPropName )
 319 {
 320     NamesToHdl *pEntry = &aNamesToHdl[0];
 321
 322     if (bFullPropName)
 323     {
 324         while (pEntry && pEntry->pFullPropName != NULL)
 325         {
 326             if (0 == rPropertyName.compareToAscii( pEntry->pFullPropName ))
 327             {
 328                 rnHdl = pEntry->nHdl;
 329                 break;
 330             }
 331             ++pEntry;
 332         }
 333         return pEntry && pEntry->pFullPropName != NULL;
 334     }
 335     else
 336     {
 337         while (pEntry && pEntry->pPropName != NULL)
 338         {
 339             if (0 == rPropertyName.compareToAscii( pEntry->pPropName ))
 340             {
 341                 rnHdl = pEntry->nHdl;
 342                 break;
 343             }
 344             ++pEntry;
 345         }
 346         return pEntry && pEntry->pPropName != NULL;
 347     }
 348 }
 349
 350
 351 uno::Any SvtLinguConfigItem::GetProperty( const OUString &rPropertyName ) const
 352 {
 353     osl::MutexGuard aGuard( GetOwnMutex() );
 354
 355     INT32 nHdl;
 356     return GetHdlByName( nHdl, rPropertyName ) ? GetProperty( nHdl ) : uno::Any();
 357 }
 358
 359
 360 uno::Any SvtLinguConfigItem::GetProperty( INT32 nPropertyHandle ) const
 361 {
 362     osl::MutexGuard aGuard( GetOwnMutex() );
 363
 364     uno::Any aRes;
 365
 366     const INT16 *pnVal = 0;
 367     const BOOL  *pbVal = 0;
 368     const INT32 *pnInt32Val = 0;
 369
 370     const SvtLinguOptions &rOpt = const_cast< SvtLinguConfigItem * >(this)->aOpt;
 371     switch (nPropertyHandle)
 372     {
 373         case UPH_IS_USE_DICTIONARY_LIST :   pbVal = &rOpt.bIsUseDictionaryList; break;
 374         case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &rOpt.bIsIgnoreControlCharacters;   break;
 375         case UPH_IS_HYPH_AUTO :             pbVal = &rOpt.bIsHyphAuto;  break;
 376         case UPH_IS_HYPH_SPECIAL :          pbVal = &rOpt.bIsHyphSpecial;   break;
 377         case UPH_IS_SPELL_AUTO :            pbVal = &rOpt.bIsSpellAuto; break;
 378         case UPH_IS_SPELL_SPECIAL :         pbVal = &rOpt.bIsSpellSpecial;  break;
 379         case UPH_IS_WRAP_REVERSE :          pbVal = &rOpt.bIsSpellReverse;  break;
 380         case UPH_DEFAULT_LANGUAGE :         pnVal = &rOpt.nDefaultLanguage; break;
 381         case UPH_IS_SPELL_CAPITALIZATION :  pbVal = &rOpt.bIsSpellCapitalization;       break;
 382         case UPH_IS_SPELL_WITH_DIGITS :     pbVal = &rOpt.bIsSpellWithDigits;   break;
 383         case UPH_IS_SPELL_UPPER_CASE :      pbVal = &rOpt.bIsSpellUpperCase;        break;
 384         case UPH_HYPH_MIN_LEADING :         pnVal = &rOpt.nHyphMinLeading;      break;
 385         case UPH_HYPH_MIN_TRAILING :        pnVal = &rOpt.nHyphMinTrailing; break;
 386         case UPH_HYPH_MIN_WORD_LENGTH :     pnVal = &rOpt.nHyphMinWordLength;   break;
 387         case UPH_ACTIVE_DICTIONARIES :
 388         {
 389             aRes <<= rOpt.aActiveDics;
 390             break;
 391         }
 392         case UPH_ACTIVE_CONVERSION_DICTIONARIES :
 393         {
 394             aRes <<= rOpt.aActiveConvDics;
 395             break;
 396         }
 397         case UPH_DEFAULT_LOCALE :
 398         {
 399             lang::Locale aLocale( MsLangId::convertLanguageToLocale( rOpt.nDefaultLanguage, false ) );
 400             aRes.setValue( &aLocale, ::getCppuType((lang::Locale*)0 ));
 401             break;
 402         }
 403         case UPH_DEFAULT_LOCALE_CJK :
 404         {
 405             lang::Locale aLocale( MsLangId::convertLanguageToLocale( rOpt.nDefaultLanguage_CJK, false ) );
 406             aRes.setValue( &aLocale, ::getCppuType((lang::Locale*)0 ));
 407             break;
 408         }
 409         case UPH_DEFAULT_LOCALE_CTL :
 410         {
 411             lang::Locale aLocale( MsLangId::convertLanguageToLocale( rOpt.nDefaultLanguage_CTL, false ) );
 412             aRes.setValue( &aLocale, ::getCppuType((lang::Locale*)0 ));
 413             break;
 414         }
 415         case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       pbVal = &rOpt.bIsIgnorePostPositionalWord; break;
 416         case UPH_IS_AUTO_CLOSE_DIALOG :                 pbVal = &rOpt.bIsAutoCloseDialog; break;
 417         case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  pbVal = &rOpt.bIsShowEntriesRecentlyUsedFirst; break;
 418         case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       pbVal = &rOpt.bIsAutoReplaceUniqueEntries; break;
 419
 420         case UPH_IS_DIRECTION_TO_SIMPLIFIED:            pbVal = &rOpt.bIsDirectionToSimplified; break;
 421         case UPH_IS_USE_CHARACTER_VARIANTS :            pbVal = &rOpt.bIsUseCharacterVariants; break;
 422         case UPH_IS_TRANSLATE_COMMON_TERMS :            pbVal = &rOpt.bIsTranslateCommonTerms; break;
 423         case UPH_IS_REVERSE_MAPPING :                   pbVal = &rOpt.bIsReverseMapping; break;
 424
 425         case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       pnInt32Val = &rOpt.nDataFilesChangedCheckValue; break;
 426         case UPH_IS_GRAMMAR_AUTO:                       pbVal = &rOpt.bIsGrammarAuto; break;
 427         case UPH_IS_GRAMMAR_INTERACTIVE:                pbVal = &rOpt.bIsGrammarInteractive; break;
 428         default :
 429             DBG_ASSERT( 0, "unexpected property handle" );
 430     }
 431
 432     if (pbVal)
 433         aRes <<= *pbVal;
 434     else if (pnVal)
 435         aRes <<= *pnVal;
 436     else if (pnInt32Val)
 437         aRes <<= *pnInt32Val;
 438
 439     return aRes;
 440 }
 441
 442
 443 BOOL SvtLinguConfigItem::SetProperty( const OUString &rPropertyName, const uno::Any &rValue )
 444 {
 445     osl::MutexGuard aGuard( GetOwnMutex() );
 446
 447     BOOL bSucc = FALSE;
 448     INT32 nHdl;
 449     if (GetHdlByName( nHdl, rPropertyName ))
 450         bSucc = SetProperty( nHdl, rValue );
 451     return bSucc;
 452 }
 453
 454
 455 BOOL SvtLinguConfigItem::SetProperty( INT32 nPropertyHandle, const uno::Any &rValue )
 456 {
 457     osl::MutexGuard aGuard( GetOwnMutex() );
 458
 459     BOOL bSucc = FALSE;
 460     if (!rValue.hasValue())
 461         return bSucc;
 462
 463     BOOL bMod = FALSE;
 464
 465     INT16 *pnVal = 0;
 466     BOOL  *pbVal = 0;
 467     INT32 *pnInt32Val = 0;
 468
 469     SvtLinguOptions &rOpt = aOpt;
 470     switch (nPropertyHandle)
 471     {
 472         case UPH_IS_USE_DICTIONARY_LIST :   pbVal = &rOpt.bIsUseDictionaryList;    break;
 473         case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &rOpt.bIsIgnoreControlCharacters;  break;
 474         case UPH_IS_HYPH_AUTO :             pbVal = &rOpt.bIsHyphAuto; break;
 475         case UPH_IS_HYPH_SPECIAL :          pbVal = &rOpt.bIsHyphSpecial;  break;
 476         case UPH_IS_SPELL_AUTO :            pbVal = &rOpt.bIsSpellAuto;    break;
 477         case UPH_IS_SPELL_SPECIAL :         pbVal = &rOpt.bIsSpellSpecial; break;
 478         case UPH_IS_WRAP_REVERSE :          pbVal = &rOpt.bIsSpellReverse; break;
 479         case UPH_DEFAULT_LANGUAGE :         pnVal = &rOpt.nDefaultLanguage;    break;
 480         case UPH_IS_SPELL_CAPITALIZATION :  pbVal = &rOpt.bIsSpellCapitalization;      break;
 481         case UPH_IS_SPELL_WITH_DIGITS :     pbVal = &rOpt.bIsSpellWithDigits;  break;
 482         case UPH_IS_SPELL_UPPER_CASE :      pbVal = &rOpt.bIsSpellUpperCase;       break;
 483         case UPH_HYPH_MIN_LEADING :         pnVal = &rOpt.nHyphMinLeading;     break;
 484         case UPH_HYPH_MIN_TRAILING :        pnVal = &rOpt.nHyphMinTrailing;    break;
 485         case UPH_HYPH_MIN_WORD_LENGTH :     pnVal = &rOpt.nHyphMinWordLength;  break;
 486         case UPH_ACTIVE_DICTIONARIES :
 487         {
 488             rValue >>= rOpt.aActiveDics;
 489             bMod = TRUE;
 490             break;
 491         }
 492         case UPH_ACTIVE_CONVERSION_DICTIONARIES :
 493         {
 494             rValue >>= rOpt.aActiveConvDics;
 495             bMod = TRUE;
 496             break;
 497         }
 498         case UPH_DEFAULT_LOCALE :
 499         {
 500             bSucc = lcl_SetLocale( rOpt.nDefaultLanguage, rValue );
 501             bMod = bSucc;
 502             break;
 503         }
 504         case UPH_DEFAULT_LOCALE_CJK :
 505         {
 506             bSucc = lcl_SetLocale( rOpt.nDefaultLanguage_CJK, rValue );
 507             bMod = bSucc;
 508             break;
 509         }
 510         case UPH_DEFAULT_LOCALE_CTL :
 511         {
 512             bSucc = lcl_SetLocale( rOpt.nDefaultLanguage_CTL, rValue );
 513             bMod = bSucc;
 514             break;
 515         }
 516         case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       pbVal = &rOpt.bIsIgnorePostPositionalWord; break;
 517         case UPH_IS_AUTO_CLOSE_DIALOG :                 pbVal = &rOpt.bIsAutoCloseDialog; break;
 518         case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  pbVal = &rOpt.bIsShowEntriesRecentlyUsedFirst; break;
 519         case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       pbVal = &rOpt.bIsAutoReplaceUniqueEntries; break;
 520
 521         case UPH_IS_DIRECTION_TO_SIMPLIFIED :           pbVal = &rOpt.bIsDirectionToSimplified; break;
 522         case UPH_IS_USE_CHARACTER_VARIANTS :            pbVal = &rOpt.bIsUseCharacterVariants; break;
 523         case UPH_IS_TRANSLATE_COMMON_TERMS :            pbVal = &rOpt.bIsTranslateCommonTerms; break;
 524         case UPH_IS_REVERSE_MAPPING :                   pbVal = &rOpt.bIsReverseMapping; break;
 525
 526         case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       pnInt32Val = &rOpt.nDataFilesChangedCheckValue; break;
 527         case UPH_IS_GRAMMAR_AUTO:                       pbVal = &rOpt.bIsGrammarAuto; break;
 528         case UPH_IS_GRAMMAR_INTERACTIVE:                pbVal = &rOpt.bIsGrammarInteractive; break;
 529         default :
 530             DBG_ASSERT( 0, "unexpected property handle" );
 531     }
 532
 533     if (pbVal)
 534     {
 535         BOOL bNew = BOOL();
 536         if (rValue >>= bNew)
 537         {
 538             if (bNew != *pbVal)
 539             {
 540                 *pbVal = bNew;
 541                 bMod = TRUE;
 542             }
 543             bSucc = TRUE;
 544         }
 545     }
 546     else if (pnVal)
 547     {
 548         INT16 nNew = INT16();
 549         if (rValue >>= nNew)
 550         {
 551             if (nNew != *pnVal)
 552             {
 553                 *pnVal = nNew;
 554                 bMod = TRUE;
 555             }
 556             bSucc = TRUE;
 557         }
 558     }
 559     else if (pnInt32Val)
 560     {
 561         INT32 nNew = INT32();
 562         if (rValue >>= nNew)
 563         {
 564             if (nNew != *pnInt32Val)
 565             {
 566                 *pnInt32Val = nNew;
 567                 bMod = TRUE;
 568             }
 569             bSucc = TRUE;
 570         }
 571     }
 572
 573     if (bMod)
 574         SetModified();
 575
 576     return bSucc;
 577 }
 578
 579
 580 BOOL SvtLinguConfigItem::GetOptions( SvtLinguOptions &rOptions ) const
 581 {
 582     osl::MutexGuard aGuard( GetOwnMutex() );
 583
 584     rOptions = aOpt;
 585     return TRUE;
 586 }
 587
 588
 589 BOOL SvtLinguConfigItem::SetOptions( const SvtLinguOptions &rOptions )
 590 {
 591     osl::MutexGuard aGuard( GetOwnMutex() );
 592
 593     aOpt = rOptions;
 594     SetModified();
 595     return TRUE;
 596 }
 597
 598
 599 BOOL SvtLinguConfigItem::LoadOptions( const uno::Sequence< OUString > &rProperyNames )
 600 {
 601     osl::MutexGuard aGuard( GetOwnMutex() );
 602
 603     BOOL bRes = FALSE;
 604
 605     const OUString *pProperyNames = rProperyNames.getConstArray();
 606     INT32 nProps = rProperyNames.getLength();
 607
 608     const uno::Sequence< uno::Any > aValues = GetProperties( rProperyNames );
 609     const uno::Sequence< sal_Bool > aROStates = GetReadOnlyStates( rProperyNames );
 610
 611     if (nProps  &&  aValues.getLength() == nProps &&  aROStates.getLength() == nProps)
 612     {
 613         SvtLinguOptions &rOpt = aOpt;
 614
 615         const uno::Any *pValue = aValues.getConstArray();
 616         const sal_Bool *pROStates = aROStates.getConstArray();
 617         for (INT32 i = 0;  i < nProps;  ++i)
 618         {
 619             const uno::Any &rVal = pValue[i];
 620             INT32 nPropertyHandle;
 621             GetHdlByName( nPropertyHandle, pProperyNames[i], sal_True );
 622             switch ( nPropertyHandle )
 623             {
 624                 case UPH_DEFAULT_LOCALE :
 625                     { rOpt.bRODefaultLanguage = pROStates[i]; rOpt.nDefaultLanguage = lcl_CfgAnyToLanguage( rVal ); } break;
 626                 case UPH_ACTIVE_DICTIONARIES :
 627                     { rOpt.bROActiveDics = pROStates[i]; rVal >>= rOpt.aActiveDics;   } break;
 628                 case UPH_IS_USE_DICTIONARY_LIST :
 629                     { rOpt.bROIsUseDictionaryList = pROStates[i]; rVal >>= rOpt.bIsUseDictionaryList;  } break;
 630                 case UPH_IS_IGNORE_CONTROL_CHARACTERS :
 631                     { rOpt.bROIsIgnoreControlCharacters = pROStates[i]; rVal >>= rOpt.bIsIgnoreControlCharacters;    } break;
 632                 case UPH_DEFAULT_LOCALE_CJK :
 633                     { rOpt.bRODefaultLanguage_CJK = pROStates[i]; rOpt.nDefaultLanguage_CJK = lcl_CfgAnyToLanguage( rVal );    } break;
 634                 case UPH_DEFAULT_LOCALE_CTL :
 635                     { rOpt.bRODefaultLanguage_CTL = pROStates[i]; rOpt.nDefaultLanguage_CTL = lcl_CfgAnyToLanguage( rVal );    } break;
 636
 637                 case UPH_IS_SPELL_UPPER_CASE :
 638                     { rOpt.bROIsSpellUpperCase = pROStates[i]; rVal >>= rOpt.bIsSpellUpperCase; } break;
 639                 case UPH_IS_SPELL_WITH_DIGITS :
 640                     { rOpt.bROIsSpellWithDigits = pROStates[i]; rVal >>= rOpt.bIsSpellWithDigits;    } break;
 641                 case UPH_IS_SPELL_CAPITALIZATION :
 642                     { rOpt.bROIsSpellCapitalization = pROStates[i]; rVal >>= rOpt.bIsSpellCapitalization;    } break;
 643                 case UPH_IS_SPELL_AUTO :
 644                     { rOpt.bROIsSpellAuto = pROStates[i]; rVal >>= rOpt.bIsSpellAuto;  } break;
 645                 case UPH_IS_SPELL_SPECIAL :
 646                     { rOpt.bROIsSpellSpecial = pROStates[i]; rVal >>= rOpt.bIsSpellSpecial;   } break;
 647                 case UPH_IS_WRAP_REVERSE :
 648                     { rOpt.bROIsSpellReverse = pROStates[i]; rVal >>= rOpt.bIsSpellReverse;   } break;
 649
 650                 case UPH_HYPH_MIN_LEADING :
 651                     { rOpt.bROHyphMinLeading = pROStates[i]; rVal >>= rOpt.nHyphMinLeading;   } break;
 652                 case UPH_HYPH_MIN_TRAILING :
 653                     { rOpt.bROHyphMinTrailing = pROStates[i]; rVal >>= rOpt.nHyphMinTrailing;  } break;
 654                 case UPH_HYPH_MIN_WORD_LENGTH :
 655                     { rOpt.bROHyphMinWordLength = pROStates[i]; rVal >>= rOpt.nHyphMinWordLength;    } break;
 656                 case UPH_IS_HYPH_SPECIAL :
 657                     { rOpt.bROIsHyphSpecial = pROStates[i]; rVal >>= rOpt.bIsHyphSpecial;    } break;
 658                 case UPH_IS_HYPH_AUTO :
 659                     { rOpt.bROIsHyphAuto = pROStates[i]; rVal >>= rOpt.bIsHyphAuto;   } break;
 660
 661                 case UPH_ACTIVE_CONVERSION_DICTIONARIES : { rOpt.bROActiveConvDics = pROStates[i]; rVal >>= rOpt.aActiveConvDics;   } break;
 662
 663                 case UPH_IS_IGNORE_POST_POSITIONAL_WORD :
 664                     { rOpt.bROIsIgnorePostPositionalWord = pROStates[i]; rVal >>= rOpt.bIsIgnorePostPositionalWord;  } break;
 665                 case UPH_IS_AUTO_CLOSE_DIALOG :
 666                     { rOpt.bROIsAutoCloseDialog = pROStates[i]; rVal >>= rOpt.bIsAutoCloseDialog;  } break;
 667                 case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :
 668                     { rOpt.bROIsShowEntriesRecentlyUsedFirst = pROStates[i]; rVal >>= rOpt.bIsShowEntriesRecentlyUsedFirst;  } break;
 669                 case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :
 670                     { rOpt.bROIsAutoReplaceUniqueEntries = pROStates[i]; rVal >>= rOpt.bIsAutoReplaceUniqueEntries;  } break;
 671
 672                 case UPH_IS_DIRECTION_TO_SIMPLIFIED :
 673                     { rOpt.bROIsDirectionToSimplified = pROStates[i];
 674                             if( ! (rVal >>= rOpt.bIsDirectionToSimplified) )
 675                             {
 676                                 //default is locale dependent:
 677                                 if(  rOpt.nDefaultLanguage_CJK == LANGUAGE_CHINESE_HONGKONG
 678                                   || rOpt.nDefaultLanguage_CJK == LANGUAGE_CHINESE_MACAU
 679                                   || rOpt.nDefaultLanguage_CJK == LANGUAGE_CHINESE_TRADITIONAL )
 680                                 {
 681                                     rOpt.bIsDirectionToSimplified = FALSE;
 682                                 }
 683                                 else
 684                                 {
 685                                     rOpt.bIsDirectionToSimplified = TRUE;
 686                                 }
 687                             }
 688                     } break;
 689                 case UPH_IS_USE_CHARACTER_VARIANTS :
 690                     { rOpt.bROIsUseCharacterVariants = pROStates[i]; rVal >>= rOpt.bIsUseCharacterVariants;  } break;
 691                 case UPH_IS_TRANSLATE_COMMON_TERMS :
 692                     { rOpt.bROIsTranslateCommonTerms = pROStates[i]; rVal >>= rOpt.bIsTranslateCommonTerms;  } break;
 693                 case UPH_IS_REVERSE_MAPPING :
 694                     { rOpt.bROIsReverseMapping = pROStates[i]; rVal >>= rOpt.bIsReverseMapping;  } break;
 695
 696                 case UPH_DATA_FILES_CHANGED_CHECK_VALUE :
 697                     { rOpt.bRODataFilesChangedCheckValue = pROStates[i]; rVal >>= rOpt.nDataFilesChangedCheckValue;  } break;
 698
 699                 case UPH_IS_GRAMMAR_AUTO:
 700                     { rOpt.bROIsGrammarAuto = pROStates[i]; rVal >>= rOpt.bIsGrammarAuto; }
 701                 break;
 702                 case UPH_IS_GRAMMAR_INTERACTIVE:
 703                     { rOpt.bROIsGrammarInteractive = pROStates[i]; rVal >>= rOpt.bIsGrammarInteractive; }
 704                 break;
 705
 706                 default:
 707                     DBG_ASSERT( 0, "unexpected case" );
 708             }
 709         }
 710
 711         bRes = TRUE;
 712     }
 713     DBG_ASSERT( bRes, "LoadOptions failed" );
 714
 715     return bRes;
 716 }
 717
 718
 719 BOOL SvtLinguConfigItem::SaveOptions( const uno::Sequence< OUString > &rProperyNames )
 720 {
 721     if (!IsModified())
 722         return TRUE;
 723
 724     osl::MutexGuard aGuard( GetOwnMutex() );
 725
 726     BOOL bRet = FALSE;
 727     const uno::Type &rBOOL     = ::getBooleanCppuType();
 728     const uno::Type &rINT16    = ::getCppuType( (INT16 *) NULL );
 729     const uno::Type &rINT32    = ::getCppuType( (INT32 *) NULL );
 730
 731     INT32 nProps = rProperyNames.getLength();
 732     uno::Sequence< uno::Any > aValues( nProps );
 733     uno::Any *pValue = aValues.getArray();
 734
 735     if (nProps  &&  aValues.getLength() == nProps)
 736     {
 737         const SvtLinguOptions &rOpt = aOpt;
 738
 739         OUString aTmp( lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage ) );
 740         *pValue++ = uno::makeAny( aTmp );                               //   0
 741         *pValue++ = uno::makeAny( rOpt.aActiveDics );                   //   1
 742         pValue++->setValue( &rOpt.bIsUseDictionaryList, rBOOL );        //   2
 743         pValue++->setValue( &rOpt.bIsIgnoreControlCharacters, rBOOL );  //   3
 744         aTmp = lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage_CJK );
 745         *pValue++ = uno::makeAny( aTmp );                               //   5
 746         aTmp = lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage_CTL );
 747         *pValue++ = uno::makeAny( aTmp );                               //   6
 748
 749         pValue++->setValue( &rOpt.bIsSpellUpperCase, rBOOL );          //   7
 750         pValue++->setValue( &rOpt.bIsSpellWithDigits, rBOOL );         //   8
 751         pValue++->setValue( &rOpt.bIsSpellCapitalization, rBOOL );     //   9
 752         pValue++->setValue( &rOpt.bIsSpellAuto, rBOOL );               //  10
 753         pValue++->setValue( &rOpt.bIsSpellSpecial, rBOOL );            //  11
 754         pValue++->setValue( &rOpt.bIsSpellReverse, rBOOL );            //  14
 755
 756         pValue++->setValue( &rOpt.nHyphMinLeading, rINT16 );           //  15
 757         pValue++->setValue( &rOpt.nHyphMinTrailing, rINT16 );          //  16
 758         pValue++->setValue( &rOpt.nHyphMinWordLength, rINT16 );        //  17
 759         pValue++->setValue( &rOpt.bIsHyphSpecial, rBOOL );             //  18
 760         pValue++->setValue( &rOpt.bIsHyphAuto, rBOOL );                //  19
 761
 762         *pValue++ = uno::makeAny( rOpt.aActiveConvDics );               //   20
 763
 764         pValue++->setValue( &rOpt.bIsIgnorePostPositionalWord, rBOOL ); //  21
 765         pValue++->setValue( &rOpt.bIsAutoCloseDialog, rBOOL );          //  22
 766         pValue++->setValue( &rOpt.bIsShowEntriesRecentlyUsedFirst, rBOOL ); //  23
 767         pValue++->setValue( &rOpt.bIsAutoReplaceUniqueEntries, rBOOL ); //  24
 768
 769         pValue++->setValue( &rOpt.bIsDirectionToSimplified, rBOOL ); //  25
 770         pValue++->setValue( &rOpt.bIsUseCharacterVariants, rBOOL ); //  26
 771         pValue++->setValue( &rOpt.bIsTranslateCommonTerms, rBOOL ); //  27
 772         pValue++->setValue( &rOpt.bIsReverseMapping, rBOOL ); //  28
 773
 774         pValue++->setValue( &rOpt.nDataFilesChangedCheckValue, rINT32 ); //  29
 775         pValue++->setValue( &rOpt.bIsGrammarAuto, rBOOL ); //  30
 776         pValue++->setValue( &rOpt.bIsGrammarInteractive, rBOOL ); // 31
 777
 778         bRet |= PutProperties( rProperyNames, aValues );
 779     }
 780
 781     if (bRet)
 782         ClearModified();
 783
 784     return bRet;
 785 }
 786
 787 BOOL SvtLinguConfigItem::IsReadOnly( const rtl::OUString &rPropertyName ) const
 788 {
 789     osl::MutexGuard aGuard( GetOwnMutex() );
 790
 791     BOOL bReadOnly = FALSE;
 792     INT32 nHdl;
 793     if (GetHdlByName( nHdl, rPropertyName ))
 794         bReadOnly = IsReadOnly( nHdl );
 795     return bReadOnly;
 796 }
 797
 798 BOOL SvtLinguConfigItem::IsReadOnly( INT32 nPropertyHandle ) const
 799 {
 800     osl::MutexGuard aGuard( GetOwnMutex() );
 801
 802     BOOL bReadOnly = FALSE;
 803
 804     const SvtLinguOptions &rOpt = const_cast< SvtLinguConfigItem * >(this)->aOpt;
 805     switch(nPropertyHandle)
 806     {
 807         case UPH_IS_USE_DICTIONARY_LIST         : bReadOnly = rOpt.bROIsUseDictionaryList      ; break;
 808         case UPH_IS_IGNORE_CONTROL_CHARACTERS   : bReadOnly = rOpt.bROIsIgnoreControlCharacters; break;
 809         case UPH_IS_HYPH_AUTO                   : bReadOnly = rOpt.bROIsHyphAuto               ; break;
 810         case UPH_IS_HYPH_SPECIAL                : bReadOnly = rOpt.bROIsHyphSpecial            ; break;
 811         case UPH_IS_SPELL_AUTO                  : bReadOnly = rOpt.bROIsSpellAuto              ; break;
 812         case UPH_IS_SPELL_SPECIAL               : bReadOnly = rOpt.bROIsSpellSpecial           ; break;
 813         case UPH_IS_WRAP_REVERSE                : bReadOnly = rOpt.bROIsSpellReverse           ; break;
 814         case UPH_DEFAULT_LANGUAGE               : bReadOnly = rOpt.bRODefaultLanguage          ; break;
 815         case UPH_IS_SPELL_CAPITALIZATION        : bReadOnly = rOpt.bROIsSpellCapitalization    ; break;
 816         case UPH_IS_SPELL_WITH_DIGITS           : bReadOnly = rOpt.bROIsSpellWithDigits        ; break;
 817         case UPH_IS_SPELL_UPPER_CASE            : bReadOnly = rOpt.bROIsSpellUpperCase         ; break;
 818         case UPH_HYPH_MIN_LEADING               : bReadOnly = rOpt.bROHyphMinLeading           ; break;
 819         case UPH_HYPH_MIN_TRAILING              : bReadOnly = rOpt.bROHyphMinTrailing          ; break;
 820         case UPH_HYPH_MIN_WORD_LENGTH           : bReadOnly = rOpt.bROHyphMinWordLength        ; break;
 821         case UPH_ACTIVE_DICTIONARIES            : bReadOnly = rOpt.bROActiveDics               ; break;
 822         case UPH_ACTIVE_CONVERSION_DICTIONARIES : bReadOnly = rOpt.bROActiveConvDics           ; break;
 823         case UPH_DEFAULT_LOCALE                 : bReadOnly = rOpt.bRODefaultLanguage          ; break;
 824         case UPH_DEFAULT_LOCALE_CJK             : bReadOnly = rOpt.bRODefaultLanguage_CJK      ; break;
 825         case UPH_DEFAULT_LOCALE_CTL             : bReadOnly = rOpt.bRODefaultLanguage_CTL      ; break;
 826         case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       bReadOnly = rOpt.bROIsIgnorePostPositionalWord; break;
 827         case UPH_IS_AUTO_CLOSE_DIALOG :                 bReadOnly = rOpt.bROIsAutoCloseDialog; break;
 828         case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  bReadOnly = rOpt.bROIsShowEntriesRecentlyUsedFirst; break;
 829         case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       bReadOnly = rOpt.bROIsAutoReplaceUniqueEntries; break;
 830         case UPH_IS_DIRECTION_TO_SIMPLIFIED : bReadOnly = rOpt.bROIsDirectionToSimplified; break;
 831         case UPH_IS_USE_CHARACTER_VARIANTS : bReadOnly = rOpt.bROIsUseCharacterVariants; break;
 832         case UPH_IS_TRANSLATE_COMMON_TERMS : bReadOnly = rOpt.bROIsTranslateCommonTerms; break;
 833         case UPH_IS_REVERSE_MAPPING :        bReadOnly = rOpt.bROIsReverseMapping; break;
 834         case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       bReadOnly = rOpt.bRODataFilesChangedCheckValue; break;
 835         case UPH_IS_GRAMMAR_AUTO:                       bReadOnly = rOpt.bROIsGrammarAuto; break;
 836         case UPH_IS_GRAMMAR_INTERACTIVE:                bReadOnly = rOpt.bROIsGrammarInteractive; break;
 837         default :
 838             DBG_ASSERT( 0, "unexpected property handle" );
 839     }
 840     return bReadOnly;
 841 }
 842
 843 //////////////////////////////////////////////////////////////////////
 844
 845 static SvtLinguConfigItem *pCfgItem = 0;
 846 static sal_Int32           nCfgItemRefCount = 0;
 847
 848 static const rtl::OUString aG_SupportedDictionaryFormats( A2OU("SupportedDictionaryFormats") );
 849 static const rtl::OUString aG_Dictionaries( A2OU("Dictionaries") );
 850 static const rtl::OUString aG_Locations( A2OU("Locations") );
 851 static const rtl::OUString aG_Format( A2OU("Format") );
 852 static const rtl::OUString aG_Locales( A2OU("Locales") );
 853 static const rtl::OUString aG_DisabledDictionaries( A2OU("DisabledDictionaries") );
 854 static const rtl::OUString aG_LastActiveDictionaries( A2OU("LastActiveDictionaries") );
 855
 856 SvtLinguConfig::SvtLinguConfig()
 857 {
 858     // Global access, must be guarded (multithreading)
 859     osl::MutexGuard aGuard( GetOwnMutex() );
 860     ++nCfgItemRefCount;
 861 }
 862
 863
 864 SvtLinguConfig::~SvtLinguConfig()
 865 {
 866     osl::MutexGuard aGuard( GetOwnMutex() );
 867
 868     if (pCfgItem && pCfgItem->IsModified())
 869         pCfgItem->Commit();
 870
 871     if (--nCfgItemRefCount <= 0)
 872     {
 873         if (pCfgItem)
 874             delete pCfgItem;
 875         pCfgItem = 0;
 876     }
 877 }
 878
 879
 880 SvtLinguConfigItem & SvtLinguConfig::GetConfigItem()
 881 {
 882     // Global access, must be guarded (multithreading)
 883     osl::MutexGuard aGuard( GetOwnMutex() );
 884     if (!pCfgItem)
 885     {
 886         pCfgItem = new SvtLinguConfigItem;
 887         ItemHolder1::holdConfigItem(E_LINGUCFG);
 888     }
 889     return *pCfgItem;
 890 }
 891
 892
 893 uno::Sequence< OUString > SvtLinguConfig::GetNodeNames( const OUString &rNode )
 894 {
 895     return GetConfigItem().GetNodeNames( rNode );
 896 }
 897
 898
 899 uno::Sequence< uno::Any > SvtLinguConfig::GetProperties( const uno::Sequence< OUString > &rNames )
 900 {
 901     return GetConfigItem().GetProperties(rNames);
 902 }
 903
 904
 905 sal_Bool SvtLinguConfig::ReplaceSetProperties(
 906         const OUString &rNode, uno::Sequence< beans::PropertyValue > rValues )
 907 {
 908     return GetConfigItem().ReplaceSetProperties( rNode, rValues );
 909 }
 910
 911
 912 uno::Any SvtLinguConfig::GetProperty( const OUString &rPropertyName ) const
 913 {
 914     return GetConfigItem().GetProperty( rPropertyName );
 915 }
 916
 917
 918 uno::Any SvtLinguConfig::GetProperty( INT32 nPropertyHandle ) const
 919 {
 920     return GetConfigItem().GetProperty( nPropertyHandle );
 921 }
 922
 923
 924 BOOL SvtLinguConfig::SetProperty( const OUString &rPropertyName, const uno::Any &rValue )
 925 {
 926     return GetConfigItem().SetProperty( rPropertyName, rValue );
 927 }
 928
 929
 930 BOOL SvtLinguConfig::SetProperty( INT32 nPropertyHandle, const uno::Any &rValue )
 931 {
 932     return GetConfigItem().SetProperty( nPropertyHandle, rValue );
 933 }
 934
 935
 936 BOOL SvtLinguConfig::GetOptions( SvtLinguOptions &rOptions ) const
 937 {
 938     return GetConfigItem().GetOptions( rOptions );
 939 }
 940
 941
 942 BOOL SvtLinguConfig::SetOptions( const SvtLinguOptions &rOptions )
 943 {
 944     return GetConfigItem().SetOptions( rOptions );
 945 }
 946
 947
 948 BOOL SvtLinguConfig::IsReadOnly( const rtl::OUString &rPropertyName ) const
 949 {
 950     return GetConfigItem().IsReadOnly( rPropertyName );
 951 }
 952
 953 BOOL SvtLinguConfig::IsReadOnly( INT32 nPropertyHandle ) const
 954 {
 955     return GetConfigItem().IsReadOnly( nPropertyHandle );
 956 }
 957
 958 BOOL SvtLinguConfig::GetElementNamesFor(
 959      const rtl::OUString &rNodeName,
 960      uno::Sequence< rtl::OUString > &rElementNames ) const
 961 {
 962     bool bSuccess = false;
 963     try
 964     {
 965         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
 966         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
 967         xNA.set( xNA->getByName( rNodeName ), uno::UNO_QUERY_THROW );
 968         rElementNames = xNA->getElementNames();
 969         bSuccess = true;
 970     }
 971     catch (uno::Exception &)
 972     {
 973     }
 974     return bSuccess;
 975 }
 976
 977 static uno::Reference< container::XNameAccess > GetOrCreateSetEntry_Impl(
 978     const uno::Reference< container::XNameAccess > &rxSetNameAccess,
 979     const rtl::OUString &rEntryName )
 980 {
 981     uno::Reference< container::XNameAccess > xResult;
 982     try
 983     {
 984         if (!rxSetNameAccess->hasByName( rEntryName ))
 985         {
 986             uno::Reference< lang::XSingleServiceFactory > xFactory( rxSetNameAccess, uno::UNO_QUERY_THROW);
 987             uno::Reference< uno::XInterface > xNewEntry( xFactory->createInstance() );
 988             uno::Reference< container::XNameContainer > xNC( rxSetNameAccess, uno::UNO_QUERY_THROW );
 989             xNC->insertByName( rEntryName, makeAny( xNewEntry ) );
 990         }
 991         xResult.set( rxSetNameAccess->getByName( rEntryName ), uno::UNO_QUERY_THROW );
 992     }
 993     catch (uno::Exception &)
 994     {
 995     }
 996     return xResult;
 997 }
 998
 999 BOOL SvtLinguConfig::GetSupportedDictionaryFormatsFor(
1000     const rtl::OUString &rSetName,
1001     const rtl::OUString &rSetEntry,
1002     uno::Sequence< rtl::OUString > &rFormatList ) const
1003 {
1004     if (rSetName.getLength() == 0 || rSetEntry.getLength() == 0)
1005         return sal_False;
1006     bool bSuccess = false;
1007     try
1008     {
1009         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1010         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1011         xNA.set( xNA->getByName( rSetName ), uno::UNO_QUERY_THROW );
1012         xNA.set( xNA->getByName( rSetEntry ), uno::UNO_QUERY_THROW );
1013         if (xNA->getByName( aG_SupportedDictionaryFormats ) >>= rFormatList)
1014             bSuccess = true;
1015         DBG_ASSERT( rFormatList.getLength(), "supported dictionary format list is empty" );
1016     }
1017     catch (uno::Exception &)
1018     {
1019     }
1020     return bSuccess;
1021 }
1022
1023 void SvtLinguConfig::SetOrCreateSupportedDictionaryFormatsFor(
1024     const rtl::OUString &rSetName,
1025     const rtl::OUString &rSetEntry,
1026     const uno::Sequence< rtl::OUString > &rFormatList  ) const
1027 {
1028     if (rSetName.getLength() == 0 || rSetEntry.getLength() == 0)
1029         return;
1030     try
1031     {
1032         DBG_ASSERT( rFormatList.getLength(), "applying empty format list. Really??" );
1033
1034         uno::Reference< util::XChangesBatch > xUpdateAccess( GetMainUpdateAccess() );
1035         uno::Reference< container::XNameAccess > xNA( xUpdateAccess, uno::UNO_QUERY_THROW );
1036         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1037         xNA.set( xNA->getByName( rSetName ), uno::UNO_QUERY_THROW );
1038         xNA = GetOrCreateSetEntry_Impl( xNA, rSetEntry );
1039
1040         uno::Reference< container::XNameReplace > xNR( xNA, uno::UNO_QUERY_THROW );
1041         xNR->replaceByName( aG_SupportedDictionaryFormats, uno::makeAny( rFormatList ) );
1042
1043         xUpdateAccess->commitChanges();
1044     }
1045     catch (uno::Exception &)
1046     {
1047     }
1048 }
1049
1050
1051 static uno::WeakReference< util::XMacroExpander > aG_xMacroExpander;
1052
1053 static uno::Reference< util::XMacroExpander > lcl_GetMacroExpander()
1054 {
1055     uno::Reference< util::XMacroExpander > xMacroExpander( aG_xMacroExpander );
1056     if ( !xMacroExpander.is() )
1057     {
1058         vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
1059
1060         if ( !xMacroExpander.is() )
1061         {
1062             uno::Reference< uno::XComponentContext > xContext;
1063             uno::Reference< beans::XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY );
1064             xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xContext;
1065             if ( xContext.is() )
1066             {
1067                 aG_xMacroExpander =  uno::Reference< com::sun::star::util::XMacroExpander >( xContext->getValueByName(
1068                                         OUString( RTL_CONSTASCII_USTRINGPARAM( "/singletons/com.sun.star.util.theMacroExpander"))),
1069                                         uno::UNO_QUERY );
1070                 xMacroExpander = aG_xMacroExpander;
1071             }
1072         }
1073     }
1074
1075     return xMacroExpander;
1076 }
1077
1078
1079 static bool lcl_GetFileUrlFromOrigin(
1080     OUString /*out*/ &rFileUrl,
1081     const OUString &rOrigin,
1082     uno::Reference< util::XMacroExpander > &rxMacroExpander )
1083 {
1084     bool bSuccess = false;
1085     if (rOrigin.getLength() > 0 && rxMacroExpander.is())
1086     {
1087         rtl::OUString aURL( rOrigin );
1088         if (( aURL.compareToAscii( RTL_CONSTASCII_STRINGPARAM( EXPAND_PROTOCOL )) == 0 ) &&
1089             rxMacroExpander.is() )
1090         {
1091             // cut protocol
1092             OUString aMacro( aURL.copy( sizeof ( EXPAND_PROTOCOL ) -1 ) );
1093             // decode uric class chars
1094             aMacro = Uri::decode( aMacro, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
1095             // expand macro string
1096             aURL = rxMacroExpander->expandMacros( aMacro );
1097
1098             bool bIsFileUrl = aURL.compareToAscii( RTL_CONSTASCII_STRINGPARAM( FILE_PROTOCOL )) == 0;
1099             if (bIsFileUrl)
1100             {
1101                 rFileUrl = aURL;
1102                 bSuccess = true;
1103             }
1104             else
1105             {
1106                 DBG_ASSERT( bIsFileUrl, "not a file URL");
1107             }
1108         }
1109         else
1110         {
1111             DBG_ASSERT( 0, "failed to get file URL" );
1112         }
1113     }
1114     return bSuccess;
1115 }
1116
1117
1118 BOOL SvtLinguConfig::GetDictionaryEntry(
1119     const rtl::OUString &rNodeName,
1120     SvtLinguConfigDictionaryEntry &rDicEntry ) const
1121 {
1122     if (rNodeName.getLength() == 0)
1123         return sal_False;
1124     bool bSuccess = false;
1125     try
1126     {
1127         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1128         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1129         xNA.set( xNA->getByName( aG_Dictionaries ), uno::UNO_QUERY_THROW );
1130         xNA.set( xNA->getByName( rNodeName ), uno::UNO_QUERY_THROW );
1131
1132         // read group data...
1133         uno::Sequence< rtl::OUString >  aLocations;
1134         rtl::OUString                                   aFormatName;
1135         uno::Sequence< rtl::OUString >  aLocaleNames;
1136         bSuccess =  (xNA->getByName( aG_Locations ) >>= aLocations)  &&
1137                     (xNA->getByName( aG_Format )    >>= aFormatName) &&
1138                     (xNA->getByName( aG_Locales )   >>= aLocaleNames);
1139         DBG_ASSERT( aLocations.getLength(), "Dictionary locations not set" );
1140         DBG_ASSERT( aFormatName.getLength(), "Dictionary format name not set" );
1141         DBG_ASSERT( aLocaleNames.getLength(), "No locales set for the dictionary" );
1142
1143         // if sucessful continue
1144         if (bSuccess)
1145         {
1146             // get file URL's for the locations
1147             uno::Reference< util::XMacroExpander > xMacroExpander( lcl_GetMacroExpander() );
1148             for (sal_Int32 i = 0;  i < aLocations.getLength();  ++i)
1149             {
1150                 rtl::OUString &rLocation = aLocations[i];
1151                 if (!lcl_GetFileUrlFromOrigin( rLocation, rLocation, xMacroExpander ))
1152                     bSuccess = false;
1153             }
1154
1155             // if everything was fine return the result
1156             if (bSuccess)
1157             {
1158                 rDicEntry.aLocations    = aLocations;
1159                 rDicEntry.aFormatName   = aFormatName;
1160                 rDicEntry.aLocaleNames  = aLocaleNames;
1161             }
1162         }
1163     }
1164     catch (uno::Exception &)
1165     {
1166     }
1167     return bSuccess;
1168 }
1169
1170 void SvtLinguConfig::SetOrCreateDictionaryEntry(
1171     const rtl::OUString &rNodeName,
1172     const SvtLinguConfigDictionaryEntry &rDicEntry ) const
1173 {
1174     if (rNodeName.getLength() == 0)
1175         return;
1176     try
1177     {
1178         uno::Reference< util::XChangesBatch > xUpdateAccess( GetMainUpdateAccess() );
1179         uno::Reference< container::XNameAccess > xNA( xUpdateAccess, uno::UNO_QUERY_THROW );
1180         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1181         xNA.set( xNA->getByName( aG_Dictionaries ), uno::UNO_QUERY_THROW );
1182         xNA = GetOrCreateSetEntry_Impl( xNA, rNodeName );
1183
1184         DBG_ASSERT( rDicEntry.aLocations.getLength(), "Applying empty dictionary locations. Really correct??" );
1185         DBG_ASSERT( rDicEntry.aFormatName.getLength(), "Applying empty dictionary format name. Really correct??" );
1186         DBG_ASSERT( rDicEntry.aLocaleNames.getLength(), "Applying empty list of locales for the dictionary. Really correct??" );
1187
1188         uno::Reference< container::XNameReplace > xNR( xNA, uno::UNO_QUERY_THROW );
1189         xNR->replaceByName( aG_Locations, uno::makeAny( rDicEntry.aLocations ) );
1190         xNR->replaceByName( aG_Format,    uno::makeAny( rDicEntry.aFormatName ) );
1191         xNR->replaceByName( aG_Locales,   uno::makeAny( rDicEntry.aLocaleNames ) );
1192
1193         xUpdateAccess->commitChanges();
1194     }
1195     catch (uno::Exception &)
1196     {
1197     }
1198 }
1199
1200 uno::Sequence< rtl::OUString > SvtLinguConfig::GetDisabledDictionaries() const
1201 {
1202     uno::Sequence< rtl::OUString > aResult;
1203     try
1204     {
1205         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1206         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1207         xNA->getByName( aG_DisabledDictionaries ) >>= aResult;
1208     }
1209     catch (uno::Exception &)
1210     {
1211     }
1212     return aResult;
1213 }
1214
1215 void SvtLinguConfig::SetDisabledDictionaries(
1216     const uno::Sequence< rtl::OUString > &rDictionaries ) const
1217 {
1218     try
1219     {
1220         uno::Reference< util::XChangesBatch > xUpdateAccess( GetMainUpdateAccess() );
1221         uno::Reference< container::XNameAccess > xNA( xUpdateAccess, uno::UNO_QUERY_THROW );
1222         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1223         if (xNA->hasByName( aG_DisabledDictionaries ))
1224         {
1225             uno::Reference< container::XNameReplace > xNR( xNA, uno::UNO_QUERY_THROW );
1226             xNR->replaceByName( aG_DisabledDictionaries, makeAny( rDictionaries ) );
1227         }
1228         else
1229         {
1230             uno::Reference< container::XNameContainer > xNC( xNA, uno::UNO_QUERY_THROW );
1231             xNC->insertByName( aG_DisabledDictionaries, makeAny( rDictionaries ) );
1232         }
1233
1234         xUpdateAccess->commitChanges();
1235     }
1236     catch (uno::Exception &)
1237     {
1238     }
1239 }
1240
1241 std::vector< SvtLinguConfigDictionaryEntry > SvtLinguConfig::GetActiveDictionariesByFormat(
1242     const rtl::OUString &rFormatName )
1243 {
1244     std::vector< SvtLinguConfigDictionaryEntry > aRes;
1245     if (rFormatName.getLength() == 0)
1246         return aRes;
1247
1248     try
1249     {
1250         uno::Sequence< rtl::OUString > aElementNames;
1251         GetElementNamesFor( aG_Dictionaries, aElementNames );
1252         sal_Int32 nLen = aElementNames.getLength();
1253         const rtl::OUString *pElementNames = aElementNames.getConstArray();
1254
1255         SvtLinguConfigDictionaryEntry aDicEntry;
1256         for (sal_Int32 i = 0;  i < nLen;  ++i)
1257         {
1258             // does dictionary match the format we are looking for?
1259             if (GetDictionaryEntry( pElementNames[i], aDicEntry ) &&
1260                 aDicEntry.aFormatName == rFormatName)
1261             {
1262                 // check if it is active or not
1263                 bool bDicIsActive = true;
1264                 const uno::Sequence< rtl::OUString > aDisabledDics( GetDisabledDictionaries() );
1265                 for (sal_Int32 k = 0;  bDicIsActive && k < aDisabledDics.getLength();  ++k)
1266                 {
1267                     if (aDisabledDics[k] == pElementNames[i])
1268                         bDicIsActive = false;
1269                 }
1270
1271                 if (bDicIsActive)
1272                 {
1273                     DBG_ASSERT( aDicEntry.aFormatName.getLength(),
1274                             "FormatName not set" );
1275                     DBG_ASSERT( aDicEntry.aLocations.getLength(),
1276                             "Locations not set" );
1277                     DBG_ASSERT( aDicEntry.aLocaleNames.getLength(),
1278                             "Locales not set" );
1279                     aRes.push_back( aDicEntry );
1280                 }
1281             }
1282         }
1283     }
1284     catch (uno::Exception &)
1285     {
1286     }
1287
1288     return aRes;
1289 }
1290
1291
1292 uno::Reference< util::XChangesBatch > SvtLinguConfig::GetMainUpdateAccess() const
1293 {
1294     if (!m_xMainUpdateAccess.is())
1295     {
1296         try
1297         {
1298             // get configuration provider
1299             uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider;
1300             uno::Reference< lang::XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory();
1301             if (xMgr.is())
1302             {
1303                 xConfigurationProvider = uno::Reference< lang::XMultiServiceFactory > (
1304                         xMgr->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM(
1305                             "com.sun.star.configuration.ConfigurationProvider" ) ) ),
1306                         uno::UNO_QUERY_THROW ) ;
1307             }
1308
1309             // get configuration update access
1310             beans::PropertyValue aValue;
1311             aValue.Name  = A2OU( "nodepath" );
1312             aValue.Value = uno::makeAny( A2OU("org.openoffice.Office.Linguistic") );
1313             uno::Sequence< uno::Any > aProps(1);
1314             aProps[0] <<= aValue;
1315             m_xMainUpdateAccess = uno::Reference< util::XChangesBatch >(
1316                     xConfigurationProvider->createInstanceWithArguments(
1317                         A2OU( "com.sun.star.configuration.ConfigurationUpdateAccess" ), aProps ),
1318                         uno::UNO_QUERY_THROW );
1319         }
1320         catch (uno::Exception &)
1321         {
1322         }
1323     }
1324
1325     return m_xMainUpdateAccess;
1326 }
1327
1328
1329 rtl::OUString SvtLinguConfig::GetVendorImageUrl_Impl(
1330     const rtl::OUString &rServiceImplName,
1331     const rtl::OUString &rImageName ) const
1332 {
1333     rtl::OUString aRes;
1334     try
1335     {
1336         uno::Reference< container::XNameAccess > xImagesNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1337         xImagesNA.set( xImagesNA->getByName( A2OU("Images") ), uno::UNO_QUERY_THROW );
1338
1339         uno::Reference< container::XNameAccess > xNA( xImagesNA->getByName( A2OU("ServiceNameEntries") ), uno::UNO_QUERY_THROW );
1340         xNA.set( xNA->getByName( rServiceImplName ), uno::UNO_QUERY_THROW );
1341         uno::Any aAny( xNA->getByName( A2OU("VendorImagesNode") ) );
1342         rtl::OUString aVendorImagesNode;
1343         if (aAny >>= aVendorImagesNode)
1344         {
1345             xNA = xImagesNA;
1346             xNA.set( xNA->getByName( A2OU("VendorImages") ), uno::UNO_QUERY_THROW );
1347             xNA.set( xNA->getByName( aVendorImagesNode ), uno::UNO_QUERY_THROW );
1348             aAny = xNA->getByName( rImageName );
1349             rtl::OUString aTmp;
1350             if (aAny >>= aTmp)
1351             {
1352                 uno::Reference< util::XMacroExpander > xMacroExpander( lcl_GetMacroExpander() );
1353                 if (lcl_GetFileUrlFromOrigin( aTmp, aTmp, xMacroExpander ))
1354                     aRes = aTmp;
1355             }
1356         }
1357     }
1358     catch (uno::Exception &)
1359     {
1360         DBG_ASSERT( 0, "exception caught. GetVendorImageUrl_Impl failed" );
1361     }
1362     return aRes;
1363 }
1364
1365
1366 rtl::OUString SvtLinguConfig::GetSpellAndGrammarDialogImage(
1367     const rtl::OUString &rServiceImplName,
1368     bool bHighContrast ) const
1369 {
1370     rtl::OUString   aRes;
1371     if (rServiceImplName.getLength() > 0)
1372     {
1373         rtl::OUString aImageName( A2OU( bHighContrast ? "SpellAndGrammarDialogImage_HC" : "SpellAndGrammarDialogImage" ));
1374         rtl::OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, aImageName ) );
1375         aRes = aPath;
1376     }
1377     return aRes;
1378 }
1379
1380
1381 rtl::OUString SvtLinguConfig::GetSpellAndGrammarContextSuggestionImage(
1382     const rtl::OUString &rServiceImplName,
1383     bool bHighContrast ) const
1384 {
1385     rtl::OUString   aRes;
1386     if (rServiceImplName.getLength() > 0)
1387     {
1388         rtl::OUString aImageName( A2OU( bHighContrast ? "SpellAndGrammarContextMenuSuggestionImage_HC" : "SpellAndGrammarContextMenuSuggestionImage" ));
1389         rtl::OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, aImageName ) );
1390         aRes = aPath;
1391     }
1392     return aRes;
1393 }
1394
1395
1396 rtl::OUString SvtLinguConfig::GetSpellAndGrammarContextDictionaryImage(
1397     const rtl::OUString &rServiceImplName,
1398     bool bHighContrast ) const
1399 {
1400     rtl::OUString   aRes;
1401     if (rServiceImplName.getLength() > 0)
1402     {
1403         rtl::OUString aImageName( A2OU( bHighContrast ? "SpellAndGrammarContextMenuDictionaryImage_HC" : "SpellAndGrammarContextMenuDictionaryImage" ));
1404         rtl::OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, aImageName ) );
1405         aRes = aPath;
1406     }
1407     return aRes;
1408 }
1409
1410
1411 bool SvtLinguConfig::HasAnyVendorImages() const
1412 {
1413     bool bRes = false;
1414     try
1415     {
1416         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1417         xNA.set( xNA->getByName( A2OU("Images") ), uno::UNO_QUERY_THROW );
1418         xNA.set( xNA->getByName( A2OU("VendorImages") ), uno::UNO_QUERY_THROW );
1419
1420         uno::Sequence< rtl::OUString > aElementNames( xNA->getElementNames() );
1421         bRes = aElementNames.getLength() > 0;
1422     }
1423     catch (uno::Exception &)
1424     {
1425         DBG_ASSERT( 0, "exception caught. HasAnyVendorImages failed" );
1426     }
1427     return bRes;
1428 }
1429
1430
1431 bool SvtLinguConfig::HasGrammarChecker() const
1432 {
1433     bool bRes = false;
1434
1435     try
1436     {
1437         uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
1438         xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
1439         xNA.set( xNA->getByName( A2OU("GrammarCheckerList") ), uno::UNO_QUERY_THROW );
1440
1441         uno::Sequence< rtl::OUString > aElementNames( xNA->getElementNames() );
1442         bRes = aElementNames.getLength() > 0;
1443     }
1444     catch (uno::Exception &)
1445     {
1446     }
1447
1448     return bRes;
1449 }
1450
1451 //////////////////////////////////////////////////////////////////////
1452