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

#include <svx/fmshell.hxx>

#include <svx/fmtools.hxx>

#include <fmprop.hxx>

#include <fmundo.hxx>

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

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

#include <sfx2/viewfrm.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/Builder.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <svl/whiter.hxx>

#include <sfx2/app.hxx>

#include <svl/intitem.hxx>

#include <svl/stritem.hxx>

#include <svl/visitem.hxx>

#include <unotools/moduleoptions.hxx>

#include <sfx2/objface.hxx>

#include <sfx2/toolbarids.hxx>

#include <sfx2/request.hxx>

#include <sfx2/dispatch.hxx>

#include <svx/svdobj.hxx>

#include <svx/fmpage.hxx>

#include <svx/svditer.hxx>

#include <svx/svxids.hrc>

#include <svx/svdobjkind.hxx>

#include <svl/eitem.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <svx/svdpage.hxx>

#include <svx/fmmodel.hxx>

#include <fmshimp.hxx>

#include <svx/svdpagv.hxx>

#include <sfx2/objitem.hxx>

#include <sfx2/viewsh.hxx>

#include <fmexpl.hxx>

#include <formcontrolling.hxx>

#include <comphelper/types.hxx>

#include <fmdocumentclassification.hxx>

#include <formtoolbars.hxx>

#include <svx/svxdlg.hxx>

#include <svx/sdrobjectfilter.hxx>

#define ShellClass_FmFormShell

#include <svxslots.hxx>

#include <memory>

// is used for Invalidate -> maintain it as well

// sort ascending !!!!!!

sal_uInt16 const ControllerSlotMap[] =    // slots of the controller

{

    SID_FM_CONFIG,

    SID_FM_PUSHBUTTON,

    SID_FM_RADIOBUTTON,

    SID_FM_CHECKBOX,

    SID_FM_FIXEDTEXT,

    SID_FM_GROUPBOX,

    SID_FM_EDIT,

    SID_FM_LISTBOX,

    SID_FM_COMBOBOX,

    SID_FM_DBGRID,

    SID_FM_IMAGEBUTTON,

    SID_FM_FILECONTROL,

    SID_FM_NAVIGATIONBAR,

    SID_FM_CTL_PROPERTIES,

    SID_FM_PROPERTIES,

    SID_FM_TAB_DIALOG,

    SID_FM_ADD_FIELD,

    SID_FM_DESIGN_MODE,

    SID_FM_SHOW_FMEXPLORER,

    SID_FM_SHOW_PROPERTIES,

    SID_FM_FMEXPLORER_CONTROL,

    SID_FM_DATEFIELD,

    SID_FM_TIMEFIELD,

    SID_FM_NUMERICFIELD,

    SID_FM_CURRENCYFIELD,

    SID_FM_PATTERNFIELD,

    SID_FM_OPEN_READONLY,

    SID_FM_IMAGECONTROL,

    SID_FM_USE_WIZARDS,

    SID_FM_FORMATTEDFIELD,

    SID_FM_FILTER_NAVIGATOR,

    SID_FM_AUTOCONTROLFOCUS,

    SID_FM_SCROLLBAR,

    SID_FM_SPINBUTTON,

    SID_FM_SHOW_DATANAVIGATOR,

    SID_FM_DATANAVIGATOR_CONTROL,

    0

};

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

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

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

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

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

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

using namespace ::svxform;

FmDesignModeChangedHint::FmDesignModeChangedHint( bool bDesMode )

    :SfxHint(SfxHintId::FmDesignModeChanged), m_bDesignMode( bDesMode )

{

}

FmDesignModeChangedHint::~FmDesignModeChangedHint()

{

}

SFX_IMPL_INTERFACE(FmFormShell, SfxShell)

void FmFormShell::InitInterface_Impl()

