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

#include <helper/mischelper.hxx>

#include <com/sun/star/beans/PropertyValue.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/configuration/theDefaultProvider.hpp>

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

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

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

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

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

#include <com/sun/star/frame/ModuleManager.hpp>

#include <com/sun/star/frame/XModuleManager2.hpp>

#include <com/sun/star/awt/Point.hpp>

#include <com/sun/star/awt/Size.hpp>

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

#include <com/sun/star/util/XChangesBatch.hpp>

#include <com/sun/star/uno/XComponentContext.hpp>

#include <comphelper/compbase.hxx>

#include <comphelper/string.hxx>

#include <cppuhelper/implbase.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <comphelper/propertysequence.hxx>

#include <comphelper/sequence.hxx>

#include <rtl/ref.hxx>

#include <sal/log.hxx>

#include <o3tl/string_view.hxx>

#include <mutex>

#include <string_view>

#include <unordered_map>

#include <vector>

using namespace com::sun::star::uno;

using namespace com::sun::star::lang;

using namespace com::sun::star::beans;

using namespace com::sun::star::util;

using namespace com::sun::star::configuration;

using namespace com::sun::star::container;

using namespace ::com::sun::star::frame;

using namespace ::com::sun::star::ui;

using namespace framework;

namespace {

// Zero based indexes, order must be the same as WindowStateMask && CONFIGURATION_PROPERTIES!

const sal_Int16 PROPERTY_LOCKED                  = 0;

const sal_Int16 PROPERTY_DOCKED                  = 1;

const sal_Int16 PROPERTY_VISIBLE                 = 2;

const sal_Int16 PROPERTY_CONTEXT                 = 3;

const sal_Int16 PROPERTY_HIDEFROMMENU            = 4;

const sal_Int16 PROPERTY_NOCLOSE                 = 5;

const sal_Int16 PROPERTY_SOFTCLOSE               = 6;

const sal_Int16 PROPERTY_CONTEXTACTIVE           = 7;

const sal_Int16 PROPERTY_DOCKINGAREA             = 8;

const sal_Int16 PROPERTY_POS                     = 9;

const sal_Int16 PROPERTY_SIZE                    = 10;

const sal_Int16 PROPERTY_UINAME                  = 11;

const sal_Int16 PROPERTY_INTERNALSTATE           = 12;

const sal_Int16 PROPERTY_STYLE                   = 13;

const sal_Int16 PROPERTY_DOCKPOS                 = 14;

const sal_Int16 PROPERTY_DOCKSIZE                = 15;

// Order must be the same as WindowStateMask!!

constexpr OUString CONFIGURATION_PROPERTIES[]

{

    WINDOWSTATE_PROPERTY_LOCKED,

    WINDOWSTATE_PROPERTY_DOCKED,

    WINDOWSTATE_PROPERTY_VISIBLE,

    WINDOWSTATE_PROPERTY_CONTEXT,

    WINDOWSTATE_PROPERTY_HIDEFROMENU,

    WINDOWSTATE_PROPERTY_NOCLOSE,

    WINDOWSTATE_PROPERTY_SOFTCLOSE,

    WINDOWSTATE_PROPERTY_CONTEXTACTIVE,

    WINDOWSTATE_PROPERTY_DOCKINGAREA,

    WINDOWSTATE_PROPERTY_POS,

    WINDOWSTATE_PROPERTY_SIZE,

    WINDOWSTATE_PROPERTY_UINAME,

    WINDOWSTATE_PROPERTY_INTERNALSTATE,

    WINDOWSTATE_PROPERTY_STYLE,

    WINDOWSTATE_PROPERTY_DOCKPOS,

    WINDOWSTATE_PROPERTY_DOCKSIZE

};

//  Configuration access class for WindowState supplier implementation

class ConfigurationAccess_WindowState : public  ::cppu::WeakImplHelper< XNameContainer, XContainerListener >

{

    public:

