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, 1381 insertions, 0 deletions

diff --git a/framework/source/uiconfiguration/uiconfigurationmanager.cxx b/framework/source/uiconfiguration/uiconfigurationmanager.cxx
new file mode 100644
index 000000000..be337b580
--- /dev/null
+++ b/framework/source/uiconfiguration/uiconfigurationmanager.cxx
@@ -0,0 +1,1381 @@
+/* -*- 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 <uiconfiguration/imagemanager.hxx>
+#include <uielement/rootitemcontainer.hxx>
+#include <uielement/constitemcontainer.hxx>
+#include <uielement/uielementtypenames.hxx>
+#include <menuconfiguration.hxx>
+#include <statusbarconfiguration.hxx>
+#include <toolboxconfiguration.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/ElementExistException.hpp>
+#include <com/sun/star/container/XIndexContainer.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/embed/XTransactedObject.hpp>
+#include <com/sun/star/lang/IllegalAccessException.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/ui/UIElementType.hpp>
+#include <com/sun/star/ui/ConfigurationEvent.hpp>
+#include <com/sun/star/ui/DocumentAcceleratorConfiguration.hpp>
+#include <com/sun/star/ui/XAcceleratorConfiguration.hpp>
+#include <com/sun/star/ui/XUIConfigurationManager2.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <vcl/svapp.hxx>
+#include <sal/log.hxx>
+
+#include <unordered_map>
+
+using namespace com::sun::star::uno;
+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 framework;
+
+namespace {
+
+class UIConfigurationManager :   public ::cppu::WeakImplHelper<
+                                        css::lang::XServiceInfo  ,
+                                        css::ui::XUIConfigurationManager2 >
+{
+public:
+    virtual OUString SAL_CALL getImplementationName() override
+    {
+        return "com.sun.star.comp.framework.UIConfigurationManager";
+    }
+
+    virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
+    {
+        return cppu::supportsService(this, ServiceName);
+    }
+
+    virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
+    {
+        return {"com.sun.star.ui.UIConfigurationManager"};
+    }
+
+    explicit UIConfigurationManager( const css::uno::Reference< css::uno::XComponentContext > & rxContext );
+
+    // XComponent
+    virtual void SAL_CALL dispose() override;
+    virtual void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener ) override;
+    virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener ) override;
+
+    // XUIConfiguration
+    virtual void SAL_CALL addConfigurationListener( const css::uno::Reference< css::ui::XUIConfigurationListener >& Listener ) override;
+    virtual void SAL_CALL removeConfigurationListener( const css::uno::Reference< css::ui::XUIConfigurationListener >& Listener ) override;
+
+    // XUIConfigurationManager
+    virtual void SAL_CALL reset() override;
+    virtual css::uno::Sequence< css::uno::Sequence< css::beans::PropertyValue > > SAL_CALL getUIElementsInfo( sal_Int16 ElementType ) override;
+    virtual css::uno::Reference< css::container::XIndexContainer > SAL_CALL createSettings(  ) override;
+    virtual sal_Bool SAL_CALL hasSettings( const OUString& ResourceURL ) override;
+    virtual css::uno::Reference< css::container::XIndexAccess > SAL_CALL getSettings( const OUString& ResourceURL, sal_Bool bWriteable ) override;
+    virtual void SAL_CALL replaceSettings( const OUString& ResourceURL, const css::uno::Reference< css::container::XIndexAccess >& aNewData ) override;
+    virtual void SAL_CALL removeSettings( const OUString& ResourceURL ) override;
+    virtual void SAL_CALL insertSettings( const OUString& NewResourceURL, const css::uno::Reference< css::container::XIndexAccess >& aNewData ) override;
+    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getImageManager() override;
+    virtual css::uno::Reference< css::ui::XAcceleratorConfiguration > SAL_CALL getShortCutManager() override;
+    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getEventsManager() override;
+
+    // XUIConfigurationPersistence
+    virtual void SAL_CALL reload() override;
+    virtual void SAL_CALL store() override;
+    virtual void SAL_CALL storeToStorage( const css::uno::Reference< css::embed::XStorage >& Storage ) override;
+    virtual sal_Bool SAL_CALL isModified() override;
+    virtual sal_Bool SAL_CALL isReadOnly() override;
+
+    // XUIConfigurationStorage
+    virtual void SAL_CALL setStorage( const css::uno::Reference< css::embed::XStorage >& Storage ) override;
+    virtual sal_Bool SAL_CALL hasStorage() override;
+
+private:
+    // private data types
+    enum NotifyOp
+    {
+        NotifyOp_Remove,
+        NotifyOp_Insert,
+        NotifyOp_Replace
+    };
+
+    struct UIElementInfo
+    {
+        UIElementInfo( const OUString& rResourceURL, const OUString& rUIName ) :
+            aResourceURL( rResourceURL), aUIName( rUIName ) {}
+        OUString   aResourceURL;
+        OUString   aUIName;
+    };
+
+    struct UIElementData
+    {
+        UIElementData() : bModified( false ), bDefault( true ) {};
+
+        OUString aResourceURL;
+        OUString aName;
+        bool          bModified;        // has been changed since last storing
+        bool          bDefault;         // default settings
+        css::uno::Reference< css::container::XIndexAccess > xSettings;
+    };
+
+    struct UIElementType;
+    friend struct UIElementType;
+    typedef std::unordered_map< OUString, UIElementData > UIElementDataHashMap;
+
+    struct UIElementType
+    {
+        UIElementType() : bModified( false ),
+                          bLoaded( false ),
+                          nElementType( css::ui::UIElementType::UNKNOWN ) {}
+
+        bool                                                              bModified;
+        bool                                                              bLoaded;
+        sal_Int16                                                         nElementType;
+        UIElementDataHashMap                                              aElementsHashMap;
+        css::uno::Reference< css::embed::XStorage > xStorage;
+    };
+
+    typedef std::vector< UIElementType > UIElementTypesVector;
+    typedef std::vector< css::ui::ConfigurationEvent > ConfigEventNotifyContainer;
+    typedef std::unordered_map< OUString, UIElementInfo > UIElementInfoHashMap;
+
+    void            impl_Initialize();
+    void            implts_notifyContainerListener( const css::ui::ConfigurationEvent& aEvent, NotifyOp eOp );
+    void            impl_fillSequenceWithElementTypeInfo( UIElementInfoHashMap& aUIElementInfoCollection, sal_Int16 nElementType );
+    void            impl_preloadUIElementTypeList( sal_Int16 nElementType );
+    UIElementData*  impl_findUIElementData( const OUString& aResourceURL, sal_Int16 nElementType, bool bLoad = true );
+    void            impl_requestUIElementData( sal_Int16 nElementType, UIElementData& aUIElementData );
+    void            impl_storeElementTypeData( css::uno::Reference< css::embed::XStorage > const & xStorage, UIElementType& rElementType, bool bResetModifyState = true );
+    void            impl_resetElementTypeData( UIElementType& rDocElementType, ConfigEventNotifyContainer& rRemoveNotifyContainer );
+    void            impl_reloadElementTypeData( UIElementType& rDocElementType, ConfigEventNotifyContainer& rRemoveNotifyContainer, ConfigEventNotifyContainer& rReplaceNotifyContainer );
+
+    UIElementTypesVector                                      m_aUIElements;
+    css::uno::Reference< css::embed::XStorage >               m_xDocConfigStorage;
+    bool                                                      m_bReadOnly;
+    bool                                                      m_bModified;
+    bool                                                      m_bDisposed;
+    OUString                                                  m_aPropUIName;
+    css::uno::Reference< css::uno::XComponentContext >        m_xContext;
+    osl::Mutex                                                m_mutex;
+    cppu::OMultiTypeInterfaceContainerHelper                  m_aListenerContainer;   /// container for ALL Listener
+    css::uno::Reference< css::lang::XComponent >              m_xImageManager;
+    css::uno::Reference< css::ui::XAcceleratorConfiguration > m_xAccConfig;
+};
+
+// important: The order and position of the elements must match the constant
+// definition of "css::ui::UIElementType"
+static OUStringLiteral UIELEMENTTYPENAMES[] =
+{
+    "",  // Dummy value for unknown!
+    UIELEMENTTYPE_MENUBAR_NAME,
+    UIELEMENTTYPE_POPUPMENU_NAME,
+    UIELEMENTTYPE_TOOLBAR_NAME,
+    UIELEMENTTYPE_STATUSBAR_NAME,
+    UIELEMENTTYPE_FLOATINGWINDOW_NAME,
+    UIELEMENTTYPE_PROGRESSBAR_NAME,
+    UIELEMENTTYPE_TOOLPANEL_NAME
+};
+
+static const char       RESOURCEURL_PREFIX[] = "private:resource/";
+static const sal_Int32  RESOURCEURL_PREFIX_SIZE = 17;
+
+sal_Int16 RetrieveTypeFromResourceURL( const OUString& aResourceURL )
+{
+
+    if (( aResourceURL.startsWith( RESOURCEURL_PREFIX ) ) &&
+        ( aResourceURL.getLength() > RESOURCEURL_PREFIX_SIZE ))
+    {
+        OUString aTmpStr     = aResourceURL.copy( RESOURCEURL_PREFIX_SIZE );
+        sal_Int32     nIndex = aTmpStr.indexOf( '/' );
+        if (( nIndex > 0 ) &&  ( aTmpStr.getLength() > nIndex ))
+        {
+            OUString aTypeStr( aTmpStr.copy( 0, nIndex ));
+            for ( int i = 0; i < UIElementType::COUNT; i++ )
+            {
+                if ( aTypeStr == UIELEMENTTYPENAMES[i] )
+                    return sal_Int16( i );
+            }
+        }
+    }
+
+    return UIElementType::UNKNOWN;
+}
+
+OUString RetrieveNameFromResourceURL( const OUString& aResourceURL )
+{
+    if (( aResourceURL.startsWith( RESOURCEURL_PREFIX ) ) &&
+        ( aResourceURL.getLength() > RESOURCEURL_PREFIX_SIZE ))
+    {
+        sal_Int32 nIndex = aResourceURL.lastIndexOf( '/' );
+        if (( nIndex > 0 ) && (( nIndex+1 ) < aResourceURL.getLength()))
+            return aResourceURL.copy( nIndex+1 );
+    }
+
+    return OUString();
+}
+
+void UIConfigurationManager::impl_fillSequenceWithElementTypeInfo( UIElementInfoHashMap& aUIElementInfoCollection, sal_Int16 nElementType )
+{
+    // preload list of element types on demand
+    impl_preloadUIElementTypeList( nElementType );
+
+    UIElementDataHashMap& rUserElements = m_aUIElements[nElementType].aElementsHashMap;
+
+    for (auto const& elem : rUserElements)
+    {
+        UIElementData* pDataSettings = impl_findUIElementData( elem.second.aResourceURL, nElementType );
+        if ( pDataSettings && !pDataSettings->bDefault )
+        {
+            // Retrieve user interface name from XPropertySet interface
+            OUString aUIName;
+            Reference< XPropertySet > xPropSet( pDataSettings->xSettings, UNO_QUERY );
+            if ( xPropSet.is() )
+            {
+                Any a = xPropSet->getPropertyValue( m_aPropUIName );
+                a >>= aUIName;
+            }
+
+            UIElementInfo aInfo( elem.second.aResourceURL, aUIName );
+            aUIElementInfoCollection.emplace( elem.second.aResourceURL, aInfo );
+        }
+    }
+}
+
+void UIConfigurationManager::impl_preloadUIElementTypeList( sal_Int16 nElementType )
+{
+    UIElementType& rElementTypeData = m_aUIElements[nElementType];
+
+    if ( !rElementTypeData.bLoaded )
+    {
+        Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage;
+        if ( xElementTypeStorage.is() )
+        {
+            OUString aResURLPrefix =
+                RESOURCEURL_PREFIX +
+                UIELEMENTTYPENAMES[ nElementType ] +
+                "/";
+
+            UIElementDataHashMap& rHashMap = rElementTypeData.aElementsHashMap;
+            const Sequence< OUString > aUIElementNames = xElementTypeStorage->getElementNames();
+            for ( OUString const & rElementName : aUIElementNames )
+            {
+                UIElementData aUIElementData;
+
+                // Resource name must be without ".xml"
+                sal_Int32 nIndex = rElementName.lastIndexOf( '.' );
+                if (( nIndex > 0 ) && ( nIndex < rElementName.getLength() ))
+                {
+                    OUString aExtension( rElementName.copy( nIndex+1 ));
+                    OUString aUIElementName( rElementName.copy( 0, nIndex ));
+
+                    if (!aUIElementName.isEmpty() &&
+                        ( aExtension.equalsIgnoreAsciiCase("xml")))
+                    {
+                        aUIElementData.aResourceURL = aResURLPrefix + aUIElementName;
+                        aUIElementData.aName        = rElementName;
+                        aUIElementData.bModified    = false;
+                        aUIElementData.bDefault     = false;
+
+                        // Create unordered_map entries for all user interface elements inside the storage. We don't load the
+                        // settings to speed up the process.
+                        rHashMap.emplace( aUIElementData.aResourceURL, aUIElementData );
+                    }
+                }
+            }
+        }
+    }
+
+    rElementTypeData.bLoaded = true;
+}
+
+void UIConfigurationManager::impl_requestUIElementData( sal_Int16 nElementType, UIElementData& aUIElementData )
+{
+    UIElementType& rElementTypeData = m_aUIElements[nElementType];
+
+    Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage;
+    if ( xElementTypeStorage.is() && !aUIElementData.aName.isEmpty() )
+    {
+        try
+        {
+            Reference< XStream > xStream = xElementTypeStorage->openStreamElement( aUIElementData.aName, ElementModes::READ );
+            Reference< XInputStream > xInputStream = xStream->getInputStream();
+
+            if ( xInputStream.is() )
+            {
+                switch ( nElementType )
+                {
+                    case css::ui::UIElementType::UNKNOWN:
+                    break;
+
+                    case css::ui::UIElementType::MENUBAR:
+                    case css::ui::UIElementType::POPUPMENU:
+                    {
+                        try
+                        {
+                            MenuConfiguration aMenuCfg( m_xContext );
+                            Reference< XIndexAccess > xContainer( aMenuCfg.CreateMenuBarConfigurationFromXML( xInputStream ));
+                            auto pRootItemContainer = comphelper::getUnoTunnelImplementation<RootItemContainer>( xContainer );
+                            if ( pRootItemContainer )
+                                aUIElementData.xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, true ) ), UNO_QUERY );
+                            else
+                                aUIElementData.xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer( xContainer, true ) ), UNO_QUERY );
+                            return;
+                        }
+                        catch ( const css::lang::WrappedTargetException& )
+                        {
+                        }
+                    }
+                    break;
+
+                    case css::ui::UIElementType::TOOLBAR:
+                    {
+                        try
+                        {
+                            Reference< XIndexContainer > xIndexContainer( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY );
+                            ToolBoxConfiguration::LoadToolBox( m_xContext, xInputStream, xIndexContainer );
+                            auto pRootItemContainer = comphelper::getUnoTunnelImplementation<RootItemContainer>( xIndexContainer );
+                            aUIElementData.xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, true ) ), UNO_QUERY );
+                            return;
+                        }
+                        catch ( const css::lang::WrappedTargetException& )
+                        {
+                        }
+
+                        break;
+                    }
+
+                    case css::ui::UIElementType::STATUSBAR:
+                    {
+                        try
+                        {
+                            Reference< XIndexContainer > xIndexContainer( static_cast< OWeakObject * >( new RootItemContainer() ), UNO_QUERY );
+                            StatusBarConfiguration::LoadStatusBar( m_xContext, xInputStream, xIndexContainer );
+                            auto pRootItemContainer = comphelper::getUnoTunnelImplementation<RootItemContainer>( xIndexContainer );
+                            aUIElementData.xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer( pRootItemContainer, true ) ), UNO_QUERY );
+                            return;
+                        }
+                        catch ( const css::lang::WrappedTargetException& )
+                        {
+                        }
+
+                        break;
+                    }
+
+                    case css::ui::UIElementType::FLOATINGWINDOW:
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+        catch ( const css::embed::InvalidStorageException& )
+        {
+        }
+        catch ( const css::lang::IllegalArgumentException& )
+        {
+        }
+        catch ( const css::io::IOException& )
+        {
+        }
+        catch ( const css::embed::StorageWrappedTargetException& )
+        {
+        }
+    }
+
+    // At least we provide an empty settings container!
+    aUIElementData.xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer()), UNO_QUERY );
+}
+
+UIConfigurationManager::UIElementData* UIConfigurationManager::impl_findUIElementData( const OUString& aResourceURL, sal_Int16 nElementType, bool bLoad )
+{
+    // preload list of element types on demand
+    impl_preloadUIElementTypeList( nElementType );
+
+    // try to look into our document vector/unordered_map combination
+    UIElementDataHashMap& rUserHashMap = m_aUIElements[nElementType].aElementsHashMap;
+    UIElementDataHashMap::iterator pIter = rUserHashMap.find( aResourceURL );
+    if ( pIter != rUserHashMap.end() )
+    {
+        // Default data settings data means removed!
+        if ( pIter->second.bDefault )
+            return &(pIter->second);
+        else
+        {
+            if ( !pIter->second.xSettings.is() && bLoad )
+                impl_requestUIElementData( nElementType, pIter->second );
+            return &(pIter->second);
+        }
+    }
+
+    // Nothing has been found!
+    return nullptr;
+}
+
+void UIConfigurationManager::impl_storeElementTypeData( Reference< XStorage > const & xStorage, UIElementType& rElementType, bool bResetModifyState )
+{
+    UIElementDataHashMap& rHashMap          = rElementType.aElementsHashMap;
+
+    for (auto & elem : rHashMap)
+    {
+        UIElementData& rElement = elem.second;
+        if ( rElement.bModified )
+        {
+            if ( rElement.bDefault )
+            {
+                xStorage->removeElement( rElement.aName );
+                rElement.bModified = false; // mark as not modified
+            }
+            else
+            {
+                Reference< XStream > xStream = xStorage->openStreamElement( rElement.aName, ElementModes::WRITE|ElementModes::TRUNCATE );
+                Reference< XOutputStream > xOutputStream( xStream->getOutputStream() );
+
+                if ( xOutputStream.is() )
+                {
+                    switch( rElementType.nElementType )
+                    {
+                        case css::ui::UIElementType::MENUBAR:
+                        case css::ui::UIElementType::POPUPMENU:
+                        {
+                            try
+                            {
+                                MenuConfiguration aMenuCfg( m_xContext );
+                                aMenuCfg.StoreMenuBarConfigurationToXML(
+                                    rElement.xSettings, xOutputStream, rElementType.nElementType == css::ui::UIElementType::MENUBAR );
+                            }
+                            catch ( const css::lang::WrappedTargetException& )
+                            {
+                            }
+                        }
+                        break;
+
+                        case css::ui::UIElementType::TOOLBAR:
+                        {
+                            try
+                            {
+                                ToolBoxConfiguration::StoreToolBox( m_xContext, xOutputStream, rElement.xSettings );
+                            }
+                            catch ( const css::lang::WrappedTargetException& )
+                            {
+                            }
+                        }
+                        break;
+
+                        case css::ui::UIElementType::STATUSBAR:
+                        {
+                            try
+                            {
+                                StatusBarConfiguration::StoreStatusBar( m_xContext, xOutputStream, rElement.xSettings );
+                            }
+                            catch ( const css::lang::WrappedTargetException& )
+                            {
+                            }
+                        }
+                        break;
+
+                        default:
+                        break;
+                    }
+                }
+
+                // mark as not modified if we store to our own storage
+                if ( bResetModifyState )
+                    rElement.bModified = false;
+            }
+        }
+    }
+
+    // commit element type storage
+    Reference< XTransactedObject > xTransactedObject( xStorage, UNO_QUERY );
+    if ( xTransactedObject.is() )
+        xTransactedObject->commit();
+
+    // mark UIElementType as not modified if we store to our own storage
+    if ( bResetModifyState )
+        rElementType.bModified = false;
+}
+
+void UIConfigurationManager::impl_resetElementTypeData(
+    UIElementType& rDocElementType,
+    ConfigEventNotifyContainer& rRemoveNotifyContainer )
+{
+    UIElementDataHashMap& rHashMap          = rDocElementType.aElementsHashMap;
+
+    Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+    Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+    // Make copies of the event structures to be thread-safe. We have to unlock our mutex before calling
+    // our listeners!
+    for (auto & elem : rHashMap)
+    {
+        UIElementData& rElement = elem.second;
+        if ( !rElement.bDefault )
+        {
+            // Remove user-defined settings from document
+            ConfigurationEvent aEvent;
+            aEvent.ResourceURL = rElement.aResourceURL;
+            aEvent.Accessor <<= xThis;
+            aEvent.Source = xIfac;
+            aEvent.Element <<= rElement.xSettings;
+
+            rRemoveNotifyContainer.push_back( aEvent );
+
+            // Mark element as default.
+            rElement.bModified = false;
+            rElement.bDefault  = true;
+        }
+        else
+            rElement.bModified = false;
+    }
+
+    // Remove all settings from our user interface elements
+    rHashMap.clear();
+}
+
+void UIConfigurationManager::impl_reloadElementTypeData(
+    UIElementType&              rDocElementType,
+    ConfigEventNotifyContainer& rRemoveNotifyContainer,
+    ConfigEventNotifyContainer& rReplaceNotifyContainer )
+{
+    UIElementDataHashMap& rHashMap          = rDocElementType.aElementsHashMap;
+    Reference< XStorage > xElementStorage( rDocElementType.xStorage );
+
+    Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+    Reference< XInterface > xIfac( xThis, UNO_QUERY );
+    sal_Int16 nType = rDocElementType.nElementType;
+
+    for (auto & elem : rHashMap)
+    {
+        UIElementData& rElement = elem.second;
+        if ( rElement.bModified )
+        {
+            if ( xElementStorage->hasByName( rElement.aName ))
+            {
+                // Replace settings with data from user layer
+                Reference< XIndexAccess > xOldSettings( rElement.xSettings );
+
+                impl_requestUIElementData( nType, rElement );
+
+                ConfigurationEvent aReplaceEvent;
+
+                aReplaceEvent.ResourceURL = rElement.aResourceURL;
+                aReplaceEvent.Accessor <<= xThis;
+                aReplaceEvent.Source = xIfac;
+                aReplaceEvent.ReplacedElement <<= xOldSettings;
+                aReplaceEvent.Element <<= rElement.xSettings;
+                rReplaceNotifyContainer.push_back( aReplaceEvent );
+
+                rElement.bModified = false;
+            }
+            else
+            {
+                // Element settings are not in any storage => remove
+                ConfigurationEvent aRemoveEvent;
+
+                aRemoveEvent.ResourceURL = rElement.aResourceURL;
+                aRemoveEvent.Accessor <<= xThis;
+                aRemoveEvent.Source = xIfac;
+                aRemoveEvent.Element <<= rElement.xSettings;
+
+                rRemoveNotifyContainer.push_back( aRemoveEvent );
+
+                // Mark element as default and not modified. That means "not active" in the document anymore
+                rElement.bModified = false;
+                rElement.bDefault  = true;
+            }
+        }
+    }
+
+    rDocElementType.bModified = false;
+}
+
+void UIConfigurationManager::impl_Initialize()
+{
+    // Initialize the top-level structures with the storage data
+    if ( m_xDocConfigStorage.is() )
+    {
+        long nModes = m_bReadOnly ? ElementModes::READ : ElementModes::READWRITE;
+
+        // Try to access our module sub folder
+        for ( sal_Int16 i = 1; i < css::ui::UIElementType::COUNT;
+              i++ )
+        {
+            Reference< XStorage > xElementTypeStorage;
+            try
+            {
+                xElementTypeStorage = m_xDocConfigStorage->openStorageElement( UIELEMENTTYPENAMES[i], 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& )
+            {
+            }
+
+            m_aUIElements[i].nElementType = i;
+            m_aUIElements[i].bModified = false;
+            m_aUIElements[i].xStorage = xElementTypeStorage;
+        }
+    }
+    else
+    {
+        // We have no storage, just initialize ui element types with empty storage!
+        for ( int i = 1; i < css::ui::UIElementType::COUNT; i++ )
+            m_aUIElements[i].xStorage = m_xDocConfigStorage;
+    }
+}
+
+UIConfigurationManager::UIConfigurationManager( const css::uno::Reference< css::uno::XComponentContext > & rxContext ) :
+      m_bReadOnly( true )
+    , m_bModified( false )
+    , m_bDisposed( false )
+    , m_aPropUIName( "UIName" )
+    , m_xContext( rxContext )
+    , m_aListenerContainer( m_mutex )
+{
+    // Make sure we have a default initialized entry for every layer and user interface element type!
+    // The following code depends on this!
+    m_aUIElements.resize( css::ui::UIElementType::COUNT );
+}
+
+// XComponent
+void SAL_CALL UIConfigurationManager::dispose()
+{
+    Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
+
+    css::lang::EventObject aEvent( xThis );
+    m_aListenerContainer.disposeAndClear( aEvent );
+
+    {
+        SolarMutexGuard g;
+        try
+        {
+            if ( m_xImageManager.is() )
+                m_xImageManager->dispose();
+        }
+        catch ( const Exception& )
+        {
+        }
+
+        m_xImageManager.clear();
+        m_aUIElements.clear();
+        m_xDocConfigStorage.clear();
+        m_bModified = false;
+        m_bDisposed = true;
+    }
+}
+
+void SAL_CALL UIConfigurationManager::addEventListener( const Reference< XEventListener >& xListener )
+{
+    {
+        SolarMutexGuard g;
+
+        /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+        if ( m_bDisposed )
+            throw DisposedException();
+    }
+
+    m_aListenerContainer.addInterface( cppu::UnoType<XEventListener>::get(), xListener );
+}
+
+void SAL_CALL UIConfigurationManager::removeEventListener( const Reference< XEventListener >& xListener )
+{
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    m_aListenerContainer.removeInterface( cppu::UnoType<XEventListener>::get(), xListener );
+}
+
+// XUIConfigurationManager
+void SAL_CALL UIConfigurationManager::addConfigurationListener( const Reference< css::ui::XUIConfigurationListener >& xListener )
+{
+    {
+        SolarMutexGuard g;
+
+        /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+        if ( m_bDisposed )
+            throw DisposedException();
+    }
+
+    m_aListenerContainer.addInterface( cppu::UnoType<XUIConfigurationListener>::get(), xListener );
+}
+
+void SAL_CALL UIConfigurationManager::removeConfigurationListener( const Reference< css::ui::XUIConfigurationListener >& xListener )
+{
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    m_aListenerContainer.removeInterface( cppu::UnoType<XUIConfigurationListener>::get(), xListener );
+}
+
+void SAL_CALL UIConfigurationManager::reset()
+{
+    SolarMutexClearableGuard aGuard;
+
+    /* SAFE AREA ----------------------------------------------------------------------------------------------- */
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( isReadOnly() )
+        return;
+
+    if ( !m_xDocConfigStorage.is() )
+        return;
+
+    try
+    {
+        // Remove all elements from our user-defined storage!
+        bool bCommit( false );
+        for ( int i = 1; i < css::ui::UIElementType::COUNT; i++ )
+        {
+            UIElementType&        rElementType = m_aUIElements[i];
+
+            if ( rElementType.xStorage.is() )
+            {
+                bool bCommitSubStorage( false );
+                const Sequence< OUString > aUIElementStreamNames = rElementType.xStorage->getElementNames();
+                for ( OUString const & rStreamName : aUIElementStreamNames )
+                {
+                    rElementType.xStorage->removeElement( rStreamName );
+                    bCommitSubStorage = true;
+                    bCommit = true;
+                }
+
+                if ( bCommitSubStorage )
+                {
+                    Reference< XTransactedObject > xTransactedObject( rElementType.xStorage, UNO_QUERY );
+                    if ( xTransactedObject.is() )
+                        xTransactedObject->commit();
+                }
+            }
+        }
+
+        // Commit changes
+        if ( bCommit )
+        {
+            Reference< XTransactedObject > xTransactedObject( m_xDocConfigStorage, UNO_QUERY );
+            if ( xTransactedObject.is() )
+                xTransactedObject->commit();
+        }
+
+        // remove settings from user defined layer and notify listener about removed settings data!
+        // Try to access our module sub folder
+        ConfigEventNotifyContainer aRemoveEventNotifyContainer;
+        for ( sal_Int16 j = 1; j < css::ui::UIElementType::COUNT; j++ )
+        {
+            UIElementType& rDocElementType = m_aUIElements[j];
+
+            impl_resetElementTypeData( rDocElementType, aRemoveEventNotifyContainer );
+            rDocElementType.bModified = false;
+        }
+
+        m_bModified = false;
+
+        // Unlock mutex before notify our listeners
+        aGuard.clear();
+
+        // Notify our listeners
+        for (const ConfigurationEvent & k : aRemoveEventNotifyContainer)
+            implts_notifyContainerListener( k, NotifyOp_Remove );
+    }
+    catch ( const css::lang::IllegalArgumentException& )
+    {
+    }
+    catch ( const css::container::NoSuchElementException& )
+    {
+    }
+    catch ( const css::embed::InvalidStorageException& )
+    {
+    }
+    catch ( const css::embed::StorageWrappedTargetException& )
+    {
+    }
+}
+
+Sequence< Sequence< PropertyValue > > SAL_CALL UIConfigurationManager::getUIElementsInfo( sal_Int16 ElementType )
+{
+    if (( ElementType < 0 ) || ( ElementType >= css::ui::UIElementType::COUNT ))
+        throw IllegalArgumentException();
+
+    SolarMutexGuard g;
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    std::vector< Sequence< PropertyValue > > aElementInfoSeq;
+    UIElementInfoHashMap aUIElementInfoCollection;
+
+    if ( ElementType == css::ui::UIElementType::UNKNOWN )
+    {
+        for ( sal_Int16 i = 0; i < css::ui::UIElementType::COUNT; i++ )
+            impl_fillSequenceWithElementTypeInfo( aUIElementInfoCollection, i );
+    }
+    else
+        impl_fillSequenceWithElementTypeInfo( aUIElementInfoCollection, ElementType );
+
+    Sequence< PropertyValue > aUIElementInfo( 2 );
+    aUIElementInfo[0].Name = "ResourceURL";
+    aUIElementInfo[1].Name = m_aPropUIName;
+
+    aElementInfoSeq.resize( aUIElementInfoCollection.size() );
+    sal_Int32 n = 0;
+    for (auto const& elem : aUIElementInfoCollection)
+    {
+        aUIElementInfo[0].Value <<= elem.second.aResourceURL;
+        aUIElementInfo[1].Value <<= elem.second.aUIName;
+        aElementInfoSeq[n++] = aUIElementInfo;
+    }
+
+    return comphelper::containerToSequence(aElementInfoSeq);
+}
+
+Reference< XIndexContainer > SAL_CALL UIConfigurationManager::createSettings()
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    // Creates an empty item container which can be filled from outside
+    return Reference< XIndexContainer >( static_cast< OWeakObject * >( new RootItemContainer()), UNO_QUERY );
+}
+
+sal_Bool SAL_CALL UIConfigurationManager::hasSettings( const OUString& ResourceURL )
+{
+    sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL );
+
+    if (( nElementType == css::ui::UIElementType::UNKNOWN ) ||
+        ( nElementType >= css::ui::UIElementType::COUNT   ))
+        throw IllegalArgumentException();
+    UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType, false );
+    if ( pDataSettings && !pDataSettings->bDefault )
+        return true;
+
+    return false;
+}
+
+Reference< XIndexAccess > SAL_CALL UIConfigurationManager::getSettings( const OUString& ResourceURL, sal_Bool bWriteable )
+{
+    sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL );
+
+    if (( nElementType == css::ui::UIElementType::UNKNOWN ) ||
+        ( nElementType >= css::ui::UIElementType::COUNT   ))
+        throw IllegalArgumentException();
+
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType );
+    if ( pDataSettings && !pDataSettings->bDefault )
+    {
+        // Create a copy of our data if someone wants to change the data.
+        if ( bWriteable )
+            return Reference< XIndexAccess >( static_cast< OWeakObject * >( new RootItemContainer( pDataSettings->xSettings ) ), UNO_QUERY );
+        else
+            return pDataSettings->xSettings;
+    }
+
+    throw NoSuchElementException();
+}
+
+void SAL_CALL UIConfigurationManager::replaceSettings( const OUString& ResourceURL, const Reference< css::container::XIndexAccess >& aNewData )
+{
+    sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL );
+
+    if (( nElementType == css::ui::UIElementType::UNKNOWN ) ||
+        ( nElementType >= css::ui::UIElementType::COUNT   ))
+        throw IllegalArgumentException();
+    else if ( m_bReadOnly )
+        throw IllegalAccessException();
+    else
+    {
+        SolarMutexClearableGuard aGuard;
+
+        if ( m_bDisposed )
+            throw DisposedException();
+
+        UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType );
+        if ( !pDataSettings || pDataSettings->bDefault )
+            throw NoSuchElementException();
+        // we have a settings entry in our user-defined layer - replace
+        Reference< XIndexAccess > xOldSettings = pDataSettings->xSettings;
+
+        // Create a copy of the data if the container is not const
+        Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY );
+        if ( xReplace.is() )
+            pDataSettings->xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY );
+        else
+            pDataSettings->xSettings = aNewData;
+
+        pDataSettings->bDefault  = false;
+        pDataSettings->bModified = true;
+        m_bModified = true;
+
+        // Modify type container
+        UIElementType& rElementType = m_aUIElements[nElementType];
+        rElementType.bModified = true;
+
+        Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+        Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+        // Create event to notify listener about replaced element settings
+        ConfigurationEvent aEvent;
+
+        aEvent.ResourceURL = ResourceURL;
+        aEvent.Accessor <<= xThis;
+        aEvent.Source = xIfac;
+        aEvent.ReplacedElement <<= xOldSettings;
+        aEvent.Element <<= pDataSettings->xSettings;
+
+        aGuard.clear();
+
+        implts_notifyContainerListener( aEvent, NotifyOp_Replace );
+    }
+}
+
+void SAL_CALL UIConfigurationManager::removeSettings( const OUString& ResourceURL )
+{
+    sal_Int16 nElementType = RetrieveTypeFromResourceURL( ResourceURL );
+
+    if (( nElementType == css::ui::UIElementType::UNKNOWN ) ||
+        ( nElementType >= css::ui::UIElementType::COUNT   ))
+        throw IllegalArgumentException( "The ResourceURL is not valid or "
+                                        "describes an unknown type. "
+                                        "ResourceURL: " + ResourceURL, nullptr, 0 );
+    else if ( m_bReadOnly )
+        throw IllegalAccessException( "The configuration manager is read-only. "
+                                      "ResourceURL: " + ResourceURL, nullptr );
+    else
+    {
+        SolarMutexClearableGuard aGuard;
+
+        if ( m_bDisposed )
+            throw DisposedException( "The configuration manager has been disposed, "
+                                     "and can't uphold its method specification anymore. "
+                                     "ResourceURL: " + ResourceURL, nullptr );
+
+        UIElementData* pDataSettings = impl_findUIElementData( ResourceURL, nElementType );
+        if ( !pDataSettings )
+            throw NoSuchElementException( "The settings data cannot be found. "
+                                          "ResourceURL: " + ResourceURL, nullptr);
+        // If element settings are default, we don't need to change anything!
+        if ( pDataSettings->bDefault )
+            return;
+        else
+        {
+            Reference< XIndexAccess > xRemovedSettings = pDataSettings->xSettings;
+            pDataSettings->bDefault = true;
+
+            // check if this is a default layer node
+            pDataSettings->bModified = true; // we have to remove this node from the user layer!
+            pDataSettings->xSettings.clear();
+            m_bModified = true; // user layer must be written
+
+            // Modify type container
+            UIElementType& rElementType = m_aUIElements[nElementType];
+            rElementType.bModified = true;
+
+            Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+            Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+            // Create event to notify listener about removed element settings
+            ConfigurationEvent aEvent;
+
+            aEvent.ResourceURL = ResourceURL;
+            aEvent.Accessor <<= xThis;
+            aEvent.Source = xIfac;
+            aEvent.Element <<= xRemovedSettings;
+
+            aGuard.clear();
+
+            implts_notifyContainerListener( aEvent, NotifyOp_Remove );
+        }
+    }
+}
+
+void SAL_CALL UIConfigurationManager::insertSettings( const OUString& NewResourceURL, const Reference< XIndexAccess >& aNewData )
+{
+    sal_Int16 nElementType = RetrieveTypeFromResourceURL( NewResourceURL );
+
+    if (( nElementType == css::ui::UIElementType::UNKNOWN ) ||
+        ( nElementType >= css::ui::UIElementType::COUNT   ))
+        throw IllegalArgumentException();
+    else if ( m_bReadOnly )
+        throw IllegalAccessException();
+    else
+    {
+        SolarMutexClearableGuard aGuard;
+
+        if ( m_bDisposed )
+            throw DisposedException();
+
+        bool           bInsertData( false );
+        UIElementData  aUIElementData;
+        UIElementData* pDataSettings = impl_findUIElementData( NewResourceURL, nElementType );
+
+        if ( pDataSettings && !pDataSettings->bDefault )
+            throw ElementExistException();
+
+        if ( !pDataSettings )
+        {
+            pDataSettings = &aUIElementData;
+            bInsertData   = true;
+        }
+
+        {
+            pDataSettings->bDefault     = false;
+            pDataSettings->bModified    = true;
+
+            // Create a copy of the data if the container is not const
+            Reference< XIndexReplace > xReplace( aNewData, UNO_QUERY );
+            if ( xReplace.is() )
+                pDataSettings->xSettings.set( static_cast< OWeakObject * >( new ConstItemContainer( aNewData ) ), UNO_QUERY );
+            else
+                pDataSettings->xSettings = aNewData;
+
+            m_bModified = true;
+
+            UIElementType& rElementType = m_aUIElements[nElementType];
+            rElementType.bModified = true;
+
+            if ( bInsertData )
+            {
+                pDataSettings->aName        = RetrieveNameFromResourceURL( NewResourceURL ) + ".xml";
+                pDataSettings->aResourceURL = NewResourceURL;
+
+                UIElementDataHashMap& rElements = rElementType.aElementsHashMap;
+                rElements.emplace( NewResourceURL, *pDataSettings );
+            }
+
+            Reference< XIndexAccess > xInsertSettings( aUIElementData.xSettings );
+            Reference< XUIConfigurationManager > xThis( static_cast< OWeakObject* >( this ), UNO_QUERY );
+            Reference< XInterface > xIfac( xThis, UNO_QUERY );
+
+            // Create event to notify listener about removed element settings
+            ConfigurationEvent aEvent;
+
+            aEvent.ResourceURL = NewResourceURL;
+            aEvent.Accessor <<= xThis;
+            aEvent.Source = xIfac;
+            aEvent.Element <<= xInsertSettings;
+
+            aGuard.clear();
+
+            implts_notifyContainerListener( aEvent, NotifyOp_Insert );
+        }
+    }
+}
+
+Reference< XInterface > SAL_CALL UIConfigurationManager::getImageManager()
+{
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( !m_xImageManager.is() )
+    {
+        m_xImageManager.set( static_cast< cppu::OWeakObject *>( new ImageManager( m_xContext )),
+                             UNO_QUERY );
+        Reference< XInitialization > xInit( m_xImageManager, UNO_QUERY );
+
+        Sequence<Any> aPropSeq(comphelper::InitAnyPropertySequence(
+        {
+            {"UserConfigStorage", Any(m_xDocConfigStorage)},
+            {"ModuleIdentifier", Any(OUString())},
+        }));
+
+        xInit->initialize( aPropSeq );
+    }
+
+    return Reference< XInterface >( m_xImageManager, UNO_QUERY );
+}
+
+Reference< XAcceleratorConfiguration > SAL_CALL UIConfigurationManager::getShortCutManager()
+{
+    // SAFE ->
+    SolarMutexGuard g;
+
+    if (!m_xAccConfig.is()) try
+    {
+        m_xAccConfig = DocumentAcceleratorConfiguration::
+            createWithDocumentRoot(m_xContext, m_xDocConfigStorage);
+    }
+    catch ( const css::uno::DeploymentException& )
+    {
+        SAL_WARN("fwk.uiconfiguration", "DocumentAcceleratorConfiguration"
+                " not available. This should happen only on mobile platforms.");
+    }
+
+    return m_xAccConfig;
+}
+
+Reference< XInterface > SAL_CALL UIConfigurationManager::getEventsManager()
+{
+    return Reference< XInterface >();
+}
+
+// XUIConfigurationStorage
+void SAL_CALL UIConfigurationManager::setStorage( const Reference< XStorage >& Storage )
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( m_xDocConfigStorage.is() )
+    {
+        try
+        {
+            // Dispose old storage to be sure that it will be closed
+            m_xDocConfigStorage->dispose();
+        }
+        catch ( const Exception& )
+        {
+        }
+    }
+
+    // We store the new storage. Be careful it could be an empty reference!
+    m_xDocConfigStorage = Storage;
+    m_bReadOnly         = true;
+
+    if ( m_xAccConfig.is() )
+        m_xAccConfig->setStorage( m_xDocConfigStorage );
+
+    if ( m_xImageManager.is() )
+    {
+        ImageManager* pImageManager = static_cast<ImageManager*>(m_xImageManager.get());
+        if ( pImageManager )
+            pImageManager->setStorage( m_xDocConfigStorage );
+    }
+
+    if ( m_xDocConfigStorage.is() )
+    {
+        Reference< XPropertySet > xPropSet( m_xDocConfigStorage, UNO_QUERY );
+        if ( xPropSet.is() )
+        {
+            try
+            {
+                long nOpenMode = 0;
+                Any a = xPropSet->getPropertyValue("OpenMode");
+                if ( a >>= nOpenMode )
+                    m_bReadOnly = !( nOpenMode & ElementModes::WRITE );
+            }
+            catch ( const css::beans::UnknownPropertyException& )
+            {
+            }
+            catch ( const css::lang::WrappedTargetException& )
+            {
+            }
+        }
+    }
+
+    impl_Initialize();
+}
+
+sal_Bool SAL_CALL UIConfigurationManager::hasStorage()
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    return m_xDocConfigStorage.is();
+}
+
+// XUIConfigurationPersistence
+void SAL_CALL UIConfigurationManager::reload()
+{
+    SolarMutexClearableGuard aGuard;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( !(m_xDocConfigStorage.is() && m_bModified && !m_bReadOnly) )
+        return;
+
+    // Try to access our module sub folder
+    ConfigEventNotifyContainer aRemoveNotifyContainer;
+    ConfigEventNotifyContainer aReplaceNotifyContainer;
+    for ( sal_Int16 i = 1; i < css::ui::UIElementType::COUNT; i++ )
+    {
+        try
+        {
+            UIElementType& rDocElementType = m_aUIElements[i];
+            if ( rDocElementType.bModified )
+                impl_reloadElementTypeData( rDocElementType, aRemoveNotifyContainer, aReplaceNotifyContainer );
+        }
+        catch ( const Exception& )
+        {
+            throw IOException();
+        }
+    }
+
+    m_bModified = false;
+
+    // Unlock mutex before notify our listeners
+    aGuard.clear();
+
+    // Notify our listeners
+    for (const ConfigurationEvent & j : aRemoveNotifyContainer)
+        implts_notifyContainerListener( j, NotifyOp_Remove );
+    for (const ConfigurationEvent & k : aReplaceNotifyContainer)
+        implts_notifyContainerListener( k, NotifyOp_Replace );
+}
+
+void SAL_CALL UIConfigurationManager::store()
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( !(m_xDocConfigStorage.is() && m_bModified && !m_bReadOnly) )
+        return;
+
+    // Try to access our module sub folder
+    for ( int i = 1; i < css::ui::UIElementType::COUNT; i++ )
+    {
+        try
+        {
+            UIElementType& rElementType = m_aUIElements[i];
+
+            if ( rElementType.bModified && rElementType.xStorage.is() )
+                impl_storeElementTypeData( rElementType.xStorage, rElementType );
+        }
+        catch ( const Exception& )
+        {
+            throw IOException();
+        }
+    }
+
+    m_bModified = false;
+    Reference< XTransactedObject > xTransactedObject( m_xDocConfigStorage, UNO_QUERY );
+    if ( xTransactedObject.is() )
+        xTransactedObject->commit();
+}
+
+void SAL_CALL UIConfigurationManager::storeToStorage( const Reference< XStorage >& Storage )
+{
+    SolarMutexGuard g;
+
+    if ( m_bDisposed )
+        throw DisposedException();
+
+    if ( !(m_xDocConfigStorage.is() && m_bModified && !m_bReadOnly) )
+        return;
+
+    // Try to access our module sub folder
+    for ( int i = 1; i < css::ui::UIElementType::COUNT; i++ )
+    {
+        try
+        {
+            Reference< XStorage > xElementTypeStorage( Storage->openStorageElement(
+                                                        UIELEMENTTYPENAMES[i], ElementModes::READWRITE ));
+            UIElementType& rElementType = m_aUIElements[i];
+
+            if ( rElementType.bModified && xElementTypeStorage.is() )
+                impl_storeElementTypeData( xElementTypeStorage, rElementType, false ); // store data to storage, but don't reset modify flag!
+        }
+        catch ( const Exception& )
+        {
+            throw IOException();
+        }
+    }
+
+    Reference< XTransactedObject > xTransactedObject( Storage, UNO_QUERY );
+    if ( xTransactedObject.is() )
+        xTransactedObject->commit();
+}
+
+sal_Bool SAL_CALL UIConfigurationManager::isModified()
+{
+    SolarMutexGuard g;
+
+    return m_bModified;
+}
+
+sal_Bool SAL_CALL UIConfigurationManager::isReadOnly()
+{
+    SolarMutexGuard g;
+
+    return m_bReadOnly;
+}
+
+void UIConfigurationManager::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();
+        }
+    }
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_framework_UIConfigurationManager_get_implementation(
+    css::uno::XComponentContext *context,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new UIConfigurationManager(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */