/**************************************************************
 * 
 * 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 file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_linguistic.hxx"

#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/linguistic2/XSearchableDictionaryList.hpp>
#include <com/sun/star/linguistic2/SpellFailure.hpp>
#include <com/sun/star/registry/XRegistryKey.hpp>

#include <cppuhelper/factory.hxx>	// helper for factories
#include <unotools/localedatawrapper.hxx>
#include <unotools/processfactory.hxx>
#include <tools/debug.hxx>
#include <svl/lngmisc.hxx>
#include <osl/mutex.hxx>

#include <vector>

#include "spelldsp.hxx"
#include "linguistic/spelldta.hxx"
#include "lngsvcmgr.hxx"
#include "linguistic/lngprops.hxx"


using namespace utl;
using namespace osl;
using namespace rtl;
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::linguistic2;
using namespace linguistic;

///////////////////////////////////////////////////////////////////////////
// ProposalList: list of proposals for misspelled words
//   The order of strings in the array should be left unchanged because the
// spellchecker should have put the more likely suggestions at the top.
// New entries will be added to the end but duplicates are to be avoided.
// Removing entries is done by assigning the empty string.
// The sequence is constructed from all non empty strings in the original 
// while maintaining the order.
//
class ProposalList
{
    std::vector< OUString > aVec;

    sal_Bool    HasEntry( const OUString &rText ) const;

    // make copy c-tor and assignment operator private
    ProposalList( const ProposalList & );
    ProposalList & operator = ( const ProposalList & );

public:
    ProposalList()  {}

    //size_t  Size() const   { return aVec.size(); }
    size_t  Count() const;
    void    Prepend( const OUString &rText );
    void    Append( const OUString &rNew );
    void    Append( const std::vector< OUString > &rNew );
    void    Append( const Sequence< OUString > &rNew );
    void    Remove( const OUString &rText );
    Sequence< OUString >    GetSequence() const;
};


sal_Bool ProposalList::HasEntry( const OUString &rText ) const
{
    sal_Bool bFound = sal_False;
    size_t nCnt = aVec.size();
    for (size_t i = 0;  !bFound && i < nCnt;  ++i)
    {
        if (aVec[i] == rText)
            bFound = sal_True;
    }
    return bFound;
}

void ProposalList::Prepend( const OUString &rText )
{
    if (!HasEntry( rText ))
        aVec.insert( aVec.begin(), rText );
}

void ProposalList::Append( const OUString &rText )
{
    if (!HasEntry( rText ))
        aVec.push_back( rText );
}

void ProposalList::Append( const std::vector< OUString > &rNew )
{
    size_t nLen = rNew.size();
    for ( size_t i = 0;  i < nLen;  ++i)
    {
        const OUString &rText = rNew[i];
        if (!HasEntry( rText ))
            Append( rText );
    }
}

void ProposalList::Append( const Sequence< OUString > &rNew )
{
    sal_Int32 nLen = rNew.getLength();
    const OUString *pNew = rNew.getConstArray();
    for (sal_Int32 i = 0;  i < nLen;  ++i)
    {
        const OUString &rText = pNew[i];
        if (!HasEntry( rText ))
            Append( rText );
    }
}

size_t ProposalList::Count() const
{
    // returns the number of non-empty strings in the vector

    size_t nRes = 0;
    size_t nLen = aVec.size();
    for (size_t i = 0;  i < nLen;  ++i)
    {
        if (aVec[i].getLength() != 0)
            ++nRes;
    }
    return nRes;
}
 
Sequence< OUString > ProposalList::GetSequence() const
{
    sal_Int32 nCount = Count();
    sal_Int32 nIdx = 0;
    Sequence< OUString > aRes( nCount );
    OUString *pRes = aRes.getArray();
    sal_Int32 nLen = aVec.size();
    for (sal_Int32 i = 0;  i < nLen;  ++i)
    {
        const OUString &rText = aVec[i];
        DBG_ASSERT( nIdx < nCount, "index our of range" );
        if (nIdx < nCount && rText.getLength() > 0)
            pRes[ nIdx++ ] = rText;
    }
    return aRes;
}

void ProposalList::Remove( const OUString &rText )
{
    size_t nLen = aVec.size();
    for (size_t i = 0;  i < nLen;  ++i)
    {
        OUString &rEntry = aVec[i];
        if (rEntry == rText)
        {
            rEntry = OUString(); 
            break;  // there should be only one matching entry
        }
    }
}


///////////////////////////////////////////////////////////////////////////

sal_Bool SvcListHasLanguage( 
        const LangSvcEntries_Spell &rEntry, 
        LanguageType nLanguage )
{
    sal_Bool bHasLanguage = sal_False;
    Locale aTmpLocale;
    
    const Reference< XSpellChecker >  *pRef  = rEntry.aSvcRefs .getConstArray();
    sal_Int32 nLen = rEntry.aSvcRefs.getLength();
    for (sal_Int32 k = 0;  k < nLen  &&  !bHasLanguage;  ++k)
    {
        if (pRef[k].is())
        {
            if (0 == aTmpLocale.Language.getLength())
                aTmpLocale = CreateLocale( nLanguage );
            bHasLanguage = pRef[k]->hasLocale( aTmpLocale );
        }
    }
    
    return bHasLanguage;
}

///////////////////////////////////////////////////////////////////////////


SpellCheckerDispatcher::SpellCheckerDispatcher( LngSvcMgr &rLngSvcMgr ) :
	rMgr	(rLngSvcMgr)
{
    pCache = NULL;
}


SpellCheckerDispatcher::~SpellCheckerDispatcher()
{
	ClearSvcList();
    delete pCache;
}


void SpellCheckerDispatcher::ClearSvcList()
{
	// release memory for each table entry
    SpellSvcByLangMap_t aTmp;
    aSvcMap.swap( aTmp );
}


Sequence< Locale > SAL_CALL SpellCheckerDispatcher::getLocales()
		throw(RuntimeException)
{
	MutexGuard	aGuard( GetLinguMutex() );
    
    Sequence< Locale > aLocales( static_cast< sal_Int32 >(aSvcMap.size()) );
    Locale *pLocales = aLocales.getArray();
    SpellSvcByLangMap_t::const_iterator aIt;
    for (aIt = aSvcMap.begin();  aIt != aSvcMap.end();  ++aIt)
    {
        *pLocales++ = CreateLocale( aIt->first );
    }    
    return aLocales;
}


sal_Bool SAL_CALL SpellCheckerDispatcher::hasLocale( const Locale& rLocale )
		throw(RuntimeException)
{
	MutexGuard	aGuard( GetLinguMutex() );
    SpellSvcByLangMap_t::const_iterator aIt( aSvcMap.find( LocaleToLanguage( rLocale ) ) );
    return aIt != aSvcMap.end();
}


sal_Bool SAL_CALL
	SpellCheckerDispatcher::isValid( const OUString& rWord, const Locale& rLocale,
			const PropertyValues& rProperties )
		throw(IllegalArgumentException, RuntimeException)
{
	MutexGuard	aGuard( GetLinguMutex() );
    return isValid_Impl( rWord, LocaleToLanguage( rLocale ), rProperties, sal_True );
}


Reference< XSpellAlternatives > SAL_CALL
	SpellCheckerDispatcher::spell( const OUString& rWord, const Locale& rLocale,
			const PropertyValues& rProperties )
		throw(IllegalArgumentException, RuntimeException)
{
	MutexGuard	aGuard( GetLinguMutex() );
    return spell_Impl( rWord, LocaleToLanguage( rLocale ), rProperties, sal_True );
}


// returns the overall result of cross-checking with all user-dictionaries
// including the IgnoreAll list
static Reference< XDictionaryEntry > lcl_GetRulingDictionaryEntry(
    const OUString &rWord,
    LanguageType nLanguage )
{
    Reference< XDictionaryEntry > xRes;

    // the order of winning from top to bottom is:
    // 1) IgnoreAll list will always win
    // 2) Negative dictionaries will win over positive dictionaries
    Reference< XDictionary > xIgnoreAll( GetIgnoreAllList() );
    if (xIgnoreAll.is())
        xRes = xIgnoreAll->getEntry( rWord );
    if (!xRes.is())
    {
        Reference< XDictionaryList > xDList( GetDictionaryList() );
        Reference< XDictionaryEntry > xNegEntry( SearchDicList( xDList,
                rWord, nLanguage, sal_False, sal_True ) );
        if (xNegEntry.is())
            xRes = xNegEntry;
        else
        {
            Reference< XDictionaryEntry > xPosEntry( SearchDicList( xDList,
                    rWord, nLanguage, sal_True, sal_True ) );
            if (xPosEntry.is())
                xRes = xPosEntry;
        }
    }

    return xRes;
}


sal_Bool SpellCheckerDispatcher::isValid_Impl(
			const OUString& rWord, 
            LanguageType nLanguage, 
			const PropertyValues& rProperties,
			sal_Bool bCheckDics) 
		throw( RuntimeException, IllegalArgumentException )
{
	MutexGuard	aGuard( GetLinguMutex() );

	sal_Bool bRes =	sal_True;
	
	if (nLanguage == LANGUAGE_NONE  || !rWord.getLength())
		return bRes;
	
	// search for entry with that language
    SpellSvcByLangMap_t::iterator    aIt( aSvcMap.find( nLanguage ) );
    LangSvcEntries_Spell    *pEntry = aIt != aSvcMap.end() ? aIt->second.get() : NULL;
	
	if (!pEntry)
	{
#ifdef LINGU_EXCEPTIONS
		throw IllegalArgumentException();
#endif
	}
	else
	{
		OUString aChkWord( rWord );
        Locale aLocale( CreateLocale( nLanguage ) );

        // replace typographical apostroph by ascii apostroph
        String aSingleQuote( GetLocaleDataWrapper( nLanguage ).getQuotationMarkEnd() );
        DBG_ASSERT( 1 == aSingleQuote.Len(), "unexpectend length of quotation mark" );
        if (aSingleQuote.Len())
            aChkWord = aChkWord.replace( aSingleQuote.GetChar(0), '\'' );

		RemoveHyphens( aChkWord );
		if (IsIgnoreControlChars( rProperties, GetPropSet() ))
			RemoveControlChars( aChkWord );

		sal_Int32 nLen = pEntry->aSvcRefs.getLength();
		DBG_ASSERT( nLen == pEntry->aSvcImplNames.getLength(), 
				"lng : sequence length mismatch");
        DBG_ASSERT( pEntry->nLastTriedSvcIndex < nLen, 
				"lng : index out of range");

		sal_Int32 i = 0;
		sal_Bool bTmpRes = sal_True;
		sal_Bool bTmpResValid = sal_False;

		// try already instantiated services first
		{
			const Reference< XSpellChecker >  *pRef  = 
					pEntry->aSvcRefs.getConstArray();
            while (i <= pEntry->nLastTriedSvcIndex
                   &&  (!bTmpResValid  ||  sal_False == bTmpRes))
			{
				bTmpResValid = sal_True;
                if (pRef[i].is()  &&  pRef[i]->hasLocale( aLocale ))
				{
                    bTmpRes = GetCache().CheckWord( aChkWord, nLanguage );
					if (!bTmpRes)
					{
                        bTmpRes = pRef[i]->isValid( aChkWord, aLocale, rProperties );
						
						// Add correct words to the cache.
						// But not those that are correct only because of
						// the temporary supplied settings.
						if (bTmpRes  &&  0 == rProperties.getLength())
                            GetCache().AddWord( aChkWord, nLanguage );
					}
				}
				else
					bTmpResValid = sal_False;

				if (bTmpResValid)
					bRes = bTmpRes;

				++i;
			}
		}
		
		// if still no result instantiate new services and try those
		if ((!bTmpResValid  ||  sal_False == bTmpRes)
            &&  pEntry->nLastTriedSvcIndex < nLen - 1)
		{
			const OUString *pImplNames = pEntry->aSvcImplNames.getConstArray();
			Reference< XSpellChecker >  *pRef  = pEntry->aSvcRefs .getArray();
			
			Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
			if (xMgr.is())
			{
				// build service initialization argument
				Sequence< Any > aArgs(2);
				aArgs.getArray()[0] <<= GetPropSet();
				//! The dispatcher searches the dictionary-list
				//! thus the service needs not to now about it
				//aArgs.getArray()[1] <<= GetDicList();

				while (i < nLen  &&  (!bTmpResValid  ||  sal_False == bTmpRes))
				{
					// create specific service via it's implementation name
					Reference< XSpellChecker > xSpell;
					try
					{
						xSpell = Reference< XSpellChecker >( 
								xMgr->createInstanceWithArguments( 
								pImplNames[i], aArgs ),  UNO_QUERY );
					}
					catch (uno::Exception &)
					{
                        DBG_ASSERT( 0, "createInstanceWithArguments failed" );
					}
					pRef [i] = xSpell;
					
					Reference< XLinguServiceEventBroadcaster > 
							xBroadcaster( xSpell, UNO_QUERY );
					if (xBroadcaster.is())
						rMgr.AddLngSvcEvtBroadcaster( xBroadcaster );
					
					bTmpResValid = sal_True;			   
                    if (xSpell.is()  &&  xSpell->hasLocale( aLocale ))
					{
                        bTmpRes = GetCache().CheckWord( aChkWord, nLanguage );
						if (!bTmpRes)
						{
                            bTmpRes = xSpell->isValid( aChkWord, aLocale, rProperties );
							
							// Add correct words to the cache.
							// But not those that are correct only because of
							// the temporary supplied settings.
							if (bTmpRes  &&  0 == rProperties.getLength())
                                GetCache().AddWord( aChkWord, nLanguage );
						}
					}
					else
						bTmpResValid = sal_False;
				
					if (bTmpResValid)
						bRes = bTmpRes;

                    pEntry->nLastTriedSvcIndex = (sal_Int16) i;
					++i;
				}
                
                // if language is not supported by any of the services
                // remove it from the list.
                if (i == nLen)
                {
                    if (!SvcListHasLanguage( *pEntry, nLanguage ))
                        aSvcMap.erase( nLanguage );
                }
			}
		}
		
		// cross-check against results from dictionaries which have precedence!
		if (bCheckDics  &&  
			GetDicList().is()  &&  IsUseDicList( rProperties, GetPropSet() ))
		{
            Reference< XDictionaryEntry > xTmp( lcl_GetRulingDictionaryEntry( aChkWord, nLanguage ) );
            if (xTmp.is())
                bRes = !xTmp->isNegative();
		}
	}

	return bRes;
}


Reference< XSpellAlternatives > SpellCheckerDispatcher::spell_Impl( 
			const OUString& rWord, 
            LanguageType nLanguage,
			const PropertyValues& rProperties,
			sal_Bool bCheckDics ) 
		throw(IllegalArgumentException, RuntimeException)
{
	MutexGuard	aGuard( GetLinguMutex() );

	Reference< XSpellAlternatives > xRes;
	
	if (nLanguage == LANGUAGE_NONE  || !rWord.getLength())
		return xRes;
	
	// search for entry with that language
    SpellSvcByLangMap_t::iterator    aIt( aSvcMap.find( nLanguage ) );
    LangSvcEntries_Spell    *pEntry = aIt != aSvcMap.end() ? aIt->second.get() : NULL;
	
	if (!pEntry)
	{
#ifdef LINGU_EXCEPTIONS
		throw IllegalArgumentException();
#endif
	}
	else
	{
		OUString aChkWord( rWord );
        Locale aLocale( CreateLocale( nLanguage ) );

        // replace typographical apostroph by ascii apostroph
        String aSingleQuote( GetLocaleDataWrapper( nLanguage ).getQuotationMarkEnd() );
        DBG_ASSERT( 1 == aSingleQuote.Len(), "unexpectend length of quotation mark" );
        if (aSingleQuote.Len())
            aChkWord = aChkWord.replace( aSingleQuote.GetChar(0), '\'' );

        RemoveHyphens( aChkWord );
		if (IsIgnoreControlChars( rProperties, GetPropSet() ))
			RemoveControlChars( aChkWord );

		sal_Int32 nLen = pEntry->aSvcRefs.getLength();
		DBG_ASSERT( nLen == pEntry->aSvcImplNames.getLength(), 
				"lng : sequence length mismatch");
        DBG_ASSERT( pEntry->nLastTriedSvcIndex < nLen, 
				"lng : index out of range");

		sal_Int32 i = 0;
		Reference< XSpellAlternatives > xTmpRes;
		sal_Bool bTmpResValid = sal_False;

		// try already instantiated services first
		{
            const Reference< XSpellChecker >  *pRef  = pEntry->aSvcRefs.getConstArray();
            sal_Int32 nNumSugestions = -1;
            while (i <= pEntry->nLastTriedSvcIndex
				   &&  (!bTmpResValid || xTmpRes.is()) )
			{
				bTmpResValid = sal_True;
                if (pRef[i].is()  &&  pRef[i]->hasLocale( aLocale ))
				{
                    sal_Bool bOK = GetCache().CheckWord( aChkWord, nLanguage );
					if (bOK)
						xTmpRes = NULL;
					else
					{
                        xTmpRes = pRef[i]->spell( aChkWord, aLocale, rProperties );
						
						// Add correct words to the cache.
						// But not those that are correct only because of
						// the temporary supplied settings.
						if (!xTmpRes.is()  &&  0 == rProperties.getLength())
                            GetCache().AddWord( aChkWord, nLanguage );
					}
				}
				else
					bTmpResValid = sal_False;

                // return first found result if the word is not known by any checker.
                // But if that result has no suggestions use the first one that does 
                // provide suggestions for the misspelled word.
				if (!xRes.is() && bTmpResValid)
                {
					xRes = xTmpRes;
                    nNumSugestions = 0;
                    if (xRes.is())
                        nNumSugestions = xRes->getAlternatives().getLength();
                }
                sal_Int32 nTmpNumSugestions = 0;
                if (xTmpRes.is() && bTmpResValid)
                    nTmpNumSugestions = xTmpRes->getAlternatives().getLength();
                if (xRes.is() && nNumSugestions == 0 && nTmpNumSugestions > 0)
                {
                    xRes = xTmpRes;
                    nNumSugestions = nTmpNumSugestions;
                }    

				++i;
			}
		}
		
		// if still no result instantiate new services and try those
		if ((!bTmpResValid || xTmpRes.is())
            &&  pEntry->nLastTriedSvcIndex < nLen - 1)
		{
			const OUString *pImplNames = pEntry->aSvcImplNames.getConstArray();
			Reference< XSpellChecker >  *pRef  = pEntry->aSvcRefs .getArray();
			
			Reference< XMultiServiceFactory >  xMgr( getProcessServiceFactory() );
			if (xMgr.is())
			{
				// build service initialization argument
				Sequence< Any > aArgs(2);
				aArgs.getArray()[0] <<= GetPropSet();
				//! The dispatcher searches the dictionary-list
				//! thus the service needs not to now about it
				//aArgs.getArray()[1] <<= GetDicList();

                sal_Int32 nNumSugestions = -1;
				while (i < nLen  &&  (!bTmpResValid || xTmpRes.is()))
				{
					// create specific service via it's implementation name
					Reference< XSpellChecker > xSpell;
					try
					{
						xSpell = Reference< XSpellChecker >( 
								xMgr->createInstanceWithArguments( 
								pImplNames[i], aArgs ), UNO_QUERY );
					}
					catch (uno::Exception &)
					{
                        DBG_ASSERT( 0, "createInstanceWithArguments failed" );
					}
					pRef [i] = xSpell;
		
					Reference< XLinguServiceEventBroadcaster > 
							xBroadcaster( xSpell, UNO_QUERY );
					if (xBroadcaster.is())
						rMgr.AddLngSvcEvtBroadcaster( xBroadcaster );
					
					bTmpResValid = sal_True;			   
                    if (xSpell.is()  &&  xSpell->hasLocale( aLocale ))
					{
                        sal_Bool bOK = GetCache().CheckWord( aChkWord, nLanguage );
						if (bOK)
							xTmpRes = NULL;
						else
						{
                            xTmpRes = xSpell->spell( aChkWord, aLocale, rProperties );
							
							// Add correct words to the cache.
							// But not those that are correct only because of
							// the temporary supplied settings.
							if (!xTmpRes.is()  &&  0 == rProperties.getLength())
                                GetCache().AddWord( aChkWord, nLanguage );
						}
					}
					else
						bTmpResValid = sal_False;
				
                    // return first found result if the word is not known by any checker.
                    // But if that result has no suggestions use the first one that does 
                    // provide suggestions for the misspelled word.
                    if (!xRes.is() && bTmpResValid)
                    {
                        xRes = xTmpRes;
                        nNumSugestions = 0;
                        if (xRes.is())
                            nNumSugestions = xRes->getAlternatives().getLength();
                    }
                    sal_Int32 nTmpNumSugestions = 0;
                    if (xTmpRes.is() && bTmpResValid)
                        nTmpNumSugestions = xTmpRes->getAlternatives().getLength();
                    if (xRes.is() && nNumSugestions == 0 && nTmpNumSugestions > 0)
                    {
                        xRes = xTmpRes;
                        nNumSugestions = nTmpNumSugestions;
                    }    

                    pEntry->nLastTriedSvcIndex = (sal_Int16) i;
					++i;
				}

                // if language is not supported by any of the services
                // remove it from the list.
                if (i == nLen)
                {
                    if (!SvcListHasLanguage( *pEntry, nLanguage ))
                        aSvcMap.erase( nLanguage );
                }
			}
		}
		
		// if word is finally found to be correct
		// clear previously remembered alternatives
		if (bTmpResValid  &&  !xTmpRes.is())
			xRes = NULL;

        // list of proposals found (to be checked against entries of
        // neagtive dictionaries)
        ProposalList aProposalList;
//        Sequence< OUString > aProposals;
        sal_Int16 eFailureType = -1;	// no failure
        if (xRes.is())
        {
            aProposalList.Append( xRes->getAlternatives() );
//            aProposals = xRes->getAlternatives();
            eFailureType = xRes->getFailureType();
        }    
        Reference< XDictionaryList > xDList;
        if (GetDicList().is()  &&  IsUseDicList( rProperties, GetPropSet() ))
            xDList = Reference< XDictionaryList >( GetDicList(), UNO_QUERY );

		// cross-check against results from user-dictionaries which have precedence!
        if (bCheckDics  &&  xDList.is())
		{
            Reference< XDictionaryEntry > xTmp( lcl_GetRulingDictionaryEntry( aChkWord, nLanguage ) );
            if (xTmp.is())
            {
                if (xTmp->isNegative())    // positive entry found
                {
				    eFailureType = SpellFailure::IS_NEGATIVE_WORD;

                    // replacement text to be added to suggestions, if not empty
                    OUString aAddRplcTxt( xTmp->getReplacementText() );

                    // replacement text must not be in negative dictionary itself
                    if (aAddRplcTxt.getLength() &&
                        !SearchDicList( xDList, aAddRplcTxt, nLanguage, sal_False, sal_True ).is())
                    {
                        aProposalList.Prepend( aAddRplcTxt );
                    }
                }
                else    // positive entry found
                {
                    xRes = NULL;
                    eFailureType = -1;  // no failure
                }
            }
		}

        if (eFailureType != -1)     // word misspelled or found in negative user-dictionary
		{
            // search suitable user-dictionaries for suggestions that are
            // similar to the misspelled word
            std::vector< OUString > aDicListProps;   // list of proposals from user-dictionaries
            SearchSimilarText( aChkWord, nLanguage, xDList, aDicListProps );
            aProposalList.Append( aDicListProps );
            Sequence< OUString > aProposals = aProposalList.GetSequence();
            
            // remove entries listed in negative dictionaries
            // (we don't want to display suggestions that will be regarded as misspelledlater on)
            if (bCheckDics  &&  xDList.is())
                SeqRemoveNegEntries( aProposals, xDList, nLanguage );
            
            uno::Reference< linguistic2::XSetSpellAlternatives > xSetAlt( xRes, uno::UNO_QUERY );
            if (xSetAlt.is())
            {
                xSetAlt->setAlternatives( aProposals );
                xSetAlt->setFailureType( eFailureType );
            }
            else
            {
                if (xRes.is())
                {
                    DBG_ASSERT( 0, "XSetSpellAlternatives not implemented!" );
                }
                else if (aProposals.getLength() > 0)
                {
                    // no xRes but Proposals found from the user-dictionaries.
                    // Thus we need to create an xRes...
                    xRes = new linguistic::SpellAlternatives( rWord, nLanguage, 
                            SpellFailure::IS_NEGATIVE_WORD, aProposals );
                }
            }
		}
	}

	return xRes;
}

uno::Sequence< sal_Int16 > SAL_CALL SpellCheckerDispatcher::getLanguages(  ) 
throw (uno::RuntimeException)
{
    MutexGuard  aGuard( GetLinguMutex() );
    uno::Sequence< Locale > aTmp( getLocales() );
    uno::Sequence< sal_Int16 > aRes( LocaleSeqToLangSeq( aTmp ) );
    return aRes;
}

    
sal_Bool SAL_CALL SpellCheckerDispatcher::hasLanguage( 
    sal_Int16 nLanguage ) 
throw (uno::RuntimeException)
{
    MutexGuard  aGuard( GetLinguMutex() );
    Locale aLocale( CreateLocale( nLanguage ) );
    return hasLocale( aLocale );
}

    
sal_Bool SAL_CALL SpellCheckerDispatcher::isValid( 
    const OUString& rWord, 
    sal_Int16 nLanguage, 
    const uno::Sequence< beans::PropertyValue >& rProperties ) 
throw (lang::IllegalArgumentException, uno::RuntimeException)
{
    MutexGuard  aGuard( GetLinguMutex() );
    Locale aLocale( CreateLocale( nLanguage ) );
    return isValid( rWord, aLocale, rProperties);
}

    
uno::Reference< linguistic2::XSpellAlternatives > SAL_CALL SpellCheckerDispatcher::spell( 
    const OUString& rWord, 
    sal_Int16 nLanguage, 
    const uno::Sequence< beans::PropertyValue >& rProperties ) 
throw (lang::IllegalArgumentException, uno::RuntimeException)
{
    MutexGuard  aGuard( GetLinguMutex() );
    Locale aLocale( CreateLocale( nLanguage ) );
    return spell( rWord, aLocale, rProperties);
}

    
void SpellCheckerDispatcher::SetServiceList( const Locale &rLocale,
		const Sequence< OUString > &rSvcImplNames )
{
	MutexGuard	aGuard( GetLinguMutex() );

    if (pCache)
        pCache->Flush();    // new services may spell differently...

	sal_Int16 nLanguage = LocaleToLanguage( rLocale );

    sal_Int32 nLen = rSvcImplNames.getLength();
    if (0 == nLen)
        // remove entry
        aSvcMap.erase( nLanguage );
    else
    {
        // modify/add entry
        LangSvcEntries_Spell *pEntry = aSvcMap[ nLanguage ].get();
        if (pEntry)
        {
            pEntry->Clear();
            pEntry->aSvcImplNames = rSvcImplNames;
            pEntry->aSvcRefs = Sequence< Reference < XSpellChecker > > ( nLen );
        }
        else
        {
            boost::shared_ptr< LangSvcEntries_Spell > pTmpEntry( new LangSvcEntries_Spell( rSvcImplNames ) );
            pTmpEntry->aSvcRefs = Sequence< Reference < XSpellChecker > >( nLen );
            aSvcMap[ nLanguage ] = pTmpEntry;
        }
    }
}


Sequence< OUString > 
	SpellCheckerDispatcher::GetServiceList( const Locale &rLocale ) const
{
	MutexGuard	aGuard( GetLinguMutex() );
	
	Sequence< OUString > aRes;
	
	// search for entry with that language and use data from that
	sal_Int16 nLanguage = LocaleToLanguage( rLocale );
    SpellCheckerDispatcher          *pThis = (SpellCheckerDispatcher *) this;
    const SpellSvcByLangMap_t::iterator aIt( pThis->aSvcMap.find( nLanguage ) );
    const LangSvcEntries_Spell      *pEntry = aIt != aSvcMap.end() ? aIt->second.get() : NULL;
	if (pEntry)
		aRes = pEntry->aSvcImplNames;

	return aRes;
}


LinguDispatcher::DspType SpellCheckerDispatcher::GetDspType() const
{
	return DSP_SPELL;
}

void SpellCheckerDispatcher::FlushSpellCache()
{
    if (pCache)
        pCache->Flush();
}    

///////////////////////////////////////////////////////////////////////////