| /************************************************************** |
| * |
| * 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_scripting.hxx" |
| #include "stringresource.hxx" |
| #include <com/sun/star/io/XTextInputStream.hpp> |
| #include <com/sun/star/io/XTextOutputStream.hpp> |
| #include <com/sun/star/io/XActiveDataSink.hpp> |
| #include <com/sun/star/io/XActiveDataSource.hpp> |
| #include <com/sun/star/io/XStream.hpp> |
| #include <com/sun/star/io/XSeekable.hpp> |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #include <com/sun/star/lang/XMultiComponentFactory.hpp> |
| #ifndef _CPPUHELPER_IMPLEMENTATIONENTRY_HXX_ |
| #include <cppuhelper/implementationentry.hxx> |
| #endif |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/container/XNameAccess.hpp> |
| |
| |
| #include <rtl/ustrbuf.hxx> |
| #include <rtl/strbuf.hxx> |
| #include <tools/urlobj.hxx> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::ucb; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::embed; |
| using namespace ::com::sun::star::container; |
| |
| |
| //......................................................................... |
| namespace stringresource |
| { |
| //......................................................................... |
| |
| // ============================================================================= |
| // mutex |
| // ============================================================================= |
| |
| ::osl::Mutex& getMutex() |
| { |
| static ::osl::Mutex* s_pMutex = 0; |
| if ( !s_pMutex ) |
| { |
| ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); |
| if ( !s_pMutex ) |
| { |
| static ::osl::Mutex s_aMutex; |
| s_pMutex = &s_aMutex; |
| } |
| } |
| return *s_pMutex; |
| } |
| |
| |
| // ============================================================================= |
| // StringResourceImpl |
| // ============================================================================= |
| |
| // component operations |
| static Sequence< ::rtl::OUString > getSupportedServiceNames_StringResourceImpl() |
| { |
| Sequence< ::rtl::OUString > names(1); |
| names[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.resource.StringResource") ); |
| return names; |
| } |
| |
| static ::rtl::OUString getImplementationName_StringResourceImpl() |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.scripting.StringResource") ); |
| } |
| |
| static Reference< XInterface > SAL_CALL create_StringResourceImpl( |
| Reference< XComponentContext > const & xContext ) |
| SAL_THROW( () ) |
| { |
| return static_cast< ::cppu::OWeakObject * >( new StringResourcePersistenceImpl( xContext ) ); |
| } |
| |
| |
| // ============================================================================= |
| |
| StringResourceImpl::StringResourceImpl( const Reference< XComponentContext >& rxContext ) |
| : m_xContext( rxContext ) |
| , m_pCurrentLocaleItem( NULL ) |
| , m_pDefaultLocaleItem( NULL ) |
| , m_bDefaultModified( false ) |
| , m_aListenerContainer( getMutex() ) |
| , m_bModified( false ) |
| , m_bReadOnly( false ) |
| , m_nNextUniqueNumericId( UNIQUE_NUMBER_NEEDS_INITIALISATION ) |
| { |
| } |
| |
| // ============================================================================= |
| |
| StringResourceImpl::~StringResourceImpl() |
| { |
| for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| delete pLocaleItem; |
| } |
| |
| for( LocaleItemVectorIt it = m_aDeletedLocaleItemVector.begin(); it != m_aDeletedLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| delete pLocaleItem; |
| } |
| } |
| |
| |
| // ============================================================================= |
| // XServiceInfo |
| |
| ::rtl::OUString StringResourceImpl::getImplementationName( ) throw (RuntimeException) |
| { |
| return getImplementationName_StringResourceImpl(); |
| } |
| |
| sal_Bool StringResourceImpl::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() ); |
| const ::rtl::OUString* pNames = aNames.getConstArray(); |
| const ::rtl::OUString* pEnd = pNames + aNames.getLength(); |
| for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames ) |
| ; |
| |
| return pNames != pEnd; |
| } |
| |
| Sequence< ::rtl::OUString > StringResourceImpl::getSupportedServiceNames( ) throw (RuntimeException) |
| { |
| return getSupportedServiceNames_StringResourceImpl(); |
| } |
| |
| |
| // ============================================================================= |
| // XModifyBroadcaster |
| |
| void StringResourceImpl::addModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| if( !aListener.is() ) |
| throw RuntimeException(); |
| |
| ::osl::MutexGuard aGuard( getMutex() ); |
| Reference< XInterface > xIface( aListener, UNO_QUERY ); |
| m_aListenerContainer.addInterface( xIface ); |
| } |
| |
| void StringResourceImpl::removeModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| if( !aListener.is() ) |
| throw RuntimeException(); |
| |
| ::osl::MutexGuard aGuard( getMutex() ); |
| Reference< XInterface > xIface( aListener, UNO_QUERY ); |
| m_aListenerContainer.removeInterface( xIface ); |
| } |
| |
| |
| // ============================================================================= |
| // XStringResourceResolver |
| |
| ::rtl::OUString StringResourceImpl::implResolveString |
| ( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem ) |
| throw (::com::sun::star::resource::MissingResourceException) |
| { |
| ::rtl::OUString aRetStr; |
| bool bSuccess = false; |
| if( pLocaleItem != NULL && loadLocale( pLocaleItem ) ) |
| { |
| IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID ); |
| if( !( it == pLocaleItem->m_aIdToStringMap.end() ) ) |
| { |
| aRetStr = (*it).second; |
| bSuccess = true; |
| } |
| } |
| if( !bSuccess ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceImpl: No entry for ResourceID: " ); |
| errorMsg.concat( ResourceID ); |
| throw ::com::sun::star::resource::MissingResourceException( errorMsg, Reference< XInterface >() ); |
| } |
| return aRetStr; |
| } |
| |
| ::rtl::OUString StringResourceImpl::resolveString( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| return implResolveString( ResourceID, m_pCurrentLocaleItem ); |
| } |
| |
| ::rtl::OUString StringResourceImpl::resolveStringForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw ( ::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| LocaleItem* pLocaleItem = getItemForLocale( locale, false ); |
| return implResolveString( ResourceID, pLocaleItem ); |
| } |
| |
| sal_Bool StringResourceImpl::implHasEntryForId( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem ) |
| { |
| bool bSuccess = false; |
| if( pLocaleItem != NULL && loadLocale( pLocaleItem ) ) |
| { |
| IdToStringMap::iterator it = pLocaleItem->m_aIdToStringMap.find( ResourceID ); |
| if( !( it == pLocaleItem->m_aIdToStringMap.end() ) ) |
| bSuccess = true; |
| } |
| return bSuccess; |
| } |
| |
| sal_Bool StringResourceImpl::hasEntryForId( const ::rtl::OUString& ResourceID ) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| return implHasEntryForId( ResourceID, m_pCurrentLocaleItem ); |
| } |
| |
| sal_Bool StringResourceImpl::hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID, |
| const Locale& locale ) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| LocaleItem* pLocaleItem = getItemForLocale( locale, false ); |
| return implHasEntryForId( ResourceID, pLocaleItem ); |
| } |
| |
| Sequence< ::rtl::OUString > StringResourceImpl::implGetResourceIDs( LocaleItem* pLocaleItem ) |
| { |
| Sequence< ::rtl::OUString > aIDSeq( 0 ); |
| if( pLocaleItem && loadLocale( pLocaleItem ) ) |
| { |
| const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap; |
| sal_Int32 nResourceIDCount = rHashMap.size(); |
| aIDSeq.realloc( nResourceIDCount ); |
| ::rtl::OUString* pStrings = aIDSeq.getArray(); |
| |
| IdToStringMap::const_iterator it; |
| int iTarget = 0; |
| for( it = rHashMap.begin(); it != rHashMap.end(); it++ ) |
| { |
| ::rtl::OUString aStr = (*it).first; |
| pStrings[iTarget] = aStr; |
| iTarget++; |
| } |
| } |
| return aIDSeq; |
| } |
| |
| Sequence< ::rtl::OUString > StringResourceImpl::getResourceIDsForLocale |
| ( const Locale& locale ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| LocaleItem* pLocaleItem = getItemForLocale( locale, false ); |
| return implGetResourceIDs( pLocaleItem ); |
| } |
| |
| Sequence< ::rtl::OUString > StringResourceImpl::getResourceIDs( ) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| return implGetResourceIDs( m_pCurrentLocaleItem ); |
| } |
| |
| Locale StringResourceImpl::getCurrentLocale() |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| Locale aRetLocale; |
| if( m_pCurrentLocaleItem != NULL ) |
| aRetLocale = m_pCurrentLocaleItem->m_locale; |
| return aRetLocale; |
| } |
| |
| Locale StringResourceImpl::getDefaultLocale( ) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| Locale aRetLocale; |
| if( m_pDefaultLocaleItem != NULL ) |
| aRetLocale = m_pDefaultLocaleItem->m_locale; |
| return aRetLocale; |
| } |
| |
| Sequence< Locale > StringResourceImpl::getLocales( ) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| sal_Int32 nSize = m_aLocaleItemVector.size(); |
| Sequence< Locale > aLocalSeq( nSize ); |
| Locale* pLocales = aLocalSeq.getArray(); |
| int iTarget = 0; |
| for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| pLocales[iTarget] = pLocaleItem->m_locale; |
| iTarget++; |
| } |
| return aLocalSeq; |
| } |
| |
| |
| // ============================================================================= |
| // XStringResourceManager |
| |
| void StringResourceImpl::implCheckReadOnly( const sal_Char* pExceptionMsg ) |
| throw (NoSupportException) |
| { |
| if( m_bReadOnly ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( pExceptionMsg ); |
| throw NoSupportException( errorMsg, Reference< XInterface >() ); |
| } |
| } |
| |
| sal_Bool StringResourceImpl::isReadOnly() |
| throw (RuntimeException) |
| { |
| return m_bReadOnly; |
| } |
| |
| void StringResourceImpl::implSetCurrentLocale( const Locale& locale, |
| sal_Bool FindClosestMatch, sal_Bool bUseDefaultIfNoMatch ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| LocaleItem* pLocaleItem = NULL; |
| if( FindClosestMatch ) |
| pLocaleItem = getClosestMatchItemForLocale( locale ); |
| else |
| pLocaleItem = getItemForLocale( locale, true ); |
| |
| if( pLocaleItem == NULL && bUseDefaultIfNoMatch ) |
| pLocaleItem = m_pDefaultLocaleItem; |
| |
| if( pLocaleItem != NULL ) |
| { |
| loadLocale( pLocaleItem ); |
| m_pCurrentLocaleItem = pLocaleItem; |
| |
| // Only notify without modifying |
| implNotifyListeners(); |
| } |
| } |
| |
| void StringResourceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| sal_Bool bUseDefaultIfNoMatch = false; |
| implSetCurrentLocale( locale, FindClosestMatch, bUseDefaultIfNoMatch ); |
| } |
| |
| void StringResourceImpl::setDefaultLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException,NoSupportException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::setDefaultLocale(): Read only" ); |
| |
| LocaleItem* pLocaleItem = getItemForLocale( locale, true ); |
| if( pLocaleItem && pLocaleItem != m_pDefaultLocaleItem ) |
| { |
| if( m_pDefaultLocaleItem ) |
| { |
| LocaleItem* pChangedDefaultLocaleItem = new LocaleItem( m_pDefaultLocaleItem->m_locale ); |
| m_aChangedDefaultLocaleVector.push_back( pChangedDefaultLocaleItem ); |
| } |
| |
| m_pDefaultLocaleItem = pLocaleItem; |
| m_bDefaultModified = true; |
| implModified(); |
| } |
| } |
| |
| void StringResourceImpl::implSetString( const ::rtl::OUString& ResourceID, |
| const ::rtl::OUString& Str, LocaleItem* pLocaleItem ) |
| { |
| if( pLocaleItem != NULL && loadLocale( pLocaleItem ) ) |
| { |
| IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap; |
| |
| IdToStringMap::iterator it = rHashMap.find( ResourceID ); |
| bool bNew = ( it == rHashMap.end() ); |
| if( bNew ) |
| { |
| IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap; |
| rIndexMap[ ResourceID ] = pLocaleItem->m_nNextIndex++; |
| implScanIdForNumber( ResourceID ); |
| } |
| rHashMap[ ResourceID ] = Str; |
| pLocaleItem->m_bModified = true; |
| implModified(); |
| } |
| } |
| |
| void StringResourceImpl::setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str ) |
| throw (NoSupportException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::setString(): Read only" ); |
| implSetString( ResourceID, Str, m_pCurrentLocaleItem ); |
| } |
| |
| void StringResourceImpl::setStringForLocale |
| ( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str, const Locale& locale ) |
| throw (NoSupportException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::setStringForLocale(): Read only" ); |
| LocaleItem* pLocaleItem = getItemForLocale( locale, false ); |
| implSetString( ResourceID, Str, pLocaleItem ); |
| } |
| |
| void StringResourceImpl::implRemoveId( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem ) |
| throw (::com::sun::star::resource::MissingResourceException) |
| { |
| if( pLocaleItem != NULL && loadLocale( pLocaleItem ) ) |
| { |
| IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap; |
| IdToStringMap::iterator it = rHashMap.find( ResourceID ); |
| if( it == rHashMap.end() ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceImpl: No entries for ResourceID: " ); |
| errorMsg.concat( ResourceID ); |
| throw ::com::sun::star::resource::MissingResourceException( errorMsg, Reference< XInterface >() ); |
| } |
| rHashMap.erase( it ); |
| pLocaleItem->m_bModified = true; |
| implModified(); |
| } |
| } |
| |
| void StringResourceImpl::removeId( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::removeId(): Read only" ); |
| implRemoveId( ResourceID, m_pCurrentLocaleItem ); |
| } |
| |
| void StringResourceImpl::removeIdForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::removeIdForLocale(): Read only" ); |
| LocaleItem* pLocaleItem = getItemForLocale( locale, false ); |
| implRemoveId( ResourceID, pLocaleItem ); |
| } |
| |
| void StringResourceImpl::newLocale( const Locale& locale ) |
| throw (ElementExistException, IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::newLocale(): Read only" ); |
| |
| if( getItemForLocale( locale, false ) != NULL ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceImpl: locale already exists" ); |
| throw ElementExistException( errorMsg, Reference< XInterface >() ); |
| } |
| |
| // TODO?: Check if locale is valid? How? |
| bool bValid = true; |
| if( bValid ) |
| { |
| LocaleItem* pLocaleItem = new LocaleItem( locale ); |
| m_aLocaleItemVector.push_back( pLocaleItem ); |
| pLocaleItem->m_bModified = true; |
| |
| // Copy strings from default locale |
| LocaleItem* pCopyFromItem = m_pDefaultLocaleItem; |
| if( pCopyFromItem == NULL ) |
| pCopyFromItem = m_pCurrentLocaleItem; |
| if( pCopyFromItem != NULL && loadLocale( pCopyFromItem ) ) |
| { |
| const IdToStringMap& rSourceMap = pCopyFromItem->m_aIdToStringMap; |
| IdToStringMap& rTargetMap = pLocaleItem->m_aIdToStringMap; |
| IdToStringMap::const_iterator it; |
| for( it = rSourceMap.begin(); it != rSourceMap.end(); it++ ) |
| { |
| ::rtl::OUString aId = (*it).first; |
| ::rtl::OUString aStr = (*it).second; |
| rTargetMap[ aId ] = aStr; |
| } |
| |
| const IdToIndexMap& rSourceIndexMap = pCopyFromItem->m_aIdToIndexMap; |
| IdToIndexMap& rTargetIndexMap = pLocaleItem->m_aIdToIndexMap; |
| IdToIndexMap::const_iterator it_index; |
| for( it_index = rSourceIndexMap.begin(); it_index != rSourceIndexMap.end(); it_index++ ) |
| { |
| ::rtl::OUString aId = (*it_index).first; |
| sal_Int32 nIndex = (*it_index).second; |
| rTargetIndexMap[ aId ] = nIndex; |
| } |
| pLocaleItem->m_nNextIndex = pCopyFromItem->m_nNextIndex; |
| } |
| |
| if( m_pCurrentLocaleItem == NULL ) |
| m_pCurrentLocaleItem = pLocaleItem; |
| |
| if( m_pDefaultLocaleItem == NULL ) |
| { |
| m_pDefaultLocaleItem = pLocaleItem; |
| m_bDefaultModified = true; |
| } |
| |
| implModified(); |
| } |
| else |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceImpl: Invalid locale" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 ); |
| } |
| } |
| |
| void StringResourceImpl::removeLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceImpl::removeLocale(): Read only" ); |
| |
| LocaleItem* pRemoveItem = getItemForLocale( locale, true ); |
| if( pRemoveItem ) |
| { |
| // Last locale? |
| sal_Int32 nLocaleCount = m_aLocaleItemVector.size(); |
| if( nLocaleCount > 1 ) |
| { |
| LocaleItem* pFallbackItem = NULL; |
| if( m_pCurrentLocaleItem == pRemoveItem || |
| m_pDefaultLocaleItem == pRemoveItem ) |
| { |
| for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != pRemoveItem ) |
| { |
| pFallbackItem = pLocaleItem; |
| break; |
| } |
| } |
| if( m_pCurrentLocaleItem == pRemoveItem ) |
| { |
| sal_Bool FindClosestMatch = false; |
| setCurrentLocale( pFallbackItem->m_locale, FindClosestMatch ); |
| } |
| if( m_pDefaultLocaleItem == pRemoveItem ) |
| { |
| setDefaultLocale( pFallbackItem->m_locale ); |
| } |
| } |
| } |
| for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem == pRemoveItem ) |
| { |
| // Remember locale item to delete file while storing |
| m_aDeletedLocaleItemVector.push_back( pLocaleItem ); |
| |
| // Last locale? |
| if( nLocaleCount == 1 ) |
| { |
| m_nNextUniqueNumericId = 0; |
| if( m_pDefaultLocaleItem ) |
| { |
| LocaleItem* pChangedDefaultLocaleItem = new LocaleItem( m_pDefaultLocaleItem->m_locale ); |
| m_aChangedDefaultLocaleVector.push_back( pChangedDefaultLocaleItem ); |
| } |
| m_pCurrentLocaleItem = NULL; |
| m_pDefaultLocaleItem = NULL; |
| } |
| |
| m_aLocaleItemVector.erase( it ); |
| |
| implModified(); |
| break; |
| } |
| } |
| } |
| } |
| |
| void StringResourceImpl::implScanIdForNumber( const ::rtl::OUString& ResourceID ) |
| { |
| const sal_Unicode* pSrc = ResourceID.getStr(); |
| sal_Int32 nLen = ResourceID.getLength(); |
| |
| sal_Int32 nNumber = 0; |
| for( sal_Int32 i = 0 ; i < nLen ; i++ ) |
| { |
| sal_Unicode c = pSrc[i]; |
| if( c >= '0' && c <= '9' ) |
| { |
| sal_uInt16 nDigitVal = c - '0'; |
| nNumber = 10*nNumber + nDigitVal; |
| } |
| else |
| break; |
| } |
| |
| if( m_nNextUniqueNumericId < nNumber + 1 ) |
| m_nNextUniqueNumericId = nNumber + 1; |
| } |
| |
| sal_Int32 StringResourceImpl::getUniqueNumericId( ) |
| throw (RuntimeException, NoSupportException) |
| { |
| if( m_nNextUniqueNumericId == UNIQUE_NUMBER_NEEDS_INITIALISATION ) |
| { |
| implLoadAllLocales(); |
| m_nNextUniqueNumericId = 0; |
| } |
| |
| if( m_nNextUniqueNumericId < UNIQUE_NUMBER_NEEDS_INITIALISATION ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "getUniqueNumericId: Extended sal_Int32 range" ); |
| throw NoSupportException( errorMsg, Reference< XInterface >() ); |
| } |
| return m_nNextUniqueNumericId; |
| } |
| |
| |
| // ============================================================================= |
| // Private helper methods |
| |
| LocaleItem* StringResourceImpl::getItemForLocale |
| ( const Locale& locale, sal_Bool bException ) |
| throw (::com::sun::star::lang::IllegalArgumentException) |
| { |
| LocaleItem* pRetItem = NULL; |
| |
| // Search for locale |
| for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem ) |
| { |
| Locale& cmp_locale = pLocaleItem->m_locale; |
| if( cmp_locale.Language == locale.Language && |
| cmp_locale.Country == locale.Country && |
| cmp_locale.Variant == locale.Variant ) |
| { |
| pRetItem = pLocaleItem; |
| break; |
| } |
| } |
| } |
| |
| if( pRetItem == NULL && bException ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceImpl: Invalid locale" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 ); |
| } |
| return pRetItem; |
| } |
| |
| // Returns the LocalItem for a given locale, if it exists, otherwise NULL |
| // This method performes a closest match search, at least the language must match |
| LocaleItem* StringResourceImpl::getClosestMatchItemForLocale( const Locale& locale ) |
| { |
| LocaleItem* pRetItem = NULL; |
| |
| // Search for locale |
| for( sal_Int32 iPass = 0 ; iPass <= 2 ; ++iPass ) |
| { |
| for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem ) |
| { |
| Locale& cmp_locale = pLocaleItem->m_locale; |
| if( cmp_locale.Language == locale.Language && |
| (iPass > 1 || cmp_locale.Country == locale.Country) && |
| (iPass > 0 || cmp_locale.Variant == locale.Variant) ) |
| { |
| pRetItem = pLocaleItem; |
| break; |
| } |
| } |
| } |
| if( pRetItem ) |
| break; |
| } |
| |
| return pRetItem; |
| } |
| |
| void StringResourceImpl::implModified( void ) |
| { |
| m_bModified = true; |
| implNotifyListeners(); |
| } |
| |
| void StringResourceImpl::implNotifyListeners( void ) |
| { |
| EventObject aEvent; |
| aEvent.Source = static_cast< XInterface* >( (OWeakObject*)this ); |
| |
| ::cppu::OInterfaceIteratorHelper it( m_aListenerContainer ); |
| while( it.hasMoreElements() ) |
| { |
| Reference< XInterface > xIface = it.next(); |
| Reference< XModifyListener > xListener( xIface, UNO_QUERY ); |
| try |
| { |
| xListener->modified( aEvent ); |
| } |
| catch(RuntimeException&) |
| { |
| it.remove(); |
| } |
| } |
| } |
| |
| |
| // ============================================================================= |
| // Loading |
| |
| bool StringResourceImpl::loadLocale( LocaleItem* pLocaleItem ) |
| { |
| // Base implementation has nothing to load |
| (void)pLocaleItem; |
| return true; |
| } |
| |
| void StringResourceImpl::implLoadAllLocales( void ) |
| { |
| // Base implementation has nothing to load |
| } |
| |
| |
| Reference< XMultiComponentFactory > StringResourceImpl::getMultiComponentFactory( void ) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| if( !m_xMCF.is() ) |
| { |
| Reference< XMultiComponentFactory > xSMgr( m_xContext->getServiceManager(), UNO_QUERY ); |
| if( !xSMgr.is() ) |
| { |
| throw RuntimeException( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StringResourceImpl::getMultiComponentFactory: Couldn't instantiate MultiComponentFactory" ) ), |
| Reference< XInterface >() ); |
| } |
| m_xMCF = xSMgr; |
| } |
| return m_xMCF; |
| } |
| |
| |
| // ============================================================================= |
| // StringResourcePersistenceImpl |
| // ============================================================================= |
| |
| StringResourcePersistenceImpl::StringResourcePersistenceImpl( const Reference< XComponentContext >& rxContext ) |
| : StringResourcePersistenceImpl_BASE( rxContext ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| StringResourcePersistenceImpl::~StringResourcePersistenceImpl() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XServiceInfo |
| // ----------------------------------------------------------------------------- |
| |
| ::rtl::OUString StringResourcePersistenceImpl::getImplementationName( ) |
| throw (RuntimeException) |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM |
| ( "com.sun.star.comp.scripting.StringResourceWithLocation") ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool StringResourcePersistenceImpl::supportsService( const ::rtl::OUString& rServiceName ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::supportsService( rServiceName ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Sequence< ::rtl::OUString > StringResourcePersistenceImpl::getSupportedServiceNames( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getSupportedServiceNames(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XInitialization base functionality for derived classes |
| // ----------------------------------------------------------------------------- |
| |
| static ::rtl::OUString aNameBaseDefaultStr = ::rtl::OUString::createFromAscii( "strings" ); |
| |
| void StringResourcePersistenceImpl::implInitializeCommonParameters |
| ( const Sequence< Any >& aArguments ) |
| throw (Exception, RuntimeException) |
| { |
| bool bReadOnlyOk = (aArguments[1] >>= m_bReadOnly); |
| if( !bReadOnlyOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "XInitialization::initialize: Expected ReadOnly flag" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 1 ); |
| } |
| |
| com::sun::star::lang::Locale aCurrentLocale; |
| bool bLocaleOk = (aArguments[2] >>= aCurrentLocale); |
| if( !bLocaleOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "XInitialization::initialize: Expected Locale" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 2 ); |
| } |
| |
| bool bNameBaseOk = (aArguments[3] >>= m_aNameBase); |
| if( !bNameBaseOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "XInitialization::initialize: Expected NameBase string" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 3 ); |
| } |
| if( m_aNameBase.getLength() == 0 ) |
| m_aNameBase = aNameBaseDefaultStr; |
| |
| bool bCommentOk = (aArguments[4] >>= m_aComment); |
| if( !bCommentOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "XInitialization::initialize: Expected Comment string" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 4 ); |
| } |
| |
| implScanLocales(); |
| |
| sal_Bool FindClosestMatch = true; |
| sal_Bool bUseDefaultIfNoMatch = true; |
| implSetCurrentLocale( aCurrentLocale, FindClosestMatch, bUseDefaultIfNoMatch ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Forwarding calls to base class |
| |
| // XModifyBroadcaster |
| void StringResourcePersistenceImpl::addModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| StringResourceImpl::addModifyListener( aListener ); |
| } |
| void StringResourcePersistenceImpl::removeModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| StringResourceImpl::removeModifyListener( aListener ); |
| } |
| |
| // XStringResourceResolver |
| ::rtl::OUString StringResourcePersistenceImpl::resolveString( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| return StringResourceImpl::resolveString( ResourceID ) ; |
| } |
| ::rtl::OUString StringResourcePersistenceImpl::resolveStringForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw ( ::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| return StringResourceImpl::resolveStringForLocale( ResourceID, locale ); |
| } |
| sal_Bool StringResourcePersistenceImpl::hasEntryForId( const ::rtl::OUString& ResourceID ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::hasEntryForId( ResourceID ) ; |
| } |
| sal_Bool StringResourcePersistenceImpl::hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID, |
| const Locale& locale ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale ); |
| } |
| Locale StringResourcePersistenceImpl::getCurrentLocale() |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getCurrentLocale(); |
| } |
| Locale StringResourcePersistenceImpl::getDefaultLocale( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getDefaultLocale(); |
| } |
| Sequence< Locale > StringResourcePersistenceImpl::getLocales( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getLocales(); |
| } |
| |
| // XStringResourceManager |
| sal_Bool StringResourcePersistenceImpl::isReadOnly() |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::isReadOnly(); |
| } |
| void StringResourcePersistenceImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| StringResourceImpl::setCurrentLocale( locale, FindClosestMatch ); |
| } |
| void StringResourcePersistenceImpl::setDefaultLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException,NoSupportException) |
| { |
| StringResourceImpl::setDefaultLocale( locale ); |
| } |
| Sequence< ::rtl::OUString > StringResourcePersistenceImpl::getResourceIDs( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getResourceIDs(); |
| } |
| void StringResourcePersistenceImpl::setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str ) |
| throw (NoSupportException, RuntimeException) |
| { |
| StringResourceImpl::setString( ResourceID, Str ); |
| } |
| void StringResourcePersistenceImpl::setStringForLocale |
| ( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str, const Locale& locale ) |
| throw (NoSupportException, RuntimeException) |
| { |
| StringResourceImpl::setStringForLocale( ResourceID, Str, locale ); |
| } |
| Sequence< ::rtl::OUString > StringResourcePersistenceImpl::getResourceIDsForLocale |
| ( const Locale& locale ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| return StringResourceImpl::getResourceIDsForLocale( locale ); |
| } |
| void StringResourcePersistenceImpl::removeId( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeId( ResourceID ); |
| } |
| void StringResourcePersistenceImpl::removeIdForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeIdForLocale( ResourceID, locale ); |
| } |
| void StringResourcePersistenceImpl::newLocale( const Locale& locale ) |
| throw (ElementExistException, IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::newLocale( locale ); |
| } |
| void StringResourcePersistenceImpl::removeLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeLocale( locale ); |
| } |
| sal_Int32 StringResourcePersistenceImpl::getUniqueNumericId( ) |
| throw (RuntimeException, NoSupportException) |
| { |
| return StringResourceImpl::getUniqueNumericId(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XStringResourcePersistence |
| |
| void StringResourcePersistenceImpl::store() |
| throw (NoSupportException, Exception, RuntimeException) |
| { |
| } |
| |
| sal_Bool StringResourcePersistenceImpl::isModified( ) |
| throw (RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| return m_bModified; |
| } |
| |
| void StringResourcePersistenceImpl::setComment( const ::rtl::OUString& Comment ) |
| throw (::com::sun::star::uno::RuntimeException) |
| { |
| m_aComment = Comment; |
| } |
| |
| void StringResourcePersistenceImpl::storeToStorage( const Reference< XStorage >& Storage, |
| const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment ) |
| throw (Exception, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| bool bUsedForStore = false; |
| bool bStoreAll = true; |
| implStoreAtStorage( NameBase, Comment, Storage, bUsedForStore, bStoreAll ); |
| } |
| |
| void StringResourcePersistenceImpl::implStoreAtStorage |
| ( |
| const ::rtl::OUString& aNameBase, |
| const ::rtl::OUString& aComment, |
| const Reference< ::com::sun::star::embed::XStorage >& Storage, |
| bool bUsedForStore, |
| bool bStoreAll |
| ) |
| throw (Exception, RuntimeException) |
| { |
| // Delete files for deleted locales |
| if( bUsedForStore ) |
| { |
| while( m_aDeletedLocaleItemVector.size() > 0 ) |
| { |
| LocaleItemVectorIt it = m_aDeletedLocaleItemVector.begin(); |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL ) |
| { |
| ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase ); |
| aStreamName += ::rtl::OUString::createFromAscii( ".properties" ); |
| |
| try |
| { |
| Storage->removeElement( aStreamName ); |
| } |
| catch( Exception& ) |
| {} |
| |
| m_aDeletedLocaleItemVector.erase( it ); |
| delete pLocaleItem; |
| } |
| } |
| } |
| |
| for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL && (bStoreAll || pLocaleItem->m_bModified) && |
| loadLocale( pLocaleItem ) ) |
| { |
| ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, aNameBase ); |
| aStreamName += ::rtl::OUString::createFromAscii( ".properties" ); |
| |
| Reference< io::XStream > xElementStream = |
| Storage->openStreamElement( aStreamName, ElementModes::READWRITE ); |
| |
| ::rtl::OUString aPropName = ::rtl::OUString::createFromAscii( "MediaType" ); |
| ::rtl::OUString aMime = ::rtl::OUString::createFromAscii( "text/plain" ); |
| |
| uno::Reference< beans::XPropertySet > xProps( xElementStream, uno::UNO_QUERY ); |
| OSL_ENSURE( xProps.is(), "The StorageStream must implement XPropertySet interface!\n" ); |
| if ( xProps.is() ) |
| { |
| xProps->setPropertyValue( aPropName, uno::makeAny( aMime ) ); |
| |
| aPropName = ::rtl::OUString::createFromAscii( "UseCommonStoragePasswordEncryption" ); |
| xProps->setPropertyValue( aPropName, uno::makeAny( sal_True ) ); |
| } |
| |
| Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream(); |
| if( xOutputStream.is() ) |
| implWritePropertiesFile( pLocaleItem, xOutputStream, aComment ); |
| xOutputStream->closeOutput(); |
| |
| if( bUsedForStore ) |
| pLocaleItem->m_bModified = false; |
| } |
| } |
| |
| // Delete files for changed defaults |
| if( bUsedForStore ) |
| { |
| for( LocaleItemVectorIt it = m_aChangedDefaultLocaleVector.begin(); |
| it != m_aChangedDefaultLocaleVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL ) |
| { |
| ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase ); |
| aStreamName += ::rtl::OUString::createFromAscii( ".default" ); |
| |
| try |
| { |
| Storage->removeElement( aStreamName ); |
| } |
| catch( Exception& ) |
| {} |
| |
| delete pLocaleItem; |
| } |
| } |
| m_aChangedDefaultLocaleVector.clear(); |
| } |
| |
| // Default locale |
| if( m_pDefaultLocaleItem != NULL && (bStoreAll || m_bDefaultModified) ) |
| { |
| ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( m_pDefaultLocaleItem, aNameBase ); |
| aStreamName += ::rtl::OUString::createFromAscii( ".default" ); |
| |
| Reference< io::XStream > xElementStream = |
| Storage->openStreamElement( aStreamName, ElementModes::READWRITE ); |
| |
| ::rtl::OUString aPropName = ::rtl::OUString::createFromAscii( "MediaType" ); |
| ::rtl::OUString aMime = ::rtl::OUString::createFromAscii( "text/plain" ); |
| |
| // Only create stream without content |
| Reference< io::XOutputStream > xOutputStream = xElementStream->getOutputStream(); |
| xOutputStream->closeOutput(); |
| |
| if( bUsedForStore ) |
| m_bDefaultModified = false; |
| } |
| } |
| |
| void StringResourcePersistenceImpl::storeToURL( const ::rtl::OUString& URL, |
| const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment, |
| const Reference< ::com::sun::star::task::XInteractionHandler >& Handler ) |
| throw (Exception, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| bool bUsedForStore = false; |
| bool bStoreAll = true; |
| |
| Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory(); |
| Reference< ucb::XSimpleFileAccess > xFileAccess; |
| xFileAccess = Reference< ucb::XSimpleFileAccess >( xMCF->createInstanceWithContext |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ), |
| m_xContext ), UNO_QUERY ); |
| if( xFileAccess.is() && Handler.is() ) |
| xFileAccess->setInteractionHandler( Handler ); |
| |
| implStoreAtLocation( URL, NameBase, Comment, xFileAccess, bUsedForStore, bStoreAll ); |
| } |
| |
| void StringResourcePersistenceImpl::implKillRemovedLocaleFiles |
| ( |
| const ::rtl::OUString& Location, |
| const ::rtl::OUString& aNameBase, |
| const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess |
| ) |
| throw (Exception, RuntimeException) |
| { |
| // Delete files for deleted locales |
| while( m_aDeletedLocaleItemVector.size() > 0 ) |
| { |
| LocaleItemVectorIt it = m_aDeletedLocaleItemVector.begin(); |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL ) |
| { |
| ::rtl::OUString aCompleteFileName = |
| implGetPathForLocaleItem( pLocaleItem, aNameBase, Location ); |
| if( xFileAccess->exists( aCompleteFileName ) ) |
| xFileAccess->kill( aCompleteFileName ); |
| |
| m_aDeletedLocaleItemVector.erase( it ); |
| delete pLocaleItem; |
| } |
| } |
| } |
| |
| void StringResourcePersistenceImpl::implKillChangedDefaultFiles |
| ( |
| const ::rtl::OUString& Location, |
| const ::rtl::OUString& aNameBase, |
| const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess |
| ) |
| throw (Exception, RuntimeException) |
| { |
| // Delete files for changed defaults |
| for( LocaleItemVectorIt it = m_aChangedDefaultLocaleVector.begin(); |
| it != m_aChangedDefaultLocaleVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL ) |
| { |
| ::rtl::OUString aCompleteFileName = |
| implGetPathForLocaleItem( pLocaleItem, aNameBase, Location, true ); |
| if( xFileAccess->exists( aCompleteFileName ) ) |
| xFileAccess->kill( aCompleteFileName ); |
| |
| delete pLocaleItem; |
| } |
| } |
| m_aChangedDefaultLocaleVector.clear(); |
| } |
| |
| void StringResourcePersistenceImpl::implStoreAtLocation |
| ( |
| const ::rtl::OUString& Location, |
| const ::rtl::OUString& aNameBase, |
| const ::rtl::OUString& aComment, |
| const Reference< ucb::XSimpleFileAccess >& xFileAccess, |
| bool bUsedForStore, |
| bool bStoreAll, |
| bool bKillAll |
| ) |
| throw (Exception, RuntimeException) |
| { |
| // Delete files for deleted locales |
| if( bUsedForStore || bKillAll ) |
| implKillRemovedLocaleFiles( Location, aNameBase, xFileAccess ); |
| |
| for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL && (bStoreAll || bKillAll || pLocaleItem->m_bModified) && |
| loadLocale( pLocaleItem ) ) |
| { |
| ::rtl::OUString aCompleteFileName = |
| implGetPathForLocaleItem( pLocaleItem, aNameBase, Location ); |
| if( xFileAccess->exists( aCompleteFileName ) ) |
| xFileAccess->kill( aCompleteFileName ); |
| |
| if( !bKillAll ) |
| { |
| // Create Output stream |
| Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName ); |
| if( xOutputStream.is() ) |
| { |
| implWritePropertiesFile( pLocaleItem, xOutputStream, aComment ); |
| xOutputStream->closeOutput(); |
| } |
| if( bUsedForStore ) |
| pLocaleItem->m_bModified = false; |
| } |
| } |
| } |
| |
| // Delete files for changed defaults |
| if( bUsedForStore || bKillAll ) |
| implKillChangedDefaultFiles( Location, aNameBase, xFileAccess ); |
| |
| // Default locale |
| if( m_pDefaultLocaleItem != NULL && (bStoreAll || bKillAll || m_bDefaultModified) ) |
| { |
| ::rtl::OUString aCompleteFileName = |
| implGetPathForLocaleItem( m_pDefaultLocaleItem, aNameBase, Location, true ); |
| if( xFileAccess->exists( aCompleteFileName ) ) |
| xFileAccess->kill( aCompleteFileName ); |
| |
| if( !bKillAll ) |
| { |
| // Create Output stream |
| Reference< io::XOutputStream > xOutputStream = xFileAccess->openFileWrite( aCompleteFileName ); |
| if( xOutputStream.is() ) |
| xOutputStream->closeOutput(); |
| |
| if( bUsedForStore ) |
| m_bDefaultModified = false; |
| } |
| } |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| // BinaryOutput, helper class for exportBinary |
| |
| class BinaryOutput |
| { |
| Reference< XMultiComponentFactory > m_xMCF; |
| Reference< XComponentContext > m_xContext; |
| Reference< XInterface > m_xTempFile; |
| Reference< io::XOutputStream > m_xOutputStream; |
| |
| public: |
| BinaryOutput( Reference< XMultiComponentFactory > xMCF, |
| Reference< XComponentContext > xContext ); |
| |
| Reference< io::XOutputStream > getOutputStream( void ) |
| { return m_xOutputStream; } |
| |
| Sequence< ::sal_Int8 > closeAndGetData( void ); |
| |
| // Template to be used with sal_Int16 and sal_Unicode |
| template< class T > |
| void write16BitInt( T n ); |
| void writeInt16( sal_Int16 n ) |
| { write16BitInt( n ); } |
| void writeUnicodeChar( sal_Unicode n ) |
| { write16BitInt( n ); } |
| void writeInt32( sal_Int32 n ); |
| void writeString( const ::rtl::OUString& aStr ); |
| }; |
| |
| BinaryOutput::BinaryOutput( Reference< XMultiComponentFactory > xMCF, |
| Reference< XComponentContext > xContext ) |
| : m_xMCF( xMCF ) |
| , m_xContext( xContext ) |
| { |
| m_xTempFile = m_xMCF->createInstanceWithContext |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ), m_xContext ); |
| if( m_xTempFile.is() ) |
| m_xOutputStream = Reference< io::XOutputStream >( m_xTempFile, UNO_QUERY ); |
| } |
| |
| template< class T > |
| void BinaryOutput::write16BitInt( T n ) |
| { |
| if( !m_xOutputStream.is() ) |
| return; |
| |
| Sequence< sal_Int8 > aSeq( 2 ); |
| sal_Int8* p = aSeq.getArray(); |
| |
| sal_Int8 nLow = sal_Int8( n & 0xff ); |
| sal_Int8 nHigh = sal_Int8( n >> 8 ); |
| |
| p[0] = nLow; |
| p[1] = nHigh; |
| m_xOutputStream->writeBytes( aSeq ); |
| } |
| |
| void BinaryOutput::writeInt32( sal_Int32 n ) |
| { |
| if( !m_xOutputStream.is() ) |
| return; |
| |
| Sequence< sal_Int8 > aSeq( 4 ); |
| sal_Int8* p = aSeq.getArray(); |
| |
| for( sal_Int16 i = 0 ; i < 4 ; i++ ) |
| { |
| p[i] = sal_Int8( n & 0xff ); |
| n >>= 8; |
| } |
| m_xOutputStream->writeBytes( aSeq ); |
| } |
| |
| void BinaryOutput::writeString( const ::rtl::OUString& aStr ) |
| { |
| sal_Int32 nLen = aStr.getLength(); |
| const sal_Unicode* pStr = aStr.getStr(); |
| |
| for( sal_Int32 i = 0 ; i < nLen ; i++ ) |
| writeUnicodeChar( pStr[i] ); |
| |
| writeUnicodeChar( 0 ); |
| } |
| |
| Sequence< ::sal_Int8 > BinaryOutput::closeAndGetData( void ) |
| { |
| Sequence< ::sal_Int8 > aRetSeq; |
| if( !m_xOutputStream.is() ) |
| return aRetSeq; |
| |
| m_xOutputStream->closeOutput(); |
| |
| Reference< io::XSeekable> xSeekable( m_xTempFile, UNO_QUERY ); |
| if( !xSeekable.is() ) |
| return aRetSeq; |
| |
| sal_Int32 nSize = (sal_Int32)xSeekable->getPosition(); |
| |
| Reference< io::XInputStream> xInputStream( m_xTempFile, UNO_QUERY ); |
| if( !xInputStream.is() ) |
| return aRetSeq; |
| |
| xSeekable->seek( 0 ); |
| sal_Int32 nRead = xInputStream->readBytes( aRetSeq, nSize ); |
| (void)nRead; |
| OSL_ENSURE( nRead == nSize, "BinaryOutput::closeAndGetData: nRead != nSize" ); |
| |
| return aRetSeq; |
| } |
| |
| |
| // Binary format: |
| |
| // Header |
| // Byte Content |
| // 0 + 1 sal_Int16: Version, currently 0, low byte first |
| // 2 + 3 sal_Int16: Locale count = n, low byte first |
| // 4 + 5 sal_Int16: Default Locale position in Locale list, == n if none |
| // 6 - 7 sal_Int32: Start index locale block 0, lowest byte first |
| // (n-1) * sal_Int32: Start index locale block 1 to n, lowest byte first |
| // 6 + 4*n sal_Int32: "Start index" non existing locale block n+1, |
| // marks the first invalid index, kind of EOF |
| |
| // Locale block |
| // All strings are stored as 2-Byte-0 terminated sequence |
| // of 16 bit Unicode characters, each with low byte first |
| // Empty strings only contain the 2-Byte-0 |
| |
| // Members of com.sun.star.lang.Locale |
| // with l1 = Locale.Language.getLength() |
| // with l2 = Locale.Country.getLength() |
| // with l3 = Locale.Variant.getLength() |
| // pos0 = 0 Locale.Language |
| // pos1 = 2 * (l1 + 1) Locale.Country |
| // pos2 = pos1 + 2 * (l2 + 1) Locale.Variant |
| // pos3 = pos2 + 2 * (l3 + 1) |
| // pos3 Properties file written by implWritePropertiesFile |
| |
| Sequence< sal_Int8 > StringResourcePersistenceImpl::exportBinary( ) |
| throw (RuntimeException) |
| { |
| Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory(); |
| BinaryOutput aOut( xMCF, m_xContext ); |
| |
| sal_Int32 nLocaleCount = m_aLocaleItemVector.size(); |
| Sequence< sal_Int8 >* pLocaleDataSeq = new Sequence< sal_Int8 >[ nLocaleCount ]; |
| |
| sal_Int32 iLocale = 0; |
| sal_Int32 iDefault = 0; |
| for( LocaleItemVectorConstIt it = m_aLocaleItemVector.begin(); |
| it != m_aLocaleItemVector.end(); it++,iLocale++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL && loadLocale( pLocaleItem ) ) |
| { |
| if( m_pDefaultLocaleItem == pLocaleItem ) |
| iDefault = iLocale; |
| |
| BinaryOutput aLocaleOut( m_xMCF, m_xContext ); |
| implWriteLocaleBinary( pLocaleItem, aLocaleOut ); |
| |
| pLocaleDataSeq[iLocale] = aLocaleOut.closeAndGetData(); |
| } |
| } |
| |
| // Write header |
| sal_Int16 nVersion = 0; |
| sal_Int16 nLocaleCount16 = (sal_Int16)nLocaleCount; |
| sal_Int16 iDefault16 = (sal_Int16)iDefault; |
| aOut.writeInt16( nVersion ); |
| aOut.writeInt16( nLocaleCount16 ); |
| aOut.writeInt16( iDefault16 ); |
| |
| // Write data positions |
| sal_Int32 nDataPos = 6 + 4 * (nLocaleCount + 1); |
| for( iLocale = 0; iLocale < nLocaleCount; iLocale++ ) |
| { |
| aOut.writeInt32( nDataPos ); |
| |
| Sequence< sal_Int8 >& rSeq = pLocaleDataSeq[iLocale]; |
| sal_Int32 nSeqLen = rSeq.getLength(); |
| nDataPos += nSeqLen; |
| } |
| // Write final position |
| aOut.writeInt32( nDataPos ); |
| |
| // Write data |
| Reference< io::XOutputStream > xOutputStream = aOut.getOutputStream(); |
| if( xOutputStream.is() ) |
| { |
| for( iLocale = 0; iLocale < nLocaleCount; iLocale++ ) |
| { |
| Sequence< sal_Int8 >& rSeq = pLocaleDataSeq[iLocale]; |
| xOutputStream->writeBytes( rSeq ); |
| } |
| } |
| |
| delete[] pLocaleDataSeq; |
| |
| Sequence< sal_Int8 > aRetSeq = aOut.closeAndGetData(); |
| return aRetSeq; |
| } |
| |
| void StringResourcePersistenceImpl::implWriteLocaleBinary |
| ( LocaleItem* pLocaleItem, BinaryOutput& rOut ) |
| { |
| Reference< io::XOutputStream > xOutputStream = rOut.getOutputStream(); |
| if( !xOutputStream.is() ) |
| return; |
| |
| Locale& rLocale = pLocaleItem->m_locale; |
| rOut.writeString( rLocale.Language ); |
| rOut.writeString( rLocale.Country ); |
| rOut.writeString( rLocale.Variant ); |
| implWritePropertiesFile( pLocaleItem, xOutputStream, m_aComment ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // BinaryOutput, helper class for exportBinary |
| |
| class BinaryInput |
| { |
| Sequence< sal_Int8 > m_aData; |
| Reference< XMultiComponentFactory > m_xMCF; |
| Reference< XComponentContext > m_xContext; |
| |
| const sal_Int8* m_pData; |
| sal_Int32 m_nCurPos; |
| sal_Int32 m_nSize; |
| |
| public: |
| BinaryInput( Sequence< ::sal_Int8 > aData, Reference< XMultiComponentFactory > xMCF, |
| Reference< XComponentContext > xContext ); |
| |
| Reference< io::XInputStream > getInputStreamForSection( sal_Int32 nSize ); |
| |
| void seek( sal_Int32 nPos ); |
| sal_Int32 getPosition( void ) |
| { return m_nCurPos; } |
| |
| sal_Int16 readInt16( void ); |
| sal_Int32 readInt32( void ); |
| sal_Unicode readUnicodeChar( void ); |
| ::rtl::OUString readString( void ); |
| }; |
| |
| BinaryInput::BinaryInput( Sequence< ::sal_Int8 > aData, Reference< XMultiComponentFactory > xMCF, |
| Reference< XComponentContext > xContext ) |
| : m_aData( aData ) |
| , m_xMCF( xMCF ) |
| , m_xContext( xContext ) |
| { |
| m_pData = m_aData.getConstArray(); |
| m_nCurPos = 0; |
| m_nSize = m_aData.getLength(); |
| } |
| |
| Reference< io::XInputStream > BinaryInput::getInputStreamForSection( sal_Int32 nSize ) |
| { |
| Reference< io::XInputStream > xIn; |
| if( m_nCurPos + nSize <= m_nSize ) |
| { |
| Reference< io::XOutputStream > xTempOut( m_xMCF->createInstanceWithContext |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ), m_xContext ), UNO_QUERY ); |
| if( xTempOut.is() ) |
| { |
| Sequence< sal_Int8 > aSection( m_pData + m_nCurPos, nSize ); |
| xTempOut->writeBytes( aSection ); |
| |
| Reference< io::XSeekable> xSeekable( xTempOut, UNO_QUERY ); |
| if( xSeekable.is() ) |
| xSeekable->seek( 0 ); |
| |
| xIn = Reference< io::XInputStream>( xTempOut, UNO_QUERY ); |
| } |
| } |
| else |
| OSL_ENSURE( false, "BinaryInput::getInputStreamForSection(): Read past end" ); |
| |
| return xIn; |
| } |
| |
| void BinaryInput::seek( sal_Int32 nPos ) |
| { |
| if( nPos <= m_nSize ) |
| m_nCurPos = nPos; |
| else |
| OSL_ENSURE( false, "BinaryInput::seek(): Position past end" ); |
| } |
| |
| |
| sal_Int16 BinaryInput::readInt16( void ) |
| { |
| sal_Int16 nRet = 0; |
| if( m_nCurPos + 2 <= m_nSize ) |
| { |
| nRet = nRet + sal_Int16( sal_uInt8( m_pData[m_nCurPos++] ) ); |
| nRet += 256 * sal_Int16( sal_uInt8( m_pData[m_nCurPos++] ) ); |
| } |
| else |
| OSL_ENSURE( false, "BinaryInput::readInt16(): Read past end" ); |
| |
| return nRet; |
| } |
| |
| sal_Int32 BinaryInput::readInt32( void ) |
| { |
| sal_Int32 nRet = 0; |
| if( m_nCurPos + 4 <= m_nSize ) |
| { |
| sal_Int32 nFactor = 1; |
| for( sal_Int16 i = 0; i < 4; i++ ) |
| { |
| nRet += sal_uInt8( m_pData[m_nCurPos++] ) * nFactor; |
| nFactor *= 256; |
| } |
| } |
| else |
| OSL_ENSURE( false, "BinaryInput::readInt32(): Read past end" ); |
| |
| return nRet; |
| } |
| |
| sal_Unicode BinaryInput::readUnicodeChar( void ) |
| { |
| sal_uInt16 nRet = 0; |
| if( m_nCurPos + 2 <= m_nSize ) |
| { |
| nRet = nRet + sal_uInt8( m_pData[m_nCurPos++] ); |
| nRet += 256 * sal_uInt8( m_pData[m_nCurPos++] ); |
| } |
| else |
| OSL_ENSURE( false, "BinaryInput::readUnicodeChar(): Read past end" ); |
| |
| sal_Unicode cRet = nRet; |
| return cRet; |
| } |
| |
| ::rtl::OUString BinaryInput::readString( void ) |
| { |
| ::rtl::OUStringBuffer aBuf; |
| sal_Unicode c; |
| do |
| { |
| c = readUnicodeChar(); |
| if( c != 0 ) |
| aBuf.append( c ); |
| } |
| while( c != 0 ); |
| |
| ::rtl::OUString aRetStr = aBuf.makeStringAndClear(); |
| return aRetStr; |
| } |
| |
| void StringResourcePersistenceImpl::importBinary( const Sequence< ::sal_Int8 >& Data ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| // Init: Remove all locales |
| sal_Int32 nOldLocaleCount = 0; |
| do |
| { |
| Sequence< Locale > aLocaleSeq = getLocales(); |
| nOldLocaleCount = aLocaleSeq.getLength(); |
| if( nOldLocaleCount > 0 ) |
| { |
| Locale aLocale = aLocaleSeq[0]; |
| removeLocale( aLocale ); |
| } |
| } |
| while( nOldLocaleCount > 0 ); |
| |
| // Import data |
| Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory(); |
| BinaryInput aIn( Data, xMCF, m_xContext ); |
| |
| sal_Int32 nVersion = aIn.readInt16(); |
| (void)nVersion; |
| sal_Int32 nLocaleCount = aIn.readInt16(); |
| sal_Int32 iDefault = aIn.readInt16(); |
| (void)iDefault; |
| |
| sal_Int32* pPositions = new sal_Int32[nLocaleCount + 1]; |
| for( sal_Int32 i = 0; i < nLocaleCount + 1; i++ ) |
| pPositions[i] = aIn.readInt32(); |
| |
| // Import locales |
| LocaleItem* pUseAsDefaultItem = NULL; |
| for( sal_Int32 i = 0; i < nLocaleCount; i++ ) |
| { |
| sal_Int32 nPos = pPositions[i]; |
| aIn.seek( nPos ); |
| |
| Locale aLocale; |
| aLocale.Language = aIn.readString(); |
| aLocale.Country = aIn.readString(); |
| aLocale.Variant = aIn.readString(); |
| |
| sal_Int32 nAfterStringPos = aIn.getPosition(); |
| sal_Int32 nSize = pPositions[i+1] - nAfterStringPos; |
| Reference< io::XInputStream > xInput = aIn.getInputStreamForSection( nSize ); |
| if( xInput.is() ) |
| { |
| LocaleItem* pLocaleItem = new LocaleItem( aLocale ); |
| if( iDefault == i ) |
| pUseAsDefaultItem = pLocaleItem; |
| m_aLocaleItemVector.push_back( pLocaleItem ); |
| implReadPropertiesFile( pLocaleItem, xInput ); |
| } |
| } |
| |
| if( pUseAsDefaultItem != NULL ) |
| setDefaultLocale( pUseAsDefaultItem->m_locale ); |
| |
| delete[] pPositions; |
| } |
| |
| |
| // ============================================================================= |
| // Private helper methods |
| |
| bool checkNamingSceme( const ::rtl::OUString& aName, const ::rtl::OUString& aNameBase, |
| Locale& aLocale ) |
| { |
| bool bSuccess = false; |
| |
| sal_Int32 nNameLen = aName.getLength(); |
| sal_Int32 nNameBaseLen = aNameBase.getLength(); |
| |
| // Name has to start with NameBase followed |
| // by a '_' and at least one more character |
| if( aName.indexOf( aNameBase ) == 0 && nNameBaseLen < nNameLen-1 && |
| aName.getStr()[nNameBaseLen] == '_' ) |
| { |
| bSuccess = true; |
| |
| sal_Int32 iStart = nNameBaseLen + 1; |
| sal_Int32 iNext_ = aName.indexOf( '_', iStart ); |
| if( iNext_ != -1 && iNext_ < nNameLen-1 ) |
| { |
| aLocale.Language = aName.copy( iStart, iNext_ - iStart ); |
| |
| iStart = iNext_ + 1; |
| iNext_ = aName.indexOf( '_', iStart ); |
| if( iNext_ != -1 && iNext_ < nNameLen-1 ) |
| { |
| aLocale.Country = aName.copy( iStart, iNext_ - iStart ); |
| aLocale.Variant = aName.copy( iNext_ + 1 ); |
| } |
| else |
| aLocale.Country = aName.copy( iStart ); |
| } |
| else |
| aLocale.Language = aName.copy( iStart ); |
| } |
| return bSuccess; |
| } |
| |
| void StringResourcePersistenceImpl::implLoadAllLocales( void ) |
| { |
| for( LocaleItemVectorIt it = m_aLocaleItemVector.begin(); it != m_aLocaleItemVector.end(); it++ ) |
| { |
| LocaleItem* pLocaleItem = *it; |
| if( pLocaleItem != NULL ) |
| loadLocale( pLocaleItem ); |
| } |
| } |
| |
| // Scan locale properties files helper |
| void StringResourcePersistenceImpl::implScanLocaleNames( const Sequence< ::rtl::OUString >& aContentSeq ) |
| { |
| Locale aDefaultLocale; |
| bool bDefaultFound = false; |
| |
| sal_Int32 nCount = aContentSeq.getLength(); |
| const ::rtl::OUString* pFiles = aContentSeq.getConstArray(); |
| for( int i = 0 ; i < nCount ; i++ ) |
| { |
| ::rtl::OUString aCompleteName = pFiles[i]; |
| rtl::OUString aPureName; |
| rtl::OUString aExtension; |
| sal_Int32 iDot = aCompleteName.lastIndexOf( '.' ); |
| sal_Int32 iSlash = aCompleteName.lastIndexOf( '/' ); |
| if( iDot != -1 ) |
| { |
| sal_Int32 iCopyFrom = (iSlash != -1) ? iSlash + 1 : 0; |
| aPureName = aCompleteName.copy( iCopyFrom, iDot-iCopyFrom ); |
| aExtension = aCompleteName.copy( iDot + 1 ); |
| } |
| |
| if( aExtension.equalsAscii( "properties" ) ) |
| { |
| //rtl::OUString aName = aInetObj.getBase(); |
| Locale aLocale; |
| |
| if( checkNamingSceme( aPureName, m_aNameBase, aLocale ) ) |
| { |
| LocaleItem* pLocaleItem = new LocaleItem( aLocale, false ); |
| m_aLocaleItemVector.push_back( pLocaleItem ); |
| |
| if( m_pCurrentLocaleItem == NULL ) |
| m_pCurrentLocaleItem = pLocaleItem; |
| |
| if( m_pDefaultLocaleItem == NULL ) |
| { |
| m_pDefaultLocaleItem = pLocaleItem; |
| m_bDefaultModified = true; |
| } |
| } |
| } |
| else if( !bDefaultFound && aExtension.equalsAscii( "default" ) ) |
| { |
| //rtl::OUString aName = aInetObj.getBase(); |
| Locale aLocale; |
| |
| if( checkNamingSceme( aPureName, m_aNameBase, aDefaultLocale ) ) |
| bDefaultFound = true; |
| } |
| } |
| if( bDefaultFound ) |
| { |
| LocaleItem* pLocaleItem = getItemForLocale( aDefaultLocale, false ); |
| if( pLocaleItem ) |
| { |
| m_pDefaultLocaleItem = pLocaleItem; |
| m_bDefaultModified = false; |
| } |
| } |
| } |
| |
| // Scan locale properties files |
| void StringResourcePersistenceImpl::implScanLocales( void ) |
| { |
| // Dummy implementation, method not called for this |
| // base class, but pure virtual not possible- |
| } |
| |
| bool StringResourcePersistenceImpl::loadLocale( LocaleItem* pLocaleItem ) |
| { |
| bool bSuccess = false; |
| |
| OSL_ENSURE( pLocaleItem, "StringResourcePersistenceImpl::loadLocale(): pLocaleItem == NULL" ); |
| if( pLocaleItem ) |
| { |
| if( pLocaleItem->m_bLoaded ) |
| { |
| bSuccess = true; |
| } |
| else |
| { |
| bSuccess = implLoadLocale( pLocaleItem ); |
| pLocaleItem->m_bLoaded = true; // = bSuccess??? -> leads to more tries |
| } |
| } |
| return bSuccess; |
| } |
| |
| bool StringResourcePersistenceImpl::implLoadLocale( LocaleItem* ) |
| { |
| // Dummy implementation, method not called for this |
| // base class, but pure virtual not possible- |
| return false; |
| } |
| |
| ::rtl::OUString implGetNameScemeForLocaleItem( const LocaleItem* pLocaleItem ) |
| { |
| static ::rtl::OUString aUnder = ::rtl::OUString::createFromAscii( "_" ); |
| |
| OSL_ENSURE( pLocaleItem, |
| "StringResourcePersistenceImpl::implGetNameScemeForLocaleItem(): pLocaleItem == NULL" ); |
| Locale aLocale = pLocaleItem->m_locale; |
| |
| ::rtl::OUString aRetStr = aUnder; |
| aRetStr += aLocale.Language; |
| |
| ::rtl::OUString aCountry = aLocale.Country; |
| if( aCountry.getLength() ) |
| { |
| aRetStr += aUnder; |
| aRetStr += aCountry; |
| } |
| |
| ::rtl::OUString aVariant = aLocale.Variant; |
| if( aVariant.getLength() ) |
| { |
| aRetStr += aUnder; |
| aRetStr += aVariant; |
| } |
| return aRetStr; |
| } |
| |
| ::rtl::OUString StringResourcePersistenceImpl::implGetFileNameForLocaleItem |
| ( LocaleItem* pLocaleItem, const ::rtl::OUString& aNameBase ) |
| { |
| ::rtl::OUString aFileName = aNameBase; |
| if( aFileName.getLength() == 0 ) |
| aFileName = aNameBaseDefaultStr; |
| |
| aFileName += implGetNameScemeForLocaleItem( pLocaleItem ); |
| return aFileName; |
| } |
| |
| ::rtl::OUString StringResourcePersistenceImpl::implGetPathForLocaleItem |
| ( LocaleItem* pLocaleItem, const ::rtl::OUString& aNameBase, |
| const ::rtl::OUString& aLocation, bool bDefaultFile ) |
| { |
| ::rtl::OUString aFileName = implGetFileNameForLocaleItem( pLocaleItem, aNameBase ); |
| INetURLObject aInetObj( aLocation ); |
| aInetObj.insertName( aFileName, sal_True, INetURLObject::LAST_SEGMENT, sal_True, INetURLObject::ENCODE_ALL ); |
| if( bDefaultFile ) |
| aInetObj.setExtension( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("default") ) ); |
| else |
| aInetObj.setExtension( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("properties") ) ); |
| ::rtl::OUString aCompleteFileName = aInetObj.GetMainURL( INetURLObject::NO_DECODE ); |
| return aCompleteFileName; |
| } |
| |
| // White space according to Java property files specification in |
| // http://java.sun.com/j2se/1.4.2/docs/api/java/util/Properties.html#load(java.io.InputStream) |
| inline bool isWhiteSpace( sal_Unicode c ) |
| { |
| bool bWhite = ( c == 0x0020 || // space |
| c == 0x0009 || // tab |
| c == 0x000a || // line feed, not always handled by TextInputStream |
| c == 0x000d || // carriage return, not always handled by TextInputStream |
| c == 0x000C ); // form feed |
| return bWhite; |
| } |
| |
| inline void skipWhites( const sal_Unicode* pBuf, sal_Int32 nLen, sal_Int32& ri ) |
| { |
| while( ri < nLen ) |
| { |
| if( !isWhiteSpace( pBuf[ri] ) ) |
| break; |
| ri++; |
| } |
| } |
| |
| inline bool isHexDigit( sal_Unicode c, sal_uInt16& nDigitVal ) |
| { |
| bool bRet = true; |
| if( c >= '0' && c <= '9' ) |
| nDigitVal = c - '0'; |
| else if( c >= 'a' && c <= 'f' ) |
| nDigitVal = c - 'a' + 10; |
| else if( c >= 'A' && c <= 'F' ) |
| nDigitVal = c - 'A' + 10; |
| else |
| bRet = false; |
| return bRet; |
| } |
| |
| sal_Unicode getEscapeChar( const sal_Unicode* pBuf, sal_Int32 nLen, sal_Int32& ri ) |
| { |
| sal_Int32 i = ri; |
| |
| sal_Unicode cRet = 0; |
| sal_Unicode c = pBuf[i]; |
| switch( c ) |
| { |
| case 't': |
| cRet = 0x0009; |
| break; |
| case 'n': |
| cRet = 0x000a; |
| break; |
| case 'f': |
| cRet = 0x000c; |
| break; |
| case 'r': |
| cRet = 0x000d; |
| break; |
| case '\\': |
| cRet = '\\'; |
| break; |
| case 'u': |
| { |
| // Skip multiple u |
| i++; |
| while( i < nLen && pBuf[i] == 'u' ) |
| i++; |
| |
| // Process hex digits |
| sal_Int32 nDigitCount = 0; |
| sal_uInt16 nDigitVal; |
| while( i < nLen && isHexDigit( pBuf[i], nDigitVal ) ) |
| { |
| cRet = 16 * cRet + nDigitVal; |
| |
| nDigitCount++; |
| if( nDigitCount == 4 ) |
| { |
| // Write back position |
| ri = i; |
| break; |
| } |
| i++; |
| } |
| break; |
| } |
| default: |
| cRet = c; |
| } |
| |
| return cRet; |
| } |
| |
| void CheckContinueInNextLine( Reference< io::XTextInputStream > xTextInputStream, |
| ::rtl::OUString& aLine, bool& bEscapePending, const sal_Unicode*& pBuf, |
| sal_Int32& nLen, sal_Int32& i ) |
| { |
| if( i == nLen && bEscapePending ) |
| { |
| bEscapePending = false; |
| |
| if( !xTextInputStream->isEOF() ) |
| { |
| aLine = xTextInputStream->readLine(); |
| nLen = aLine.getLength(); |
| pBuf = aLine.getStr(); |
| i = 0; |
| |
| skipWhites( pBuf, nLen, i ); |
| } |
| } |
| } |
| |
| bool StringResourcePersistenceImpl::implReadPropertiesFile |
| ( LocaleItem* pLocaleItem, const Reference< io::XInputStream >& xInputStream ) |
| { |
| if( !xInputStream.is() || pLocaleItem == NULL ) |
| return false; |
| |
| bool bSuccess = false; |
| Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory(); |
| Reference< io::XTextInputStream > xTextInputStream( xMCF->createInstanceWithContext |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TextInputStream" ), m_xContext ), UNO_QUERY ); |
| |
| if( xTextInputStream.is() ) |
| { |
| Reference< io::XActiveDataSink> xActiveDataSink( xTextInputStream, UNO_QUERY ); |
| if( xActiveDataSink.is() ) |
| { |
| bSuccess = true; |
| |
| xActiveDataSink->setInputStream( xInputStream ); |
| |
| ::rtl::OUString aEncodingStr = ::rtl::OUString::createFromAscii |
| ( rtl_getMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ) ); |
| xTextInputStream->setEncoding( aEncodingStr ); |
| |
| ::rtl::OUString aLine; |
| while( !xTextInputStream->isEOF() ) |
| { |
| aLine = xTextInputStream->readLine(); |
| |
| sal_Int32 nLen = aLine.getLength(); |
| if( 0 == nLen ) |
| continue; |
| const sal_Unicode* pBuf = aLine.getStr(); |
| ::rtl::OUStringBuffer aBuf; |
| sal_Unicode c = 0; |
| sal_Int32 i = 0; |
| |
| skipWhites( pBuf, nLen, i ); |
| if( i == nLen ) |
| continue; // line contains only white spaces |
| |
| // Comment? |
| c = pBuf[i]; |
| if( c == '#' || c == '!' ) |
| continue; |
| |
| // Scan key |
| ::rtl::OUString aResourceID; |
| bool bEscapePending = false; |
| bool bStrComplete = false; |
| while( i < nLen && !bStrComplete ) |
| { |
| c = pBuf[i]; |
| if( bEscapePending ) |
| { |
| aBuf.append( getEscapeChar( pBuf, nLen, i ) ); |
| bEscapePending = false; |
| } |
| else |
| { |
| if( c == '\\' ) |
| { |
| bEscapePending = true; |
| } |
| else |
| { |
| if( c == ':' || c == '=' || isWhiteSpace( c ) ) |
| bStrComplete = true; |
| else |
| aBuf.append( c ); |
| } |
| } |
| i++; |
| |
| CheckContinueInNextLine( xTextInputStream, aLine, bEscapePending, pBuf, nLen, i ); |
| if( i == nLen ) |
| bStrComplete = true; |
| |
| if( bStrComplete ) |
| aResourceID = aBuf.makeStringAndClear(); |
| } |
| |
| // Ignore lines with empty keys |
| if( 0 == aResourceID.getLength() ) |
| continue; |
| |
| // Scan value |
| skipWhites( pBuf, nLen, i ); |
| |
| ::rtl::OUString aValueStr; |
| bEscapePending = false; |
| bStrComplete = false; |
| while( i < nLen && !bStrComplete ) |
| { |
| c = pBuf[i]; |
| if( c == 0x000a || c == 0x000d ) // line feed/carriage return, not always handled by TextInputStream |
| { |
| i++; |
| } |
| else |
| { |
| if( bEscapePending ) |
| { |
| aBuf.append( getEscapeChar( pBuf, nLen, i ) ); |
| bEscapePending = false; |
| } |
| else if( c == '\\' ) |
| bEscapePending = true; |
| else |
| aBuf.append( c ); |
| i++; |
| |
| CheckContinueInNextLine( xTextInputStream, aLine, bEscapePending, pBuf, nLen, i ); |
| } |
| if( i == nLen ) |
| bStrComplete = true; |
| |
| if( bStrComplete ) |
| aValueStr = aBuf.makeStringAndClear(); |
| } |
| |
| // Push into table |
| pLocaleItem->m_aIdToStringMap[ aResourceID ] = aValueStr; |
| implScanIdForNumber( aResourceID ); |
| IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap; |
| rIndexMap[ aResourceID ] = pLocaleItem->m_nNextIndex++; |
| } |
| } |
| } |
| |
| return bSuccess; |
| } |
| |
| |
| inline sal_Unicode getHexCharForDigit( sal_uInt16 nDigitVal ) |
| { |
| sal_Unicode cRet = ( nDigitVal < 10 ) ? ('0' + nDigitVal) : ('a' + (nDigitVal-10)); |
| return cRet; |
| } |
| |
| void implWriteCharToBuffer( ::rtl::OUStringBuffer& aBuf, sal_Unicode cu, bool bKey ) |
| { |
| if( cu == '\\' ) |
| { |
| aBuf.append( (sal_Unicode)'\\' ); |
| aBuf.append( (sal_Unicode)'\\' ); |
| } |
| else if( cu == 0x000a ) |
| { |
| aBuf.append( (sal_Unicode)'\\' ); |
| aBuf.append( (sal_Unicode)'n' ); |
| } |
| else if( cu == 0x000d ) |
| { |
| aBuf.append( (sal_Unicode)'\\' ); |
| aBuf.append( (sal_Unicode)'r' ); |
| } |
| else if( bKey && cu == '=' ) |
| { |
| aBuf.append( (sal_Unicode)'\\' ); |
| aBuf.append( (sal_Unicode)'=' ); |
| } |
| else if( bKey && cu == ':' ) |
| { |
| aBuf.append( (sal_Unicode)'\\' ); |
| aBuf.append( (sal_Unicode)':' ); |
| } |
| // ISO/IEC 8859-1 range according to: |
| // http://en.wikipedia.org/wiki/ISO/IEC_8859-1 |
| else if( (cu >= 0x20 && cu <= 0x7e) ) |
| //TODO: Check why (cu >= 0xa0 && cu <= 0xFF) |
| //is encoded in sample properties files |
| //else if( (cu >= 0x20 && cu <= 0x7e) || |
| // (cu >= 0xa0 && cu <= 0xFF) ) |
| { |
| aBuf.append( cu ); |
| } |
| else |
| { |
| // Unicode encoding |
| aBuf.append( (sal_Unicode)'\\' ); |
| aBuf.append( (sal_Unicode)'u' ); |
| |
| sal_uInt16 nVal = cu; |
| for( sal_uInt16 i = 0 ; i < 4 ; i++ ) |
| { |
| sal_uInt16 nDigit = nVal / 0x1000; |
| nVal -= nDigit * 0x1000; |
| nVal *= 0x10; |
| aBuf.append( getHexCharForDigit( nDigit ) ); |
| } |
| } |
| } |
| |
| void implWriteStringWithEncoding( const ::rtl::OUString& aStr, |
| Reference< io::XTextOutputStream > xTextOutputStream, bool bKey ) |
| { |
| static sal_Unicode cLineFeed = 0xa; |
| |
| (void)aStr; |
| (void)xTextOutputStream; |
| |
| ::rtl::OUStringBuffer aBuf; |
| sal_Int32 nLen = aStr.getLength(); |
| const sal_Unicode* pSrc = aStr.getStr(); |
| for( sal_Int32 i = 0 ; i < nLen ; i++ ) |
| { |
| sal_Unicode cu = pSrc[i]; |
| implWriteCharToBuffer( aBuf, cu, bKey ); |
| // TODO?: split long lines |
| } |
| if( !bKey ) |
| aBuf.append( cLineFeed ); |
| |
| ::rtl::OUString aWriteStr = aBuf.makeStringAndClear(); |
| xTextOutputStream->writeString( aWriteStr ); |
| } |
| |
| bool StringResourcePersistenceImpl::implWritePropertiesFile( LocaleItem* pLocaleItem, |
| const Reference< io::XOutputStream >& xOutputStream, const ::rtl::OUString& aComment ) |
| { |
| static ::rtl::OUString aAssignmentStr = ::rtl::OUString::createFromAscii( "=" ); |
| static ::rtl::OUString aLineFeedStr = ::rtl::OUString::createFromAscii( "\n" ); |
| |
| if( !xOutputStream.is() || pLocaleItem == NULL ) |
| return false; |
| |
| bool bSuccess = false; |
| Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory(); |
| Reference< io::XTextOutputStream > xTextOutputStream( xMCF->createInstanceWithContext |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TextOutputStream" ), m_xContext ), UNO_QUERY ); |
| |
| if( xTextOutputStream.is() ) |
| { |
| Reference< io::XActiveDataSource> xActiveDataSource( xTextOutputStream, UNO_QUERY ); |
| if( xActiveDataSource.is() ) |
| { |
| xActiveDataSource->setOutputStream( xOutputStream ); |
| |
| ::rtl::OUString aEncodingStr = ::rtl::OUString::createFromAscii |
| ( rtl_getMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ) ); |
| xTextOutputStream->setEncoding( aEncodingStr ); |
| |
| xTextOutputStream->writeString( aComment ); |
| xTextOutputStream->writeString( aLineFeedStr ); |
| |
| const IdToStringMap& rHashMap = pLocaleItem->m_aIdToStringMap; |
| if( rHashMap.size() > 0 ) |
| { |
| // Sort ids according to read order |
| const IdToIndexMap& rIndexMap = pLocaleItem->m_aIdToIndexMap; |
| IdToIndexMap::const_iterator it_index; |
| |
| // Find max/min index |
| sal_Int32 nMinIndex = -1; |
| sal_Int32 nMaxIndex = -1; |
| for( it_index = rIndexMap.begin(); it_index != rIndexMap.end(); it_index++ ) |
| { |
| sal_Int32 nIndex = (*it_index).second; |
| if( nMinIndex > nIndex || nMinIndex == -1 ) |
| nMinIndex = nIndex; |
| if( nMaxIndex < nIndex ) |
| nMaxIndex = nIndex; |
| } |
| sal_Int32 nTabSize = nMaxIndex - nMinIndex + 1; |
| |
| // Create sorted array of pointers to the id strings |
| const ::rtl::OUString** pIdPtrs = new const ::rtl::OUString*[nTabSize]; |
| sal_Int32 i; |
| for( i = 0 ; i < nTabSize ; i++ ) |
| pIdPtrs[i] = NULL; |
| for( it_index = rIndexMap.begin(); it_index != rIndexMap.end(); it_index++ ) |
| { |
| sal_Int32 nIndex = (*it_index).second; |
| pIdPtrs[nIndex - nMinIndex] = &((*it_index).first); |
| } |
| |
| // Write lines in correct order |
| for( i = 0 ; i < nTabSize ; i++ ) |
| { |
| const ::rtl::OUString* pStr = pIdPtrs[i]; |
| if( pStr != NULL ) |
| { |
| ::rtl::OUString aResourceID = *pStr; |
| IdToStringMap::const_iterator it = rHashMap.find( aResourceID ); |
| if( !( it == rHashMap.end() ) ) |
| { |
| implWriteStringWithEncoding( aResourceID, xTextOutputStream, true ); |
| xTextOutputStream->writeString( aAssignmentStr ); |
| ::rtl::OUString aValStr = (*it).second; |
| implWriteStringWithEncoding( aValStr, xTextOutputStream, false ); |
| } |
| } |
| } |
| |
| delete pIdPtrs; |
| } |
| |
| bSuccess = true; |
| } |
| } |
| return bSuccess; |
| } |
| |
| |
| // ============================================================================= |
| // StringResourceWithStorageImpl |
| // ============================================================================= |
| |
| // component operations |
| static Sequence< ::rtl::OUString > getSupportedServiceNames_StringResourceWithStorageImpl() |
| { |
| Sequence< ::rtl::OUString > names(1); |
| names[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.resource.StringResourceWithStorage") ); |
| return names; |
| } |
| |
| static ::rtl::OUString getImplementationName_StringResourceWithStorageImpl() |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.scripting.StringResourceWithStorage") ); |
| } |
| |
| static Reference< XInterface > SAL_CALL create_StringResourceWithStorageImpl( |
| Reference< XComponentContext > const & xContext ) |
| SAL_THROW( () ) |
| { |
| return static_cast< ::cppu::OWeakObject * >( new StringResourceWithStorageImpl( xContext ) ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| StringResourceWithStorageImpl::StringResourceWithStorageImpl( const Reference< XComponentContext >& rxContext ) |
| : StringResourceWithStorageImpl_BASE( rxContext ) |
| , m_bStorageChanged( false ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| StringResourceWithStorageImpl::~StringResourceWithStorageImpl() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XServiceInfo |
| // ----------------------------------------------------------------------------- |
| |
| ::rtl::OUString StringResourceWithStorageImpl::getImplementationName( ) throw (RuntimeException) |
| { |
| return getImplementationName_StringResourceWithStorageImpl(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool StringResourceWithStorageImpl::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() ); |
| const ::rtl::OUString* pNames = aNames.getConstArray(); |
| const ::rtl::OUString* pEnd = pNames + aNames.getLength(); |
| for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames ) |
| ; |
| |
| return pNames != pEnd; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Sequence< ::rtl::OUString > StringResourceWithStorageImpl::getSupportedServiceNames( ) throw (RuntimeException) |
| { |
| return getSupportedServiceNames_StringResourceWithStorageImpl(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XInitialization |
| // ----------------------------------------------------------------------------- |
| |
| void StringResourceWithStorageImpl::initialize( const Sequence< Any >& aArguments ) |
| throw (Exception, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| if ( aArguments.getLength() != 5 ) |
| { |
| throw RuntimeException( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StringResourceWithStorageImpl::initialize: invalid number of arguments!" ) ), |
| Reference< XInterface >() ); |
| } |
| |
| bool bOk = (aArguments[0] >>= m_xStorage); |
| if( bOk && !m_xStorage.is() ) |
| bOk = false; |
| |
| if( !bOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceWithStorageImpl::initialize: invalid storage" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 ); |
| } |
| |
| implInitializeCommonParameters( aArguments ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Forwarding calls to base class |
| |
| // XModifyBroadcaster |
| void StringResourceWithStorageImpl::addModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| StringResourceImpl::addModifyListener( aListener ); |
| } |
| void StringResourceWithStorageImpl::removeModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| StringResourceImpl::removeModifyListener( aListener ); |
| } |
| |
| // XStringResourceResolver |
| ::rtl::OUString StringResourceWithStorageImpl::resolveString( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| return StringResourceImpl::resolveString( ResourceID ) ; |
| } |
| ::rtl::OUString StringResourceWithStorageImpl::resolveStringForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw ( ::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| return StringResourceImpl::resolveStringForLocale( ResourceID, locale ); |
| } |
| sal_Bool StringResourceWithStorageImpl::hasEntryForId( const ::rtl::OUString& ResourceID ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::hasEntryForId( ResourceID ) ; |
| } |
| sal_Bool StringResourceWithStorageImpl::hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID, |
| const Locale& locale ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale ); |
| } |
| Sequence< ::rtl::OUString > StringResourceWithStorageImpl::getResourceIDs( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getResourceIDs(); |
| } |
| Sequence< ::rtl::OUString > StringResourceWithStorageImpl::getResourceIDsForLocale |
| ( const Locale& locale ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| return StringResourceImpl::getResourceIDsForLocale( locale ); |
| } |
| Locale StringResourceWithStorageImpl::getCurrentLocale() |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getCurrentLocale(); |
| } |
| Locale StringResourceWithStorageImpl::getDefaultLocale( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getDefaultLocale(); |
| } |
| Sequence< Locale > StringResourceWithStorageImpl::getLocales( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getLocales(); |
| } |
| |
| // XStringResourceManager |
| sal_Bool StringResourceWithStorageImpl::isReadOnly() |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::isReadOnly(); |
| } |
| void StringResourceWithStorageImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| StringResourceImpl::setCurrentLocale( locale, FindClosestMatch ); |
| } |
| void StringResourceWithStorageImpl::setDefaultLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException,NoSupportException) |
| { |
| StringResourceImpl::setDefaultLocale( locale ); |
| } |
| void StringResourceWithStorageImpl::setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str ) |
| throw (NoSupportException, RuntimeException) |
| { |
| StringResourceImpl::setString( ResourceID, Str ); |
| } |
| void StringResourceWithStorageImpl::setStringForLocale |
| ( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str, const Locale& locale ) |
| throw (NoSupportException, RuntimeException) |
| { |
| StringResourceImpl::setStringForLocale( ResourceID, Str, locale ); |
| } |
| void StringResourceWithStorageImpl::removeId( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeId( ResourceID ); |
| } |
| void StringResourceWithStorageImpl::removeIdForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeIdForLocale( ResourceID, locale ); |
| } |
| void StringResourceWithStorageImpl::newLocale( const Locale& locale ) |
| throw (ElementExistException, IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::newLocale( locale ); |
| } |
| void StringResourceWithStorageImpl::removeLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeLocale( locale ); |
| } |
| sal_Int32 StringResourceWithStorageImpl::getUniqueNumericId( ) |
| throw (RuntimeException, NoSupportException) |
| { |
| return StringResourceImpl::getUniqueNumericId(); |
| } |
| |
| // XStringResourcePersistence |
| void StringResourceWithStorageImpl::store() |
| throw (NoSupportException, Exception, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceWithStorageImpl::store(): Read only" ); |
| |
| bool bUsedForStore = true; |
| bool bStoreAll = m_bStorageChanged; |
| m_bStorageChanged = false; |
| if( !m_bModified && !bStoreAll ) |
| return; |
| |
| implStoreAtStorage( m_aNameBase, m_aComment, m_xStorage, bUsedForStore, bStoreAll ); |
| m_bModified = false; |
| } |
| |
| sal_Bool StringResourceWithStorageImpl::isModified( ) |
| throw (RuntimeException) |
| { |
| return StringResourcePersistenceImpl::isModified(); |
| } |
| void StringResourceWithStorageImpl::setComment( const ::rtl::OUString& Comment ) |
| throw (::com::sun::star::uno::RuntimeException) |
| { |
| StringResourcePersistenceImpl::setComment( Comment ); |
| } |
| void StringResourceWithStorageImpl::storeToStorage( const Reference< XStorage >& Storage, |
| const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment ) |
| throw (Exception, RuntimeException) |
| { |
| StringResourcePersistenceImpl::storeToStorage( Storage, NameBase, Comment ); |
| } |
| void StringResourceWithStorageImpl::storeToURL( const ::rtl::OUString& URL, |
| const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment, |
| const Reference< ::com::sun::star::task::XInteractionHandler >& Handler ) |
| throw (Exception, RuntimeException) |
| { |
| StringResourcePersistenceImpl::storeToURL( URL, NameBase, Comment, Handler ); |
| } |
| Sequence< ::sal_Int8 > StringResourceWithStorageImpl::exportBinary( ) |
| throw (RuntimeException) |
| { |
| return StringResourcePersistenceImpl::exportBinary(); |
| } |
| void StringResourceWithStorageImpl::importBinary( const Sequence< ::sal_Int8 >& Data ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| StringResourcePersistenceImpl::importBinary( Data ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XStringResourceWithStorage |
| |
| void StringResourceWithStorageImpl::storeAsStorage( const Reference< XStorage >& Storage ) |
| throw (Exception, RuntimeException) |
| { |
| setStorage( Storage ); |
| store(); |
| } |
| |
| void StringResourceWithStorageImpl::setStorage( const Reference< XStorage >& Storage ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| if( !Storage.is() ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii |
| ( "StringResourceWithStorageImpl::setStorage: invalid storage" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 ); |
| } |
| |
| implLoadAllLocales(); |
| |
| m_xStorage = Storage; |
| m_bStorageChanged = true; |
| } |
| |
| |
| // ============================================================================= |
| // Private helper methods |
| // ============================================================================= |
| |
| // Scan locale properties files |
| void StringResourceWithStorageImpl::implScanLocales( void ) |
| { |
| Reference< container::XNameAccess > xNameAccess( m_xStorage, UNO_QUERY ); |
| if( xNameAccess.is() ) |
| { |
| Sequence< ::rtl::OUString > aContentSeq = xNameAccess->getElementNames(); |
| implScanLocaleNames( aContentSeq ); |
| } |
| |
| implLoadAllLocales(); |
| } |
| |
| // Loading |
| bool StringResourceWithStorageImpl::implLoadLocale( LocaleItem* pLocaleItem ) |
| { |
| bool bSuccess = false; |
| try |
| { |
| ::rtl::OUString aStreamName = implGetFileNameForLocaleItem( pLocaleItem, m_aNameBase ); |
| aStreamName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(".properties") ); |
| |
| Reference< io::XStream > xElementStream = |
| m_xStorage->openStreamElement( aStreamName, ElementModes::READ ); |
| |
| if( xElementStream.is() ) |
| { |
| Reference< io::XInputStream > xInputStream = xElementStream->getInputStream(); |
| if( xInputStream.is() ) |
| { |
| bSuccess = StringResourcePersistenceImpl::implReadPropertiesFile( pLocaleItem, xInputStream ); |
| xInputStream->closeInput(); |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| |
| return bSuccess; |
| } |
| |
| |
| // ============================================================================= |
| // StringResourceWithLocationImpl |
| // ============================================================================= |
| |
| // component operations |
| static Sequence< ::rtl::OUString > getSupportedServiceNames_StringResourceWithLocationImpl() |
| { |
| Sequence< ::rtl::OUString > names(1); |
| names[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.resource.StringResourceWithLocation") ); |
| return names; |
| } |
| |
| static ::rtl::OUString getImplementationName_StringResourceWithLocationImpl() |
| { |
| return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.scripting.StringResourceWithLocation") ); |
| } |
| |
| static Reference< XInterface > SAL_CALL create_StringResourceWithLocationImpl( |
| Reference< XComponentContext > const & xContext ) |
| SAL_THROW( () ) |
| { |
| return static_cast< ::cppu::OWeakObject * >( new StringResourceWithLocationImpl( xContext ) ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| StringResourceWithLocationImpl::StringResourceWithLocationImpl( const Reference< XComponentContext >& rxContext ) |
| : StringResourceWithLocationImpl_BASE( rxContext ) |
| , m_bLocationChanged( false ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| StringResourceWithLocationImpl::~StringResourceWithLocationImpl() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XServiceInfo |
| // ----------------------------------------------------------------------------- |
| |
| ::rtl::OUString StringResourceWithLocationImpl::getImplementationName( ) throw (RuntimeException) |
| { |
| return getImplementationName_StringResourceWithLocationImpl(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool StringResourceWithLocationImpl::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException) |
| { |
| Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() ); |
| const ::rtl::OUString* pNames = aNames.getConstArray(); |
| const ::rtl::OUString* pEnd = pNames + aNames.getLength(); |
| for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames ) |
| ; |
| |
| return pNames != pEnd; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Sequence< ::rtl::OUString > StringResourceWithLocationImpl::getSupportedServiceNames( ) throw (RuntimeException) |
| { |
| return getSupportedServiceNames_StringResourceWithLocationImpl(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XInitialization |
| // ----------------------------------------------------------------------------- |
| |
| void StringResourceWithLocationImpl::initialize( const Sequence< Any >& aArguments ) |
| throw (Exception, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| if ( aArguments.getLength() != 6 ) |
| { |
| throw RuntimeException( |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM |
| ( "XInitialization::initialize: invalid number of arguments!" ) ), |
| Reference< XInterface >() ); |
| } |
| |
| bool bOk = (aArguments[0] >>= m_aLocation); |
| sal_Int32 nLen = m_aLocation.getLength(); |
| if( bOk && nLen == 0 ) |
| { |
| bOk = false; |
| } |
| else |
| { |
| if( m_aLocation.getStr()[nLen - 1] != '/' ) |
| m_aLocation += ::rtl::OUString::createFromAscii( "/" ); |
| } |
| |
| if( !bOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "XInitialization::initialize: invalid URL" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 ); |
| } |
| |
| |
| bOk = (aArguments[5] >>= m_xInteractionHandler); |
| if( !bOk ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii( "StringResourceWithStorageImpl::initialize: invalid type" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 5 ); |
| } |
| |
| implInitializeCommonParameters( aArguments ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Forwarding calls to base class |
| |
| // XModifyBroadcaster |
| void StringResourceWithLocationImpl::addModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| StringResourceImpl::addModifyListener( aListener ); |
| } |
| void StringResourceWithLocationImpl::removeModifyListener( const Reference< XModifyListener >& aListener ) |
| throw (RuntimeException) |
| { |
| StringResourceImpl::removeModifyListener( aListener ); |
| } |
| |
| // XStringResourceResolver |
| ::rtl::OUString StringResourceWithLocationImpl::resolveString( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| return StringResourceImpl::resolveString( ResourceID ) ; |
| } |
| ::rtl::OUString StringResourceWithLocationImpl::resolveStringForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw ( ::com::sun::star::resource::MissingResourceException, RuntimeException) |
| { |
| return StringResourceImpl::resolveStringForLocale( ResourceID, locale ); |
| } |
| sal_Bool StringResourceWithLocationImpl::hasEntryForId( const ::rtl::OUString& ResourceID ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::hasEntryForId( ResourceID ) ; |
| } |
| sal_Bool StringResourceWithLocationImpl::hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID, |
| const Locale& locale ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::hasEntryForIdAndLocale( ResourceID, locale ); |
| } |
| Sequence< ::rtl::OUString > StringResourceWithLocationImpl::getResourceIDs( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getResourceIDs(); |
| } |
| Sequence< ::rtl::OUString > StringResourceWithLocationImpl::getResourceIDsForLocale |
| ( const Locale& locale ) throw (::com::sun::star::uno::RuntimeException) |
| { |
| return StringResourceImpl::getResourceIDsForLocale( locale ); |
| } |
| Locale StringResourceWithLocationImpl::getCurrentLocale() |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getCurrentLocale(); |
| } |
| Locale StringResourceWithLocationImpl::getDefaultLocale( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getDefaultLocale(); |
| } |
| Sequence< Locale > StringResourceWithLocationImpl::getLocales( ) |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::getLocales(); |
| } |
| |
| // XStringResourceManager |
| sal_Bool StringResourceWithLocationImpl::isReadOnly() |
| throw (RuntimeException) |
| { |
| return StringResourceImpl::isReadOnly(); |
| } |
| void StringResourceWithLocationImpl::setCurrentLocale( const Locale& locale, sal_Bool FindClosestMatch ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| StringResourceImpl::setCurrentLocale( locale, FindClosestMatch ); |
| } |
| void StringResourceWithLocationImpl::setDefaultLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException,NoSupportException) |
| { |
| StringResourceImpl::setDefaultLocale( locale ); |
| } |
| void StringResourceWithLocationImpl::setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str ) |
| throw (NoSupportException, RuntimeException) |
| { |
| StringResourceImpl::setString( ResourceID, Str ); |
| } |
| void StringResourceWithLocationImpl::setStringForLocale |
| ( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str, const Locale& locale ) |
| throw (NoSupportException, RuntimeException) |
| { |
| StringResourceImpl::setStringForLocale( ResourceID, Str, locale ); |
| } |
| void StringResourceWithLocationImpl::removeId( const ::rtl::OUString& ResourceID ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeId( ResourceID ); |
| } |
| void StringResourceWithLocationImpl::removeIdForLocale( const ::rtl::OUString& ResourceID, const Locale& locale ) |
| throw (::com::sun::star::resource::MissingResourceException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeIdForLocale( ResourceID, locale ); |
| } |
| void StringResourceWithLocationImpl::newLocale( const Locale& locale ) |
| throw (ElementExistException, IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::newLocale( locale ); |
| } |
| void StringResourceWithLocationImpl::removeLocale( const Locale& locale ) |
| throw (IllegalArgumentException, RuntimeException, NoSupportException) |
| { |
| StringResourceImpl::removeLocale( locale ); |
| } |
| sal_Int32 StringResourceWithLocationImpl::getUniqueNumericId( ) |
| throw (RuntimeException, NoSupportException) |
| { |
| return StringResourceImpl::getUniqueNumericId(); |
| } |
| |
| // XStringResourcePersistence |
| void StringResourceWithLocationImpl::store() |
| throw (NoSupportException, Exception, RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceWithLocationImpl::store(): Read only" ); |
| |
| bool bUsedForStore = true; |
| bool bStoreAll = m_bLocationChanged; |
| m_bLocationChanged = false; |
| if( !m_bModified && !bStoreAll ) |
| return; |
| |
| Reference< ucb::XSimpleFileAccess > xFileAccess = getFileAccess(); |
| implStoreAtLocation( m_aLocation, m_aNameBase, m_aComment, |
| xFileAccess, bUsedForStore, bStoreAll ); |
| m_bModified = false; |
| } |
| |
| sal_Bool StringResourceWithLocationImpl::isModified( ) |
| throw (RuntimeException) |
| { |
| return StringResourcePersistenceImpl::isModified(); |
| } |
| void StringResourceWithLocationImpl::setComment( const ::rtl::OUString& Comment ) |
| throw (::com::sun::star::uno::RuntimeException) |
| { |
| StringResourcePersistenceImpl::setComment( Comment ); |
| } |
| void StringResourceWithLocationImpl::storeToStorage( const Reference< XStorage >& Storage, |
| const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment ) |
| throw (Exception, RuntimeException) |
| { |
| StringResourcePersistenceImpl::storeToStorage( Storage, NameBase, Comment ); |
| } |
| void StringResourceWithLocationImpl::storeToURL( const ::rtl::OUString& URL, |
| const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment, |
| const Reference< ::com::sun::star::task::XInteractionHandler >& Handler ) |
| throw (Exception, RuntimeException) |
| { |
| StringResourcePersistenceImpl::storeToURL( URL, NameBase, Comment, Handler ); |
| } |
| Sequence< ::sal_Int8 > StringResourceWithLocationImpl::exportBinary( ) |
| throw (RuntimeException) |
| { |
| return StringResourcePersistenceImpl::exportBinary(); |
| } |
| void StringResourceWithLocationImpl::importBinary( const Sequence< ::sal_Int8 >& Data ) |
| throw (IllegalArgumentException, RuntimeException) |
| { |
| StringResourcePersistenceImpl::importBinary( Data ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // XStringResourceWithLocation |
| |
| // XStringResourceWithLocation |
| void StringResourceWithLocationImpl::storeAsURL( const ::rtl::OUString& URL ) |
| throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) |
| { |
| setURL( URL ); |
| store(); |
| } |
| |
| void StringResourceWithLocationImpl::setURL( const ::rtl::OUString& URL ) |
| throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| implCheckReadOnly( "StringResourceWithLocationImpl::setURL(): Read only" ); |
| |
| sal_Int32 nLen = URL.getLength(); |
| if( nLen == 0 ) |
| { |
| ::rtl::OUString errorMsg = ::rtl::OUString::createFromAscii |
| ( "StringResourceWithLocationImpl::setURL: invalid URL" ); |
| throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 0 ); |
| } |
| |
| implLoadAllLocales(); |
| |
| // Delete files at old location |
| bool bUsedForStore = false; |
| bool bStoreAll = false; |
| bool bKillAll = true; |
| implStoreAtLocation( m_aLocation, m_aNameBase, m_aComment, |
| getFileAccess(), bUsedForStore, bStoreAll, bKillAll ); |
| |
| m_aLocation = URL; |
| m_bLocationChanged = true; |
| } |
| |
| |
| // ============================================================================= |
| // Private helper methods |
| // ============================================================================= |
| |
| // Scan locale properties files |
| void StringResourceWithLocationImpl::implScanLocales( void ) |
| { |
| const Reference< ucb::XSimpleFileAccess > xFileAccess = getFileAccess(); |
| if( xFileAccess.is() && xFileAccess->isFolder( m_aLocation ) ) |
| { |
| Sequence< ::rtl::OUString > aContentSeq = xFileAccess->getFolderContents( m_aLocation, false ); |
| implScanLocaleNames( aContentSeq ); |
| } |
| } |
| |
| // Loading |
| bool StringResourceWithLocationImpl::implLoadLocale( LocaleItem* pLocaleItem ) |
| { |
| bool bSuccess = false; |
| |
| const Reference< ucb::XSimpleFileAccess > xFileAccess = getFileAccess(); |
| if( xFileAccess.is() ) |
| { |
| ::rtl::OUString aCompleteFileName = |
| implGetPathForLocaleItem( pLocaleItem, m_aNameBase, m_aLocation ); |
| |
| Reference< io::XInputStream > xInputStream; |
| try |
| { |
| xInputStream = xFileAccess->openFileRead( aCompleteFileName ); |
| } |
| catch( Exception& ) |
| {} |
| if( xInputStream.is() ) |
| { |
| bSuccess = StringResourcePersistenceImpl::implReadPropertiesFile( pLocaleItem, xInputStream ); |
| xInputStream->closeInput(); |
| } |
| } |
| |
| return bSuccess; |
| } |
| |
| const Reference< ucb::XSimpleFileAccess > StringResourceWithLocationImpl::getFileAccess( void ) |
| { |
| ::osl::MutexGuard aGuard( getMutex() ); |
| |
| if( !m_xSFI.is() ) |
| { |
| Reference< XMultiComponentFactory > xMCF = getMultiComponentFactory(); |
| m_xSFI = Reference< ucb::XSimpleFileAccess >( xMCF->createInstanceWithContext |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess" ), m_xContext ), UNO_QUERY ); |
| |
| if( m_xSFI.is() && m_xInteractionHandler.is() ) |
| m_xSFI->setInteractionHandler( m_xInteractionHandler ); |
| } |
| return m_xSFI; |
| } |
| |
| |
| // ============================================================================= |
| // component export operations |
| // ============================================================================= |
| |
| static struct ::cppu::ImplementationEntry s_component_entries [] = |
| { |
| { |
| create_StringResourceImpl, getImplementationName_StringResourceImpl, |
| getSupportedServiceNames_StringResourceImpl, |
| ::cppu::createSingleComponentFactory, |
| 0, 0 |
| }, |
| { |
| create_StringResourceWithLocationImpl, getImplementationName_StringResourceWithLocationImpl, |
| getSupportedServiceNames_StringResourceWithLocationImpl, |
| ::cppu::createSingleComponentFactory, |
| 0, 0 |
| }, |
| { |
| create_StringResourceWithStorageImpl, getImplementationName_StringResourceWithStorageImpl, |
| getSupportedServiceNames_StringResourceWithStorageImpl, |
| ::cppu::createSingleComponentFactory, |
| 0, 0 |
| }, |
| { 0, 0, 0, 0, 0, 0 } |
| }; |
| |
| |
| //......................................................................... |
| } // namespace dlgprov |
| //......................................................................... |
| |
| |
| // ============================================================================= |
| // component exports |
| // ============================================================================= |
| |
| extern "C" |
| { |
| void SAL_CALL component_getImplementationEnvironment( |
| const sal_Char ** ppEnvTypeName, uno_Environment ** ppEnv ) |
| { |
| (void)ppEnv; |
| |
| *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; |
| } |
| |
| void * SAL_CALL component_getFactory( |
| const sal_Char * pImplName, lang::XMultiServiceFactory * pServiceManager, |
| registry::XRegistryKey * pRegistryKey ) |
| { |
| return ::cppu::component_getFactoryHelper( |
| pImplName, pServiceManager, pRegistryKey, ::stringresource::s_component_entries ); |
| } |
| } |
