/* -*- 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 <memory>

#include <fmdocumentclassification.hxx>

#include <fmobj.hxx>

#include <fmpgeimp.hxx>

#include <fmprop.hxx>

#include <svx/strings.hrc>

#include <fmservs.hxx>

#include <fmshimp.hxx>

#include <svx/fmtools.hxx>

#include <fmvwimp.hxx>

#include <formcontrolfactory.hxx>

#include <svx/sdrpaintwindow.hxx>

#include <svx/svditer.hxx>

#include <svx/dataaccessdescriptor.hxx>

#include <svx/dialmgr.hxx>

#include <svx/svdobjkind.hxx>

#include <svx/fmmodel.hxx>

#include <svx/fmpage.hxx>

#include <svx/fmshell.hxx>

#include <svx/fmview.hxx>

#include <svx/sdrpagewindow.hxx>

#include <svx/svdogrp.hxx>

#include <svx/svdpagv.hxx>

#include <svx/xmlexchg.hxx>

#include <toolkit/controls/unocontrolcontainer.hxx>

#include <toolkit/helper/vclunohelper.hxx>

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

#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>

#include <com/sun/star/sdbc/XRowSet.hpp>

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

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

#include <com/sun/star/sdb/CommandType.hpp>

#include <com/sun/star/sdbc/DataType.hpp>

#include <com/sun/star/form/FormComponentType.hpp>

#include <com/sun/star/form/FormButtonType.hpp>

#include <com/sun/star/form/binding/XBindableValue.hpp>

#include <com/sun/star/form/binding/XValueBinding.hpp>

#include <com/sun/star/form/runtime/FormController.hpp>

#include <com/sun/star/form/submission/XSubmissionSupplier.hpp>

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

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

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

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

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

#include <com/sun/star/sdbc/SQLException.hpp>

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

#include <comphelper/namedvaluecollection.hxx>

#include <comphelper/property.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/types.hxx>

#include <cppuhelper/exc_hlp.hxx>

#include <unotools/moduleoptions.hxx>

#include <tools/debug.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <sal/log.hxx>

#include <utility>

#include <vcl/svapp.hxx>

#include <vcl/stdtext.hxx>

#include <vcl/window.hxx>

#include <connectivity/dbtools.hxx>

#include <algorithm>

using namespace ::comphelper;

using namespace ::svx;

using namespace ::svxform;

using namespace ::dbtools;

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

    using ::com::sun::star::uno::Exception;

    using ::com::sun::star::uno::XInterface;

    using ::com::sun::star::uno::Sequence;

    using ::com::sun::star::uno::UNO_QUERY;

    using ::com::sun::star::uno::UNO_QUERY_THROW;

    using ::com::sun::star::uno::UNO_SET_THROW;

    using ::com::sun::star::uno::Type;

    using ::com::sun::star::uno::Reference;

    using ::com::sun::star::uno::Any;

    using ::com::sun::star::uno::XComponentContext;

    using ::com::sun::star::form::FormButtonType_SUBMIT;

    using ::com::sun::star::form::binding::XValueBinding;

    using ::com::sun::star::form::binding::XBindableValue;

    using ::com::sun::star::lang::XComponent;

    using ::com::sun::star::container::XIndexAccess;

    using ::com::sun::star::form::runtime::FormController;

    using ::com::sun::star::form::runtime::XFormController;

    using ::com::sun::star::script::XEventAttacherManager;

    using ::com::sun::star::awt::XTabControllerModel;

    using ::com::sun::star::container::XChild;

    using ::com::sun::star::task::XInteractionHandler;

    using ::com::sun::star::awt::XTabController;

    using ::com::sun::star::awt::XControlContainer;

    using ::com::sun::star::awt::XControl;

    using ::com::sun::star::form::XFormComponent;

    using ::com::sun::star::form::XForm;

    using ::com::sun::star::lang::IndexOutOfBoundsException;

    using ::com::sun::star::container::XContainer;

    using ::com::sun::star::container::ContainerEvent;

    using ::com::sun::star::lang::EventObject;

    using ::com::sun::star::sdb::SQLErrorEvent;

    using ::com::sun::star::sdbc::XRowSet;

    using ::com::sun::star::beans::XPropertySet;

    using ::com::sun::star::container::XElementAccess;

    using ::com::sun::star::awt::XWindow;

    using ::com::sun::star::awt::FocusEvent;

    using ::com::sun::star::ui::dialogs::XExecutableDialog;

    using ::com::sun::star::sdbc::XDataSource;

    using ::com::sun::star::container::XIndexContainer;

    using ::com::sun::star::sdbc::XConnection;

    using ::com::sun::star::container::XNameAccess;

    using ::com::sun::star::sdbc::SQLException;

    using ::com::sun::star::util::XNumberFormatsSupplier;

    using ::com::sun::star::util::XNumberFormats;

    using ::com::sun::star::beans::XPropertySetInfo;

    namespace FormComponentType = ::com::sun::star::form::FormComponentType;

    namespace CommandType = ::com::sun::star::sdb::CommandType;

    namespace DataType = ::com::sun::star::sdbc::DataType;

class FmXFormView::ObjectRemoveListener : public SfxListener

{

    FmXFormView* m_pParent;

public:

    explicit ObjectRemoveListener( FmXFormView* pParent );

    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;

};

FormViewPageWindowAdapter::FormViewPageWindowAdapter( css::uno::Reference<css::uno::XComponentContext> _xContext, const SdrPageWindow& _rWindow, FmXFormView* _pViewImpl )

:   m_xControlContainer( _rWindow.GetControlContainer() ),

    m_xContext(std::move( _xContext )),

    m_pViewImpl( _pViewImpl ),

    m_pWindow( _rWindow.GetPaintWindow().GetOutputDevice().GetOwnerWindow() )

{

    // create an XFormController for every form

    FmFormPage* pFormPage = dynamic_cast< FmFormPage* >( _rWindow.GetPageView().GetPage() );

    DBG_ASSERT( pFormPage, "FormViewPageWindowAdapter::FormViewPageWindowAdapter: no FmFormPage found!" );

    if ( !pFormPage )

        return;

    try

    {

        Reference< XIndexAccess > xForms( pFormPage->GetForms(), UNO_QUERY_THROW );

        sal_uInt32 nLength = xForms->getCount();

        for (sal_uInt32 i = 0; i < nLength; i++)

        {

            Reference< XForm > xForm( xForms->getByIndex(i), UNO_QUERY );

            if ( xForm.is() )

                setController( xForm, nullptr );

        }

    }

    catch (const Exception&)

    {

        DBG_UNHANDLED_EXCEPTION("svx");

    }

}

FormViewPageWindowAdapter::~FormViewPageWindowAdapter()

{

}

void FormViewPageWindowAdapter::dispose()

{

    for (   ::std::vector< Reference< XFormController > >::const_iterator i = m_aControllerList.begin();

            i != m_aControllerList.end();

            ++i

        )

    {

        try

        {

            Reference< XFormController > xController( *i, UNO_SET_THROW );

            // detaching the events

            Reference< XChild > xControllerModel( xController->getModel(), UNO_QUERY );

            if ( xControllerModel.is() )

            {

                Reference< XEventAttacherManager >  xEventManager( xControllerModel->getParent(), UNO_QUERY_THROW );

                Reference< XInterface > xControllerNormalized( xController, UNO_QUERY_THROW );

                xEventManager->detach( i - m_aControllerList.begin(), xControllerNormalized );

            }

            // dispose the formcontroller

            xController->dispose();

        }

        catch (const Exception&)

        {

            DBG_UNHANDLED_EXCEPTION("svx");

        }

    }

    m_aControllerList.clear();

}

sal_Bool SAL_CALL FormViewPageWindowAdapter::hasElements()

{

    return getCount() != 0;

}

Type SAL_CALL  FormViewPageWindowAdapter::getElementType()

{

    return cppu::UnoType<XFormController>::get();

}

// XIndexAccess

sal_Int32 SAL_CALL FormViewPageWindowAdapter::getCount()

{

    return m_aControllerList.size();

}

Any SAL_CALL FormViewPageWindowAdapter::getByIndex(sal_Int32 nIndex)

{

    if (nIndex < 0 ||

        nIndex >= getCount())

        throw IndexOutOfBoundsException();

    Any aElement;

    aElement <<= m_aControllerList[nIndex];

    return aElement;

}

void SAL_CALL FormViewPageWindowAdapter::makeVisible( const Reference< XControl >& Control )

{

    SolarMutexGuard aSolarGuard;

    Reference< XWindow >  xWindow( Control, UNO_QUERY );

    if ( xWindow.is() && m_pViewImpl->getView() && m_pWindow )

    {

        awt::Rectangle aRect = xWindow->getPosSize();

        ::tools::Rectangle aNewRect( aRect.X, aRect.Y, aRect.X + aRect.Width, aRect.Y + aRect.Height );

        aNewRect = m_pWindow->PixelToLogic( aNewRect );

        m_pViewImpl->getView()->MakeVisible( aNewRect, *m_pWindow );

    }

}

static Reference< XFormController >  getControllerSearchChildren( const Reference< XIndexAccess > & xIndex, const Reference< XTabControllerModel > & xModel)

{

    if (xIndex.is() && xIndex->getCount())

    {

        Reference< XFormController >  xController;

        for (sal_Int32 n = xIndex->getCount(); n-- && !xController.is(); )

        {

            xIndex->getByIndex(n) >>= xController;

            if (xModel.get() == xController->getModel().get())

                return xController;

            else

            {

                xController = getControllerSearchChildren(xController, xModel);

                if ( xController.is() )

                    return xController;

            }

        }

    }

    return Reference< XFormController > ();

}

// Search the according controller

Reference< XFormController >  FormViewPageWindowAdapter::getController( const Reference< XForm > & xForm ) const

{

    Reference< XTabControllerModel >  xModel(xForm, UNO_QUERY);

    for (const auto& rpController : m_aControllerList)

    {

        if (rpController->getModel().get() == xModel.get())

            return rpController;

        // the current-round controller isn't the right one. perhaps one of its children ?

        Reference< XFormController >  xChildSearch = getControllerSearchChildren(Reference< XIndexAccess > (rpController, UNO_QUERY), xModel);

        if (xChildSearch.is())

            return xChildSearch;

    }

    return Reference< XFormController > ();

}

void FormViewPageWindowAdapter::setController(const Reference< XForm > & xForm, const Reference< XFormController >& _rxParentController )

{

    DBG_ASSERT( xForm.is(), "FormViewPageWindowAdapter::setController: there should be a form!" );

    Reference< XIndexAccess >  xFormCps(xForm, UNO_QUERY);

    if (!xFormCps.is())

        return;

    Reference< XTabControllerModel >  xTabOrder(xForm, UNO_QUERY);

    // create a form controller

    Reference< XFormController > xController( FormController::create(m_xContext) );

    Reference< XInteractionHandler > xHandler;

    if ( _rxParentController.is() )

        xHandler = _rxParentController->getInteractionHandler();

    else

    {

        // TODO: should we create a default handler? Not really necessary, since the

        // FormController itself has a default fallback

    }

    if ( xHandler.is() )

        xController->setInteractionHandler( xHandler );

    xController->setContext( this );

    xController->setModel( xTabOrder );

    xController->setContainer( m_xControlContainer );

    xController->activateTabOrder();

    xController->addActivateListener( m_pViewImpl );

    if ( _rxParentController.is() )

        _rxParentController->addChildController( xController );

    else

    {

        m_aControllerList.push_back(xController);

        xController->setParent( *this );

        // attaching the events

        Reference< XEventAttacherManager > xEventManager( xForm->getParent(), UNO_QUERY );

        xEventManager->attach(m_aControllerList.size() - 1, Reference<XInterface>( xController, UNO_QUERY ), Any(xController) );

    }

    // now go through the subforms

    sal_uInt32 nLength = xFormCps->getCount();

    Reference< XForm >  xSubForm;

    for (sal_uInt32 i = 0; i < nLength; i++)

    {

        if ( xFormCps->getByIndex(i) >>= xSubForm )

            setController( xSubForm, xController );

    }

}

void FormViewPageWindowAdapter::updateTabOrder( const Reference< XForm >& _rxForm )

{

    OSL_PRECOND( _rxForm.is(), "FormViewPageWindowAdapter::updateTabOrder: illegal argument!" );

    if ( !_rxForm.is() )

        return;

    try

    {

        Reference< XTabController > xTabCtrl( getController( _rxForm ) );

        if ( xTabCtrl.is() )

        {   // if there already is a TabController for this form, then delegate the "updateTabOrder" request

            xTabCtrl->activateTabOrder();

        }

        else

        {   // otherwise, create a TabController

            // if it's a sub form, then we must ensure there exist TabControllers

            // for all its ancestors, too

            Reference< XForm > xParentForm( _rxForm->getParent(), UNO_QUERY );

            // there is a parent form -> look for the respective controller

            Reference< XFormController > xParentController;

            if ( xParentForm.is() )

                xParentController = getController( xParentForm );

            setController( _rxForm, xParentController );

        }

    }

    catch (const Exception&)

    {

        DBG_UNHANDLED_EXCEPTION("svx");

    }

}

FmXFormView::FmXFormView(FmFormView* _pView )

    :m_pMarkedGrid(nullptr)

    ,m_pView(_pView)

    ,m_nActivationEvent(nullptr)

    ,m_nErrorMessageEvent( nullptr )

    ,m_nAutoFocusEvent( nullptr )

    ,m_nControlWizardEvent( nullptr )

    ,m_bFirstActivation( true )

    ,m_isTabOrderUpdateSuspended( false )

{

}

void FmXFormView::cancelEvents()

{

    if ( m_nActivationEvent )

    {

        Application::RemoveUserEvent( m_nActivationEvent );

        m_nActivationEvent = nullptr;

    }

    if ( m_nErrorMessageEvent )

    {

        Application::RemoveUserEvent( m_nErrorMessageEvent );

        m_nErrorMessageEvent = nullptr;

    }

    if ( m_nAutoFocusEvent )

    {

        Application::RemoveUserEvent( m_nAutoFocusEvent );

        m_nAutoFocusEvent = nullptr;

    }

    if ( m_nControlWizardEvent )

    {

        Application::RemoveUserEvent( m_nControlWizardEvent );

        m_nControlWizardEvent = nullptr;

    }

}

void FmXFormView::notifyViewDying( )

{

    DBG_ASSERT( m_pView, "FmXFormView::notifyViewDying: my view already died!" );

    m_pView = nullptr;

    cancelEvents();

}

FmXFormView::~FmXFormView()

{

    DBG_ASSERT( m_aPageWindowAdapters.empty(), "FmXFormView::~FmXFormView: Window list not empty!" );

    for (const auto& rpAdapter : m_aPageWindowAdapters)

    {

        rpAdapter->dispose();

    }

    cancelEvents();

}

//      EventListener

void SAL_CALL FmXFormView::disposing(const EventObject& Source)

{

    if ( m_xWindow.is() && Source.Source == m_xWindow )

    {

        m_xWindow->removeFocusListener(this);

        if ( m_pView )

        {

            m_pView->SetMoveOutside( false, FmFormView::ImplAccess() );

        }

        m_xWindow = nullptr;

    }

}

// XFormControllerListener

void SAL_CALL FmXFormView::formActivated(const EventObject& rEvent)

{

    if ( m_pView && m_pView->GetFormShell() && m_pView->GetFormShell()->GetImpl() )

        m_pView->GetFormShell()->GetImpl()->formActivated( rEvent );

}

void SAL_CALL FmXFormView::formDeactivated(const EventObject& rEvent)

{

    if ( m_pView && m_pView->GetFormShell() && m_pView->GetFormShell()->GetImpl() )

        m_pView->GetFormShell()->GetImpl()->formDeactivated( rEvent );

}

// XContainerListener

void SAL_CALL FmXFormView::elementInserted(const ContainerEvent& evt)

{

    try

    {

        Reference< XControlContainer > xControlContainer( evt.Source, UNO_QUERY_THROW );

        Reference< XControl > xControl( evt.Element, UNO_QUERY_THROW );

        Reference< XFormComponent > xControlModel( xControl->getModel(), UNO_QUERY_THROW );

        Reference< XForm > xForm( xControlModel->getParent(), UNO_QUERY_THROW );

        if ( m_isTabOrderUpdateSuspended )

        {

            // remember the container and the control, so we can update the tab order on resumeTabOrderUpdate

            m_aNeedTabOrderUpdate[ xControlContainer ].insert( xForm );

        }

        else

        {

            rtl::Reference< FormViewPageWindowAdapter > pAdapter = findWindow( xControlContainer );

            if ( pAdapter.is() )

                pAdapter->updateTabOrder( xForm );

        }

    }

    catch (const Exception&)

    {

        DBG_UNHANDLED_EXCEPTION("svx");

    }

}

void SAL_CALL FmXFormView::elementReplaced(const ContainerEvent& evt)

{

    elementInserted(evt);

}

void SAL_CALL FmXFormView::elementRemoved(const ContainerEvent& /*evt*/)