                                  ConfigurationAccess_WindowState( std::u16string_view aWindowStateConfigFile, const Reference< XComponentContext >& rxContext );

        virtual                   ~ConfigurationAccess_WindowState() override;

        // XNameAccess

        virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override;

        virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override;

        virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;

        // XNameContainer

        virtual void SAL_CALL removeByName( const OUString& sName ) override;

        virtual void SAL_CALL insertByName( const OUString& sName, const css::uno::Any&   aPropertySet ) override;

        // XNameReplace

        virtual void SAL_CALL replaceByName( const OUString& sName, const css::uno::Any& aPropertySet ) override;

        // XElementAccess

        virtual css::uno::Type SAL_CALL getElementType() override;

        virtual sal_Bool SAL_CALL hasElements() override;

        // container.XContainerListener

        virtual void SAL_CALL     elementInserted( const ContainerEvent& aEvent ) override;

        virtual void SAL_CALL     elementRemoved ( const ContainerEvent& aEvent ) override;

        virtual void SAL_CALL     elementReplaced( const ContainerEvent& aEvent ) override;

        // lang.XEventListener

        virtual void SAL_CALL disposing( const EventObject& aEvent ) override;

    protected:

        enum // WindowStateMask

        {

            WINDOWSTATE_MASK_DOCKINGAREA    = 256,

            WINDOWSTATE_MASK_POS            = 512,

            WINDOWSTATE_MASK_SIZE           = 1024,

            WINDOWSTATE_MASK_UINAME         = 2048,

            WINDOWSTATE_MASK_INTERNALSTATE  = 4096,

            WINDOWSTATE_MASK_STYLE          = 8192,

            WINDOWSTATE_MASK_DOCKPOS        = 16384,

            WINDOWSTATE_MASK_DOCKSIZE       = 32768

        };

        // Cache structure. Valid values are described by the eMask member. All other values should not be

        // provided to outside code!

        struct WindowStateInfo

        {

            WindowStateInfo()

                : bLocked(false)

                , bDocked(false)

                , bVisible(false)

                , bContext(false)

                , bHideFromMenu(false)

                , bNoClose(false)

                , bSoftClose(false)

                , bContextActive(false)

                , aDockingArea(css::ui::DockingArea_DOCKINGAREA_TOP)

                , aDockPos(0, 0)

                , aPos(0, 0)

                , aSize(0, 0)

                , nInternalState(0)

                , nStyle(0)

                , nMask(0)

            {

            }

            bool                                    bLocked : 1,

                                                    bDocked : 1,

                                                    bVisible : 1,

                                                    bContext : 1,

                                                    bHideFromMenu : 1,

                                                    bNoClose : 1,

                                                    bSoftClose : 1,

                                                    bContextActive : 1;

            css::ui::DockingArea                    aDockingArea;

            css::awt::Point                         aDockPos;

            css::awt::Size                          aDockSize;

            css::awt::Point                         aPos;

            css::awt::Size                          aSize;

            OUString                                aUIName;

            sal_uInt32                              nInternalState;

            sal_uInt16                              nStyle;

            sal_uInt32                              nMask; // see WindowStateMask

        };

        void                      impl_putPropertiesFromStruct( const WindowStateInfo& rWinStateInfo, Reference< XPropertySet > const & xPropSet );

        Any                       impl_insertCacheAndReturnSequence( const OUString& rResourceURL, Reference< XNameAccess > const & rNameAccess );

        WindowStateInfo&          impl_insertCacheAndReturnWinState( const OUString& rResourceURL, Reference< XNameAccess > const & rNameAccess );

        Any                       impl_getSequenceFromStruct( const WindowStateInfo& rWinStateInfo );

        void                      impl_fillStructFromSequence( WindowStateInfo& rWinStateInfo, const Sequence< PropertyValue >& rSeq );

        Any                       impl_getWindowStateFromResourceURL( const OUString& rResourceURL );

        void                      impl_initializeConfigAccess();

    private:

        typedef std::unordered_map< OUString,