{

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION, SfxVisibilityFlags::Standard|SfxVisibilityFlags::ReadonlyDoc,

                                            ToolbarId::SvxTbx_Form_Navigation,

                                            SfxShellFeature::FormShowDatabaseBar);

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION, SfxVisibilityFlags::Standard|SfxVisibilityFlags::ReadonlyDoc,

                                            ToolbarId::SvxTbx_Form_Filter,

                                            SfxShellFeature::FormShowFilterBar);

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Standard | SfxVisibilityFlags::ReadonlyDoc,

                                            ToolbarId::SvxTbx_Text_Control_Attributes,

                                            SfxShellFeature::FormShowTextControlBar);

    GetStaticInterface()->RegisterChildWindow(SID_FM_ADD_FIELD, false, SfxShellFeature::FormShowField);

    GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_PROPERTIES, false, SfxShellFeature::FormShowProperties);

    GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_FMEXPLORER, false, SfxShellFeature::FormShowExplorer);

    GetStaticInterface()->RegisterChildWindow(SID_FM_FILTER_NAVIGATOR, false, SfxShellFeature::FormShowFilterNavigator);

    GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_DATANAVIGATOR, false, SfxShellFeature::FormShowDataNavigator);

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Standard,

                                            ToolbarId::SvxTbx_Controls,

                                            SfxShellFeature::FormTBControls);

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Standard,

                                            ToolbarId::SvxTbx_FormDesign,

                                            SfxShellFeature::FormTBDesign);

}

FmFormShell::FmFormShell( SfxViewShell* _pParent, FmFormView* pView )

            :SfxShell(_pParent)

            ,m_pImpl(new FmXFormShell(*this, &_pParent->GetViewFrame()))

            ,m_pFormView( pView )

            ,m_pFormModel( nullptr )

            ,m_nLastSlot( 0 )

            ,m_bDesignMode( true )

            ,m_bHasForms(false)

{

    SetPool( &SfxGetpApp()->GetPool() );

    SetName( u"Form"_ustr );

    SetView(m_pFormView);

}

FmFormShell::~FmFormShell()

{

    if ( m_pFormView )

        SetView( nullptr );

    m_pImpl->dispose();

}

void FmFormShell::NotifyMarkListChanged(FmFormView* pWhichView)

{

    FmNavViewMarksChanged aChangeNotification(pWhichView);

    Broadcast(aChangeNotification);

}

bool FmFormShell::PrepareClose(bool bUI)

{

    if (GetImpl()->didPrepareClose_Lock())

        // we already made a PrepareClose for the current modifications of the current form

        return true;

    bool bResult = true;

    // Save the data records, not in DesignMode and FilterMode

    if (!m_bDesignMode && !GetImpl()->isInFilterMode_Lock() &&

        m_pFormView && m_pFormView->GetActualOutDev() &&

        m_pFormView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)

    {

        SdrPageView* pCurPageView = m_pFormView->GetSdrPageView();

        // sal_uInt16 nPos = pCurPageView ? pCurPageView->GetWinList().Find((OutputDevice*)m_pFormView->GetActualOutDev()) : SDRPAGEVIEWWIN_NOTFOUND;

        SdrPageWindow* pWindow = pCurPageView ? pCurPageView->FindPageWindow(*const_cast<OutputDevice*>(m_pFormView->GetActualOutDev())) : nullptr;

        if(pWindow)

        {

            // First, the current contents of the controls are stored.

            // If everything has gone smoothly, the modified records are stored.

            if (GetImpl()->getActiveController_Lock().is())

            {

                const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures_Lock();

                if ( rController->commitCurrentControl() )

                {

                    const bool bModified = rController->isModifiedRow();

                    if ( bModified && bUI )

                    {

                        SfxViewShell* pShell = GetViewShell();

                        vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : nullptr;

                        weld::Widget* pFrameWeld = pShellWnd ? pShellWnd->GetFrameWeld() : nullptr;

                        std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pFrameWeld, u"svx/ui/savemodifieddialog.ui"_ustr));

                        std::unique_ptr<weld::MessageDialog> xQry(xBuilder->weld_message_dialog(u"SaveModifiedDialog"_ustr));

                        switch (xQry->run())

                        {

                            case RET_YES:

                                bResult = rController->commitCurrentRecord( );

                                [[fallthrough]];

                            case RET_NO:

                                GetImpl()->didPrepareClose_Lock(true);

                                break;

                            case RET_CANCEL:

                                return false;

                        }

                    }

                }

            }

        }

    }

    return bResult;

}

