diff options
Diffstat (limited to 'framework/source/uiconfiguration/imagemanagerimpl.cxx')
| -rwxr-xr-x | framework/source/uiconfiguration/imagemanagerimpl.cxx | 1463 |
1 files changed, 1463 insertions, 0 deletions
diff --git a/framework/source/uiconfiguration/imagemanagerimpl.cxx b/framework/source/uiconfiguration/imagemanagerimpl.cxx new file mode 100755 index 000000000000..a5304a9d64df --- /dev/null +++ b/framework/source/uiconfiguration/imagemanagerimpl.cxx @@ -0,0 +1,1463 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" +#include <imagemanagerimpl.hxx> +#include <threadhelp/resetableguard.hxx> +#include <framework/imagesconfiguration.hxx> +#include <uiconfiguration/graphicnameaccess.hxx> +#include <services.h> + +#include "properties.h" + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ +#include <com/sun/star/ui/UIElementType.hpp> +#include <com/sun/star/ui/ConfigurationEvent.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/io/XStream.hpp> +#include <com/sun/star/ui/ImageType.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <vcl/svapp.hxx> +#include <rtl/ustrbuf.hxx> +#include <osl/mutex.hxx> +#include <comphelper/sequence.hxx> +#include <tools/urlobj.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <vcl/pngread.hxx> +#include <vcl/pngwrite.hxx> +#include <rtl/logfile.hxx> +#include "svtools/miscopt.hxx" + +//_________________________________________________________________________________________________________________ +// namespaces +//_________________________________________________________________________________________________________________ + +using ::rtl::OUString; +using ::com::sun::star::uno::Sequence; +using ::com::sun::star::uno::XInterface; +using ::com::sun::star::uno::Exception; +using ::com::sun::star::uno::RuntimeException; +using ::com::sun::star::uno::UNO_QUERY; +using ::com::sun::star::uno::Any; +using ::com::sun::star::uno::makeAny; +using ::com::sun::star::graphic::XGraphic; +using namespace ::com::sun::star; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::embed; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::ui; +using namespace ::cppu; + +// Image sizes for our toolbars/menus +const sal_Int32 IMAGE_SIZE_NORMAL = 16; +const sal_Int32 IMAGE_SIZE_LARGE = 26; +const sal_Int16 MAX_IMAGETYPE_VALUE = ::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST| + ::com::sun::star::ui::ImageType::SIZE_LARGE; + +static const char IMAGE_FOLDER[] = "images"; +static const char BITMAPS_FOLDER[] = "Bitmaps"; +static const char IMAGE_EXTENSION[] = ".png"; + +static const char* IMAGELIST_XML_FILE[] = +{ + "sc_imagelist.xml", + "lc_imagelist.xml", + "sch_imagelist.xml", + "lch_imagelist.xml" +}; + +static const char* BITMAP_FILE_NAMES[] = +{ + "sc_userimages.png", + "lc_userimages.png", + "sch_userimages.png", + "lch_userimages.png" +}; + +namespace framework +{ + static char ModuleImageList[] = "private:resource/images/moduleimages"; + static osl::Mutex* pImageListWrapperMutex = 0; + static GlobalImageList* pGlobalImageList = 0; + static const char* ImageType_Prefixes[ImageType_COUNT] = + { + "res/commandimagelist/sc_", + "res/commandimagelist/lc_", + "res/commandimagelist/sch_", + "res/commandimagelist/lch_" + }; + +typedef GraphicNameAccess CmdToXGraphicNameAccess; + +static osl::Mutex& getGlobalImageListMutex() +{ + if ( pImageListWrapperMutex == 0 ) + { + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + if ( pImageListWrapperMutex == 0 ) + pImageListWrapperMutex = new osl::Mutex; + } + + return *pImageListWrapperMutex; +} + +static GlobalImageList* getGlobalImageList( const uno::Reference< XMultiServiceFactory >& rServiceManager ) +{ + osl::MutexGuard guard( getGlobalImageListMutex() ); + + if ( pGlobalImageList == 0 ) + pGlobalImageList = new GlobalImageList( rServiceManager ); + + return pGlobalImageList; +} + +static rtl::OUString getCanonicalName( const rtl::OUString& rFileName ) +{ + bool bRemoveSlash( true ); + sal_Int32 nLength = rFileName.getLength(); + const sal_Unicode* pString = rFileName.getStr(); + + rtl::OUStringBuffer aBuf( nLength ); + for ( sal_Int32 i = 0; i < nLength; i++ ) + { + const sal_Unicode c = pString[i]; + switch ( c ) + { + // map forbidden characters to escape + case '/' : if ( !bRemoveSlash ) + aBuf.appendAscii( "%2f" ); + break; + case '\\': aBuf.appendAscii( "%5c" ); bRemoveSlash = false; break; + case ':' : aBuf.appendAscii( "%3a" ); bRemoveSlash = false; break; + case '*' : aBuf.appendAscii( "%2a" ); bRemoveSlash = false; break; + case '?' : aBuf.appendAscii( "%3f" ); bRemoveSlash = false; break; + case '<' : aBuf.appendAscii( "%3c" ); bRemoveSlash = false; break; + case '>' : aBuf.appendAscii( "%3e" ); bRemoveSlash = false; break; + case '|' : aBuf.appendAscii( "%7c" ); bRemoveSlash = false; break; + default: aBuf.append( c ); bRemoveSlash = false; + } + } + return aBuf.makeStringAndClear(); +} + +//_________________________________________________________________________________________________________________ + +CmdImageList::CmdImageList( const uno::Reference< XMultiServiceFactory >& rServiceManager, const rtl::OUString& aModuleIdentifier ) : + m_bVectorInit( sal_False ), + m_aModuleIdentifier( aModuleIdentifier ), + m_xServiceManager( rServiceManager ), + m_nSymbolsStyle( SvtMiscOptions().GetCurrentSymbolsStyle() ) +{ + for ( sal_Int32 n=0; n < ImageType_COUNT; n++ ) + m_pImageList[n] = 0; +} + +CmdImageList::~CmdImageList() +{ + for ( sal_Int32 n=0; n < ImageType_COUNT; n++ ) + delete m_pImageList[n]; +} + +void CmdImageList::impl_fillCommandToImageNameMap() +{ + RTL_LOGFILE_CONTEXT( aLog, "framework: CmdImageList::impl_fillCommandToImageNameMap" ); + + if ( !m_bVectorInit ) + { + const rtl::OUString aCommandImageList( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDIMAGELIST )); + Sequence< OUString > aCmdImageSeq; + uno::Reference< XNameAccess > xCmdDesc( m_xServiceManager->createInstance( + SERVICENAME_UICOMMANDDESCRIPTION ), + UNO_QUERY ); + + if ( m_aModuleIdentifier.getLength() > 0 ) + { + // If we have a module identifier - use to retrieve the command image name list from it. + // Otherwise we will use the global command image list + try + { + xCmdDesc->getByName( m_aModuleIdentifier ) >>= xCmdDesc; + if ( xCmdDesc.is() ) + xCmdDesc->getByName( aCommandImageList ) >>= aCmdImageSeq; + } + catch ( NoSuchElementException& ) + { + // Module unknown we will work with an empty command image list! + return; + } + } + + if ( xCmdDesc.is() ) + { + try + { + xCmdDesc->getByName( aCommandImageList ) >>= aCmdImageSeq; + } + catch ( NoSuchElementException& ) + { + } + catch ( WrappedTargetException& ) + { + } + } + + // We have to map commands which uses special characters like '/',':','?','\','<'.'>','|' + String aExt = String::CreateFromAscii( IMAGE_EXTENSION ); + m_aImageCommandNameVector.resize(aCmdImageSeq.getLength() ); + m_aImageNameVector.resize( aCmdImageSeq.getLength() ); + + ::std::copy( aCmdImageSeq.getConstArray(), + aCmdImageSeq.getConstArray()+aCmdImageSeq.getLength(), + m_aImageCommandNameVector.begin() ); + + // Create a image name vector that must be provided to the vcl imagelist. We also need + // a command to image name map to speed up access time for image retrieval. + OUString aUNOString( RTL_CONSTASCII_USTRINGPARAM( ".uno:" )); + String aEmptyString; + const sal_uInt32 nCount = m_aImageCommandNameVector.size(); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + OUString aCommandName( m_aImageCommandNameVector[i] ); + String aImageName; + + if ( aCommandName.indexOf( aUNOString ) != 0 ) + { + INetURLObject aUrlObject( aCommandName, INetURLObject::ENCODE_ALL ); + aImageName = aUrlObject.GetURLPath(); + aImageName = getCanonicalName( aImageName ); // convert to valid filename + } + else + { + // just remove the schema + if ( aCommandName.getLength() > 5 ) + aImageName = aCommandName.copy( 5 ); + else + aImageName = aEmptyString; + + // Search for query part. + sal_Int32 nIndex = aImageName.Search( '?' ); + if ( nIndex != STRING_NOTFOUND ) + aImageName = getCanonicalName( aImageName ); // convert to valid filename + } + // Image names are not case-dependent. Always use lower case characters to + // reflect this. + aImageName += aExt; + aImageName.ToLowerAscii(); + + m_aImageNameVector[i] = aImageName; + m_aCommandToImageNameMap.insert( CommandToImageNameMap::value_type( aCommandName, aImageName )); + } + + m_bVectorInit = sal_True; + } +} + +ImageList* CmdImageList::impl_getImageList( sal_Int16 nImageType ) +{ + SvtMiscOptions aMiscOptions; + + sal_Int16 nSymbolsStyle = aMiscOptions.GetCurrentSymbolsStyle(); + if ( nSymbolsStyle != m_nSymbolsStyle ) + { + m_nSymbolsStyle = nSymbolsStyle; + for ( sal_Int32 n=0; n < ImageType_COUNT; n++ ) + delete m_pImageList[n], m_pImageList[n] = NULL; + } + + if ( !m_pImageList[nImageType] ) + { + m_pImageList[nImageType] = new ImageList( m_aImageNameVector, + OUString::createFromAscii( ImageType_Prefixes[nImageType] ) ); + } + + return m_pImageList[nImageType]; +} + +std::vector< ::rtl::OUString >& CmdImageList::impl_getImageNameVector() +{ + return m_aImageNameVector; +} + +std::vector< rtl::OUString >& CmdImageList::impl_getImageCommandNameVector() +{ + return m_aImageCommandNameVector; +} + +Image CmdImageList::getImageFromCommandURL( sal_Int16 nImageType, const rtl::OUString& rCommandURL ) +{ + impl_fillCommandToImageNameMap(); + CommandToImageNameMap::const_iterator pIter = m_aCommandToImageNameMap.find( rCommandURL ); + if ( pIter != m_aCommandToImageNameMap.end() ) + { + ImageList* pImageList = impl_getImageList( nImageType ); + return pImageList->GetImage( pIter->second ); + } + + return Image(); +} + +bool CmdImageList::hasImage( sal_Int16 /*nImageType*/, const rtl::OUString& rCommandURL ) +{ + impl_fillCommandToImageNameMap(); + CommandToImageNameMap::const_iterator pIter = m_aCommandToImageNameMap.find( rCommandURL ); + if ( pIter != m_aCommandToImageNameMap.end() ) + return true; + else + return false; +} + +::std::vector< rtl::OUString >& CmdImageList::getImageNames() +{ + return impl_getImageNameVector(); +} + +::std::vector< rtl::OUString >& CmdImageList::getImageCommandNames() +{ + return impl_getImageCommandNameVector(); +} + +//_________________________________________________________________________________________________________________ + +GlobalImageList::GlobalImageList( const uno::Reference< XMultiServiceFactory >& rServiceManager ) : + CmdImageList( rServiceManager, rtl::OUString() ), + m_nRefCount( 0 ) +{ +} + +GlobalImageList::~GlobalImageList() +{ +} + +Image GlobalImageList::getImageFromCommandURL( sal_Int16 nImageType, const rtl::OUString& rCommandURL ) +{ + osl::MutexGuard guard( getGlobalImageListMutex() ); + return CmdImageList::getImageFromCommandURL( nImageType, rCommandURL ); +} + +bool GlobalImageList::hasImage( sal_Int16 nImageType, const rtl::OUString& rCommandURL ) +{ + osl::MutexGuard guard( getGlobalImageListMutex() ); + return CmdImageList::hasImage( nImageType, rCommandURL ); +} + +::std::vector< rtl::OUString >& GlobalImageList::getImageNames() +{ + osl::MutexGuard guard( getGlobalImageListMutex() ); + return impl_getImageNameVector(); +} + +::std::vector< rtl::OUString >& GlobalImageList::getImageCommandNames() +{ + osl::MutexGuard guard( getGlobalImageListMutex() ); + return impl_getImageCommandNameVector(); +} + +oslInterlockedCount GlobalImageList::acquire() +{ + osl_incrementInterlockedCount( &m_nRefCount ); + return m_nRefCount; +} + +oslInterlockedCount GlobalImageList::release() +{ + osl::MutexGuard guard( getGlobalImageListMutex() ); + + if ( !osl_decrementInterlockedCount( &m_nRefCount )) + { + oslInterlockedCount nCount( m_nRefCount ); + // remove global pointer as we destroy the object now + pGlobalImageList = 0; + delete this; + return nCount; + } + + return m_nRefCount; +} + +static sal_Bool implts_checkAndScaleGraphic( uno::Reference< XGraphic >& rOutGraphic, const uno::Reference< XGraphic >& rInGraphic, sal_Int16 nImageType ) +{ + static Size aNormSize( IMAGE_SIZE_NORMAL, IMAGE_SIZE_NORMAL ); + static Size aLargeSize( IMAGE_SIZE_LARGE, IMAGE_SIZE_LARGE ); + + if ( !rInGraphic.is() ) + { + rOutGraphic = Image().GetXGraphic(); + return sal_False; + } + + // Check size and scale it + Image aImage( rInGraphic ); + Size aSize = aImage.GetSizePixel(); + bool bMustScale( false ); + + if (( nImageType == ImageType_Color_Large ) || + ( nImageType == ImageType_HC_Large )) + bMustScale = ( aSize != aLargeSize ); + else + bMustScale = ( aSize != aNormSize ); + + if ( bMustScale ) + { + BitmapEx aBitmap = aImage.GetBitmapEx(); + aBitmap.Scale( aNormSize ); + aImage = Image( aBitmap ); + rOutGraphic = aImage.GetXGraphic(); + } + else + rOutGraphic = rInGraphic; + return sal_True; +} + +static sal_Int16 implts_convertImageTypeToIndex( sal_Int16 nImageType ) +{ + sal_Int16 nIndex( 0 ); + if ( nImageType & ::com::sun::star::ui::ImageType::SIZE_LARGE ) + nIndex += 1; + if ( nImageType & ::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST ) + nIndex += 2; + return nIndex; +} + +ImageList* ImageManagerImpl::implts_getUserImageList( ImageType nImageType ) +{ + ResetableGuard aGuard( m_aLock ); + if ( !m_pUserImageList[nImageType] ) + implts_loadUserImages( nImageType, m_xUserImageStorage, m_xUserBitmapsStorage ); + + return m_pUserImageList[nImageType]; +} + +void ImageManagerImpl::implts_initialize() +{ + // Initialize the top-level structures with the storage data + if ( m_xUserConfigStorage.is() ) + { + long nModes = m_bReadOnly ? ElementModes::READ : ElementModes::READWRITE; + + try + { + m_xUserImageStorage = m_xUserConfigStorage->openStorageElement( OUString::createFromAscii( IMAGE_FOLDER ), + nModes ); + if ( m_xUserImageStorage.is() ) + { + m_xUserBitmapsStorage = m_xUserImageStorage->openStorageElement( OUString::createFromAscii( BITMAPS_FOLDER ), + nModes ); + } + } + catch ( com::sun::star::container::NoSuchElementException& ) + { + } + catch ( ::com::sun::star::embed::InvalidStorageException& ) + { + } + catch ( ::com::sun::star::lang::IllegalArgumentException& ) + { + } + catch ( ::com::sun::star::io::IOException& ) + { + } + catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) + { + } + } +} + +sal_Bool ImageManagerImpl::implts_loadUserImages( + ImageType nImageType, + const uno::Reference< XStorage >& xUserImageStorage, + const uno::Reference< XStorage >& xUserBitmapsStorage ) +{ + ResetableGuard aGuard( m_aLock ); + + if ( xUserImageStorage.is() && xUserBitmapsStorage.is() ) + { + try + { + uno::Reference< XStream > xStream = xUserImageStorage->openStreamElement( rtl::OUString::createFromAscii( IMAGELIST_XML_FILE[nImageType] ), + ElementModes::READ ); + uno::Reference< XInputStream > xInputStream = xStream->getInputStream(); + + ImageListsDescriptor aUserImageListInfo; + ImagesConfiguration::LoadImages( m_xServiceManager, + xInputStream, + aUserImageListInfo ); + if (( aUserImageListInfo.pImageList != 0 ) && + ( aUserImageListInfo.pImageList->Count() > 0 )) + { + ImageListItemDescriptor* pList = aUserImageListInfo.pImageList->GetObject(0); + sal_Int32 nCount = pList->pImageItemList->Count(); + std::vector< OUString > aUserImagesVector; + aUserImagesVector.reserve(nCount); + for ( USHORT i=0; i < nCount; i++ ) + { + const ImageItemDescriptor* pItem = pList->pImageItemList->GetObject(i); + aUserImagesVector.push_back( pItem->aCommandURL ); + } + + uno::Reference< XStream > xBitmapStream = xUserBitmapsStorage->openStreamElement( + rtl::OUString::createFromAscii( BITMAP_FILE_NAMES[nImageType] ), + ElementModes::READ ); + + if ( xBitmapStream.is() ) + { + SvStream* pSvStream( 0 ); + BitmapEx aUserBitmap; + { + pSvStream = utl::UcbStreamHelper::CreateStream( xBitmapStream ); + vcl::PNGReader aPngReader( *pSvStream ); + aUserBitmap = aPngReader.Read(); + } + delete pSvStream; + + // Delete old image list and create a new one from the read bitmap + delete m_pUserImageList[nImageType]; + m_pUserImageList[nImageType] = new ImageList(); + m_pUserImageList[nImageType]->InsertFromHorizontalStrip + ( aUserBitmap, aUserImagesVector ); + return sal_True; + } + } + } + catch ( com::sun::star::container::NoSuchElementException& ) + { + } + catch ( ::com::sun::star::embed::InvalidStorageException& ) + { + } + catch ( ::com::sun::star::lang::IllegalArgumentException& ) + { + } + catch ( ::com::sun::star::io::IOException& ) + { + } + catch ( ::com::sun::star::embed::StorageWrappedTargetException& ) + { + } + } + + // Destroy old image list - create a new empty one + delete m_pUserImageList[nImageType]; + m_pUserImageList[nImageType] = new ImageList; + + return sal_True; +} + +sal_Bool ImageManagerImpl::implts_storeUserImages( + ImageType nImageType, + const uno::Reference< XStorage >& xUserImageStorage, + const uno::Reference< XStorage >& xUserBitmapsStorage ) +{ + ResetableGuard aGuard( m_aLock ); + + if ( m_bModified ) + { + ImageList* pImageList = implts_getUserImageList( nImageType ); + if ( pImageList->GetImageCount() > 0 ) + { + ImageListsDescriptor aUserImageListInfo; + aUserImageListInfo.pImageList = new ImageListDescriptor; + + ImageListItemDescriptor* pList = new ImageListItemDescriptor; + aUserImageListInfo.pImageList->Insert( pList, 0 ); + + pList->pImageItemList = new ImageItemListDescriptor; + for ( USHORT i=0; i < pImageList->GetImageCount(); i++ ) + { + ImageItemDescriptor* pItem = new ::framework::ImageItemDescriptor; + + pItem->nIndex = i; + pItem->aCommandURL = pImageList->GetImageName( i ); + pList->pImageItemList->Insert( pItem, pList->pImageItemList->Count() ); + } + + pList->aURL = String::CreateFromAscii("Bitmaps/"); + pList->aURL += String::CreateFromAscii( BITMAP_FILE_NAMES[nImageType] ); + + uno::Reference< XTransactedObject > xTransaction; + uno::Reference< XOutputStream > xOutputStream; + uno::Reference< XStream > xStream = xUserImageStorage->openStreamElement( rtl::OUString::createFromAscii( IMAGELIST_XML_FILE[nImageType] ), + ElementModes::WRITE|ElementModes::TRUNCATE ); + if ( xStream.is() ) + { + uno::Reference< XStream > xBitmapStream = + xUserBitmapsStorage->openStreamElement( rtl::OUString::createFromAscii( BITMAP_FILE_NAMES[nImageType] ), + ElementModes::WRITE|ElementModes::TRUNCATE ); + if ( xBitmapStream.is() ) + { + SvStream* pSvStream = utl::UcbStreamHelper::CreateStream( xBitmapStream ); + { + vcl::PNGWriter aPngWriter( pImageList->GetAsHorizontalStrip() ); + aPngWriter.Write( *pSvStream ); + } + delete pSvStream; + + // Commit user bitmaps storage + xTransaction = uno::Reference< XTransactedObject >( xUserBitmapsStorage, UNO_QUERY ); + if ( xTransaction.is() ) + xTransaction->commit(); + } + + xOutputStream = xStream->getOutputStream(); + if ( xOutputStream.is() ) + ImagesConfiguration::StoreImages( m_xServiceManager, xOutputStream, aUserImageListInfo ); + + // Commit user image storage + xTransaction = uno::Reference< XTransactedObject >( xUserImageStorage, UNO_QUERY ); + if ( xTransaction.is() ) + xTransaction->commit(); + } + + return sal_True; + } + else + { + // Remove the streams from the storage, if we have no data. We have to catch + // the NoSuchElementException as it can be possible that there is no stream at all! + try + { + xUserImageStorage->removeElement( rtl::OUString::createFromAscii( IMAGELIST_XML_FILE[nImageType] )); + } + catch ( ::com::sun::star::container::NoSuchElementException& ) + { + } + + try + { + xUserBitmapsStorage->removeElement( rtl::OUString::createFromAscii( BITMAP_FILE_NAMES[nImageType] )); + } + catch ( ::com::sun::star::container::NoSuchElementException& ) + { + } + + uno::Reference< XTransactedObject > xTransaction; + + // Commit user image storage + xTransaction = uno::Reference< XTransactedObject >( xUserImageStorage, UNO_QUERY ); + if ( xTransaction.is() ) + xTransaction->commit(); + + // Commit user bitmaps storage + xTransaction = uno::Reference< XTransactedObject >( xUserBitmapsStorage, UNO_QUERY ); + if ( xTransaction.is() ) + xTransaction->commit(); + + return sal_True; + } + } + + return sal_False; +} +const rtl::Reference< GlobalImageList >& ImageManagerImpl::implts_getGlobalImageList() +{ + ResetableGuard aGuard( m_aLock ); + + if ( !m_pGlobalImageList.is() ) + m_pGlobalImageList = getGlobalImageList( m_xServiceManager ); + return m_pGlobalImageList; +} + +CmdImageList* ImageManagerImpl::implts_getDefaultImageList() +{ + ResetableGuard aGuard( m_aLock ); + + if ( !m_pDefaultImageList ) + m_pDefaultImageList = new CmdImageList( m_xServiceManager, m_aModuleIdentifier ); + + return m_pDefaultImageList; +} + +ImageManagerImpl::ImageManagerImpl( const uno::Reference< XMultiServiceFactory >& xServiceManager,const uno::Reference< XInterface >& _xOwner,bool _bUseGlobal ) : + ThreadHelpBase( &Application::GetSolarMutex() ) + , m_xServiceManager( xServiceManager ) + , m_xOwner(_xOwner) + , m_pDefaultImageList( 0 ) + , m_aXMLPostfix( RTL_CONSTASCII_USTRINGPARAM( ".xml" )) + , m_aResourceString( RTL_CONSTASCII_USTRINGPARAM( ModuleImageList )) + , m_aListenerContainer( m_aLock.getShareableOslMutex() ) + , m_bUseGlobal(_bUseGlobal) + , m_bReadOnly( true ) + , m_bInitialized( false ) + , m_bModified( false ) + , m_bConfigRead( false ) + , m_bDisposed( false ) +{ + for ( sal_Int32 n=0; n < ImageType_COUNT; n++ ) + { + m_pUserImageList[n] = 0; + m_bUserImageListModified[n] = false; + } +} + +ImageManagerImpl::~ImageManagerImpl() +{ + clear(); +} + +void ImageManagerImpl::dispose() +{ + css::lang::EventObject aEvent( m_xOwner ); + m_aListenerContainer.disposeAndClear( aEvent ); + + { + ResetableGuard aGuard( m_aLock ); + m_xUserConfigStorage.clear(); + m_xUserImageStorage.clear(); + m_xUserRootCommit.clear(); + m_bConfigRead = false; + m_bModified = false; + m_bDisposed = true; + + // delete user and default image list on dispose + for ( sal_Int32 n=0; n < ImageType_COUNT; n++ ) + { + delete m_pUserImageList[n]; + m_pUserImageList[n] = 0; + } + delete m_pDefaultImageList; + m_pDefaultImageList = 0; + } + +} +void ImageManagerImpl::addEventListener( const uno::Reference< XEventListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) +{ + { + ResetableGuard aGuard( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + } + + m_aListenerContainer.addInterface( ::getCppuType( ( const uno::Reference< XEventListener >* ) NULL ), xListener ); +} + +void ImageManagerImpl::removeEventListener( const uno::Reference< XEventListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) +{ + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + m_aListenerContainer.removeInterface( ::getCppuType( ( const uno::Reference< XEventListener >* ) NULL ), xListener ); +} + +// XInitialization +void ImageManagerImpl::initialize( const Sequence< Any >& aArguments ) +{ + ResetableGuard aLock( m_aLock ); + + if ( !m_bInitialized ) + { + for ( sal_Int32 n = 0; n < aArguments.getLength(); n++ ) + { + PropertyValue aPropValue; + if ( aArguments[n] >>= aPropValue ) + { + if ( aPropValue.Name.equalsAscii( "UserConfigStorage" )) + { + aPropValue.Value >>= m_xUserConfigStorage; + } + else if ( aPropValue.Name.equalsAscii( "ModuleIdentifier" )) + { + aPropValue.Value >>= m_aModuleIdentifier; + } + else if ( aPropValue.Name.equalsAscii( "UserRootCommit" )) + { + aPropValue.Value >>= m_xUserRootCommit; + } + } + } + + if ( m_xUserConfigStorage.is() ) + { + uno::Reference< XPropertySet > xPropSet( m_xUserConfigStorage, UNO_QUERY ); + if ( xPropSet.is() ) + { + long nOpenMode = 0; + if ( xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" ))) >>= nOpenMode ) + m_bReadOnly = !( nOpenMode & ElementModes::WRITE ); + } + } + + implts_initialize(); + + m_bInitialized = true; + } +} + +// XImageManagerImpl +void ImageManagerImpl::reset() +throw (::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aLock( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + + std::vector< OUString > aUserImageNames; + + for ( sal_Int32 i = 0; i < ImageType_COUNT; i++ ) + { + aUserImageNames.clear(); + ImageList* pImageList = implts_getUserImageList( ImageType(i)); + pImageList->GetImageNames( aUserImageNames ); + + Sequence< rtl::OUString > aRemoveList( aUserImageNames.size() ); + const sal_uInt32 nCount = aUserImageNames.size(); + for ( sal_uInt32 j = 0; j < nCount; j++ ) + aRemoveList[j] = aUserImageNames[j]; + + // Remove images + removeImages( sal_Int16( i ), aRemoveList ); + m_bUserImageListModified[i] = true; + } + + m_bModified = sal_True; +} + +Sequence< ::rtl::OUString > ImageManagerImpl::getAllImageNames( ::sal_Int16 nImageType ) +throw (::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aLock( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + + ImageNameMap aImageCmdNameMap; + + sal_Int16 nIndex = implts_convertImageTypeToIndex( nImageType ); + + sal_uInt32 i( 0 ); + if ( m_bUseGlobal ) + { + rtl::Reference< GlobalImageList > rGlobalImageList = implts_getGlobalImageList(); + + const std::vector< OUString >& rGlobalImageNameVector = rGlobalImageList->getImageCommandNames(); + const sal_uInt32 nGlobalCount = rGlobalImageNameVector.size(); + for ( i = 0; i < nGlobalCount; i++ ) + aImageCmdNameMap.insert( ImageNameMap::value_type( rGlobalImageNameVector[i], sal_True )); + + const std::vector< OUString >& rModuleImageNameVector = implts_getDefaultImageList()->getImageCommandNames(); + const sal_uInt32 nModuleCount = rModuleImageNameVector.size(); + for ( i = 0; i < nModuleCount; i++ ) + aImageCmdNameMap.insert( ImageNameMap::value_type( rModuleImageNameVector[i], sal_True )); + } + + ImageList* pImageList = implts_getUserImageList( ImageType( nIndex )); + std::vector< OUString > rUserImageNames; + pImageList->GetImageNames( rUserImageNames ); + const sal_uInt32 nUserCount = rUserImageNames.size(); + for ( i = 0; i < nUserCount; i++ ) + aImageCmdNameMap.insert( ImageNameMap::value_type( rUserImageNames[i], sal_True )); + + Sequence< OUString > aImageNameSeq( aImageCmdNameMap.size() ); + ImageNameMap::const_iterator pIter; + i = 0; + for ( pIter = aImageCmdNameMap.begin(); pIter != aImageCmdNameMap.end(); pIter++ ) + aImageNameSeq[i++] = pIter->first; + + return aImageNameSeq; +} + +::sal_Bool ImageManagerImpl::hasImage( ::sal_Int16 nImageType, const ::rtl::OUString& aCommandURL ) +throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aLock( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + + if (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE )) + throw IllegalArgumentException(); + + sal_Int16 nIndex = implts_convertImageTypeToIndex( nImageType ); + if ( m_bUseGlobal && implts_getGlobalImageList()->hasImage( nIndex, aCommandURL )) + return sal_True; + else + { + if ( m_bUseGlobal && implts_getDefaultImageList()->hasImage( nIndex, aCommandURL )) + return sal_True; + else + { + // User layer + ImageList* pImageList = implts_getUserImageList( ImageType( nIndex )); + if ( pImageList ) + return ( pImageList->GetImagePos( aCommandURL ) != IMAGELIST_IMAGE_NOTFOUND ); + } + } + + return sal_False; +} + +Sequence< uno::Reference< XGraphic > > ImageManagerImpl::getImages( + ::sal_Int16 nImageType, + const Sequence< ::rtl::OUString >& aCommandURLSequence ) +throw ( ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException ) +{ + ResetableGuard aLock( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + + if (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE )) + throw IllegalArgumentException(); + + Sequence< uno::Reference< XGraphic > > aGraphSeq( aCommandURLSequence.getLength() ); + + const rtl::OUString* aStrArray = aCommandURLSequence.getConstArray(); + + sal_Int16 nIndex = implts_convertImageTypeToIndex( nImageType ); + rtl::Reference< GlobalImageList > rGlobalImageList; + CmdImageList* pDefaultImageList = NULL; + if ( m_bUseGlobal ) + { + rGlobalImageList = implts_getGlobalImageList(); + pDefaultImageList = implts_getDefaultImageList(); + } + ImageList* pUserImageList = implts_getUserImageList( ImageType( nIndex )); + + // We have to search our image list in the following order: + // 1. user image list (read/write) + // 2. module image list (read) + // 3. global image list (read) + for ( sal_Int32 n = 0; n < aCommandURLSequence.getLength(); n++ ) + { + Image aImage = pUserImageList->GetImage( aStrArray[n] ); + if ( !aImage && m_bUseGlobal ) + { + aImage = pDefaultImageList->getImageFromCommandURL( nIndex, aStrArray[n] ); + if ( !aImage ) + aImage = rGlobalImageList->getImageFromCommandURL( nIndex, aStrArray[n] ); + } + + aGraphSeq[n] = aImage.GetXGraphic(); + } + + return aGraphSeq; +} + +void ImageManagerImpl::replaceImages( + ::sal_Int16 nImageType, + const Sequence< ::rtl::OUString >& aCommandURLSequence, + const Sequence< uno::Reference< XGraphic > >& aGraphicsSequence ) +throw ( ::com::sun::star::lang::IllegalArgumentException, + ::com::sun::star::lang::IllegalAccessException, + ::com::sun::star::uno::RuntimeException) +{ + CmdToXGraphicNameAccess* pInsertedImages( 0 ); + CmdToXGraphicNameAccess* pReplacedImages( 0 ); + + { + ResetableGuard aLock( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + + if (( aCommandURLSequence.getLength() != aGraphicsSequence.getLength() ) || + (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE ))) + throw IllegalArgumentException(); + + if ( m_bReadOnly ) + throw IllegalAccessException(); + + sal_Int16 nIndex = implts_convertImageTypeToIndex( nImageType ); + ImageList* pImageList = implts_getUserImageList( ImageType( nIndex )); + + uno::Reference< XGraphic > xGraphic; + for ( sal_Int32 i = 0; i < aCommandURLSequence.getLength(); i++ ) + { + // Check size and scale. If we don't have any graphics ignore it + if ( !implts_checkAndScaleGraphic( xGraphic, aGraphicsSequence[i], nIndex )) + continue; + + USHORT nPos = pImageList->GetImagePos( aCommandURLSequence[i] ); + if ( nPos == IMAGELIST_IMAGE_NOTFOUND ) + { + pImageList->AddImage( aCommandURLSequence[i], xGraphic ); + if ( !pInsertedImages ) + pInsertedImages = new CmdToXGraphicNameAccess(); + pInsertedImages->addElement( aCommandURLSequence[i], xGraphic ); + } + else + { + pImageList->ReplaceImage( aCommandURLSequence[i], xGraphic ); + if ( !pReplacedImages ) + pReplacedImages = new CmdToXGraphicNameAccess(); + pReplacedImages->addElement( aCommandURLSequence[i], xGraphic ); + } + } + + if (( pInsertedImages != 0 ) || ( pReplacedImages != 0 )) + { + m_bModified = sal_True; + m_bUserImageListModified[nIndex] = true; + } + } + + // Notify listeners + if ( pInsertedImages != 0 ) + { + ConfigurationEvent aInsertEvent; + aInsertEvent.aInfo <<= nImageType; + aInsertEvent.Accessor <<= m_xOwner; + aInsertEvent.Source = m_xOwner; + aInsertEvent.ResourceURL = m_aResourceString; + aInsertEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pInsertedImages ), UNO_QUERY )); + implts_notifyContainerListener( aInsertEvent, NotifyOp_Insert ); + } + if ( pReplacedImages != 0 ) + { + ConfigurationEvent aReplaceEvent; + aReplaceEvent.aInfo <<= nImageType; + aReplaceEvent.Accessor <<= m_xOwner; + aReplaceEvent.Source = m_xOwner; + aReplaceEvent.ResourceURL = m_aResourceString; + aReplaceEvent.ReplacedElement = Any(); + aReplaceEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pReplacedImages ), UNO_QUERY )); + implts_notifyContainerListener( aReplaceEvent, NotifyOp_Replace ); + } +} + +void ImageManagerImpl::removeImages( ::sal_Int16 nImageType, const Sequence< ::rtl::OUString >& aCommandURLSequence ) +throw ( ::com::sun::star::lang::IllegalArgumentException, + ::com::sun::star::lang::IllegalAccessException, + ::com::sun::star::uno::RuntimeException) +{ + CmdToXGraphicNameAccess* pRemovedImages( 0 ); + CmdToXGraphicNameAccess* pReplacedImages( 0 ); + + { + ResetableGuard aLock( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + + if (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE )) + throw IllegalArgumentException(); + + if ( m_bReadOnly ) + throw IllegalAccessException(); + + sal_Int16 nIndex = implts_convertImageTypeToIndex( nImageType ); + rtl::Reference< GlobalImageList > rGlobalImageList; + CmdImageList* pDefaultImageList = NULL; + if ( m_bUseGlobal ) + { + rGlobalImageList = implts_getGlobalImageList(); + pDefaultImageList = implts_getDefaultImageList(); + } + ImageList* pImageList = implts_getUserImageList( ImageType( nIndex )); + uno::Reference< XGraphic > xEmptyGraphic( Image().GetXGraphic() ); + + for ( sal_Int32 i = 0; i < aCommandURLSequence.getLength(); i++ ) + { + USHORT nPos = pImageList->GetImagePos( aCommandURLSequence[i] ); + if ( nPos != IMAGELIST_IMAGE_NOTFOUND ) + { + Image aImage = pImageList->GetImage( nPos ); + USHORT nId = pImageList->GetImageId( nPos ); + pImageList->RemoveImage( nId ); + + if ( m_bUseGlobal ) + { + // Check, if we have a image in our module/global image list. If we find one => + // this is a replace instead of a remove operation! + Image aNewImage = pDefaultImageList->getImageFromCommandURL( nIndex, aCommandURLSequence[i] ); + if ( !aNewImage ) + aNewImage = rGlobalImageList->getImageFromCommandURL( nIndex, aCommandURLSequence[i] ); + if ( !aNewImage ) + { + if ( !pRemovedImages ) + pRemovedImages = new CmdToXGraphicNameAccess(); + pRemovedImages->addElement( aCommandURLSequence[i], xEmptyGraphic ); + } + else + { + if ( !pReplacedImages ) + pReplacedImages = new CmdToXGraphicNameAccess(); + pReplacedImages->addElement( aCommandURLSequence[i], aNewImage.GetXGraphic() ); + } + } // if ( m_bUseGlobal ) + else + { + if ( !pRemovedImages ) + pRemovedImages = new CmdToXGraphicNameAccess(); + pRemovedImages->addElement( aCommandURLSequence[i], xEmptyGraphic ); + } + } + } + + if (( pReplacedImages != 0 ) || ( pRemovedImages != 0 )) + { + m_bModified = sal_True; + m_bUserImageListModified[nIndex] = true; + } + } + + // Notify listeners + if ( pRemovedImages != 0 ) + { + ConfigurationEvent aRemoveEvent; + aRemoveEvent.aInfo = uno::makeAny( nImageType ); + aRemoveEvent.Accessor = uno::makeAny( m_xOwner ); + aRemoveEvent.Source = m_xOwner; + aRemoveEvent.ResourceURL = m_aResourceString; + aRemoveEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pRemovedImages ), UNO_QUERY )); + implts_notifyContainerListener( aRemoveEvent, NotifyOp_Remove ); + } + if ( pReplacedImages != 0 ) + { + ConfigurationEvent aReplaceEvent; + aReplaceEvent.aInfo = uno::makeAny( nImageType ); + aReplaceEvent.Accessor = uno::makeAny( m_xOwner ); + aReplaceEvent.Source = m_xOwner; + aReplaceEvent.ResourceURL = m_aResourceString; + aReplaceEvent.ReplacedElement = Any(); + aReplaceEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pReplacedImages ), UNO_QUERY )); + implts_notifyContainerListener( aReplaceEvent, NotifyOp_Replace ); + } +} + +void ImageManagerImpl::insertImages( ::sal_Int16 nImageType, const Sequence< ::rtl::OUString >& aCommandURLSequence, const Sequence< uno::Reference< XGraphic > >& aGraphicSequence ) +throw ( ::com::sun::star::container::ElementExistException, + ::com::sun::star::lang::IllegalArgumentException, + ::com::sun::star::lang::IllegalAccessException, + ::com::sun::star::uno::RuntimeException) +{ + replaceImages(nImageType,aCommandURLSequence,aGraphicSequence); +} + + +// XUIConfigurationPersistence +void ImageManagerImpl::reload() +throw ( ::com::sun::star::uno::Exception, + ::com::sun::star::uno::RuntimeException ) +{ + ResetableGuard aGuard( m_aLock ); + + if ( m_bDisposed ) + throw DisposedException(); + + CommandMap aOldUserCmdImageSet; + std::vector< rtl::OUString > aNewUserCmdImageSet; + + if ( m_bModified ) + { + for ( sal_Int16 i = 0; i < sal_Int16( ImageType_COUNT ); i++ ) + { + if ( !m_bDisposed && m_bUserImageListModified[i] ) + { + std::vector< rtl::OUString > aOldUserCmdImageVector; + ImageList* pImageList = implts_getUserImageList( (ImageType)i ); + pImageList->GetImageNames( aOldUserCmdImageVector ); + + // Fill hash map to speed up search afterwards + sal_uInt32 j( 0 ); + const sal_uInt32 nOldCount = aOldUserCmdImageVector.size(); + for ( j = 0; j < nOldCount; j++ ) + aOldUserCmdImageSet.insert( CommandMap::value_type( aOldUserCmdImageVector[j], false )); + + // Attention: This can make the old image list pointer invalid! + implts_loadUserImages( (ImageType)i, m_xUserImageStorage, m_xUserBitmapsStorage ); + pImageList = implts_getUserImageList( (ImageType)i ); + pImageList->GetImageNames( aNewUserCmdImageSet ); + + CmdToXGraphicNameAccess* pInsertedImages( 0 ); + CmdToXGraphicNameAccess* pReplacedImages( 0 ); + CmdToXGraphicNameAccess* pRemovedImages( 0 ); + + const sal_uInt32 nNewCount = aNewUserCmdImageSet.size(); + for ( j = 0; j < nNewCount; j++ ) + { + CommandMap::iterator pIter = aOldUserCmdImageSet.find( aNewUserCmdImageSet[j] ); + if ( pIter != aOldUserCmdImageSet.end() ) + { + pIter->second = true; // mark entry as replaced + if ( !pReplacedImages ) + pReplacedImages = new CmdToXGraphicNameAccess(); + pReplacedImages->addElement( aNewUserCmdImageSet[j], + pImageList->GetImage( aNewUserCmdImageSet[j] ).GetXGraphic() ); + } + else + { + if ( !pInsertedImages ) + pInsertedImages = new CmdToXGraphicNameAccess(); + pInsertedImages->addElement( aNewUserCmdImageSet[j], + pImageList->GetImage( aNewUserCmdImageSet[j] ).GetXGraphic() ); + } + } + + // Search map for unmarked entries => they have been removed from the user list + // through this reload operation. + // We have to search the module and global image list! + rtl::Reference< GlobalImageList > rGlobalImageList; + CmdImageList* pDefaultImageList = NULL; + if ( m_bUseGlobal ) + { + rGlobalImageList = implts_getGlobalImageList(); + pDefaultImageList = implts_getDefaultImageList(); + } + uno::Reference< XGraphic > xEmptyGraphic( Image().GetXGraphic() ); + CommandMap::const_iterator pIter = aOldUserCmdImageSet.begin(); + while ( pIter != aOldUserCmdImageSet.end() ) + { + if ( !pIter->second ) + { + if ( m_bUseGlobal ) + { + Image aImage = pDefaultImageList->getImageFromCommandURL( i, pIter->first ); + if ( !aImage ) + aImage = rGlobalImageList->getImageFromCommandURL( i, pIter->first ); + + if ( !aImage ) + { + // No image in the module/global image list => remove user image + if ( !pRemovedImages ) + pRemovedImages = new CmdToXGraphicNameAccess(); + pRemovedImages->addElement( pIter->first, xEmptyGraphic ); + } + else + { + // Image has been found in the module/global image list => replace user image + if ( !pReplacedImages ) + pReplacedImages = new CmdToXGraphicNameAccess(); + pReplacedImages->addElement( pIter->first, aImage.GetXGraphic() ); + } + } // if ( m_bUseGlobal ) + else + { + // No image in the user image list => remove user image + if ( !pRemovedImages ) + pRemovedImages = new CmdToXGraphicNameAccess(); + pRemovedImages->addElement( pIter->first, xEmptyGraphic ); + } + } + ++pIter; + } + + aGuard.unlock(); + + // Now notify our listeners. Unlock mutex to prevent deadlocks + if ( pInsertedImages != 0 ) + { + ConfigurationEvent aInsertEvent; + aInsertEvent.aInfo = uno::makeAny( i ); + aInsertEvent.Accessor = uno::makeAny( m_xOwner ); + aInsertEvent.Source = m_xOwner; + aInsertEvent.ResourceURL = m_aResourceString; + aInsertEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pInsertedImages ), UNO_QUERY )); + implts_notifyContainerListener( aInsertEvent, NotifyOp_Insert ); + } + if ( pReplacedImages != 0 ) + { + ConfigurationEvent aReplaceEvent; + aReplaceEvent.aInfo = uno::makeAny( i ); + aReplaceEvent.Accessor = uno::makeAny( m_xOwner ); + aReplaceEvent.Source = m_xOwner; + aReplaceEvent.ResourceURL = m_aResourceString; + aReplaceEvent.ReplacedElement = Any(); + aReplaceEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pReplacedImages ), UNO_QUERY )); + implts_notifyContainerListener( aReplaceEvent, NotifyOp_Replace ); + } + if ( pRemovedImages != 0 ) + { + ConfigurationEvent aRemoveEvent; + aRemoveEvent.aInfo = uno::makeAny( i ); + aRemoveEvent.Accessor = uno::makeAny( m_xOwner ); + aRemoveEvent.Source = m_xOwner; + aRemoveEvent.ResourceURL = m_aResourceString; + aRemoveEvent.Element = uno::makeAny( uno::Reference< XNameAccess >( + static_cast< OWeakObject *>( pRemovedImages ), UNO_QUERY )); + implts_notifyContainerListener( aRemoveEvent, NotifyOp_Remove ); + } + + aGuard.lock(); + } + } + } +} + +void ImageManagerImpl::store() +throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aGuard( m_aLock ); + + if ( m_bDisposed ) + throw DisposedException(); + + if ( m_bModified ) + { + sal_Bool bWritten( sal_False ); + for ( sal_Int32 i = 0; i < ImageType_COUNT; i++ ) + { + sal_Bool bSuccess = implts_storeUserImages( ImageType(i), m_xUserImageStorage, m_xUserBitmapsStorage ); + if ( bSuccess ) + bWritten = sal_True; + m_bUserImageListModified[i] = false; + } + + if ( bWritten && + m_xUserConfigStorage.is() ) + { + uno::Reference< XTransactedObject > xUserConfigStorageCommit( m_xUserConfigStorage, UNO_QUERY ); + if ( xUserConfigStorageCommit.is() ) + xUserConfigStorageCommit->commit(); + if ( m_xUserRootCommit.is() ) + m_xUserRootCommit->commit(); + } + + m_bModified = sal_False; + } +} + +void ImageManagerImpl::storeToStorage( const uno::Reference< XStorage >& Storage ) +throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aGuard( m_aLock ); + + if ( m_bDisposed ) + throw DisposedException(); + + if ( m_bModified && Storage.is() ) + { + long nModes = ElementModes::READWRITE; + + uno::Reference< XStorage > xUserImageStorage = Storage->openStorageElement( OUString::createFromAscii( IMAGE_FOLDER ), + nModes ); + if ( xUserImageStorage.is() ) + { + uno::Reference< XStorage > xUserBitmapsStorage = xUserImageStorage->openStorageElement( OUString::createFromAscii( BITMAPS_FOLDER ), + nModes ); + for ( sal_Int32 i = 0; i < ImageType_COUNT; i++ ) + { + implts_getUserImageList( (ImageType)i ); + implts_storeUserImages( (ImageType)i, xUserImageStorage, xUserBitmapsStorage ); + } + + uno::Reference< XTransactedObject > xTransaction( Storage, UNO_QUERY ); + if ( xTransaction.is() ) + xTransaction->commit(); + } + } +} + +sal_Bool ImageManagerImpl::isModified() +throw (::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aGuard( m_aLock ); + return m_bModified; +} + +sal_Bool ImageManagerImpl::isReadOnly() throw (::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aGuard( m_aLock ); + return m_bReadOnly; +} +// XUIConfiguration +void ImageManagerImpl::addConfigurationListener( const uno::Reference< ::com::sun::star::ui::XUIConfigurationListener >& xListener ) +throw (::com::sun::star::uno::RuntimeException) +{ + { + ResetableGuard aGuard( m_aLock ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( m_bDisposed ) + throw DisposedException(); + } + + m_aListenerContainer.addInterface( ::getCppuType( ( const uno::Reference< XUIConfigurationListener >* ) NULL ), xListener ); +} + +void ImageManagerImpl::removeConfigurationListener( const uno::Reference< ::com::sun::star::ui::XUIConfigurationListener >& xListener ) +throw (::com::sun::star::uno::RuntimeException) +{ + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + m_aListenerContainer.removeInterface( ::getCppuType( ( const uno::Reference< XUIConfigurationListener >* ) NULL ), xListener ); +} + + +void ImageManagerImpl::implts_notifyContainerListener( const ConfigurationEvent& aEvent, NotifyOp eOp ) +{ + ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( + ::getCppuType( ( const css::uno::Reference< ::com::sun::star::ui::XUIConfigurationListener >*) NULL ) ); + if ( pContainer != NULL ) + { + ::cppu::OInterfaceIteratorHelper pIterator( *pContainer ); + while ( pIterator.hasMoreElements() ) + { + try + { + switch ( eOp ) + { + case NotifyOp_Replace: + ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementReplaced( aEvent ); + break; + case NotifyOp_Insert: + ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementInserted( aEvent ); + break; + case NotifyOp_Remove: + ((::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementRemoved( aEvent ); + break; + } + } + catch( css::uno::RuntimeException& ) + { + pIterator.remove(); + } + } + } +} +void ImageManagerImpl::clear() +{ + ResetableGuard aGuard( m_aLock ); + for ( sal_Int32 n = 0; n < ImageType_COUNT; n++ ) + { + delete m_pUserImageList[n]; + m_pUserImageList[n] = 0; + } +} +} // namespace framework |