                                    WindowStateInfo > ResourceURLToInfoCache;

        std::mutex                        m_aMutex;

        OUString                          m_aConfigWindowAccess;

        Reference< XMultiServiceFactory > m_xConfigProvider;

        Reference< XNameAccess >          m_xConfigAccess;

        rtl::Reference< WeakContainerListener >   m_xConfigListener;

        ResourceURLToInfoCache            m_aResourceURLToInfoCache;

        bool                              m_bConfigAccessInitialized : 1,

                                          m_bModified : 1;

        std::vector< OUString >           m_aPropArray;

};

ConfigurationAccess_WindowState::ConfigurationAccess_WindowState( std::u16string_view aModuleName, const Reference< XComponentContext >& rxContext ) :

    // Create configuration hierarchical access name

    m_aConfigWindowAccess(

        OUString::Concat("/org.openoffice.Office.UI.") + aModuleName + "/UIElements/States"),

    m_xConfigProvider(theDefaultProvider::get( rxContext )),

    m_bConfigAccessInitialized( false ),

    m_bModified( false )

{

    // Initialize access array with property names.

    for (const OUString & s : CONFIGURATION_PROPERTIES )

        m_aPropArray.push_back(s);

}

ConfigurationAccess_WindowState::~ConfigurationAccess_WindowState()

{

    // SAFE

    std::unique_lock g(m_aMutex);

    Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );

    if ( xContainer.is() )

        xContainer->removeContainerListener(m_xConfigListener);

}

// XNameAccess

Any SAL_CALL ConfigurationAccess_WindowState::getByName( const OUString& rResourceURL )

{

    // SAFE

    std::unique_lock g(m_aMutex);

    ResourceURLToInfoCache::const_iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );

    if ( pIter != m_aResourceURLToInfoCache.end() )

        return impl_getSequenceFromStruct( pIter->second );

    else

    {

        Any a( impl_getWindowStateFromResourceURL( rResourceURL ) );

        if ( a == Any() )

            throw NoSuchElementException();

        return a;

    }

}

Sequence< OUString > SAL_CALL ConfigurationAccess_WindowState::getElementNames()

{

    // SAFE

    std::unique_lock g(m_aMutex);

    if ( !m_bConfigAccessInitialized )

    {

        impl_initializeConfigAccess();

        m_bConfigAccessInitialized = true;

    }

    if ( m_xConfigAccess.is() )

        return m_xConfigAccess->getElementNames();

    else

        return Sequence< OUString > ();

}

sal_Bool SAL_CALL ConfigurationAccess_WindowState::hasByName( const OUString& rResourceURL )

{

    // SAFE

    std::unique_lock g(m_aMutex);

    ResourceURLToInfoCache::const_iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );

    if ( pIter != m_aResourceURLToInfoCache.end() )

        return true;

    else

    {

        Any a( impl_getWindowStateFromResourceURL( rResourceURL ) );

        if ( a == Any() )

            return false;

        else

            return true;

    }

}

// XElementAccess

Type SAL_CALL ConfigurationAccess_WindowState::getElementType()

{

    return cppu::UnoType<Sequence< PropertyValue >>::get();

}

sal_Bool SAL_CALL ConfigurationAccess_WindowState::hasElements()

{

    // SAFE

    std::unique_lock g(m_aMutex);

    if ( !m_bConfigAccessInitialized )

    {

        impl_initializeConfigAccess();

        m_bConfigAccessInitialized = true;

    }

    if ( m_xConfigAccess.is() )

        return m_xConfigAccess->hasElements();

    else

        return false;

}

// XNameContainer

void SAL_CALL ConfigurationAccess_WindowState::removeByName( const OUString& rResourceURL )

{

    // SAFE

    std::unique_lock g(m_aMutex);

    ResourceURLToInfoCache::iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );

    if ( pIter != m_aResourceURLToInfoCache.end() )

        m_aResourceURLToInfoCache.erase( pIter );

    if ( !m_bConfigAccessInitialized )

    {

        impl_initializeConfigAccess();

        m_bConfigAccessInitialized = true;

    }

    try

    {

        // Remove must be write-through => remove element from configuration

        Reference< XNameContainer > xNameContainer( m_xConfigAccess, UNO_QUERY );

        if ( xNameContainer.is() )

        {

            g.unlock();

            xNameContainer->removeByName( rResourceURL );

            Reference< XChangesBatch > xFlush( m_xConfigAccess, UNO_QUERY );

            if ( xFlush.is() )

                xFlush->commitChanges();

        }

    }

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

    {

    }

}

void SAL_CALL ConfigurationAccess_WindowState::insertByName( const OUString& rResourceURL, const css::uno::Any& aPropertySet )

{

    // SAFE

    std::unique_lock g(m_aMutex);

    Sequence< PropertyValue > aPropSet;

    if ( !(aPropertySet >>= aPropSet) )

        throw IllegalArgumentException();

    ResourceURLToInfoCache::const_iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );

    if ( pIter != m_aResourceURLToInfoCache.end() )

        throw ElementExistException();

    if ( !m_bConfigAccessInitialized )

    {

        impl_initializeConfigAccess();

        m_bConfigAccessInitialized = true;

    }

    // Try to ask our configuration access

    if ( !m_xConfigAccess.is() )

        return;

    if ( m_xConfigAccess->hasByName( rResourceURL ) )

        throw ElementExistException();

    WindowStateInfo aWinStateInfo;

    impl_fillStructFromSequence( aWinStateInfo, aPropSet );

    m_aResourceURLToInfoCache.emplace( rResourceURL, aWinStateInfo );

    // insert must be write-through => insert element into configuration

    Reference< XNameContainer > xNameContainer( m_xConfigAccess, UNO_QUERY );

    if ( !xNameContainer.is() )

        return;

    Reference< XSingleServiceFactory > xFactory( m_xConfigAccess, UNO_QUERY );

    g.unlock();

    try

    {

        Reference< XPropertySet > xPropSet( xFactory->createInstance(), UNO_QUERY );

        if ( xPropSet.is() )

        {

            Any a;

            impl_putPropertiesFromStruct( aWinStateInfo, xPropSet );

            a <<= xPropSet;

            xNameContainer->insertByName( rResourceURL, a );

            Reference< XChangesBatch > xFlush( xFactory, UNO_QUERY );

            if ( xFlush.is() )

                xFlush->commitChanges();

        }

    }

    catch ( const Exception& )

    {

    }

}

// XNameReplace

void SAL_CALL ConfigurationAccess_WindowState::replaceByName( const OUString& rResourceURL, const css::uno::Any& aPropertySet )

{

    // SAFE

    std::unique_lock g(m_aMutex);

    Sequence< PropertyValue > aPropSet;

    if ( !(aPropertySet >>= aPropSet) )

        throw IllegalArgumentException();

    ResourceURLToInfoCache::iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );

    if ( pIter != m_aResourceURLToInfoCache.end() )

    {

        WindowStateInfo& rWinStateInfo = pIter->second;

        impl_fillStructFromSequence( rWinStateInfo, aPropSet );

        m_bModified = true;

    }

    else

    {

        if ( !m_bConfigAccessInitialized )

        {

            impl_initializeConfigAccess();

            m_bConfigAccessInitialized = true;

        }

        // Try to ask our configuration access

        Reference< XNameAccess > xNameAccess;

        Any a( m_xConfigAccess->getByName( rResourceURL ));

        if ( !(a >>= xNameAccess) )

            throw NoSuchElementException();

        WindowStateInfo& rWinStateInfo( impl_insertCacheAndReturnWinState( rResourceURL, xNameAccess ));

        impl_fillStructFromSequence( rWinStateInfo, aPropSet );

        m_bModified = true;

        pIter = m_aResourceURLToInfoCache.find( rResourceURL );

    }

    if ( !(m_bModified && pIter != m_aResourceURLToInfoCache.end()) )

        return;

    Reference< XNameContainer > xNameContainer( m_xConfigAccess, UNO_QUERY );

    if ( !xNameContainer.is() )

        return;

    WindowStateInfo aWinStateInfo( pIter->second );

    OUString        aResourceURL( pIter->first );

    m_bModified = false;

    g.unlock();

    try

    {

        Reference< XPropertySet > xPropSet;

        if ( xNameContainer->getByName( aResourceURL ) >>= xPropSet )

        {

            impl_putPropertiesFromStruct( aWinStateInfo, xPropSet );

            Reference< XChangesBatch > xFlush( m_xConfigAccess, UNO_QUERY );

            if ( xFlush.is() )

                xFlush->commitChanges();

        }

    }

    catch ( const Exception& )

    {

    }

}

// container.XContainerListener

void SAL_CALL ConfigurationAccess_WindowState::elementInserted( const ContainerEvent& )

{

    // do nothing - next time someone wants to retrieve this node we will find it in the configuration

}

void SAL_CALL ConfigurationAccess_WindowState::elementRemoved ( const ContainerEvent& )

{

}

void SAL_CALL ConfigurationAccess_WindowState::elementReplaced( const ContainerEvent& )

{

}

// lang.XEventListener

void SAL_CALL ConfigurationAccess_WindowState::disposing( const EventObject& aEvent )

{

    // SAFE

    // remove our reference to the config access

    std::unique_lock g(m_aMutex);

    Reference< XInterface > xIfac1( aEvent.Source, UNO_QUERY );

    Reference< XInterface > xIfac2( m_xConfigAccess, UNO_QUERY );

    if ( xIfac1 == xIfac2 )

        m_xConfigAccess.clear();

}

// private helper methods

Any ConfigurationAccess_WindowState::impl_getSequenceFromStruct( const WindowStateInfo& rWinStateInfo )

{

    sal_Int32                 i( 0 );

    sal_Int32                 nCount( m_aPropArray.size() );

    std::vector< PropertyValue > aPropVec;

    for ( i = 0; i < nCount; i++ )

    {

        if ( rWinStateInfo.nMask & ( 1 << i ))

        {

            // put value into the return sequence

            PropertyValue pv;

            pv.Name = m_aPropArray[i];

            switch ( i )

            {

                case PROPERTY_LOCKED:

                    pv.Value <<= rWinStateInfo.bLocked; break;

                case PROPERTY_DOCKED:

                    pv.Value <<= rWinStateInfo.bDocked; break;

                case PROPERTY_VISIBLE:

                    pv.Value <<= rWinStateInfo.bVisible; break;

                case PROPERTY_CONTEXT:

                    pv.Value <<= rWinStateInfo.bContext; break;

                case PROPERTY_HIDEFROMMENU:

                    pv.Value <<= rWinStateInfo.bHideFromMenu; break;

                case PROPERTY_NOCLOSE:

                    pv.Value <<= rWinStateInfo.bNoClose; break;

                case PROPERTY_SOFTCLOSE:

                    pv.Value <<= rWinStateInfo.bSoftClose; break;

                case PROPERTY_CONTEXTACTIVE:

                    pv.Value <<= rWinStateInfo.bContextActive; break;

                case PROPERTY_DOCKINGAREA:

                    pv.Value <<= rWinStateInfo.aDockingArea; break;

                case PROPERTY_POS:

                    pv.Value <<= rWinStateInfo.aPos; break;

                case PROPERTY_SIZE:

                    pv.Value <<= rWinStateInfo.aSize; break;

                case PROPERTY_UINAME:

                    pv.Value <<= rWinStateInfo.aUIName; break;

                case PROPERTY_INTERNALSTATE:

                    pv.Value <<= sal_Int32( rWinStateInfo.nInternalState ); break;

                case PROPERTY_STYLE:

                    pv.Value <<= sal_Int16( rWinStateInfo.nStyle ); break;

                case PROPERTY_DOCKPOS:

                    pv.Value <<= rWinStateInfo.aDockPos; break;

                case PROPERTY_DOCKSIZE:

                    pv.Value <<= rWinStateInfo.aDockSize; break;

                default:

                    assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );

            }

            aPropVec.push_back(pv);

        }

    }

    return Any( comphelper::containerToSequence(aPropVec) );

}

Any ConfigurationAccess_WindowState::impl_insertCacheAndReturnSequence( const OUString& rResourceURL, Reference< XNameAccess > const & xNameAccess )

{

    sal_Int32                 nMask( 0 );

    sal_Int32                 nCount( m_aPropArray.size() );

    sal_Int32                 i( 0 );

    std::vector< PropertyValue > aPropVec;

    WindowStateInfo           aWindowStateInfo;

    for ( i = 0; i < nCount; i++ )

    {

        try

        {

            bool    bAddToSeq( false );

            Any     a( xNameAccess->getByName( m_aPropArray[i] ) );

            switch ( i )

            {

                case PROPERTY_LOCKED:

                case PROPERTY_DOCKED:

                case PROPERTY_VISIBLE:

                case PROPERTY_CONTEXT:

                case PROPERTY_HIDEFROMMENU:

                case PROPERTY_NOCLOSE:

                case PROPERTY_SOFTCLOSE:

                case PROPERTY_CONTEXTACTIVE:

                {

                    bool bValue;

                    if ( a >>= bValue )

                    {

                        sal_Int32 nValue( 1 << i );

                        nMask |= nValue;

                        bAddToSeq = true;

                        switch ( i )

                        {

                            case PROPERTY_LOCKED:

                                aWindowStateInfo.bLocked = bValue; break;

                            case PROPERTY_DOCKED:

                                aWindowStateInfo.bDocked = bValue; break;

                            case PROPERTY_VISIBLE:

                                aWindowStateInfo.bVisible = bValue; break;

                            case PROPERTY_CONTEXT:

                                aWindowStateInfo.bContext = bValue; break;

                            case PROPERTY_HIDEFROMMENU:

                                aWindowStateInfo.bHideFromMenu = bValue; break;

                            case PROPERTY_NOCLOSE:

                                aWindowStateInfo.bNoClose = bValue; break;

                            case PROPERTY_SOFTCLOSE:

                                aWindowStateInfo.bSoftClose = bValue; break;

                            case PROPERTY_CONTEXTACTIVE:

                                aWindowStateInfo.bContextActive = bValue; break;

                        }

                    }

                }

                break;

                case PROPERTY_DOCKINGAREA:

                {

                    sal_Int32 nDockingArea = 0;

                    if ( a >>= nDockingArea )

                    {

                        if (( nDockingArea >= 0 ) &&

                            ( nDockingArea <= sal_Int32( DockingArea_DOCKINGAREA_RIGHT )))

                        {

                            aWindowStateInfo.aDockingArea = static_cast<DockingArea>(nDockingArea);

                            nMask |= WINDOWSTATE_MASK_DOCKINGAREA;

                            a <<= aWindowStateInfo.aDockingArea;

                            bAddToSeq = true;

                        }

                    }

                }

                break;

                case PROPERTY_POS:

                case PROPERTY_DOCKPOS:

                {

                    OUString aString;

                    if ( a >>= aString )

                    {

                        sal_Int32 nToken( 0 );

                        std::u16string_view aXStr = o3tl::getToken(aString, 0, ',', nToken );

                        if ( nToken > 0 )

                        {

                            css::awt::Point aPos;

                            aPos.X = o3tl::toInt32(aXStr);

                            aPos.Y = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));

                            if ( i == PROPERTY_POS )

                            {

                                aWindowStateInfo.aPos = aPos;

                                nMask |= WINDOWSTATE_MASK_POS;

                            }

                            else

                            {

                                aWindowStateInfo.aDockPos = aPos;

                                nMask |= WINDOWSTATE_MASK_DOCKPOS;

                            }

                            a <<= aPos;

                            bAddToSeq = true;

                        }

                    }

                }

                break;

                case PROPERTY_SIZE:

                case PROPERTY_DOCKSIZE:

                {

                    OUString aString;

                    if ( a >>= aString )

                    {

                        sal_Int32 nToken( 0 );

                        std::u16string_view aStr = o3tl::getToken(aString, 0, ',', nToken );

                        if ( nToken > 0 )

                        {

                            css::awt::Size aSize;

                            aSize.Width = o3tl::toInt32(aStr);

                            aSize.Height = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));

                            if ( i == PROPERTY_SIZE )

                            {

                                aWindowStateInfo.aSize = aSize;

                                nMask |= WINDOWSTATE_MASK_SIZE;

                            }

                            else

                            {

                                aWindowStateInfo.aDockSize = aSize;

                                nMask |= WINDOWSTATE_MASK_DOCKSIZE;

                            }

                            a <<= aSize;

                            bAddToSeq = true;

                        }

                    }

                }

                break;

                case PROPERTY_UINAME:

                {

                    OUString aValue;

                    if ( a >>= aValue )

                    {

                        nMask |= WINDOWSTATE_MASK_UINAME;

                        aWindowStateInfo.aUIName = aValue;

                        bAddToSeq = true;

                    }

                }

                break;

                case PROPERTY_INTERNALSTATE:

                {

                    sal_uInt32 nValue = 0;

                    if ( a >>= nValue )

                    {

                        nMask |= WINDOWSTATE_MASK_INTERNALSTATE;

                        aWindowStateInfo.nInternalState = nValue;

                        bAddToSeq = true;

                    }

                }

                break;

                case PROPERTY_STYLE:

                {

                    sal_Int32 nValue = 0;

                    if ( a >>= nValue )

                    {

                        nMask |= WINDOWSTATE_MASK_STYLE;

                        aWindowStateInfo.nStyle = sal_uInt16( nValue );

                        bAddToSeq = true;

                    }

                }

                break;

                default:

                   assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );

            }

            if ( bAddToSeq )

            {

                // put value into the return sequence

                PropertyValue pv;

                pv.Name  = m_aPropArray[i];

                pv.Value = std::move(a);

                aPropVec.push_back(pv);

            }

        }

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

        {

        }

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

        {

        }

    }

    aWindowStateInfo.nMask = nMask;

    m_aResourceURLToInfoCache.emplace( rResourceURL, aWindowStateInfo );

    return Any( comphelper::containerToSequence(aPropVec) );

}