void FmFormShell::impl_setDesignMode(bool bDesign)

{

    if (m_pFormView)

    {

        if (!bDesign)

            m_nLastSlot = SID_FM_DESIGN_MODE;

        GetImpl()->SetDesignMode_Lock(bDesign);

        // my m_bDesignMode is also set by the Impl ...

    }

    else

    {

        m_bHasForms = false;

        m_bDesignMode = bDesign;

        UIFeatureChanged();

    }

    GetViewShell()->GetViewFrame().GetBindings().Invalidate(ControllerSlotMap);

}

bool FmFormShell::HasUIFeature(SfxShellFeature nFeature) const

{

    assert((nFeature & ~SfxShellFeature::FormMask) == SfxShellFeature::NONE);

    bool bResult = false;

    if (nFeature & SfxShellFeature::FormShowDatabaseBar)

    {

        // only if forms are also available

        bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && !GetImpl()->isInFilterMode_Lock();

    }

    else if (nFeature & SfxShellFeature::FormShowFilterBar)

    {

        // only if forms are also available

        bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && GetImpl()->isInFilterMode_Lock();

    }

    else if (nFeature & SfxShellFeature::FormShowFilterNavigator)

    {

        bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar_Lock() && GetImpl()->isInFilterMode_Lock();

    }

    else if (nFeature & SfxShellFeature::FormShowField)

    {

        bResult = m_bDesignMode && m_pFormView && m_bHasForms;

    }

    else if (nFeature & SfxShellFeature::FormShowProperties)

    {

        bResult = m_bDesignMode && m_pFormView && m_bHasForms;

    }

    else if (nFeature & SfxShellFeature::FormShowExplorer)

    {

        bResult = m_bDesignMode; // OJ #101593# && m_pFormView && m_bHasForms;

    }

    else if (nFeature & SfxShellFeature::FormShowTextControlBar)

    {

        bResult = !GetImpl()->IsReadonlyDoc_Lock() && m_pImpl->IsActiveControl_Lock(true);

    }

    else if (nFeature & SfxShellFeature::FormShowDataNavigator)

    {

        bResult = GetImpl()->isEnhancedForm_Lock();

    }

    else if (  (nFeature & SfxShellFeature::FormTBControls)

            || (nFeature & SfxShellFeature::FormTBDesign)

            )

    {

        bResult = true;

    }

    return bResult;

}

void FmFormShell::Execute(SfxRequest &rReq)

