| /************************************************************** |
| * |
| * 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/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/linguistic2/XSupportedLocales.hpp> |
| #include <com/sun/star/linguistic2/DictionaryListEventFlags.hpp> |
| #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp> |
| |
| #include <tools/solar.h> |
| #include <unotools/lingucfg.hxx> |
| #include <unotools/processfactory.hxx> |
| #include <i18npool/lang.h> |
| #include <i18npool/mslangid.hxx> |
| #include <cppuhelper/factory.hxx> |
| #include <comphelper/extract.hxx> |
| #include <rtl/logfile.hxx> |
| |
| #include <boost/checked_delete.hpp> |
| |
| #include "lngsvcmgr.hxx" |
| #include "lngopt.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; |
| using ::rtl::OUString; |
| |
| // forward declarations |
| uno::Sequence< OUString > static GetLangSvcList( const uno::Any &rVal ); |
| uno::Sequence< OUString > static GetLangSvc( const uno::Any &rVal ); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| static sal_Bool lcl_SeqHasString( const uno::Sequence< OUString > &rSeq, const OUString &rText ) |
| { |
| sal_Bool bRes = sal_False; |
| |
| sal_Int32 nLen = rSeq.getLength(); |
| if (nLen == 0 || rText.getLength() == 0) |
| return bRes; |
| |
| const OUString *pSeq = rSeq.getConstArray(); |
| for (sal_Int32 i = 0; i < nLen && !bRes; ++i) |
| { |
| if (rText == pSeq[i]) |
| bRes = sal_True; |
| } |
| return bRes; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| static uno::Sequence< lang::Locale > GetAvailLocales( |
| const uno::Sequence< OUString > &rSvcImplNames ) |
| { |
| uno::Sequence< lang::Locale > aRes; |
| |
| uno::Reference< lang::XMultiServiceFactory > xFac( utl::getProcessServiceFactory() ); |
| sal_Int32 nNames = rSvcImplNames.getLength(); |
| if (nNames && xFac.is()) |
| { |
| 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 = uno::Reference< linguistic2::XSupportedLocales >( |
| xFac->createInstanceWithArguments( pImplNames[i], aArgs ), uno::UNO_QUERY ); |
| } |
| catch (uno::Exception &) |
| { |
| DBG_ASSERT( 0, "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 = LocaleToLanguage( pLoc[k] ); |
| |
| // language not already added? |
| if (aLanguages.find( nLang ) == aLanguages.end()) |
| aLanguages.insert( nLang ); |
| } |
| } |
| else |
| { |
| DBG_ASSERT( 0, "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(); |
| std::set< LanguageType >::const_iterator aIt( aLanguages.begin() ); |
| for (i = 0; aIt != aLanguages.end(); ++aIt, ++i) |
| { |
| LanguageType nLang = *aIt; |
| pRes[i] = CreateLocale( nLang ); |
| } |
| } |
| |
| return aRes; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| struct SvcInfo |
| { |
| const OUString aSvcImplName; |
| const uno::Sequence< sal_Int16 > aSuppLanguages; |
| |
| SvcInfo( const OUString &rSvcImplName, |
| const uno::Sequence< sal_Int16 > &rSuppLanguages ) : |
| aSvcImplName (rSvcImplName), |
| aSuppLanguages (rSuppLanguages) |
| { |
| } |
| |
| sal_Bool HasLanguage( sal_Int16 nLanguage ) const; |
| }; |
| |
| |
| sal_Bool SvcInfo::HasLanguage( sal_Int16 nLanguage ) const |
| { |
| sal_Int32 nCnt = aSuppLanguages.getLength(); |
| const sal_Int16 *pLang = aSuppLanguages.getConstArray(); |
| sal_Int32 i; |
| |
| for ( i = 0; i < nCnt; ++i) |
| { |
| if (nLanguage == pLang[i]) |
| break; |
| } |
| return i < nCnt; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| |
| void LngSvcMgr::SetAvailableCfgServiceLists( LinguDispatcher &rDispatcher, |
| const SvcInfoArray &rAvailSvcs ) |
| { |
| // get list of nodenames to look at for their service list |
| const char *pEntryName = 0; |
| sal_Bool bHasLangSvcList = sal_True; |
| switch (rDispatcher.GetDspType()) |
| { |
| case LinguDispatcher::DSP_SPELL : pEntryName = "ServiceManager/SpellCheckerList"; break; |
| case LinguDispatcher::DSP_GRAMMAR : pEntryName = "ServiceManager/GrammarCheckerList"; |
| bHasLangSvcList = sal_False; |
| break; |
| case LinguDispatcher::DSP_HYPH : pEntryName = "ServiceManager/HyphenatorList"; |
| bHasLangSvcList = sal_False; |
| break; |
| case LinguDispatcher::DSP_THES : pEntryName = "ServiceManager/ThesaurusList"; break; |
| default : |
| DBG_ASSERT( 0, "unexpected case" ); |
| } |
| String aNode( String::CreateFromAscii( pEntryName ) ); |
| uno::Sequence < OUString > aNodeNames( /*aCfg.*/GetNodeNames( aNode ) ); |
| |
| |
| sal_Int32 nLen = aNodeNames.getLength(); |
| const OUString *pNodeNames = aNodeNames.getConstArray(); |
| for (sal_Int32 i = 0; i < nLen; ++i) |
| { |
| uno::Sequence< OUString > aSvcImplNames; |
| |
| uno::Sequence< OUString > aNames( 1 ); |
| OUString *pNames = aNames.getArray(); |
| |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += pNodeNames[i]; |
| pNames[0] = aPropName; |
| |
| uno::Sequence< uno::Any > aValues = /*aCfg.*/GetProperties( aNames ); |
| if (aValues.getLength()) |
| { |
| // get list of configured service names for the |
| // current node (language) |
| const uno::Any &rValue = aValues.getConstArray()[0]; |
| if (bHasLangSvcList) |
| aSvcImplNames = GetLangSvcList( rValue ); |
| else |
| aSvcImplNames = GetLangSvc( rValue ); |
| |
| sal_Int32 nSvcs = aSvcImplNames.getLength(); |
| if (nSvcs) |
| { |
| const OUString *pImplNames = aSvcImplNames.getConstArray(); |
| |
| LanguageType nLang = MsLangId::convertIsoStringToLanguage( pNodeNames[i] ); |
| |
| // build list of available services from those |
| sal_Int32 nCnt = 0; |
| uno::Sequence< OUString > aAvailSvcs( nSvcs ); |
| OUString *pAvailSvcs = aAvailSvcs.getArray(); |
| for (sal_Int32 k = 0; k < nSvcs; ++k) |
| { |
| // check for availability of the service |
| size_t nAvailSvcs = rAvailSvcs.size(); |
| for (size_t m = 0; m < nAvailSvcs; ++m) |
| { |
| const SvcInfo &rSvcInfo = *rAvailSvcs[m]; |
| if (rSvcInfo.aSvcImplName == pImplNames[k] && |
| rSvcInfo.HasLanguage( nLang )) |
| { |
| pAvailSvcs[ nCnt++ ] = rSvcInfo.aSvcImplName; |
| break; |
| } |
| } |
| } |
| |
| if (nCnt) |
| { |
| aAvailSvcs.realloc( nCnt ); |
| rDispatcher.SetServiceList( CreateLocale( nLang ), aAvailSvcs ); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| |
| class LngSvcMgrListenerHelper : |
| public cppu::WeakImplHelper2 |
| < |
| linguistic2::XLinguServiceEventListener, |
| linguistic2::XDictionaryListEventListener |
| > |
| { |
| LngSvcMgr &rMyManager; |
| // Timer aLaunchTimer; |
| |
| //cppu::OMultiTypeInterfaceContainerHelper aListeners; |
| ::cppu::OInterfaceContainerHelper aLngSvcMgrListeners; |
| ::cppu::OInterfaceContainerHelper aLngSvcEvtBroadcasters; |
| uno::Reference< linguistic2::XDictionaryList > xDicList; |
| uno::Reference< uno::XInterface > xMyEvtObj; |
| |
| sal_Int16 nCombinedLngSvcEvt; |
| |
| // disallow copy-constructor and assignment-operator for now |
| LngSvcMgrListenerHelper(const LngSvcMgrListenerHelper &); |
| LngSvcMgrListenerHelper & operator = (const LngSvcMgrListenerHelper &); |
| |
| void LaunchEvent( sal_Int16 nLngSvcEvtFlags ); |
| |
| // DECL_LINK( TimeOut, Timer* ); |
| long Timeout(); |
| |
| public: |
| LngSvcMgrListenerHelper( LngSvcMgr &rLngSvcMgr, |
| const uno::Reference< uno::XInterface > &rxSource, |
| const uno::Reference< linguistic2::XDictionaryList > &rxDicList ); |
| |
| // lang::XEventListener |
| virtual void SAL_CALL |
| disposing( const lang::EventObject& rSource ) |
| throw(uno::RuntimeException); |
| |
| // linguistic2::XLinguServiceEventListener |
| virtual void SAL_CALL |
| processLinguServiceEvent( const linguistic2::LinguServiceEvent& aLngSvcEvent ) |
| throw(uno::RuntimeException); |
| |
| // linguistic2::XDictionaryListEventListener |
| virtual void SAL_CALL |
| processDictionaryListEvent( |
| const linguistic2::DictionaryListEvent& rDicListEvent ) |
| throw(uno::RuntimeException); |
| |
| inline sal_Bool AddLngSvcMgrListener( |
| const uno::Reference< lang::XEventListener >& rxListener ); |
| inline sal_Bool RemoveLngSvcMgrListener( |
| const uno::Reference< lang::XEventListener >& rxListener ); |
| void DisposeAndClear( const lang::EventObject &rEvtObj ); |
| sal_Bool AddLngSvcEvtBroadcaster( |
| const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster ); |
| sal_Bool RemoveLngSvcEvtBroadcaster( |
| const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster ); |
| |
| void AddLngSvcEvt( sal_Int16 nLngSvcEvt ); |
| }; |
| |
| |
| LngSvcMgrListenerHelper::LngSvcMgrListenerHelper( |
| LngSvcMgr &rLngSvcMgr, |
| const uno::Reference< uno::XInterface > &rxSource, |
| const uno::Reference< linguistic2::XDictionaryList > &rxDicList ) : |
| rMyManager ( rLngSvcMgr ), |
| aLngSvcMgrListeners ( GetLinguMutex() ), |
| aLngSvcEvtBroadcasters ( GetLinguMutex() ), |
| xDicList ( rxDicList ), |
| xMyEvtObj ( rxSource ) |
| { |
| if (xDicList.is()) |
| { |
| xDicList->addDictionaryListEventListener( |
| (linguistic2::XDictionaryListEventListener *) this, sal_False ); |
| } |
| |
| //! The timer is used to 'sum up' different events in order to reduce the |
| //! number of events forwarded. |
| //! (This may happen already if a property was changed that has several |
| //! listeners, and each of them is launching an event of it's own!) |
| //! Thus this behaviour is necessary to avoid unecessary actions of |
| //! this objects listeners! |
| // aLaunchTimer.SetTimeout( 2000 ); |
| // aLaunchTimer.SetTimeoutHdl( LINK( this, LngSvcMgrListenerHelper, TimeOut ) ); |
| nCombinedLngSvcEvt = 0; |
| } |
| |
| |
| void SAL_CALL LngSvcMgrListenerHelper::disposing( const lang::EventObject& rSource ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| uno::Reference< uno::XInterface > xRef( rSource.Source ); |
| if ( xRef.is() ) |
| { |
| aLngSvcMgrListeners .removeInterface( xRef ); |
| aLngSvcEvtBroadcasters.removeInterface( xRef ); |
| if (xDicList == xRef) |
| xDicList = 0; |
| } |
| } |
| |
| |
| //IMPL_LINK( LngSvcMgrListenerHelper, TimeOut, Timer*, pTimer ) |
| long LngSvcMgrListenerHelper::Timeout() |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| // if (&aLaunchTimer == pTimer) |
| { |
| // 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( xMyEvtObj, nCombinedLngSvcEvt ); |
| nCombinedLngSvcEvt = 0; |
| |
| if (rMyManager.pSpellDsp) |
| rMyManager.pSpellDsp->FlushSpellCache(); |
| |
| // pass event on to linguistic2::XLinguServiceEventListener's |
| cppu::OInterfaceIteratorHelper aIt( aLngSvcMgrListeners ); |
| while (aIt.hasMoreElements()) |
| { |
| uno::Reference< linguistic2::XLinguServiceEventListener > xRef( aIt.next(), uno::UNO_QUERY ); |
| if (xRef.is()) |
| xRef->processLinguServiceEvent( aEvtObj ); |
| } |
| } |
| return 0; |
| } |
| |
| |
| void LngSvcMgrListenerHelper::AddLngSvcEvt( sal_Int16 nLngSvcEvt ) |
| { |
| nCombinedLngSvcEvt |= nLngSvcEvt; |
| // aLaunchTimer.Start(); |
| Timeout(); |
| } |
| |
| |
| void SAL_CALL |
| LngSvcMgrListenerHelper::processLinguServiceEvent( |
| const linguistic2::LinguServiceEvent& rLngSvcEvent ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| AddLngSvcEvt( rLngSvcEvent.nEvent ); |
| } |
| |
| |
| void SAL_CALL |
| LngSvcMgrListenerHelper::processDictionaryListEvent( |
| const linguistic2::DictionaryListEvent& rDicListEvent ) |
| throw(uno::RuntimeException) |
| { |
| 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 |
| cppu::OInterfaceIteratorHelper aIt( aLngSvcMgrListeners ); |
| while (aIt.hasMoreElements()) |
| { |
| uno::Reference< linguistic2::XDictionaryListEventListener > xRef( aIt.next(), uno::UNO_QUERY ); |
| if (xRef.is()) |
| xRef->processDictionaryListEvent( rDicListEvent ); |
| } |
| |
| // |
| // "translate" DictionaryList event into linguistic2::LinguServiceEvent |
| // |
| sal_Int16 nLngSvcEvt = 0; |
| // |
| sal_Int16 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 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 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.pSpellDsp) |
| rMyManager.pSpellDsp->FlushSpellCache(); |
| if (nLngSvcEvt) |
| LaunchEvent( nLngSvcEvt ); |
| } |
| |
| |
| void LngSvcMgrListenerHelper::LaunchEvent( sal_Int16 nLngSvcEvtFlags ) |
| { |
| linguistic2::LinguServiceEvent aEvt( xMyEvtObj, nLngSvcEvtFlags ); |
| |
| // pass event on to linguistic2::XLinguServiceEventListener's |
| cppu::OInterfaceIteratorHelper aIt( aLngSvcMgrListeners ); |
| while (aIt.hasMoreElements()) |
| { |
| uno::Reference< linguistic2::XLinguServiceEventListener > xRef( aIt.next(), uno::UNO_QUERY ); |
| if (xRef.is()) |
| xRef->processLinguServiceEvent( aEvt ); |
| } |
| } |
| |
| |
| inline sal_Bool LngSvcMgrListenerHelper::AddLngSvcMgrListener( |
| const uno::Reference< lang::XEventListener >& rxListener ) |
| { |
| aLngSvcMgrListeners.addInterface( rxListener ); |
| return sal_True; |
| } |
| |
| |
| inline sal_Bool LngSvcMgrListenerHelper::RemoveLngSvcMgrListener( |
| const uno::Reference< lang::XEventListener >& rxListener ) |
| { |
| aLngSvcMgrListeners.removeInterface( rxListener ); |
| return sal_True; |
| } |
| |
| |
| 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 |
| cppu::OInterfaceIteratorHelper aIt( aLngSvcEvtBroadcasters ); |
| while (aIt.hasMoreElements()) |
| { |
| uno::Reference< linguistic2::XLinguServiceEventBroadcaster > xRef( aIt.next(), uno::UNO_QUERY ); |
| if (xRef.is()) |
| RemoveLngSvcEvtBroadcaster( xRef ); |
| } |
| |
| // remove refernce to this object hold by the dictionary-list |
| if (xDicList.is()) |
| { |
| xDicList->removeDictionaryListEventListener( |
| (linguistic2::XDictionaryListEventListener *) this ); |
| xDicList = 0; |
| } |
| } |
| |
| |
| sal_Bool LngSvcMgrListenerHelper::AddLngSvcEvtBroadcaster( |
| const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster ) |
| { |
| sal_Bool bRes = sal_False; |
| if (rxBroadcaster.is()) |
| { |
| aLngSvcEvtBroadcasters.addInterface( rxBroadcaster ); |
| rxBroadcaster->addLinguServiceEventListener( |
| (linguistic2::XLinguServiceEventListener *) this ); |
| } |
| return bRes; |
| } |
| |
| |
| sal_Bool LngSvcMgrListenerHelper::RemoveLngSvcEvtBroadcaster( |
| const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster ) |
| { |
| sal_Bool bRes = sal_False; |
| if (rxBroadcaster.is()) |
| { |
| aLngSvcEvtBroadcasters.removeInterface( rxBroadcaster ); |
| rxBroadcaster->removeLinguServiceEventListener( |
| (linguistic2::XLinguServiceEventListener *) this ); |
| } |
| return bRes; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| |
| LngSvcMgr::LngSvcMgr() : |
| utl::ConfigItem( String::CreateFromAscii( "Office.Linguistic" ) ), |
| aEvtListeners ( GetLinguMutex() ) |
| { |
| bHasAvailSpellLocales = |
| bHasAvailGrammarLocales = |
| bHasAvailHyphLocales = |
| bHasAvailThesLocales = |
| bDisposing = sal_False; |
| |
| pSpellDsp = 0; |
| pGrammarDsp = 0; |
| pHyphDsp = 0; |
| pThesDsp = 0; |
| |
| pAvailSpellSvcs = 0; |
| pAvailGrammarSvcs = 0; |
| pAvailHyphSvcs = 0; |
| pAvailThesSvcs = 0; |
| pListenerHelper = 0; |
| |
| // request notify events when properties (i.e. something in the subtree) changes |
| uno::Sequence< OUString > aNames(4); |
| OUString *pNames = aNames.getArray(); |
| pNames[0] = A2OU( "ServiceManager/SpellCheckerList" ); |
| pNames[1] = A2OU( "ServiceManager/GrammarCheckerList" ); |
| pNames[2] = A2OU( "ServiceManager/HyphenatorList" ); |
| pNames[3] = A2OU( "ServiceManager/ThesaurusList" ); |
| EnableNotification( aNames ); |
| } |
| |
| void LngSvcMgr::clearSvcInfoArray(SvcInfoArray* pInfo) |
| { |
| if (pInfo) |
| { |
| std::for_each(pInfo->begin(), pInfo->end(), boost::checked_deleter<SvcInfo>()); |
| delete pInfo; |
| } |
| } |
| |
| LngSvcMgr::~LngSvcMgr() |
| { |
| // memory for pSpellDsp, pHyphDsp, pThesDsp, pListenerHelper |
| // will be freed in the destructor of the respective Reference's |
| // xSpellDsp, xGrammarDsp, xHyphDsp, xThesDsp |
| |
| clearSvcInfoArray(pAvailSpellSvcs); |
| clearSvcInfoArray(pAvailGrammarSvcs); |
| clearSvcInfoArray(pAvailHyphSvcs); |
| clearSvcInfoArray(pAvailThesSvcs); |
| } |
| |
| |
| void LngSvcMgr::Notify( const uno::Sequence< OUString > &rPropertyNames ) |
| { |
| const OUString aSpellCheckerList( A2OU("ServiceManager/SpellCheckerList") ); |
| const OUString aGrammarCheckerList( A2OU("ServiceManager/GrammarCheckerList") ); |
| const OUString aHyphenatorList( A2OU("ServiceManager/HyphenatorList") ); |
| const OUString aThesaurusList( A2OU("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 ); |
| DBG_ASSERT( aKeyText.getLength() != 0, "unexpected key (lang::Locale) string" ); |
| if (0 == rName.compareTo( aSpellCheckerList, aSpellCheckerList.getLength() )) |
| { |
| // delete old cached data, needs to be acquired new on demand |
| clearSvcInfoArray(pAvailSpellSvcs); pAvailSpellSvcs = 0; |
| |
| OUString aNode( aSpellCheckerList ); |
| if (lcl_SeqHasString( aSpellCheckerListEntries, aKeyText )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aKeyText; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| uno::Sequence< OUString > aSvcImplNames; |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] ); |
| |
| LanguageType nLang = LANGUAGE_NONE; |
| if (0 != aKeyText.getLength()) |
| nLang = MsLangId::convertIsoStringToLanguage( aKeyText ); |
| |
| GetSpellCheckerDsp_Impl( sal_False ); // don't set service list, it will be done below |
| pSpellDsp->SetServiceList( CreateLocale(nLang), aSvcImplNames ); |
| } |
| } |
| else if (0 == rName.compareTo( aGrammarCheckerList, aGrammarCheckerList.getLength() )) |
| { |
| // delete old cached data, needs to be acquired new on demand |
| clearSvcInfoArray(pAvailGrammarSvcs); pAvailGrammarSvcs = 0; |
| |
| OUString aNode( aGrammarCheckerList ); |
| if (lcl_SeqHasString( aGrammarCheckerListEntries, aKeyText )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aKeyText; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| uno::Sequence< OUString > aSvcImplNames; |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] ); |
| |
| LanguageType nLang = LANGUAGE_NONE; |
| if (0 != aKeyText.getLength()) |
| nLang = MsLangId::convertIsoStringToLanguage( aKeyText ); |
| |
| if (SvtLinguConfig().HasGrammarChecker()) |
| { |
| GetGrammarCheckerDsp_Impl( sal_False ); // don't set service list, it will be done below |
| pGrammarDsp->SetServiceList( CreateLocale(nLang), aSvcImplNames ); |
| } |
| } |
| } |
| else if (0 == rName.compareTo( aHyphenatorList, aHyphenatorList.getLength() )) |
| { |
| // delete old cached data, needs to be acquired new on demand |
| clearSvcInfoArray(pAvailHyphSvcs); pAvailHyphSvcs = 0; |
| |
| OUString aNode( aHyphenatorList ); |
| if (lcl_SeqHasString( aHyphenatorListEntries, aKeyText )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aKeyText; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| uno::Sequence< OUString > aSvcImplNames; |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] ); |
| |
| LanguageType nLang = LANGUAGE_NONE; |
| if (0 != aKeyText.getLength()) |
| nLang = MsLangId::convertIsoStringToLanguage( aKeyText ); |
| |
| GetHyphenatorDsp_Impl( sal_False ); // don't set service list, it will be done below |
| pHyphDsp->SetServiceList( CreateLocale(nLang), aSvcImplNames ); |
| } |
| } |
| else if (0 == rName.compareTo( aThesaurusList, aThesaurusList.getLength() )) |
| { |
| // delete old cached data, needs to be acquired new on demand |
| clearSvcInfoArray(pAvailThesSvcs); pAvailThesSvcs = 0; |
| |
| OUString aNode( aThesaurusList ); |
| if (lcl_SeqHasString( aThesaurusListEntries, aKeyText )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aKeyText; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| uno::Sequence< OUString > aSvcImplNames; |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] ); |
| |
| LanguageType nLang = LANGUAGE_NONE; |
| if (0 != aKeyText.getLength()) |
| nLang = MsLangId::convertIsoStringToLanguage( aKeyText ); |
| |
| GetThesaurusDsp_Impl( sal_False ); // don't set service list, it will be done below |
| pThesDsp->SetServiceList( CreateLocale(nLang), aSvcImplNames ); |
| } |
| } |
| else |
| { |
| DBG_ASSERT( 0, "nofified for unexpected property" ); |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::Commit() |
| { |
| // everything necessary should have already been done by 'SaveCfgSvcs' |
| // called from within 'setConfiguredServices'. |
| // Also this class usually exits only when the Office i sbeing shutdown. |
| } |
| |
| |
| void LngSvcMgr::GetListenerHelper_Impl() |
| { |
| if (!pListenerHelper) |
| { |
| pListenerHelper = new LngSvcMgrListenerHelper( *this, |
| (XLinguServiceManager *) this, linguistic::GetDictionaryList() ); |
| xListenerHelper = (linguistic2::XLinguServiceEventListener *) pListenerHelper; |
| } |
| } |
| |
| |
| void LngSvcMgr::GetSpellCheckerDsp_Impl( sal_Bool bSetSvcList ) |
| { |
| if (!pSpellDsp) |
| { |
| pSpellDsp = new SpellCheckerDispatcher( *this ); |
| xSpellDsp = pSpellDsp; |
| if (bSetSvcList) |
| SetCfgServiceLists( *pSpellDsp ); |
| } |
| } |
| |
| |
| void LngSvcMgr::GetGrammarCheckerDsp_Impl( sal_Bool bSetSvcList ) |
| { |
| if (!pGrammarDsp && 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 |
| { |
| uno::Reference< lang::XMultiServiceFactory > xMgr( |
| utl::getProcessServiceFactory(), uno::UNO_QUERY_THROW ); |
| xGCI = uno::Reference< linguistic2::XProofreadingIterator >( |
| xMgr->createInstance( A2OU( SN_GRAMMARCHECKINGITERATOR ) ), uno::UNO_QUERY_THROW ); |
| } |
| catch (uno::Exception &) |
| { |
| } |
| DBG_ASSERT( xGCI.is(), "instantiating grammar checking iterator failed" ); |
| |
| if (xGCI.is()) |
| { |
| pGrammarDsp = dynamic_cast< GrammarCheckingIterator * >(xGCI.get()); |
| xGrammarDsp = xGCI; |
| DBG_ASSERT( pGrammarDsp, "failed to get implementation" ); |
| if (bSetSvcList) |
| SetCfgServiceLists( *pGrammarDsp ); |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::GetHyphenatorDsp_Impl( sal_Bool bSetSvcList ) |
| { |
| if (!pHyphDsp) |
| { |
| pHyphDsp = new HyphenatorDispatcher( *this ); |
| xHyphDsp = pHyphDsp; |
| if (bSetSvcList) |
| SetCfgServiceLists( *pHyphDsp ); |
| } |
| } |
| |
| |
| void LngSvcMgr::GetThesaurusDsp_Impl( sal_Bool bSetSvcList ) |
| { |
| if (!pThesDsp) |
| { |
| pThesDsp = new ThesaurusDispatcher; |
| xThesDsp = pThesDsp; |
| if (bSetSvcList) |
| SetCfgServiceLists( *pThesDsp ); |
| } |
| } |
| |
| |
| void LngSvcMgr::GetAvailableSpellSvcs_Impl() |
| { |
| if (!pAvailSpellSvcs) |
| { |
| pAvailSpellSvcs = new SvcInfoArray; |
| |
| uno::Reference< lang::XMultiServiceFactory > xFac( utl::getProcessServiceFactory() ); |
| if (xFac.is()) |
| { |
| uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xFac, uno::UNO_QUERY ); |
| uno::Reference< container::XEnumeration > xEnum; |
| if (xEnumAccess.is()) |
| xEnum = xEnumAccess->createContentEnumeration( |
| A2OU( 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; |
| if ( cppu::extractInterface( xCompFactory, aCurrent ) || ::cppu::extractInterface( xFactory, aCurrent ) ) |
| { |
| try |
| { |
| uno::Reference < uno::XComponentContext > xContext; |
| uno::Reference< beans::XPropertySet > xProps( xFac, uno::UNO_QUERY ); |
| |
| xProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xContext; |
| xSvc = uno::Reference< linguistic2::XSpellChecker >( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY ); |
| } |
| catch (uno::Exception &rEx) |
| { |
| (void) rEx; |
| DBG_ASSERT( 0, "createInstance failed" ); |
| } |
| } |
| |
| if (xSvc.is()) |
| { |
| OUString aImplName; |
| uno::Sequence< sal_Int16 > aLanguages; |
| uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY ); |
| if (xInfo.is()) |
| aImplName = xInfo->getImplementationName(); |
| DBG_ASSERT( aImplName.getLength(), |
| "empty implementation name" ); |
| uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY ); |
| DBG_ASSERT( xSuppLoc.is(), "interfaces not supported" ); |
| if (xSuppLoc.is()) { |
| uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales()); |
| aLanguages = LocaleSeqToLangSeq( aLocaleSequence ); |
| } |
| |
| pAvailSpellSvcs->push_back( new SvcInfo( aImplName, aLanguages ) ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::GetAvailableGrammarSvcs_Impl() |
| { |
| if (!pAvailGrammarSvcs) |
| { |
| pAvailGrammarSvcs = new SvcInfoArray; |
| |
| uno::Reference< lang::XMultiServiceFactory > xFac( utl::getProcessServiceFactory() ); |
| if (xFac.is()) |
| { |
| uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xFac, uno::UNO_QUERY ); |
| uno::Reference< container::XEnumeration > xEnum; |
| if (xEnumAccess.is()) |
| xEnum = xEnumAccess->createContentEnumeration( |
| A2OU( 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; |
| if ( cppu::extractInterface( xCompFactory, aCurrent ) || ::cppu::extractInterface( xFactory, aCurrent ) ) |
| { |
| try |
| { |
| uno::Reference < uno::XComponentContext > xContext; |
| uno::Reference< beans::XPropertySet > xProps( xFac, uno::UNO_QUERY ); |
| |
| xProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xContext; |
| xSvc = uno::Reference< linguistic2::XProofreader >( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY ); |
| } |
| catch (uno::Exception &rEx) |
| { |
| (void) rEx; |
| DBG_ASSERT( 0, "createInstance failed" ); |
| } |
| } |
| |
| if (xSvc.is()) |
| { |
| OUString aImplName; |
| uno::Sequence< sal_Int16 > aLanguages; |
| uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY ); |
| if (xInfo.is()) |
| aImplName = xInfo->getImplementationName(); |
| DBG_ASSERT( aImplName.getLength(), |
| "empty implementation name" ); |
| uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY ); |
| DBG_ASSERT( xSuppLoc.is(), "interfaces not supported" ); |
| if (xSuppLoc.is()) { |
| uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales()); |
| aLanguages = LocaleSeqToLangSeq( aLocaleSequence ); |
| } |
| |
| pAvailGrammarSvcs->push_back( new SvcInfo( aImplName, aLanguages ) ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::GetAvailableHyphSvcs_Impl() |
| { |
| if (!pAvailHyphSvcs) |
| { |
| pAvailHyphSvcs = new SvcInfoArray; |
| uno::Reference< lang::XMultiServiceFactory > xFac( utl::getProcessServiceFactory() ); |
| if (xFac.is()) |
| { |
| uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xFac, uno::UNO_QUERY ); |
| uno::Reference< container::XEnumeration > xEnum; |
| if (xEnumAccess.is()) |
| xEnum = xEnumAccess->createContentEnumeration( A2OU( 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; |
| if ( cppu::extractInterface( xCompFactory, aCurrent ) || ::cppu::extractInterface( xFactory, aCurrent ) ) |
| { |
| try |
| { |
| uno::Reference < uno::XComponentContext > xContext; |
| uno::Reference< beans::XPropertySet > xProps( xFac, uno::UNO_QUERY ); |
| |
| xProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xContext; |
| xSvc = uno::Reference< linguistic2::XHyphenator >( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY ); |
| |
| } |
| catch (uno::Exception &rEx) |
| { |
| (void) rEx; |
| DBG_ASSERT( 0, "createInstance failed" ); |
| } |
| } |
| |
| if (xSvc.is()) |
| { |
| OUString aImplName; |
| uno::Sequence< sal_Int16 > aLanguages; |
| uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY ); |
| if (xInfo.is()) |
| aImplName = xInfo->getImplementationName(); |
| DBG_ASSERT( aImplName.getLength(), |
| "empty implementation name" ); |
| uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY ); |
| DBG_ASSERT( xSuppLoc.is(), "interfaces not supported" ); |
| if (xSuppLoc.is()) { |
| uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales()); |
| aLanguages = LocaleSeqToLangSeq( aLocaleSequence ); |
| } |
| |
| pAvailHyphSvcs->push_back( new SvcInfo( aImplName, aLanguages ) ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::GetAvailableThesSvcs_Impl() |
| { |
| if (!pAvailThesSvcs) |
| { |
| pAvailThesSvcs = new SvcInfoArray; |
| |
| uno::Reference< lang::XMultiServiceFactory > xFac( utl::getProcessServiceFactory() ); |
| if (xFac.is()) |
| { |
| uno::Reference< container::XContentEnumerationAccess > xEnumAccess( xFac, uno::UNO_QUERY ); |
| uno::Reference< container::XEnumeration > xEnum; |
| if (xEnumAccess.is()) |
| xEnum = xEnumAccess->createContentEnumeration( |
| A2OU( 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; |
| if ( cppu::extractInterface( xCompFactory, aCurrent ) || ::cppu::extractInterface( xFactory, aCurrent ) ) |
| { |
| try |
| { |
| uno::Reference < uno::XComponentContext > xContext; |
| uno::Reference< beans::XPropertySet > xProps( xFac, uno::UNO_QUERY ); |
| |
| xProps->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ))) >>= xContext; |
| xSvc = uno::Reference< linguistic2::XThesaurus >( ( xCompFactory.is() ? xCompFactory->createInstanceWithContext( xContext ) : xFactory->createInstance() ), uno::UNO_QUERY ); |
| } |
| catch (uno::Exception &rEx) |
| { |
| (void) rEx; |
| DBG_ASSERT( 0, "createInstance failed" ); |
| } |
| } |
| |
| if (xSvc.is()) |
| { |
| OUString aImplName; |
| uno::Sequence< sal_Int16 > aLanguages; |
| uno::Reference< XServiceInfo > xInfo( xSvc, uno::UNO_QUERY ); |
| if (xInfo.is()) |
| aImplName = xInfo->getImplementationName(); |
| DBG_ASSERT( aImplName.getLength(), |
| "empty implementation name" ); |
| uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xSvc, uno::UNO_QUERY ); |
| DBG_ASSERT( xSuppLoc.is(), "interfaces not supported" ); |
| if (xSuppLoc.is()) { |
| uno::Sequence<lang::Locale> aLocaleSequence(xSuppLoc->getLocales()); |
| aLanguages = LocaleSeqToLangSeq( aLocaleSequence ); |
| } |
| |
| pAvailThesSvcs->push_back( new SvcInfo( aImplName, aLanguages ) ); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::SetCfgServiceLists( SpellCheckerDispatcher &rSpellDsp ) |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "linguistic: LngSvcMgr::SetCfgServiceLists - Spell" ); |
| |
| String aNode( String::CreateFromAscii( "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 |
| String aPrefix( aNode ); |
| aPrefix.Append( (sal_Unicode) '/' ); |
| for (int i = 0; i < nLen; ++i) |
| { |
| OUString aTmp( aPrefix ); |
| aTmp += pNames[i]; |
| pNames[i] = aTmp; |
| } |
| |
| 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) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| // sal_Int32 nSvcs = aSvcImplNames.getLength(); |
| // const OUString *pSvcImplNames = aSvcImplNames.getConstArray(); |
| #endif |
| String aLocaleStr( pNames[i] ); |
| xub_StrLen nSeperatorPos = aLocaleStr.SearchBackward( sal_Unicode( '/' ) ); |
| aLocaleStr = aLocaleStr.Copy( nSeperatorPos + 1 ); |
| lang::Locale aLocale( CreateLocale( MsLangId::convertIsoStringToLanguage(aLocaleStr) ) ); |
| rSpellDsp.SetServiceList( aLocale, aSvcImplNames ); |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::SetCfgServiceLists( GrammarCheckingIterator &rGrammarDsp ) |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "linguistic: LngSvcMgr::SetCfgServiceLists - Grammar" ); |
| |
| String aNode( String::CreateFromAscii( "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 |
| String aPrefix( aNode ); |
| aPrefix.Append( (sal_Unicode) '/' ); |
| for (int i = 0; i < nLen; ++i) |
| { |
| OUString aTmp( aPrefix ); |
| aTmp += pNames[i]; |
| pNames[i] = aTmp; |
| } |
| |
| 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); |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| // sal_Int32 nSvcs = aSvcImplNames.getLength(); |
| // const OUString *pSvcImplNames = aSvcImplNames.getConstArray(); |
| #endif |
| String aLocaleStr( pNames[i] ); |
| xub_StrLen nSeperatorPos = aLocaleStr.SearchBackward( sal_Unicode( '/' ) ); |
| aLocaleStr = aLocaleStr.Copy( nSeperatorPos + 1 ); |
| lang::Locale aLocale( CreateLocale( MsLangId::convertIsoStringToLanguage(aLocaleStr) ) ); |
| rGrammarDsp.SetServiceList( aLocale, aSvcImplNames ); |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::SetCfgServiceLists( HyphenatorDispatcher &rHyphDsp ) |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "linguistic: LngSvcMgr::SetCfgServiceLists - Hyph" ); |
| |
| String aNode( String::CreateFromAscii( "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 |
| String aPrefix( aNode ); |
| aPrefix.Append( (sal_Unicode) '/' ); |
| for (int i = 0; i < nLen; ++i) |
| { |
| OUString aTmp( aPrefix ); |
| aTmp += pNames[i]; |
| pNames[i] = aTmp; |
| } |
| |
| 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); |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| // sal_Int32 nSvcs = aSvcImplNames.getLength(); |
| // const OUString *pSvcImplNames = aSvcImplNames.getConstArray(); |
| #endif |
| String aLocaleStr( pNames[i] ); |
| xub_StrLen nSeperatorPos = aLocaleStr.SearchBackward( sal_Unicode( '/' ) ); |
| aLocaleStr = aLocaleStr.Copy( nSeperatorPos + 1 ); |
| lang::Locale aLocale( CreateLocale( MsLangId::convertIsoStringToLanguage(aLocaleStr) ) ); |
| rHyphDsp.SetServiceList( aLocale, aSvcImplNames ); |
| } |
| } |
| } |
| } |
| |
| |
| void LngSvcMgr::SetCfgServiceLists( ThesaurusDispatcher &rThesDsp ) |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "linguistic: LngSvcMgr::SetCfgServiceLists - Thes" ); |
| |
| String aNode( String::CreateFromAscii( "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 |
| String aPrefix( aNode ); |
| aPrefix.Append( (sal_Unicode) '/' ); |
| for (int i = 0; i < nLen; ++i) |
| { |
| OUString aTmp( aPrefix ); |
| aTmp += pNames[i]; |
| pNames[i] = aTmp; |
| } |
| |
| 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) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| // sal_Int32 nSvcs = aSvcImplNames.getLength(); |
| // const OUString *pSvcImplNames = aSvcImplNames.getConstArray(); |
| #endif |
| String aLocaleStr( pNames[i] ); |
| xub_StrLen nSeperatorPos = aLocaleStr.SearchBackward( sal_Unicode( '/' ) ); |
| aLocaleStr = aLocaleStr.Copy( nSeperatorPos + 1 ); |
| lang::Locale aLocale( CreateLocale( MsLangId::convertIsoStringToLanguage(aLocaleStr) ) ); |
| rThesDsp.SetServiceList( aLocale, aSvcImplNames ); |
| } |
| } |
| } |
| } |
| |
| |
| uno::Reference< linguistic2::XSpellChecker > SAL_CALL |
| LngSvcMgr::getSpellChecker() |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| #if OSL_DEBUG_LEVEL > 1 |
| getAvailableLocales( A2OU( SN_SPELLCHECKER )); |
| #endif |
| |
| uno::Reference< linguistic2::XSpellChecker > xRes; |
| if (!bDisposing) |
| { |
| if (!xSpellDsp.is()) |
| GetSpellCheckerDsp_Impl(); |
| xRes = xSpellDsp; |
| } |
| return xRes; |
| } |
| |
| |
| uno::Reference< linguistic2::XHyphenator > SAL_CALL |
| LngSvcMgr::getHyphenator() |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| #if OSL_DEBUG_LEVEL > 1 |
| getAvailableLocales( A2OU( SN_HYPHENATOR )); |
| #endif |
| |
| uno::Reference< linguistic2::XHyphenator > xRes; |
| if (!bDisposing) |
| { |
| if (!xHyphDsp.is()) |
| GetHyphenatorDsp_Impl(); |
| xRes = xHyphDsp; |
| } |
| return xRes; |
| } |
| |
| |
| uno::Reference< linguistic2::XThesaurus > SAL_CALL |
| LngSvcMgr::getThesaurus() |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| #if OSL_DEBUG_LEVEL > 1 |
| getAvailableLocales( A2OU( SN_THESAURUS )); |
| #endif |
| |
| uno::Reference< linguistic2::XThesaurus > xRes; |
| if (!bDisposing) |
| { |
| if (!xThesDsp.is()) |
| GetThesaurusDsp_Impl(); |
| xRes = xThesDsp; |
| } |
| return xRes; |
| } |
| |
| |
| sal_Bool SAL_CALL |
| LngSvcMgr::addLinguServiceManagerListener( |
| const uno::Reference< lang::XEventListener >& xListener ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| sal_Bool bRes = sal_False; |
| if (!bDisposing && xListener.is()) |
| { |
| if (!pListenerHelper) |
| GetListenerHelper_Impl(); |
| bRes = pListenerHelper->AddLngSvcMgrListener( xListener ); |
| } |
| return bRes; |
| } |
| |
| |
| sal_Bool SAL_CALL |
| LngSvcMgr::removeLinguServiceManagerListener( |
| const uno::Reference< lang::XEventListener >& xListener ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| sal_Bool bRes = sal_False; |
| if (!bDisposing && xListener.is()) |
| { |
| DBG_ASSERT( pListenerHelper, "listener removed without being added" ); |
| if (!pListenerHelper) |
| GetListenerHelper_Impl(); |
| bRes = pListenerHelper->RemoveLngSvcMgrListener( xListener ); |
| } |
| return bRes; |
| } |
| |
| |
| uno::Sequence< OUString > SAL_CALL |
| LngSvcMgr::getAvailableServices( |
| const OUString& rServiceName, |
| const lang::Locale& rLocale ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| uno::Sequence< OUString > aRes; |
| const SvcInfoArray *pInfoArray = 0; |
| |
| if (0 == rServiceName.compareToAscii( SN_SPELLCHECKER )) |
| { |
| // don't used cached data here (force re-evaluation in order to have downloaded dictionaries |
| // already found without the need to restart the office |
| clearSvcInfoArray(pAvailSpellSvcs); pAvailSpellSvcs = 0; |
| GetAvailableSpellSvcs_Impl(); |
| pInfoArray = pAvailSpellSvcs; |
| } |
| else if (0 == rServiceName.compareToAscii( SN_GRAMMARCHECKER )) |
| { |
| // don't clear cache as it makes start with some extentions so slow it looks |
| // like a freeze (a restart is needed anyway after grammar checker installation), |
| // see https://issues.apache.org/ooo/show_bug.cgi?id=116409 |
| //clearSvcInfoArray(pAvailGrammarSvcs); pAvailGrammarSvcs = 0; |
| GetAvailableGrammarSvcs_Impl(); |
| pInfoArray = pAvailGrammarSvcs; |
| } |
| else if (0 == rServiceName.compareToAscii( SN_HYPHENATOR )) |
| { |
| // don't used cached data here (force re-evaluation in order to have downloaded dictionaries |
| // already found without the need to restart the office |
| clearSvcInfoArray(pAvailHyphSvcs); pAvailHyphSvcs = 0; |
| GetAvailableHyphSvcs_Impl(); |
| pInfoArray = pAvailHyphSvcs; |
| } |
| else if (0 == rServiceName.compareToAscii( SN_THESAURUS )) |
| { |
| // don't used cached data here (force re-evaluation in order to have downloaded dictionaries |
| // already found without the need to restart the office |
| clearSvcInfoArray(pAvailThesSvcs); pAvailThesSvcs = 0; |
| GetAvailableThesSvcs_Impl(); |
| pInfoArray = pAvailThesSvcs; |
| } |
| |
| 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 = LocaleToLanguage( rLocale ); |
| for (size_t i = 0; i < nMaxCnt; ++i) |
| { |
| const SvcInfo *pInfo = (*pInfoArray)[i]; |
| if (LANGUAGE_NONE == nLanguage |
| || (pInfo && pInfo->HasLanguage( nLanguage ))) |
| { |
| pImplName[ nCnt++ ] = pInfo->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 ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| uno::Sequence< lang::Locale > aRes; |
| |
| uno::Sequence< lang::Locale > *pAvailLocales = NULL; |
| sal_Bool *pHasAvailLocales = NULL; |
| if (0 == rServiceName.compareToAscii( SN_SPELLCHECKER )) |
| { |
| pAvailLocales = &aAvailSpellLocales; |
| pHasAvailLocales = &bHasAvailSpellLocales; |
| } |
| else if (0 == rServiceName.compareToAscii( SN_GRAMMARCHECKER )) |
| { |
| pAvailLocales = &aAvailGrammarLocales; |
| pHasAvailLocales = &bHasAvailGrammarLocales; |
| } |
| else if (0 == rServiceName.compareToAscii( SN_HYPHENATOR )) |
| { |
| pAvailLocales = &aAvailHyphLocales; |
| pHasAvailLocales = &bHasAvailHyphLocales; |
| } |
| else if (0 == rServiceName.compareToAscii( SN_THESAURUS )) |
| { |
| pAvailLocales = &aAvailThesLocales; |
| pHasAvailLocales = &bHasAvailThesLocales; |
| } |
| |
| // about pHasAvailLocales: 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 /*&& pHasAvailLocales */) |
| { |
| // if (!*pHasAvailLocales) |
| // { |
| *pAvailLocales = GetAvailLocales( |
| getAvailableServices( rServiceName, lang::Locale() ) ); |
| // *pHasAvailLocales = sal_True; |
| // } |
| aRes = *pAvailLocales; |
| } |
| |
| return aRes; |
| } |
| |
| static sal_Bool IsEqSvcList( const uno::Sequence< OUString > &rList1, |
| const uno::Sequence< OUString > &rList2 ) |
| { |
| // returns sal_True iff both sequences are equal |
| |
| sal_Bool bRes = sal_False; |
| sal_Int32 nLen = rList1.getLength(); |
| if (rList2.getLength() == nLen) |
| { |
| const OUString *pStr1 = rList1.getConstArray(); |
| const OUString *pStr2 = rList2.getConstArray(); |
| bRes = sal_True; |
| for (sal_Int32 i = 0; i < nLen && bRes; ++i) |
| { |
| if (*pStr1++ != *pStr2++) |
| bRes = sal_False; |
| } |
| } |
| return bRes; |
| } |
| |
| |
| void SAL_CALL |
| LngSvcMgr::setConfiguredServices( |
| const OUString& rServiceName, |
| const lang::Locale& rLocale, |
| const uno::Sequence< OUString >& rServiceImplNames ) |
| throw(uno::RuntimeException) |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "linguistic: LngSvcMgr::setConfiguredServices" ); |
| |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| // const OUString *pImplNames = rServiceImplNames.getConstArray(); |
| #endif |
| |
| LanguageType nLanguage = LocaleToLanguage( rLocale ); |
| if (LANGUAGE_NONE != nLanguage) |
| { |
| if (0 == rServiceName.compareToAscii( SN_SPELLCHECKER )) |
| { |
| if (!xSpellDsp.is()) |
| GetSpellCheckerDsp_Impl(); |
| sal_Bool bChanged = !IsEqSvcList( rServiceImplNames, |
| pSpellDsp->GetServiceList( rLocale ) ); |
| if (bChanged) |
| { |
| pSpellDsp->SetServiceList( rLocale, rServiceImplNames ); |
| SaveCfgSvcs( A2OU( SN_SPELLCHECKER ) ); |
| |
| if (pListenerHelper && bChanged) |
| pListenerHelper->AddLngSvcEvt( |
| linguistic2::LinguServiceEventFlags::SPELL_CORRECT_WORDS_AGAIN | |
| linguistic2::LinguServiceEventFlags::SPELL_WRONG_WORDS_AGAIN ); |
| } |
| } |
| else if (0 == rServiceName.compareToAscii( SN_GRAMMARCHECKER )) |
| { |
| if (!xGrammarDsp.is()) |
| GetGrammarCheckerDsp_Impl(); |
| sal_Bool bChanged = !IsEqSvcList( rServiceImplNames, |
| pGrammarDsp->GetServiceList( rLocale ) ); |
| if (bChanged) |
| { |
| pGrammarDsp->SetServiceList( rLocale, rServiceImplNames ); |
| SaveCfgSvcs( A2OU( SN_GRAMMARCHECKER ) ); |
| |
| if (pListenerHelper && bChanged) |
| pListenerHelper->AddLngSvcEvt( |
| linguistic2::LinguServiceEventFlags::PROOFREAD_AGAIN ); |
| } |
| } |
| else if (0 == rServiceName.compareToAscii( SN_HYPHENATOR )) |
| { |
| if (!xHyphDsp.is()) |
| GetHyphenatorDsp_Impl(); |
| sal_Bool bChanged = !IsEqSvcList( rServiceImplNames, |
| pHyphDsp->GetServiceList( rLocale ) ); |
| if (bChanged) |
| { |
| pHyphDsp->SetServiceList( rLocale, rServiceImplNames ); |
| SaveCfgSvcs( A2OU( SN_HYPHENATOR ) ); |
| |
| if (pListenerHelper && bChanged) |
| pListenerHelper->AddLngSvcEvt( |
| linguistic2::LinguServiceEventFlags::HYPHENATE_AGAIN ); |
| } |
| } |
| else if (0 == rServiceName.compareToAscii( SN_THESAURUS )) |
| { |
| if (!xThesDsp.is()) |
| GetThesaurusDsp_Impl(); |
| sal_Bool bChanged = !IsEqSvcList( rServiceImplNames, |
| pThesDsp->GetServiceList( rLocale ) ); |
| if (bChanged) |
| { |
| pThesDsp->SetServiceList( rLocale, rServiceImplNames ); |
| SaveCfgSvcs( A2OU( SN_THESAURUS ) ); |
| } |
| } |
| } |
| } |
| |
| |
| sal_Bool LngSvcMgr::SaveCfgSvcs( const String &rServiceName ) |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "linguistic: LngSvcMgr::SaveCfgSvcs" ); |
| |
| sal_Bool bRes = sal_False; |
| |
| LinguDispatcher *pDsp = 0; |
| uno::Sequence< lang::Locale > aLocales; |
| |
| if (0 == rServiceName.CompareToAscii( SN_SPELLCHECKER )) |
| { |
| if (!pSpellDsp) |
| GetSpellCheckerDsp_Impl(); |
| pDsp = pSpellDsp; |
| aLocales = getAvailableLocales( A2OU( SN_SPELLCHECKER ) ); |
| } |
| else if (0 == rServiceName.CompareToAscii( SN_GRAMMARCHECKER )) |
| { |
| if (!pGrammarDsp) |
| GetGrammarCheckerDsp_Impl(); |
| pDsp = pGrammarDsp; |
| aLocales = getAvailableLocales( A2OU( SN_GRAMMARCHECKER ) ); |
| } |
| else if (0 == rServiceName.CompareToAscii( SN_HYPHENATOR )) |
| { |
| if (!pHyphDsp) |
| GetHyphenatorDsp_Impl(); |
| pDsp = pHyphDsp; |
| aLocales = getAvailableLocales( A2OU( SN_HYPHENATOR ) ); |
| } |
| else if (0 == rServiceName.CompareToAscii( SN_THESAURUS )) |
| { |
| if (!pThesDsp) |
| GetThesaurusDsp_Impl(); |
| pDsp = pThesDsp; |
| aLocales = getAvailableLocales( A2OU( 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 = NULL; |
| if (pDsp == pSpellDsp) |
| pNodeName = "ServiceManager/SpellCheckerList"; |
| else if (pDsp == pGrammarDsp) |
| pNodeName = "ServiceManager/GrammarCheckerList"; |
| else if (pDsp == pHyphDsp) |
| pNodeName = "ServiceManager/HyphenatorList"; |
| else if (pDsp == pThesDsp) |
| pNodeName = "ServiceManager/ThesaurusList"; |
| else |
| { |
| DBG_ASSERT( 0, "node name missing" ); |
| } |
| OUString aNodeName( A2OU(pNodeName) ); |
| |
| for (sal_Int32 i = 0; i < nLen; ++i) |
| { |
| uno::Sequence< OUString > aSvcImplNames; |
| aSvcImplNames = pDsp->GetServiceList( pLocale[i] ); |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| sal_Int32 nSvcs = aSvcImplNames.getLength(); |
| const OUString *pSvcImplName = aSvcImplNames.getConstArray(); |
| for (sal_Int32 j = 0; j < nSvcs; ++j) |
| { |
| OUString aImplName( pSvcImplName[j] ); |
| } |
| #endif |
| // build value to be written back to configuration |
| uno::Any aCfgAny; |
| if ((pDsp == pHyphDsp || pDsp == pGrammarDsp) && 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( MsLangId::convertLanguageToIsoString( |
| LocaleToLanguage( pLocale[i] ) ) ); |
| pValue->Value = aCfgAny; |
| pValue->Name = aNodeName; |
| pValue->Name += OUString::valueOf( (sal_Unicode) '/' ); |
| pValue->Name += aCfgLocaleStr; |
| pValue++; |
| } |
| { |
| RTL_LOGFILE_CONTEXT( aLog, "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 > 1 |
| sal_Int32 nSvcs = aRes.getLength(); |
| if (nSvcs) |
| { |
| const OUString *pSvcName = aRes.getConstArray(); |
| for (sal_Int32 j = 0; j < nSvcs; ++j) |
| { |
| OUString aImplName( pSvcName[j] ); |
| DBG_ASSERT( aImplName.getLength(), "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.getLength() != 0) |
| { |
| aRes.realloc(1); |
| aRes.getArray()[0] = aImplName; |
| } |
| else |
| { |
| DBG_ASSERT( 0, "GetLangSvc: unexpected type encountered" ); |
| } |
| } |
| |
| return aRes; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| uno::Sequence< OUString > SAL_CALL |
| LngSvcMgr::getConfiguredServices( |
| const OUString& rServiceName, |
| const lang::Locale& rLocale ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| uno::Sequence< OUString > aSvcImplNames; |
| |
| LanguageType nLanguage = LocaleToLanguage( rLocale ); |
| OUString aCfgLocale( MsLangId::convertLanguageToIsoString( nLanguage ) ); |
| |
| uno::Sequence< uno::Any > aValues; |
| uno::Sequence< OUString > aNames( 1 ); |
| OUString *pNames = aNames.getArray(); |
| if ( 0 == rServiceName.compareToAscii( SN_SPELLCHECKER ) ) |
| { |
| OUString aNode( OUString::createFromAscii( "ServiceManager/SpellCheckerList" )); |
| const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) ); |
| if (lcl_SeqHasString( aNodeEntries, aCfgLocale )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aCfgLocale; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] ); |
| } |
| } |
| else if ( 0 == rServiceName.compareToAscii( SN_GRAMMARCHECKER ) ) |
| { |
| OUString aNode( OUString::createFromAscii( "ServiceManager/GrammarCheckerList" )); |
| const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) ); |
| if (lcl_SeqHasString( aNodeEntries, aCfgLocale )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aCfgLocale; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] ); |
| } |
| } |
| else if ( 0 == rServiceName.compareToAscii( SN_HYPHENATOR ) ) |
| { |
| OUString aNode( OUString::createFromAscii( "ServiceManager/HyphenatorList" )); |
| const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) ); |
| if (lcl_SeqHasString( aNodeEntries, aCfgLocale )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aCfgLocale; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvc( aValues.getConstArray()[0] ); |
| } |
| } |
| else if ( 0 == rServiceName.compareToAscii( SN_THESAURUS ) ) |
| { |
| OUString aNode( OUString::createFromAscii( "ServiceManager/ThesaurusList" )); |
| const uno::Sequence< OUString > aNodeEntries( GetNodeNames( aNode ) ); |
| if (lcl_SeqHasString( aNodeEntries, aCfgLocale )) |
| { |
| OUString aPropName( aNode ); |
| aPropName += OUString::valueOf( (sal_Unicode) '/' ); |
| aPropName += aCfgLocale; |
| pNames[0] = aPropName; |
| aValues = /*aCfg.*/GetProperties( aNames ); |
| if (aValues.getLength()) |
| aSvcImplNames = GetLangSvcList( aValues.getConstArray()[0] ); |
| } |
| } |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| const OUString *pImplNames = aSvcImplNames.getConstArray(); |
| (void) pImplNames; |
| #endif |
| return aSvcImplNames; |
| } |
| |
| |
| void SAL_CALL |
| LngSvcMgr::dispose() |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| if (!bDisposing) |
| { |
| bDisposing = sal_True; |
| |
| // require listeners to release this object |
| lang::EventObject aEvtObj( (XLinguServiceManager *) this ); |
| aEvtListeners.disposeAndClear( aEvtObj ); |
| |
| if (pListenerHelper) |
| pListenerHelper->DisposeAndClear( aEvtObj ); |
| } |
| } |
| |
| |
| void SAL_CALL |
| LngSvcMgr::addEventListener( |
| const uno::Reference< lang::XEventListener >& xListener ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| if (!bDisposing && xListener.is()) |
| { |
| aEvtListeners.addInterface( xListener ); |
| } |
| } |
| |
| |
| void SAL_CALL |
| LngSvcMgr::removeEventListener( |
| const uno::Reference< lang::XEventListener >& xListener ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| if (xListener.is()) |
| { |
| aEvtListeners.removeInterface( xListener ); |
| } |
| } |
| |
| |
| sal_Bool LngSvcMgr::AddLngSvcEvtBroadcaster( |
| const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster ) |
| { |
| sal_Bool bRes = sal_False; |
| if (rxBroadcaster.is()) |
| { |
| if (!pListenerHelper) |
| GetListenerHelper_Impl(); |
| bRes = pListenerHelper->AddLngSvcEvtBroadcaster( rxBroadcaster ); |
| } |
| return bRes; |
| } |
| |
| |
| sal_Bool LngSvcMgr::RemoveLngSvcEvtBroadcaster( |
| const uno::Reference< linguistic2::XLinguServiceEventBroadcaster > &rxBroadcaster ) |
| { |
| sal_Bool bRes = sal_False; |
| if (rxBroadcaster.is()) |
| { |
| DBG_ASSERT( pListenerHelper, "pListenerHelper non existent" ); |
| if (!pListenerHelper) |
| GetListenerHelper_Impl(); |
| bRes = pListenerHelper->RemoveLngSvcEvtBroadcaster( rxBroadcaster ); |
| } |
| return bRes; |
| } |
| |
| |
| OUString SAL_CALL |
| LngSvcMgr::getImplementationName() |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| return getImplementationName_Static(); |
| } |
| |
| |
| sal_Bool SAL_CALL |
| LngSvcMgr::supportsService( const OUString& ServiceName ) |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| uno::Sequence< OUString > aSNL = getSupportedServiceNames(); |
| const OUString * pArray = aSNL.getConstArray(); |
| for( sal_Int32 i = 0; i < aSNL.getLength(); i++ ) |
| if( pArray[i] == ServiceName ) |
| return sal_True; |
| return sal_False; |
| } |
| |
| |
| uno::Sequence< OUString > SAL_CALL |
| LngSvcMgr::getSupportedServiceNames() |
| throw(uno::RuntimeException) |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| return getSupportedServiceNames_Static(); |
| } |
| |
| |
| uno::Sequence< OUString > LngSvcMgr::getSupportedServiceNames_Static() |
| throw() |
| { |
| osl::MutexGuard aGuard( GetLinguMutex() ); |
| |
| uno::Sequence< OUString > aSNS( 1 ); // auch mehr als 1 Service moeglich |
| aSNS.getArray()[0] = A2OU( SN_LINGU_SERVCICE_MANAGER ); |
| return aSNS; |
| } |
| |
| |
| uno::Reference< uno::XInterface > SAL_CALL LngSvcMgr_CreateInstance( |
| const uno::Reference< lang::XMultiServiceFactory > & /*rSMgr*/ ) |
| throw(uno::Exception) |
| { |
| uno::Reference< uno::XInterface > xService = (cppu::OWeakObject*) new LngSvcMgr; |
| return xService; |
| } |
| |
| void * SAL_CALL LngSvcMgr_getFactory( |
| const sal_Char * pImplName, |
| lang::XMultiServiceFactory * pServiceManager, |
| void * /*pRegistryKey*/ ) |
| { |
| |
| void * pRet = 0; |
| if ( !LngSvcMgr::getImplementationName_Static().compareToAscii( 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; |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
