INTEGRATION: CWS docking1 (1.1.2); FILE ADDED

2004/06/28 18:26:36 cd 1.1.2.9: #i30169# Wrong order of image stream names
2004/06/23 09:27:28 cd 1.1.2.8: #i30169# Provide command names instead of image names for getAllImageNames()
2004/06/21 13:33:27 cd 1.1.2.7: #i30169# Solved build problems with Solaris compiler
2004/06/20 19:56:39 cd 1.1.2.6: #i30169# Added files for image manager
2004/06/18 13:04:01 ssa 1.1.2.5: #i30169# correct res path
2004/06/17 20:46:20 cd 1.1.2.4: #i30169# Added scaling for images with the wrong size
2004/06/17 06:59:59 cd 1.1.2.3: #i30169# Fixed some problems with gcc compiler
2004/06/17 06:39:43 cd 1.1.2.2: #i30169# First implementation of an UNO based module image manager
2004/06/16 13:39:06 cd 1.1.2.1: #i30169# First implementation of an UNO based module image manager

1 files changed, 1518 insertions, 0 deletions

diff --git a/framework/source/uiconfiguration/moduleimagemanager.cxx b/framework/source/uiconfiguration/moduleimagemanager.cxx
new file mode 100644
index 0000000000..edb2233e35
--- /dev/null
+++ b/framework/source/uiconfiguration/moduleimagemanager.cxx
@@ -0,0 +1,1518 @@
+/*************************************************************************
+ *
+ *  $RCSfile: moduleimagemanager.cxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: obo $ $Date: 2004-07-06 16:59:05 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library 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 for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (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.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#ifndef __FRAMEWORK_UICONFIGURATION_MODULEIMAGEMANAGER_HXX_
+#include <uiconfiguration/moduleimagemanager.hxx>
+#endif
+
+#ifndef __FRAMEWORK_THREADHELP_RESETABLEGUARD_HXX_
+#include <threadhelp/resetableguard.hxx>
+#endif
+
+#ifndef __FRAMEWORK_XML_IMAGESCONFIGURATION_HXX_
+#include <xml/imagesconfiguration.hxx>
+#endif
+
+#ifndef __FRAMEWORK_UICONFIGURATION_GRAPHICNAMEACCESS_HXX_
+#include <uiconfiguration/graphicnameaccess.hxx>
+#endif
+
+#ifndef __FRAMEWORK_SERVICES_H_
+#include <services.h>
+#endif
+
+#include "properties.h"
+
+//_________________________________________________________________________________________________________________
+//	interface includes
+//_________________________________________________________________________________________________________________
+
+#ifndef _DRAFTS_COM_SUN_STAR_UI_UIELEMENTTYPE_HPP_
+#include <drafts/com/sun/star/ui/UIElementType.hpp>
+#endif
+
+#ifndef _DRAFTS_COM_SUN_STAR_UI_CONFIGURATIONEVENT_HPP_
+#include <drafts/com/sun/star/ui/ConfigurationEvent.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
+#include <com/sun/star/lang/DisposedException.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_
+#include <com/sun/star/beans/XPropertySet.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
+#include <com/sun/star/beans/PropertyValue.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_EMBED_ELEMENTMODES_HPP_
+#include <com/sun/star/embed/ElementModes.hpp>
+#endif
+
+#ifndef _COM_SUN_STAR_IO_XSTREAM_HPP_
+#include <com/sun/star/io/XStream.hpp>
+#endif
+
+#ifndef _DRAFTS_COM_SUN_STAR_UI_IMAGETYPE_HPP_
+#include <drafts/com/sun/star/ui/ImageType.hpp>
+#endif
+
+//_________________________________________________________________________________________________________________
+//	other includes
+//_________________________________________________________________________________________________________________
+
+#include <vcl/svapp.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/mutex.hxx>
+#include <comphelper/sequence.hxx>
+#include <tools/urlobj.hxx>
+#ifndef _UNTOOLS_UCBSTREAMHELPER_HXX
+#include <unotools/ucbstreamhelper.hxx>
+#endif
+#ifndef _SV_PNGREAD_HXX
+#include <vcl/pngread.hxx>
+#endif
+#ifndef _SV_PNGWRITE_HXX
+#include <vcl/pngwrite.hxx>
+#endif
+ 
+//_________________________________________________________________________________________________________________
+//	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 ::drafts::com::sun::star::ui;
+
+// 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       = ::drafts::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST|
+                                            ::drafts::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 osl::Mutex*          pImageListWrapperMutex = 0;
+static GlobalImageList*     pGlobalImageList = 0;
+static char* ImageType_Prefixes[ImageType_COUNT] = 
+{ 
+    "res/commandimagelist/sc_", 
+    "res/commandimagelist/lc_", 
+    "res/commandimagelist/sch_", 
+    "res/commandimagelist/lch_" 
+};
+static char ModuleImageList[] = "private:resource/images/moduleimages"; 
+
+typedef GraphicNameAccess CmdToXGraphicNameAccess;
+
+static osl::Mutex& getGlobalImageListMutex()
+{
+    if ( pImageListWrapperMutex == 0 )
+    {
+        osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
+        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;
+}
+
+//_________________________________________________________________________________________________________________
+
+CmdImageList::CmdImageList( const uno::Reference< XMultiServiceFactory >& rServiceManager, const rtl::OUString& aModuleIdentifier ) :
+    m_aModuleIdentifier( aModuleIdentifier ),
+    m_bVectorInit( sal_False ),
+    m_xServiceManager( rServiceManager )
+{
+    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()
+{
+    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.
+        for ( sal_uInt32 i = 0; i < m_aImageCommandNameVector.size(); i++ )
+        {
+            INetURLObject aURLObj( m_aImageCommandNameVector[i] );
+            m_aImageNameVector[i] = ( aURLObj.GetURLPath().ToLowerAscii() += aExt );
+            m_aCommandToImageNameMap.insert( CommandToImageNameMap::value_type( m_aImageCommandNameVector[i], 
+                                                                                m_aImageNameVector[i] ));
+        }
+        
+        m_bVectorInit = sal_True;
+    }
+}
+
+ImageList* CmdImageList::impl_getImageList( sal_Int16 nImageType )
+{
+    if ( !m_pImageList[nImageType] )
+    {
+        impl_fillCommandToImageNameMap();
+        m_pImageList[nImageType] = new ImageList( m_aImageNameVector, 
+                                                  OUString::createFromAscii( ImageType_Prefixes[nImageType] ), 
+                                                  NULL );
+    }
+
+    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 )
+{
+    ImageList* pImageList = impl_getImageList( nImageType );
+    if ( pImageList )
+    {
+        CommandToImageNameMap::const_iterator pIter = m_aCommandToImageNameMap.find( rCommandURL );
+        if ( pIter != m_aCommandToImageNameMap.end() )
+            return pImageList->GetImage( pIter->second );
+    }
+
+    return Image();
+}
+
+bool CmdImageList::hasImage( sal_Int16 nImageType, const rtl::OUString& rCommandURL )
+{
+    ImageList* pImageList = impl_getImageList( nImageType );
+    if ( pImageList )
+    {
+        CommandToImageNameMap::const_iterator pIter = m_aCommandToImageNameMap.find( rCommandURL );
+        if ( pIter != m_aCommandToImageNameMap.end() )
+            return ( pImageList->GetImagePos( pIter->second ) != IMAGELIST_IMAGE_NOTFOUND );
+    }
+
+    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;
+}
+
+//*****************************************************************************************************************
+//	XInterface, XTypeProvider, XServiceInfo
+//*****************************************************************************************************************
+DEFINE_XINTERFACE_6                    (    ModuleImageManager                                                    ,
+                                            OWeakObject                                                                     ,
+                                            DIRECT_INTERFACE( css::lang::XTypeProvider                                      ),
+                                            DIRECT_INTERFACE( css::lang::XComponent                                         ),
+                                            DIRECT_INTERFACE( css::lang::XInitialization                                    ),
+                                            DIRECT_INTERFACE( drafts::com::sun::star::ui::XImageManager                     ),
+                                            DIRECT_INTERFACE( drafts::com::sun::star::ui::XUIConfiguration                  ),
+                                            DIRECT_INTERFACE( drafts::com::sun::star::ui::XUIConfigurationPersistence       )
+                                        )
+
+DEFINE_XTYPEPROVIDER_6                  (   ModuleImageManager                                          ,
+                                            css::lang::XTypeProvider			                        ,
+                                            css::lang::XComponent                                       ,
+                                            css::lang::XInitialization                                  ,
+                                            drafts::com::sun::star::ui::XImageManager                   ,
+                                            drafts::com::sun::star::ui::XUIConfiguration                ,
+                                            drafts::com::sun::star::ui::XUIConfigurationPersistence     
+                                        )
+
+static OUString RetrieveNameFromResourceURL( const rtl::OUString& aResourceURL )
+{
+    return OUString();
+}
+
+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 & ::drafts::com::sun::star::ui::ImageType::SIZE_LARGE )
+        nIndex += 1;
+    if ( nImageType & ::drafts::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST )
+        nIndex += 2;
+    return nIndex;
+}
+
+static sal_Int16 implts_convertIndexToImageType( sal_Int16 nIndex )
+{
+    sal_Int16 nImageType = ::drafts::com::sun::star::ui::ImageType::SIZE_DEFAULT;
+    switch ( nImageType )
+    {
+        case 0: break;
+        case 1: nImageType |= ::drafts::com::sun::star::ui::ImageType::SIZE_LARGE; break;
+        case 2: nImageType |= ::drafts::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST; break;
+        case 3: nImageType |= ::drafts::com::sun::star::ui::ImageType::COLOR_HIGHCONTRAST|
+                              ::drafts::com::sun::star::ui::ImageType::SIZE_LARGE; break;
+    }
+    return nImageType;
+}
+
+const rtl::Reference< GlobalImageList >& ModuleImageManager::implts_getGlobalImageList()
+{
+    ResetableGuard aGuard( m_aLock );
+
+    if ( !m_pGlobalImageList.is() )
+        m_pGlobalImageList = getGlobalImageList( m_xServiceManager ); 
+    return m_pGlobalImageList;
+}
+
+CmdImageList* ModuleImageManager::implts_getDefaultImageList()
+{
+    ResetableGuard aGuard( m_aLock );
+    
+    if ( !m_pDefaultImageList )
+        m_pDefaultImageList = new CmdImageList( m_xServiceManager, m_aModuleIdentifier );
+
+    return m_pDefaultImageList;
+}
+
+ImageList* ModuleImageManager::implts_getUserImageList( ImageType nImageType )
+{
+    ResetableGuard aGuard( m_aLock );
+    if ( !m_pUserImageList[nImageType] )
+        implts_loadUserImages( nImageType, m_xUserImageStorage, m_xUserBitmapsStorage );
+
+    return m_pUserImageList[nImageType];
+}
+
+void ModuleImageManager::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 ModuleImageManager::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;
+            sal_Bool bResult = 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;
+                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 = utl::UcbStreamHelper::CreateStream( xBitmapStream );
+                    vcl::PNGReader aPngReader( *pSvStream );
+                    BitmapEx 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( 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 ModuleImageManager::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( *pSvStream );
+                    aPngWriter.Write( pImageList->GetBitmapEx() );
+                    delete pSvStream;
+
+                    // Commit user bitmaps storage
+                    xTransaction = uno::Reference< XTransactedObject >( xUserBitmapsStorage, UNO_QUERY );
+                    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 );
+                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& )
+            {
+            }
+        
+            return sal_True;
+        }
+    }
+
+    return sal_False;
+}
+
+ModuleImageManager::ModuleImageManager( uno::Reference< XMultiServiceFactory > xServiceManager ) :
+    ThreadHelpBase( &Application::GetSolarMutex() )
+    , m_aListenerContainer( m_aLock.getShareableOslMutex() )
+    , m_bReadOnly( true )
+    , m_bModified( false )
+    , m_xUserImageStorage( 0 )
+    , m_xUserConfigStorage( 0 )
+    , m_bConfigRead( false )
+    , m_bDisposed( false )
+    , m_bInitialized( false )
+    , m_xServiceManager( xServiceManager )
+    , m_aXMLPostfix( RTL_CONSTASCII_USTRINGPARAM( ".xml" ))
+    , m_aResourceString( RTL_CONSTASCII_USTRINGPARAM( ModuleImageList ))
+    , m_pDefaultImageList( 0 )
+{
+    for ( sal_Int32 n=0; n < ImageType_COUNT; n++ )
+    {
+        m_pUserImageList[n] = 0;
+        m_bUserImageListModified[n] = false;
+    }
+}
+
+ModuleImageManager::~ModuleImageManager()
+{
+}
+
+// XComponent
+void SAL_CALL ModuleImageManager::dispose() throw (::com::sun::star::uno::RuntimeException)
+{
+    uno::Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
+
+    css::lang::EventObject aEvent( xThis );
+    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;
+    }
+}
+
+void SAL_CALL ModuleImageManager::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 SAL_CALL ModuleImageManager::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 SAL_CALL ModuleImageManager::initialize( const Sequence< Any >& aArguments ) throw ( Exception, RuntimeException )
+{
+    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;
+                Any a = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OpenMode" )));
+                if ( a >>= nOpenMode )
+                    m_bReadOnly = !( nOpenMode & ElementModes::WRITE );
+            }
+        }
+    
+        implts_initialize();
+
+        m_bInitialized = true;    
+    }
+}
+
+// XImageManager
+void SAL_CALL ModuleImageManager::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() );
+        for ( sal_uInt32 j = 0; j < aUserImageNames.size(); j++ )
+            aRemoveList[j] = aUserImageNames[j];
+
+        // Remove images
+        removeImages( sal_Int16( i ), aRemoveList );
+        m_bUserImageListModified[i] = true;
+    }
+
+    m_bModified = sal_True;
+}
+
+Sequence< ::rtl::OUString > SAL_CALL ModuleImageManager::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 );
+    rtl::Reference< GlobalImageList > rGlobalImageList = implts_getGlobalImageList();
+
+    sal_uInt32 i( 0 );
+    const std::vector< OUString >& rGlobalImageNameVector = rGlobalImageList->getImageCommandNames();
+    for ( i = 0; i < rGlobalImageNameVector.size(); i++ )
+        aImageCmdNameMap.insert( ImageNameMap::value_type( rGlobalImageNameVector[i], sal_True ));
+
+    const std::vector< OUString >& rModuleImageNameVector = implts_getDefaultImageList()->getImageCommandNames();
+    for ( i = 0; i < rModuleImageNameVector.size(); i++ )
+        aImageCmdNameMap.insert( ImageNameMap::value_type( rModuleImageNameVector[i], sal_True ));
+
+    ImageList* pImageList = implts_getUserImageList( ImageType( nIndex ));
+    std::vector< OUString > rUserImageNames;
+    pImageList->GetImageNames( rUserImageNames );
+    for ( i = 0; i < rUserImageNames.size(); 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 SAL_CALL ModuleImageManager::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 ( implts_getGlobalImageList()->hasImage( nIndex, aCommandURL ))
+        return sal_True;
+    else 
+    {
+        if ( 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 > > SAL_CALL ModuleImageManager::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  = implts_getGlobalImageList();
+    CmdImageList*                     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 )
+        {
+            aImage = pDefaultImageList->getImageFromCommandURL( nIndex, aStrArray[n] );
+            if ( !aImage )
+                aImage = rGlobalImageList->getImageFromCommandURL( nIndex, aStrArray[n] );
+        }
+            
+        aGraphSeq[n] = aImage.GetXGraphic();
+    }
+
+    return aGraphSeq;
+}
+
+void SAL_CALL ModuleImageManager::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
+    uno::Reference< XImageManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+    uno::Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+    if ( pInsertedImages != 0 )
+    {
+        ConfigurationEvent aInsertEvent;
+        aInsertEvent.aInfo           = uno::makeAny( nImageType );
+        aInsertEvent.Accessor        = uno::makeAny( xThis );
+        aInsertEvent.Source          = xIfac;
+        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( nImageType );
+        aReplaceEvent.Accessor        = uno::makeAny( xThis );
+        aReplaceEvent.Source          = xIfac;
+        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 SAL_CALL ModuleImageManager::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  = implts_getGlobalImageList();
+        CmdImageList*                     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 );
+
+                // 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 (( pReplacedImages != 0 ) || ( pRemovedImages != 0 ))
+        {
+            m_bModified = sal_True;
+            m_bUserImageListModified[nIndex] = true;
+        }
+    }
+
+    // Notify listeners
+    uno::Reference< XImageManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+    uno::Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+    if ( pRemovedImages != 0 )
+    {
+        ConfigurationEvent aRemoveEvent;
+        aRemoveEvent.aInfo           = uno::makeAny( nImageType );
+        aRemoveEvent.Accessor        = uno::makeAny( xThis );
+        aRemoveEvent.Source          = xIfac;
+        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( xThis );
+        aReplaceEvent.Source          = xIfac;
+        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 SAL_CALL ModuleImageManager::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)
+{
+    CmdToXGraphicNameAccess* pInsertedImages( 0 );
+    CmdToXGraphicNameAccess* pReplacedImages( 0 );
+
+    {
+        ResetableGuard aLock( m_aLock );
+            
+        /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+        if ( m_bDisposed )
+            throw DisposedException();
+
+        if (( aCommandURLSequence.getLength() != aGraphicSequence.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++ )
+        {
+            if ( !implts_checkAndScaleGraphic( xGraphic, aGraphicSequence[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
+    uno::Reference< XImageManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+    uno::Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+    if ( pInsertedImages != 0 )
+    {
+        ConfigurationEvent aInsertEvent;
+        aInsertEvent.aInfo           = uno::makeAny( nImageType );
+        aInsertEvent.Accessor        = uno::makeAny( xThis );
+        aInsertEvent.Source          = xIfac;
+        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( nImageType );
+        aReplaceEvent.Accessor        = uno::makeAny( xThis );
+        aReplaceEvent.Source          = xIfac;
+        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 );
+    }
+}
+
+// XUIConfiguration
+void SAL_CALL ModuleImageManager::addConfigurationListener( const uno::Reference< ::drafts::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 SAL_CALL ModuleImageManager::removeConfigurationListener( const uno::Reference< ::drafts::com::sun::star::ui::XUIConfigurationListener >& xListener ) 
+throw (::com::sun::star::uno::RuntimeException)
+{
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    m_aListenerContainer.removeInterface( ::getCppuType( ( const uno::Reference< XUIConfigurationListener >* ) NULL ), xListener );
+}
+
+// XUIConfigurationPersistence
+void SAL_CALL ModuleImageManager::reload() 
+throw ( ::com::sun::star::uno::Exception, 
+        ::com::sun::star::uno::RuntimeException )
+{
+    ResetableGuard aGuard( m_aLock );
+
+    uno::Reference< uno::XInterface > xThis( static_cast< OWeakObject* >( this ));
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    CommandMap                   aOldUserCmdImageSet;   
+    std::vector< rtl::OUString > aNewUserCmdImageSet;
+    
+    if ( m_bModified )
+    {
+        uno::Reference< XImageManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+        uno::Reference< XInterface > xIfac( xThis, UNO_QUERY );
+                
+        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 );
+                for ( j = 0; j < aOldUserCmdImageVector.size(); 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 );
+
+                for ( j = 0; j < aNewUserCmdImageSet.size(); 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  = implts_getGlobalImageList();
+                CmdImageList*                     pDefaultImageList = implts_getDefaultImageList();
+                uno::Reference< XGraphic >        xEmptyGraphic( Image().GetXGraphic() );
+                CommandMap::const_iterator        pIter = aOldUserCmdImageSet.begin();
+                while ( pIter != aOldUserCmdImageSet.end() )
+                {
+                    if ( !pIter->second )
+                    {
+                        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() );
+                        }
+                    }
+                    ++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( xThis );
+                    aInsertEvent.Source          = xIfac;
+                    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( xThis );
+                    aReplaceEvent.Source          = xIfac;
+                    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( xThis );
+                    aRemoveEvent.Source          = xIfac;
+                    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 SAL_CALL ModuleImageManager::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() &&  
+             m_xUserRootCommit.is() )
+        {
+            uno::Reference< XTransactedObject > xUserConfigStorageCommit( m_xUserConfigStorage, UNO_QUERY );
+            xUserConfigStorageCommit->commit();
+            m_xUserRootCommit->commit();
+        }
+
+        m_bModified = sal_False;
+    }
+}
+
+void SAL_CALL ModuleImageManager::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 );
+            xTransaction->commit();
+        }
+    }
+}
+
+sal_Bool SAL_CALL ModuleImageManager::isModified() 
+throw (::com::sun::star::uno::RuntimeException)
+{
+    ResetableGuard aGuard( m_aLock );
+    return m_bModified;
+}
+
+sal_Bool SAL_CALL ModuleImageManager::isReadOnly() throw (::com::sun::star::uno::RuntimeException)
+{
+    ResetableGuard aGuard( m_aLock );
+    
+    return m_bReadOnly;
+}
+
+void ModuleImageManager::implts_notifyContainerListener( const ConfigurationEvent& aEvent, NotifyOp eOp )
+{
+    ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( 
+                                        ::getCppuType( ( const css::uno::Reference< drafts::com::sun::star::ui::XUIConfigurationListener >*) NULL ) );
+    if ( pContainer != NULL )
+    {
+        ::cppu::OInterfaceIteratorHelper pIterator( *pContainer );
+        while ( pIterator.hasMoreElements() )
+        {
+            try
+            {
+                switch ( eOp )
+                {
+                    case NotifyOp_Replace:
+                        ((drafts::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementReplaced( aEvent );
+                        break;
+                    case NotifyOp_Insert:
+                        ((drafts::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementInserted( aEvent );
+                        break;
+                    case NotifyOp_Remove:
+                        ((drafts::com::sun::star::ui::XUIConfigurationListener*)pIterator.next())->elementRemoved( aEvent );
+                        break;
+                }
+            }
+            catch( css::uno::RuntimeException& )
+            {
+                pIterator.remove();
+            }
+        }
+    }
+}
+
+} // namespace framework