Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 798 insertions, 0 deletions

diff --git a/linguistic/source/misc.cxx b/linguistic/source/misc.cxx
new file mode 100644
index 000000000..87cdb0272
--- /dev/null
+++ b/linguistic/source/misc.cxx
@@ -0,0 +1,798 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file754
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <sal/log.hxx>
+#include <svl/lngmisc.hxx>
+#include <ucbhelper/content.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XFastPropertySet.hpp>
+#include <com/sun/star/beans/PropertyValues.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/linguistic2/DictionaryType.hpp>
+#include <com/sun/star/linguistic2/DictionaryList.hpp>
+#include <com/sun/star/linguistic2/LinguProperties.hpp>
+#include <com/sun/star/ucb/XCommandEnvironment.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequence.hxx>
+#include <unotools/charclass.hxx>
+#include <unotools/linguprops.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <svtools/strings.hrc>
+#include <unotools/resmgr.hxx>
+
+#include <rtl/instance.hxx>
+
+#include <linguistic/misc.hxx>
+#include <linguistic/hyphdta.hxx>
+
+using namespace osl;
+using namespace com::sun::star;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::i18n;
+using namespace com::sun::star::linguistic2;
+
+namespace linguistic
+{
+
+namespace {
+
+//!! multi-thread safe mutex for all platforms !!
+struct LinguMutex : public rtl::Static< osl::Mutex, LinguMutex >
+{
+};
+
+}
+
+osl::Mutex &    GetLinguMutex()
+{
+    return LinguMutex::get();
+}
+
+const LocaleDataWrapper & GetLocaleDataWrapper( LanguageType nLang )
+{
+    static LocaleDataWrapper aLclDtaWrp( SvtSysLocale().GetLanguageTag() );
+
+    if (nLang != aLclDtaWrp.getLoadedLanguageTag().getLanguageType())
+        aLclDtaWrp.setLanguageTag( LanguageTag( nLang ) );
+    return aLclDtaWrp;
+}
+
+LanguageType LinguLocaleToLanguage( const css::lang::Locale& rLocale )
+{
+    if ( rLocale.Language.isEmpty() )
+        return LANGUAGE_NONE;
+    return LanguageTag::convertToLanguageType( rLocale );
+}
+
+css::lang::Locale LinguLanguageToLocale( LanguageType nLanguage )
+{
+    if (nLanguage == LANGUAGE_NONE)
+        return css::lang::Locale();
+    return LanguageTag::convertToLocale( nLanguage);
+}
+
+bool LinguIsUnspecified( LanguageType nLanguage )
+{
+    return nLanguage.anyOf(
+         LANGUAGE_NONE,
+         LANGUAGE_UNDETERMINED,
+         LANGUAGE_MULTIPLE);
+}
+
+// When adding anything keep both LinguIsUnspecified() methods in sync!
+// For mappings between language code string and LanguageType see
+// i18nlangtag/source/isolang/isolang.cxx
+
+bool LinguIsUnspecified( const OUString & rBcp47 )
+{
+    if (rBcp47.getLength() != 3)
+        return false;
+    return rBcp47 == "zxx" || rBcp47 == "und" || rBcp47 == "mul";
+}
+
+static sal_Int32 Minimum( sal_Int32 n1, sal_Int32 n2, sal_Int32 n3 )
+{
+    return std::min(std::min(n1, n2), n3);
+}
+
+namespace {
+
+class IntArray2D
+{
+private:
+    std::unique_ptr<sal_Int32[]>  pData;
+    int                           n1, n2;
+
+public:
+    IntArray2D( int nDim1, int nDim2 );
+
+    sal_Int32 & Value( int i, int k  );
+};
+
+}
+
+IntArray2D::IntArray2D( int nDim1, int nDim2 )
+{
+    n1 = nDim1;
+    n2 = nDim2;
+    pData.reset( new sal_Int32[n1 * n2] );
+}
+
+sal_Int32 & IntArray2D::Value( int i, int k  )
+{
+    assert( (0 <= i && i < n1) && "first index out of range" );
+    assert( (0 <= k && k < n2) && "second index out of range" );
+    assert( (i * n2 + k < n1 * n2) && "index out of range" );
+    return pData[ i * n2 + k ];
+}
+
+sal_Int32 LevDistance( const OUString &rTxt1, const OUString &rTxt2 )
+{
+    sal_Int32 nLen1 = rTxt1.getLength();
+    sal_Int32 nLen2 = rTxt2.getLength();
+
+    if (nLen1 == 0)
+        return nLen2;
+    if (nLen2 == 0)
+        return nLen1;
+
+    IntArray2D aData( nLen1 + 1, nLen2 + 1 );
+
+    sal_Int32 i, k;
+    for (i = 0;  i <= nLen1;  ++i)
+        aData.Value(i, 0) = i;
+    for (k = 0;  k <= nLen2;  ++k)
+        aData.Value(0, k) = k;
+    for (i = 1;  i <= nLen1;  ++i)
+    {
+        for (k = 1;  k <= nLen2;  ++k)
+        {
+            sal_Unicode c1i = rTxt1[i - 1];
+            sal_Unicode c2k = rTxt2[k - 1];
+            sal_Int32 nCost = c1i == c2k ? 0 : 1;
+            sal_Int32 nNew = Minimum( aData.Value(i-1, k  ) + 1,
+                                       aData.Value(i  , k-1) + 1,
+                                       aData.Value(i-1, k-1) + nCost );
+            // take transposition (exchange with left or right char) in account
+            if (2 < i && 2 < k)
+            {
+                int nT = aData.Value(i-2, k-2) + 1;
+                if (rTxt1[i - 2] != c1i)
+                    ++nT;
+                if (rTxt2[k - 2] != c2k)
+                    ++nT;
+                if (nT < nNew)
+                    nNew = nT;
+            }
+
+            aData.Value(i, k) = nNew;
+        }
+    }
+    sal_Int32 nDist = aData.Value(nLen1, nLen2);
+    return nDist;
+}
+
+bool IsUseDicList( const PropertyValues &rProperties,
+        const uno::Reference< XPropertySet > &rxProp )
+{
+    bool bRes = true;
+
+    const PropertyValue *pVal = std::find_if(rProperties.begin(), rProperties.end(),
+        [](const PropertyValue& rVal) { return UPH_IS_USE_DICTIONARY_LIST == rVal.Handle; });
+
+    if (pVal != rProperties.end())
+    {
+        pVal->Value >>= bRes;
+    }
+    else  // no temporary value found in 'rProperties'
+    {
+        uno::Reference< XFastPropertySet > xFast( rxProp, UNO_QUERY );
+        if (xFast.is())
+            xFast->getFastPropertyValue( UPH_IS_USE_DICTIONARY_LIST ) >>= bRes;
+    }
+
+    return bRes;
+}
+
+bool IsIgnoreControlChars( const PropertyValues &rProperties,
+        const uno::Reference< XPropertySet > &rxProp )
+{
+    bool bRes = true;
+
+    const PropertyValue *pVal = std::find_if(rProperties.begin(), rProperties.end(),
+        [](const PropertyValue& rVal) { return UPH_IS_IGNORE_CONTROL_CHARACTERS == rVal.Handle; });
+
+    if (pVal != rProperties.end())
+    {
+        pVal->Value >>= bRes;
+    }
+    else  // no temporary value found in 'rProperties'
+    {
+        uno::Reference< XFastPropertySet > xFast( rxProp, UNO_QUERY );
+        if (xFast.is())
+            xFast->getFastPropertyValue( UPH_IS_IGNORE_CONTROL_CHARACTERS ) >>= bRes;
+    }
+
+    return bRes;
+}
+
+static bool lcl_HasHyphInfo( const uno::Reference<XDictionaryEntry> &xEntry )
+{
+    bool bRes = false;
+    if (xEntry.is())
+    {
+        // there has to be (at least one) '=' or '[' denoting a hyphenation position
+        // and it must not be before any character of the word
+        sal_Int32 nIdx = xEntry->getDictionaryWord().indexOf( '=' );
+        if (nIdx == -1)
+            nIdx = xEntry->getDictionaryWord().indexOf( '[' );
+        bRes = nIdx != -1  &&  nIdx != 0;
+    }
+    return bRes;
+}
+
+uno::Reference< XDictionaryEntry > SearchDicList(
+        const uno::Reference< XSearchableDictionaryList > &xDicList,
+        const OUString &rWord, LanguageType nLanguage,
+        bool bSearchPosDics, bool bSearchSpellEntry )
+{
+    MutexGuard  aGuard( GetLinguMutex() );
+
+    uno::Reference< XDictionaryEntry > xEntry;
+
+    if (!xDicList.is())
+        return xEntry;
+
+    const uno::Sequence< uno::Reference< XDictionary > >
+            aDics( xDicList->getDictionaries() );
+    const uno::Reference< XDictionary >
+            *pDic = aDics.getConstArray();
+    sal_Int32 nDics = xDicList->getCount();
+
+    sal_Int32 i;
+    for (i = 0;  i < nDics;  i++)
+    {
+        uno::Reference< XDictionary > axDic = pDic[i];
+
+        DictionaryType  eType = axDic->getDictionaryType();
+        LanguageType    nLang = LinguLocaleToLanguage( axDic->getLocale() );
+
+        if ( axDic.is() && axDic->isActive()
+            && (nLang == nLanguage  ||  LinguIsUnspecified( nLang)) )
+        {
+            // DictionaryType_MIXED is deprecated
+            SAL_WARN_IF(eType == DictionaryType_MIXED, "linguistic", "unexpected dictionary type");
+
+            if (   (!bSearchPosDics  &&  eType == DictionaryType_NEGATIVE)
+                || ( bSearchPosDics  &&  eType == DictionaryType_POSITIVE))
+            {
+                xEntry = axDic->getEntry( rWord );
+                if ( xEntry.is() && (bSearchSpellEntry || lcl_HasHyphInfo( xEntry )) )
+                    break;
+                xEntry = nullptr;
+            }
+        }
+    }
+
+    return xEntry;
+}
+
+bool SaveDictionaries( const uno::Reference< XSearchableDictionaryList > &xDicList )
+{
+    if (!xDicList.is())
+        return true;
+
+    bool bRet = true;
+
+    const Sequence< uno::Reference< XDictionary >  > aDics( xDicList->getDictionaries() );
+    for (const uno::Reference<XDictionary>& rDic : aDics)
+    {
+        try
+        {
+            uno::Reference< frame::XStorable >  xStor( rDic, UNO_QUERY );
+            if (xStor.is())
+            {
+                if (!xStor->isReadonly() && xStor->hasLocation())
+                    xStor->store();
+            }
+        }
+        catch(uno::Exception &)
+        {
+            bRet = false;
+        }
+    }
+
+    return bRet;
+}
+
+DictionaryError AddEntryToDic(
+        uno::Reference< XDictionary > const &rxDic,
+        const OUString &rWord, bool bIsNeg,
+        const OUString &rRplcTxt,
+        bool bStripDot )
+{
+    if (!rxDic.is())
+        return DictionaryError::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 );
+        }
+    }
+    bool bAddOk = rxDic->add( aTmp, bIsNeg, rRplcTxt );
+
+    DictionaryError nRes = DictionaryError::NONE;
+    if (!bAddOk)
+    {
+        if (rxDic->isFull())
+            nRes = DictionaryError::FULL;
+        else
+        {
+            uno::Reference< frame::XStorable >  xStor( rxDic, UNO_QUERY );
+            if (xStor.is() && xStor->isReadonly())
+                nRes = DictionaryError::READONLY;
+            else
+                nRes = DictionaryError::UNKNOWN;
+        }
+    }
+
+    return nRes;
+}
+
+std::vector< LanguageType >
+    LocaleSeqToLangVec( uno::Sequence< Locale > const &rLocaleSeq )
+{
+    std::vector< LanguageType >   aLangs;
+    aLangs.reserve(rLocaleSeq.getLength());
+
+    std::transform(rLocaleSeq.begin(), rLocaleSeq.end(), std::back_inserter(aLangs),
+        [](const Locale& rLocale) { return LinguLocaleToLanguage(rLocale); });
+
+    return aLangs;
+}
+
+uno::Sequence< sal_Int16 >
+     LocaleSeqToLangSeq( uno::Sequence< Locale > const &rLocaleSeq )
+{
+    std::vector<sal_Int16> aLangs;
+    aLangs.reserve(rLocaleSeq.getLength());
+
+    std::transform(rLocaleSeq.begin(), rLocaleSeq.end(), std::back_inserter(aLangs),
+        [](const Locale& rLocale) { return static_cast<sal_uInt16>(LinguLocaleToLanguage(rLocale)); });
+
+    return comphelper::containerToSequence(aLangs);
+}
+bool    IsReadOnly( const OUString &rURL, bool *pbExist )
+{
+    bool bRes = false;
+    bool bExists = false;
+
+    if (!rURL.isEmpty())
+    {
+        try
+        {
+            uno::Reference< css::ucb::XCommandEnvironment > xCmdEnv;
+            ::ucbhelper::Content aContent( rURL, xCmdEnv, comphelper::getProcessComponentContext() );
+
+            bExists = aContent.isDocument();
+            if (bExists)
+            {
+                Any aAny( aContent.getPropertyValue( "IsReadOnly" ) );
+                aAny >>= bRes;
+            }
+        }
+        catch (Exception &)
+        {
+            bRes = true;
+        }
+    }
+
+    if (pbExist)
+        *pbExist = bExists;
+    return bRes;
+}
+
+static bool GetAltSpelling( sal_Int16 &rnChgPos, sal_Int16 &rnChgLen, OUString &rRplc,
+        uno::Reference< XHyphenatedWord > const &rxHyphWord )
+{
+    bool bRes = rxHyphWord->isAlternativeSpelling();
+    if (bRes)
+    {
+        OUString aWord( rxHyphWord->getWord() ),
+                 aHyphenatedWord( rxHyphWord->getHyphenatedWord() );
+        sal_Int16   nHyphenationPos     = rxHyphWord->getHyphenationPos();
+        /*sal_Int16   nHyphenPos          = rxHyphWord->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 (sal_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--)
+            ;
+
+        rnChgPos = sal::static_int_cast< sal_Int16 >(nPosL);
+        rnChgLen = sal::static_int_cast< sal_Int16 >(nAltPosR - nPosL);
+        assert( rnChgLen >= 0 && "nChgLen < 0");
+
+        sal_Int32 nTxtStart = nPosL;
+        sal_Int32 nTxtLen   = nAltPosR - nPosL + 1;
+        rRplc = aHyphenatedWord.copy( nTxtStart, nTxtLen );
+    }
+    return bRes;
+}
+
+static sal_Int16 GetOrigWordPos( const OUString &rOrigWord, sal_Int16 nPos )
+{
+    sal_Int32 nLen = rOrigWord.getLength();
+    sal_Int32 i = -1;
+    while (nPos >= 0  &&  i++ < nLen)
+    {
+        sal_Unicode cChar = rOrigWord[i];
+        bool bSkip = IsHyphen( cChar ) || IsControlChar( cChar );
+        if (!bSkip)
+            --nPos;
+    }
+    return sal::static_int_cast< sal_Int16 >((0 <= i  &&  i < nLen) ? i : -1);
+}
+
+sal_Int32 GetPosInWordToCheck( const OUString &rTxt, sal_Int32 nPos )
+{
+    sal_Int32 nRes = -1;
+    sal_Int32 nLen = rTxt.getLength();
+    if (0 <= nPos  &&  nPos < nLen)
+    {
+        nRes = 0;
+        for (sal_Int32 i = 0;  i < nPos;  ++i)
+        {
+            sal_Unicode cChar = rTxt[i];
+            bool bSkip = IsHyphen( cChar ) || IsControlChar( cChar );
+            if (!bSkip)
+                ++nRes;
+        }
+    }
+    return nRes;
+}
+
+uno::Reference< XHyphenatedWord > RebuildHyphensAndControlChars(
+        const OUString &rOrigWord,
+        uno::Reference< XHyphenatedWord > const &rxHyphWord )
+{
+    uno::Reference< XHyphenatedWord > xRes;
+    if (!rOrigWord.isEmpty() && rxHyphWord.is())
+    {
+        sal_Int16    nChgPos = 0,
+                 nChgLen = 0;
+        OUString aRplc;
+        bool bAltSpelling = GetAltSpelling( nChgPos, nChgLen, aRplc, rxHyphWord );
+
+        OUString aOrigHyphenatedWord;
+        sal_Int16 nOrigHyphenPos        = -1;
+        sal_Int16 nOrigHyphenationPos   = -1;
+        if (!bAltSpelling)
+        {
+            aOrigHyphenatedWord = rOrigWord;
+            nOrigHyphenPos      = GetOrigWordPos( rOrigWord, rxHyphWord->getHyphenPos() );
+            nOrigHyphenationPos = GetOrigWordPos( rOrigWord, rxHyphWord->getHyphenationPos() );
+        }
+        else
+        {
+            //! should at least work with the German words
+            //! B-"u-c-k-er and Sc-hif-fah-rt
+
+            OUString aLeft, aRight;
+            sal_Int16 nPos = GetOrigWordPos( rOrigWord, nChgPos );
+
+            // get words like Sc-hif-fah-rt to work correct
+            sal_Int16 nHyphenationPos = rxHyphWord->getHyphenationPos();
+            if (nChgPos > nHyphenationPos)
+                --nPos;
+
+            aLeft = rOrigWord.copy( 0, nPos );
+            aRight = rOrigWord.copy( nPos ); // FIXME: changes at the right side
+
+            aOrigHyphenatedWord =  aLeft + aRplc + aRight;
+
+            nOrigHyphenPos      = sal::static_int_cast< sal_Int16 >(aLeft.getLength() +
+                                  rxHyphWord->getHyphenPos() - nChgPos);
+            nOrigHyphenationPos = GetOrigWordPos( rOrigWord, nHyphenationPos );
+        }
+
+        if (nOrigHyphenPos == -1  ||  nOrigHyphenationPos == -1)
+        {
+            SAL_WARN( "linguistic", "failed to get nOrigHyphenPos or nOrigHyphenationPos" );
+        }
+        else
+        {
+            LanguageType nLang = LinguLocaleToLanguage( rxHyphWord->getLocale() );
+            xRes = new HyphenatedWord(
+                        rOrigWord, nLang, nOrigHyphenationPos,
+                        aOrigHyphenatedWord, nOrigHyphenPos );
+        }
+
+    }
+    return xRes;
+}
+
+static CharClass & lcl_GetCharClass()
+{
+    static CharClass aCC( LanguageTag( LANGUAGE_ENGLISH_US ));
+    return aCC;
+}
+
+static osl::Mutex & lcl_GetCharClassMutex()
+{
+    static osl::Mutex   aMutex;
+    return aMutex;
+}
+
+bool IsUpper( const OUString &rText, sal_Int32 nPos, sal_Int32 nLen, LanguageType nLanguage )
+{
+    MutexGuard  aGuard( lcl_GetCharClassMutex() );
+
+    CharClass &rCC = lcl_GetCharClass();
+    rCC.setLanguageTag( LanguageTag( nLanguage ));
+    sal_Int32 nFlags = rCC.getStringType( rText, nPos, nLen );
+    return      (nFlags & KCharacterType::UPPER)
+            && !(nFlags & KCharacterType::LOWER);
+}
+
+CapType capitalType(const OUString& aTerm, CharClass const * pCC)
+{
+        sal_Int32 tlen = aTerm.getLength();
+        if (pCC && tlen)
+        {
+            sal_Int32 nc = 0;
+            for (sal_Int32 tindex = 0; tindex < tlen; ++tindex)
+            {
+                if (pCC->getCharacterType(aTerm,tindex) &
+                   css::i18n::KCharacterType::UPPER) nc++;
+            }
+
+            if (nc == 0)
+                return CapType::NOCAP;
+            if (nc == tlen)
+                return CapType::ALLCAP;
+            if ((nc == 1) && (pCC->getCharacterType(aTerm,0) &
+                  css::i18n::KCharacterType::UPPER))
+                return CapType::INITCAP;
+
+            return CapType::MIXED;
+        }
+        return CapType::UNKNOWN;
+}
+
+OUString ToLower( const OUString &rText, LanguageType nLanguage )
+{
+    MutexGuard  aGuard( lcl_GetCharClassMutex() );
+
+    CharClass &rCC = lcl_GetCharClass();
+    rCC.setLanguageTag( LanguageTag( nLanguage ));
+    return rCC.lowercase( rText );
+}
+
+// sorted(!) array of unicode ranges for code points that are exclusively(!) used as numbers
+// and thus may NOT not be part of names or words like the Chinese/Japanese number characters
+static const sal_uInt32 the_aDigitZeroes [] =
+{
+    0x00000030, //0039    ; Decimal # Nd  [10] DIGIT ZERO..DIGIT NINE
+    0x00000660, //0669    ; Decimal # Nd  [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
+    0x000006F0, //06F9    ; Decimal # Nd  [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE
+    0x000007C0, //07C9    ; Decimal # Nd  [10] NKO DIGIT ZERO..NKO DIGIT NINE
+    0x00000966, //096F    ; Decimal # Nd  [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
+    0x000009E6, //09EF    ; Decimal # Nd  [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE
+    0x00000A66, //0A6F    ; Decimal # Nd  [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
+    0x00000AE6, //0AEF    ; Decimal # Nd  [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
+    0x00000B66, //0B6F    ; Decimal # Nd  [10] ODIA DIGIT ZERO..ODIA DIGIT NINE
+    0x00000BE6, //0BEF    ; Decimal # Nd  [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+    0x00000C66, //0C6F    ; Decimal # Nd  [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+    0x00000CE6, //0CEF    ; Decimal # Nd  [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
+    0x00000D66, //0D6F    ; Decimal # Nd  [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE
+    0x00000E50, //0E59    ; Decimal # Nd  [10] THAI DIGIT ZERO..THAI DIGIT NINE
+    0x00000ED0, //0ED9    ; Decimal # Nd  [10] LAO DIGIT ZERO..LAO DIGIT NINE
+    0x00000F20, //0F29    ; Decimal # Nd  [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE
+    0x00001040, //1049    ; Decimal # Nd  [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
+    0x00001090, //1099    ; Decimal # Nd  [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE
+    0x000017E0, //17E9    ; Decimal # Nd  [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+    0x00001810, //1819    ; Decimal # Nd  [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE
+    0x00001946, //194F    ; Decimal # Nd  [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
+    0x000019D0, //19D9    ; Decimal # Nd  [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE
+    0x00001B50, //1B59    ; Decimal # Nd  [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE
+    0x00001BB0, //1BB9    ; Decimal # Nd  [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE
+    0x00001C40, //1C49    ; Decimal # Nd  [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+    0x00001C50, //1C59    ; Decimal # Nd  [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE
+    0x0000A620, //A629    ; Decimal # Nd  [10] VAI DIGIT ZERO..VAI DIGIT NINE
+    0x0000A8D0, //A8D9    ; Decimal # Nd  [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE
+    0x0000A900, //A909    ; Decimal # Nd  [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE
+    0x0000AA50, //AA59    ; Decimal # Nd  [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+    0x0000FF10, //FF19    ; Decimal # Nd  [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE
+    0x000104A0, //104A9   ; Decimal # Nd  [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE
+    0x0001D7CE  //1D7FF   ; Decimal # Nd  [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
+};
+
+bool HasDigits( const OUString &rText )
+{
+    const sal_Int32 nLen = rText.getLength();
+
+    sal_Int32 i = 0;
+    while (i < nLen) // for all characters ...
+    {
+        const sal_uInt32 nCodePoint = rText.iterateCodePoints( &i );    // handle unicode surrogates correctly...
+        for (unsigned int nDigitZero : the_aDigitZeroes)   // ... check in all 0..9 ranges
+        {
+            if (nDigitZero > nCodePoint)
+                break;
+            if (/*nDigitZero <= nCodePoint &&*/ nCodePoint <= nDigitZero + 9)
+                return true;
+        }
+    }
+    return false;
+}
+
+bool IsNumeric( const OUString &rText )
+{
+    bool bRes = false;
+    if (!rText.isEmpty())
+    {
+        sal_Int32 nLen = rText.getLength();
+        bRes = true;
+        for(sal_Int32 i = 0; i < nLen; ++i)
+        {
+            sal_Unicode cChar = rText[ i ];
+            if ( !('0' <= cChar  &&  cChar <= '9') )
+            {
+                bRes = false;
+                break;
+            }
+        }
+    }
+    return bRes;
+}
+
+uno::Reference< XLinguProperties > GetLinguProperties()
+{
+    return LinguProperties::create( comphelper::getProcessComponentContext() );
+}
+
+uno::Reference< XSearchableDictionaryList > GetDictionaryList()
+{
+    uno::Reference< XComponentContext > xContext( comphelper::getProcessComponentContext() );
+    uno::Reference< XSearchableDictionaryList > xRef;
+    try
+    {
+        xRef = DictionaryList::create(xContext);
+    }
+    catch (const uno::Exception &)
+    {
+        SAL_WARN( "linguistic", "createInstance failed" );
+    }
+
+    return xRef;
+}
+
+uno::Reference< XDictionary > GetIgnoreAllList()
+{
+    uno::Reference< XDictionary > xRes;
+    uno::Reference< XSearchableDictionaryList > xDL( GetDictionaryList() );
+    if (xDL.is())
+    {
+        std::locale loc(Translate::Create("svt"));
+        xRes = xDL->getDictionaryByName( Translate::get(STR_DESCRIPTION_IGNOREALLLIST, loc) );
+    }
+    return xRes;
+}
+
+AppExitListener::AppExitListener()
+{
+    // add object to Desktop EventListeners in order to properly call
+    // the AtExit function at application exit.
+    uno::Reference< XComponentContext > xContext( comphelper::getProcessComponentContext() );
+
+    try
+    {
+        xDesktop = frame::Desktop::create(xContext);
+    }
+    catch (const uno::Exception &)
+    {
+        SAL_WARN( "linguistic", "createInstance failed" );
+    }
+}
+
+AppExitListener::~AppExitListener()
+{
+}
+
+void AppExitListener::Activate()
+{
+    if (xDesktop.is())
+        xDesktop->addTerminateListener( this );
+}
+
+void AppExitListener::Deactivate()
+{
+    if (xDesktop.is())
+        xDesktop->removeTerminateListener( this );
+}
+
+void SAL_CALL
+    AppExitListener::disposing( const EventObject& rEvtSource )
+{
+    MutexGuard  aGuard( GetLinguMutex() );
+
+    if (xDesktop.is()  &&  rEvtSource.Source == xDesktop)
+    {
+        xDesktop = nullptr;    //! release reference to desktop
+    }
+}
+
+void SAL_CALL
+    AppExitListener::queryTermination( const EventObject& /*rEvtSource*/ )
+{
+}
+
+void SAL_CALL
+    AppExitListener::notifyTermination( const EventObject& rEvtSource )
+{
+    MutexGuard  aGuard( GetLinguMutex() );
+
+    if (xDesktop.is()  &&  rEvtSource.Source == xDesktop)
+    {
+        AtExit();
+    }
+}
+
+}   // namespace linguistic
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */