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