cbosdo02: merging changesets up to DEV300_m69

1 files changed, 1453 insertions, 0 deletions

diff --git a/unotools/source/config/lingucfg.cxx b/unotools/source/config/lingucfg.cxx
new file mode 100644
index 000000000000..d4eff83efec6
--- /dev/null
+++ b/unotools/source/config/lingucfg.cxx
@@ -0,0 +1,1453 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: lingucfg.cxx,v $
+ * $Revision: 1.14 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_unotools.hxx"
+
+
+#include <com/sun/star/lang/Locale.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/container/XNameReplace.hpp>
+#include "com/sun/star/util/XMacroExpander.hpp"
+#include "com/sun/star/beans/XPropertySet.hpp"
+#include <rtl/uri.hxx>
+#include <vos/mutex.hxx>
+#include <i18npool/mslangid.hxx>
+#include <tools/debug.hxx>
+#include <tools/string.hxx>
+#include <unotools/lingucfg.hxx>
+#include <unotools/linguprops.hxx>
+
+#include <comphelper/processfactory.hxx>
+
+#include <itemholder1.hxx>
+
+using namespace rtl;
+using namespace com::sun::star;
+
+#define A2OU(x)        ::rtl::OUString::createFromAscii( x )
+#define EXPAND_PROTOCOL     "vnd.sun.star.expand:"
+#define FILE_PROTOCOL       "file:///"
+
+///////////////////////////////////////////////////////////////////////////
+
+
+static osl::Mutex &  GetOwnMutex()
+{
+    static osl::Mutex aMutex;
+    return aMutex;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+
+
+static BOOL lcl_SetLocale( INT16 &rLanguage, const uno::Any &rVal )
+{
+    BOOL bSucc = FALSE;
+
+    lang::Locale aNew;
+    if (rVal >>= aNew)  // conversion successful?
+    {
+        INT16 nNew = MsLangId::convertLocaleToLanguage( aNew );
+        if (nNew != rLanguage)
+        {
+            rLanguage = nNew;
+            bSucc = TRUE;
+        }
+    }
+    return bSucc;
+}
+
+
+static inline const OUString lcl_LanguageToCfgLocaleStr( INT16 nLanguage )
+{
+    OUString aRes;
+    if (LANGUAGE_SYSTEM != nLanguage)
+        aRes = MsLangId::convertLanguageToIsoString( nLanguage );
+    return aRes;
+}
+
+
+static INT16 lcl_CfgAnyToLanguage( const uno::Any &rVal )
+{
+    OUString aTmp;
+    rVal >>= aTmp;
+    return (aTmp.getLength() == 0) ? LANGUAGE_SYSTEM : MsLangId::convertIsoStringToLanguage( aTmp );
+}
+
+
+//////////////////////////////////////////////////////////////////////
+
+SvtLinguOptions::SvtLinguOptions()
+{
+    nDefaultLanguage = LANGUAGE_NONE;
+    nDefaultLanguage_CJK = LANGUAGE_NONE;
+    nDefaultLanguage_CTL = LANGUAGE_NONE;
+
+    // general options
+    bIsUseDictionaryList    =
+    bIsIgnoreControlCharacters  = TRUE;
+
+    // spelling options
+    bIsSpellCapitalization  =
+    bIsSpellSpecial         = TRUE;
+    bIsSpellAuto            =
+    bIsSpellReverse         =
+    bIsSpellWithDigits      =
+    bIsSpellUpperCase       = FALSE;
+
+    // text conversion options
+    bIsIgnorePostPositionalWord     = TRUE;
+    bIsAutoCloseDialog              =
+    bIsShowEntriesRecentlyUsedFirst =
+    bIsAutoReplaceUniqueEntries     = FALSE;
+    bIsDirectionToSimplified        = TRUE;
+    bIsUseCharacterVariants         =
+    bIsTranslateCommonTerms         =
+    bIsReverseMapping               = FALSE;
+
+    bROIsDirectionToSimplified      =
+    bROIsUseCharacterVariants       =
+    bROIsTranslateCommonTerms       =
+    bROIsReverseMapping             = FALSE;
+
+    // hyphenation options
+    bIsHyphSpecial          = TRUE;
+    bIsHyphAuto             = FALSE;
+    nHyphMinLeading         =
+    nHyphMinTrailing        = 2;
+    nHyphMinWordLength      = 0;
+
+    nDataFilesChangedCheckValue = 0;
+
+    //grammar options
+    bIsGrammarAuto = sal_False,
+    bIsGrammarInteractive = sal_False;
+
+}
+
+
+//////////////////////////////////////////////////////////////////////
+
+
+class SvtLinguConfigItem : public utl::ConfigItem
+{
+    SvtLinguOptions     aOpt;
+
+    // disallow copy-constructor and assignment-operator for now
+    SvtLinguConfigItem( const SvtLinguConfigItem & );
+    SvtLinguConfigItem & operator = ( const SvtLinguConfigItem & );
+
+    static BOOL GetHdlByName( INT32 &rnHdl, const OUString &rPropertyName, sal_Bool bFullPropName = sal_False );
+    static const uno::Sequence< OUString > & GetPropertyNames();
+    BOOL                LoadOptions( const uno::Sequence< OUString > &rProperyNames );
+    BOOL                SaveOptions( const uno::Sequence< OUString > &rProperyNames );
+
+public:
+    SvtLinguConfigItem();
+    virtual ~SvtLinguConfigItem();
+
+    // utl::ConfigItem
+    virtual void    Notify( const com::sun::star::uno::Sequence< rtl::OUString > &rPropertyNames );
+    virtual void    Commit();
+
+    // make some protected functions of utl::ConfigItem public
+    using utl::ConfigItem::GetNodeNames;
+    using utl::ConfigItem::GetProperties;
+    //using utl::ConfigItem::PutProperties;
+    //using utl::ConfigItem::SetSetProperties;
+    using utl::ConfigItem::ReplaceSetProperties;
+    //using utl::ConfigItem::GetReadOnlyStates;
+
+
+    com::sun::star::uno::Any
+            GetProperty( const rtl::OUString &rPropertyName ) const;
+    com::sun::star::uno::Any
+            GetProperty( INT32 nPropertyHandle ) const;
+
+    BOOL    SetProperty( const rtl::OUString &rPropertyName,
+                         const com::sun::star::uno::Any &rValue );
+    BOOL    SetProperty( INT32 nPropertyHandle,
+                         const com::sun::star::uno::Any &rValue );
+
+    BOOL    GetOptions( SvtLinguOptions &rOptions ) const;
+    BOOL    SetOptions( const SvtLinguOptions &rOptions );
+
+    BOOL    IsReadOnly( const rtl::OUString &rPropertyName ) const;
+    BOOL    IsReadOnly( INT32 nPropertyHandle ) const;
+};
+
+
+SvtLinguConfigItem::SvtLinguConfigItem() :
+    utl::ConfigItem( String::CreateFromAscii( "Office.Linguistic" ) )
+{
+    LoadOptions( GetPropertyNames() );
+    ClearModified();
+
+    // request notify events when properties change
+    EnableNotification( GetPropertyNames() );
+}
+
+
+SvtLinguConfigItem::~SvtLinguConfigItem()
+{
+    //! Commit (SaveOptions) will be called by the d-tor of the base called !
+}
+
+
+void SvtLinguConfigItem::Notify( const uno::Sequence< OUString > &rPropertyNames )
+{
+    LoadOptions( rPropertyNames );
+    NotifyListeners(0);
+}
+
+
+void SvtLinguConfigItem::Commit()
+{
+    SaveOptions( GetPropertyNames() );
+}
+
+
+static struct NamesToHdl
+{
+    const char   *pFullPropName;      // full qualified name as used in configuration
+    const char   *pPropName;          // property name only (atom) of above
+    INT32   nHdl;               // numeric handle representing the property
+}aNamesToHdl[] =
+{
+{/*  0 */    "General/DefaultLocale",                         UPN_DEFAULT_LOCALE,                    UPH_DEFAULT_LOCALE},
+{/*  1 */    "General/DictionaryList/ActiveDictionaries",     UPN_ACTIVE_DICTIONARIES,               UPH_ACTIVE_DICTIONARIES},
+{/*  2 */    "General/DictionaryList/IsUseDictionaryList",    UPN_IS_USE_DICTIONARY_LIST,            UPH_IS_USE_DICTIONARY_LIST},
+{/*  3 */    "General/IsIgnoreControlCharacters",             UPN_IS_IGNORE_CONTROL_CHARACTERS,      UPH_IS_IGNORE_CONTROL_CHARACTERS},
+{/*  5 */    "General/DefaultLocale_CJK",                     UPN_DEFAULT_LOCALE_CJK,                UPH_DEFAULT_LOCALE_CJK},
+{/*  6 */    "General/DefaultLocale_CTL",                     UPN_DEFAULT_LOCALE_CTL,                UPH_DEFAULT_LOCALE_CTL},
+
+{/*  7 */    "SpellChecking/IsSpellUpperCase",                UPN_IS_SPELL_UPPER_CASE,               UPH_IS_SPELL_UPPER_CASE},
+{/*  8 */    "SpellChecking/IsSpellWithDigits",               UPN_IS_SPELL_WITH_DIGITS,              UPH_IS_SPELL_WITH_DIGITS},
+{/*  9 */    "SpellChecking/IsSpellCapitalization",           UPN_IS_SPELL_CAPITALIZATION,           UPH_IS_SPELL_CAPITALIZATION},
+{/* 10 */    "SpellChecking/IsSpellAuto",                     UPN_IS_SPELL_AUTO,                     UPH_IS_SPELL_AUTO},
+{/* 11 */    "SpellChecking/IsSpellSpecial",                  UPN_IS_SPELL_SPECIAL,                  UPH_IS_SPELL_SPECIAL},
+{/* 14 */    "SpellChecking/IsReverseDirection",              UPN_IS_WRAP_REVERSE,                   UPH_IS_WRAP_REVERSE},
+
+{/* 15 */    "Hyphenation/MinLeading",                        UPN_HYPH_MIN_LEADING,                  UPH_HYPH_MIN_LEADING},
+{/* 16 */    "Hyphenation/MinTrailing",                       UPN_HYPH_MIN_TRAILING,                 UPH_HYPH_MIN_TRAILING},
+{/* 17 */    "Hyphenation/MinWordLength",                     UPN_HYPH_MIN_WORD_LENGTH,              UPH_HYPH_MIN_WORD_LENGTH},
+{/* 18 */    "Hyphenation/IsHyphSpecial",                     UPN_IS_HYPH_SPECIAL,                   UPH_IS_HYPH_SPECIAL},
+{/* 19 */    "Hyphenation/IsHyphAuto",                        UPN_IS_HYPH_AUTO,                      UPH_IS_HYPH_AUTO},
+
+{/* 20 */    "TextConversion/ActiveConversionDictionaries",   UPN_ACTIVE_CONVERSION_DICTIONARIES,        UPH_ACTIVE_CONVERSION_DICTIONARIES},
+{/* 21 */    "TextConversion/IsIgnorePostPositionalWord",     UPN_IS_IGNORE_POST_POSITIONAL_WORD,        UPH_IS_IGNORE_POST_POSITIONAL_WORD},
+{/* 22 */    "TextConversion/IsAutoCloseDialog",              UPN_IS_AUTO_CLOSE_DIALOG,                  UPH_IS_AUTO_CLOSE_DIALOG},
+{/* 23 */    "TextConversion/IsShowEntriesRecentlyUsedFirst", UPN_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST,   UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST},
+{/* 24 */    "TextConversion/IsAutoReplaceUniqueEntries",     UPN_IS_AUTO_REPLACE_UNIQUE_ENTRIES,        UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES},
+{/* 25 */    "TextConversion/IsDirectionToSimplified",        UPN_IS_DIRECTION_TO_SIMPLIFIED,            UPH_IS_DIRECTION_TO_SIMPLIFIED},
+{/* 26 */    "TextConversion/IsUseCharacterVariants",         UPN_IS_USE_CHARACTER_VARIANTS,             UPH_IS_USE_CHARACTER_VARIANTS},
+{/* 27 */    "TextConversion/IsTranslateCommonTerms",         UPN_IS_TRANSLATE_COMMON_TERMS,             UPH_IS_TRANSLATE_COMMON_TERMS},
+{/* 28 */    "TextConversion/IsReverseMapping",               UPN_IS_REVERSE_MAPPING,                    UPH_IS_REVERSE_MAPPING},
+
+{/* 29 */    "ServiceManager/DataFilesChangedCheckValue",     UPN_DATA_FILES_CHANGED_CHECK_VALUE,        UPH_DATA_FILES_CHANGED_CHECK_VALUE},
+
+{/* 30 */    "GrammarChecking/IsAutoCheck",                   UPN_IS_GRAMMAR_AUTO,                      UPH_IS_GRAMMAR_AUTO},
+{/* 31 */    "GrammarChecking/IsInteractiveCheck",            UPN_IS_GRAMMAR_INTERACTIVE,               UPH_IS_GRAMMAR_INTERACTIVE},
+
+            /* similar to entry 0 (thus no own configuration entry) but with different property name and type */
+{            NULL,                                           UPN_DEFAULT_LANGUAGE,                      UPH_DEFAULT_LANGUAGE},
+
+{            NULL,                                            NULL,                                      -1}
+};
+
+
+const uno::Sequence< OUString > & SvtLinguConfigItem::GetPropertyNames()
+{
+    static uno::Sequence< OUString > aNames;
+    static sal_Bool bInitialized = sal_False;
+
+    if (!bInitialized)
+    {
+        INT32 nMax = sizeof(aNamesToHdl) / sizeof(aNamesToHdl[0]);
+
+        aNames.realloc( nMax );
+        OUString *pNames = aNames.getArray();
+        INT32 nIdx = 0;
+        for (INT32 i = 0; i < nMax;  ++i)
+        {
+            const sal_Char *pFullPropName = aNamesToHdl[i].pFullPropName;
+            if (pFullPropName)
+                pNames[ nIdx++ ] = A2OU( pFullPropName );
+        }
+        aNames.realloc( nIdx );
+        bInitialized = sal_True;
+    }
+    return aNames;
+}
+
+
+BOOL SvtLinguConfigItem::GetHdlByName(
+    INT32 &rnHdl,
+    const OUString &rPropertyName,
+    sal_Bool bFullPropName )
+{
+    NamesToHdl *pEntry = &aNamesToHdl[0];
+
+    if (bFullPropName)
+    {
+        while (pEntry && pEntry->pFullPropName != NULL)
+        {
+            if (0 == rPropertyName.compareToAscii( pEntry->pFullPropName ))
+            {
+                rnHdl = pEntry->nHdl;
+                break;
+            }
+            ++pEntry;
+        }
+        return pEntry && pEntry->pFullPropName != NULL;
+    }
+    else
+    {
+        while (pEntry && pEntry->pPropName != NULL)
+        {
+            if (0 == rPropertyName.compareToAscii( pEntry->pPropName ))
+            {
+                rnHdl = pEntry->nHdl;
+                break;
+            }
+            ++pEntry;
+        }
+        return pEntry && pEntry->pPropName != NULL;
+    }
+}
+
+
+uno::Any SvtLinguConfigItem::GetProperty( const OUString &rPropertyName ) const
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    INT32 nHdl;
+    return GetHdlByName( nHdl, rPropertyName ) ? GetProperty( nHdl ) : uno::Any();
+}
+
+
+uno::Any SvtLinguConfigItem::GetProperty( INT32 nPropertyHandle ) const
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    uno::Any aRes;
+
+    const INT16 *pnVal = 0;
+    const BOOL  *pbVal = 0;
+    const INT32 *pnInt32Val = 0;
+
+    const SvtLinguOptions &rOpt = const_cast< SvtLinguConfigItem * >(this)->aOpt;
+    switch (nPropertyHandle)
+    {
+        case UPH_IS_USE_DICTIONARY_LIST :   pbVal = &rOpt.bIsUseDictionaryList; break;
+        case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &rOpt.bIsIgnoreControlCharacters;   break;
+        case UPH_IS_HYPH_AUTO :             pbVal = &rOpt.bIsHyphAuto;  break;
+        case UPH_IS_HYPH_SPECIAL :          pbVal = &rOpt.bIsHyphSpecial;   break;
+        case UPH_IS_SPELL_AUTO :            pbVal = &rOpt.bIsSpellAuto; break;
+        case UPH_IS_SPELL_SPECIAL :         pbVal = &rOpt.bIsSpellSpecial;  break;
+        case UPH_IS_WRAP_REVERSE :          pbVal = &rOpt.bIsSpellReverse;  break;
+        case UPH_DEFAULT_LANGUAGE :         pnVal = &rOpt.nDefaultLanguage; break;
+        case UPH_IS_SPELL_CAPITALIZATION :  pbVal = &rOpt.bIsSpellCapitalization;       break;
+        case UPH_IS_SPELL_WITH_DIGITS :     pbVal = &rOpt.bIsSpellWithDigits;   break;
+        case UPH_IS_SPELL_UPPER_CASE :      pbVal = &rOpt.bIsSpellUpperCase;        break;
+        case UPH_HYPH_MIN_LEADING :         pnVal = &rOpt.nHyphMinLeading;      break;
+        case UPH_HYPH_MIN_TRAILING :        pnVal = &rOpt.nHyphMinTrailing; break;
+        case UPH_HYPH_MIN_WORD_LENGTH :     pnVal = &rOpt.nHyphMinWordLength;   break;
+        case UPH_ACTIVE_DICTIONARIES :
+        {
+            aRes <<= rOpt.aActiveDics;
+            break;
+        }
+        case UPH_ACTIVE_CONVERSION_DICTIONARIES :
+        {
+            aRes <<= rOpt.aActiveConvDics;
+            break;
+        }
+        case UPH_DEFAULT_LOCALE :
+        {
+            lang::Locale aLocale( MsLangId::convertLanguageToLocale( rOpt.nDefaultLanguage, false ) );
+            aRes.setValue( &aLocale, ::getCppuType((lang::Locale*)0 ));
+            break;
+        }
+        case UPH_DEFAULT_LOCALE_CJK :
+        {
+            lang::Locale aLocale( MsLangId::convertLanguageToLocale( rOpt.nDefaultLanguage_CJK, false ) );
+            aRes.setValue( &aLocale, ::getCppuType((lang::Locale*)0 ));
+            break;
+        }
+        case UPH_DEFAULT_LOCALE_CTL :
+        {
+            lang::Locale aLocale( MsLangId::convertLanguageToLocale( rOpt.nDefaultLanguage_CTL, false ) );
+            aRes.setValue( &aLocale, ::getCppuType((lang::Locale*)0 ));
+            break;
+        }
+        case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       pbVal = &rOpt.bIsIgnorePostPositionalWord; break;
+        case UPH_IS_AUTO_CLOSE_DIALOG :                 pbVal = &rOpt.bIsAutoCloseDialog; break;
+        case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  pbVal = &rOpt.bIsShowEntriesRecentlyUsedFirst; break;
+        case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       pbVal = &rOpt.bIsAutoReplaceUniqueEntries; break;
+
+        case UPH_IS_DIRECTION_TO_SIMPLIFIED:            pbVal = &rOpt.bIsDirectionToSimplified; break;
+        case UPH_IS_USE_CHARACTER_VARIANTS :            pbVal = &rOpt.bIsUseCharacterVariants; break;
+        case UPH_IS_TRANSLATE_COMMON_TERMS :            pbVal = &rOpt.bIsTranslateCommonTerms; break;
+        case UPH_IS_REVERSE_MAPPING :                   pbVal = &rOpt.bIsReverseMapping; break;
+
+        case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       pnInt32Val = &rOpt.nDataFilesChangedCheckValue; break;
+        case UPH_IS_GRAMMAR_AUTO:                       pbVal = &rOpt.bIsGrammarAuto; break;
+        case UPH_IS_GRAMMAR_INTERACTIVE:                pbVal = &rOpt.bIsGrammarInteractive; break;
+        default :
+            DBG_ASSERT( 0, "unexpected property handle" );
+    }
+
+    if (pbVal)
+        aRes <<= *pbVal;
+    else if (pnVal)
+        aRes <<= *pnVal;
+    else if (pnInt32Val)
+        aRes <<= *pnInt32Val;
+
+    return aRes;
+}
+
+
+BOOL SvtLinguConfigItem::SetProperty( const OUString &rPropertyName, const uno::Any &rValue )
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    BOOL bSucc = FALSE;
+    INT32 nHdl;
+    if (GetHdlByName( nHdl, rPropertyName ))
+        bSucc = SetProperty( nHdl, rValue );
+    return bSucc;
+}
+
+
+BOOL SvtLinguConfigItem::SetProperty( INT32 nPropertyHandle, const uno::Any &rValue )
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    BOOL bSucc = FALSE;
+    if (!rValue.hasValue())
+        return bSucc;
+
+    BOOL bMod = FALSE;
+
+    INT16 *pnVal = 0;
+    BOOL  *pbVal = 0;
+    INT32 *pnInt32Val = 0;
+
+    SvtLinguOptions &rOpt = aOpt;
+    switch (nPropertyHandle)
+    {
+        case UPH_IS_USE_DICTIONARY_LIST :   pbVal = &rOpt.bIsUseDictionaryList;    break;
+        case UPH_IS_IGNORE_CONTROL_CHARACTERS : pbVal = &rOpt.bIsIgnoreControlCharacters;  break;
+        case UPH_IS_HYPH_AUTO :             pbVal = &rOpt.bIsHyphAuto; break;
+        case UPH_IS_HYPH_SPECIAL :          pbVal = &rOpt.bIsHyphSpecial;  break;
+        case UPH_IS_SPELL_AUTO :            pbVal = &rOpt.bIsSpellAuto;    break;
+        case UPH_IS_SPELL_SPECIAL :         pbVal = &rOpt.bIsSpellSpecial; break;
+        case UPH_IS_WRAP_REVERSE :          pbVal = &rOpt.bIsSpellReverse; break;
+        case UPH_DEFAULT_LANGUAGE :         pnVal = &rOpt.nDefaultLanguage;    break;
+        case UPH_IS_SPELL_CAPITALIZATION :  pbVal = &rOpt.bIsSpellCapitalization;      break;
+        case UPH_IS_SPELL_WITH_DIGITS :     pbVal = &rOpt.bIsSpellWithDigits;  break;
+        case UPH_IS_SPELL_UPPER_CASE :      pbVal = &rOpt.bIsSpellUpperCase;       break;
+        case UPH_HYPH_MIN_LEADING :         pnVal = &rOpt.nHyphMinLeading;     break;
+        case UPH_HYPH_MIN_TRAILING :        pnVal = &rOpt.nHyphMinTrailing;    break;
+        case UPH_HYPH_MIN_WORD_LENGTH :     pnVal = &rOpt.nHyphMinWordLength;  break;
+        case UPH_ACTIVE_DICTIONARIES :
+        {
+            rValue >>= rOpt.aActiveDics;
+            bMod = TRUE;
+            break;
+        }
+        case UPH_ACTIVE_CONVERSION_DICTIONARIES :
+        {
+            rValue >>= rOpt.aActiveConvDics;
+            bMod = TRUE;
+            break;
+        }
+        case UPH_DEFAULT_LOCALE :
+        {
+            bSucc = lcl_SetLocale( rOpt.nDefaultLanguage, rValue );
+            bMod = bSucc;
+            break;
+        }
+        case UPH_DEFAULT_LOCALE_CJK :
+        {
+            bSucc = lcl_SetLocale( rOpt.nDefaultLanguage_CJK, rValue );
+            bMod = bSucc;
+            break;
+        }
+        case UPH_DEFAULT_LOCALE_CTL :
+        {
+            bSucc = lcl_SetLocale( rOpt.nDefaultLanguage_CTL, rValue );
+            bMod = bSucc;
+            break;
+        }
+        case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       pbVal = &rOpt.bIsIgnorePostPositionalWord; break;
+        case UPH_IS_AUTO_CLOSE_DIALOG :                 pbVal = &rOpt.bIsAutoCloseDialog; break;
+        case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  pbVal = &rOpt.bIsShowEntriesRecentlyUsedFirst; break;
+        case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       pbVal = &rOpt.bIsAutoReplaceUniqueEntries; break;
+
+        case UPH_IS_DIRECTION_TO_SIMPLIFIED :           pbVal = &rOpt.bIsDirectionToSimplified; break;
+        case UPH_IS_USE_CHARACTER_VARIANTS :            pbVal = &rOpt.bIsUseCharacterVariants; break;
+        case UPH_IS_TRANSLATE_COMMON_TERMS :            pbVal = &rOpt.bIsTranslateCommonTerms; break;
+        case UPH_IS_REVERSE_MAPPING :                   pbVal = &rOpt.bIsReverseMapping; break;
+
+        case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       pnInt32Val = &rOpt.nDataFilesChangedCheckValue; break;
+        case UPH_IS_GRAMMAR_AUTO:                       pbVal = &rOpt.bIsGrammarAuto; break;
+        case UPH_IS_GRAMMAR_INTERACTIVE:                pbVal = &rOpt.bIsGrammarInteractive; break;
+        default :
+            DBG_ASSERT( 0, "unexpected property handle" );
+    }
+
+    if (pbVal)
+    {
+        BOOL bNew = BOOL();
+        if (rValue >>= bNew)
+        {
+            if (bNew != *pbVal)
+            {
+                *pbVal = bNew;
+                bMod = TRUE;
+            }
+            bSucc = TRUE;
+        }
+    }
+    else if (pnVal)
+    {
+        INT16 nNew = INT16();
+        if (rValue >>= nNew)
+        {
+            if (nNew != *pnVal)
+            {
+                *pnVal = nNew;
+                bMod = TRUE;
+            }
+            bSucc = TRUE;
+        }
+    }
+    else if (pnInt32Val)
+    {
+        INT32 nNew = INT32();
+        if (rValue >>= nNew)
+        {
+            if (nNew != *pnInt32Val)
+            {
+                *pnInt32Val = nNew;
+                bMod = TRUE;
+            }
+            bSucc = TRUE;
+        }
+    }
+
+    if (bMod)
+        SetModified();
+
+    NotifyListeners(0);
+    return bSucc;
+}
+
+
+BOOL SvtLinguConfigItem::GetOptions( SvtLinguOptions &rOptions ) const
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    rOptions = aOpt;
+    return TRUE;
+}
+
+
+BOOL SvtLinguConfigItem::SetOptions( const SvtLinguOptions &rOptions )
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    aOpt = rOptions;
+    SetModified();
+    NotifyListeners(0);
+    return TRUE;
+}
+
+
+BOOL SvtLinguConfigItem::LoadOptions( const uno::Sequence< OUString > &rProperyNames )
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    BOOL bRes = FALSE;
+
+    const OUString *pProperyNames = rProperyNames.getConstArray();
+    INT32 nProps = rProperyNames.getLength();
+
+    const uno::Sequence< uno::Any > aValues = GetProperties( rProperyNames );
+    const uno::Sequence< sal_Bool > aROStates = GetReadOnlyStates( rProperyNames );
+
+    if (nProps  &&  aValues.getLength() == nProps &&  aROStates.getLength() == nProps)
+    {
+        SvtLinguOptions &rOpt = aOpt;
+
+        const uno::Any *pValue = aValues.getConstArray();
+        const sal_Bool *pROStates = aROStates.getConstArray();
+        for (INT32 i = 0;  i < nProps;  ++i)
+        {
+            const uno::Any &rVal = pValue[i];
+            INT32 nPropertyHandle;
+            GetHdlByName( nPropertyHandle, pProperyNames[i], sal_True );
+            switch ( nPropertyHandle )
+            {
+                case UPH_DEFAULT_LOCALE :
+                    { rOpt.bRODefaultLanguage = pROStates[i]; rOpt.nDefaultLanguage = lcl_CfgAnyToLanguage( rVal ); } break;
+                case UPH_ACTIVE_DICTIONARIES :
+                    { rOpt.bROActiveDics = pROStates[i]; rVal >>= rOpt.aActiveDics;   } break;
+                case UPH_IS_USE_DICTIONARY_LIST :
+                    { rOpt.bROIsUseDictionaryList = pROStates[i]; rVal >>= rOpt.bIsUseDictionaryList;  } break;
+                case UPH_IS_IGNORE_CONTROL_CHARACTERS :
+                    { rOpt.bROIsIgnoreControlCharacters = pROStates[i]; rVal >>= rOpt.bIsIgnoreControlCharacters;    } break;
+                case UPH_DEFAULT_LOCALE_CJK :
+                    { rOpt.bRODefaultLanguage_CJK = pROStates[i]; rOpt.nDefaultLanguage_CJK = lcl_CfgAnyToLanguage( rVal );    } break;
+                case UPH_DEFAULT_LOCALE_CTL :
+                    { rOpt.bRODefaultLanguage_CTL = pROStates[i]; rOpt.nDefaultLanguage_CTL = lcl_CfgAnyToLanguage( rVal );    } break;
+
+                case UPH_IS_SPELL_UPPER_CASE :
+                    { rOpt.bROIsSpellUpperCase = pROStates[i]; rVal >>= rOpt.bIsSpellUpperCase; } break;
+                case UPH_IS_SPELL_WITH_DIGITS :
+                    { rOpt.bROIsSpellWithDigits = pROStates[i]; rVal >>= rOpt.bIsSpellWithDigits;    } break;
+                case UPH_IS_SPELL_CAPITALIZATION :
+                    { rOpt.bROIsSpellCapitalization = pROStates[i]; rVal >>= rOpt.bIsSpellCapitalization;    } break;
+                case UPH_IS_SPELL_AUTO :
+                    { rOpt.bROIsSpellAuto = pROStates[i]; rVal >>= rOpt.bIsSpellAuto;  } break;
+                case UPH_IS_SPELL_SPECIAL :
+                    { rOpt.bROIsSpellSpecial = pROStates[i]; rVal >>= rOpt.bIsSpellSpecial;   } break;
+                case UPH_IS_WRAP_REVERSE :
+                    { rOpt.bROIsSpellReverse = pROStates[i]; rVal >>= rOpt.bIsSpellReverse;   } break;
+
+                case UPH_HYPH_MIN_LEADING :
+                    { rOpt.bROHyphMinLeading = pROStates[i]; rVal >>= rOpt.nHyphMinLeading;   } break;
+                case UPH_HYPH_MIN_TRAILING :
+                    { rOpt.bROHyphMinTrailing = pROStates[i]; rVal >>= rOpt.nHyphMinTrailing;  } break;
+                case UPH_HYPH_MIN_WORD_LENGTH :
+                    { rOpt.bROHyphMinWordLength = pROStates[i]; rVal >>= rOpt.nHyphMinWordLength;    } break;
+                case UPH_IS_HYPH_SPECIAL :
+                    { rOpt.bROIsHyphSpecial = pROStates[i]; rVal >>= rOpt.bIsHyphSpecial;    } break;
+                case UPH_IS_HYPH_AUTO :
+                    { rOpt.bROIsHyphAuto = pROStates[i]; rVal >>= rOpt.bIsHyphAuto;   } break;
+
+                case UPH_ACTIVE_CONVERSION_DICTIONARIES : { rOpt.bROActiveConvDics = pROStates[i]; rVal >>= rOpt.aActiveConvDics;   } break;
+
+                case UPH_IS_IGNORE_POST_POSITIONAL_WORD :
+                    { rOpt.bROIsIgnorePostPositionalWord = pROStates[i]; rVal >>= rOpt.bIsIgnorePostPositionalWord;  } break;
+                case UPH_IS_AUTO_CLOSE_DIALOG :
+                    { rOpt.bROIsAutoCloseDialog = pROStates[i]; rVal >>= rOpt.bIsAutoCloseDialog;  } break;
+                case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :
+                    { rOpt.bROIsShowEntriesRecentlyUsedFirst = pROStates[i]; rVal >>= rOpt.bIsShowEntriesRecentlyUsedFirst;  } break;
+                case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :
+                    { rOpt.bROIsAutoReplaceUniqueEntries = pROStates[i]; rVal >>= rOpt.bIsAutoReplaceUniqueEntries;  } break;
+
+                case UPH_IS_DIRECTION_TO_SIMPLIFIED :
+                    { rOpt.bROIsDirectionToSimplified = pROStates[i];
+                            if( ! (rVal >>= rOpt.bIsDirectionToSimplified) )
+                            {
+                                //default is locale dependent:
+                                if(  rOpt.nDefaultLanguage_CJK == LANGUAGE_CHINESE_HONGKONG
+                                  || rOpt.nDefaultLanguage_CJK == LANGUAGE_CHINESE_MACAU
+                                  || rOpt.nDefaultLanguage_CJK == LANGUAGE_CHINESE_TRADITIONAL )
+                                {
+                                    rOpt.bIsDirectionToSimplified = FALSE;
+                                }
+                                else
+                                {
+                                    rOpt.bIsDirectionToSimplified = TRUE;
+                                }
+                            }
+                    } break;
+                case UPH_IS_USE_CHARACTER_VARIANTS :
+                    { rOpt.bROIsUseCharacterVariants = pROStates[i]; rVal >>= rOpt.bIsUseCharacterVariants;  } break;
+                case UPH_IS_TRANSLATE_COMMON_TERMS :
+                    { rOpt.bROIsTranslateCommonTerms = pROStates[i]; rVal >>= rOpt.bIsTranslateCommonTerms;  } break;
+                case UPH_IS_REVERSE_MAPPING :
+                    { rOpt.bROIsReverseMapping = pROStates[i]; rVal >>= rOpt.bIsReverseMapping;  } break;
+
+                case UPH_DATA_FILES_CHANGED_CHECK_VALUE :
+                    { rOpt.bRODataFilesChangedCheckValue = pROStates[i]; rVal >>= rOpt.nDataFilesChangedCheckValue;  } break;
+
+                case UPH_IS_GRAMMAR_AUTO:
+                    { rOpt.bROIsGrammarAuto = pROStates[i]; rVal >>= rOpt.bIsGrammarAuto; }
+                break;
+                case UPH_IS_GRAMMAR_INTERACTIVE:
+                    { rOpt.bROIsGrammarInteractive = pROStates[i]; rVal >>= rOpt.bIsGrammarInteractive; }
+                break;
+
+                default:
+                    DBG_ASSERT( 0, "unexpected case" );
+            }
+        }
+
+        bRes = TRUE;
+    }
+    DBG_ASSERT( bRes, "LoadOptions failed" );
+
+    return bRes;
+}
+
+
+BOOL SvtLinguConfigItem::SaveOptions( const uno::Sequence< OUString > &rProperyNames )
+{
+    if (!IsModified())
+        return TRUE;
+
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    BOOL bRet = FALSE;
+    const uno::Type &rBOOL     = ::getBooleanCppuType();
+    const uno::Type &rINT16    = ::getCppuType( (INT16 *) NULL );
+    const uno::Type &rINT32    = ::getCppuType( (INT32 *) NULL );
+
+    INT32 nProps = rProperyNames.getLength();
+    uno::Sequence< uno::Any > aValues( nProps );
+    uno::Any *pValue = aValues.getArray();
+
+    if (nProps  &&  aValues.getLength() == nProps)
+    {
+        const SvtLinguOptions &rOpt = aOpt;
+
+        OUString aTmp( lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage ) );
+        *pValue++ = uno::makeAny( aTmp );                               //   0
+        *pValue++ = uno::makeAny( rOpt.aActiveDics );                   //   1
+        pValue++->setValue( &rOpt.bIsUseDictionaryList, rBOOL );        //   2
+        pValue++->setValue( &rOpt.bIsIgnoreControlCharacters, rBOOL );  //   3
+        aTmp = lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage_CJK );
+        *pValue++ = uno::makeAny( aTmp );                               //   5
+        aTmp = lcl_LanguageToCfgLocaleStr( rOpt.nDefaultLanguage_CTL );
+        *pValue++ = uno::makeAny( aTmp );                               //   6
+
+        pValue++->setValue( &rOpt.bIsSpellUpperCase, rBOOL );          //   7
+        pValue++->setValue( &rOpt.bIsSpellWithDigits, rBOOL );         //   8
+        pValue++->setValue( &rOpt.bIsSpellCapitalization, rBOOL );     //   9
+        pValue++->setValue( &rOpt.bIsSpellAuto, rBOOL );               //  10
+        pValue++->setValue( &rOpt.bIsSpellSpecial, rBOOL );            //  11
+        pValue++->setValue( &rOpt.bIsSpellReverse, rBOOL );            //  14
+
+        pValue++->setValue( &rOpt.nHyphMinLeading, rINT16 );           //  15
+        pValue++->setValue( &rOpt.nHyphMinTrailing, rINT16 );          //  16
+        pValue++->setValue( &rOpt.nHyphMinWordLength, rINT16 );        //  17
+        pValue++->setValue( &rOpt.bIsHyphSpecial, rBOOL );             //  18
+        pValue++->setValue( &rOpt.bIsHyphAuto, rBOOL );                //  19
+
+        *pValue++ = uno::makeAny( rOpt.aActiveConvDics );               //   20
+
+        pValue++->setValue( &rOpt.bIsIgnorePostPositionalWord, rBOOL ); //  21
+        pValue++->setValue( &rOpt.bIsAutoCloseDialog, rBOOL );          //  22
+        pValue++->setValue( &rOpt.bIsShowEntriesRecentlyUsedFirst, rBOOL ); //  23
+        pValue++->setValue( &rOpt.bIsAutoReplaceUniqueEntries, rBOOL ); //  24
+
+        pValue++->setValue( &rOpt.bIsDirectionToSimplified, rBOOL ); //  25
+        pValue++->setValue( &rOpt.bIsUseCharacterVariants, rBOOL ); //  26
+        pValue++->setValue( &rOpt.bIsTranslateCommonTerms, rBOOL ); //  27
+        pValue++->setValue( &rOpt.bIsReverseMapping, rBOOL ); //  28
+
+        pValue++->setValue( &rOpt.nDataFilesChangedCheckValue, rINT32 ); //  29
+        pValue++->setValue( &rOpt.bIsGrammarAuto, rBOOL ); //  30
+        pValue++->setValue( &rOpt.bIsGrammarInteractive, rBOOL ); // 31
+
+        bRet |= PutProperties( rProperyNames, aValues );
+    }
+
+    if (bRet)
+        ClearModified();
+
+    return bRet;
+}
+
+BOOL SvtLinguConfigItem::IsReadOnly( const rtl::OUString &rPropertyName ) const
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    BOOL bReadOnly = FALSE;
+    INT32 nHdl;
+    if (GetHdlByName( nHdl, rPropertyName ))
+        bReadOnly = IsReadOnly( nHdl );
+    return bReadOnly;
+}
+
+BOOL SvtLinguConfigItem::IsReadOnly( INT32 nPropertyHandle ) const
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    BOOL bReadOnly = FALSE;
+
+    const SvtLinguOptions &rOpt = const_cast< SvtLinguConfigItem * >(this)->aOpt;
+    switch(nPropertyHandle)
+    {
+        case UPH_IS_USE_DICTIONARY_LIST         : bReadOnly = rOpt.bROIsUseDictionaryList      ; break;
+        case UPH_IS_IGNORE_CONTROL_CHARACTERS   : bReadOnly = rOpt.bROIsIgnoreControlCharacters; break;
+        case UPH_IS_HYPH_AUTO                   : bReadOnly = rOpt.bROIsHyphAuto               ; break;
+        case UPH_IS_HYPH_SPECIAL                : bReadOnly = rOpt.bROIsHyphSpecial            ; break;
+        case UPH_IS_SPELL_AUTO                  : bReadOnly = rOpt.bROIsSpellAuto              ; break;
+        case UPH_IS_SPELL_SPECIAL               : bReadOnly = rOpt.bROIsSpellSpecial           ; break;
+        case UPH_IS_WRAP_REVERSE                : bReadOnly = rOpt.bROIsSpellReverse           ; break;
+        case UPH_DEFAULT_LANGUAGE               : bReadOnly = rOpt.bRODefaultLanguage          ; break;
+        case UPH_IS_SPELL_CAPITALIZATION        : bReadOnly = rOpt.bROIsSpellCapitalization    ; break;
+        case UPH_IS_SPELL_WITH_DIGITS           : bReadOnly = rOpt.bROIsSpellWithDigits        ; break;
+        case UPH_IS_SPELL_UPPER_CASE            : bReadOnly = rOpt.bROIsSpellUpperCase         ; break;
+        case UPH_HYPH_MIN_LEADING               : bReadOnly = rOpt.bROHyphMinLeading           ; break;
+        case UPH_HYPH_MIN_TRAILING              : bReadOnly = rOpt.bROHyphMinTrailing          ; break;
+        case UPH_HYPH_MIN_WORD_LENGTH           : bReadOnly = rOpt.bROHyphMinWordLength        ; break;
+        case UPH_ACTIVE_DICTIONARIES            : bReadOnly = rOpt.bROActiveDics               ; break;
+        case UPH_ACTIVE_CONVERSION_DICTIONARIES : bReadOnly = rOpt.bROActiveConvDics           ; break;
+        case UPH_DEFAULT_LOCALE                 : bReadOnly = rOpt.bRODefaultLanguage          ; break;
+        case UPH_DEFAULT_LOCALE_CJK             : bReadOnly = rOpt.bRODefaultLanguage_CJK      ; break;
+        case UPH_DEFAULT_LOCALE_CTL             : bReadOnly = rOpt.bRODefaultLanguage_CTL      ; break;
+        case UPH_IS_IGNORE_POST_POSITIONAL_WORD :       bReadOnly = rOpt.bROIsIgnorePostPositionalWord; break;
+        case UPH_IS_AUTO_CLOSE_DIALOG :                 bReadOnly = rOpt.bROIsAutoCloseDialog; break;
+        case UPH_IS_SHOW_ENTRIES_RECENTLY_USED_FIRST :  bReadOnly = rOpt.bROIsShowEntriesRecentlyUsedFirst; break;
+        case UPH_IS_AUTO_REPLACE_UNIQUE_ENTRIES :       bReadOnly = rOpt.bROIsAutoReplaceUniqueEntries; break;
+        case UPH_IS_DIRECTION_TO_SIMPLIFIED : bReadOnly = rOpt.bROIsDirectionToSimplified; break;
+        case UPH_IS_USE_CHARACTER_VARIANTS : bReadOnly = rOpt.bROIsUseCharacterVariants; break;
+        case UPH_IS_TRANSLATE_COMMON_TERMS : bReadOnly = rOpt.bROIsTranslateCommonTerms; break;
+        case UPH_IS_REVERSE_MAPPING :        bReadOnly = rOpt.bROIsReverseMapping; break;
+        case UPH_DATA_FILES_CHANGED_CHECK_VALUE :       bReadOnly = rOpt.bRODataFilesChangedCheckValue; break;
+        case UPH_IS_GRAMMAR_AUTO:                       bReadOnly = rOpt.bROIsGrammarAuto; break;
+        case UPH_IS_GRAMMAR_INTERACTIVE:                bReadOnly = rOpt.bROIsGrammarInteractive; break;
+        default :
+            DBG_ASSERT( 0, "unexpected property handle" );
+    }
+    return bReadOnly;
+}
+
+//////////////////////////////////////////////////////////////////////
+
+static SvtLinguConfigItem *pCfgItem = 0;
+static sal_Int32           nCfgItemRefCount = 0;
+
+static const rtl::OUString aG_SupportedDictionaryFormats( A2OU("SupportedDictionaryFormats") );
+static const rtl::OUString aG_Dictionaries( A2OU("Dictionaries") );
+static const rtl::OUString aG_Locations( A2OU("Locations") );
+static const rtl::OUString aG_Format( A2OU("Format") );
+static const rtl::OUString aG_Locales( A2OU("Locales") );
+static const rtl::OUString aG_DisabledDictionaries( A2OU("DisabledDictionaries") );
+static const rtl::OUString aG_LastActiveDictionaries( A2OU("LastActiveDictionaries") );
+
+SvtLinguConfig::SvtLinguConfig()
+{
+    // Global access, must be guarded (multithreading)
+    osl::MutexGuard aGuard( GetOwnMutex() );
+    ++nCfgItemRefCount;
+}
+
+
+SvtLinguConfig::~SvtLinguConfig()
+{
+    osl::MutexGuard aGuard( GetOwnMutex() );
+
+    if (pCfgItem && pCfgItem->IsModified())
+        pCfgItem->Commit();
+
+    if (--nCfgItemRefCount <= 0)
+    {
+        if (pCfgItem)
+            delete pCfgItem;
+        pCfgItem = 0;
+    }
+}
+
+
+SvtLinguConfigItem & SvtLinguConfig::GetConfigItem()
+{
+    // Global access, must be guarded (multithreading)
+    osl::MutexGuard aGuard( GetOwnMutex() );
+    if (!pCfgItem)
+    {
+        pCfgItem = new SvtLinguConfigItem;
+        ItemHolder1::holdConfigItem(E_LINGUCFG);
+    }
+    return *pCfgItem;
+}
+
+
+uno::Sequence< OUString > SvtLinguConfig::GetNodeNames( const OUString &rNode )
+{
+    return GetConfigItem().GetNodeNames( rNode );
+}
+
+
+uno::Sequence< uno::Any > SvtLinguConfig::GetProperties( const uno::Sequence< OUString > &rNames )
+{
+    return GetConfigItem().GetProperties(rNames);
+}
+
+
+sal_Bool SvtLinguConfig::ReplaceSetProperties(
+        const OUString &rNode, uno::Sequence< beans::PropertyValue > rValues )
+{
+    return GetConfigItem().ReplaceSetProperties( rNode, rValues );
+}
+
+
+uno::Any SvtLinguConfig::GetProperty( const OUString &rPropertyName ) const
+{
+    return GetConfigItem().GetProperty( rPropertyName );
+}
+
+
+uno::Any SvtLinguConfig::GetProperty( INT32 nPropertyHandle ) const
+{
+    return GetConfigItem().GetProperty( nPropertyHandle );
+}
+
+
+BOOL SvtLinguConfig::SetProperty( const OUString &rPropertyName, const uno::Any &rValue )
+{
+    return GetConfigItem().SetProperty( rPropertyName, rValue );
+}
+
+
+BOOL SvtLinguConfig::SetProperty( INT32 nPropertyHandle, const uno::Any &rValue )
+{
+    return GetConfigItem().SetProperty( nPropertyHandle, rValue );
+}
+
+
+BOOL SvtLinguConfig::GetOptions( SvtLinguOptions &rOptions ) const
+{
+    return GetConfigItem().GetOptions( rOptions );
+}
+
+
+BOOL SvtLinguConfig::SetOptions( const SvtLinguOptions &rOptions )
+{
+    return GetConfigItem().SetOptions( rOptions );
+}
+
+
+BOOL SvtLinguConfig::IsReadOnly( const rtl::OUString &rPropertyName ) const
+{
+    return GetConfigItem().IsReadOnly( rPropertyName );
+}
+
+BOOL SvtLinguConfig::IsReadOnly( INT32 nPropertyHandle ) const
+{
+    return GetConfigItem().IsReadOnly( nPropertyHandle );
+}
+
+BOOL SvtLinguConfig::GetElementNamesFor(
+     const rtl::OUString &rNodeName,
+     uno::Sequence< rtl::OUString > &rElementNames ) const
+{
+    bool bSuccess = false;
+    try
+    {
+        uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( rNodeName ), uno::UNO_QUERY_THROW );
+        rElementNames = xNA->getElementNames();
+        bSuccess = true;
+    }
+    catch (uno::Exception &)
+    {
+    }
+    return bSuccess;
+}
+
+static uno::Reference< container::XNameAccess > GetOrCreateSetEntry_Impl(
+    const uno::Reference< container::XNameAccess > &rxSetNameAccess,
+    const rtl::OUString &rEntryName )
+{
+    uno::Reference< container::XNameAccess > xResult;
+    try
+    {
+        if (!rxSetNameAccess->hasByName( rEntryName ))
+        {
+            uno::Reference< lang::XSingleServiceFactory > xFactory( rxSetNameAccess, uno::UNO_QUERY_THROW);
+            uno::Reference< uno::XInterface > xNewEntry( xFactory->createInstance() );
+            uno::Reference< container::XNameContainer > xNC( rxSetNameAccess, uno::UNO_QUERY_THROW );
+            xNC->insertByName( rEntryName, makeAny( xNewEntry ) );
+        }
+        xResult.set( rxSetNameAccess->getByName( rEntryName ), uno::UNO_QUERY_THROW );
+    }
+    catch (uno::Exception &)
+    {
+    }
+    return xResult;
+}
+
+BOOL SvtLinguConfig::GetSupportedDictionaryFormatsFor(
+    const rtl::OUString &rSetName,
+    const rtl::OUString &rSetEntry,
+    uno::Sequence< rtl::OUString > &rFormatList ) const
+{
+    if (rSetName.getLength() == 0 || rSetEntry.getLength() == 0)
+        return sal_False;
+    bool bSuccess = false;
+    try
+    {
+        uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( rSetName ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( rSetEntry ), uno::UNO_QUERY_THROW );
+        if (xNA->getByName( aG_SupportedDictionaryFormats ) >>= rFormatList)
+            bSuccess = true;
+        DBG_ASSERT( rFormatList.getLength(), "supported dictionary format list is empty" );
+    }
+    catch (uno::Exception &)
+    {
+    }
+    return bSuccess;
+}
+
+void SvtLinguConfig::SetOrCreateSupportedDictionaryFormatsFor(
+    const rtl::OUString &rSetName,
+    const rtl::OUString &rSetEntry,
+    const uno::Sequence< rtl::OUString > &rFormatList  ) const
+{
+    if (rSetName.getLength() == 0 || rSetEntry.getLength() == 0)
+        return;
+    try
+    {
+        DBG_ASSERT( rFormatList.getLength(), "applying empty format list. Really??" );
+
+        uno::Reference< util::XChangesBatch > xUpdateAccess( GetMainUpdateAccess() );
+        uno::Reference< container::XNameAccess > xNA( xUpdateAccess, uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( rSetName ), uno::UNO_QUERY_THROW );
+        xNA = GetOrCreateSetEntry_Impl( xNA, rSetEntry );
+
+        uno::Reference< container::XNameReplace > xNR( xNA, uno::UNO_QUERY_THROW );
+        xNR->replaceByName( aG_SupportedDictionaryFormats, uno::makeAny( rFormatList ) );
+
+        xUpdateAccess->commitChanges();
+    }
+    catch (uno::Exception &)
+    {
+    }
+}
+
+
+static uno::WeakReference< util::XMacroExpander > aG_xMacroExpander;
+
+static uno::Reference< util::XMacroExpander > lcl_GetMacroExpander()
+{
+    uno::Reference< util::XMacroExpander > xMacroExpander( aG_xMacroExpander );
+    if ( !xMacroExpander.is() )
+    {
+        if ( !xMacroExpander.is() )
+        {
+            uno::Reference< uno::XComponentContext > xContext;
+            uno::Reference< beans::XPropertySet > xProps( ::comphelper::getProcessServiceFactory(), uno::UNO_QUERY );
+            xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xContext;
+            if ( xContext.is() )
+            {
+                aG_xMacroExpander =  uno::Reference< com::sun::star::util::XMacroExpander >( xContext->getValueByName(
+                                        OUString( RTL_CONSTASCII_USTRINGPARAM( "/singletons/com.sun.star.util.theMacroExpander"))),
+                                        uno::UNO_QUERY );
+                xMacroExpander = aG_xMacroExpander;
+            }
+        }
+    }
+
+    return xMacroExpander;
+}
+
+
+static bool lcl_GetFileUrlFromOrigin(
+    OUString /*out*/ &rFileUrl,
+    const OUString &rOrigin,
+    uno::Reference< util::XMacroExpander > &rxMacroExpander )
+{
+    bool bSuccess = false;
+    if (rOrigin.getLength() > 0 && rxMacroExpander.is())
+    {
+        rtl::OUString aURL( rOrigin );
+        if (( aURL.compareToAscii( RTL_CONSTASCII_STRINGPARAM( EXPAND_PROTOCOL )) == 0 ) &&
+            rxMacroExpander.is() )
+        {
+            // cut protocol
+            OUString aMacro( aURL.copy( sizeof ( EXPAND_PROTOCOL ) -1 ) );
+            // decode uric class chars
+            aMacro = Uri::decode( aMacro, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
+            // expand macro string
+            aURL = rxMacroExpander->expandMacros( aMacro );
+
+            bool bIsFileUrl = aURL.compareToAscii( RTL_CONSTASCII_STRINGPARAM( FILE_PROTOCOL )) == 0;
+            if (bIsFileUrl)
+            {
+                rFileUrl = aURL;
+                bSuccess = true;
+            }
+            else
+            {
+                DBG_ASSERT( bIsFileUrl, "not a file URL");
+            }
+        }
+        else
+        {
+            DBG_ASSERT( 0, "failed to get file URL" );
+        }
+    }
+    return bSuccess;
+}
+
+
+BOOL SvtLinguConfig::GetDictionaryEntry(
+    const rtl::OUString &rNodeName,
+    SvtLinguConfigDictionaryEntry &rDicEntry ) const
+{
+    if (rNodeName.getLength() == 0)
+        return sal_False;
+    bool bSuccess = false;
+    try
+    {
+        uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( aG_Dictionaries ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( rNodeName ), uno::UNO_QUERY_THROW );
+
+        // read group data...
+        uno::Sequence< rtl::OUString >  aLocations;
+        rtl::OUString                   aFormatName;
+        uno::Sequence< rtl::OUString >  aLocaleNames;
+        bSuccess =  (xNA->getByName( aG_Locations ) >>= aLocations)  &&
+                    (xNA->getByName( aG_Format )    >>= aFormatName) &&
+                    (xNA->getByName( aG_Locales )   >>= aLocaleNames);
+        DBG_ASSERT( aLocations.getLength(), "Dictionary locations not set" );
+        DBG_ASSERT( aFormatName.getLength(), "Dictionary format name not set" );
+        DBG_ASSERT( aLocaleNames.getLength(), "No locales set for the dictionary" );
+
+        // if sucessful continue
+        if (bSuccess)
+        {
+            // get file URL's for the locations
+            uno::Reference< util::XMacroExpander > xMacroExpander( lcl_GetMacroExpander() );
+            for (sal_Int32 i = 0;  i < aLocations.getLength();  ++i)
+            {
+                rtl::OUString &rLocation = aLocations[i];
+                if (!lcl_GetFileUrlFromOrigin( rLocation, rLocation, xMacroExpander ))
+                    bSuccess = false;
+            }
+
+            // if everything was fine return the result
+            if (bSuccess)
+            {
+                rDicEntry.aLocations    = aLocations;
+                rDicEntry.aFormatName   = aFormatName;
+                rDicEntry.aLocaleNames  = aLocaleNames;
+            }
+        }
+    }
+    catch (uno::Exception &)
+    {
+    }
+    return bSuccess;
+}
+
+void SvtLinguConfig::SetOrCreateDictionaryEntry(
+    const rtl::OUString &rNodeName,
+    const SvtLinguConfigDictionaryEntry &rDicEntry ) const
+{
+    if (rNodeName.getLength() == 0)
+        return;
+    try
+    {
+        uno::Reference< util::XChangesBatch > xUpdateAccess( GetMainUpdateAccess() );
+        uno::Reference< container::XNameAccess > xNA( xUpdateAccess, uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( aG_Dictionaries ), uno::UNO_QUERY_THROW );
+        xNA = GetOrCreateSetEntry_Impl( xNA, rNodeName );
+
+        DBG_ASSERT( rDicEntry.aLocations.getLength(), "Applying empty dictionary locations. Really correct??" );
+        DBG_ASSERT( rDicEntry.aFormatName.getLength(), "Applying empty dictionary format name. Really correct??" );
+        DBG_ASSERT( rDicEntry.aLocaleNames.getLength(), "Applying empty list of locales for the dictionary. Really correct??" );
+
+        uno::Reference< container::XNameReplace > xNR( xNA, uno::UNO_QUERY_THROW );
+        xNR->replaceByName( aG_Locations, uno::makeAny( rDicEntry.aLocations ) );
+        xNR->replaceByName( aG_Format,    uno::makeAny( rDicEntry.aFormatName ) );
+        xNR->replaceByName( aG_Locales,   uno::makeAny( rDicEntry.aLocaleNames ) );
+
+        xUpdateAccess->commitChanges();
+    }
+    catch (uno::Exception &)
+    {
+    }
+}
+
+uno::Sequence< rtl::OUString > SvtLinguConfig::GetDisabledDictionaries() const
+{
+    uno::Sequence< rtl::OUString > aResult;
+    try
+    {
+        uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA->getByName( aG_DisabledDictionaries ) >>= aResult;
+    }
+    catch (uno::Exception &)
+    {
+    }
+    return aResult;
+}
+
+void SvtLinguConfig::SetDisabledDictionaries(
+    const uno::Sequence< rtl::OUString > &rDictionaries ) const
+{
+    try
+    {
+        uno::Reference< util::XChangesBatch > xUpdateAccess( GetMainUpdateAccess() );
+        uno::Reference< container::XNameAccess > xNA( xUpdateAccess, uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        if (xNA->hasByName( aG_DisabledDictionaries ))
+        {
+            uno::Reference< container::XNameReplace > xNR( xNA, uno::UNO_QUERY_THROW );
+            xNR->replaceByName( aG_DisabledDictionaries, makeAny( rDictionaries ) );
+        }
+        else
+        {
+            uno::Reference< container::XNameContainer > xNC( xNA, uno::UNO_QUERY_THROW );
+            xNC->insertByName( aG_DisabledDictionaries, makeAny( rDictionaries ) );
+        }
+
+        xUpdateAccess->commitChanges();
+    }
+    catch (uno::Exception &)
+    {
+    }
+}
+
+std::vector< SvtLinguConfigDictionaryEntry > SvtLinguConfig::GetActiveDictionariesByFormat(
+    const rtl::OUString &rFormatName )
+{
+    std::vector< SvtLinguConfigDictionaryEntry > aRes;
+    if (rFormatName.getLength() == 0)
+        return aRes;
+
+    try
+    {
+        uno::Sequence< rtl::OUString > aElementNames;
+        GetElementNamesFor( aG_Dictionaries, aElementNames );
+        sal_Int32 nLen = aElementNames.getLength();
+        const rtl::OUString *pElementNames = aElementNames.getConstArray();
+
+        SvtLinguConfigDictionaryEntry aDicEntry;
+        for (sal_Int32 i = 0;  i < nLen;  ++i)
+        {
+            // does dictionary match the format we are looking for?
+            if (GetDictionaryEntry( pElementNames[i], aDicEntry ) &&
+                aDicEntry.aFormatName == rFormatName)
+            {
+                // check if it is active or not
+                bool bDicIsActive = true;
+                const uno::Sequence< rtl::OUString > aDisabledDics( GetDisabledDictionaries() );
+                for (sal_Int32 k = 0;  bDicIsActive && k < aDisabledDics.getLength();  ++k)
+                {
+                    if (aDisabledDics[k] == pElementNames[i])
+                        bDicIsActive = false;
+                }
+
+                if (bDicIsActive)
+                {
+                    DBG_ASSERT( aDicEntry.aFormatName.getLength(),
+                            "FormatName not set" );
+                    DBG_ASSERT( aDicEntry.aLocations.getLength(),
+                            "Locations not set" );
+                    DBG_ASSERT( aDicEntry.aLocaleNames.getLength(),
+                            "Locales not set" );
+                    aRes.push_back( aDicEntry );
+                }
+            }
+        }
+    }
+    catch (uno::Exception &)
+    {
+    }
+
+    return aRes;
+}
+
+
+uno::Reference< util::XChangesBatch > SvtLinguConfig::GetMainUpdateAccess() const
+{
+    if (!m_xMainUpdateAccess.is())
+    {
+        try
+        {
+            // get configuration provider
+            uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider;
+            uno::Reference< lang::XMultiServiceFactory > xMgr = comphelper::getProcessServiceFactory();
+            if (xMgr.is())
+            {
+                xConfigurationProvider = uno::Reference< lang::XMultiServiceFactory > (
+                        xMgr->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM(
+                            "com.sun.star.configuration.ConfigurationProvider" ) ) ),
+                        uno::UNO_QUERY_THROW ) ;
+            }
+
+            // get configuration update access
+            beans::PropertyValue aValue;
+            aValue.Name  = A2OU( "nodepath" );
+            aValue.Value = uno::makeAny( A2OU("org.openoffice.Office.Linguistic") );
+            uno::Sequence< uno::Any > aProps(1);
+            aProps[0] <<= aValue;
+            m_xMainUpdateAccess = uno::Reference< util::XChangesBatch >(
+                    xConfigurationProvider->createInstanceWithArguments(
+                        A2OU( "com.sun.star.configuration.ConfigurationUpdateAccess" ), aProps ),
+                        uno::UNO_QUERY_THROW );
+        }
+        catch (uno::Exception &)
+        {
+        }
+    }
+
+    return m_xMainUpdateAccess;
+}
+
+
+rtl::OUString SvtLinguConfig::GetVendorImageUrl_Impl(
+    const rtl::OUString &rServiceImplName,
+    const rtl::OUString &rImageName ) const
+{
+    rtl::OUString aRes;
+    try
+    {
+        uno::Reference< container::XNameAccess > xImagesNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xImagesNA.set( xImagesNA->getByName( A2OU("Images") ), uno::UNO_QUERY_THROW );
+
+        uno::Reference< container::XNameAccess > xNA( xImagesNA->getByName( A2OU("ServiceNameEntries") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( rServiceImplName ), uno::UNO_QUERY_THROW );
+        uno::Any aAny( xNA->getByName( A2OU("VendorImagesNode") ) );
+        rtl::OUString aVendorImagesNode;
+        if (aAny >>= aVendorImagesNode)
+        {
+            xNA = xImagesNA;
+            xNA.set( xNA->getByName( A2OU("VendorImages") ), uno::UNO_QUERY_THROW );
+            xNA.set( xNA->getByName( aVendorImagesNode ), uno::UNO_QUERY_THROW );
+            aAny = xNA->getByName( rImageName );
+            rtl::OUString aTmp;
+            if (aAny >>= aTmp)
+            {
+                uno::Reference< util::XMacroExpander > xMacroExpander( lcl_GetMacroExpander() );
+                if (lcl_GetFileUrlFromOrigin( aTmp, aTmp, xMacroExpander ))
+                    aRes = aTmp;
+            }
+        }
+    }
+    catch (uno::Exception &)
+    {
+        DBG_ASSERT( 0, "exception caught. GetVendorImageUrl_Impl failed" );
+    }
+    return aRes;
+}
+
+
+rtl::OUString SvtLinguConfig::GetSpellAndGrammarDialogImage(
+    const rtl::OUString &rServiceImplName,
+    bool bHighContrast ) const
+{
+    rtl::OUString   aRes;
+    if (rServiceImplName.getLength() > 0)
+    {
+        rtl::OUString aImageName( A2OU( bHighContrast ? "SpellAndGrammarDialogImage_HC" : "SpellAndGrammarDialogImage" ));
+        rtl::OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, aImageName ) );
+        aRes = aPath;
+    }
+    return aRes;
+}
+
+
+rtl::OUString SvtLinguConfig::GetSpellAndGrammarContextSuggestionImage(
+    const rtl::OUString &rServiceImplName,
+    bool bHighContrast ) const
+{
+    rtl::OUString   aRes;
+    if (rServiceImplName.getLength() > 0)
+    {
+        rtl::OUString aImageName( A2OU( bHighContrast ? "SpellAndGrammarContextMenuSuggestionImage_HC" : "SpellAndGrammarContextMenuSuggestionImage" ));
+        rtl::OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, aImageName ) );
+        aRes = aPath;
+    }
+    return aRes;
+}
+
+
+rtl::OUString SvtLinguConfig::GetSpellAndGrammarContextDictionaryImage(
+    const rtl::OUString &rServiceImplName,
+    bool bHighContrast ) const
+{
+    rtl::OUString   aRes;
+    if (rServiceImplName.getLength() > 0)
+    {
+        rtl::OUString aImageName( A2OU( bHighContrast ? "SpellAndGrammarContextMenuDictionaryImage_HC" : "SpellAndGrammarContextMenuDictionaryImage" ));
+        rtl::OUString aPath( GetVendorImageUrl_Impl( rServiceImplName, aImageName ) );
+        aRes = aPath;
+    }
+    return aRes;
+}
+
+
+bool SvtLinguConfig::HasAnyVendorImages() const
+{
+    bool bRes = false;
+    try
+    {
+        uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("Images") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("VendorImages") ), uno::UNO_QUERY_THROW );
+
+        uno::Sequence< rtl::OUString > aElementNames( xNA->getElementNames() );
+        bRes = aElementNames.getLength() > 0;
+    }
+    catch (uno::Exception &)
+    {
+        DBG_ASSERT( 0, "exception caught. HasAnyVendorImages failed" );
+    }
+    return bRes;
+}
+
+
+bool SvtLinguConfig::HasGrammarChecker() const
+{
+    bool bRes = false;
+
+    try
+    {
+        uno::Reference< container::XNameAccess > xNA( GetMainUpdateAccess(), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("ServiceManager") ), uno::UNO_QUERY_THROW );
+        xNA.set( xNA->getByName( A2OU("GrammarCheckerList") ), uno::UNO_QUERY_THROW );
+
+        uno::Sequence< rtl::OUString > aElementNames( xNA->getElementNames() );
+        bRes = aElementNames.getLength() > 0;
+    }
+    catch (uno::Exception &)
+    {
+    }
+
+    return bRes;
+}
+
+//////////////////////////////////////////////////////////////////////
+