{

}

rtl::Reference< FormViewPageWindowAdapter > FmXFormView::findWindow( const Reference< XControlContainer >& _rxCC )  const

{

    auto i = std::find_if(m_aPageWindowAdapters.begin(), m_aPageWindowAdapters.end(),

        [&_rxCC](const rtl::Reference< FormViewPageWindowAdapter >& rpAdapter) { return _rxCC == rpAdapter->getControlContainer(); });

    if (i != m_aPageWindowAdapters.end())

        return *i;

    return nullptr;

}

void FmXFormView::addWindow(const SdrPageWindow& rWindow)

{

    FmFormPage* pFormPage = dynamic_cast<FmFormPage*>( rWindow.GetPageView().GetPage()  );

    if ( !pFormPage )

        return;

    const rtl::Reference< UnoControlContainer > & xCC = rWindow.GetControlContainer();

    if  (   xCC.is()

        &&  ( !findWindow( xCC ).is() )

        )

    {

        rtl::Reference< FormViewPageWindowAdapter > pAdapter = new FormViewPageWindowAdapter( comphelper::getProcessComponentContext(), rWindow, this );

        m_aPageWindowAdapters.push_back( pAdapter );

        // listen at the ControlContainer to notice changes

        xCC->addContainerListener( this );

    }

}

void FmXFormView::removeWindow( const Reference< XControlContainer >& _rxCC )

{

    // Is called if

    // - the design mode is being switched to

    // - a window is deleted while in the design mode

    // - the control container for a window is removed while the active mode is on

    auto i = std::find_if(m_aPageWindowAdapters.begin(), m_aPageWindowAdapters.end(),

        [&_rxCC](const rtl::Reference< FormViewPageWindowAdapter >& rpAdapter) { return _rxCC == rpAdapter->getControlContainer(); });

    if (i != m_aPageWindowAdapters.end())

    {

        Reference< XContainer >  xContainer( _rxCC, UNO_QUERY );

        if ( xContainer.is() )

            xContainer->removeContainerListener( this );

        (*i)->dispose();

        m_aPageWindowAdapters.erase( i );

    }

}

void FmXFormView::displayAsyncErrorMessage( const SQLErrorEvent& _rEvent )

{

    DBG_ASSERT( nullptr == m_nErrorMessageEvent, "FmXFormView::displayAsyncErrorMessage: not too fast, please!" );

        // This should not happen - usually, the PostUserEvent is faster than any possible user

        // interaction which could trigger a new error. If it happens, we need a queue for the events.

    m_aAsyncError = _rEvent;

    m_nErrorMessageEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnDelayedErrorMessage ) );

}

IMPL_LINK_NOARG(FmXFormView, OnDelayedErrorMessage, void*, void)

{

    m_nErrorMessageEvent = nullptr;

    displayException(m_aAsyncError, GetParentWindow());

}

void FmXFormView::onFirstViewActivation( const FmFormModel* _pDocModel )

{

    if ( _pDocModel && _pDocModel->GetAutoControlFocus() )

        m_nAutoFocusEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnAutoFocus ) );

}

void FmXFormView::suspendTabOrderUpdate()

{

    OSL_ENSURE( !m_isTabOrderUpdateSuspended, "FmXFormView::suspendTabOrderUpdate: nesting not allowed!" );

    m_isTabOrderUpdateSuspended = true;

}

void FmXFormView::resumeTabOrderUpdate()

{

    OSL_ENSURE( m_isTabOrderUpdateSuspended, "FmXFormView::resumeTabOrderUpdate: not suspended!" );

    m_isTabOrderUpdateSuspended = false;

    // update the tab orders for all components which were collected since the suspendTabOrderUpdate call.

    for (const auto& rContainer : m_aNeedTabOrderUpdate)

    {

        rtl::Reference< FormViewPageWindowAdapter > pAdapter = findWindow( rContainer.first );

        if ( !pAdapter.is() )

            continue;

        for (const auto& rForm : rContainer.second)

        {

            pAdapter->updateTabOrder( rForm );

        }

    }

    m_aNeedTabOrderUpdate.clear();

}

namespace

{

    bool isActivableDatabaseForm(const Reference< XFormController > &xController)

    {

        // only database forms are to be activated

        Reference< XRowSet >  xForm(xController->getModel(), UNO_QUERY);

        if ( !xForm.is() || !getConnection( xForm ).is() )

            return false;

        Reference< XPropertySet > xFormSet( xForm, UNO_QUERY );

        if ( !xFormSet.is() )

        {

            SAL_WARN( "svx.form", "FmXFormView::OnActivate: a form which does not have properties?" );

            return false;

        }

        const OUString aSource = ::comphelper::getString( xFormSet->getPropertyValue( FM_PROP_COMMAND ) );

        return !aSource.isEmpty();

    }

    class find_active_databaseform

    {

        const Reference< XFormController > xActiveController;

    public:

        explicit find_active_databaseform( const Reference< XFormController >& _xActiveController )

            : xActiveController(_xActiveController )

        {}

        Reference < XFormController > operator() (const Reference< XFormController > &xController)

        {

            if(xController == xActiveController && isActivableDatabaseForm(xController))

                return xController;

            if ( !xController.is() )

            {

                SAL_WARN( "svx.form", "FmXFormView::OnActivate: a form controller which does not have children?" );

                return nullptr;

            }

            for(sal_Int32 i = 0; i < xController->getCount(); ++i)

            {

                const Any a(xController->getByIndex(i));

                Reference < XFormController > xI;

                if ((a >>= xI) && xI.is())

                {

                    Reference < XFormController > xRes(operator()(xI));

                    if (xRes.is())

                        return xRes;

                }

            }

            return nullptr;

        }

    };

}

IMPL_LINK_NOARG(FmXFormView, OnActivate, void*, void)

{

    m_nActivationEvent = nullptr;

    if ( !m_pView )

    {

        OSL_FAIL( "FmXFormView::OnActivate: well... seems we have a timing problem (the view already died)!" );

        return;

    }

    // setting the controller to activate

    if (!(m_pView->GetFormShell() && m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW))

        return;

    FmXFormShell* const pShImpl =  m_pView->GetFormShell()->GetImpl();

    if(!pShImpl)

        return;

    find_active_databaseform fad(pShImpl->getActiveController_Lock());

    vcl::Window* pWindow = m_pView->GetActualOutDev()->GetOwnerWindow();

    rtl::Reference< FormViewPageWindowAdapter > pAdapter = m_aPageWindowAdapters.empty() ? nullptr : m_aPageWindowAdapters[0];

    for (const auto& rpPageWindowAdapter : m_aPageWindowAdapters)

    {

        if ( pWindow == rpPageWindowAdapter->getWindow() )

            pAdapter = rpPageWindowAdapter;

    }

    if ( !pAdapter.is() )

        return;

    Reference< XFormController > xControllerToActivate;

    for (const Reference< XFormController > & xController : pAdapter->GetList())

    {

        if ( !xController.is() )

            continue;

        {

            Reference< XFormController > xActiveController(fad(xController));

            if (xActiveController.is())

            {

                xControllerToActivate = std::move(xActiveController);

                break;

            }

        }

        if(xControllerToActivate.is() || !isActivableDatabaseForm(xController))

            continue;

        xControllerToActivate = xController;

    }

    pShImpl->setActiveController_Lock(xControllerToActivate);

}

void FmXFormView::Activate(bool bSync)

{

    if (m_nActivationEvent)

    {

        Application::RemoveUserEvent(m_nActivationEvent);

        m_nActivationEvent = nullptr;

    }

    if (bSync)

    {

        LINK(this,FmXFormView,OnActivate).Call(nullptr);

    }

    else

        m_nActivationEvent = Application::PostUserEvent(LINK(this,FmXFormView,OnActivate));

}

void FmXFormView::Deactivate(bool bDeactivateController)

{

    if (m_nActivationEvent)

    {

        Application::RemoveUserEvent(m_nActivationEvent);

        m_nActivationEvent = nullptr;

    }

    FmXFormShell* pShImpl =  m_pView->GetFormShell() ? m_pView->GetFormShell()->GetImpl() : nullptr;

    if (pShImpl && bDeactivateController)

        pShImpl->setActiveController_Lock(nullptr);

}

FmFormShell* FmXFormView::GetFormShell() const

{

    return m_pView ? m_pView->GetFormShell() : nullptr;

}

void FmXFormView::AutoFocus()

{

    if (m_nAutoFocusEvent)

        Application::RemoveUserEvent(m_nAutoFocusEvent);

    m_nAutoFocusEvent = Application::PostUserEvent(LINK(this, FmXFormView, OnAutoFocus));

}

bool FmXFormView::isFocusable( const Reference< XControl >& i_rControl )

{

    if ( !i_rControl.is() )

        return false;

    try

    {

        Reference< XPropertySet > xModelProps( i_rControl->getModel(), UNO_QUERY_THROW );

        // only enabled controls are allowed to participate

        bool bEnabled = false;

        OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_ENABLED ) >>= bEnabled );

        if ( !bEnabled )

            return false;

        // check the class id of the control model

        sal_Int16 nClassId = FormComponentType::CONTROL;

        OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId );

        // controls which are not focussable

        if  (   ( FormComponentType::CONTROL != nClassId )

            &&  ( FormComponentType::IMAGEBUTTON != nClassId )

            &&  ( FormComponentType::GROUPBOX != nClassId )

            &&  ( FormComponentType::FIXEDTEXT != nClassId )

            &&  ( FormComponentType::HIDDENCONTROL != nClassId )

            &&  ( FormComponentType::IMAGECONTROL != nClassId )

            &&  ( FormComponentType::SCROLLBAR != nClassId )

            &&  ( FormComponentType::SPINBUTTON!= nClassId )

            )

        {

            return true;

        }

    }

    catch (const Exception&)

    {

        DBG_UNHANDLED_EXCEPTION("svx");

    }

    return false;

}

static Reference< XControl > lcl_firstFocussableControl( const Sequence< Reference< XControl > >& _rControls )

{

    Reference< XControl > xReturn;

    // loop through all the controls

    for ( auto const & control : _rControls )

    {

        if ( !control.is() )

            continue;

        if ( FmXFormView::isFocusable( control ) )

        {

            xReturn = control;

            break;

        }

    }

    if ( !xReturn.is() && _rControls.hasElements() )

        xReturn = _rControls[0];

    return xReturn;

}

namespace

{

    void lcl_ensureControlsOfFormExist_nothrow( const SdrPage& _rPage, const SdrView& _rView, const vcl::Window& _rWindow, const Reference< XForm >& _rxForm )

