/* -*- 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 <accelerators/presethandler.hxx>

#include <uiconfiguration/imagemanager.hxx>

#include <uielement/constitemcontainer.hxx>

#include <uielement/rootitemcontainer.hxx>

#include <uielement/uielementtypenames.hxx>

#include <menuconfiguration.hxx>

#include <toolboxconfiguration.hxx>

#include <statusbarconfiguration.hxx>

#include <com/sun/star/ui/UIElementType.hpp>

#include <com/sun/star/ui/ConfigurationEvent.hpp>

#include <com/sun/star/ui/ModuleAcceleratorConfiguration.hpp>

#include <com/sun/star/ui/XModuleUIConfigurationManager2.hpp>

#include <com/sun/star/lang/DisposedException.hpp>

#include <com/sun/star/lang/IllegalAccessException.hpp>

#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>

#include <com/sun/star/beans/XPropertySet.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/container/ElementExistException.hpp>

#include <com/sun/star/container/XNameAccess.hpp>

#include <com/sun/star/container/XIndexContainer.hpp>

#include <com/sun/star/io/IOException.hpp>

#include <com/sun/star/io/XStream.hpp>

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <com/sun/star/lang/XComponent.hpp>

#include <comphelper/propertysequence.hxx>

#include <comphelper/sequence.hxx>

#include <cppuhelper/exc_hlp.hxx>

#include <cppuhelper/implbase.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <utility>

#include <vcl/svapp.hxx>

#include <sal/log.hxx>

#include <comphelper/interfacecontainer4.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <comphelper/servicehelper.hxx>

#include <o3tl/string_view.hxx>

#include <memory>

#include <mutex>

#include <string_view>

using namespace css;

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 framework;

constexpr OUStringLiteral RESOURCETYPE_MENUBAR = u"menubar";

constexpr OUStringLiteral RESOURCETYPE_TOOLBAR = u"toolbar";

constexpr OUStringLiteral RESOURCETYPE_STATUSBAR = u"statusbar";

constexpr OUStringLiteral RESOURCETYPE_POPUPMENU = u"popupmenu";

namespace {

class ModuleUIConfigurationManager : public cppu::WeakImplHelper<

                                       css::lang::XServiceInfo,

                                       css::lang::XComponent,

                                       css::ui::XModuleUIConfigurationManager2 >

{

public:

    ModuleUIConfigurationManager(

            const css::uno::Reference< css::uno::XComponentContext >& xServiceManager,

            const css::uno::Sequence< css::uno::Any >& aArguments);

    virtual OUString SAL_CALL getImplementationName() override

    {

        return u"com.sun.star.comp.framework.ModuleUIConfigurationManager"_ustr;

    }

    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 {u"com.sun.star.ui.ModuleUIConfigurationManager"_ustr};

    }

    // 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::ui::XAcceleratorConfiguration > SAL_CALL createShortCutManager() override;

    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getEventsManager() override;

    // XModuleUIConfigurationManager

    virtual sal_Bool SAL_CALL isDefaultSettings( const OUString& ResourceURL ) override;

    virtual css::uno::Reference< css::container::XIndexAccess > SAL_CALL getDefaultSettings( const OUString& ResourceURL ) 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;

private:

    // private data types

    enum Layer

    {

        LAYER_DEFAULT,

        LAYER_USERDEFINED,

        LAYER_COUNT

    };

    enum NotifyOp

    {

        NotifyOp_Remove,

        NotifyOp_Insert,

        NotifyOp_Replace

    };

    struct UIElementInfo

    {

        UIElementInfo( OUString _aResourceURL, OUString _aUIName ) :

            aResourceURL(std::move( _aResourceURL)), aUIName(std::move( _aUIName )) {}

        OUString   aResourceURL;

        OUString   aUIName;

    };

    struct UIElementData

    {

        UIElementData() : bModified( false ), bDefault( true ), bDefaultNode( true ) {};

        OUString aResourceURL;

        OUString aName;

        bool          bModified;        // has been changed since last storing

        bool          bDefault;         // default settings

        bool          bDefaultNode;     // this is a default layer element data

        css::uno::Reference< css::container::XIndexAccess > xSettings;

    };

    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( Layer eLayer, sal_Int16 nElementType );

    UIElementData*  impl_findUIElementData( const OUString& aResourceURL, sal_Int16 nElementType, bool bLoad = true );

    void            impl_requestUIElementData( sal_Int16 nElementType, Layer eLayer, UIElementData& aUIElementData );

    void            impl_storeElementTypeData( const css::uno::Reference< css::embed::XStorage >& xStorage, UIElementType& rElementType, bool bResetModifyState = true );

    void            impl_resetElementTypeData( UIElementType& rUserElementType, UIElementType const & rDefaultElementType, ConfigEventNotifyContainer& rRemoveNotifyContainer, ConfigEventNotifyContainer& rReplaceNotifyContainer );

    void            impl_reloadElementTypeData( UIElementType& rUserElementType, UIElementType const & rDefaultElementType, ConfigEventNotifyContainer& rRemoveNotifyContainer, ConfigEventNotifyContainer& rReplaceNotifyContainer );

    UIElementTypesVector                                      m_aUIElements[LAYER_COUNT];

    std::unique_ptr<PresetHandler>                            m_pStorageHandler[css::ui::UIElementType::COUNT];

    css::uno::Reference< css::embed::XStorage >               m_xDefaultConfigStorage;

    css::uno::Reference< css::embed::XStorage >               m_xUserConfigStorage;

    bool                                                      m_bReadOnly;

    bool                                                      m_bModified;

    bool                                                      m_bDisposed;

    OUString                                                  m_aXMLPostfix;

    OUString                                                  m_aPropUIName;

    OUString                                                  m_aModuleIdentifier;

    css::uno::Reference< css::embed::XTransactedObject >      m_xUserRootCommit;

    css::uno::Reference< css::uno::XComponentContext >        m_xContext;

    std::mutex                                                m_mutex;

    comphelper::OInterfaceContainerHelper4<css::lang::XEventListener> m_aEventListeners;

    comphelper::OInterfaceContainerHelper4<css::ui::XUIConfigurationListener> m_aConfigListeners;

    rtl::Reference< ImageManager >                            m_xModuleImageManager;

    css::uno::Reference< css::ui::XAcceleratorConfiguration > m_xModuleAcceleratorManager;

};

// important: The order and position of the elements must match the constant

// definition of "css::ui::UIElementType"

constexpr std::u16string_view UIELEMENTTYPENAMES[] =

{

    u"",  // Dummy value for unknown!

    u"" UIELEMENTTYPE_MENUBAR_NAME,

    u"" UIELEMENTTYPE_POPUPMENU_NAME,

    u"" UIELEMENTTYPE_TOOLBAR_NAME,

    u"" UIELEMENTTYPE_STATUSBAR_NAME,

    u"" UIELEMENTTYPE_FLOATINGWINDOW_NAME,

    u"" UIELEMENTTYPE_PROGRESSBAR_NAME,

    u"" UIELEMENTTYPE_TOOLPANEL_NAME

};

constexpr std::u16string_view RESOURCEURL_PREFIX = u"private:resource/";

sal_Int16 RetrieveTypeFromResourceURL( std::u16string_view aResourceURL )

{

    if (( o3tl::starts_with(aResourceURL, RESOURCEURL_PREFIX ) ) &&

        ( aResourceURL.size() > RESOURCEURL_PREFIX.size() ))

    {

        std::u16string_view aTmpStr = aResourceURL.substr( RESOURCEURL_PREFIX.size() );

        size_t nIndex = aTmpStr.find( '/' );

        if (( nIndex > 0 ) &&  ( aTmpStr.size() > nIndex ))

        {

            std::u16string_view aTypeStr( aTmpStr.substr( 0, nIndex ));

            for ( int i = 0; i < ui::UIElementType::COUNT; i++ )

            {

                if ( aTypeStr == UIELEMENTTYPENAMES[i] )

                    return sal_Int16( i );

            }

        }

    }

    return ui::UIElementType::UNKNOWN;

}

OUString RetrieveNameFromResourceURL( std::u16string_view aResourceURL )

{

    if (( o3tl::starts_with(aResourceURL, RESOURCEURL_PREFIX ) ) &&

        ( aResourceURL.size() > RESOURCEURL_PREFIX.size() ))

    {

        size_t nIndex = aResourceURL.rfind( '/' );

        if ( nIndex > 0 && nIndex != std::u16string_view::npos && (( nIndex+1 ) < aResourceURL.size()) )

            return OUString(aResourceURL.substr( nIndex+1 ));

    }

    return OUString();

}

void ModuleUIConfigurationManager::impl_fillSequenceWithElementTypeInfo( UIElementInfoHashMap& aUIElementInfoCollection, sal_Int16 nElementType )

{

    // preload list of element types on demand

    impl_preloadUIElementTypeList( LAYER_USERDEFINED, nElementType );

    impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType );

    UIElementDataHashMap& rUserElements = m_aUIElements[LAYER_USERDEFINED][nElementType].aElementsHashMap;

    OUString aCustomUrlPrefix( u"custom_"_ustr );

    for (auto const& userElement : rUserElements)

    {

        sal_Int32 nIndex = userElement.second.aResourceURL.indexOf( aCustomUrlPrefix, RESOURCEURL_PREFIX.size() );

        if ( nIndex > static_cast<sal_Int32>(RESOURCEURL_PREFIX.size()) )

        {

            // Performance: Retrieve user interface name only for custom user interface elements.

            // It's only used by them!

            UIElementData* pDataSettings = impl_findUIElementData( userElement.second.aResourceURL, nElementType );

            if ( pDataSettings )

            {

                // 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( userElement.second.aResourceURL, aUIName );

                aUIElementInfoCollection.emplace( userElement.second.aResourceURL, aInfo );

            }

        }

        else

        {

            // The user interface name for standard user interface elements is stored in the WindowState.xcu file

            UIElementInfo aInfo( userElement.second.aResourceURL, OUString() );

            aUIElementInfoCollection.emplace( userElement.second.aResourceURL, aInfo );

        }

    }

    UIElementDataHashMap& rDefaultElements = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap;

    for (auto const& defaultElement : rDefaultElements)

    {

        UIElementInfoHashMap::const_iterator pIterInfo = aUIElementInfoCollection.find( defaultElement.second.aResourceURL );

        if ( pIterInfo == aUIElementInfoCollection.end() )

        {

            sal_Int32 nIndex = defaultElement.second.aResourceURL.indexOf( aCustomUrlPrefix, RESOURCEURL_PREFIX.size() );

            if ( nIndex > static_cast<sal_Int32>(RESOURCEURL_PREFIX.size()) )

            {

                // Performance: Retrieve user interface name only for custom user interface elements.

                // It's only used by them!

                UIElementData* pDataSettings = impl_findUIElementData( defaultElement.second.aResourceURL, nElementType );

                if ( pDataSettings )

                {

                    // 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( defaultElement.second.aResourceURL, aUIName );

                    aUIElementInfoCollection.emplace( defaultElement.second.aResourceURL, aInfo );

                }

            }

            else

            {

                // The user interface name for standard user interface elements is stored in the WindowState.xcu file

                UIElementInfo aInfo( defaultElement.second.aResourceURL, OUString() );

                aUIElementInfoCollection.emplace( defaultElement.second.aResourceURL, aInfo );

            }

        }

    }

}

void ModuleUIConfigurationManager::impl_preloadUIElementTypeList( Layer eLayer, sal_Int16 nElementType )

{

    UIElementType& rElementTypeData = m_aUIElements[eLayer][nElementType];

    if ( rElementTypeData.bLoaded )

        return;

    Reference< XStorage > xElementTypeStorage = rElementTypeData.xStorage;

    if ( !xElementTypeStorage.is() )

        return;

    OUString aResURLPrefix =

        OUString::Concat(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() ))

        {

            std::u16string_view aExtension( rElementName.subView( nIndex+1 ));

            std::u16string_view aUIElementName( rElementName.subView( 0, nIndex ));

            if (!aUIElementName.empty() &&

                ( o3tl::equalsIgnoreAsciiCase(aExtension, u"xml")))

            {

                aUIElementData.aResourceURL = aResURLPrefix + aUIElementName;

                aUIElementData.aName        = rElementName;

                if ( eLayer == LAYER_USERDEFINED )

                {

                    aUIElementData.bModified    = false;

                    aUIElementData.bDefault     = false;

                    aUIElementData.bDefaultNode = false;

                }

                // Create std::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 ModuleUIConfigurationManager::impl_requestUIElementData( sal_Int16 nElementType, Layer eLayer, UIElementData& aUIElementData )

{

    UIElementType& rElementTypeData = m_aUIElements[eLayer][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 = dynamic_cast<RootItemContainer*>( xContainer.get() );

                            if ( pRootItemContainer )

                                aUIElementData.xSettings = new ConstItemContainer( pRootItemContainer, true );

                            else

                                aUIElementData.xSettings = new ConstItemContainer( xContainer, true );

                            return;

                        }

                        catch ( const css::lang::WrappedTargetException& )

                        {

                        }

                    }

                    break;

                    case css::ui::UIElementType::TOOLBAR:

                    {

                        try

                        {

                            Reference< XIndexContainer > xIndexContainer( new RootItemContainer() );

                            ToolBoxConfiguration::LoadToolBox( m_xContext, xInputStream, xIndexContainer );

                            auto pRootItemContainer = dynamic_cast<RootItemContainer*>( xIndexContainer.get() );

                            aUIElementData.xSettings = new ConstItemContainer( pRootItemContainer, true );

                            return;

                        }

                        catch ( const css::lang::WrappedTargetException& )

                        {

                        }

                        break;

                    }

                    case css::ui::UIElementType::STATUSBAR:

                    {

                        try

                        {

                            Reference< XIndexContainer > xIndexContainer( new RootItemContainer() );

                            StatusBarConfiguration::LoadStatusBar( m_xContext, xInputStream, xIndexContainer );

                            auto pRootItemContainer = dynamic_cast<RootItemContainer*>( xIndexContainer.get() );

                            aUIElementData.xSettings = new ConstItemContainer( pRootItemContainer, true );

                            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 = new ConstItemContainer();

}

ModuleUIConfigurationManager::UIElementData*  ModuleUIConfigurationManager::impl_findUIElementData( const OUString& aResourceURL, sal_Int16 nElementType, bool bLoad )

{

    // preload list of element types on demand

    impl_preloadUIElementTypeList( LAYER_USERDEFINED, nElementType );

    impl_preloadUIElementTypeList( LAYER_DEFAULT, nElementType );

    // first try to look into our user-defined vector/unordered_map combination

    UIElementDataHashMap& rUserHashMap = m_aUIElements[LAYER_USERDEFINED][nElementType].aElementsHashMap;

    UIElementDataHashMap::iterator pIter = rUserHashMap.find( aResourceURL );

    if ( pIter != rUserHashMap.end() )

    {

        // Default data settings data must be retrieved from the default layer!

        if ( !pIter->second.bDefault )

        {

            if ( !pIter->second.xSettings.is() && bLoad )

                impl_requestUIElementData( nElementType, LAYER_USERDEFINED, pIter->second );

            return &(pIter->second);

        }

    }

    // Not successful, we have to look into our default vector/unordered_map combination

    UIElementDataHashMap& rDefaultHashMap = m_aUIElements[LAYER_DEFAULT][nElementType].aElementsHashMap;

    pIter = rDefaultHashMap.find( aResourceURL );

    if ( pIter != rDefaultHashMap.end() )

    {

        if ( !pIter->second.xSettings.is() && bLoad )

            impl_requestUIElementData( nElementType, LAYER_DEFAULT, pIter->second );

        return &(pIter->second);

    }

    // Nothing has been found!

    return nullptr;

}

void ModuleUIConfigurationManager::impl_storeElementTypeData( const Reference< XStorage >& 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;

}

// This is only allowed to be called on the LAYER_USER_DEFINED!

void ModuleUIConfigurationManager::impl_resetElementTypeData(

    UIElementType& rUserElementType,

    UIElementType const & rDefaultElementType,

    ConfigEventNotifyContainer& rRemoveNotifyContainer,

    ConfigEventNotifyContainer& rReplaceNotifyContainer )

{

    UIElementDataHashMap& rHashMap          = rUserElementType.aElementsHashMap;

    Reference< XUIConfigurationManager > xThis(this);

    Reference< XInterface >  xIfac( xThis, UNO_QUERY );

    sal_Int16 nType = rUserElementType.nElementType;

    // 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 )

        {

            if ( rDefaultElementType.xStorage->hasByName( rElement.aName ))

            {

                // Replace settings with data from default layer

                Reference< XIndexAccess > xOldSettings( rElement.xSettings );

                impl_requestUIElementData( nType, LAYER_DEFAULT, rElement );

                ui::ConfigurationEvent aReplaceEvent;

                aReplaceEvent.ResourceURL = rElement.aResourceURL;

                aReplaceEvent.Accessor <<= xThis;

                aReplaceEvent.Source = xIfac;

                aReplaceEvent.ReplacedElement <<= xOldSettings;

                aReplaceEvent.Element <<= rElement.xSettings;

                rReplaceNotifyContainer.push_back( aReplaceEvent );

                // Mark element as default and not modified. That means "not active"

                // in the user layer anymore.

                rElement.bModified = false;

                rElement.bDefault  = true;

            }

            else

            {

                // Remove user-defined settings from user layer

                ui::ConfigurationEvent aEvent;

                aEvent.ResourceURL = rElement.aResourceURL;

                aEvent.Accessor <<= xThis;

                aEvent.Source = xIfac;

                aEvent.Element <<= rElement.xSettings;

                rRemoveNotifyContainer.push_back( aEvent );

                // Mark element as default and not modified. That means "not active"

                // in the user layer anymore.

                rElement.bModified = false;

                rElement.bDefault  = true;

            }

        }

    }

    // Remove all settings from our user interface elements

    rHashMap.clear();

}

void ModuleUIConfigurationManager::impl_reloadElementTypeData(

    UIElementType&              rUserElementType,

    UIElementType const &       rDefaultElementType,

    ConfigEventNotifyContainer& rRemoveNotifyContainer,

    ConfigEventNotifyContainer& rReplaceNotifyContainer )

{

    UIElementDataHashMap& rHashMap          = rUserElementType.aElementsHashMap;

    Reference< XUIConfigurationManager > xThis(this);

    Reference< XInterface > xIfac( xThis, UNO_QUERY );

    sal_Int16 nType = rUserElementType.nElementType;

    for (auto & elem : rHashMap)

    {

        UIElementData& rElement = elem.second;

        if ( rElement.bModified )

        {

            if ( rUserElementType.xStorage->hasByName( rElement.aName ))

            {

                // Replace settings with data from user layer

                Reference< XIndexAccess > xOldSettings( rElement.xSettings );

                impl_requestUIElementData( nType, LAYER_USERDEFINED, rElement );

                ui::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 if ( rDefaultElementType.xStorage->hasByName( rElement.aName ))

            {

                // Replace settings with data from default layer

                Reference< XIndexAccess > xOldSettings( rElement.xSettings );

                impl_requestUIElementData( nType, LAYER_DEFAULT, rElement );

                ui::ConfigurationEvent aReplaceEvent;

                aReplaceEvent.ResourceURL = rElement.aResourceURL;

                aReplaceEvent.Accessor <<= xThis;

                aReplaceEvent.Source = xIfac;

                aReplaceEvent.ReplacedElement <<= xOldSettings;

                aReplaceEvent.Element <<= rElement.xSettings;

                rReplaceNotifyContainer.push_back( aReplaceEvent );

                // Mark element as default and not modified. That means "not active"

                // in the user layer anymore.

                rElement.bModified = false;

                rElement.bDefault  = true;

            }

            else

            {

                // Element settings are not in any storage => remove

                ui::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 user layer anymore.

                rElement.bModified = false;

                rElement.bDefault  = true;

            }

        }

    }

    rUserElementType.bModified = false;

}

void ModuleUIConfigurationManager::impl_Initialize()

{

    // Initialize the top-level structures with the storage data

    if ( m_xUserConfigStorage.is() )

    {

        // Try to access our module sub folder

        for ( sal_Int16 i = 1; i < css::ui::UIElementType::COUNT;

              i++ )

        {

            Reference< XStorage > xElementTypeStorage;

            try

            {

                if ( m_pStorageHandler[i] )

                    xElementTypeStorage = m_pStorageHandler[i]->getWorkingStorageUser();

            }

            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[LAYER_USERDEFINED][i].nElementType = i;

            m_aUIElements[LAYER_USERDEFINED][i].bModified = false;

            m_aUIElements[LAYER_USERDEFINED][i].xStorage = std::move(xElementTypeStorage);

        }

    }

    if ( !m_xDefaultConfigStorage.is() )

        return;

    Reference< XNameAccess > xNameAccess( m_xDefaultConfigStorage, UNO_QUERY_THROW );

    // Try to access our module sub folder

    for ( sal_Int16 i = 1; i < css::ui::UIElementType::COUNT;

          i++ )

    {

        Reference< XStorage > xElementTypeStorage;

        try

        {

            const OUString sName( UIELEMENTTYPENAMES[i] );

            if( xNameAccess->hasByName( sName ) )

                xNameAccess->getByName( sName ) >>= xElementTypeStorage;

        }

        catch ( const css::container::NoSuchElementException& )

        {

        }

        m_aUIElements[LAYER_DEFAULT][i].nElementType = i;

        m_aUIElements[LAYER_DEFAULT][i].bModified = false;

        m_aUIElements[LAYER_DEFAULT][i].xStorage = std::move(xElementTypeStorage);

    }

}

ModuleUIConfigurationManager::ModuleUIConfigurationManager(

        const Reference< XComponentContext >& xContext,

        const css::uno::Sequence< css::uno::Any >& aArguments)

    : m_bReadOnly( true )

    , m_bModified( false )

    , m_bDisposed( false )

    , m_aXMLPostfix( u".xml"_ustr )

    , m_aPropUIName( u"UIName"_ustr )

    , m_xContext( xContext )

{

    // Make sure we have a default initialized entry for every layer and user interface element type!

    // The following code depends on this!

    m_aUIElements[LAYER_DEFAULT].resize( css::ui::UIElementType::COUNT );

    m_aUIElements[LAYER_USERDEFINED].resize( css::ui::UIElementType::COUNT );

    SolarMutexGuard g;

    OUString aModuleShortName;

    if( aArguments.getLength() == 2 && (aArguments[0] >>= aModuleShortName) && (aArguments[1] >>= m_aModuleIdentifier))

    {

    }

    else

    {

        ::comphelper::SequenceAsHashMap lArgs(aArguments);

        aModuleShortName  = lArgs.getUnpackedValueOrDefault(u"ModuleShortName"_ustr, OUString());

        m_aModuleIdentifier = lArgs.getUnpackedValueOrDefault(u"ModuleIdentifier"_ustr, OUString());

    }

    for ( int i = 1; i < css::ui::UIElementType::COUNT; i++ )

    {

        OUString aResourceType;

        if ( i == css::ui::UIElementType::MENUBAR )

            aResourceType = RESOURCETYPE_MENUBAR;

        else if ( i == css::ui::UIElementType::TOOLBAR )

            aResourceType = RESOURCETYPE_TOOLBAR;

        else if ( i == css::ui::UIElementType::STATUSBAR )

            aResourceType = RESOURCETYPE_STATUSBAR;

        else if ( i == css::ui::UIElementType::POPUPMENU )

            aResourceType = RESOURCETYPE_POPUPMENU;

        if ( !aResourceType.isEmpty() )

        {

            m_pStorageHandler[i].reset( new PresetHandler( m_xContext ) );

            m_pStorageHandler[i]->connectToResource( PresetHandler::E_MODULES,

                                                     aResourceType, // this path won't be used later... see next lines!

                                                     aModuleShortName,

                                                     css::uno::Reference< css::embed::XStorage >()); // no document root used here!

        }

    }

    // initialize root storages for all resource types

    m_xUserRootCommit.set( m_pStorageHandler[css::ui::UIElementType::MENUBAR]->getOrCreateRootStorageUser(), css::uno::UNO_QUERY); // can be empty

    m_xDefaultConfigStorage = m_pStorageHandler[css::ui::UIElementType::MENUBAR]->getParentStorageShare();

    m_xUserConfigStorage    = m_pStorageHandler[css::ui::UIElementType::MENUBAR]->getParentStorageUser();

    if ( m_xUserConfigStorage.is() )

    {

        Reference< XPropertySet > xPropSet( m_xUserConfigStorage, UNO_QUERY );

        if ( xPropSet.is() )

        {

            tools::Long nOpenMode = 0;

            Any a = xPropSet->getPropertyValue(u"OpenMode"_ustr);

            if ( a >>= nOpenMode )

                m_bReadOnly = !( nOpenMode & ElementModes::WRITE );

        }

    }

    impl_Initialize();

}

// XComponent

void SAL_CALL ModuleUIConfigurationManager::dispose()

{

    Reference< XComponent > xThis(this);

    css::lang::EventObject aEvent( xThis );

    {

        std::unique_lock aGuard(m_mutex);

        m_aEventListeners.disposeAndClear( aGuard, aEvent );

    }

    {

        std::unique_lock aGuard(m_mutex);

        m_aConfigListeners.disposeAndClear( aGuard, aEvent );

    }

    /* SAFE AREA ----------------------------------------------------------------------------------------------- */

    SolarMutexClearableGuard aGuard;

    rtl::Reference< ImageManager > xModuleImageManager = std::move( m_xModuleImageManager );

    m_xModuleAcceleratorManager.clear();

    m_aUIElements[LAYER_USERDEFINED].clear();

    m_aUIElements[LAYER_DEFAULT].clear();

    m_xDefaultConfigStorage.clear();

    m_xUserConfigStorage.clear();

    m_xUserRootCommit.clear();

    m_bModified = false;

    m_bDisposed = true;

    aGuard.clear();

    /* SAFE AREA ----------------------------------------------------------------------------------------------- */

    try

    {

        if ( xModuleImageManager.is() )