{

    sal_uInt16 nSlot = rReq.GetSlot();

    // set MasterSlot

    switch( nSlot )

    {

        case SID_FM_PUSHBUTTON:

        case SID_FM_RADIOBUTTON:

        case SID_FM_CHECKBOX:

        case SID_FM_FIXEDTEXT:

        case SID_FM_GROUPBOX:

        case SID_FM_LISTBOX:

        case SID_FM_COMBOBOX:

        case SID_FM_NAVIGATIONBAR:

        case SID_FM_EDIT:

        case SID_FM_DBGRID:

        case SID_FM_IMAGEBUTTON:

        case SID_FM_IMAGECONTROL:

        case SID_FM_FILECONTROL:

        case SID_FM_DATEFIELD:

        case SID_FM_TIMEFIELD:

        case SID_FM_NUMERICFIELD:

        case SID_FM_CURRENCYFIELD:

        case SID_FM_PATTERNFIELD:

        case SID_FM_FORMATTEDFIELD:

        case SID_FM_SCROLLBAR:

        case SID_FM_SPINBUTTON:

            m_nLastSlot = nSlot;

            break;

    }

    // set the Identifier and Inventor of the Uno control

    SdrObjKind nIdentifier = SdrObjKind::NONE;

    switch( nSlot )

    {

        case SID_FM_CHECKBOX:

            nIdentifier = SdrObjKind::FormCheckbox;

            break;

        case SID_FM_PUSHBUTTON:

            nIdentifier = SdrObjKind::FormButton;

            break;

        case SID_FM_FIXEDTEXT:

            nIdentifier = SdrObjKind::FormFixedText;

            break;

        case SID_FM_LISTBOX:

            nIdentifier = SdrObjKind::FormListbox;

            break;

        case SID_FM_EDIT:

            nIdentifier = SdrObjKind::FormEdit;

            break;

        case SID_FM_RADIOBUTTON:

            nIdentifier = SdrObjKind::FormRadioButton;

            break;

        case SID_FM_GROUPBOX:

            nIdentifier = SdrObjKind::FormGroupBox;

            break;

        case SID_FM_COMBOBOX:

            nIdentifier = SdrObjKind::FormCombobox;

            break;

        case SID_FM_NAVIGATIONBAR:

            nIdentifier = SdrObjKind::FormNavigationBar;

            break;

        case SID_FM_DBGRID:

            nIdentifier = SdrObjKind::FormGrid;

            break;

        case SID_FM_IMAGEBUTTON:

            nIdentifier = SdrObjKind::FormImageButton;

            break;

        case SID_FM_IMAGECONTROL:

            nIdentifier = SdrObjKind::FormImageControl;

            break;

        case SID_FM_FILECONTROL:

            nIdentifier = SdrObjKind::FormFileControl;

            break;

        case SID_FM_DATEFIELD:

            nIdentifier = SdrObjKind::FormDateField;

            break;

        case SID_FM_TIMEFIELD:

            nIdentifier = SdrObjKind::FormTimeField;

            break;

        case SID_FM_NUMERICFIELD:

            nIdentifier = SdrObjKind::FormNumericField;

            break;

        case SID_FM_CURRENCYFIELD:

            nIdentifier = SdrObjKind::FormCurrencyField;

            break;

        case SID_FM_PATTERNFIELD:

            nIdentifier = SdrObjKind::FormPatternField;

            break;

        case SID_FM_FORMATTEDFIELD:

            nIdentifier = SdrObjKind::FormFormattedField;

            break;

        case SID_FM_SCROLLBAR:

            nIdentifier = SdrObjKind::FormScrollbar;

            break;

        case SID_FM_SPINBUTTON:

            nIdentifier = SdrObjKind::FormSpinButton;

            break;

    }

    switch ( nSlot )

    {

        case SID_FM_CHECKBOX:

        case SID_FM_PUSHBUTTON:

        case SID_FM_FIXEDTEXT:

        case SID_FM_LISTBOX:

        case SID_FM_EDIT:

        case SID_FM_RADIOBUTTON:

        case SID_FM_COMBOBOX:

        case SID_FM_NAVIGATIONBAR:

        case SID_FM_GROUPBOX:

        case SID_FM_DBGRID:

        case SID_FM_IMAGEBUTTON:

        case SID_FM_IMAGECONTROL:

        case SID_FM_FILECONTROL:

        case SID_FM_DATEFIELD:

        case SID_FM_TIMEFIELD:

        case SID_FM_NUMERICFIELD:

        case SID_FM_CURRENCYFIELD:

        case SID_FM_PATTERNFIELD:

        case SID_FM_FORMATTEDFIELD:

        case SID_FM_SCROLLBAR:

        case SID_FM_SPINBUTTON:

        {

            const SfxBoolItem* pGrabFocusItem = rReq.GetArg(SID_FM_TOGGLECONTROLFOCUS);

            if ( pGrabFocusItem && pGrabFocusItem->GetValue() )

            {   // see below

                SfxViewShell* pShell = GetViewShell();

                vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : nullptr;

                if ( pShellWnd )

                    pShellWnd->GrabFocus();

                break;

            }

            SfxUInt16Item aIdentifierItem( SID_FM_CONTROL_IDENTIFIER, static_cast<sal_uInt16>(nIdentifier) );

            SfxUInt32Item aInventorItem( SID_FM_CONTROL_INVENTOR, sal_uInt32(SdrInventor::FmForm) );

            const SfxPoolItem* pArgs[] =

            {

                &aIdentifierItem, &aInventorItem, nullptr

            };

            const SfxPoolItem* pInternalArgs[] =

            {

                nullptr

            };

            GetViewShell()->GetViewFrame().GetDispatcher()->Execute( SID_FM_CREATE_CONTROL, SfxCallMode::ASYNCHRON,

                                      pArgs, rReq.GetModifier(), pInternalArgs );

            if ( rReq.GetModifier() & KEY_MOD1 )

            {

                //  #99013# if selected with control key, return focus to current view

                // do this asynchronously, so that the creation can be finished first

                // reusing the SID_FM_TOGGLECONTROLFOCUS is somewhat hacky... which it wouldn't if it would have another

                // name, so I do not really have a big problem with this...

                SfxBoolItem aGrabFocusIndicatorItem( SID_FM_TOGGLECONTROLFOCUS, true );

                GetViewShell()->GetViewFrame().GetDispatcher()->ExecuteList(

                        nSlot, SfxCallMode::ASYNCHRON,

                        { &aGrabFocusIndicatorItem });

            }

            rReq.Done();

        }   break;

    }

    // individual actions

    switch( nSlot )

    {

        case SID_FM_FORM_DESIGN_TOOLS:

        {

            FormToolboxes aToolboxAccess(GetImpl()->getHostFrame_Lock());

            aToolboxAccess.toggleToolbox( nSlot );

            rReq.Done();

        }

        break;

        case SID_FM_TOGGLECONTROLFOCUS:

        {

            FmFormView* pFormView = GetFormView();

            if ( !pFormView )

                break;

            // if we execute this ourself, then either the application does not implement an own handling for this,

            // or we're on the top of the dispatcher stack, which means a control has the focus.

            // In the latter case, we put the focus to the document window, otherwise, we focus the first control

            const bool bHasControlFocus = GetImpl()->HasControlFocus_Lock();

            if ( bHasControlFocus )

            {

                if (m_pFormView)

                {

                    const OutputDevice* pDevice = m_pFormView->GetActualOutDev();

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

                    if ( pWindow )

                        pWindow->GrabFocus();

                }

            }

            else

            {

                pFormView->GrabFirstControlFocus( );

            }

        }

        break;

        case SID_FM_VIEW_AS_GRID:

            GetImpl()->CreateExternalView_Lock();

            break;

        case SID_FM_CONVERTTO_EDIT          :

        case SID_FM_CONVERTTO_BUTTON            :

        case SID_FM_CONVERTTO_FIXEDTEXT     :

        case SID_FM_CONVERTTO_LISTBOX       :

        case SID_FM_CONVERTTO_CHECKBOX      :

        case SID_FM_CONVERTTO_RADIOBUTTON   :

        case SID_FM_CONVERTTO_GROUPBOX      :

        case SID_FM_CONVERTTO_COMBOBOX      :

        case SID_FM_CONVERTTO_IMAGEBUTTON   :

        case SID_FM_CONVERTTO_FILECONTROL   :

        case SID_FM_CONVERTTO_DATE          :

        case SID_FM_CONVERTTO_TIME          :

        case SID_FM_CONVERTTO_NUMERIC       :

        case SID_FM_CONVERTTO_CURRENCY      :

        case SID_FM_CONVERTTO_PATTERN       :

        case SID_FM_CONVERTTO_IMAGECONTROL  :

        case SID_FM_CONVERTTO_FORMATTED     :

        case SID_FM_CONVERTTO_SCROLLBAR     :

        case SID_FM_CONVERTTO_SPINBUTTON    :

        case SID_FM_CONVERTTO_NAVIGATIONBAR :

            GetImpl()->executeControlConversionSlot_Lock(FmXFormShell::SlotToIdent(nSlot));

            // after the conversion, re-determine the selection, since the

            // selected object has changed

            GetImpl()->SetSelection_Lock(GetFormView()->GetMarkedObjectList());

            break;

        case SID_FM_LEAVE_CREATE:

            m_nLastSlot = 0;

            rReq.Done();

            break;

        case SID_FM_SHOW_PROPERTY_BROWSER:

        {

            const SfxBoolItem* pShowItem = rReq.GetArg(SID_FM_SHOW_PROPERTIES);

            bool bShow = true;

            if ( pShowItem )

                bShow = pShowItem->GetValue();

            GetImpl()->ShowSelectionProperties_Lock(bShow);

            rReq.Done();

        } break;

        case SID_FM_PROPERTIES:

        {

            // display the PropertyBrowser

            const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(nSlot);

            bool bShow = pShowItem == nullptr || pShowItem->GetValue();

            InterfaceBag aOnlyTheForm;

            aOnlyTheForm.insert(Reference<XInterface>(GetImpl()->getCurrentForm_Lock(), UNO_QUERY));

            GetImpl()->setCurrentSelection_Lock(std::move(aOnlyTheForm));

            GetImpl()->ShowSelectionProperties_Lock(bShow);

            rReq.Done();

        }   break;

        case SID_FM_CTL_PROPERTIES:

        {

            const SfxBoolItem* pShowItem = rReq.GetArg<SfxBoolItem>(nSlot);

            bool bShow = pShowItem == nullptr || pShowItem->GetValue();

            OSL_ENSURE( GetImpl()->onlyControlsAreMarked_Lock(), "FmFormShell::Execute: ControlProperties should be disabled!" );

            if ( bShow )

                GetImpl()->selectLastMarkedControls_Lock();

            GetImpl()->ShowSelectionProperties_Lock(bShow);

            rReq.Done();

        }   break;

        case SID_FM_SHOW_PROPERTIES:

        case SID_FM_ADD_FIELD:

        case SID_FM_FILTER_NAVIGATOR:

        case SID_FM_SHOW_DATANAVIGATOR :

        {

            // request may explicitly request to show/hide these

            // so may or may not result in a ToggleChildWindow

            GetViewShell()->GetViewFrame().ChildWindowExecute(rReq);

            rReq.Done();

        }   break;

        case SID_FM_SHOW_FMEXPLORER:

        {

            if (!m_pFormView)   // force setting the view

                GetViewShell()->GetViewFrame().GetDispatcher()->Execute(SID_CREATE_SW_DRAWVIEW);

            GetViewShell()->GetViewFrame().ChildWindowExecute(rReq);

            rReq.Done();

        }

        break;

        case SID_FM_TAB_DIALOG:

        {

            GetImpl()->ExecuteTabOrderDialog_Lock(

                Reference<XTabControllerModel>(GetImpl()->getCurrentForm_Lock(), UNO_QUERY));

            rReq.Done();

        }

        break;

        case SID_FM_DESIGN_MODE:

        {

            const SfxBoolItem* pDesignItem = rReq.GetArg<SfxBoolItem>(nSlot);

            bool bDesignMode = pDesignItem ? pDesignItem->GetValue() : !m_bDesignMode;

            SetDesignMode( bDesignMode );

            if ( m_bDesignMode == bDesignMode )

                rReq.Done();

            m_nLastSlot = SID_FM_DESIGN_MODE;

        }

        break;

        case SID_FM_AUTOCONTROLFOCUS:

        {

            FmFormModel* pModel = GetFormModel();

            DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !");

                // should have been disabled in GetState if we don't have a FormModel

            pModel->SetAutoControlFocus( !pModel->GetAutoControlFocus() );

            GetViewShell()->GetViewFrame().GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS);

        }

        break;

        case SID_FM_OPEN_READONLY:

        {

            FmFormModel* pModel = GetFormModel();

            DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !");

                // should have been disabled in GetState if we don't have a FormModel

            pModel->SetOpenInDesignMode( !pModel->GetOpenInDesignMode() );

            GetViewShell()->GetViewFrame().GetBindings().Invalidate(SID_FM_OPEN_READONLY);

        }

        break;

        case SID_FM_USE_WIZARDS:

        {

            GetImpl()->SetWizardUsing_Lock(!GetImpl()->GetWizardUsing_Lock());

            GetViewShell()->GetViewFrame().GetBindings().Invalidate(SID_FM_USE_WIZARDS);

        }

        break;

        case SID_FM_SEARCH:

        {

            const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures_Lock();

            if ( rController->commitCurrentControl() && rController->commitCurrentRecord() )

                GetImpl()->ExecuteSearch_Lock();

            rReq.Done();

        }

        break;

        case SID_FM_RECORD_FIRST:

        case SID_FM_RECORD_PREV:

        case SID_FM_RECORD_NEXT:

        case SID_FM_RECORD_LAST:

        case SID_FM_RECORD_NEW:

        case SID_FM_REFRESH:

        case SID_FM_REFRESH_FORM_CONTROL:

        case SID_FM_RECORD_DELETE:

        case SID_FM_RECORD_UNDO:

        case SID_FM_RECORD_SAVE:

        case SID_FM_REMOVE_FILTER_SORT:

        case SID_FM_SORTDOWN:

        case SID_FM_SORTUP:

        case SID_FM_AUTOFILTER:

        case SID_FM_ORDERCRIT:

        case SID_FM_FORM_FILTERED:

        {

            GetImpl()->ExecuteFormSlot_Lock(nSlot);

            rReq.Done();

        }

        break;

        case SID_FM_RECORD_ABSOLUTE:

        {

            const svx::ControllerFeatures& rController = GetImpl()->getNavControllerFeatures_Lock();

            sal_Int32 nRecord = -1;

            const SfxItemSet* pArgs = rReq.GetArgs();

            if ( pArgs )

            {

                const SfxPoolItem* pItem;

                if ( ( pArgs->GetItemState( FN_PARAM_1, true, &pItem ) ) == SfxItemState::SET )

                {

                    const SfxInt32Item* pTypedItem = dynamic_cast<const SfxInt32Item* >( pItem );

                    if ( pTypedItem )

                        nRecord = std::max( pTypedItem->GetValue(), sal_Int32(0) );

                }

            }

            else

            {

                SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();

                ScopedVclPtr<AbstractFmInputRecordNoDialog> dlg(pFact->CreateFmInputRecordNoDialog(rReq.GetFrameWeld()));

                dlg->SetValue( rController->getCursor()->getRow() );

                if ( dlg->Execute() == RET_OK )

                    nRecord = dlg->GetValue();

                rReq.AppendItem( SfxInt32Item( TypedWhichId<SfxInt32Item>(FN_PARAM_1), nRecord ) );

            }

            if ( nRecord != -1 )

                rController->execute( nSlot, u"Position"_ustr, Any( nRecord ) );

            rReq.Done();

        }   break;

        case SID_FM_FILTER_EXECUTE:

        case SID_FM_FILTER_EXIT:

        {

            bool bCancelled = ( SID_FM_FILTER_EXIT == nSlot );

            bool bReopenNavigator = false;

            if ( !bCancelled )

            {

                // if the filter navigator is still open, we need to close it, so it can possibly

                // commit its most recent changes

                if (GetViewShell())

                    if ( GetViewShell()->GetViewFrame().HasChildWindow( SID_FM_FILTER_NAVIGATOR ) )

                    {

                        GetViewShell()->GetViewFrame().ToggleChildWindow( SID_FM_FILTER_NAVIGATOR );

                        bReopenNavigator = true;

                    }

                Reference<runtime::XFormController> const xController(GetImpl()->getActiveController_Lock());

                if  (   GetViewShell()->GetViewFrame().HasChildWindow( SID_FM_FILTER_NAVIGATOR )

                        // closing the window was denied, for instance because of an invalid criterion

                    ||  (   xController.is()

                        &&  !GetImpl()->getActiveControllerFeatures_Lock()->commitCurrentControl()

                        )

                        // committing the controller was denied

                    )

                {

                    rReq.Done();

                    break;

                }

            }

            GetImpl()->stopFiltering_Lock(!bCancelled);

            rReq.Done();

            if ( bReopenNavigator )

                // we closed the navigator only to implicitly commit it (as we do not have another

                // direct wire to it), but to the user, it should look as it was always open

                GetViewShell()->GetViewFrame().ToggleChildWindow( SID_FM_FILTER_NAVIGATOR );

        }

        break;

        case SID_FM_FILTER_START:

        {

            GetImpl()->startFiltering_Lock();

            rReq.Done();

            // initially open the filter navigator, the whole form based filter is pretty useless without it

            SfxBoolItem aIdentifierItem( SID_FM_FILTER_NAVIGATOR, true );

            GetViewShell()->GetViewFrame().GetDispatcher()->ExecuteList(

                    SID_FM_FILTER_NAVIGATOR, SfxCallMode::ASYNCHRON,

                    { &aIdentifierItem });

        }   break;

    }

}

