    /* -*- 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 file
     *   except in compliance with the License. You may obtain a copy of
     *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
     */

    #include <sal/config.h>
    #include <sal/log.hxx>

    #include <com/sun/star/deployment/DeploymentException.hpp>
    #include <com/sun/star/deployment/ExtensionManager.hpp>
    #include <com/sun/star/registry/XRegistryKey.hpp>
    #include <com/sun/star/container/XContentEnumerationAccess.hpp>
    #include <com/sun/star/container/XEnumeration.hpp>
    #include <com/sun/star/lang/XMultiServiceFactory.hpp>
    #include <com/sun/star/lang/XSingleComponentFactory.hpp>
    #include <com/sun/star/lang/XSingleServiceFactory.hpp>
    #include <com/sun/star/linguistic2/XSupportedLocales.hpp>
    #include <com/sun/star/linguistic2/DictionaryListEventFlags.hpp>
    #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>
    #include <com/sun/star/linguistic2/ProofreadingIterator.hpp>

    #include <unotools/lingucfg.hxx>
    #include <vcl/svapp.hxx>
    #include <comphelper/processfactory.hxx>
    #include <i18nlangtag/lang.h>
    #include <i18nlangtag/languagetag.hxx>
    #include <cppuhelper/factory.hxx>
    #include <cppuhelper/implbase.hxx>
    #include <cppuhelper/supportsservice.hxx>
    #include <o3tl/make_unique.hxx>

    #include "lngsvcmgr.hxx"
    #include "lngopt.hxx"
    #include "lngreg.hxx"
    #include <linguistic/misc.hxx>
    #include "spelldsp.hxx"
    #include "hyphdsp.hxx"
    #include "thesdsp.hxx"
    #include "gciterator.hxx"

    using namespace com::sun::star;
    using namespace linguistic;

    uno::Sequence< OUString > static GetLangSvcList( const uno::Any &rVal );
    uno::Sequence< OUString > static GetLangSvc( const uno::Any &rVal );

    static bool lcl_SeqHasString( const uno::Sequence< OUString > &rSeq, const OUString &rText )
    {
        bool bRes = false;

        sal_Int32 nLen = rSeq.getLength();
        if (nLen == 0 || rText.isEmpty())
            return bRes;

        const OUString *pSeq = rSeq.getConstArray();
        for (sal_Int32 i = 0;  i < nLen  &&  !bRes;  ++i)
        {
            if (rText == pSeq[i])
                bRes = true;
        }
        return bRes;
    }

    static uno::Sequence< lang::Locale > GetAvailLocales(
            const uno::Sequence< OUString > &rSvcImplNames )
    {
        uno::Sequence< lang::Locale > aRes;

        uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
        sal_Int32 nNames = rSvcImplNames.getLength();
        if( nNames )
        {
            std::set< LanguageType > aLanguages;

            //! since we're going to create one-instance services we have to
            //! supply their arguments even if we would not need them here...
            uno::Sequence< uno::Any > aArgs(2);
            aArgs.getArray()[0] <<= GetLinguProperties();

            // check all services for the supported languages and new
            // languages to the result
            const OUString *pImplNames = rSvcImplNames.getConstArray();
            sal_Int32 i;

            for (i = 0;  i < nNames;  ++i)
            {
                uno::Reference< linguistic2::XSupportedLocales > xSuppLoc;
                try
                {
                    xSuppLoc.set( xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
                                     pImplNames[i], aArgs, xContext ),
                                  uno::UNO_QUERY );
                }
                catch (uno::Exception &)
                {
                    SAL_WARN( "linguistic", "createInstanceWithArguments failed" );
                }

                if (xSuppLoc.is())
                {
                    uno::Sequence< lang::Locale > aLoc( xSuppLoc->getLocales() );
                    sal_Int32 nLoc = aLoc.getLength();
                    for (sal_Int32 k = 0;  k < nLoc;  ++k)
                    {
                        const lang::Locale *pLoc = aLoc.getConstArray();
                        LanguageType nLang = LinguLocaleToLanguage( pLoc[k] );

                        // It's a set, so insertion fails if language was already added.
                        aLanguages.insert( nLang );
                    }
                }
                else
                {
                    SAL_WARN( "linguistic", "interface not supported by service" );
                }
            }

            // build return sequence
            sal_Int32 nLanguages = static_cast< sal_Int32 >(aLanguages.size());
            aRes.realloc( nLanguages );
            lang::Locale *pRes = aRes.getArray();
            i=0;
            for (auto const& language : aLanguages)
            {
                pRes[i++] = LanguageTag::convertToLocale(language);
            }
        }

        return aRes;
    }

    struct SvcInfo
    {
        const OUString                  aSvcImplName;
        const std::vector< LanguageType >    aSuppLanguages;

        SvcInfo( const OUString &rSvcImplName,
                 const std::vector< LanguageType >  &rSuppLanguages ) :
            aSvcImplName    (rSvcImplName),
            aSuppLanguages  (rSuppLanguages)
        {
        }

        bool    HasLanguage( LanguageType nLanguage ) const;
    };

    bool SvcInfo::HasLanguage( LanguageType nLanguage ) const
    {
        for ( auto const & i : aSuppLanguages)
        {
            if (nLanguage == i)
                return true;
        }
        return false;
    }

    class LngSvcMgrListenerHelper :
        public cppu::WeakImplHelper
        <
            linguistic2::XLinguServiceEventListener,
            linguistic2::XDictionaryListEventListener
        >
    {
        LngSvcMgr  &rMyManager;

        ::comphelper::OInterfaceContainerHelper2           aLngSvcMgrListeners;
        ::comphelper::OInterfaceContainerHelper2           aLngSvcEvtBroadcasters;
        uno::Reference< linguistic2::XSearchableDictionaryList >           xDicList;

        sal_Int16   nCombinedLngSvcEvt;

        void    LaunchEvent( sal_Int16 nLngSvcEvtFlags );

        void Timeout();

    public:
        LngSvcMgrListenerHelper( LngSvcMgr &rLngSvcMgr,
            const uno::Reference< linguistic2::XSearchableDictionaryList > &rxDicList );

        LngSvcMgrListenerHelper(const LngSvcMgrListenerHelper&) = delete;
        LngSvcMgrListenerHelper& operator=(const LngSvcMgrListenerHelper&) = delete;

        // lang::XEventListener
        virtual void SAL_CALL
            disposing( const lang::EventObject& rSource ) override;

        // linguistic2::XLinguServiceEventListener
        virtual void SAL_CALL
            processLinguServiceEvent( const linguistic2::LinguServiceEvent& aLngSvcEvent ) override;

        // linguistic2::XDictionaryListEventListener
        virtual void SAL_CALL
            processDictionaryListEvent(
                    const linguistic2::DictionaryListEvent& rDicListEvent ) override;

        inline  void    AddLngSvcMgrListener(
                            const uno::Reference< lang::XEventListener >& rxListener );
        inline  void    RemoveLngSvcMgrListener(
                            const uno::Reference< lang::XEventListener >& rxListener );
        void    DisposeAndClear( const lang::EventObject &rEvtObj );
        void    AddLngSvcEvtBroadcaster(
                            const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster );
        void    RemoveLngSvcEvtBroadcaster(
                            const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster );

        void    AddLngSvcEvt( sal_Int16 nLngSvcEvt );
    };

    LngSvcMgrListenerHelper::LngSvcMgrListenerHelper(
            LngSvcMgr &rLngSvcMgr,
            const uno::Reference< linguistic2::XSearchableDictionaryList > &rxDicList  ) :
        rMyManager              ( rLngSvcMgr ),
        aLngSvcMgrListeners     ( GetLinguMutex() ),
        aLngSvcEvtBroadcasters  ( GetLinguMutex() ),
        xDicList                ( rxDicList )
    {
        if (xDicList.is())
        {
            xDicList->addDictionaryListEventListener(
                static_cast<linguistic2::XDictionaryListEventListener *>(this), false );
        }

        nCombinedLngSvcEvt = 0;
    }

    void SAL_CALL LngSvcMgrListenerHelper::disposing( const lang::EventObject& rSource )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        uno::Reference< uno::XInterface > xRef( rSource.Source );
        if ( xRef.is() )
        {
            aLngSvcMgrListeners   .removeInterface( xRef );
            aLngSvcEvtBroadcasters.removeInterface( xRef );
            if (xDicList == xRef)
                xDicList = nullptr;
        }
    }

    void LngSvcMgrListenerHelper::Timeout()
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        {
            // change event source to LinguServiceManager since the listeners
            // probably do not know (and need not to know) about the specific
            // SpellChecker's or Hyphenator's.
            linguistic2::LinguServiceEvent aEvtObj(
                static_cast<css::linguistic2::XLinguServiceManager*>(&rMyManager), nCombinedLngSvcEvt );
            nCombinedLngSvcEvt = 0;

            if (rMyManager.mxSpellDsp.is())
                rMyManager.mxSpellDsp->FlushSpellCache();

            // pass event on to linguistic2::XLinguServiceEventListener's
            aLngSvcMgrListeners.notifyEach( &linguistic2::XLinguServiceEventListener::processLinguServiceEvent, aEvtObj );
        }
    }

    void LngSvcMgrListenerHelper::AddLngSvcEvt( sal_Int16 nLngSvcEvt )
    {
        nCombinedLngSvcEvt |= nLngSvcEvt;
        Timeout();
    }

    void SAL_CALL
        LngSvcMgrListenerHelper::processLinguServiceEvent(
                const linguistic2::LinguServiceEvent& rLngSvcEvent )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );
        AddLngSvcEvt( rLngSvcEvent.nEvent );
    }

    void SAL_CALL
        LngSvcMgrListenerHelper::processDictionaryListEvent(
                const linguistic2::DictionaryListEvent& rDicListEvent )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        sal_Int16 nDlEvt = rDicListEvent.nCondensedEvent;
        if (0 == nDlEvt)
            return;

        // we do keep the original event source here though...

        // pass event on to linguistic2::XDictionaryListEventListener's
        aLngSvcMgrListeners.notifyEach( &linguistic2::XDictionaryListEventListener::processDictionaryListEvent, rDicListEvent );

        // "translate" DictionaryList event into linguistic2::LinguServiceEvent
        sal_Int16 nLngSvcEvt = 0;
        sal_Int16 const nSpellCorrectFlags =
                linguistic2::DictionaryListEventFlags::ADD_NEG_ENTRY        |
                linguistic2::DictionaryListEventFlags::DEL_POS_ENTRY        |
                linguistic2::DictionaryListEventFlags::ACTIVATE_NEG_DIC |
                linguistic2::DictionaryListEventFlags::DEACTIVATE_POS_DIC;
        if (0 != (nDlEvt & nSpellCorrectFlags))
            nLngSvcEvt |= linguistic2::LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN;

        sal_Int16 const nSpellWrongFlags =
                linguistic2::DictionaryListEventFlags::ADD_POS_ENTRY        |
                linguistic2::DictionaryListEventFlags::DEL_NEG_ENTRY        |
                linguistic2::DictionaryListEventFlags::ACTIVATE_POS_DIC |
                linguistic2::DictionaryListEventFlags::DEACTIVATE_NEG_DIC;
        if (0 != (nDlEvt & nSpellWrongFlags))
            nLngSvcEvt |= linguistic2::LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN;

        sal_Int16 const nHyphenateFlags =
                linguistic2::DictionaryListEventFlags::ADD_POS_ENTRY        |
                linguistic2::DictionaryListEventFlags::DEL_POS_ENTRY        |
                linguistic2::DictionaryListEventFlags::ACTIVATE_POS_DIC |
                linguistic2::DictionaryListEventFlags::ACTIVATE_NEG_DIC;
        if (0 != (nDlEvt & nHyphenateFlags))
            nLngSvcEvt |= linguistic2::LinguServiceEventFlags::HYPHENATE_AGAIN;

        if (rMyManager.mxSpellDsp.is())
            rMyManager.mxSpellDsp->FlushSpellCache();
        if (nLngSvcEvt)
            LaunchEvent( nLngSvcEvt );
    }

    void LngSvcMgrListenerHelper::LaunchEvent( sal_Int16 nLngSvcEvtFlags )
    {
        linguistic2::LinguServiceEvent aEvt(
            static_cast<css::linguistic2::XLinguServiceManager*>(&rMyManager), nLngSvcEvtFlags );

        // pass event on to linguistic2::XLinguServiceEventListener's
        aLngSvcMgrListeners.notifyEach( &linguistic2::XLinguServiceEventListener::processLinguServiceEvent, aEvt );
    }

    inline void LngSvcMgrListenerHelper::AddLngSvcMgrListener(
            const uno::Reference< lang::XEventListener >& rxListener )
    {
        aLngSvcMgrListeners.addInterface( rxListener );
    }

    inline void LngSvcMgrListenerHelper::RemoveLngSvcMgrListener(
            const uno::Reference< lang::XEventListener >& rxListener )
    {
        aLngSvcMgrListeners.removeInterface( rxListener );
    }

    void LngSvcMgrListenerHelper::DisposeAndClear( const lang::EventObject &rEvtObj )
    {
        // call "disposing" for all listeners and clear list
        aLngSvcMgrListeners   .disposeAndClear( rEvtObj );

        // remove references to this object hold by the broadcasters
        comphelper::OInterfaceIteratorHelper2 aIt( aLngSvcEvtBroadcasters );
        while (aIt.hasMoreElements())
        {
            uno::Reference< linguistic2::XLinguServiceEventBroadcaster > xRef( aIt.next(), uno::UNO_QUERY );
            if (xRef.is())
                RemoveLngSvcEvtBroadcaster( xRef );
        }

        // remove reference to this object hold by the dictionary-list
        if (xDicList.is())
        {
            xDicList->removeDictionaryListEventListener(
                static_cast<linguistic2::XDictionaryListEventListener *>(this) );
            xDicList = nullptr;
        }
    }

    void LngSvcMgrListenerHelper::AddLngSvcEvtBroadcaster(
            const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster )
    {
        if (rxBroadcaster.is())
        {
            aLngSvcEvtBroadcasters.addInterface( rxBroadcaster );
            rxBroadcaster->addLinguServiceEventListener(
                    static_cast<linguistic2::XLinguServiceEventListener *>(this) );
        }
    }

    void LngSvcMgrListenerHelper::RemoveLngSvcEvtBroadcaster(
            const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster )
    {
        if (rxBroadcaster.is())
        {
            aLngSvcEvtBroadcasters.removeInterface( rxBroadcaster );
            rxBroadcaster->removeLinguServiceEventListener(
                    static_cast<linguistic2::XLinguServiceEventListener *>(this) );
        }
    }

    LngSvcMgr::LngSvcMgr()
        : utl::ConfigItem("Office.Linguistic")
        , aEvtListeners(GetLinguMutex())
    {
        bDisposing = false;

        // request notify events when properties (i.e. something in the subtree) changes
        uno::Sequence< OUString > aNames(4);
        OUString *pNames = aNames.getArray();
        pNames[0] = "ServiceManager/SpellCheckerList";
        pNames[1] = "ServiceManager/GrammarCheckerList";
        pNames[2] = "ServiceManager/HyphenatorList";
        pNames[3] = "ServiceManager/ThesaurusList";
        EnableNotification( aNames );

        UpdateAll();

        aUpdateIdle.SetPriority(TaskPriority::LOWEST);
        aUpdateIdle.SetInvokeHandler(LINK(this, LngSvcMgr, updateAndBroadcast));

        // request to be notified if an extension has been added/removed
        uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());

        uno::Reference<deployment::XExtensionManager> xExtensionManager;
        try {
            xExtensionManager = deployment::ExtensionManager::get(xContext);
        } catch ( const uno::DeploymentException & ) {
            SAL_WARN( "linguistic", "no extension manager - should fire on mobile only" );
        } catch ( const deployment::DeploymentException & ) {
            SAL_WARN( "linguistic", "no extension manager - should fire on mobile only" );
        }
        if (xExtensionManager.is())
        {
            xMB.set(xExtensionManager, uno::UNO_QUERY_THROW);

            uno::Reference<util::XModifyListener> xListener(this);
            xMB->addModifyListener( xListener );
        }
    }

    // css::util::XModifyListener
    void LngSvcMgr::modified(const lang::EventObject&)
    {
        {
            osl::MutexGuard aGuard(GetLinguMutex());
            //assume that if an extension has been added/removed that
            //it might be a dictionary extension, so drop our cache

            pAvailSpellSvcs.reset();
            pAvailGrammarSvcs.reset();
            pAvailHyphSvcs.reset();
            pAvailThesSvcs.reset();
        }

        {
            SolarMutexGuard aGuard;
            //schedule in an update to execute in the main thread
            aUpdateIdle.Start();
        }
    }

    //run update, and inform everyone that dictionaries (may) have changed, this
    //needs to be run in the main thread because
    //utl::ConfigChangeListener_Impl::changesOccurred grabs the SolarMutex and we
    //get notified that an extension was added from an extension manager thread
    IMPL_LINK_NOARG(LngSvcMgr, updateAndBroadcast, Timer *, void)
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        UpdateAll();

        if (mxListenerHelper.is())
        {
            mxListenerHelper->AddLngSvcEvt(
                    linguistic2::LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN |
                    linguistic2::LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN |
                    linguistic2::LinguServiceEventFlags::PROOFREAD_AGAIN |
                    linguistic2::LinguServiceEventFlags::HYPHENATE_AGAIN );
        }
    }

    void LngSvcMgr::stopListening()
    {
        osl::MutexGuard aGuard(GetLinguMutex());

        if (xMB.is())
        {
            try
            {
                    uno::Reference<util::XModifyListener>  xListener(this);
                    xMB->removeModifyListener(xListener);
            }
            catch (const uno::Exception&)
            {
            }

            xMB.clear();
        }
    }

    void LngSvcMgr::disposing(const lang::EventObject&)
    {
        stopListening();
    }

    LngSvcMgr::~LngSvcMgr()
    {
        stopListening();

        // memory for pSpellDsp, pHyphDsp, pThesDsp, pListenerHelper
        // will be freed in the destructor of the respective Reference's
        // xSpellDsp, xGrammarDsp, xHyphDsp, xThesDsp

        pAvailSpellSvcs.reset();
        pAvailGrammarSvcs.reset();
        pAvailHyphSvcs.reset();
        pAvailThesSvcs.reset();
    }

    namespace
    {
        using lang::Locale;
        using uno::Any;
        using uno::Sequence;

        bool lcl_FindEntry( const OUString &rEntry, const Sequence< OUString > &rCfgSvcs )
        {
            sal_Int32 nRes = -1;
            sal_Int32 nEntries = rCfgSvcs.getLength();
            const OUString *pEntry = rCfgSvcs.getConstArray();
            for (sal_Int32 i = 0;  i < nEntries && nRes == -1;  ++i)
            {
                if (rEntry == pEntry[i])
                    nRes = i;
            }
            return nRes != -1;
        }

        Sequence< OUString > lcl_GetLastFoundSvcs(
                SvtLinguConfig const &rCfg,
                const OUString &rLastFoundList ,
                const OUString& rCfgLocaleStr )
        {
            Sequence< OUString > aRes;

            Sequence< OUString > aNodeNames( rCfg.GetNodeNames(rLastFoundList) );
            bool bFound = lcl_FindEntry( rCfgLocaleStr, aNodeNames);

            if (bFound)
            {
                Sequence< OUString > aNames { rLastFoundList + "/" + rCfgLocaleStr };
                Sequence< Any > aValues( rCfg.GetProperties( aNames ) );
                if (aValues.getLength())
                {
                    SAL_WARN_IF( aValues.getLength() != 1, "linguistic", "unexpected length of sequence" );
                    Sequence< OUString > aSvcImplNames;
                    if (aValues.getConstArray()[0] >>= aSvcImplNames)
                        aRes = aSvcImplNames;
                    else
                    {
                        SAL_WARN( "linguistic", "type mismatch" );
                    }
                }
            }

            return aRes;
        }

        Sequence< OUString > lcl_RemoveMissingEntries(
                const Sequence< OUString > &rCfgSvcs,
                const Sequence< OUString > &rAvailSvcs )
        {
            Sequence< OUString > aRes( rCfgSvcs.getLength() );
            OUString *pRes = aRes.getArray();
            sal_Int32 nCnt = 0;

            for (OUString const & entry : rCfgSvcs)
            {
                if (!entry.isEmpty() && lcl_FindEntry( entry, rAvailSvcs ))
                    pRes[ nCnt++ ] = entry;
            }

            aRes.realloc( nCnt );
            return aRes;
        }

        Sequence< OUString > lcl_GetNewEntries(
                const Sequence< OUString > &rLastFoundSvcs,
                const Sequence< OUString > &rAvailSvcs )
        {
            sal_Int32 nLen = rAvailSvcs.getLength();
            Sequence< OUString > aRes( nLen );
            OUString *pRes = aRes.getArray();
            sal_Int32 nCnt = 0;

            const OUString *pEntry = rAvailSvcs.getConstArray();
            for (sal_Int32 i = 0;  i < nLen;  ++i)
            {
                if (!pEntry[i].isEmpty() && !lcl_FindEntry( pEntry[i], rLastFoundSvcs ))
                    pRes[ nCnt++ ] = pEntry[i];
            }

            aRes.realloc( nCnt );
            return aRes;
        }

        Sequence< OUString > lcl_MergeSeq(
                const Sequence< OUString > &rCfgSvcs,
                const Sequence< OUString > &rNewSvcs )
        {
            Sequence< OUString > aRes( rCfgSvcs.getLength() + rNewSvcs.getLength() );
            OUString *pRes = aRes.getArray();
            sal_Int32 nCnt = 0;

            for (sal_Int32 k = 0;  k < 2;  ++k)
            {
                // add previously configured service first and append
                // new found services at the end
                const Sequence< OUString > &rSeq = k == 0 ? rCfgSvcs : rNewSvcs;

                sal_Int32 nLen = rSeq.getLength();
                const OUString *pEntry = rSeq.getConstArray();
                for (sal_Int32 i = 0;  i < nLen;  ++i)
                {
                    if (!pEntry[i].isEmpty() && !lcl_FindEntry( pEntry[i], aRes ))
                        pRes[ nCnt++ ] = pEntry[i];
                }
            }

            aRes.realloc( nCnt );
            return aRes;
        }
    }

    void LngSvcMgr::UpdateAll()
    {
        using beans::PropertyValue;
        using lang::Locale;
        using uno::Sequence;

        typedef Sequence< OUString > Sequence_OUString_t;
        typedef std::map< OUString, Sequence_OUString_t > list_entry_map_t;

        SvtLinguConfig aCfg;

        const int nNumServices = 4;
        const sal_Char * const apServices[nNumServices]       =  { SN_SPELLCHECKER, SN_GRAMMARCHECKER, SN_HYPHENATOR, SN_THESAURUS };
        const sal_Char * const apCurLists[nNumServices]       =  { "ServiceManager/SpellCheckerList",       "ServiceManager/GrammarCheckerList",       "ServiceManager/HyphenatorList",       "ServiceManager/ThesaurusList" };
        const sal_Char * const apLastFoundLists[nNumServices] =  { "ServiceManager/LastFoundSpellCheckers", "ServiceManager/LastFoundGrammarCheckers", "ServiceManager/LastFoundHyphenators", "ServiceManager/LastFoundThesauri" };

        // usage of indices as above: 0 = spell checker, 1 = grammar checker, 2 = hyphenator, 3 = thesaurus
        std::vector< list_entry_map_t > aLastFoundSvcs(nNumServices);
        std::vector< list_entry_map_t > aCurSvcs(nNumServices);

        for (int k = 0;  k < nNumServices;  ++k)
        {
            OUString aService( OUString::createFromAscii( apServices[k] ) );
            OUString aActiveList( OUString::createFromAscii( apCurLists[k] ) );
            OUString aLastFoundList( OUString::createFromAscii( apLastFoundLists[k] ) );
            sal_Int32 i;

            // remove configured but not available language/services entries

            Sequence< OUString > aNodeNames( aCfg.GetNodeNames( aActiveList ) );   // list of configured locales
            sal_Int32 nNodeNames = aNodeNames.getLength();
            const OUString *pNodeName = aNodeNames.getConstArray();
            for (i = 0;  i < nNodeNames;  ++i)
            {
                Locale aLocale( LanguageTag::convertToLocale( pNodeName[i]));
                Sequence< OUString > aCfgSvcs( getConfiguredServices( aService, aLocale ));
                Sequence< OUString > aAvailSvcs( getAvailableServices( aService, aLocale ));

                aCfgSvcs = lcl_RemoveMissingEntries( aCfgSvcs, aAvailSvcs );

                aCurSvcs[k][ pNodeName[i] ] = aCfgSvcs;
            }

            // add new available language/service entries
            // and
            // set last found services to currently available ones

            Sequence< Locale > aAvailLocales( getAvailableLocales(aService) );
            sal_Int32 nAvailLocales = aAvailLocales.getLength();
            const Locale *pAvailLocale = aAvailLocales.getConstArray();
            for (i = 0;  i < nAvailLocales;  ++i)
            {
                OUString aCfgLocaleStr( LanguageTag::convertToBcp47( pAvailLocale[i]));

                Sequence< OUString > aAvailSvcs( getAvailableServices( aService, pAvailLocale[i] ));

                aLastFoundSvcs[k][ aCfgLocaleStr ] = aAvailSvcs;

                Sequence< OUString > aLastSvcs(
                        lcl_GetLastFoundSvcs( aCfg, aLastFoundList , aCfgLocaleStr ));
                Sequence< OUString > aNewSvcs =
                        lcl_GetNewEntries( aLastSvcs, aAvailSvcs );

                Sequence< OUString > aCfgSvcs( aCurSvcs[k][ aCfgLocaleStr ] );

                // merge services list (previously configured to be listed first).
                aCfgSvcs = lcl_MergeSeq( aCfgSvcs, aNewSvcs );

                aCurSvcs[k][ aCfgLocaleStr ] = aCfgSvcs;
            }
        }

        // write new data back to configuration

        for (int k = 0;  k < nNumServices;  ++k)
        {
            for (int i = 0;  i < 2;  ++i)
            {
                const sal_Char *pSubNodeName = (i == 0) ? apCurLists[k] : apLastFoundLists[k];
                OUString aSubNodeName( OUString::createFromAscii(pSubNodeName) );

                list_entry_map_t &rCurMap = (i == 0) ? aCurSvcs[k] : aLastFoundSvcs[k];
                sal_Int32 nVals = static_cast< sal_Int32 >( rCurMap.size() );
                Sequence< PropertyValue > aNewValues( nVals );
                PropertyValue *pNewValue = aNewValues.getArray();
                for (auto const& elem : rCurMap)
                {
                    pNewValue->Name = aSubNodeName + "/" + elem.first;
                    pNewValue->Value <<= elem.second;
                    ++pNewValue;
                }
                OSL_ENSURE( pNewValue - aNewValues.getArray() == nVals,
                        "possible mismatch of sequence size and property number" );

                {
                    // add new or replace existing entries.
                    bool bRes = aCfg.ReplaceSetProperties( aSubNodeName, aNewValues );
                    SAL_WARN_IF(!bRes, "linguistic", "failed to set new configuration values");
                }
            }
        }

        //The new settings in the configuration get applied ! because we are
        //listening to the configuration for changes of the relevant ! properties
        //and Notify applies the new settings.
    }

    void LngSvcMgr::Notify( const uno::Sequence< OUString > &rPropertyNames )
    {
        const OUString aSpellCheckerList( "ServiceManager/SpellCheckerList" );
        const OUString aGrammarCheckerList( "ServiceManager/GrammarCheckerList" );
        const OUString aHyphenatorList( "ServiceManager/HyphenatorList" );
        const OUString aThesaurusList( "ServiceManager/ThesaurusList" );

        const uno::Sequence< OUString > aSpellCheckerListEntries( GetNodeNames( aSpellCheckerList ) );
        const uno::Sequence< OUString > aGrammarCheckerListEntries( GetNodeNames( aGrammarCheckerList ) );
        const uno::Sequence< OUString > aHyphenatorListEntries( GetNodeNames( aHyphenatorList ) );
        const uno::Sequence< OUString > aThesaurusListEntries( GetNodeNames( aThesaurusList ) );

        uno::Sequence< uno::Any > aValues;
        uno::Sequence< OUString > aNames( 1 );
        OUString *pNames = aNames.getArray();

        sal_Int32 nLen = rPropertyNames.getLength();
        const OUString *pPropertyNames = rPropertyNames.getConstArray();
        for (sal_Int32 i = 0;  i < nLen;  ++i)
        {
            // property names look like
            // "ServiceManager/ThesaurusList/de-CH"

            const OUString &rName = pPropertyNames[i];
            sal_Int32 nKeyStart;
            nKeyStart = rName.lastIndexOf( '/' );
            OUString aKeyText;
            if (nKeyStart != -1)
                aKeyText = rName.copy( nKeyStart + 1 );
            SAL_WARN_IF( aKeyText.isEmpty(), "linguistic", "unexpected key (lang::Locale) string" );
            if (rName.startsWith( aSpellCheckerList ))
            {
                osl::MutexGuard aGuard(GetLinguMutex());

                // delete old cached data, needs to be acquired new on demand
                pAvailSpellSvcs.reset();

                if (lcl_SeqHasString( aSpellCheckerListEntries, aKeyText ))
                {
                    pNames[0] = aSpellCheckerList + "/" + aKeyText;
                    aValues = /*aCfg.*/GetProperties( aNames );
                    uno::Sequence< OUString > aSvcImplNames;
                    if (aValues.getLength())
                        aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] );

                    LanguageType nLang = LANGUAGE_NONE;
                    if (!aKeyText.isEmpty())
                        nLang = LanguageTag::convertToLanguageType( aKeyText );

                    GetSpellCheckerDsp_Impl( false );     // don't set service list, it will be done below
                    mxSpellDsp->SetServiceList( LanguageTag::convertToLocale(nLang), aSvcImplNames );
                }
            }
            else if (rName.startsWith( aGrammarCheckerList ))
            {
                osl::MutexGuard aGuard(GetLinguMutex());

                // delete old cached data, needs to be acquired new on demand
                pAvailGrammarSvcs.reset();

                if (lcl_SeqHasString( aGrammarCheckerListEntries, aKeyText ))
                {
                    pNames[0] = aGrammarCheckerList + "/" + aKeyText;
                    aValues = /*aCfg.*/GetProperties( aNames );
                    uno::Sequence< OUString > aSvcImplNames;
                    if (aValues.getLength())
                        aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] );

                    LanguageType nLang = LANGUAGE_NONE;
                    if (!aKeyText.isEmpty())
                        nLang = LanguageTag::convertToLanguageType( aKeyText );

                    if (SvtLinguConfig().HasGrammarChecker())
                    {
                        GetGrammarCheckerDsp_Impl( false );   // don't set service list, it will be done below
                        mxGrammarDsp->SetServiceList( LanguageTag::convertToLocale(nLang), aSvcImplNames );
                    }
                }
            }
            else if (rName.startsWith( aHyphenatorList ))
            {
                osl::MutexGuard aGuard(GetLinguMutex());

                // delete old cached data, needs to be acquired new on demand
                pAvailHyphSvcs.reset();

                if (lcl_SeqHasString( aHyphenatorListEntries, aKeyText ))
                {
                    pNames[0] = aHyphenatorList + "/" + aKeyText;
                    aValues = /*aCfg.*/GetProperties( aNames );
                    uno::Sequence< OUString > aSvcImplNames;
                    if (aValues.getLength())
                        aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] );

                    LanguageType nLang = LANGUAGE_NONE;
                    if (!aKeyText.isEmpty())
                        nLang = LanguageTag::convertToLanguageType( aKeyText );

                    GetHyphenatorDsp_Impl( false );   // don't set service list, it will be done below
                    mxHyphDsp->SetServiceList( LanguageTag::convertToLocale(nLang), aSvcImplNames );
                }
            }
            else if (rName.startsWith( aThesaurusList ))
            {
                osl::MutexGuard aGuard(GetLinguMutex());

                // delete old cached data, needs to be acquired new on demand
                pAvailThesSvcs.reset();

                if (lcl_SeqHasString( aThesaurusListEntries, aKeyText ))
                {
                    pNames[0] = aThesaurusList + "/" + aKeyText;
                    aValues = /*aCfg.*/GetProperties( aNames );
                    uno::Sequence< OUString > aSvcImplNames;
                    if (aValues.getLength())
                        aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] );

                    LanguageType nLang = LANGUAGE_NONE;
                    if (!aKeyText.isEmpty())
                        nLang = LanguageTag::convertToLanguageType( aKeyText );

                    GetThesaurusDsp_Impl( false );  // don't set service list, it will be done below
                    mxThesDsp->SetServiceList( LanguageTag::convertToLocale(nLang), aSvcImplNames );
                }
            }
            else
            {
                SAL_WARN( "linguistic", "notified for unexpected property" );
            }
        }
    }

    void LngSvcMgr::ImplCommit()
    {
        // everything necessary should have already been done by 'SaveCfgSvcs'
        // called from within 'setConfiguredServices'.
        // Also this class usually exits only when the Office is being shutdown.
    }

    void LngSvcMgr::GetListenerHelper_Impl()
    {
        if (!mxListenerHelper.is())
        {
            mxListenerHelper = new LngSvcMgrListenerHelper( *this, linguistic::GetDictionaryList() );
        }
    }

    void LngSvcMgr::GetSpellCheckerDsp_Impl( bool bSetSvcList )
    {
        if (!mxSpellDsp.is())
        {
            mxSpellDsp = new SpellCheckerDispatcher( *this );
            if (bSetSvcList)
                SetCfgServiceLists( *mxSpellDsp );
        }
    }

    void LngSvcMgr::GetGrammarCheckerDsp_Impl( bool bSetSvcList  )
    {
        if (!mxGrammarDsp.is() && SvtLinguConfig().HasGrammarChecker())
        {
            //! since the grammar checking iterator needs to be a one instance service
            //! we need to create it the correct way!
            uno::Reference< linguistic2::XProofreadingIterator > xGCI;
            try
            {
                xGCI = linguistic2::ProofreadingIterator::create( comphelper::getProcessComponentContext() );
            }
            catch (const uno::Exception &)
            {
            }
            SAL_WARN_IF( !xGCI.is(), "linguistic", "instantiating grammar checking iterator failed" );

            if (xGCI.is())
            {
                mxGrammarDsp = dynamic_cast< GrammarCheckingIterator * >(xGCI.get());
                SAL_WARN_IF( mxGrammarDsp == nullptr, "linguistic", "failed to get implementation" );
                if (bSetSvcList && mxGrammarDsp.is())
                    SetCfgServiceLists( *mxGrammarDsp );
            }
        }
    }

    void LngSvcMgr::GetHyphenatorDsp_Impl( bool bSetSvcList  )
    {
        if (!mxHyphDsp.is())
        {
            mxHyphDsp = new HyphenatorDispatcher( *this );
            if (bSetSvcList)
                SetCfgServiceLists( *mxHyphDsp );
        }
    }

    void LngSvcMgr::GetThesaurusDsp_Impl( bool bSetSvcList  )
    {
        if (!mxThesDsp.is())
        {
            mxThesDsp = new ThesaurusDispatcher;
            if (bSetSvcList)
                SetCfgServiceLists( *mxThesDsp );
        }
    }

    void LngSvcMgr::GetAvailableSpellSvcs_Impl()
    {
        if (!pAvailSpellSvcs)
        {
            pAvailSpellSvcs.reset(new SvcInfoArray);

            uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );

            uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xContext->getServiceManager(), uno::UNO_QUERY );
            uno::Reference< container::XEnumeration > xEnum;
            if (xEnumAccess.is())
                xEnum = xEnumAccess->createContentEnumeration( SN_SPELLCHECKER );

            if (xEnum.is())
            {
                while (xEnum->hasMoreElements())
                {
                    uno::Any aCurrent = xEnum->nextElement();
                    uno::Reference< lang::XSingleComponentFactory > xCompFactory;
                    uno::Reference< lang::XSingleServiceFactory > xFactory;

                    uno::Reference< linguistic2::XSpellChecker > xSvc;
                    xCompFactory.set(aCurrent, css::uno::UNO_QUERY);
                    if (!xCompFactory.is())
                    {
                        xFactory.set(aCurrent, css::uno::UNO_QUERY);
                    }
                    if ( xCompFactory.is() || xFactory.is() )
                    {
                        try
                        {
                            xSvc.set( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY );
                        }
                        catch (const uno::Exception &)
                        {
                            SAL_WARN( "linguistic", "createInstance failed" );
                        }
                    }

                    if (xSvc.is())
                    {
                        OUString            aImplName;
                        std::vector< LanguageType >   aLanguages;
                        uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY );
                        if (xInfo.is())
                            aImplName = xInfo->getImplementationName();
                        SAL_WARN_IF( aImplName.isEmpty(), "linguistic", "empty implementation name" );
                        uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY );
                        SAL_WARN_IF( !xSuppLoc.is(), "linguistic", "interfaces not supported" );
                        if (xSuppLoc.is()) {
                            uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales());
                            aLanguages = LocaleSeqToLangVec( aLocaleSequence );
                        }

                        pAvailSpellSvcs->push_back( o3tl::make_unique<SvcInfo>( aImplName, aLanguages ) );
                    }
                }
            }
        }
    }

    void LngSvcMgr::GetAvailableGrammarSvcs_Impl()
    {
        if (!pAvailGrammarSvcs)
        {
            pAvailGrammarSvcs.reset(new SvcInfoArray);

            uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );

            uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xContext->getServiceManager(), uno::UNO_QUERY );
            uno::Reference< container::XEnumeration > xEnum;
            if (xEnumAccess.is())
                xEnum = xEnumAccess->createContentEnumeration( SN_GRAMMARCHECKER );

            if (xEnum.is())
            {
                while (xEnum->hasMoreElements())
                {
                    uno::Any aCurrent = xEnum->nextElement();
                    uno::Reference< lang::XSingleComponentFactory > xCompFactory;
                    uno::Reference< lang::XSingleServiceFactory > xFactory;

                    uno::Reference< linguistic2::XProofreader > xSvc;
                    xCompFactory.set(aCurrent, css::uno::UNO_QUERY);
                    if (!xCompFactory.is())
                    {
                        xFactory.set(aCurrent, css::uno::UNO_QUERY);
                    }
                    if ( xCompFactory.is() || xFactory.is() )
                    {
                        try
                        {
                            xSvc.set( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY );
                        }
                        catch (const uno::Exception &)
                        {
                            SAL_WARN( "linguistic", "createInstance failed" );
                        }
                    }

                    if (xSvc.is() && pAvailGrammarSvcs)
                    {
                        OUString            aImplName;
                        std::vector< LanguageType >    aLanguages;
                        uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY );
                        if (xInfo.is())
                            aImplName = xInfo->getImplementationName();
                        SAL_WARN_IF( aImplName.isEmpty(), "linguistic", "empty implementation name" );
                        uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY );
                        SAL_WARN_IF( !xSuppLoc.is(), "linguistic", "interfaces not supported" );
                        if (xSuppLoc.is())
                        {
                            uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales());
                            aLanguages = LocaleSeqToLangVec( aLocaleSequence );
                        }

                        pAvailGrammarSvcs->push_back( o3tl::make_unique<SvcInfo>( aImplName, aLanguages ) );
                    }
                }
            }
        }
    }

    void LngSvcMgr::GetAvailableHyphSvcs_Impl()
    {
        if (!pAvailHyphSvcs)
        {
            pAvailHyphSvcs.reset(new SvcInfoArray);
            uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );

            uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xContext->getServiceManager(), uno::UNO_QUERY );
            uno::Reference< container::XEnumeration > xEnum;
            if (xEnumAccess.is())
                xEnum = xEnumAccess->createContentEnumeration( SN_HYPHENATOR );

            if (xEnum.is())
            {
                while (xEnum->hasMoreElements())
                {
                    uno::Any aCurrent = xEnum->nextElement();
                    uno::Reference< lang::XSingleComponentFactory > xCompFactory;
                    uno::Reference< lang::XSingleServiceFactory > xFactory;

                    uno::Reference< linguistic2::XHyphenator > xSvc;
                    xCompFactory.set(aCurrent, css::uno::UNO_QUERY);
                    if (!xCompFactory.is())
                    {
                        xFactory.set(aCurrent, css::uno::UNO_QUERY);
                    }
                    if ( xCompFactory.is() || xFactory.is() )
                    {
                        try
                        {
                            xSvc.set( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY );
                        }
                        catch (const uno::Exception &)
                        {
                            SAL_WARN( "linguistic", "createInstance failed" );
                        }
                    }
                    if (xSvc.is())
                    {
                        OUString            aImplName;
                        std::vector< LanguageType >    aLanguages;
                        uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY );
                        if (xInfo.is())
                            aImplName = xInfo->getImplementationName();
                        SAL_WARN_IF( aImplName.isEmpty(), "linguistic", "empty implementation name" );
                        uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY );
                        SAL_WARN_IF( !xSuppLoc.is(), "linguistic", "interfaces not supported" );
                        if (xSuppLoc.is())
                        {
                            uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales());
                            aLanguages = LocaleSeqToLangVec( aLocaleSequence );
                        }
                        pAvailHyphSvcs->push_back( o3tl::make_unique<SvcInfo>( aImplName, aLanguages ) );
                    }
                }
            }
        }
    }

    void LngSvcMgr::GetAvailableThesSvcs_Impl()
    {
        if (!pAvailThesSvcs)
        {
            pAvailThesSvcs.reset(new SvcInfoArray);

            uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );

            uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xContext->getServiceManager(), uno::UNO_QUERY );
            uno::Reference< container::XEnumeration > xEnum;
            if (xEnumAccess.is())
                xEnum = xEnumAccess->createContentEnumeration( SN_THESAURUS );

            if (xEnum.is())
            {
                while (xEnum->hasMoreElements())
                {
                    uno::Any aCurrent = xEnum->nextElement();
                    uno::Reference< lang::XSingleComponentFactory > xCompFactory;
                    uno::Reference< lang::XSingleServiceFactory > xFactory;

                    uno::Reference< linguistic2::XThesaurus > xSvc;
                    xCompFactory.set(aCurrent, css::uno::UNO_QUERY);
                    if (!xCompFactory.is())
                    {
                        xFactory.set(aCurrent, css::uno::UNO_QUERY);
                    }
                    if ( xCompFactory.is() || xFactory.is() )
                    {
                        try
                        {
                            xSvc.set( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY );
                        }
                        catch (const uno::Exception &)
                        {
                           SAL_WARN( "linguistic", "createInstance failed" );
                        }
                    }
                    if (xSvc.is())
                    {
                        OUString            aImplName;
                        std::vector< LanguageType >    aLanguages;
                        uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY );
                        if (xInfo.is())
                            aImplName = xInfo->getImplementationName();
                        SAL_WARN_IF( aImplName.isEmpty(), "linguistic", "empty implementation name" );
                        uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY );
                        SAL_WARN_IF( !xSuppLoc.is(), "linguistic", "interfaces not supported" );
                        if (xSuppLoc.is())
                        {
                            uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales());
                            aLanguages = LocaleSeqToLangVec( aLocaleSequence );
                        }

                        pAvailThesSvcs->push_back( o3tl::make_unique<SvcInfo>( aImplName, aLanguages ) );
                    }
                }
            }
        }
    }

    void LngSvcMgr::SetCfgServiceLists( SpellCheckerDispatcher &rSpellDsp )
    {
        SAL_INFO( "linguistic", "linguistic: LngSvcMgr::SetCfgServiceLists - Spell" );

        OUString aNode("ServiceManager/SpellCheckerList");
        uno::Sequence< OUString > aNames( /*aCfg.*/GetNodeNames( aNode ) );
        OUString *pNames = aNames.getArray();
        sal_Int32 nLen = aNames.getLength();

        // append path prefix need for 'GetProperties' call below
        OUString aPrefix = aNode + "/";
        for (OUString & name : aNames)
        {
            name = aPrefix + name;
        }

        uno::Sequence< uno::Any > aValues( /*aCfg.*/GetProperties( aNames ) );
        if (nLen  &&  nLen == aValues.getLength())
        {
            const uno::Any *pValues = aValues.getConstArray();
            for (sal_Int32 i = 0;  i < nLen;  ++i)
            {
                uno::Sequence< OUString > aSvcImplNames;
                if (pValues[i] >>= aSvcImplNames)
                {
                    OUString aLocaleStr( pNames[i] );
                    sal_Int32 nSeparatorPos = aLocaleStr.lastIndexOf( '/' );
                    aLocaleStr = aLocaleStr.copy( nSeparatorPos + 1 );
                    rSpellDsp.SetServiceList( LanguageTag::convertToLocale(aLocaleStr), aSvcImplNames );
                }
            }
        }
    }

    void LngSvcMgr::SetCfgServiceLists( GrammarCheckingIterator &rGrammarDsp )
    {
        SAL_INFO( "linguistic", "linguistic: LngSvcMgr::SetCfgServiceLists - Grammar" );

        OUString aNode("ServiceManager/GrammarCheckerList");
        uno::Sequence< OUString > aNames( /*aCfg.*/GetNodeNames( aNode ) );
        OUString *pNames = aNames.getArray();
        sal_Int32 nLen = aNames.getLength();

        // append path prefix need for 'GetProperties' call below
        OUString aPrefix = aNode  + "/";
        for (OUString & name : aNames)
        {
            name = aPrefix + name;
        }

        uno::Sequence< uno::Any > aValues( /*aCfg.*/GetProperties( aNames ) );
        if (nLen  &&  nLen == aValues.getLength())
        {
            const uno::Any *pValues = aValues.getConstArray();
            for (sal_Int32 i = 0;  i < nLen;  ++i)
            {
                uno::Sequence< OUString > aSvcImplNames;
                if (pValues[i] >>= aSvcImplNames)
                {
                    // there should only be one grammar checker in use per language...
                    if (aSvcImplNames.getLength() > 1)
                        aSvcImplNames.realloc(1);

                    OUString aLocaleStr( pNames[i] );
                    sal_Int32 nSeparatorPos = aLocaleStr.lastIndexOf( '/' );
                    aLocaleStr = aLocaleStr.copy( nSeparatorPos + 1 );
                    rGrammarDsp.SetServiceList( LanguageTag::convertToLocale(aLocaleStr), aSvcImplNames );
                }
            }
        }
    }

    void LngSvcMgr::SetCfgServiceLists( HyphenatorDispatcher &rHyphDsp )
    {
        SAL_INFO( "linguistic", "linguistic: LngSvcMgr::SetCfgServiceLists - Hyph" );

        OUString aNode("ServiceManager/HyphenatorList");
        uno::Sequence< OUString > aNames( /*aCfg.*/GetNodeNames( aNode ) );
        OUString *pNames = aNames.getArray();
        sal_Int32 nLen = aNames.getLength();

        // append path prefix need for 'GetProperties' call below
        OUString aPrefix = aNode + "/";
        for (OUString & name : aNames)
        {
            name = aPrefix + name;
        }

        uno::Sequence< uno::Any > aValues( /*aCfg.*/GetProperties( aNames ) );
        if (nLen  &&  nLen == aValues.getLength())
        {
            const uno::Any *pValues = aValues.getConstArray();
            for (sal_Int32 i = 0;  i < nLen;  ++i)
            {
                uno::Sequence< OUString > aSvcImplNames;
                if (pValues[i] >>= aSvcImplNames)
                {
                    // there should only be one hyphenator in use per language...
                    if (aSvcImplNames.getLength() > 1)
                        aSvcImplNames.realloc(1);

                    OUString aLocaleStr( pNames[i] );
                    sal_Int32 nSeparatorPos = aLocaleStr.lastIndexOf( '/' );
                    aLocaleStr = aLocaleStr.copy( nSeparatorPos + 1 );
                    rHyphDsp.SetServiceList( LanguageTag::convertToLocale(aLocaleStr), aSvcImplNames );
                }
            }
        }
    }

    void LngSvcMgr::SetCfgServiceLists( ThesaurusDispatcher &rThesDsp )
    {
        SAL_INFO( "linguistic", "linguistic: LngSvcMgr::SetCfgServiceLists - Thes" );

        OUString aNode("ServiceManager/ThesaurusList");
        uno::Sequence< OUString > aNames( /*aCfg.*/GetNodeNames( aNode ) );
        OUString *pNames = aNames.getArray();
        sal_Int32 nLen = aNames.getLength();

        // append path prefix need for 'GetProperties' call below
        OUString aPrefix = aNode + "/";
        for (OUString & name : aNames)
        {
            name = aPrefix + name;
        }

        uno::Sequence< uno::Any > aValues( /*aCfg.*/GetProperties( aNames ) );
        if (nLen  &&  nLen == aValues.getLength())
        {
            const uno::Any *pValues = aValues.getConstArray();
            for (sal_Int32 i = 0;  i < nLen;  ++i)
            {
                uno::Sequence< OUString > aSvcImplNames;
                if (pValues[i] >>= aSvcImplNames)
                {
                    OUString aLocaleStr( pNames[i] );
                    sal_Int32 nSeparatorPos = aLocaleStr.lastIndexOf( '/' );
                    aLocaleStr = aLocaleStr.copy( nSeparatorPos + 1 );
                    rThesDsp.SetServiceList( LanguageTag::convertToLocale(aLocaleStr), aSvcImplNames );
                }
            }
        }
    }

    uno::Reference< linguistic2::XSpellChecker > SAL_CALL
        LngSvcMgr::getSpellChecker()
    {
        osl::MutexGuard aGuard( GetLinguMutex() );
    #if OSL_DEBUG_LEVEL > 0
        getAvailableLocales(SN_SPELLCHECKER);
    #endif

        uno::Reference< linguistic2::XSpellChecker > xRes;
        if (!bDisposing)
        {
            if (!mxSpellDsp.is())
                GetSpellCheckerDsp_Impl();
            xRes = mxSpellDsp.get();
        }
        return xRes;
    }

    uno::Reference< linguistic2::XHyphenator > SAL_CALL
        LngSvcMgr::getHyphenator()
    {
        osl::MutexGuard aGuard( GetLinguMutex() );
    #if OSL_DEBUG_LEVEL > 0
        getAvailableLocales(SN_HYPHENATOR);
    #endif
        uno::Reference< linguistic2::XHyphenator >   xRes;
        if (!bDisposing)
        {
            if (!mxHyphDsp.is())
                GetHyphenatorDsp_Impl();
            xRes = mxHyphDsp.get();
        }
        return xRes;
    }

    uno::Reference< linguistic2::XThesaurus > SAL_CALL
        LngSvcMgr::getThesaurus()
    {
        osl::MutexGuard aGuard( GetLinguMutex() );
    #if OSL_DEBUG_LEVEL > 0
        getAvailableLocales(SN_THESAURUS);
    #endif
        uno::Reference< linguistic2::XThesaurus >    xRes;
        if (!bDisposing)
        {
            if (!mxThesDsp.is())
                GetThesaurusDsp_Impl();
            xRes = mxThesDsp.get();
        }
        return xRes;
    }

    sal_Bool SAL_CALL
        LngSvcMgr::addLinguServiceManagerListener(
                const uno::Reference< lang::XEventListener >& xListener )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        if (bDisposing || !xListener.is())
            return false;

        if (!mxListenerHelper.is())
            GetListenerHelper_Impl();
        mxListenerHelper->AddLngSvcMgrListener( xListener );
        return true;
    }

    sal_Bool SAL_CALL
        LngSvcMgr::removeLinguServiceManagerListener(
                const uno::Reference< lang::XEventListener >& xListener )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        if (bDisposing || !xListener.is())
            return false;

        DBG_ASSERT( mxListenerHelper.is(), "listener removed without being added" );
        if (!mxListenerHelper.is())
            GetListenerHelper_Impl();
        mxListenerHelper->RemoveLngSvcMgrListener( xListener );
        return true;
    }

    uno::Sequence< OUString > SAL_CALL
        LngSvcMgr::getAvailableServices(
                const OUString& rServiceName,
                const lang::Locale& rLocale )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        uno::Sequence< OUString > aRes;
        const SvcInfoArray *pInfoArray = nullptr;

        if (rServiceName == SN_SPELLCHECKER)
        {
            GetAvailableSpellSvcs_Impl();
            pInfoArray = pAvailSpellSvcs.get();
        }
        else if (rServiceName == SN_GRAMMARCHECKER)
        {
            GetAvailableGrammarSvcs_Impl();
            pInfoArray = pAvailGrammarSvcs.get();
        }
        else if (rServiceName == SN_HYPHENATOR)
        {
            GetAvailableHyphSvcs_Impl();
            pInfoArray = pAvailHyphSvcs.get();
        }
        else if (rServiceName == SN_THESAURUS)
        {
            GetAvailableThesSvcs_Impl();
            pInfoArray = pAvailThesSvcs.get();
        }

        if (pInfoArray)
        {
            // resize to max number of entries
            size_t nMaxCnt = pInfoArray->size();
            aRes.realloc( nMaxCnt );
            OUString *pImplName = aRes.getArray();

            sal_uInt16 nCnt = 0;
            LanguageType nLanguage = LinguLocaleToLanguage( rLocale );
            for (size_t i = 0;  i < nMaxCnt; ++i)
            {
                const SvcInfo &rInfo = *(*pInfoArray)[i].get();
                if (LinguIsUnspecified( nLanguage )
                    || rInfo.HasLanguage( nLanguage ))
                {
                    pImplName[ nCnt++ ] = rInfo.aSvcImplName;
                }
            }

            // resize to actual number of entries
            if (nCnt != nMaxCnt)
                aRes.realloc( nCnt );
        }

        return aRes;
    }

    uno::Sequence< lang::Locale > SAL_CALL
        LngSvcMgr::getAvailableLocales(
                const OUString& rServiceName )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        uno::Sequence< lang::Locale > aRes;

        uno::Sequence< lang::Locale >  *pAvailLocales     = nullptr;
        if (rServiceName == SN_SPELLCHECKER)
            pAvailLocales       = &aAvailSpellLocales;
        else if (rServiceName == SN_GRAMMARCHECKER)
            pAvailLocales       = &aAvailGrammarLocales;
        else if (rServiceName == SN_HYPHENATOR)
            pAvailLocales       = &aAvailHyphLocales;
        else if (rServiceName == SN_THESAURUS)
            pAvailLocales       = &aAvailThesLocales;

        // Nowadays (with OOo lingu in SO) we want to know immediately about
        // new downloaded dictionaries and have them ready right away if the Tools/Options...
        // is used to activate them. Thus we can not rely anymore on buffered data.
        if (pAvailLocales)
        {
            *pAvailLocales = GetAvailLocales(getAvailableServices(rServiceName, lang::Locale()));
            aRes = *pAvailLocales;
        }

        return aRes;
    }

    static bool IsEqSvcList( const uno::Sequence< OUString > &rList1,
                             const uno::Sequence< OUString > &rList2 )
    {
        // returns true iff both sequences are equal

        bool bRes = false;
        sal_Int32 nLen = rList1.getLength();
        if (rList2.getLength() == nLen)
        {
            const OUString *pStr1 = rList1.getConstArray();
            const OUString *pStr2 = rList2.getConstArray();
            bRes = true;
            for (sal_Int32 i = 0;  i < nLen  &&  bRes;  ++i)
            {
                if (*pStr1++ != *pStr2++)
                    bRes = false;
            }
        }
        return bRes;
    }

    void SAL_CALL
        LngSvcMgr::setConfiguredServices(
                const OUString& rServiceName,
                const lang::Locale& rLocale,
                const uno::Sequence< OUString >& rServiceImplNames )
    {
        SAL_INFO( "linguistic", "linguistic: LngSvcMgr::setConfiguredServices" );

        osl::MutexGuard aGuard( GetLinguMutex() );

        LanguageType nLanguage = LinguLocaleToLanguage( rLocale );
        if (!LinguIsUnspecified( nLanguage))
        {
            if (rServiceName == SN_SPELLCHECKER)
            {
                if (!mxSpellDsp.is())
                    GetSpellCheckerDsp_Impl();
                bool bChanged = !IsEqSvcList( rServiceImplNames,
                                              mxSpellDsp->GetServiceList( rLocale ) );
                if (bChanged)
                {
                    mxSpellDsp->SetServiceList( rLocale, rServiceImplNames );
                    SaveCfgSvcs( SN_SPELLCHECKER );

                    if (mxListenerHelper.is() && bChanged)
                        mxListenerHelper->AddLngSvcEvt(
                                linguistic2::LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN |
                                linguistic2::LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN );
                }
            }
            else if (rServiceName == SN_GRAMMARCHECKER)
            {
                if (!mxGrammarDsp.is())
                    GetGrammarCheckerDsp_Impl();
                bool bChanged = !IsEqSvcList( rServiceImplNames,
                                              mxGrammarDsp->GetServiceList( rLocale ) );
                if (bChanged)
                {
                    mxGrammarDsp->SetServiceList( rLocale, rServiceImplNames );
                    SaveCfgSvcs( SN_GRAMMARCHECKER );

                    if (mxListenerHelper.is() && bChanged)
                        mxListenerHelper->AddLngSvcEvt(
                                linguistic2::LinguServiceEventFlags::PROOFREAD_AGAIN );
                }
            }
            else if (rServiceName == SN_HYPHENATOR)
            {
                if (!mxHyphDsp.is())
                    GetHyphenatorDsp_Impl();
                bool bChanged = !IsEqSvcList( rServiceImplNames,
                                              mxHyphDsp->GetServiceList( rLocale ) );
                if (bChanged)
                {
                    mxHyphDsp->SetServiceList( rLocale, rServiceImplNames );
                    SaveCfgSvcs( SN_HYPHENATOR );

                    if (mxListenerHelper.is() && bChanged)
                        mxListenerHelper->AddLngSvcEvt(
                                linguistic2::LinguServiceEventFlags::HYPHENATE_AGAIN );
                }
            }
            else if (rServiceName == SN_THESAURUS)
            {
                if (!mxThesDsp.is())
                    GetThesaurusDsp_Impl();
                bool bChanged = !IsEqSvcList( rServiceImplNames,
                                              mxThesDsp->GetServiceList( rLocale ) );
                if (bChanged)
                {
                    mxThesDsp->SetServiceList( rLocale, rServiceImplNames );
                    SaveCfgSvcs( SN_THESAURUS );
                }
            }
        }
    }

    bool LngSvcMgr::SaveCfgSvcs( const OUString &rServiceName )
    {
        SAL_INFO( "linguistic", "linguistic: LngSvcMgr::SaveCfgSvcs" );

        bool bRes = false;

        LinguDispatcher *pDsp = nullptr;
        uno::Sequence< lang::Locale > aLocales;

        if (rServiceName == SN_SPELLCHECKER)
        {
            if (!mxSpellDsp.get())
                GetSpellCheckerDsp_Impl();
            pDsp = mxSpellDsp.get();
            aLocales = getAvailableLocales( SN_SPELLCHECKER );
        }
        else if (rServiceName == SN_GRAMMARCHECKER)
        {
            if (!mxGrammarDsp.is())
                GetGrammarCheckerDsp_Impl();
            pDsp = mxGrammarDsp.get();
            aLocales = getAvailableLocales( SN_GRAMMARCHECKER );
        }
        else if (rServiceName == SN_HYPHENATOR)
        {
            if (!mxHyphDsp.is())
                GetHyphenatorDsp_Impl();
            pDsp = mxHyphDsp.get();
            aLocales = getAvailableLocales( SN_HYPHENATOR );
        }
        else if (rServiceName == SN_THESAURUS)
        {
            if (!mxThesDsp.is())
                GetThesaurusDsp_Impl();
            pDsp = mxThesDsp.get();
            aLocales = getAvailableLocales( SN_THESAURUS );
        }

        if (pDsp  &&  aLocales.getLength())
        {
            sal_Int32 nLen = aLocales.getLength();
            const lang::Locale *pLocale = aLocales.getConstArray();

            uno::Sequence< beans::PropertyValue > aValues( nLen );
            beans::PropertyValue *pValues = aValues.getArray();
            beans::PropertyValue *pValue  = pValues;

            // get node name to be used
            const char *pNodeName = nullptr;
            if (pDsp == mxSpellDsp.get())
                pNodeName = "ServiceManager/SpellCheckerList";
            else if (pDsp == mxGrammarDsp.get())
                pNodeName = "ServiceManager/GrammarCheckerList";
            else if (pDsp == mxHyphDsp.get())
                pNodeName = "ServiceManager/HyphenatorList";
            else if (pDsp == mxThesDsp.get())
                pNodeName = "ServiceManager/ThesaurusList";
            else
            {
                SAL_WARN( "linguistic", "node name missing" );
            }
            OUString aNodeName( OUString::createFromAscii(pNodeName) );

            for (sal_Int32 i = 0;  i < nLen;  ++i)
            {
                uno::Sequence< OUString > aSvcImplNames;
                aSvcImplNames = pDsp->GetServiceList( pLocale[i] );

                // build value to be written back to configuration
                uno::Any aCfgAny;
                if ((pDsp == mxHyphDsp.get() || pDsp == mxGrammarDsp.get()) && aSvcImplNames.getLength() > 1)
                    aSvcImplNames.realloc(1);   // there should be only one entry for hyphenators or grammar checkers (because they are not chained)
                aCfgAny <<= aSvcImplNames;
                DBG_ASSERT( aCfgAny.hasValue(), "missing value for 'Any' type" );

                OUString aCfgLocaleStr( LanguageTag::convertToBcp47( pLocale[i]));
                pValue->Value = aCfgAny;
                pValue->Name  = aNodeName + "/" + aCfgLocaleStr;
                pValue++;
            }
            {
            SAL_INFO( "linguistic", "linguistic: LngSvcMgr::SaveCfgSvcs - ReplaceSetProperties" );
            // change, add new or replace existing entries.
            bRes |= /*aCfg.*/ReplaceSetProperties( aNodeName, aValues );
            }
        }

        return bRes;
    }

    static uno::Sequence< OUString > GetLangSvcList( const uno::Any &rVal )
    {
        uno::Sequence< OUString > aRes;

        if (rVal.hasValue())
        {
            rVal >>= aRes;
    #if OSL_DEBUG_LEVEL > 0
            sal_Int32 nSvcs = aRes.getLength();
            if (nSvcs)
            {
                const OUString *pSvcName = aRes.getConstArray();
                for (sal_Int32 j = 0;  j < nSvcs;  ++j)
                {
                    SAL_WARN_IF( pSvcName[j].isEmpty(), "linguistic", "service impl-name missing" );
                }
            }
    #endif
        }

        return aRes;
    }

    static uno::Sequence< OUString > GetLangSvc( const uno::Any &rVal )
    {
        uno::Sequence< OUString > aRes;
        if (!rVal.hasValue())
            return aRes;

        // allowing for a sequence here as well (even though it should only
        // be a string) makes coding easier in other places since one needs
        // not make a special case for writing a string only and not a
        // sequence of strings.
        if (rVal >>= aRes)
        {
            // but only the first string should be used.
            if (aRes.getLength() > 1)
                aRes.realloc(1);
        }
        else
        {
            OUString aImplName;
            if ((rVal >>= aImplName) && !aImplName.isEmpty())
            {
                aRes.realloc(1);
                aRes.getArray()[0] = aImplName;
            }
            else
            {
                SAL_WARN( "linguistic", "GetLangSvc: unexpected type encountered" );
            }
        }

        return aRes;
    }

    uno::Sequence< OUString > SAL_CALL
        LngSvcMgr::getConfiguredServices(
                const OUString& rServiceName,
                const lang::Locale& rLocale )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        uno::Sequence< OUString > aSvcImplNames;

        OUString aCfgLocale( LanguageTag::convertToBcp47( rLocale) );

        uno::Sequence< uno::Any > aValues;
        uno::Sequence< OUString > aNames( 1 );
        OUString *pNames = aNames.getArray();
        if ( rServiceName == SN_SPELLCHECKER )
        {
            OUString aNode( "ServiceManager/SpellCheckerList");
            const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) );
            if (lcl_SeqHasString( aNodeEntries, aCfgLocale ))
            {
                pNames[0] = aNode + "/" + aCfgLocale;
                aValues = /*aCfg.*/GetProperties( aNames );
                if (aValues.getLength())
                    aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] );
            }
        }
        else if ( rServiceName == SN_GRAMMARCHECKER )
        {
            OUString aNode( "ServiceManager/GrammarCheckerList");
            const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) );
            if (lcl_SeqHasString( aNodeEntries, aCfgLocale ))
            {
                pNames[0] = aNode + "/" + aCfgLocale;
                aValues = /*aCfg.*/GetProperties( aNames );
                if (aValues.getLength())
                    aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] );
            }
        }
        else if ( rServiceName == SN_HYPHENATOR )
        {
            OUString aNode( "ServiceManager/HyphenatorList");
            const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) );
            if (lcl_SeqHasString( aNodeEntries, aCfgLocale ))
            {
                pNames[0] = aNode + "/" + aCfgLocale;
                aValues = /*aCfg.*/GetProperties( aNames );
                if (aValues.getLength())
                    aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] );
            }
        }
        else if ( rServiceName == SN_THESAURUS )
        {
            OUString aNode( "ServiceManager/ThesaurusList");
            const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) );
            if (lcl_SeqHasString( aNodeEntries, aCfgLocale ))
            {
                pNames[0] = aNode + "/" + aCfgLocale;
                aValues = /*aCfg.*/GetProperties( aNames );
                if (aValues.getLength())
                    aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] );
            }
        }

        return aSvcImplNames;
    }

    void SAL_CALL
        LngSvcMgr::dispose()
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        if (!bDisposing)
        {
            bDisposing = true;

            // require listeners to release this object
            lang::EventObject aEvtObj( static_cast<XLinguServiceManager*>(this) );
            aEvtListeners.disposeAndClear( aEvtObj );

            if (mxListenerHelper.is())
                mxListenerHelper->DisposeAndClear( aEvtObj );
        }
    }

    void SAL_CALL
        LngSvcMgr::addEventListener(
                const uno::Reference< lang::XEventListener >& xListener )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        if (!bDisposing  &&  xListener.is())
        {
            aEvtListeners.addInterface( xListener );
        }
    }

    void SAL_CALL
        LngSvcMgr::removeEventListener(
                const uno::Reference< lang::XEventListener >& xListener )
    {
        osl::MutexGuard aGuard( GetLinguMutex() );

        if (xListener.is())
        {
            aEvtListeners.removeInterface( xListener );
        }
    }

    bool LngSvcMgr::AddLngSvcEvtBroadcaster(
                const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster )
    {
        if (!rxBroadcaster.is())
            return false;
        if (!mxListenerHelper.is())
            GetListenerHelper_Impl();
        mxListenerHelper->AddLngSvcEvtBroadcaster( rxBroadcaster );
        return true;
    }

    OUString SAL_CALL
        LngSvcMgr::getImplementationName()
    {
        return getImplementationName_Static();
    }

    sal_Bool SAL_CALL
        LngSvcMgr::supportsService( const OUString& ServiceName )
    {
        return cppu::supportsService(this, ServiceName);
    }

    uno::Sequence< OUString > SAL_CALL
        LngSvcMgr::getSupportedServiceNames()
    {
        return getSupportedServiceNames_Static();
    }

    uno::Sequence< OUString > LngSvcMgr::getSupportedServiceNames_Static()
            throw()
    {
        uno::Sequence< OUString > aSNS { "com.sun.star.linguistic2.LinguServiceManager" };
        return aSNS;
    }

    /// @throws uno::Exception
    uno::Reference< uno::XInterface > LngSvcMgr_CreateInstance(
                const uno::Reference< lang::XMultiServiceFactory > & /*rSMgr*/ )
    {
        uno::Reference< uno::XInterface > xService = static_cast<cppu::OWeakObject*>(new LngSvcMgr);
        return xService;
    }

    void * LngSvcMgr_getFactory(
                const sal_Char * pImplName,
                lang::XMultiServiceFactory * pServiceManager )
    {

        void * pRet = nullptr;
        if ( LngSvcMgr::getImplementationName_Static().equalsAscii( pImplName ) )
        {
            uno::Reference< lang::XSingleServiceFactory > xFactory =
                cppu::createOneInstanceFactory(
                    pServiceManager,
                    LngSvcMgr::getImplementationName_Static(),
                    LngSvcMgr_CreateInstance,
                    LngSvcMgr::getSupportedServiceNames_Static());
            // acquire, because we return an interface pointer instead of a reference
            xFactory->acquire();
            pRet = xFactory.get();
        }
        return pRet;
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V560 A part of conditional expression is always true: bChanged.

↑ V560 A part of conditional expression is always true: bChanged.

↑ V560 A part of conditional expression is always true: bChanged.