    {

        try

        {

            Reference< XInterface > xNormalizedForm( _rxForm, UNO_QUERY_THROW );

            SdrObjListIter aSdrObjectLoop( &_rPage, SdrIterMode::DeepNoGroups );

            while ( aSdrObjectLoop.IsMore() )

            {

                FmFormObj* pFormObject = FmFormObj::GetFormObject( aSdrObjectLoop.Next() );

                if ( !pFormObject )

                    continue;

                Reference< XChild > xModel( pFormObject->GetUnoControlModel(), UNO_QUERY_THROW );

                Reference< XInterface > xModelParent( xModel->getParent(), UNO_QUERY );

                if ( xNormalizedForm.get() != xModelParent.get() )

                    continue;

                pFormObject->GetUnoControl( _rView, *_rWindow.GetOutDev() );

            }

        }

        catch (const Exception&)

        {

            DBG_UNHANDLED_EXCEPTION("svx");

        }

    }

}

Reference< XFormController > FmXFormView::getFormController( const Reference< XForm >& _rxForm, const OutputDevice& _rDevice ) const

{

    Reference< XFormController > xController;

    for (const rtl::Reference< FormViewPageWindowAdapter >& pAdapter : m_aPageWindowAdapters)

    {

        if ( !pAdapter )

        {

            SAL_WARN( "svx.form", "FmXFormView::getFormController: invalid page window adapter!" );

            continue;

        }

        if ( pAdapter->getWindow() != _rDevice.GetOwnerWindow() )

            // wrong device

            continue;

        xController = pAdapter->getController( _rxForm );

        if ( xController.is() )

            break;

    }

    return xController;

}

IMPL_LINK_NOARG(FmXFormView, OnAutoFocus, void*, void)

{

    m_nAutoFocusEvent = nullptr;

    // go to the first form of our page, examine it's TabController, go to its first (in terms of the tab order)

    // control, give it the focus

    SdrPageView *pPageView = m_pView ? m_pView->GetSdrPageView() : nullptr;

    SdrPage *pSdrPage = pPageView ? pPageView->GetPage() : nullptr;

    // get the forms collection of the page we belong to

    FmFormPage* pPage = dynamic_cast<FmFormPage*>( pSdrPage  );

    Reference< XIndexAccess > xForms( pPage ? Reference< XIndexAccess >( pPage->GetForms() ) : Reference< XIndexAccess >() );

    const rtl::Reference< FormViewPageWindowAdapter > pAdapter = m_aPageWindowAdapters.empty() ? nullptr : m_aPageWindowAdapters[0];

    const vcl::Window* pWindow = pAdapter ? pAdapter->getWindow() : nullptr;

    ENSURE_OR_RETURN_VOID( xForms.is() && pWindow, "FmXFormView::OnAutoFocus: could not collect all essentials!" );

    try

    {

        // go for the tab controller of the first form

        if ( !xForms->getCount() )

            return;

        Reference< XForm > xForm( xForms->getByIndex( 0 ), UNO_QUERY_THROW );

        Reference< XTabController > xTabController( pAdapter->getController( xForm ), UNO_QUERY_THROW );

        // go for the first control of the controller

        Sequence< Reference< XControl > > aControls( xTabController->getControls() );

        if ( !aControls.hasElements() )

        {

            Reference< XElementAccess > xFormElementAccess( xForm, UNO_QUERY_THROW );

            if (xFormElementAccess->hasElements() && pPage && m_pView)

            {

                // there are control models in the form, but no controls, yet.

                // Well, since some time controls are created on demand only. In particular,

                // they're normally created when they're first painted.

                // Unfortunately, the FormController does not have any way to

                // trigger the creation itself, so we must hack this ...

                lcl_ensureControlsOfFormExist_nothrow( *pPage, *m_pView, *pWindow, xForm );

                aControls = xTabController->getControls();

                OSL_ENSURE( aControls.hasElements(), "FmXFormView::OnAutoFocus: no controls at all!" );

            }

        }