void FmFormShell::GetState(SfxItemSet &rSet)

{

    SfxWhichIter aIter( rSet );

    sal_uInt16 nWhich = aIter.FirstWhich();

    while ( nWhich )

    {

        switch( nWhich )

        {

            case SID_FM_FORM_DESIGN_TOOLS:

            {

                FormToolboxes aToolboxAccess(GetImpl()->getHostFrame_Lock());

                rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible( nWhich ) ) );

            }

            break;

            case SID_FM_FILTER_EXECUTE:

            case SID_FM_FILTER_EXIT:

                if (!GetImpl()->isInFilterMode_Lock())

                    rSet.DisableItem( nWhich );

                break;

            case SID_FM_USE_WIZARDS:

                if (!SvtModuleOptions().IsDataBaseInstalled())

                    rSet.Put( SfxVisibilityItem( nWhich, false ) );

                else if (!GetFormModel())

                    rSet.DisableItem( nWhich );

                else

                    rSet.Put(SfxBoolItem(nWhich, GetImpl()->GetWizardUsing_Lock()));

                break;

            case SID_FM_AUTOCONTROLFOCUS:

                if (!GetFormModel())

                    rSet.DisableItem( nWhich );

                else

                    rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetAutoControlFocus() ) );

                break;

            case SID_FM_OPEN_READONLY:

                if (!GetFormModel())

                    rSet.DisableItem( nWhich );

                else

                    rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetOpenInDesignMode() ) );

                break;

            case SID_FM_NAVIGATIONBAR:

            case SID_FM_DBGRID:

                if (!SvtModuleOptions().IsDataBaseInstalled())

                {

                    rSet.Put( SfxVisibilityItem( nWhich, false ) );

                    break;

                }

                [[fallthrough]];

            case SID_FM_SCROLLBAR:

            case SID_FM_IMAGECONTROL:

            case SID_FM_FILECONTROL:

            case SID_FM_CURRENCYFIELD:

            case SID_FM_PATTERNFIELD:

            case SID_FM_IMAGEBUTTON:

            case SID_FM_RADIOBUTTON:

            case SID_FM_COMBOBOX:

            case SID_FM_GROUPBOX:

            case SID_FM_CHECKBOX:

            case SID_FM_PUSHBUTTON:

            case SID_FM_FIXEDTEXT:

            case SID_FM_LISTBOX:

            case SID_FM_EDIT:

            case SID_FM_DATEFIELD:

            case SID_FM_TIMEFIELD:

            case SID_FM_NUMERICFIELD:

            case SID_FM_FORMATTEDFIELD:

            case SID_FM_SPINBUTTON:

                if (!m_bDesignMode)

                    rSet.DisableItem( nWhich );

                else

                {

                    bool bLayerLocked = false;

                    if (m_pFormView)

                    {

                        // If the css::drawing::Layer is locked, the slots must be disabled. #36897

                        SdrPageView* pPV = m_pFormView->GetSdrPageView();

                        if (pPV != nullptr)

                            bLayerLocked = pPV->IsLayerLocked(m_pFormView->GetActiveLayer());

                    }

                    if (bLayerLocked)

                        rSet.DisableItem( nWhich );

                    else

                        rSet.Put( SfxBoolItem(nWhich, (nWhich==m_nLastSlot)) );

                }

                break;

            case SID_FM_FILTER_NAVIGATOR_CONTROL:

            {

                if (GetImpl()->isInFilterMode_Lock())

                    rSet.Put(SfxObjectItem(nWhich, this));