| /************************************************************** |
| * |
| * 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_framework.hxx" |
| |
| #include <imagemanagerimpl.hxx> |
| #include <threadhelp/resetableguard.hxx> |
| #include <xml/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 ( sal_uInt16 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 ( sal_uInt16 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; |
| |
| sal_uInt16 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++ ) |
| { |
| sal_uInt16 nPos = pImageList->GetImagePos( aCommandURLSequence[i] ); |
| if ( nPos != IMAGELIST_IMAGE_NOTFOUND ) |
| { |
| Image aImage = pImageList->GetImage( nPos ); |
| sal_uInt16 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 |
