initial import

1 files changed, 778 insertions, 0 deletions

diff --git a/svx/source/editeng/unolingu.cxx b/svx/source/editeng/unolingu.cxx
new file mode 100644
index 000000000000..708e2d44d31b
--- /dev/null
+++ b/svx/source/editeng/unolingu.cxx
@@ -0,0 +1,778 @@
+/*************************************************************************
+ *
+ *  $RCSfile: unolingu.cxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 17:01:14 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library 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 for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#pragma hdrstop
+
+#include <unolingu.hxx>
+
+#ifndef _SFXINIMGR_HXX
+#include <svtools/iniman.hxx>
+#endif
+#ifndef _LANG_HXX
+#include <tools/lang.hxx>
+#endif
+#ifndef _TOOLS_DEBUG_HXX
+#include <tools/debug.hxx>
+#endif
+#ifndef _URLOBJ_HXX
+#include <tools/urlobj.hxx>
+#endif
+#ifndef _COM_SUN_STAR_FRAME_XSTORABLE_HPP_
+#include <com/sun/star/frame/XStorable.hpp>
+#endif
+#ifndef _COM_SUN_STAR_FRAME_XMODEL_HPP_
+#include <com/sun/star/frame/XModel.hpp>
+#endif
+#ifndef _COM_SUN_STAR_LINGUISTIC_XDICTIONARYSUPPLIER_HPP_
+#include <com/sun/star/linguistic/XDictionarySupplier.hpp>
+#endif
+#ifndef _COM_SUN_STAR_LANG_XEVENTLISTENER_HPP_
+#include <com/sun/star/lang/XEventListener.hpp>
+#endif
+#ifndef _UNOTOOLS_PROCESSFACTORY_HXX_
+#include <unotools/processfactory.hxx>
+#endif
+
+#ifndef _CPPUHELPER_IMPLBASE1_HXX_
+#include <cppuhelper/implbase1.hxx> // helper for implementations
+#endif
+
+#ifndef _ISOLANG_HXX
+#include <tools/isolang.hxx>
+#endif
+#ifndef _SV_MSGBOX_HXX
+#include <vcl/msgbox.hxx>
+#endif
+#ifndef _SHL_HXX
+#include <tools/shl.hxx>
+#endif
+
+#ifndef _SVX_DIALMGR_HXX
+#include <dialmgr.hxx>
+#endif
+#include "dialogs.hrc"
+
+using namespace ::rtl;
+using namespace ::utl;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::linguistic;
+
+///////////////////////////////////////////////////////////////////////////
+
+typedef cppu::WeakImplHelper1 < XEventListener > LinguMgrAppExitLstnrBaseClass;
+
+class LinguMgrAppExitLstnr : public LinguMgrAppExitLstnrBaseClass
+{
+    Reference< XComponent >         xDesktop;
+
+public:
+    LinguMgrAppExitLstnr();
+    virtual ~LinguMgrAppExitLstnr();
+
+    virtual void    AtExit() = 0;
+
+
+    // lang::XEventListener
+    virtual void    SAL_CALL disposing(const EventObject& rSource)
+            throw( RuntimeException );
+};
+
+LinguMgrAppExitLstnr::LinguMgrAppExitLstnr()
+{
+    // add object to frame::Desktop EventListeners in order to properly call
+    // the AtExit function at appliction exit.
+
+    Reference< XMultiServiceFactory >  xMgr = getProcessServiceFactory();
+    if ( xMgr.is() )
+    {
+        xDesktop = Reference< XComponent > ( xMgr->createInstance(
+                OUString( RTL_CONSTASCII_USTRINGPARAM (
+                            "com.sun.star.frame.Desktop" ) ) ), UNO_QUERY ) ;
+        if (xDesktop.is())
+            xDesktop->addEventListener( this );
+    }
+}
+
+LinguMgrAppExitLstnr::~LinguMgrAppExitLstnr()
+{
+    if (xDesktop.is())
+    {
+        xDesktop->removeEventListener( this );
+        xDesktop = NULL;    //! release reference to desktop
+    }
+    DBG_ASSERT(!xDesktop.is(), "reference to desktop should be realeased");
+}
+
+void LinguMgrAppExitLstnr::disposing(const EventObject& rSource)
+        throw( RuntimeException )
+{
+    if (xDesktop.is()  &&  rSource.Source == xDesktop)
+    {
+        xDesktop->removeEventListener( this );
+        xDesktop = NULL;    //! release reference to desktop
+
+        AtExit();
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+class LinguMgrExitLstnr : public LinguMgrAppExitLstnr
+{
+public:
+    virtual void    AtExit();
+};
+
+void LinguMgrExitLstnr::AtExit()
+{
+    // release references
+    LinguMgr::xSpell        = 0;
+    LinguMgr::xHyph         = 0;
+    LinguMgr::xThes         = 0;
+    LinguMgr::xDicList      = 0;
+    LinguMgr::xProp         = 0;
+    LinguMgr::xIgnoreAll    = 0;
+    LinguMgr::xChangeAll    = 0;
+
+    LinguMgr::bExiting      = sal_True;
+
+    //TL:TODO: MBA fragen wie ich ohne Absturz hier meinen Speicher
+    //  wieder freibekomme...
+    //delete LinguMgr::pExitLstnr;
+    LinguMgr::pExitLstnr    = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+// static member initialization
+LinguMgrExitLstnr *             LinguMgr::pExitLstnr    = 0;
+sal_Bool                        LinguMgr::bExiting      = sal_False;
+Reference< XSpellChecker1 >     LinguMgr::xSpell        = 0;
+Reference< XHyphenator >        LinguMgr::xHyph         = 0;
+Reference< XThesaurus >         LinguMgr::xThes         = 0;
+Reference< XDictionaryList >    LinguMgr::xDicList      = 0;
+Reference< XPropertySet >       LinguMgr::xProp         = 0;
+Reference< XDictionary1 >       LinguMgr::xIgnoreAll    = 0;
+Reference< XDictionary1 >       LinguMgr::xChangeAll    = 0;
+
+Reference< XSpellChecker1 > LinguMgr::GetSpellChecker()
+{
+    return xSpell.is() ? xSpell : GetSpell();
+}
+
+Reference< XHyphenator > LinguMgr::GetHyphenator()
+{
+    return xHyph.is() ? xHyph : GetHyph();
+}
+
+Reference< XThesaurus > LinguMgr::GetThesaurus()
+{
+    return xThes.is() ? xThes : GetThes();
+}
+
+Reference< XDictionaryList > LinguMgr::GetDictionaryList()
+{
+    return xDicList.is() ? xDicList : GetDicList();
+}
+
+Reference< XPropertySet > LinguMgr::GetLinguPropertySet()
+{
+    return xProp.is() ? xProp : GetProp();
+}
+
+Reference< XDictionary1 > LinguMgr::GetStandardDic()
+{
+    //! don't hold reference to this
+    //! (it may be removed from dictionary list and needs to be
+    //! created empty if accessed again)
+    return GetStandard();
+}
+
+Reference< XDictionary1 > LinguMgr::GetIgnoreAllList()
+{
+    return xIgnoreAll.is() ? xIgnoreAll : GetIgnoreAll();
+}
+
+Reference< XDictionary1 > LinguMgr::GetChangeAllList()
+{
+    return xChangeAll.is() ? xChangeAll : GetChangeAll();
+}
+
+Reference< XSpellChecker1 > LinguMgr::GetSpell()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
+    if (xMgr.is())
+    {
+        xSpell = Reference< XSpellChecker1 > ( xMgr->createInstance(
+                    OUString::createFromAscii(
+                        "com.sun.star.linguistic.SpellChecker1") ), UNO_QUERY );
+        if (xSpell.is())
+            xSpell->setDictionaryList( GetDictionaryList() );
+    }
+    return xSpell;
+}
+
+Reference< XHyphenator > LinguMgr::GetHyph()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
+    if (xMgr.is())
+    {
+        xHyph = Reference< XHyphenator > ( xMgr->createInstance(
+                    OUString::createFromAscii(
+                        "com.sun.star.linguistic.Hyphenator1") ), UNO_QUERY );
+        if (xHyph.is())
+            xHyph->setDictionaryList( GetDictionaryList() );
+    }
+    return xHyph;
+}
+
+Reference< XThesaurus > LinguMgr::GetThes()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
+    if (xMgr.is())
+    {
+        xThes = Reference< XThesaurus > ( xMgr->createInstance(
+                    OUString::createFromAscii(
+                        "com.sun.star.linguistic.Thesaurus") ), UNO_QUERY );
+    }
+    return xThes;
+}
+
+Reference< XDictionaryList > LinguMgr::GetDicList()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
+    if (xMgr.is())
+    {
+        xDicList = Reference< XDictionaryList > ( xMgr->createInstance(
+                    OUString::createFromAscii(
+                        "com.sun.star.linguistic.DictionaryList") ), UNO_QUERY );
+    }
+    return xDicList;
+}
+
+Reference< XPropertySet > LinguMgr::GetProp()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
+    if (xMgr.is())
+    {
+        xProp = Reference< XPropertySet > ( xMgr->createInstance(
+                    OUString::createFromAscii(
+                        "com.sun.star.linguistic.LinguProperties") ), UNO_QUERY );
+    }
+    return xProp;
+}
+
+Reference< XDictionary1 > LinguMgr::GetIgnoreAll()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XDictionaryList >  xTmpDicList( GetDictionaryList() );
+    if (xTmpDicList.is())
+    {
+        xIgnoreAll = Reference< XDictionary1 > ( xTmpDicList->getDictionaryByName(
+                    OUString::createFromAscii("IgnoreAllList") ), UNO_QUERY );
+    }
+    return xIgnoreAll;
+}
+
+Reference< XDictionary1 > LinguMgr::GetChangeAll()
+{
+    if (bExiting)
+        return 0;
+
+    if (!pExitLstnr)
+        pExitLstnr = new LinguMgrExitLstnr;
+
+    Reference< XDictionarySupplier >  xSupplier( GetDictionaryList() , UNO_QUERY );
+    if (xSupplier.is())
+    {
+        xChangeAll = Reference< XDictionary1 > (
+                        xSupplier->createDictionary(
+                            OUString::createFromAscii("ChangeAllList"),
+                            SvxCreateLocale( LANGUAGE_NONE ),
+                            DictionaryType_NEGATIVE, String() ), UNO_QUERY );
+    }
+    return xChangeAll;
+}
+
+Reference< XDictionary1 > LinguMgr::GetStandard()
+{
+    // Tries to return a dictionary which may hold positive entries is
+    // persistent and not read-only.
+
+    if (bExiting)
+        return 0;
+
+    Reference< XDictionaryList >  xTmpDicList( GetDictionaryList() );
+    if (!xTmpDicList.is())
+        return NULL;
+
+    const OUString aDicName( RTL_CONSTASCII_USTRINGPARAM( "standard.dic" ) );
+    Reference< XDictionary1 >   xDic( xTmpDicList->getDictionaryByName( aDicName ),
+                                      UNO_QUERY );
+    Reference< XStorable >      xStor( xDic, UNO_QUERY );
+
+    if (   !(xDic.is() && xDic->getDictionaryType() != DictionaryType_NEGATIVE &&
+                xDic->getLanguage() == LANGUAGE_NONE)
+        || !(xStor.is() && xStor->hasLocation() && !xStor->isReadonly()) )
+    {
+        Reference< XDictionary >  xTmp;
+
+        Reference< XDictionarySupplier >  xSupplier( xTmpDicList, UNO_QUERY );
+        if (xSupplier.is())
+        {
+            // try to create standard dictionary
+            try
+            {
+                xTmp =  xSupplier->createDictionary( aDicName,
+                            SvxCreateLocale( LANGUAGE_NONE ),
+                            DictionaryType_POSITIVE,
+                            SvxGetDictionaryURL( aDicName, sal_True ) );
+            }
+            catch(...)
+            {
+            }
+        }
+
+        // add new dictionary to list
+        if (xTmp.is())
+            xTmpDicList->addDictionary( xTmp );
+        xDic = Reference< XDictionary1 > ( xTmp, UNO_QUERY );
+    }
+    DBG_ASSERT(xDic.is() && xDic->getDictionaryType() != DictionaryType_NEGATIVE,
+        "wrong dictionary type");
+
+    return xDic;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+Reference< XSpellChecker1 >  SvxGetSpellChecker()
+{
+    return LinguMgr::GetSpellChecker();
+}
+
+Reference< XHyphenator >  SvxGetHyphenator()
+{
+    return LinguMgr::GetHyphenator();
+}
+
+Reference< XThesaurus >  SvxGetThesaurus()
+{
+    return LinguMgr::GetThesaurus();
+}
+
+Reference< XDictionaryList >  SvxGetDictionaryList()
+{
+    return LinguMgr::GetDictionaryList();
+}
+
+Reference< XPropertySet >   SvxGetLinguPropertySet()
+{
+    return LinguMgr::GetLinguPropertySet();
+}
+
+//TL:TODO: remove argument or provide SvxGetIgnoreAllList with the same one
+Reference< XDictionary1 >  SvxGetOrCreatePosDic(
+        Reference< XDictionaryList >  xDicList )
+{
+    return LinguMgr::GetStandardDic();
+}
+
+Reference< XDictionary1 >  SvxGetIgnoreAllList()
+{
+    return LinguMgr::GetIgnoreAllList();
+}
+
+Reference< XDictionary1 >  SvxGetChangeAllList()
+{
+    return LinguMgr::GetChangeAllList();
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+#ifdef TL_NOTYET
+
+#ifndef _COM_SUN_STAR_LINGUISTIC2_XHYPHENATEDWORD_HPP_
+#include <com/sun/star/linguistic2/XHyphenatedWord.hpp>
+#endif
+
+SvxAlternativeSpelling SvxGetAltSpelling(
+        const ::com::sun::star::uno::Reference<
+            ::com::sun::star::linguistic2::XHyphenatedWord > & rHyphWord )
+{
+    SvxAlternativeSpelling aRes;
+    if (rHyphWord.is() && rHyphWord->isAlternativeSpelling())
+    {
+        OUString aWord( rHyphWord->getWord() ),
+                 aHyphenatedWord( rHyphWord->getHyphenatedWord() );
+        INT16   nHyphenationPos     = rHyphWord->getHyphenationPos(),
+                nHyphenPos          = rHyphWord->getHyphenPos();
+        const sal_Unicode *pWord    = aWord.getStr(),
+                          *pAltWord = aHyphenatedWord.getStr();
+
+        // at least char changes directly left or right to the hyphen
+        // should(!) be handled properly...
+        //! nHyphenationPos and nHyphenPos differ at most by 1 (see above)
+        //! Beware: eg "Schiffahrt" in German (pre spelling reform)
+        //! proves to be a bit nasty (nChgPosLeft and nChgPosRight overlap
+        //! to an extend.)
+
+        // find first different char from left
+        sal_Int32   nPosL    = 0,
+                    nAltPosL = 0;
+        for (INT16 i = 0 ;  pWord[ nPosL ] == pAltWord[ nAltPosL ];  nPosL++, nAltPosL++, i++)
+        {
+            // restrict changes area beginning to the right to
+            // the char immediately following the hyphen.
+            //! serves to insert the additional "f" in "Schiffahrt" at
+            //! position 5 rather than position 6.
+            if (i >= nHyphenationPos + 1)
+                break;
+        }
+
+        // find first different char from right
+        sal_Int32   nPosR    = aWord.getLength() - 1,
+                    nAltPosR = aHyphenatedWord.getLength() - 1;
+        for ( ;  nPosR >= nPosL  &&  nAltPosR >= nAltPosL
+                    &&  pWord[ nPosR ] == pAltWord[ nAltPosR ];
+              nPosR--, nAltPosR--)
+            ;
+
+        INT16   nChgLen = nPosR - nPosL + 1;
+        DBG_ASSERT( nChgLen >= 0, "nChgLen < 0");
+
+        sal_Int32 nTxtStart = nPosL;
+        sal_Int32 nTxtLen   = nAltPosL - nPosL + 1;
+        OUString aRplc( aHyphenatedWord.copy( nTxtStart, nTxtLen ) );
+
+        aRes.aReplacement       = aRplc;
+        aRes.nChangedPos        = nPosL;
+        aRes.nChangedLength     = nChgLen;
+        aRes.bIsAltSpelling     = TRUE;
+        aRes.xHyphWord          = rHyphWord;
+    }
+    return aRes;
+}
+#endif //TL_NOTYET
+
+///////////////////////////////////////////////////////////////////////////
+
+SvxDicListChgClamp::SvxDicListChgClamp( Reference< XDictionaryList >  &rxDicList ) :
+    xDicList    ( rxDicList )
+{
+    if (xDicList.is())
+    {
+        xDicList->beginCollectEvents();
+    }
+}
+
+SvxDicListChgClamp::~SvxDicListChgClamp()
+{
+    if (xDicList.is())
+    {
+        xDicList->endCollectEvents();
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+//! some code somewhere requires LANGUAGE_NONE to be the first entry!
+static const Language aLanguages[] =
+{
+    LANGUAGE_NONE,
+    LANGUAGE_GERMAN,
+    LANGUAGE_GERMAN_SWISS,
+    LANGUAGE_ENGLISH_US,
+    LANGUAGE_ENGLISH_UK,
+    LANGUAGE_FRENCH,
+    LANGUAGE_ITALIAN,
+    LANGUAGE_SPANISH,
+    LANGUAGE_PORTUGUESE,
+    LANGUAGE_DANISH,
+    LANGUAGE_DUTCH,
+    LANGUAGE_SWEDISH,
+    LANGUAGE_FINNISH,
+    LANGUAGE_NORWEGIAN_BOKMAL,
+    LANGUAGE_NORWEGIAN_NYNORSK,
+
+    // newly IPR supported languages
+    LANGUAGE_AFRIKAANS,
+    LANGUAGE_CATALAN,
+    LANGUAGE_CZECH,
+    LANGUAGE_GREEK,
+    LANGUAGE_HUNGARIAN,
+    LANGUAGE_POLISH,
+    LANGUAGE_PORTUGUESE_BRAZILIAN,
+    LANGUAGE_RUSSIAN
+};
+
+const Sequence< Language > & SvxGetSelectableLanguages()
+{
+    static const Sequence< Language >
+        aSeq( aLanguages, (sizeof(aLanguages) / sizeof(aLanguages[0])) );
+    return aSeq;
+}
+
+sal_Int32 SvxGetLanguagePos(const Sequence< Language > &rSeq, Language nLang)
+{
+    sal_Int32 nRes = -1;
+
+    sal_Int32 n = rSeq.getLength();
+    const Language *pLang = rSeq.getConstArray();
+    for (sal_Int32 i = 0;  i < n;  i++)
+        if (pLang[i] == nLang)
+        {
+            nRes = i;
+            break;
+        }
+
+    return nRes;
+}
+
+String SvxGetDictionaryURL(const String &rDicName, sal_Bool bIsUserDic)
+{
+    // get directory to use
+    SfxIniManager  *pIniMgr = SfxIniManager::Get();
+    sal_uInt16 nSfxIniKey = bIsUserDic ?
+            SFX_KEY_USERDICTIONARY_DIR : SFX_KEY_DICTIONARY_PATH;
+    String aDirName ( pIniMgr->Get( nSfxIniKey ) );
+
+    INetURLObject aURLObj;
+    aURLObj.SetSmartProtocol( INET_PROT_FILE );
+    aURLObj.SetSmartURL( aDirName );
+    DBG_ASSERT(!aURLObj.HasError(), "lng : invalid URL");
+    aURLObj.Append( rDicName );
+    DBG_ASSERT(!aURLObj.HasError(), "lng : invalid URL");
+
+    return aURLObj.GetMainURL();
+}
+
+//TL:TODO: soll mal den rictigen R�ckgabetyp bekommen!
+sal_Bool SvxAddEntryToDic(
+        Reference< XDictionary >  &rxDic,
+        const OUString &rWord, sal_Bool bIsNeg,
+        const OUString &rRplcTxt, sal_Int16 nRplcLang,
+        sal_Bool bStripDot )
+{
+    if (!rxDic.is())
+        return DIC_ERR_NOT_EXISTS;
+
+    OUString aTmp( rWord );
+    if (bStripDot)
+    {
+        sal_Int32 nLen = rWord.getLength();
+        if (nLen > 0  &&  '.' == rWord[ nLen - 1])
+        {
+            // remove trailing '.'
+            // (this is the official way to do this :-( )
+            aTmp = aTmp.copy( 0, nLen - 1 );
+        }
+    }
+    sal_Bool bAddOk = rxDic->add( aTmp, bIsNeg, rRplcTxt,
+                                  SvxCreateLocale( nRplcLang ) );
+
+    sal_Int16 nRes = DIC_ERR_NONE;
+    if (!bAddOk)
+    {
+        if (rxDic->isFull())
+            nRes = DIC_ERR_FULL;
+        else
+        {
+            Reference< XStorable >  xStor( rxDic, UNO_QUERY );
+            if (xStor.is() && xStor->isReadonly())
+                nRes = DIC_ERR_READONLY;
+            else
+                nRes = DIC_ERR_UNKNOWN;
+        }
+    }
+
+    return nRes;
+}
+
+short SvxDicError( Window *pParent, sal_Int16 nError )
+{
+    short nRes = 0;
+    if (DIC_ERR_NONE != nError)
+    {
+        int nRid;
+        switch (nError)
+        {
+            case DIC_ERR_FULL     : nRid = RID_SVXSTR_DIC_ERR_FULL;  break;
+            case DIC_ERR_READONLY : nRid = RID_SVXSTR_DIC_ERR_READONLY;  break;
+            default:
+                nRid = RID_SVXSTR_DIC_ERR_UNKNOWN;
+                DBG_ASSERT(0, "unexpected case");
+        }
+        nRes = InfoBox( pParent, SVX_RESSTR( nRid ) ).Execute();
+    }
+    return nRes;
+}
+
+sal_Bool SvxSaveDictionaries( const Reference< XDictionaryList >  &xDicList )
+{
+    if (!xDicList.is())
+        return sal_True;
+
+    sal_Bool bRet = sal_True;
+
+    Sequence< Reference< XDictionary >  > aDics( xDicList->getDictionaries() );
+    const Reference< XDictionary >  *pDic = aDics.getConstArray();
+    sal_Int16 nCount = aDics.getLength();
+    for (sal_Int16 i = 0;  i < nCount;  i++)
+    {
+        try
+        {
+            Reference< XStorable >  xStor( pDic[i], UNO_QUERY );
+            if (xStor.is())
+            {
+                if (!xStor->isReadonly() && xStor->hasLocation())
+                    xStor->store();
+            }
+        }
+        catch(...)
+        {
+            bRet = sal_False;
+        }
+    }
+
+    return bRet;
+}
+
+LanguageType SvxLocaleToLanguage( const Locale& rLocale )
+{
+    //  empty language -> LANGUAGE_NONE
+    if ( rLocale.Language.getLength() == 0 )
+        return LANGUAGE_NONE;
+
+    String aLangStr = rLocale.Language;
+    String aCtryStr = rLocale.Country;
+    //  Variant is ignored
+
+    LanguageType eRet = ConvertIsoNamesToLanguage( aLangStr, aCtryStr );
+    if ( eRet == LANGUAGE_SYSTEM )
+        eRet = LANGUAGE_NONE;
+
+    return eRet;
+}
+
+Locale& SvxLanguageToLocale( Locale& rLocale, LanguageType eLang )
+{
+    String aLangStr, aCtryStr;
+    if ( eLang == LANGUAGE_NONE )
+        eLang = LANGUAGE_SYSTEM;
+    ConvertLanguageToIsoNames( eLang, aLangStr, aCtryStr );
+    rLocale.Language = aLangStr;
+    rLocale.Country  = aCtryStr;
+
+    return rLocale;
+}
+
+Locale SvxCreateLocale( LanguageType eLang )
+{
+    if ( eLang == LANGUAGE_NONE )
+        eLang = LANGUAGE_SYSTEM;
+    String aLangStr, aCtryStr;
+    ConvertLanguageToIsoNames( eLang, aLangStr, aCtryStr );
+
+    return Locale( aLangStr, aCtryStr, String() );
+}
+
+