diff options
Diffstat (limited to 'linguistic/source/convdiclist.cxx')
| -rw-r--r-- | linguistic/source/convdiclist.cxx | 772 |
1 files changed, 772 insertions, 0 deletions
diff --git a/linguistic/source/convdiclist.cxx b/linguistic/source/convdiclist.cxx new file mode 100644 index 000000000000..831c67b7baa8 --- /dev/null +++ b/linguistic/source/convdiclist.cxx @@ -0,0 +1,772 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: convdiclist.cxx,v $ + * $Revision: 1.11 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_linguistic.hxx" +#include <tools/fsys.hxx> +#include <tools/stream.hxx> +#include <tools/urlobj.hxx> +#include <unotools/pathoptions.hxx> +#include <unotools/useroptions.hxx> +#include <unotools/lingucfg.hxx> +#include <rtl/instance.hxx> +#include <cppuhelper/factory.hxx> // helper for factories +#include <unotools/localfilehelper.hxx> +#include <com/sun/star/linguistic2/XConversionDictionaryList.hpp> +#include <com/sun/star/linguistic2/XConversionDictionary.hpp> +#include <com/sun/star/linguistic2/ConversionDictionaryType.hpp> +#include <com/sun/star/util/XFlushable.hpp> +#include <com/sun/star/lang/Locale.hpp> +#ifndef _COM_SUN_STAR_UNO_REFERENCE_HPP_ +#include <com/sun/star/uno/Reference.h> +#endif +#include <com/sun/star/registry/XRegistryKey.hpp> +#include <com/sun/star/container/XNameContainer.hpp> + +#include <ucbhelper/content.hxx> + +#include "convdiclist.hxx" +#include "convdic.hxx" +#include "hhconvdic.hxx" +#include "misc.hxx" +#include "defs.hxx" + +//using namespace utl; +using namespace osl; +using namespace rtl; +using namespace com::sun::star; +using namespace com::sun::star::lang; +using namespace com::sun::star::uno; +using namespace com::sun::star::container; +using namespace com::sun::star::linguistic2; +using namespace linguistic; + +#define SN_CONV_DICTIONARY_LIST "com.sun.star.linguistic2.ConversionDictionaryList" + + +/////////////////////////////////////////////////////////////////////////// + +bool operator == ( const Locale &r1, const Locale &r2 ) +{ + return r1.Language == r2.Language && + r1.Country == r2.Country && + r1.Variant == r2.Variant; +} + +/////////////////////////////////////////////////////////////////////////// + +String GetConvDicMainURL( const String &rDicName, const String &rDirectoryURL ) +{ + // build URL to use for new (persistent) dictionaries + + String aFullDicName( rDicName ); + aFullDicName.AppendAscii( CONV_DIC_DOT_EXT ); + + INetURLObject aURLObj; + aURLObj.SetSmartProtocol( INET_PROT_FILE ); + aURLObj.SetSmartURL( rDirectoryURL ); + aURLObj.Append( aFullDicName, INetURLObject::ENCODE_ALL ); + DBG_ASSERT(!aURLObj.HasError(), "invalid URL"); + if (aURLObj.HasError()) + return String(); + else + return aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI ); +} + +/////////////////////////////////////////////////////////////////////////// + +class ConvDicNameContainer : + public cppu::WeakImplHelper1 + < + ::com::sun::star::container::XNameContainer + > +{ + uno::Sequence< uno::Reference< XConversionDictionary > > aConvDics; + ConvDicList &rConvDicList; + + // disallow copy-constructor and assignment-operator for now + ConvDicNameContainer(const ConvDicNameContainer &); + ConvDicNameContainer & operator = (const ConvDicNameContainer &); + + INT32 GetIndexByName_Impl( const OUString& rName ); + +public: + ConvDicNameContainer( ConvDicList &rMyConvDicList ); + virtual ~ConvDicNameContainer(); + + // XElementAccess + virtual ::com::sun::star::uno::Type SAL_CALL getElementType( ) throw (::com::sun::star::uno::RuntimeException); + virtual sal_Bool SAL_CALL hasElements( ) throw (::com::sun::star::uno::RuntimeException); + + // XNameAccess + virtual ::com::sun::star::uno::Any SAL_CALL getByName( const ::rtl::OUString& aName ) throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException); + virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getElementNames( ) throw (::com::sun::star::uno::RuntimeException); + virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName ) throw (::com::sun::star::uno::RuntimeException); + + // XNameReplace + virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const ::com::sun::star::uno::Any& aElement ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException); + + // XNameContainer + virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const ::com::sun::star::uno::Any& aElement ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::ElementExistException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL removeByName( const ::rtl::OUString& Name ) throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException); + + + // looks for conversion dictionaries with the specified extension + // in the directory and adds them to the container + void AddConvDics( const String &rSearchDirPathURL, const String &rExtension ); + + // calls Flush for the dictionaries that support XFlushable + void FlushDics() const; + + INT32 GetCount() const { return aConvDics.getLength(); } + uno::Reference< XConversionDictionary > GetByName( const OUString& rName ); + + const uno::Reference< XConversionDictionary > GetByIndex( INT32 nIdx ) + { + return aConvDics.getConstArray()[nIdx]; + } +}; + + +ConvDicNameContainer::ConvDicNameContainer( ConvDicList &rMyConvDicList ) : + rConvDicList( rMyConvDicList ) +{ +} + + +ConvDicNameContainer::~ConvDicNameContainer() +{ +} + + +void ConvDicNameContainer::FlushDics() const +{ + INT32 nLen = aConvDics.getLength(); + const uno::Reference< XConversionDictionary > *pDic = aConvDics.getConstArray(); + for (INT32 i = 0; i < nLen; ++i) + { + uno::Reference< util::XFlushable > xFlush( pDic[i] , UNO_QUERY ); + if (xFlush.is()) + { + try + { + xFlush->flush(); + } + catch(Exception &) + { + DBG_ERROR( "flushing of conversion dictionary failed" ); + } + } + } +} + + +INT32 ConvDicNameContainer::GetIndexByName_Impl( + const OUString& rName ) +{ + INT32 nRes = -1; + INT32 nLen = aConvDics.getLength(); + const uno::Reference< XConversionDictionary > *pDic = aConvDics.getConstArray(); + for (INT32 i = 0; i < nLen && nRes == -1; ++i) + { + if (rName == pDic[i]->getName()) + nRes = i; + } + return nRes; +} + + +uno::Reference< XConversionDictionary > ConvDicNameContainer::GetByName( + const OUString& rName ) +{ + uno::Reference< XConversionDictionary > xRes; + INT32 nIdx = GetIndexByName_Impl( rName ); + if ( nIdx != -1) + xRes = aConvDics.getArray()[nIdx]; + return xRes; +} + + +uno::Type SAL_CALL ConvDicNameContainer::getElementType( ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + return uno::Type( ::getCppuType( (uno::Reference< XConversionDictionary > *) 0) ); +} + + +sal_Bool SAL_CALL ConvDicNameContainer::hasElements( ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + return aConvDics.getLength() > 0; +} + + +uno::Any SAL_CALL ConvDicNameContainer::getByName( const OUString& rName ) + throw (NoSuchElementException, WrappedTargetException, RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + uno::Reference< XConversionDictionary > xRes( GetByName( rName ) ); + if (!xRes.is()) + throw NoSuchElementException(); + return makeAny( xRes ); +} + + +uno::Sequence< OUString > SAL_CALL ConvDicNameContainer::getElementNames( ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + INT32 nLen = aConvDics.getLength(); + uno::Sequence< OUString > aRes( nLen ); + OUString *pName = aRes.getArray(); + const uno::Reference< XConversionDictionary > *pDic = aConvDics.getConstArray(); + for (INT32 i = 0; i < nLen; ++i) + pName[i] = pDic[i]->getName(); + return aRes; +} + + +sal_Bool SAL_CALL ConvDicNameContainer::hasByName( const OUString& rName ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + return GetByName( rName ).is(); +} + + +void SAL_CALL ConvDicNameContainer::replaceByName( + const OUString& rName, + const uno::Any& rElement ) + throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + INT32 nRplcIdx = GetIndexByName_Impl( rName ); + if (nRplcIdx == -1) + throw NoSuchElementException(); + uno::Reference< XConversionDictionary > xNew; + rElement >>= xNew; + if (!xNew.is() || xNew->getName() != rName) + throw IllegalArgumentException(); + aConvDics.getArray()[ nRplcIdx ] = xNew; +} + + +void SAL_CALL ConvDicNameContainer::insertByName( + const OUString& rName, + const Any& rElement ) + throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + if (GetByName( rName ).is()) + throw ElementExistException(); + uno::Reference< XConversionDictionary > xNew; + rElement >>= xNew; + if (!xNew.is() || xNew->getName() != rName) + throw IllegalArgumentException(); + + INT32 nLen = aConvDics.getLength(); + aConvDics.realloc( nLen + 1 ); + aConvDics.getArray()[ nLen ] = xNew; +} + + +void SAL_CALL ConvDicNameContainer::removeByName( const OUString& rName ) + throw (NoSuchElementException, WrappedTargetException, RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + INT32 nRplcIdx = GetIndexByName_Impl( rName ); + if (nRplcIdx == -1) + throw NoSuchElementException(); + + // physically remove dictionary + uno::Reference< XConversionDictionary > xDel = aConvDics.getArray()[nRplcIdx]; + String aName( xDel->getName() ); + String aDicMainURL( GetConvDicMainURL( aName, GetDictionaryWriteablePath() ) ); + INetURLObject aObj( aDicMainURL ); + DBG_ASSERT( aObj.GetProtocol() == INET_PROT_FILE, "+HangulHanjaOptionsDialog::OkHdl(): non-file URLs cannot be deleted" ); + if( aObj.GetProtocol() == INET_PROT_FILE ) + { + try + { + ::ucbhelper::Content aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ), + uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () ); + aCnt.executeCommand( OUString::createFromAscii( "delete" ), makeAny( sal_Bool( sal_True ) ) ); + } + catch( ::com::sun::star::ucb::CommandAbortedException& ) + { + DBG_ERRORFILE( "HangulHanjaOptionsDialog::OkHdl(): CommandAbortedException" ); + } + catch( ... ) + { + DBG_ERRORFILE( "HangulHanjaOptionsDialog::OkHdl(): Any other exception" ); + } + } + + INT32 nLen = aConvDics.getLength(); + uno::Reference< XConversionDictionary > *pDic = aConvDics.getArray(); + for (INT32 i = nRplcIdx; i < nLen - 1; ++i) + pDic[i] = pDic[i + 1]; + aConvDics.realloc( nLen - 1 ); +} + + +void ConvDicNameContainer::AddConvDics( + const String &rSearchDirPathURL, + const String &rExtension ) +{ + const Sequence< OUString > aDirCnt( + utl::LocalFileHelper::GetFolderContents( rSearchDirPathURL, FALSE ) ); + const OUString *pDirCnt = aDirCnt.getConstArray(); + INT32 nEntries = aDirCnt.getLength(); + + for (INT32 i = 0; i < nEntries; ++i) + { + String aURL( pDirCnt[i] ); + + xub_StrLen nPos = aURL.SearchBackward('.'); + String aExt(aURL.Copy(nPos + 1)); + aExt.ToLowerAscii(); + String aSearchExt( rExtension ); + aSearchExt.ToLowerAscii(); + if(aExt != aSearchExt) + continue; // skip other files + + INT16 nLang; + sal_Int16 nConvType; + if (IsConvDic( aURL, nLang, nConvType )) + { + // get decoded dictionary file name + INetURLObject aURLObj( aURL ); + String aDicName = aURLObj.getBase( INetURLObject::LAST_SEGMENT, + true, INetURLObject::DECODE_WITH_CHARSET, + RTL_TEXTENCODING_UTF8 ); + + uno::Reference < XConversionDictionary > xDic; + if (nLang == LANGUAGE_KOREAN && + nConvType == ConversionDictionaryType::HANGUL_HANJA) + { + xDic = new HHConvDic( aDicName, aURL ); + } + else if ((nLang == LANGUAGE_CHINESE_SIMPLIFIED || nLang == LANGUAGE_CHINESE_TRADITIONAL) && + nConvType == ConversionDictionaryType::SCHINESE_TCHINESE) + { + xDic = new ConvDic( aDicName, nLang, nConvType, FALSE, aURL ); + } + + if (xDic.is()) + { + uno::Any aAny; + aAny <<= xDic; + insertByName( xDic->getName(), aAny ); + } + } + } +} + +/////////////////////////////////////////////////////////////////////////// + +namespace +{ +template<typename T, typename InitData, + typename Unique = InitData, typename Data = T> +class StaticWithInit_ { +public: + /** Gets the static. Mutual exclusion is performed using the + osl global mutex. + + @return + static variable + */ + static T & get() { + return *rtl_Instance< + T, StaticInstanceWithInit, + ::osl::MutexGuard, ::osl::GetGlobalMutex, + Data, InitData >::create( StaticInstanceWithInit(), + ::osl::GetGlobalMutex(), + InitData() ); + } +private: + struct StaticInstanceWithInit { + T * operator () ( Data d ) { + static T instance(d); + return &instance; + } + }; +}; + +//after src680m62 you can replace StaticWithInit_ with rtl::StaticWithInit and remove the above definition of StaticWithInit_ + +struct StaticConvDicList : public StaticWithInit_< + uno::Reference<XInterface>, StaticConvDicList> { + uno::Reference<XInterface> operator () () { + return (cppu::OWeakObject *) new ConvDicList; + } +}; +} + + +void ConvDicList::MyAppExitListener::AtExit() +{ + rMyDicList.FlushDics(); + StaticConvDicList::get().clear(); +} + +ConvDicList::ConvDicList() : + aEvtListeners( GetLinguMutex() ) +{ + pNameContainer = 0; + bDisposing = FALSE; + + pExitListener = new MyAppExitListener( *this ); + xExitListener = pExitListener; + pExitListener->Activate(); +} + + +ConvDicList::~ConvDicList() +{ + // NameContainer will deleted when the reference xNameContainer + // is destroyed. + // delete pNameContainer; + + if (!bDisposing && pNameContainer) + pNameContainer->FlushDics(); + + pExitListener->Deactivate(); +} + + +void ConvDicList::FlushDics() +{ + // check only pointer to avoid creating the container when + // the dictionaries were not accessed yet + if (pNameContainer) + pNameContainer->FlushDics(); +} + + +ConvDicNameContainer & ConvDicList::GetNameContainer() +{ + if (!pNameContainer) + { + pNameContainer = new ConvDicNameContainer( *this ); + pNameContainer->AddConvDics( GetDictionaryWriteablePath(), + A2OU( CONV_DIC_EXT ) ); + xNameContainer = pNameContainer; + + // access list of text conversion dictionaries to activate + SvtLinguOptions aOpt; + SvtLinguConfig().GetOptions( aOpt ); + INT32 nLen = aOpt.aActiveConvDics.getLength(); + const OUString *pActiveConvDics = aOpt.aActiveConvDics.getConstArray(); + for (INT32 i = 0; i < nLen; ++i) + { + uno::Reference< XConversionDictionary > xDic = + pNameContainer->GetByName( pActiveConvDics[i] ); + if (xDic.is()) + xDic->setActive( sal_True ); + } + + // since there is no UI to active/deactivate the dictionaries + // for chinese text conversion they should be activated by default + uno::Reference< XConversionDictionary > xS2TDic( + pNameContainer->GetByName( A2OU("ChineseS2T") ), UNO_QUERY ); + uno::Reference< XConversionDictionary > xT2SDic( + pNameContainer->GetByName( A2OU("ChineseT2S") ), UNO_QUERY ); + if (xS2TDic.is()) + xS2TDic->setActive( sal_True ); + if (xT2SDic.is()) + xT2SDic->setActive( sal_True ); + + } + return *pNameContainer; +} + + +uno::Reference< container::XNameContainer > SAL_CALL ConvDicList::getDictionaryContainer( ) throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + GetNameContainer(); + DBG_ASSERT( xNameContainer.is(), "missing name container" ); + return xNameContainer; +} + + +uno::Reference< XConversionDictionary > SAL_CALL ConvDicList::addNewDictionary( + const OUString& rName, + const Locale& rLocale, + sal_Int16 nConvDicType ) + throw (NoSupportException, ElementExistException, RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + INT16 nLang = LocaleToLanguage( rLocale ); + + if (GetNameContainer().hasByName( rName )) + throw ElementExistException(); + + uno::Reference< XConversionDictionary > xRes; + String aDicMainURL( GetConvDicMainURL( rName, GetDictionaryWriteablePath() ) ); + if (nLang == LANGUAGE_KOREAN && + nConvDicType == ConversionDictionaryType::HANGUL_HANJA) + { + xRes = new HHConvDic( rName, aDicMainURL ); + } + else if ((nLang == LANGUAGE_CHINESE_SIMPLIFIED || nLang == LANGUAGE_CHINESE_TRADITIONAL) && + nConvDicType == ConversionDictionaryType::SCHINESE_TCHINESE) + { + xRes = new ConvDic( rName, nLang, nConvDicType, FALSE, aDicMainURL ); + } + + if (!xRes.is()) + throw NoSupportException(); + else + { + xRes->setActive( sal_True ); + uno::Any aAny; + aAny <<= xRes; + GetNameContainer().insertByName( rName, aAny ); + } + return xRes; +} + + +uno::Sequence< OUString > SAL_CALL ConvDicList::queryConversions( + const OUString& rText, + sal_Int32 nStartPos, + sal_Int32 nLength, + const Locale& rLocale, + sal_Int16 nConversionDictionaryType, + ConversionDirection eDirection, + sal_Int32 nTextConversionOptions ) + throw (IllegalArgumentException, NoSupportException, RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + /*INT16 nLang = LocaleToLanguage( rLocale );*/ + + INT32 nCount = 0; + uno::Sequence< OUString > aRes( 20 ); + OUString *pRes = aRes.getArray(); + + sal_Bool bSupported = sal_False; + INT32 nLen = GetNameContainer().GetCount(); + for (INT32 i = 0; i < nLen; ++i) + { + const uno::Reference< XConversionDictionary > xDic( GetNameContainer().GetByIndex(i) ); + sal_Bool bMatch = xDic.is() && + xDic->getLocale() == rLocale && + xDic->getConversionType() == nConversionDictionaryType; + bSupported |= bMatch; + if (bMatch && xDic->isActive()) + { + Sequence< OUString > aNewConv( xDic->getConversions( + rText, nStartPos, nLength, + eDirection, nTextConversionOptions ) ); + INT32 nNewLen = aNewConv.getLength(); + if (nNewLen > 0) + { + if (nCount + nNewLen > aRes.getLength()) + { + aRes.realloc( nCount + nNewLen + 20 ); + pRes = aRes.getArray(); + } + const OUString *pNewConv = aNewConv.getConstArray(); + for (INT32 k = 0; k < nNewLen; ++k) + pRes[nCount++] = pNewConv[k]; + } + } + } + + if (!bSupported) + throw NoSupportException(); + + aRes.realloc( nCount ); + return aRes; +} + + +sal_Int16 SAL_CALL ConvDicList::queryMaxCharCount( + const Locale& rLocale, + sal_Int16 nConversionDictionaryType, + ConversionDirection eDirection ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + + sal_Int16 nRes = 0; + GetNameContainer(); + INT32 nLen = GetNameContainer().GetCount(); + for (INT32 i = 0; i < nLen; ++i) + { + const uno::Reference< XConversionDictionary > xDic( GetNameContainer().GetByIndex(i) ); + if (xDic.is() && + xDic->getLocale() == rLocale && + xDic->getConversionType() == nConversionDictionaryType) + { + sal_Int16 nC = xDic->getMaxCharCount( eDirection ); + if (nC > nRes) + nRes = nC; + } + } + return nRes; +} + + +void SAL_CALL ConvDicList::dispose( ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + if (!bDisposing) + { + bDisposing = TRUE; + EventObject aEvtObj( (XConversionDictionaryList *) this ); + aEvtListeners.disposeAndClear( aEvtObj ); + + FlushDics(); + } +} + + +void SAL_CALL ConvDicList::addEventListener( + const uno::Reference< XEventListener >& rxListener ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + if (!bDisposing && rxListener.is()) + aEvtListeners.addInterface( rxListener ); +} + + +void SAL_CALL ConvDicList::removeEventListener( + const uno::Reference< XEventListener >& rxListener ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + if (!bDisposing && rxListener.is()) + aEvtListeners.removeInterface( rxListener ); +} + + +OUString SAL_CALL ConvDicList::getImplementationName( ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + return getImplementationName_Static(); +} + + +sal_Bool SAL_CALL ConvDicList::supportsService( const OUString& rServiceName ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + return rServiceName.equalsAscii( SN_CONV_DICTIONARY_LIST ); +} + + +uno::Sequence< OUString > SAL_CALL ConvDicList::getSupportedServiceNames( ) + throw (RuntimeException) +{ + MutexGuard aGuard( GetLinguMutex() ); + return getSupportedServiceNames_Static(); +} + + +uno::Sequence< OUString > ConvDicList::getSupportedServiceNames_Static() + throw() +{ + uno::Sequence< OUString > aSNS( 1 ); + aSNS.getArray()[0] = A2OU( SN_CONV_DICTIONARY_LIST ); + return aSNS; +} + + +/////////////////////////////////////////////////////////////////////////// + +uno::Reference< uno::XInterface > SAL_CALL ConvDicList_CreateInstance( + const uno::Reference< XMultiServiceFactory > & /*rSMgr*/ ) + throw(Exception) +{ + return StaticConvDicList::get(); +} + + +sal_Bool SAL_CALL ConvDicList_writeInfo( + void * /*pServiceManager*/, registry::XRegistryKey * pRegistryKey ) +{ + try + { + String aImpl( '/' ); + aImpl += ConvDicList::getImplementationName_Static().getStr(); + aImpl.AppendAscii( "/UNO/SERVICES" ); + uno::Reference< registry::XRegistryKey > xNewKey = + pRegistryKey->createKey(aImpl ); + uno::Sequence< OUString > aServices = + ConvDicList::getSupportedServiceNames_Static(); + for( INT32 i = 0; i < aServices.getLength(); i++ ) + xNewKey->createKey( aServices.getConstArray()[i]); + + return sal_True; + } + catch(Exception &) + { + return sal_False; + } +} + + +void * SAL_CALL ConvDicList_getFactory( + const sal_Char * pImplName, + XMultiServiceFactory * pServiceManager, void * ) +{ + void * pRet = 0; + if ( !ConvDicList::getImplementationName_Static().compareToAscii( pImplName ) ) + { + uno::Reference< XSingleServiceFactory > xFactory = + cppu::createOneInstanceFactory( + pServiceManager, + ConvDicList::getImplementationName_Static(), + ConvDicList_CreateInstance, + ConvDicList::getSupportedServiceNames_Static()); + // acquire, because we return an interface pointer instead of a reference + xFactory->acquire(); + pRet = xFactory.get(); + } + return pRet; +} + +/////////////////////////////////////////////////////////////////////////// + |