Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1211 insertions, 0 deletions

diff --git a/framework/source/uiconfiguration/imagemanagerimpl.cxx b/framework/source/uiconfiguration/imagemanagerimpl.cxx
new file mode 100644
index 000000000..297def1bb
--- /dev/null
+++ b/framework/source/uiconfiguration/imagemanagerimpl.cxx
@@ -0,0 +1,1211 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+#include "imagemanagerimpl.hxx"
+#include <xml/imagesconfiguration.hxx>
+#include <uiconfiguration/imagetype.hxx>
+#include <uiconfiguration/graphicnameaccess.hxx>
+
+#include <properties.h>
+
+#include <com/sun/star/frame/theUICommandDescription.hpp>
+#include <com/sun/star/ui/ConfigurationEvent.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/lang/IllegalAccessException.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/embed/InvalidStorageException.hpp>
+#include <com/sun/star/embed/StorageWrappedTargetException.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/ui/ImageType.hpp>
+#include <vcl/graph.hxx>
+#include <vcl/svapp.hxx>
+#include <o3tl/enumrange.hxx>
+#include <osl/mutex.hxx>
+#include <comphelper/sequence.hxx>
+#include <unotools/ucbstreamhelper.hxx>
+#include <vcl/pngread.hxx>
+#include <vcl/pngwrite.hxx>
+#include <rtl/instance.hxx>
+#include <memory>
+
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::XInterface;
+using ::com::sun::star::uno::RuntimeException;
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::uno::Any;
+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;
+
+const sal_Int16 MAX_IMAGETYPE_VALUE       = css::ui::ImageType::SIZE_32;
+
+static const char   IMAGE_FOLDER[]        = "images";
+static const char   BITMAPS_FOLDER[]      = "Bitmaps";
+
+static const o3tl::enumarray<vcl::ImageType, const char*> IMAGELIST_XML_FILE =
+{
+    "sc_imagelist.xml",
+    "lc_imagelist.xml",
+    "xc_imagelist.xml"
+};
+
+static const o3tl::enumarray<vcl::ImageType, const char*> BITMAP_FILE_NAMES =
+{
+    "sc_userimages.png",
+    "lc_userimages.png",
+    "xc_userimages.png"
+};
+
+namespace framework
+{
+
+static GlobalImageList*     pGlobalImageList = nullptr;
+
+namespace
+{
+    class theGlobalImageListMutex
+        : public rtl::Static<osl::Mutex, theGlobalImageListMutex> {};
+}
+
+static osl::Mutex& getGlobalImageListMutex()
+{
+    return theGlobalImageListMutex::get();
+}
+
+static GlobalImageList* getGlobalImageList( const uno::Reference< uno::XComponentContext >& rxContext )
+{
+    osl::MutexGuard guard( getGlobalImageListMutex() );
+
+    if ( pGlobalImageList == nullptr )
+        pGlobalImageList = new GlobalImageList( rxContext );
+
+    return pGlobalImageList;
+}
+
+CmdImageList::CmdImageList( const uno::Reference< uno::XComponentContext >& rxContext, const OUString& aModuleIdentifier ) :
+    m_bInitialized(false),
+    m_aModuleIdentifier( aModuleIdentifier ),
+    m_xContext( rxContext )
+{
+}
+
+CmdImageList::~CmdImageList()
+{
+}
+
+void CmdImageList::initialize()
+{
+    if (m_bInitialized)
+        return;
+
+    const OUString aCommandImageList(UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDIMAGELIST);
+
+    Sequence<OUString> aCommandImageSeq;
+    uno::Reference<XNameAccess> xCommandDesc = frame::theUICommandDescription::get(m_xContext);
+
+    if (!m_aModuleIdentifier.isEmpty())
+    {
+        // 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
+        {
+            xCommandDesc->getByName(m_aModuleIdentifier) >>= xCommandDesc;
+            if (xCommandDesc.is())
+                xCommandDesc->getByName(aCommandImageList) >>= aCommandImageSeq;
+        }
+        catch (const NoSuchElementException&)
+        {
+            // Module unknown we will work with an empty command image list!
+            return;
+        }
+    }
+
+    if (xCommandDesc.is())
+    {
+        try
+        {
+            xCommandDesc->getByName(aCommandImageList) >>= aCommandImageSeq;
+        }
+        catch (const NoSuchElementException&)
+        {
+        }
+        catch (const WrappedTargetException&)
+        {
+        }
+    }
+
+    m_aResolver.registerCommands(aCommandImageSeq);
+
+    m_bInitialized = true;
+}
+
+
+Image CmdImageList::getImageFromCommandURL(vcl::ImageType nImageType, const OUString& rCommandURL)
+{
+    initialize();
+    return m_aResolver.getImageFromCommandURL(nImageType, rCommandURL);
+}
+
+bool CmdImageList::hasImage(vcl::ImageType /*nImageType*/, const OUString& rCommandURL)
+{
+    initialize();
+    return m_aResolver.hasImage(rCommandURL);
+}
+
+std::vector<OUString>& CmdImageList::getImageCommandNames()
+{
+    return m_aResolver.getCommandNames();
+}
+
+GlobalImageList::GlobalImageList( const uno::Reference< uno::XComponentContext >& rxContext ) :
+    CmdImageList( rxContext, OUString() )
+{
+}
+
+GlobalImageList::~GlobalImageList()
+{
+    osl::MutexGuard guard( getGlobalImageListMutex() );
+    // remove global pointer as we destroy the object now
+    pGlobalImageList = nullptr;
+}
+
+Image GlobalImageList::getImageFromCommandURL( vcl::ImageType nImageType, const OUString& rCommandURL )
+{
+    osl::MutexGuard guard( getGlobalImageListMutex() );
+    return CmdImageList::getImageFromCommandURL( nImageType, rCommandURL );
+}
+
+bool GlobalImageList::hasImage( vcl::ImageType nImageType, const OUString& rCommandURL )
+{
+    osl::MutexGuard guard( getGlobalImageListMutex() );
+    return CmdImageList::hasImage( nImageType, rCommandURL );
+}
+
+::std::vector< OUString >& GlobalImageList::getImageCommandNames()
+{
+    osl::MutexGuard guard( getGlobalImageListMutex() );
+    return CmdImageList::getImageCommandNames();
+}
+
+static bool implts_checkAndScaleGraphic( uno::Reference< XGraphic >& rOutGraphic, const uno::Reference< XGraphic >& rInGraphic, vcl::ImageType nImageType )
+{
+    if ( !rInGraphic.is() )
+    {
+        rOutGraphic = uno::Reference<graphic::XGraphic>();
+        return false;
+    }
+
+    static const o3tl::enumarray<vcl::ImageType, Size> BITMAP_SIZE =
+    {
+        Size(16, 16), Size(24, 24), Size(32, 32)
+    };
+
+    // Check size and scale it
+    Graphic aImage(rInGraphic);
+    if (BITMAP_SIZE[nImageType] != aImage.GetSizePixel())
+    {
+        BitmapEx aBitmap = aImage.GetBitmapEx();
+        aBitmap.Scale(BITMAP_SIZE[nImageType]);
+        aImage = Graphic(aBitmap);
+        rOutGraphic = aImage.GetXGraphic();
+    }
+    else
+        rOutGraphic = rInGraphic;
+
+    return true;
+}
+
+static vcl::ImageType implts_convertImageTypeToIndex( sal_Int16 nImageType )
+{
+    if (nImageType & css::ui::ImageType::SIZE_LARGE)
+        return vcl::ImageType::Size26;
+    else if (nImageType & css::ui::ImageType::SIZE_32)
+        return vcl::ImageType::Size32;
+    else
+        return vcl::ImageType::Size16;
+}
+
+ImageList* ImageManagerImpl::implts_getUserImageList( vcl::ImageType nImageType )
+{
+    SolarMutexGuard g;
+    if ( !m_pUserImageList[nImageType] )
+        implts_loadUserImages( nImageType, m_xUserImageStorage, m_xUserBitmapsStorage );
+
+    return m_pUserImageList[nImageType].get();
+}
+
+void ImageManagerImpl::implts_initialize()
+{
+    // Initialize the top-level structures with the storage data
+    if ( !m_xUserConfigStorage.is() )
+        return;
+
+    long nModes = m_bReadOnly ? ElementModes::READ : ElementModes::READWRITE;
+
+    try
+    {
+        m_xUserImageStorage = m_xUserConfigStorage->openStorageElement( IMAGE_FOLDER,
+                                                                        nModes );
+        if ( m_xUserImageStorage.is() )
+        {
+            m_xUserBitmapsStorage = m_xUserImageStorage->openStorageElement( BITMAPS_FOLDER,
+                                                                             nModes );
+        }
+    }
+    catch ( const css::container::NoSuchElementException& )
+    {
+    }
+    catch ( const css::embed::InvalidStorageException& )
+    {
+    }
+    catch ( const css::lang::IllegalArgumentException& )
+    {
+    }
+    catch ( const css::io::IOException& )
+    {
+    }
+    catch ( const css::embed::StorageWrappedTargetException& )
+    {
+    }
+}
+
+void ImageManagerImpl::implts_loadUserImages(
+    vcl::ImageType nImageType,
+    const uno::Reference< XStorage >& xUserImageStorage,
+    const uno::Reference< XStorage >& xUserBitmapsStorage )
+{
+    SolarMutexGuard g;
+
+    if ( xUserImageStorage.is() && xUserBitmapsStorage.is() )
+    {
+        try
+        {
+            uno::Reference< XStream > xStream = xUserImageStorage->openStreamElement( OUString::createFromAscii( IMAGELIST_XML_FILE[nImageType] ),
+                                                                                      ElementModes::READ );
+            uno::Reference< XInputStream > xInputStream = xStream->getInputStream();
+
+            ImageItemDescriptorList aUserImageListInfo;
+            ImagesConfiguration::LoadImages( m_xContext,
+                                             xInputStream,
+                                             aUserImageListInfo );
+            if ( !aUserImageListInfo.empty() )
+            {
+                sal_Int32 nCount = aUserImageListInfo.size();
+                std::vector< OUString > aUserImagesVector;
+                aUserImagesVector.reserve(nCount);
+                for ( sal_Int32 i=0; i < nCount; i++ )
+                {
+                    const ImageItemDescriptor& rItem = aUserImageListInfo[i];
+                    aUserImagesVector.push_back( rItem.aCommandURL );
+                }
+
+                uno::Reference< XStream > xBitmapStream = xUserBitmapsStorage->openStreamElement(
+                                                        OUString::createFromAscii( BITMAP_FILE_NAMES[nImageType] ),
+                                                        ElementModes::READ );
+
+                if ( xBitmapStream.is() )
+                {
+                    BitmapEx aUserBitmap;
+                    {
+                        std::unique_ptr<SvStream> pSvStream(utl::UcbStreamHelper::CreateStream( xBitmapStream ));
+                        vcl::PNGReader aPngReader( *pSvStream );
+                        aUserBitmap = aPngReader.Read();
+                    }
+
+                    // Delete old image list and create a new one from the read bitmap
+                    m_pUserImageList[nImageType].reset(new ImageList());
+                    m_pUserImageList[nImageType]->InsertFromHorizontalStrip
+                        ( aUserBitmap, aUserImagesVector );
+                    return;
+                }
+            }
+        }
+        catch ( const css::container::NoSuchElementException& )
+        {
+        }
+        catch ( const css::embed::InvalidStorageException& )
+        {
+        }
+        catch ( const css::lang::IllegalArgumentException& )
+        {
+        }
+        catch ( const css::io::IOException& )
+        {
+        }
+        catch ( const css::embed::StorageWrappedTargetException& )
+        {
+        }
+    }
+
+    // Destroy old image list - create a new empty one
+    m_pUserImageList[nImageType].reset(new ImageList);
+}
+
+bool ImageManagerImpl::implts_storeUserImages(
+    vcl::ImageType nImageType,
+    const uno::Reference< XStorage >& xUserImageStorage,
+    const uno::Reference< XStorage >& xUserBitmapsStorage )
+{
+    SolarMutexGuard g;
+
+    if ( m_bModified )
+    {
+        ImageList* pImageList = implts_getUserImageList( nImageType );
+        if ( pImageList->GetImageCount() > 0 )
+        {
+            ImageItemDescriptorList aUserImageListInfo;
+
+            for ( sal_uInt16 i=0; i < pImageList->GetImageCount(); i++ )
+            {
+                ImageItemDescriptor aItem;
+                aItem.aCommandURL = pImageList->GetImageName( i );
+                aUserImageListInfo.push_back( aItem );
+            }
+
+            uno::Reference< XTransactedObject > xTransaction;
+            uno::Reference< XOutputStream >     xOutputStream;
+            uno::Reference< XStream > xStream = xUserImageStorage->openStreamElement( OUString::createFromAscii( IMAGELIST_XML_FILE[nImageType] ),
+                                                                                      ElementModes::WRITE|ElementModes::TRUNCATE );
+            if ( xStream.is() )
+            {
+                uno::Reference< XStream > xBitmapStream =
+                    xUserBitmapsStorage->openStreamElement( OUString::createFromAscii( BITMAP_FILE_NAMES[nImageType] ),
+                                                            ElementModes::WRITE|ElementModes::TRUNCATE );
+                if ( xBitmapStream.is() )
+                {
+                    {
+                        std::unique_ptr<SvStream> pSvStream(utl::UcbStreamHelper::CreateStream( xBitmapStream ));
+                        vcl::PNGWriter aPngWriter( pImageList->GetAsHorizontalStrip() );
+                        aPngWriter.Write( *pSvStream );
+                    }
+
+                    // Commit user bitmaps storage
+                    xTransaction.set( xUserBitmapsStorage, UNO_QUERY );
+                    if ( xTransaction.is() )
+                        xTransaction->commit();
+                }
+
+                xOutputStream = xStream->getOutputStream();
+                if ( xOutputStream.is() )
+                    ImagesConfiguration::StoreImages( m_xContext, xOutputStream, aUserImageListInfo );
+
+                // Commit user image storage
+                xTransaction.set( xUserImageStorage, UNO_QUERY );
+                if ( xTransaction.is() )
+                    xTransaction->commit();
+            }
+
+            return 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( OUString::createFromAscii( IMAGELIST_XML_FILE[nImageType] ));
+            }
+            catch ( const css::container::NoSuchElementException& )
+            {
+            }
+
+            try
+            {
+                xUserBitmapsStorage->removeElement( OUString::createFromAscii( BITMAP_FILE_NAMES[nImageType] ));
+            }
+            catch ( const css::container::NoSuchElementException& )
+            {
+            }
+
+            uno::Reference< XTransactedObject > xTransaction;
+
+            // Commit user image storage
+            xTransaction.set( xUserImageStorage, UNO_QUERY );
+            if ( xTransaction.is() )
+                xTransaction->commit();
+
+            // Commit user bitmaps storage
+            xTransaction.set( xUserBitmapsStorage, UNO_QUERY );
+            if ( xTransaction.is() )
+                xTransaction->commit();
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+const rtl::Reference< GlobalImageList >& ImageManagerImpl::implts_getGlobalImageList()
+{
+    SolarMutexGuard g;
+
+    if ( !m_pGlobalImageList.is() )
+        m_pGlobalImageList = getGlobalImageList( m_xContext );
+    return m_pGlobalImageList;
+}
+
+CmdImageList* ImageManagerImpl::implts_getDefaultImageList()
+{
+    SolarMutexGuard g;
+
+    if ( !m_pDefaultImageList )
+        m_pDefaultImageList.reset(new CmdImageList( m_xContext, m_aModuleIdentifier ));
+
+    return m_pDefaultImageList.get();
+}
+
+ImageManagerImpl::ImageManagerImpl( const uno::Reference< uno::XComponentContext >& rxContext,::cppu::OWeakObject* pOwner,bool _bUseGlobal ) :
+    m_xContext( rxContext )
+    , m_pOwner(pOwner)
+    , m_aResourceString( "private:resource/images/moduleimages" )
+    , m_aListenerContainer( m_mutex )
+    , m_bUseGlobal(_bUseGlobal)
+    , m_bReadOnly( true )
+    , m_bInitialized( false )
+    , m_bModified( false )
+    , m_bDisposed( false )
+{
+    for ( vcl::ImageType n : o3tl::enumrange<vcl::ImageType>() )
+    {
+        m_pUserImageList[n] = nullptr;
+        m_bUserImageListModified[n] = false;
+    }
+}
+
+ImageManagerImpl::~ImageManagerImpl()
+{
+    clear();
+}
+
+void ImageManagerImpl::dispose()
+{
+    uno::Reference< uno::XInterface > xOwner(m_pOwner);
+    css::lang::EventObject aEvent( xOwner );
+    m_aListenerContainer.disposeAndClear( aEvent );
+
+    {
+        SolarMutexGuard g;
+        m_xUserConfigStorage.clear();
+        m_xUserImageStorage.clear();
+        m_xUserRootCommit.clear();
+        m_bModified = false;
+        m_bDisposed = true;
+
+        // delete user and default image list on dispose
+        for (auto& n : m_pUserImageList)
+        {
+            n.reset();
+        }
+        m_pDefaultImageList.reset();
+    }
+
+}
+void ImageManagerImpl::addEventListener( const uno::Reference< XEventListener >& xListener )
+{
+    {
+        SolarMutexGuard g;
+
+        /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+        if ( m_bDisposed )
+            throw DisposedException();
+    }
+
+    m_aListenerContainer.addInterface( cppu::UnoType<XEventListener>::get(), xListener );
+}
+
+void ImageManagerImpl::removeEventListener( const uno::Reference< XEventListener >& xListener )
+{
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    m_aListenerContainer.removeInterface( cppu::UnoType<XEventListener>::get(), xListener );
+}
+
+// XInitialization
+void ImageManagerImpl::initialize( const Sequence< Any >& aArguments )
+{
+    SolarMutexGuard g;
+
+    if ( m_bInitialized )
+        return;
+
+    for ( const Any& rArg : aArguments )
+    {
+        PropertyValue aPropValue;
+        if ( rArg >>= aPropValue )
+        {
+            if ( aPropValue.Name == "UserConfigStorage" )
+            {
+                aPropValue.Value >>= m_xUserConfigStorage;
+            }
+            else if ( aPropValue.Name == "ModuleIdentifier" )
+            {
+                aPropValue.Value >>= m_aModuleIdentifier;
+            }
+            else if ( aPropValue.Name == "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("OpenMode") >>= nOpenMode )
+                m_bReadOnly = !( nOpenMode & ElementModes::WRITE );
+        }
+    }
+
+    implts_initialize();
+
+    m_bInitialized = true;
+}
+
+// XImageManagerImpl
+void ImageManagerImpl::reset()
+{
+    SolarMutexGuard g;
+
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    std::vector< OUString > aUserImageNames;
+
+    for ( vcl::ImageType i : o3tl::enumrange<vcl::ImageType>() )
+    {
+        aUserImageNames.clear();
+        ImageList* pImageList = implts_getUserImageList(i);
+        pImageList->GetImageNames( aUserImageNames );
+
+        Sequence< OUString > aRemoveList( comphelper::containerToSequence(aUserImageNames) );
+
+        // Remove images
+        removeImages( sal_Int16( i ), aRemoveList );
+        m_bUserImageListModified[i] = true;
+    }
+
+    m_bModified = true;
+}
+
+Sequence< OUString > ImageManagerImpl::getAllImageNames( ::sal_Int16 nImageType )
+{
+    SolarMutexGuard g;
+
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    ImageNameMap aImageCmdNameMap;
+
+    vcl::ImageType 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.emplace( rGlobalImageNameVector[i], true );
+
+        const std::vector< OUString >& rModuleImageNameVector = implts_getDefaultImageList()->getImageCommandNames();
+        const sal_uInt32 nModuleCount = rModuleImageNameVector.size();
+        for ( i = 0; i < nModuleCount; i++ )
+            aImageCmdNameMap.emplace( rModuleImageNameVector[i], true );
+    }
+
+    ImageList* pImageList = implts_getUserImageList(nIndex);
+    std::vector< OUString > rUserImageNames;
+    pImageList->GetImageNames( rUserImageNames );
+    const sal_uInt32 nUserCount = rUserImageNames.size();
+    for ( i = 0; i < nUserCount; i++ )
+        aImageCmdNameMap.emplace( rUserImageNames[i], true );
+
+    return comphelper::mapKeysToSequence( aImageCmdNameMap );
+}
+
+bool ImageManagerImpl::hasImage( ::sal_Int16 nImageType, const OUString& aCommandURL )
+{
+    SolarMutexGuard g;
+
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE ))
+        throw IllegalArgumentException();
+
+    vcl::ImageType nIndex = implts_convertImageTypeToIndex( nImageType );
+    if ( m_bUseGlobal && implts_getGlobalImageList()->hasImage( nIndex, aCommandURL ))
+        return true;
+    else
+    {
+        if ( m_bUseGlobal && implts_getDefaultImageList()->hasImage( nIndex, aCommandURL ))
+            return true;
+        else
+        {
+            // User layer
+            ImageList* pImageList = implts_getUserImageList(nIndex);
+            if ( pImageList )
+                return ( pImageList->GetImagePos( aCommandURL ) != IMAGELIST_IMAGE_NOTFOUND );
+        }
+    }
+
+    return false;
+}
+
+namespace
+{
+    css::uno::Reference< css::graphic::XGraphic > GetXGraphic(const Image &rImage)
+    {
+        return Graphic(rImage).GetXGraphic();
+    }
+}
+
+Sequence< uno::Reference< XGraphic > > ImageManagerImpl::getImages(
+    ::sal_Int16 nImageType,
+    const Sequence< OUString >& aCommandURLSequence )
+{
+    SolarMutexGuard g;
+
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE ))
+        throw IllegalArgumentException();
+
+    Sequence< uno::Reference< XGraphic > > aGraphSeq( aCommandURLSequence.getLength() );
+
+    vcl::ImageType                    nIndex            = implts_convertImageTypeToIndex( nImageType );
+    rtl::Reference< GlobalImageList > rGlobalImageList;
+    CmdImageList*                     pDefaultImageList = nullptr;
+    if ( m_bUseGlobal )
+    {
+        rGlobalImageList  = implts_getGlobalImageList();
+        pDefaultImageList = implts_getDefaultImageList();
+    }
+    ImageList*                        pUserImageList    = implts_getUserImageList(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)
+    sal_Int32 n = 0;
+    for ( const OUString& rURL : aCommandURLSequence )
+    {
+        Image aImage = pUserImageList->GetImage( rURL );
+        if ( !aImage && m_bUseGlobal )
+        {
+            aImage = pDefaultImageList->getImageFromCommandURL( nIndex, rURL );
+            if ( !aImage )
+                aImage = rGlobalImageList->getImageFromCommandURL( nIndex, rURL );
+        }
+
+        aGraphSeq[n++] = GetXGraphic(aImage);
+    }
+
+    return aGraphSeq;
+}
+
+void ImageManagerImpl::replaceImages(
+    ::sal_Int16 nImageType,
+    const Sequence< OUString >& aCommandURLSequence,
+    const Sequence< uno::Reference< XGraphic > >& aGraphicsSequence )
+{
+    GraphicNameAccess* pInsertedImages( nullptr );
+    GraphicNameAccess* pReplacedImages( nullptr );
+
+    {
+        SolarMutexGuard g;
+
+        /* 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();
+
+        vcl::ImageType nIndex = implts_convertImageTypeToIndex( nImageType );
+        ImageList* pImageList = implts_getUserImageList(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], Image(xGraphic));
+                if ( !pInsertedImages )
+                    pInsertedImages = new GraphicNameAccess();
+                pInsertedImages->addElement( aCommandURLSequence[i], xGraphic );
+            }
+            else
+            {
+                pImageList->ReplaceImage(aCommandURLSequence[i], Image(xGraphic));
+                if ( !pReplacedImages )
+                    pReplacedImages = new GraphicNameAccess();
+                pReplacedImages->addElement( aCommandURLSequence[i], xGraphic );
+            }
+        }
+
+        if (( pInsertedImages != nullptr ) || (  pReplacedImages != nullptr ))
+        {
+            m_bModified = true;
+            m_bUserImageListModified[nIndex] = true;
+        }
+    }
+
+    uno::Reference< uno::XInterface > xOwner(m_pOwner);
+    // Notify listeners
+    if ( pInsertedImages != nullptr )
+    {
+        ConfigurationEvent aInsertEvent;
+        aInsertEvent.aInfo           <<= nImageType;
+        aInsertEvent.Accessor        <<= xOwner;
+        aInsertEvent.Source          = xOwner;
+        aInsertEvent.ResourceURL     = m_aResourceString;
+        aInsertEvent.Element         <<= uno::Reference< XNameAccess >(
+                                           static_cast< OWeakObject *>( pInsertedImages ), UNO_QUERY );
+        implts_notifyContainerListener( aInsertEvent, NotifyOp_Insert );
+    }
+    if ( pReplacedImages != nullptr )
+    {
+        ConfigurationEvent aReplaceEvent;
+        aReplaceEvent.aInfo           <<= nImageType;
+        aReplaceEvent.Accessor        <<= xOwner;
+        aReplaceEvent.Source          = xOwner;
+        aReplaceEvent.ResourceURL     = m_aResourceString;
+        aReplaceEvent.ReplacedElement = Any();
+        aReplaceEvent.Element         <<= uno::Reference< XNameAccess >(
+                                            static_cast< OWeakObject *>( pReplacedImages ), UNO_QUERY );
+        implts_notifyContainerListener( aReplaceEvent, NotifyOp_Replace );
+    }
+}
+
+void ImageManagerImpl::removeImages( ::sal_Int16 nImageType, const Sequence< OUString >& aCommandURLSequence )
+{
+    GraphicNameAccess* pRemovedImages( nullptr );
+    GraphicNameAccess* pReplacedImages( nullptr );
+
+    {
+        SolarMutexGuard g;
+
+        /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+        if ( m_bDisposed )
+            throw DisposedException();
+
+        if (( nImageType < 0 ) || ( nImageType > MAX_IMAGETYPE_VALUE ))
+            throw IllegalArgumentException();
+
+        if ( m_bReadOnly )
+            throw IllegalAccessException();
+
+        vcl::ImageType nIndex = implts_convertImageTypeToIndex( nImageType );
+        rtl::Reference< GlobalImageList > rGlobalImageList;
+        CmdImageList*                     pDefaultImageList = nullptr;
+        if ( m_bUseGlobal )
+        {
+            rGlobalImageList  = implts_getGlobalImageList();
+            pDefaultImageList = implts_getDefaultImageList();
+        }
+        ImageList*                        pImageList        = implts_getUserImageList(nIndex);
+        uno::Reference<XGraphic> xEmptyGraphic;
+
+        for ( const OUString& rURL : aCommandURLSequence )
+        {
+            sal_uInt16 nPos = pImageList->GetImagePos( rURL );
+            if ( nPos != IMAGELIST_IMAGE_NOTFOUND )
+            {
+                sal_uInt16 nId   = pImageList->GetImageId( nPos );
+                pImageList->RemoveImage( nId );
+
+                if ( m_bUseGlobal )
+                {
+                    // Check, if we have an 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, rURL );
+                    if ( !aNewImage )
+                        aNewImage = rGlobalImageList->getImageFromCommandURL( nIndex, rURL );
+                    if ( !aNewImage )
+                    {
+                        if ( !pRemovedImages )
+                            pRemovedImages = new GraphicNameAccess();
+                        pRemovedImages->addElement( rURL, xEmptyGraphic );
+                    }
+                    else
+                    {
+                        if ( !pReplacedImages )
+                            pReplacedImages = new GraphicNameAccess();
+                        pReplacedImages->addElement(rURL, GetXGraphic(aNewImage));
+                    }
+                } // if ( m_bUseGlobal )
+                else
+                {
+                    if ( !pRemovedImages )
+                        pRemovedImages = new GraphicNameAccess();
+                    pRemovedImages->addElement( rURL, xEmptyGraphic );
+                }
+            }
+        }
+
+        if (( pReplacedImages != nullptr ) || ( pRemovedImages != nullptr ))
+        {
+            m_bModified = true;
+            m_bUserImageListModified[nIndex] = true;
+        }
+    }
+
+    // Notify listeners
+    uno::Reference< uno::XInterface > xOwner(m_pOwner);
+    if ( pRemovedImages != nullptr )
+    {
+        ConfigurationEvent aRemoveEvent;
+        aRemoveEvent.aInfo           <<= nImageType;
+        aRemoveEvent.Accessor        <<= xOwner;
+        aRemoveEvent.Source          = xOwner;
+        aRemoveEvent.ResourceURL     = m_aResourceString;
+        aRemoveEvent.Element         <<= uno::Reference< XNameAccess >(
+                                            static_cast< OWeakObject *>( pRemovedImages ), UNO_QUERY );
+        implts_notifyContainerListener( aRemoveEvent, NotifyOp_Remove );
+    }
+    if ( pReplacedImages != nullptr )
+    {
+        ConfigurationEvent aReplaceEvent;
+        aReplaceEvent.aInfo           <<= nImageType;
+        aReplaceEvent.Accessor        <<= xOwner;
+        aReplaceEvent.Source          = xOwner;
+        aReplaceEvent.ResourceURL     = m_aResourceString;
+        aReplaceEvent.ReplacedElement = Any();
+        aReplaceEvent.Element         <<= uno::Reference< XNameAccess >(
+                                            static_cast< OWeakObject *>( pReplacedImages ), UNO_QUERY );
+        implts_notifyContainerListener( aReplaceEvent, NotifyOp_Replace );
+    }
+}
+
+void ImageManagerImpl::insertImages( ::sal_Int16 nImageType, const Sequence< OUString >& aCommandURLSequence, const Sequence< uno::Reference< XGraphic > >& aGraphicSequence )
+{
+    replaceImages(nImageType,aCommandURLSequence,aGraphicSequence);
+}
+
+// XUIConfigurationPersistence
+void ImageManagerImpl::reload()
+{
+    SolarMutexClearableGuard aGuard;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    CommandMap                   aOldUserCmdImageSet;
+    std::vector< OUString > aNewUserCmdImageSet;
+
+    if ( !m_bModified )
+        return;
+
+    for ( vcl::ImageType i : o3tl::enumrange<vcl::ImageType>() )
+    {
+        if ( !m_bDisposed && m_bUserImageListModified[i] )
+        {
+            std::vector< OUString > aOldUserCmdImageVector;
+            ImageList* pImageList = implts_getUserImageList(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.emplace( aOldUserCmdImageVector[j], false );
+
+            // Attention: This can make the old image list pointer invalid!
+            implts_loadUserImages( i, m_xUserImageStorage, m_xUserBitmapsStorage );
+            pImageList = implts_getUserImageList(i);
+            pImageList->GetImageNames( aNewUserCmdImageSet );
+
+            GraphicNameAccess* pInsertedImages( nullptr );
+            GraphicNameAccess* pReplacedImages( nullptr );
+            GraphicNameAccess* pRemovedImages( nullptr );
+
+            for (auto const& newUserCmdImage : aNewUserCmdImageSet)
+            {
+                CommandMap::iterator pIter = aOldUserCmdImageSet.find(newUserCmdImage);
+                if ( pIter != aOldUserCmdImageSet.end() )
+                {
+                    pIter->second = true; // mark entry as replaced
+                    if ( !pReplacedImages )
+                        pReplacedImages = new GraphicNameAccess();
+                    pReplacedImages->addElement( newUserCmdImage,
+                                                 GetXGraphic(pImageList->GetImage(newUserCmdImage)) );
+                }
+                else
+                {
+                    if ( !pInsertedImages )
+                        pInsertedImages = new GraphicNameAccess();
+                    pInsertedImages->addElement( newUserCmdImage,
+                                                 GetXGraphic(pImageList->GetImage(newUserCmdImage)) );
+                }
+            }
+
+            // 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 = nullptr;
+            if ( m_bUseGlobal )
+            {
+                rGlobalImageList  = implts_getGlobalImageList();
+                pDefaultImageList = implts_getDefaultImageList();
+            }
+            uno::Reference<XGraphic> xEmptyGraphic;
+            for (auto const& oldUserCmdImage : aOldUserCmdImageSet)
+            {
+                if ( !oldUserCmdImage.second )
+                {
+                    if ( m_bUseGlobal )
+                    {
+                        Image aImage = pDefaultImageList->getImageFromCommandURL( i, oldUserCmdImage.first );
+                        if ( !aImage )
+                            aImage = rGlobalImageList->getImageFromCommandURL( i, oldUserCmdImage.first );
+
+                        if ( !aImage )
+                        {
+                            // No image in the module/global image list => remove user image
+                            if ( !pRemovedImages )
+                                pRemovedImages = new GraphicNameAccess();
+                            pRemovedImages->addElement( oldUserCmdImage.first, xEmptyGraphic );
+                        }
+                        else
+                        {
+                            // Image has been found in the module/global image list => replace user image
+                            if ( !pReplacedImages )
+                                pReplacedImages = new GraphicNameAccess();
+                            pReplacedImages->addElement(oldUserCmdImage.first, GetXGraphic(aImage));
+                        }
+                    } // if ( m_bUseGlobal )
+                    else
+                    {
+                        // No image in the user image list => remove user image
+                        if ( !pRemovedImages )
+                            pRemovedImages = new GraphicNameAccess();
+                        pRemovedImages->addElement( oldUserCmdImage.first, xEmptyGraphic );
+                    }
+                }
+            }
+
+            aGuard.clear();
+
+            // Now notify our listeners. Unlock mutex to prevent deadlocks
+            uno::Reference< uno::XInterface > xOwner(m_pOwner);
+            if ( pInsertedImages != nullptr )
+            {
+                ConfigurationEvent aInsertEvent;
+                aInsertEvent.aInfo           <<=static_cast<sal_uInt16>(i);
+                aInsertEvent.Accessor        <<= xOwner;
+                aInsertEvent.Source          = xOwner;
+                aInsertEvent.ResourceURL     = m_aResourceString;
+                aInsertEvent.Element         <<= uno::Reference< XNameAccess >(
+                                                   static_cast< OWeakObject *>( pInsertedImages ), UNO_QUERY );
+                implts_notifyContainerListener( aInsertEvent, NotifyOp_Insert );
+            }
+            if ( pReplacedImages != nullptr )
+            {
+                ConfigurationEvent aReplaceEvent;
+                aReplaceEvent.aInfo           <<= static_cast<sal_uInt16>(i);
+                aReplaceEvent.Accessor        <<= xOwner;
+                aReplaceEvent.Source          = xOwner;
+                aReplaceEvent.ResourceURL     = m_aResourceString;
+                aReplaceEvent.ReplacedElement = Any();
+                aReplaceEvent.Element         <<= uno::Reference< XNameAccess >(
+                                                static_cast< OWeakObject *>( pReplacedImages ), UNO_QUERY );
+                implts_notifyContainerListener( aReplaceEvent, NotifyOp_Replace );
+            }
+            if ( pRemovedImages != nullptr )
+            {
+                ConfigurationEvent aRemoveEvent;
+                aRemoveEvent.aInfo           <<= static_cast<sal_uInt16>(i);
+                aRemoveEvent.Accessor        <<= xOwner;
+                aRemoveEvent.Source          = xOwner;
+                aRemoveEvent.ResourceURL     = m_aResourceString;
+                aRemoveEvent.Element         <<= uno::Reference< XNameAccess >(
+                                                    static_cast< OWeakObject *>( pRemovedImages ), UNO_QUERY );
+                implts_notifyContainerListener( aRemoveEvent, NotifyOp_Remove );
+            }
+
+            aGuard.clear();
+        }
+    }
+}
+
+void ImageManagerImpl::store()
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( !m_bModified )
+        return;
+
+    bool bWritten( false );
+    for ( vcl::ImageType i : o3tl::enumrange<vcl::ImageType>() )
+    {
+        bool bSuccess = implts_storeUserImages(i, m_xUserImageStorage, m_xUserBitmapsStorage );
+        if ( bSuccess )
+            bWritten = 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 = false;
+}
+
+void ImageManagerImpl::storeToStorage( const uno::Reference< XStorage >& Storage )
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( !(m_bModified && Storage.is()) )
+        return;
+
+    long nModes = ElementModes::READWRITE;
+
+    uno::Reference< XStorage > xUserImageStorage = Storage->openStorageElement( IMAGE_FOLDER,
+                                                                                nModes );
+    if ( !xUserImageStorage.is() )
+        return;
+
+    uno::Reference< XStorage > xUserBitmapsStorage = xUserImageStorage->openStorageElement( BITMAPS_FOLDER,
+                                                                                            nModes );
+    for ( vcl::ImageType i : o3tl::enumrange<vcl::ImageType>() )
+    {
+        implts_getUserImageList(i);
+        implts_storeUserImages( i, xUserImageStorage, xUserBitmapsStorage );
+    }
+
+    uno::Reference< XTransactedObject > xTransaction( Storage, UNO_QUERY );
+    if ( xTransaction.is() )
+        xTransaction->commit();
+}
+
+bool ImageManagerImpl::isModified() const
+{
+    SolarMutexGuard g;
+    return m_bModified;
+}
+
+bool ImageManagerImpl::isReadOnly() const
+{
+    SolarMutexGuard g;
+    return m_bReadOnly;
+}
+// XUIConfiguration
+void ImageManagerImpl::addConfigurationListener( const uno::Reference< css::ui::XUIConfigurationListener >& xListener )
+{
+    {
+        SolarMutexGuard g;
+
+        /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+        if ( m_bDisposed )
+            throw DisposedException();
+    }
+
+    m_aListenerContainer.addInterface( cppu::UnoType<XUIConfigurationListener>::get(), xListener );
+}
+
+void ImageManagerImpl::removeConfigurationListener( const uno::Reference< css::ui::XUIConfigurationListener >& xListener )
+{
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    m_aListenerContainer.removeInterface( cppu::UnoType<XUIConfigurationListener>::get(), xListener );
+}
+
+void ImageManagerImpl::implts_notifyContainerListener( const ConfigurationEvent& aEvent, NotifyOp eOp )
+{
+    ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer(
+                                        cppu::UnoType<css::ui::XUIConfigurationListener>::get());
+    if ( pContainer == nullptr )
+        return;
+
+    ::cppu::OInterfaceIteratorHelper pIterator( *pContainer );
+    while ( pIterator.hasMoreElements() )
+    {
+        try
+        {
+            switch ( eOp )
+            {
+                case NotifyOp_Replace:
+                    static_cast< css::ui::XUIConfigurationListener*>(pIterator.next())->elementReplaced( aEvent );
+                    break;
+                case NotifyOp_Insert:
+                    static_cast< css::ui::XUIConfigurationListener*>(pIterator.next())->elementInserted( aEvent );
+                    break;
+                case NotifyOp_Remove:
+                    static_cast< css::ui::XUIConfigurationListener*>(pIterator.next())->elementRemoved( aEvent );
+                    break;
+            }
+        }
+        catch( const css::uno::RuntimeException& )
+        {
+            pIterator.remove();
+        }
+    }
+}
+void ImageManagerImpl::clear()
+{
+    SolarMutexGuard g;
+
+    for (auto & n : m_pUserImageList)
+    {
+        n.reset();
+    }
+}
+} // namespace framework
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */