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

#include <vcl/svapp.hxx>

#include <o3tl/safeint.hxx>

#include <osl/mutex.hxx>

#include <helper/property.hxx>

#include <helper/servicenames.hxx>

#include <controls/geometrycontrolmodel.hxx>

#include <toolkit/controls/unocontrols.hxx>

#include <controls/formattedcontrol.hxx>

#include <controls/roadmapcontrol.hxx>

#include <controls/tkscrollbar.hxx>

#include <controls/tabpagemodel.hxx>

#include <controls/stdtabcontroller.hxx>

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

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

#include <com/sun/star/resource/XStringResourceResolver.hpp>

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

#include <cppuhelper/queryinterface.hxx>

#include <cppuhelper/weak.hxx>

#include <cppuhelper/weakagg.hxx>

#include <tools/debug.hxx>

#include <tools/mapunit.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <vcl/outdev.hxx>

#include <comphelper/types.hxx>

#include "tree/treecontrol.hxx"

#include "grid/gridcontrol.hxx"

#include <controls/tabpagecontainer.hxx>

#include <map>

#include <algorithm>

#include <tools/urlobj.hxx>

#include <osl/file.hxx>

#include <sal/log.hxx>

#include <controls/dialogcontrol.hxx>

#include <helper/unopropertyarrayhelper.hxx>

#include "controlmodelcontainerbase_internal.hxx"

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

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

using namespace ::com::sun::star::awt;

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

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

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

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

using namespace toolkit;

constexpr OUString PROPERTY_RESOURCERESOLVER = u"ResourceResolver"_ustr;

namespace

{

    const Sequence< OUString >& lcl_getLanguageDependentProperties()

    {

        // note: properties must be sorted

        static Sequence<OUString> s_aLanguageDependentProperties{ u"HelpText"_ustr, u"Title"_ustr };

        return s_aLanguageDependentProperties;

    }

// functor for disposing a control model

struct DisposeControlModel

{

    void operator()( Reference< XControlModel >& _rxModel )

    {

        try

        {

            ::comphelper::disposeComponent( _rxModel );

        }

        catch (const Exception&)

        {

            TOOLS_WARN_EXCEPTION("toolkit", "caught an exception while disposing a component" );

        }

    }

};

}

// functor for cloning a control model, and insertion into a target list

struct CloneControlModel

{

private:

    ControlModelContainerBase::UnoControlModelHolderVector&   m_rTargetVector;

public:

    explicit CloneControlModel( ControlModelContainerBase::UnoControlModelHolderVector& _rTargetVector )

        :m_rTargetVector( _rTargetVector )

    {

    }

    void operator()( const ControlModelContainerBase::UnoControlModelHolder& _rSource )

    {

        // clone the source object

        Reference< XCloneable > xCloneSource( _rSource.first, UNO_QUERY );

        Reference< XControlModel > xClone( xCloneSource->createClone(), UNO_QUERY );

        // add to target list

        m_rTargetVector.emplace_back( xClone, _rSource.second );

    }

};

// functor for comparing a XControlModel with a given reference

struct CompareControlModel

{

private:

    Reference< XControlModel > m_xReference;

public:

    explicit CompareControlModel( const Reference< XControlModel >& _rxReference ) : m_xReference( _rxReference ) { }

    bool operator()( const ControlModelContainerBase::UnoControlModelHolder& _rCompare )

    {

        return _rCompare.first.get() == m_xReference.get();

    }

};

constexpr OUString aTabIndexPropertyNameStr( u"TabIndex"_ustr );

ControlModelContainerBase::ControlModelContainerBase( const Reference< XComponentContext >& rxContext )

    :ControlModelContainer_IBase( rxContext )

    ,maContainerListeners( *this )

    ,mbGroupsUpToDate( false )

    ,m_nTabPageId(0)

{

    ImplRegisterProperty(BASEPROPERTY_ENABLED);

}

Unexecuted instantiation: ControlModelContainerBase::ControlModelContainerBase(com::sun::star::uno::Reference<com::sun::star::uno::XComponentContext> const&)

Unexecuted instantiation: ControlModelContainerBase::ControlModelContainerBase(com::sun::star::uno::Reference<com::sun::star::uno::XComponentContext> const&)

ControlModelContainerBase::ControlModelContainerBase( const ControlModelContainerBase& rModel )

    : ControlModelContainer_IBase( rModel )

    , maContainerListeners( *this )

    , mbGroupsUpToDate( false )

    , m_nTabPageId( rModel.m_nTabPageId )

{

}

Unexecuted instantiation: ControlModelContainerBase::ControlModelContainerBase(ControlModelContainerBase const&)

Unexecuted instantiation: ControlModelContainerBase::ControlModelContainerBase(ControlModelContainerBase const&)

ControlModelContainerBase::~ControlModelContainerBase()

{

    maModels.clear();

    mbGroupsUpToDate = false;

}

Any ControlModelContainerBase::ImplGetDefaultValue( sal_uInt16 nPropId ) const

{

    Any aAny;

    switch ( nPropId )

    {

        case BASEPROPERTY_DEFAULTCONTROL:

            aAny <<= sServiceName_UnoControlDialog;

            break;

        default:

            aAny = UnoControlModel::ImplGetDefaultValue( nPropId );

    }

    return aAny;

}

::cppu::IPropertyArrayHelper& ControlModelContainerBase::getInfoHelper()

{

    static UnoPropertyArrayHelper aHelper( ImplGetPropertyIds() );

    return aHelper;

}

void SAL_CALL ControlModelContainerBase::dispose(  )

{

    // tell our listeners

    {

        std::unique_lock aGuard( m_aMutex );

        EventObject aDisposeEvent;

        aDisposeEvent.Source = static_cast< XAggregation* >( static_cast< ::cppu::OWeakAggObject* >( this ) );

        maContainerListeners.disposeAndClear( aGuard, aDisposeEvent );

        maChangeListeners.disposeAndClear( aGuard, aDisposeEvent );

    }

    // call the base class

    UnoControlModel::dispose();

    // dispose our child models

    // for this, collect the models (we collect them from maModels, and this is modified when disposing children)

    ::std::vector< Reference< XControlModel > > aChildModels( maModels.size() );

    ::std::transform(

        maModels.begin(), maModels.end(),               // source range

        aChildModels.begin(),                           // target location

        []( const UnoControlModelHolder& rUnoControlModelHolder )

        { return rUnoControlModelHolder.first; }        // operation to apply -> select the XControlModel part

    );

    // now dispose

    ::std::for_each( aChildModels.begin(), aChildModels.end(), DisposeControlModel() );

    aChildModels.clear();

    mbGroupsUpToDate = false;

}

// XMultiPropertySet

Reference< XPropertySetInfo > ControlModelContainerBase::getPropertySetInfo(  )

{

    static Reference< XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );

    return xInfo;

}

void ControlModelContainerBase::Clone_Impl(ControlModelContainerBase& _rClone) const

{

    // clone all children

    ::std::for_each(

        maModels.begin(), maModels.end(),

        CloneControlModel( _rClone.maModels )

    );

}

rtl::Reference<UnoControlModel> ControlModelContainerBase::Clone() const

{

    // clone the container itself

    rtl::Reference<ControlModelContainerBase> pClone = new ControlModelContainerBase( *this );

    Clone_Impl(*pClone);

    return pClone;

}

ControlModelContainerBase::UnoControlModelHolderVector::iterator ControlModelContainerBase::ImplFindElement( std::u16string_view rName )

{

    return ::std::find_if( maModels.begin(), maModels.end(), [&](const UnoControlModelHolder& elem) { return elem.second == rName; });

}

// ::XMultiServiceFactory

Reference< XInterface > ControlModelContainerBase::createInstance( const OUString& aServiceSpecifier )

{

    SolarMutexGuard aGuard;

    rtl::Reference<OGeometryControlModel_Base> pNewModel;

    if ( aServiceSpecifier == "com.sun.star.awt.UnoControlEditModel" )

        pNewModel = new OGeometryControlModel< UnoControlEditModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlFormattedFieldModel" )

        pNewModel = new OGeometryControlModel< UnoControlFormattedFieldModel >( m_xContext);

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlFileControlModel" )

        pNewModel = new OGeometryControlModel< UnoControlFileControlModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlButtonModel" )

        pNewModel = new OGeometryControlModel< UnoControlButtonModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlImageControlModel" )

        pNewModel = new OGeometryControlModel< UnoControlImageControlModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlRadioButtonModel" )

        pNewModel = new OGeometryControlModel< UnoControlRadioButtonModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlCheckBoxModel" )

        pNewModel = new OGeometryControlModel< UnoControlCheckBoxModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlFixedHyperlinkModel" )

        pNewModel = new OGeometryControlModel< UnoControlFixedHyperlinkModel >( m_xContext );

    else if ( aServiceSpecifier == "stardiv.vcl.controlmodel.FixedText" )

        pNewModel = new OGeometryControlModel< UnoControlFixedTextModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlGroupBoxModel" )

        pNewModel = new OGeometryControlModel< UnoControlGroupBoxModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlListBoxModel" )

        pNewModel = new OGeometryControlModel< UnoControlListBoxModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlComboBoxModel" )

        pNewModel = new OGeometryControlModel< UnoControlComboBoxModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlDateFieldModel" )

        pNewModel = new OGeometryControlModel< UnoControlDateFieldModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlTimeFieldModel" )

        pNewModel = new OGeometryControlModel< UnoControlTimeFieldModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlNumericFieldModel" )

        pNewModel = new OGeometryControlModel< UnoControlNumericFieldModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlCurrencyFieldModel" )

        pNewModel = new OGeometryControlModel< UnoControlCurrencyFieldModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlPatternFieldModel" )

        pNewModel = new OGeometryControlModel< UnoControlPatternFieldModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlProgressBarModel" )

        pNewModel = new OGeometryControlModel< UnoControlProgressBarModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlScrollBarModel" )

        pNewModel = new OGeometryControlModel< UnoControlScrollBarModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlFixedLineModel" )

        pNewModel = new OGeometryControlModel< UnoControlFixedLineModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoControlRoadmapModel" )

        pNewModel = new OGeometryControlModel< UnoControlRoadmapModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.tree.TreeControlModel" )

        pNewModel = new OGeometryControlModel< UnoTreeModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.grid.UnoControlGridModel" )

        pNewModel = new OGeometryControlModel< UnoGridModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.tab.UnoControlTabPageContainerModel" )

        pNewModel = new OGeometryControlModel< UnoControlTabPageContainerModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoMultiPageModel" )

        pNewModel = new OGeometryControlModel< UnoMultiPageModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.tab.UnoControlTabPageModel" )

        pNewModel = new OGeometryControlModel< UnoControlTabPageModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoPageModel" )

        pNewModel = new OGeometryControlModel< UnoPageModel >( m_xContext );

    else if ( aServiceSpecifier == "com.sun.star.awt.UnoFrameModel" )

        pNewModel = new OGeometryControlModel< UnoFrameModel >( m_xContext );

    if ( !pNewModel )

    {

        Reference< XInterface > xObject = m_xContext->getServiceManager()->createInstanceWithContext(aServiceSpecifier, m_xContext);

        Reference< XServiceInfo > xSI( xObject, UNO_QUERY );

        Reference< XCloneable > xCloneAccess( xSI, UNO_QUERY );

        Reference< XAggregation > xAgg( xCloneAccess, UNO_QUERY );

        if ( xAgg.is() )

        {

            if ( xSI->supportsService(u"com.sun.star.awt.UnoControlModel"_ustr) )

            {

                // release 3 of the 4 references we have to the object

                xAgg.clear();

                xSI.clear();

                xObject.clear();

                pNewModel = new OCommonGeometryControlModel( xCloneAccess, aServiceSpecifier );

            }

        }

    }

    return cppu::getXWeak(pNewModel.get());

}

Reference< XInterface > ControlModelContainerBase::createInstanceWithArguments( const OUString& ServiceSpecifier, const Sequence< Any >& i_arguments )

{

    const Reference< XInterface > xInstance( createInstance( ServiceSpecifier ) );

    const Reference< XInitialization > xInstanceInit( xInstance, UNO_QUERY );

    ENSURE_OR_RETURN( xInstanceInit.is(), "ControlModelContainerBase::createInstanceWithArguments: can't pass the arguments!", xInstance );

    xInstanceInit->initialize( i_arguments );

    return xInstance;

}

Sequence< OUString > ControlModelContainerBase::getAvailableServiceNames()

{

    return { u"com.sun.star.awt.UnoControlEditModel"_ustr,

            u"com.sun.star.awt.UnoControlFormattedFieldModel"_ustr,

            u"com.sun.star.awt.UnoControlFileControlModel"_ustr,

            u"com.sun.star.awt.UnoControlButtonModel"_ustr,

            u"com.sun.star.awt.UnoControlImageControlModel"_ustr,

            u"com.sun.star.awt.UnoControlRadioButtonModel"_ustr,

            u"com.sun.star.awt.UnoControlCheckBoxModel"_ustr,

            u"com.sun.star.awt.UnoControlFixedTextModel"_ustr,

            u"com.sun.star.awt.UnoControlGroupBoxModel"_ustr,

            u"com.sun.star.awt.UnoControlListBoxModel"_ustr,

            u"com.sun.star.awt.UnoControlComboBoxModel"_ustr,

            u"com.sun.star.awt.UnoControlDateFieldModel"_ustr,

            u"com.sun.star.awt.UnoControlTimeFieldModel"_ustr,

            u"com.sun.star.awt.UnoControlNumericFieldModel"_ustr,

            u"com.sun.star.awt.UnoControlCurrencyFieldModel"_ustr,

            u"com.sun.star.awt.UnoControlPatternFieldModel"_ustr,

            u"com.sun.star.awt.UnoControlProgressBarModel"_ustr,

            u"com.sun.star.awt.UnoControlScrollBarModel"_ustr,

            u"com.sun.star.awt.UnoControlFixedLineModel"_ustr,

            u"com.sun.star.awt.UnoControlRoadmapModel"_ustr,

            u"com.sun.star.awt.tree.TreeControlModel"_ustr,

            u"com.sun.star.awt.grid.UnoControlGridModel"_ustr,

            u"com.sun.star.awt.UnoControlFixedHyperlinkModel"_ustr,

            u"com.sun.star.awt.tab.UnoControlTabPageContainerModel"_ustr,

            u"com.sun.star.awt.tab.UnoControlTabPageModel"_ustr,

            u"com.sun.star.awt.UnoMultiPageModel"_ustr,

            u"com.sun.star.awt.UnoFrameModel"_ustr

    };

}

// XContainer

void ControlModelContainerBase::addContainerListener( const Reference< XContainerListener >& l )

{

    maContainerListeners.addInterface( l );

}

void ControlModelContainerBase::removeContainerListener( const Reference< XContainerListener >& l )

{

    maContainerListeners.removeInterface( l );

}

// XElementAccess

Type ControlModelContainerBase::getElementType()

{

    Type aType = cppu::UnoType<XControlModel>::get();

    return aType;

}

sal_Bool ControlModelContainerBase::hasElements()

{

    return !maModels.empty();

}

// XNameContainer, XNameReplace, XNameAccess

void ControlModelContainerBase::replaceByName( const OUString& aName, const Any& aElement )

{

    SolarMutexGuard aGuard;

    Reference< XControlModel > xNewModel;

    aElement >>= xNewModel;

    if ( !xNewModel.is() )

        throw IllegalArgumentException();

    UnoControlModelHolderVector::iterator aElementPos = ImplFindElement( aName );

    if ( maModels.end() == aElementPos )

        throw NoSuchElementException();

    // Dialog behaviour is to have all containee names unique (MSO Userform is the same)

    // With container controls you could have constructed an existing hierarchy and are now

    // add this to an existing container, in this case a name nested in the containment

    // hierarchy of the added control could contain a name clash, if we have access to the

    // list of global names then recursively check for previously existing names (we need

    // to do this obviously before the 'this' objects container is updated)

    Reference< XNameContainer > xAllChildren( getPropertyValue( GetPropertyName( BASEPROPERTY_USERFORMCONTAINEES ) ), UNO_QUERY );

    if ( xAllChildren.is() )

    {

        // remove old control (and children) from global list of containers

        updateUserFormChildren( xAllChildren, aName, Remove, uno::Reference< XControlModel >() );

        // Add new control (and containers if they exist)

        updateUserFormChildren( xAllChildren, aName, Insert, xNewModel );

    }

    // stop listening at the old model

    stopControlListening( aElementPos->first );

    Reference< XControlModel > xReplaced( aElementPos->first );

    // remember the new model, and start listening

    aElementPos->first = xNewModel;

    startControlListening( xNewModel );

    ContainerEvent aEvent;

    aEvent.Source = *this;

    aEvent.Element = aElement;

    aEvent.ReplacedElement <<= xReplaced;

    aEvent.Accessor <<= aName;

    // notify the container listener

    maContainerListeners.elementReplaced( aEvent );

    // our "tab controller model" has potentially changed -> notify this

    implNotifyTabModelChange( aName );

}

Any ControlModelContainerBase::getByName( const OUString& aName )

{

    UnoControlModelHolderVector::iterator aElementPos = ImplFindElement( aName );

    if ( maModels.end() == aElementPos )

        throw NoSuchElementException();

    return Any( aElementPos->first );

}

Sequence< OUString > ControlModelContainerBase::getElementNames()

{

    Sequence< OUString > aNames( maModels.size() );

    ::std::transform(

        maModels.begin(), maModels.end(),               // source range

        aNames.getArray(),                              // target range

        []( const UnoControlModelHolder& rUnoControlModelHolder )

        { return rUnoControlModelHolder.second; }        // operator to apply: select the second element (the name)

    );

    return aNames;

}

sal_Bool ControlModelContainerBase::hasByName( const OUString& aName )

{

    return maModels.end() != ImplFindElement( aName );

}

void ControlModelContainerBase::insertByName( const OUString& aName, const Any& aElement )

{

    SolarMutexGuard aGuard;

    Reference< XControlModel > xM;

    aElement >>= xM;

    if ( xM.is() )

    {

        Reference< beans::XPropertySet > xProps( xM, UNO_QUERY );

        if ( xProps.is() )

        {

                Reference< beans::XPropertySetInfo > xPropInfo = xProps->getPropertySetInfo();

                const OUString& sImageSourceProperty = GetPropertyName( BASEPROPERTY_IMAGEURL );

                if ( xPropInfo->hasPropertyByName(  sImageSourceProperty ) && ImplHasProperty(BASEPROPERTY_DIALOGSOURCEURL) )

                {

                    Any aUrl = xProps->getPropertyValue(  sImageSourceProperty );

                    OUString absoluteUrl =

                        getPhysicalLocation( getPropertyValue( GetPropertyName( BASEPROPERTY_DIALOGSOURCEURL ) ), aUrl );

                    aUrl <<= absoluteUrl;

                    xProps->setPropertyValue(  sImageSourceProperty , aUrl );

                }

        }

    }

    if ( aName.isEmpty() || !xM.is() )

        throw IllegalArgumentException();

    UnoControlModelHolderVector::iterator aElementPos = ImplFindElement( aName );

    if ( maModels.end() != aElementPos )

        throw ElementExistException();

    // Dialog behaviour is to have all containee names unique (MSO Userform is the same)

    // With container controls you could have constructed an existing hierarchy and are now

    // add this to an existing container, in this case a name nested in the containment

    // hierarchy of the added control could contain a name clash, if we have access to the

    // list of global names then we need to recursively check for previously existing

    // names (we need to do this obviously before the 'this' objects container is updated)

    // remove old control (and children) from global list of containers

    Reference< XNameContainer > xAllChildren( getPropertyValue( GetPropertyName( BASEPROPERTY_USERFORMCONTAINEES ) ), UNO_QUERY );

    if ( xAllChildren.is() )

        updateUserFormChildren( xAllChildren, aName, Insert, xM );

    maModels.emplace_back( xM, aName );

    mbGroupsUpToDate = false;

    startControlListening( xM );

    ContainerEvent aEvent;

    aEvent.Source = *this;

    aEvent.Element = aElement;

    aEvent.Accessor <<= aName;

    maContainerListeners.elementInserted( aEvent );

    // our "tab controller model" has potentially changed -> notify this

    implNotifyTabModelChange( aName );

}

void ControlModelContainerBase::removeByName( const OUString& aName )

{

    SolarMutexGuard aGuard;

    UnoControlModelHolderVector::iterator aElementPos = ImplFindElement( aName );

    if ( maModels.end() == aElementPos )

        throw NoSuchElementException();

    // Dialog behaviour is to have all containee names unique (MSO Userform is the same)

    // With container controls you could have constructed an existing hierarchy and are now

    // removing this control from an existing container, in this case all nested names in

    // the containment hierarchy of the control to be removed need to be removed from the global

    // names cache (we need to do this obviously before the 'this' objects container is updated)

    Reference< XNameContainer > xAllChildren( getPropertyValue( GetPropertyName( BASEPROPERTY_USERFORMCONTAINEES ) ), UNO_QUERY );

    if ( xAllChildren.is() )

        updateUserFormChildren( xAllChildren, aName, Remove, uno::Reference< XControlModel >() );

    ContainerEvent aEvent;

    aEvent.Source = *this;

    aEvent.Element <<= aElementPos->first;

    aEvent.Accessor <<= aName;

    maContainerListeners.elementRemoved( aEvent );

    stopControlListening( aElementPos->first );

    Reference< XPropertySet > xPS( aElementPos->first, UNO_QUERY );

    maModels.erase( aElementPos );

    mbGroupsUpToDate = false;

    if ( xPS.is() )

    {

        try

        {

            xPS->setPropertyValue( PROPERTY_RESOURCERESOLVER, Any( Reference< resource::XStringResourceResolver >() ) );

        }

        catch (const Exception&)

        {

            DBG_UNHANDLED_EXCEPTION("toolkit.controls");

        }

    }

    // our "tab controller model" has potentially changed -> notify this

    implNotifyTabModelChange( aName );

}

sal_Bool SAL_CALL ControlModelContainerBase::getGroupControl(  )

{

    return true;

}

void SAL_CALL ControlModelContainerBase::setGroupControl( sal_Bool )

{

    SAL_WARN("toolkit", "explicit grouping not supported" );

}

void SAL_CALL ControlModelContainerBase::setControlModels( const Sequence< Reference< XControlModel > >& _rControls )

{

    SolarMutexGuard aGuard;

    // set the tab indexes according to the order of models in the sequence

    sal_Int16 nTabIndex = 1;

    for ( auto const & control : _rControls )

    {

        // look up the control in our own structure. This is to prevent invalid arguments

        UnoControlModelHolderVector::const_iterator aPos =

            ::std::find_if(

                maModels.begin(), maModels.end(),

                CompareControlModel( control )

            );

        if ( maModels.end() != aPos )

        {

            // okay, this is an existent model

            // now set the TabIndex property (if applicable)

            Reference< XPropertySet > xProps( aPos->first, UNO_QUERY );

            Reference< XPropertySetInfo > xPSI;

            if ( xProps.is() )

                xPSI = xProps->getPropertySetInfo();

            if ( xPSI.is() && xPSI->hasPropertyByName( aTabIndexPropertyNameStr ) )

                xProps->setPropertyValue( aTabIndexPropertyNameStr, Any( nTabIndex++ ) );

        }

        mbGroupsUpToDate = false;

    }

}

typedef ::std::multimap< sal_Int32, Reference< XControlModel > > MapIndexToModel;

Sequence< Reference< XControlModel > > SAL_CALL ControlModelContainerBase::getControlModels(  )

{

    SolarMutexGuard aGuard;

    MapIndexToModel aSortedModels;

        // will be the sorted container of all models which have a tab index property

    ::std::vector< Reference< XControlModel > > aUnindexedModels;

        // will be the container of all models which do not have a tab index property

    for ( const auto& rModel : maModels )

    {

        Reference< XControlModel > xModel( rModel.first );

        // see if the model has a TabIndex property

        Reference< XPropertySet > xControlProps( xModel, UNO_QUERY );

        Reference< XPropertySetInfo > xPSI;

        if ( xControlProps.is() )

            xPSI = xControlProps->getPropertySetInfo( );

        DBG_ASSERT( xPSI.is(), "ControlModelContainerBase::getControlModels: invalid child model!" );

        // has it?

        if ( xPSI.is() && xPSI->hasPropertyByName( aTabIndexPropertyNameStr ) )

        {   // yes

            sal_Int32 nTabIndex = -1;

            xControlProps->getPropertyValue( aTabIndexPropertyNameStr ) >>= nTabIndex;

            aSortedModels.emplace( nTabIndex, xModel );

        }

        else if ( xModel.is() )

            // no, it hasn't, but we have to include it, anyway

            aUnindexedModels.push_back( xModel );

    }

    // okay, here we have a container of all our models, sorted by tab index,

    // plus a container of "unindexed" models

    // -> merge them

    Sequence< Reference< XControlModel > > aReturn( aUnindexedModels.size() + aSortedModels.size() );

    ::std::transform(

            aSortedModels.begin(), aSortedModels.end(),

            ::std::copy( aUnindexedModels.begin(), aUnindexedModels.end(), aReturn.getArray() ),

            [] ( const MapIndexToModel::value_type& entryIndexToModel )

            { return entryIndexToModel.second; }

        );

    return aReturn;

}

void SAL_CALL ControlModelContainerBase::setGroup( const Sequence< Reference< XControlModel > >&, const OUString& )

{

    // not supported. We have only implicit grouping:

    // We only have a sequence of control models, and we _know_ (yes, that's a HACK relying on

    // implementation details) that VCL does grouping according to the order of controls automatically

    // At least VCL does this for all we're interested in: Radio buttons.

    SAL_WARN("toolkit", "grouping not supported" );

}

////----- XInitialization -------------------------------------------------------------------

void SAL_CALL ControlModelContainerBase::initialize (const Sequence<Any>& rArguments)

{

    if ( rArguments.getLength() == 1 )

    {

        sal_Int16 nPageId = -1;

        if ( !( rArguments[ 0 ] >>= nPageId ))

            throw lang::IllegalArgumentException();

        m_nTabPageId = nPageId;

    }

    else

        m_nTabPageId = -1;

}

::sal_Int16 SAL_CALL ControlModelContainerBase::getTabPageID()

{

    return m_nTabPageId;

}

sal_Bool SAL_CALL ControlModelContainerBase::getEnabled()

{

    SolarMutexGuard aGuard;

    bool bEnabled = false;

    getPropertyValue(GetPropertyName(BASEPROPERTY_ENABLED)) >>= bEnabled;

    return bEnabled;

}

void SAL_CALL ControlModelContainerBase::setEnabled( sal_Bool _enabled )

{

    SolarMutexGuard aGuard;

    setPropertyValue(GetPropertyName(BASEPROPERTY_ENABLED), Any(_enabled));

}

OUString SAL_CALL ControlModelContainerBase::getTitle()

{

    SolarMutexGuard aGuard;

    OUString sTitle;

    getPropertyValue(GetPropertyName(BASEPROPERTY_TITLE)) >>= sTitle;

    return sTitle;

}

void SAL_CALL ControlModelContainerBase::setTitle( const OUString& _title )

{

    SolarMutexGuard aGuard;

    setPropertyValue(GetPropertyName(BASEPROPERTY_TITLE),Any(_title));

}

OUString SAL_CALL ControlModelContainerBase::getImageURL()

{

    return m_sImageURL;

}

void SAL_CALL ControlModelContainerBase::setImageURL( const OUString& _imageurl )

{

    m_sImageURL = _imageurl;

    SolarMutexGuard aGuard;

    setPropertyValue(GetPropertyName(BASEPROPERTY_IMAGEURL), Any(_imageurl));

}

OUString SAL_CALL ControlModelContainerBase::getToolTip()

{

    return m_sTooltip;

}

void SAL_CALL ControlModelContainerBase::setToolTip( const OUString& _tooltip )

{

    m_sTooltip = _tooltip;

}

namespace

{

    enum GroupingMachineState

    {

        eLookingForGroup,

        eExpandingGroup

    };

    sal_Int32 lcl_getDialogStep( const Reference< XControlModel >& _rxModel )

    {

        sal_Int32 nStep = 0;

        try

        {

            Reference< XPropertySet > xModelProps( _rxModel, UNO_QUERY );

            xModelProps->getPropertyValue( u"Step"_ustr ) >>= nStep;

        }

        catch (const Exception&)

        {

            TOOLS_WARN_EXCEPTION("toolkit", "caught an exception while determining the dialog page" );

        }

        return nStep;

    }

}

sal_Int32 SAL_CALL ControlModelContainerBase::getGroupCount(  )

{

    SolarMutexGuard aGuard;

    implUpdateGroupStructure();

    return maGroups.size();

}

void SAL_CALL ControlModelContainerBase::getGroup( sal_Int32 _nGroup, Sequence< Reference< XControlModel > >& _rGroup, OUString& _rName )

{

    SolarMutexGuard aGuard;

    implUpdateGroupStructure();

    if ( ( _nGroup < 0 ) || ( o3tl::make_unsigned(_nGroup) >= maGroups.size() ) )

    {

        SAL_WARN("toolkit", "invalid argument and I am not allowed to throw exception!" );

        _rGroup.realloc( 0 );

        _rName.clear();

    }

    else

    {

        AllGroups::const_iterator aGroupPos = maGroups.begin() + _nGroup;

        _rGroup.realloc( aGroupPos->size() );

        // copy the models

        ::std::copy( aGroupPos->begin(), aGroupPos->end(), _rGroup.getArray() );

        // give the group a name

        _rName = OUString::number( _nGroup );

    }

}