ConfigurationAccess_WindowState::WindowStateInfo& ConfigurationAccess_WindowState::impl_insertCacheAndReturnWinState( const OUString& rResourceURL, Reference< XNameAccess > const & rNameAccess )

{

    sal_Int32                 nMask( 0 );

    sal_Int32                 nCount( m_aPropArray.size() );

    sal_Int32                 i( 0 );

    WindowStateInfo           aWindowStateInfo;

    for ( i = 0; i < nCount; i++ )

    {

        try

        {

            Any     a( rNameAccess->getByName( m_aPropArray[i] ) );

            switch ( i )

            {

                case PROPERTY_LOCKED:

                case PROPERTY_DOCKED:

                case PROPERTY_VISIBLE:

                case PROPERTY_CONTEXT:

                case PROPERTY_HIDEFROMMENU:

                case PROPERTY_NOCLOSE:

                case PROPERTY_SOFTCLOSE:

                case PROPERTY_CONTEXTACTIVE:

                {

                    bool bValue;

                    if ( a >>= bValue )

                    {

                        sal_Int32 nValue( 1 << i );

                        nMask |= nValue;

                        switch ( i )

                        {

                            case PROPERTY_LOCKED:

                                aWindowStateInfo.bLocked = bValue; break;

                            case PROPERTY_DOCKED:

                                aWindowStateInfo.bDocked = bValue; break;

                            case PROPERTY_VISIBLE:

                                aWindowStateInfo.bVisible = bValue; break;

                            case PROPERTY_CONTEXT:

                                aWindowStateInfo.bContext = bValue; break;

                            case PROPERTY_HIDEFROMMENU:

                                aWindowStateInfo.bHideFromMenu = bValue; break;

                            case PROPERTY_NOCLOSE:

                                aWindowStateInfo.bNoClose = bValue; break;

                            case PROPERTY_SOFTCLOSE:

                                aWindowStateInfo.bNoClose = bValue; break;

                            case PROPERTY_CONTEXTACTIVE:

                                aWindowStateInfo.bContextActive = bValue; break;

                            default:

                                SAL_WARN( "fwk.uiconfiguration", "Unknown boolean property in WindowState found!" );

                        }

                    }

                }

                break;

                case PROPERTY_DOCKINGAREA:

                {

                    sal_Int32 nDockingArea = 0;

                    if ( a >>= nDockingArea )

                    {

                        if (( nDockingArea >= 0 ) &&

                            ( nDockingArea <= sal_Int32( DockingArea_DOCKINGAREA_RIGHT )))

                        {

                            aWindowStateInfo.aDockingArea = static_cast<DockingArea>(nDockingArea);

                            nMask |= WINDOWSTATE_MASK_DOCKINGAREA;

                        }

                    }

                }

                break;

                case PROPERTY_POS:

                case PROPERTY_DOCKPOS:

                {

                    OUString aString;

                    if ( a >>= aString )

                    {

                        sal_Int32 nToken( 0 );

                        std::u16string_view aXStr = o3tl::getToken(aString, 0, ',', nToken );

                        if ( nToken > 0 )

                        {

                            css::awt::Point aPos;

                            aPos.X = o3tl::toInt32(aXStr);

                            aPos.Y = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));

                            if ( i == PROPERTY_POS )

                            {

                                aWindowStateInfo.aPos = aPos;

                                nMask |= WINDOWSTATE_MASK_POS;

                            }

                            else

                            {

                                aWindowStateInfo.aDockPos = aPos;

                                nMask |= WINDOWSTATE_MASK_DOCKPOS;

                            }

                        }

                    }

                }

                break;

                case PROPERTY_SIZE:

                case PROPERTY_DOCKSIZE:

                {

                    OUString aString;

                    if ( a >>= aString )

                    {

                        sal_Int32 nToken( 0 );

                        std::u16string_view aStr = o3tl::getToken(aString, 0, ',', nToken );

                        if ( nToken > 0 )

                        {

                            css::awt::Size aSize;

                            aSize.Width  = o3tl::toInt32(aStr);

                            aSize.Height = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));

                            if ( i == PROPERTY_SIZE )

                            {

                                aWindowStateInfo.aSize = aSize;

                                nMask |= WINDOWSTATE_MASK_SIZE;

                            }

                            else

                            {

                                aWindowStateInfo.aDockSize = aSize;

                                nMask |= WINDOWSTATE_MASK_DOCKSIZE;

                            }

                        }

                    }

                }

                break;

                case PROPERTY_UINAME:

                {

                    OUString aValue;

                    if ( a >>= aValue )

                    {

                        nMask |= WINDOWSTATE_MASK_UINAME;

                        aWindowStateInfo.aUIName = aValue;

                    }

                }

                break;

                case PROPERTY_INTERNALSTATE:

                {

                    sal_Int32 nValue = 0;

                    if ( a >>= nValue )

                    {

                        nMask |= WINDOWSTATE_MASK_INTERNALSTATE;

                        aWindowStateInfo.nInternalState = sal_uInt32( nValue );

                    }

                }

                break;

                case PROPERTY_STYLE:

                {

                    sal_Int32 nValue = 0;

                    if ( a >>= nValue )

                    {

                        nMask |= WINDOWSTATE_MASK_STYLE;

                        aWindowStateInfo.nStyle = sal_uInt16( nValue );

                    }

                }

                break;