void SAL_CALL ControlModelContainerBase::getGroupByName( const OUString& _rName, Sequence< Reference< XControlModel > >& _rGroup )

{

    SolarMutexGuard aGuard;

    OUString sDummyName;

    getGroup( _rName.toInt32( ), _rGroup, sDummyName );

}

void SAL_CALL ControlModelContainerBase::addChangesListener( const Reference< XChangesListener >& _rxListener )

{

    std::unique_lock g(m_aMutex);

    maChangeListeners.addInterface( g, _rxListener );

}

void SAL_CALL ControlModelContainerBase::removeChangesListener( const Reference< XChangesListener >& _rxListener )

{

    std::unique_lock g(m_aMutex);

    maChangeListeners.removeInterface( g, _rxListener );

}

void ControlModelContainerBase::implNotifyTabModelChange( const OUString& _rAccessor )

{

    // multiplex to our change listeners:

    // the changes event

    ChangesEvent aEvent;

    aEvent.Source = *this;

    aEvent.Base <<= aEvent.Source;  // the "base of the changes root" is also ourself

    aEvent.Changes.realloc( 1 );    // exactly one change

    aEvent.Changes.getArray()[ 0 ].Accessor <<= _rAccessor;

    std::unique_lock g(m_aMutex);

    std::vector< Reference< css::util::XChangesListener > > aChangeListeners( maChangeListeners.getElements(g) );

    g.unlock();

    for ( const auto& rListener : aChangeListeners )

        rListener->changesOccurred( aEvent );

}

void ControlModelContainerBase::implUpdateGroupStructure()

{

    if ( mbGroupsUpToDate )

        // nothing to do

        return;

    // conditions for a group:

    // * all elements of the group are radio buttons

    // * all elements of the group are on the same dialog page

    // * in the overall control order (determined by the tab index), all elements are subsequent

    maGroups.clear();

    const Sequence< Reference< XControlModel > > aControlModels = getControlModels();

    // in extreme we have as much groups as controls

    maGroups.reserve( aControlModels.getLength() );

    GroupingMachineState eState = eLookingForGroup;     // the current state of our machine

    Reference< XServiceInfo > xModelSI;                 // for checking for a radio button

    AllGroups::iterator aCurrentGroup = maGroups.end(); // the group which we're currently building

    sal_Int32   nCurrentGroupStep = -1;                 // the step which all controls of the current group belong to

    for ( const Reference< XControlModel >& rControlModel : aControlModels )

    {

        // we'll need this in every state

        xModelSI.set(rControlModel, css::uno::UNO_QUERY);

        // is it a radio button?

        bool bIsRadioButton = xModelSI.is() && xModelSI->supportsService( u"com.sun.star.awt.UnoControlRadioButtonModel"_ustr );

        switch ( eState )

        {

            case eLookingForGroup:

            {

                if ( !bIsRadioButton )

                    // this is no radio button -> still looking for the beginning of a group

                    continue;

                // the current model is a radio button

                // -> we found the beginning of a new group

                // create the place for this group

                size_t nGroups = maGroups.size();

                maGroups.resize( nGroups + 1 );

                aCurrentGroup = maGroups.begin() + nGroups;

                // and add the (only, til now) member

                aCurrentGroup->push_back( rControlModel );

                // get the step which all controls of this group now have to belong to

                nCurrentGroupStep = lcl_getDialogStep( rControlModel );

                // new state: looking for further members

                eState = eExpandingGroup;

            }

            break;

            case eExpandingGroup:

            {

                if ( !bIsRadioButton )

                {   // no radio button -> the group is done

                    aCurrentGroup = maGroups.end();

                    eState = eLookingForGroup;

                    continue;

                }

                // it is a radio button - is it on the proper page?

                const sal_Int32 nThisModelStep = lcl_getDialogStep( rControlModel );

                if  (   ( nThisModelStep == nCurrentGroupStep ) // the current button is on the same dialog page

                    ||  ( 0 == nThisModelStep )                 // the current button appears on all pages

                    )

                {

                    // -> it belongs to the same group

                    aCurrentGroup->push_back( rControlModel );