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

#include <drwlayer.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/passwd.hxx>

#include <sfx2/request.hxx>

#include <sfx2/sidebar/Sidebar.hxx>

#include <svl/ptitem.hxx>

#include <svl/stritem.hxx>

#include <tools/urlobj.hxx>

#include <sfx2/objface.hxx>

#include <vcl/svapp.hxx>

#include <vcl/vclenum.hxx>

#include <vcl/uitest/logger.hxx>

#include <vcl/uitest/eventdescription.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <globstr.hrc>

#include <strings.hrc>

#include <scmod.hxx>

#include <appoptio.hxx>

#include <tabvwsh.hxx>

#include <document.hxx>

#include <sc.hrc>

#include <helpids.h>

#include <inputwin.hxx>

#include <scresid.hxx>

#include <docsh.hxx>

#include <rangeutl.hxx>

#include <reffact.hxx>

#include <tabprotection.hxx>

#include <protectiondlg.hxx>

#include <duplicaterecordsdlg.hxx>

#include <markdata.hxx>

#include <cellsuno.hxx>

#include <svl/ilstitem.hxx>

#include <vector>

#include <svx/zoomslideritem.hxx>

#include <svx/svxdlg.hxx>

#include <svx/ColorSets.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/string.hxx>

#include <com/sun/star/uno/Reference.h>

#include <com/sun/star/sheet/XCellRangeData.hpp>

#include <sfx2/lokhelper.hxx>

#include <scabstdlg.hxx>

#include <officecfg/Office/Calc.hxx>

#include <basegfx/utils/zoomtools.hxx>

#include <svx/dialog/ThemeDialog.hxx>

#include <ThemeColorChanger.hxx>

#include <dialogs/SelectSheetViewDialog.hxx>

namespace

{

    void collectUIInformation(const OUString& aZoom)

    {

        EventDescription aDescription;

        aDescription.aID = "grid_window";

        aDescription.aParameters = {{"ZOOM", aZoom}};

        aDescription.aAction = "SET";

        aDescription.aKeyWord = "ScGridWinUIObject";

        aDescription.aParent = "MainWindow";

        UITestLogger::getInstance().logEvent(aDescription);

    }

    enum class DetectFlags

    {

        NONE,

        RANGE,

        ADDRESS

    };

    struct ScRefFlagsAndType

    {

        ScRefFlags nResult;

        DetectFlags eDetected;

    };

    ScRefFlagsAndType lcl_ParseRangeOrAddress(ScRange& rScRange, ScAddress& rScAddress,

                                              const OUString& aAddress, const ScDocument& rDoc,

                                              SCCOL nCurCol, SCROW nCurRow)

    {

        ScRefFlagsAndType aRet;

        // Relative address parsing needs current position.

        // row,col parameters, not col,row!

        ScAddress::Details aDetails( rDoc.GetAddressConvention(), nCurRow, nCurCol);

        // start with the address convention set in the document

        aRet.nResult = rScRange.Parse(aAddress, rDoc, aDetails);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::RANGE;

            return aRet;

        }

        aRet.nResult = rScAddress.Parse(aAddress, rDoc, aDetails);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::ADDRESS;

            return aRet;

        }

        // try the default Calc (A1) address convention

        aRet.nResult = rScRange.Parse(aAddress, rDoc);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::RANGE;

            return aRet;

        }

        aRet.nResult = rScAddress.Parse(aAddress, rDoc);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::ADDRESS;

            return aRet;

        }

        // try the Excel A1 address convention

        aRet.nResult = rScRange.Parse(aAddress, rDoc, formula::FormulaGrammar::CONV_XL_A1);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::RANGE;

            return aRet;

        }

        // try the Excel A1 address convention

        aRet.nResult = rScAddress.Parse(aAddress, rDoc, formula::FormulaGrammar::CONV_XL_A1);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::ADDRESS;

            return aRet;

        }

        // try Excel R1C1 address convention

        aDetails.eConv = formula::FormulaGrammar::CONV_XL_R1C1;

        aRet.nResult = rScRange.Parse(aAddress, rDoc, aDetails);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::RANGE;

            return aRet;

        }

        aRet.nResult = rScAddress.Parse(aAddress, rDoc, aDetails);

        if (aRet.nResult & ScRefFlags::VALID)

        {

            aRet.eDetected = DetectFlags::ADDRESS;

            return aRet;

        }

        aRet.nResult = ScRefFlags::ZERO;

        aRet.eDetected = DetectFlags::NONE;

        return aRet;

    }

}

void ScTabViewShell::ExecGoToTab( SfxRequest& rReq, SfxBindings& rBindings )

{

    SCTAB nTab;

    ScViewData& rViewData = GetViewData();

    ScDocument& rDoc = rViewData.GetDocument();

    SCTAB nTabCount = rDoc.GetTableCount();

    const SfxItemSet* pReqArgs = rReq.GetArgs();

    sal_uInt16 nSlot = rReq.GetSlot();

    if ( pReqArgs ) // command from Navigator with nTab

    {

        // sheet for basic is one-based

        nTab = static_cast<const SfxUInt16Item&>(pReqArgs->Get(nSlot)).GetValue() - 1;

        if ( nTab < nTabCount )

        {

            SetTabNo( nTab );

            rBindings.Update( nSlot );

            if( ! rReq.IsAPI() )

                rReq.Done();

        }

    }

    else            // command from Menu: ask for nTab

    {

        auto xRequest = std::make_shared<SfxRequest>(rReq);

        rReq.Ignore();

        ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();

        VclPtr<AbstractScGoToTabDlg> pDlg(pFact->CreateScGoToTabDlg(GetFrameWeld()));

        pDlg->SetDescription(

            ScResId( STR_DLG_SELECTTABLE_TITLE ),

            ScResId( STR_DLG_SELECTTABLE_MASK ),

            ScResId( STR_DLG_SELECTTABLE_LBNAME ),

            GetStaticInterface()->GetSlot(SID_CURRENTTAB)->GetCommand(), HID_GOTOTABLEMASK, HID_GOTOTABLE );

        // fill all table names and select current tab

        OUString aTabName;

        for( nTab = 0; nTab < nTabCount; ++nTab )

        {

            if( rDoc.IsVisible( nTab ) )

            {

                rDoc.GetName( nTab, aTabName );

                pDlg->Insert( aTabName, rViewData.CurrentTabForData() == nTab );

            }

        }

        pDlg->StartExecuteAsync([this, nTab, nTabCount, pDlg,

                                 xRequest=std::move(xRequest)](sal_Int32 response) {

            if( response == RET_OK )

            {

                auto nTab2 = nTab;

                if( !GetViewData().GetDocument().GetTable( pDlg->GetSelectedEntry(), nTab2 ) )

                    nTab2 = nTabCount;

                if ( nTab2 < nTabCount )

                {

                    SetTabNo( nTab2 );

                    if ( !xRequest->IsAPI() )

                        xRequest->Done();

                }

            }

            else

            {

                xRequest->Ignore();

            }

            pDlg->disposeOnce();

        });

    }

}

void ScTabViewShell::FinishProtectTable()

{

    TabChanged();

    UpdateInputHandler(true);   // to immediately enable input again

    SelectionChanged();

}

void ScTabViewShell::ExecProtectTable( SfxRequest& rReq )

{

    ScModule* pScMod = ScModule::get();

    const SfxItemSet*   pReqArgs    = rReq.GetArgs();

    ScDocument&         rDoc = GetViewData().GetDocument();

    SCTAB               nTab = GetViewData().GetTabNumber();

    bool                bOldProtection = rDoc.IsTabProtected(nTab);

    if( pReqArgs )

    {

        const SfxPoolItem* pItem;

        bool bNewProtection = !bOldProtection;

        if( pReqArgs->HasItem( FID_PROTECT_TABLE, &pItem ) )

            bNewProtection = static_cast<const SfxBoolItem*>(pItem)->GetValue();

        if( bNewProtection == bOldProtection )

        {

            rReq.Ignore();

            return;

        }

    }

    if (bOldProtection)

    {

        // Unprotect a protected sheet.

        const ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);

        if (pProtect && pProtect->isProtectedWithPass())

        {

            std::shared_ptr<SfxRequest> xRequest;

            if (!pReqArgs)

            {

                xRequest = std::make_shared<SfxRequest>(rReq);

                rReq.Ignore(); // the 'old' request is not relevant any more

            }

            OUString aText( ScResId(SCSTR_PASSWORDOPT) );

            auto pDlg = std::make_shared<SfxPasswordDialog>(GetFrameWeld(), &aText);

            pDlg->set_title(ScResId(SCSTR_UNPROTECTTAB));

            pDlg->SetMinLen(0);

            pDlg->set_help_id(GetStaticInterface()->GetSlot(FID_PROTECT_TABLE)->GetCommand());

            pDlg->SetEditHelpId(HID_PASSWD_TABLE);

            pDlg->PreRun();

            weld::DialogController::runAsync(pDlg, [this, nTab, pDlg,

                                                    xRequest=std::move(xRequest)](sal_Int32 response) {

                if (response == RET_OK)

                {

                    OUString aPassword = pDlg->GetPassword();

                    Unprotect(nTab, aPassword);

                }

                if (xRequest)

                {

                    xRequest->AppendItem( SfxBoolItem(FID_PROTECT_TABLE, false) );

                    xRequest->Done();

                }

                FinishProtectTable();

            });

            return;

        }

        else

            // this sheet is not password-protected.

            Unprotect(nTab, std::u16string_view());

        if (!pReqArgs)

        {

            rReq.AppendItem( SfxBoolItem(FID_PROTECT_TABLE, false) );

            rReq.Done();

        }

    }

    else

    {

        // Protect a current sheet.

        std::shared_ptr<SfxRequest> xRequest;

        if (!pReqArgs)

        {

            xRequest = std::make_shared<SfxRequest>(rReq);

            rReq.Ignore(); // the 'old' request is not relevant any more

        }

        auto pDlg = std::make_shared<ScTableProtectionDlg>(GetFrameWeld());

        const ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);

        if (pProtect)

            pDlg->SetDialogData(*pProtect);

        weld::DialogController::runAsync(pDlg, [this, pDlg, pScMod, nTab,

                                               xRequest=std::move(xRequest)](sal_uInt32 nResult) {

            if (nResult == RET_OK)

            {

                pScMod->InputEnterHandler();

                ScTableProtection aNewProtect;

                pDlg->WriteData(aNewProtect);

                ProtectSheet(nTab, aNewProtect);

                if (xRequest)

                {

                    xRequest->AppendItem( SfxBoolItem(FID_PROTECT_TABLE, true) );

                    xRequest->Done();

                }

            }

            FinishProtectTable();

        });

        return;

    }

    FinishProtectTable();

}

void ScTabViewShell::Execute( SfxRequest& rReq )

{

    SfxViewFrame&       rThisFrame  = GetViewFrame();

    SfxBindings&        rBindings   = rThisFrame.GetBindings();

    ScModule* pScMod = ScModule::get();

    const SfxItemSet*   pReqArgs    = rReq.GetArgs();

    sal_uInt16              nSlot       = rReq.GetSlot();

    if (nSlot != SID_CURRENTCELL)       // comes with MouseButtonUp

        HideListBox();                  // Autofilter-DropDown-Listbox

    switch ( nSlot )

    {

        case FID_INSERT_FILE:

            {

                const SfxPoolItem* pItem;

                if ( pReqArgs &&

                     pReqArgs->GetItemState(FID_INSERT_FILE,true,&pItem) == SfxItemState::SET )

                {

                    OUString aFileName = static_cast<const SfxStringItem*>(pItem)->GetValue();

                        // insert position

                    Point aInsertPos;

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

                        aInsertPos = static_cast<const SfxPointItem*>(pItem)->GetValue();

                    else

                        aInsertPos = GetInsertPos();

                        // as Link?

                    bool bAsLink = false;

                    if ( pReqArgs->GetItemState(FN_PARAM_2,true,&pItem) == SfxItemState::SET )

                        bAsLink = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                        // execute

                    PasteFile( aInsertPos, aFileName, bAsLink );

                }

            }

            break;

        case SID_OPENDLG_EDIT_PRINTAREA:

            {

                sal_uInt16          nId  = ScPrintAreasDlgWrapper::GetChildWindowId();

                SfxChildWindow* pWnd = rThisFrame.GetChildWindow( nId );

                pScMod->SetRefDialog( nId, pWnd == nullptr );

            }

            break;

        case SID_CHANGE_PRINTAREA:

            {

                if ( pReqArgs )         // OK from dialog

                {

                    OUString aPrintStr;

                    OUString aRowStr;

                    OUString aColStr;

                    bool bEntire = false;

                    const SfxPoolItem* pItem;

                    if ( pReqArgs->GetItemState( SID_CHANGE_PRINTAREA, true, &pItem ) == SfxItemState::SET )

                        aPrintStr = static_cast<const SfxStringItem*>(pItem)->GetValue();

                    if ( pReqArgs->GetItemState( FN_PARAM_2, true, &pItem ) == SfxItemState::SET )

                        aRowStr = static_cast<const SfxStringItem*>(pItem)->GetValue();

                    if ( pReqArgs->GetItemState( FN_PARAM_3, true, &pItem ) == SfxItemState::SET )

                        aColStr = static_cast<const SfxStringItem*>(pItem)->GetValue();

                    if ( pReqArgs->GetItemState( FN_PARAM_4, true, &pItem ) == SfxItemState::SET )

                        bEntire = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                    SetPrintRanges( bEntire, &aPrintStr, &aColStr, &aRowStr, false );

                    rReq.Done();

                }

            }

            break;

        case SID_ADD_PRINTAREA:

        case SID_DEFINE_PRINTAREA:      // menu or basic

            {

                bool bAdd = ( nSlot == SID_ADD_PRINTAREA );

                if ( pReqArgs )

                {

                    OUString aPrintStr;

                    const SfxPoolItem* pItem;

                    if ( pReqArgs->GetItemState( SID_DEFINE_PRINTAREA, true, &pItem ) == SfxItemState::SET )

                        aPrintStr = static_cast<const SfxStringItem*>(pItem)->GetValue();

                    SetPrintRanges( false, &aPrintStr, nullptr, nullptr, bAdd );

                }

                else

                {

                    SetPrintRanges( false, nullptr, nullptr, nullptr, bAdd );      // from selection

                    rReq.Done();

                }

            }

            break;

        case SID_DELETE_PRINTAREA:

            {

                // Clear currently defined print range if any, and reset it to

                // print entire sheet which is the default.

                OUString aEmpty;

                SetPrintRanges(true, &aEmpty, nullptr, nullptr, false);

                rReq.Done();

            }

            break;

        case FID_DEL_MANUALBREAKS:

            RemoveManualBreaks();

            rReq.Done();

            break;

        case FID_ADJUST_PRINTZOOM:

            AdjustPrintZoom();

            rReq.Done();

            break;

        case FID_RESET_PRINTZOOM:

            SetPrintZoom( 100 );     // 100%, not on pages

            rReq.Done();

            break;

        case SID_FORMATPAGE:

        case SID_STATUS_PAGESTYLE:

        case SID_HFEDIT:

            GetViewData().GetDocShell()->

                ExecutePageStyle( *this, rReq, GetViewData().CurrentTabForData() );

            break;

        case SID_JUMPTOMARK:

        case SID_CURRENTCELL:

            if ( pReqArgs )

            {

                OUString aAddress;

                const SfxPoolItem* pItem;

                if ( pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET )

                    aAddress = static_cast<const SfxStringItem*>(pItem)->GetValue();

                else if ( nSlot == SID_JUMPTOMARK && pReqArgs->GetItemState(

                                            SID_JUMPTOMARK, true, &pItem ) == SfxItemState::SET )

                    aAddress = static_cast<const SfxStringItem*>(pItem)->GetValue();

                //  #i14927# SID_CURRENTCELL with a single cell must unmark if FN_PARAM_1

                //  isn't set (for recorded macros, because IsAPI is no longer available).

                //  ScGridWindow::MouseButtonUp no longer executes the slot for a single

                //  cell if there is a multi selection.

                bool bUnmark = ( nSlot == SID_CURRENTCELL );

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

                    bUnmark = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                bool bAlignToCursor = true;

                if (pReqArgs->GetItemState(FN_PARAM_2, true, &pItem) == SfxItemState::SET)

                    bAlignToCursor = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                bool bForceGlobalName = false;

                if (pReqArgs->GetItemState(FN_PARAM_3, true, &pItem) == SfxItemState::SET)

                    bForceGlobalName = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                if ( nSlot == SID_JUMPTOMARK )

                {

                    //  URL has to be decoded for escaped characters (%20)

                    aAddress = INetURLObject::decode( aAddress,

                                               INetURLObject::DecodeMechanism::WithCharset );

                }

                bool bFound = false;

                ScViewData& rViewData = GetViewData();

                ScDocument& rDoc      = rViewData.GetDocument();

                ScMarkData& rMark     = rViewData.GetMarkData();

                ScRange     aScRange;

                ScAddress   aScAddress;

                ScRefFlagsAndType aResult = lcl_ParseRangeOrAddress(aScRange, aScAddress, aAddress, rDoc,

                        rViewData.GetCurX(), rViewData.GetCurY());

                ScRefFlags  nResult = aResult.nResult;

                SCTAB       nTab = rViewData.CurrentTabForData();

                bool        bMark = true;

                // Is this a range ?

                if (aResult.eDetected == DetectFlags::RANGE)

                {

                    if ( nResult & ScRefFlags::TAB_3D )

                    {

                        if( aScRange.aStart.Tab() != nTab )

                        {

                            nTab = aScRange.aStart.Tab();

                            SetTabNo( nTab );

                        }

                    }

                    else

                    {

                        aScRange.aStart.SetTab( nTab );

                        aScRange.aEnd.SetTab( nTab );

                    }

                }

                // Is this a cell ?

                else if (aResult.eDetected == DetectFlags::ADDRESS)

                {

                    if ( nResult & ScRefFlags::TAB_3D )

                    {

                        if( aScAddress.Tab() != nTab )

                        {

                            nTab = aScAddress.Tab();

                            SetTabNo( nTab );

                        }

                    }

                    else

                        aScAddress.SetTab( nTab );

                    aScRange = ScRange( aScAddress, aScAddress );

                    // cells should not be marked

                    bMark = false;

                }

                // Is it a named area (first named ranges then database ranges)?

                else

                {

                    const RutlNameScope eScope = (bForceGlobalName ? RUTL_NAMES_GLOBAL : RUTL_NAMES);

                    ScAddress::Details aDetails( rDoc.GetAddressConvention(), rViewData.GetCurY(), rViewData.GetCurX());

                    if (ScRangeUtil::MakeRangeFromName( aAddress, rDoc, nTab, aScRange, eScope, aDetails, true) ||

                        ScRangeUtil::MakeRangeFromName( aAddress, rDoc, nTab, aScRange, RUTL_DBASE, aDetails, true))

                    {

                        nResult |= ScRefFlags::VALID;

                        if( aScRange.aStart.Tab() != nTab )

                        {

                            nTab = aScRange.aStart.Tab();

                            SetTabNo( nTab );

                        }

                    }

                }

                if ( !(nResult & ScRefFlags::VALID) && comphelper::string::isdigitAsciiString(aAddress) )

                {

                    sal_Int32 nNumeric = aAddress.toInt32();

                    if ( nNumeric > 0 && nNumeric <= rDoc.MaxRow()+1 )

                    {

                        // one-based row numbers

                        aScAddress.SetRow( static_cast<SCROW>(nNumeric - 1) );

                        aScAddress.SetCol( rViewData.GetCurX() );

                        aScAddress.SetTab( nTab );

                        aScRange = ScRange( aScAddress, aScAddress );

                        bMark    = false;

                        nResult  = ScRefFlags::VALID;

                    }

                }

                if ( !rDoc.ValidRow(aScRange.aStart.Row()) || !rDoc.ValidRow(aScRange.aEnd.Row()) )

                    nResult = ScRefFlags::ZERO;

                // we have found something

                if( nResult & ScRefFlags::VALID )

                {

                    bFound = true;

                    SCCOL nCol = aScRange.aStart.Col();

                    SCROW nRow = aScRange.aStart.Row();

                    bool bNothing = ( rViewData.GetCurX()==nCol && rViewData.GetCurY()==nRow );

                    // mark

                    if( bMark )

                    {

                        if (rMark.IsMarked())           // is the same range already marked?

                        {

                            ScRange aOldMark = rMark.GetMarkArea();

                            aOldMark.PutInOrder();

                            ScRange aCurrent = aScRange;

                            aCurrent.PutInOrder();

                            bNothing = ( aCurrent == aOldMark );

                        }

                        else

                            bNothing = false;

                        if (!bNothing)

                            MarkRange( aScRange, false );   // cursor comes after...

                    }

                    else

                    {

                        //  remove old selection, unless bUnmark argument is sal_False (from navigator)

                        if( bUnmark )

                        {

                            MoveCursorAbs( nCol, nRow,

                                SC_FOLLOW_NONE, false, false );

                        }

                    }

                    // and set cursor

                    // consider merged cells:

                    rDoc.SkipOverlapped(nCol, nRow, nTab);

                    // navigator calls are not part of the API!!!

                    if( bNothing )

                    {

                        if (rReq.IsAPI())

                            rReq.Ignore();      // if macro, then nothing

                        else

                            rReq.Done();        // then at least paint it

                    }

                    else

                    {

                        rViewData.ResetOldCursor();

                        SetCursor( nCol, nRow );

                        rBindings.Invalidate( SID_CURRENTCELL );

                        rBindings.Update( nSlot );

                        if (!rReq.IsAPI())

                            rReq.Done();

                    }

                    if (bAlignToCursor)

                    {

                        // align to cursor even if the cursor position hasn't changed,

                        // because the cursor may be set outside the visible area.

                        AlignToCursor( nCol, nRow, SC_FOLLOW_JUMP );

                        if ( nSlot == SID_JUMPTOMARK && comphelper::LibreOfficeKit::isActive() )

                            rViewData.GetActiveWin()->notifyKitCellFollowJump();

                    }

                    rReq.SetReturnValue( SfxStringItem( SID_CURRENTCELL, aAddress ) );

                }

                if (!bFound)    // no valid range

                {

                    // if it is a sheet name, then switch (for Navigator/URL)

                    SCTAB nNameTab;

                    if ( rDoc.GetTable( aAddress, nNameTab ) )

                    {

                        bFound = true;

                        if (nNameTab != nTab)

                        {

                            if (!rDoc.IsVisible(nNameTab))

                                ErrorMessage(STR_ERR_HIDDEN_SHEET);

                            else

                                SetTabNo(nNameTab);

                        }

                    }

                }

                if ( !bFound && nSlot == SID_JUMPTOMARK )

                {

                    // test graphics objects (only for URL)

                    bFound = SelectObject( aAddress );

                }

                if (!bFound && !rReq.IsAPI())

                    ErrorMessage( STR_ERR_INVALID_AREA );

            }

            break;

        case SID_CURRENTOBJECT:

            if ( pReqArgs )

            {

                OUString aName = static_cast<const SfxStringItem&>(pReqArgs->Get(nSlot)).GetValue();

                SelectObject( aName );

            }

            break;

        case SID_CURRENTTAB:

            {

                ExecGoToTab( rReq, rBindings );

                //! otherwise an error ?

            }

            break;

        case SID_CURRENTDOC:

            if ( pReqArgs )

            {

                OUString aStrDocName( static_cast<const SfxStringItem&>(pReqArgs->

                                        Get(nSlot)).GetValue() );

                SfxViewFrame*   pViewFrame = nullptr;

                ScDocShell*     pDocSh = static_cast<ScDocShell*>(SfxObjectShell::GetFirst());

                bool            bFound = false;

                // search for ViewFrame to be activated

                while ( pDocSh && !bFound )

                {

                    if ( pDocSh->GetTitle() == aStrDocName )

                    {

                        pViewFrame = SfxViewFrame::GetFirst( pDocSh );

                        bFound = ( nullptr != pViewFrame );

                    }

                    pDocSh = static_cast<ScDocShell*>(SfxObjectShell::GetNext( *pDocSh ));

                }

                if ( bFound )

                    pViewFrame->GetFrame().Appear();

                rReq.Ignore();//XXX is handled by SFX

            }

            break;

        case SID_PRINTPREVIEW:

            {

                if ( !rThisFrame.GetFrame().IsInPlace() )          // not for OLE

                {

                    //  print preview is now always in the same frame as the tab view

                    //  -> always switch this frame back to normal view

                    //  (ScPreviewShell ctor reads view data)

                    // #102785#; finish input

                    pScMod->InputEnterHandler();

                    rThisFrame.GetDispatcher()->Execute( SID_VIEWSHELL1, SfxCallMode::ASYNCHRON );

                }

                //  else error (e.g. Ole)

            }

            break;

        case SID_DETECTIVE_DEL_ALL:

            DetectiveDelAll();

            rReq.Done();

            break;

        // SID_TABLE_ACTIVATE and SID_MARKAREA are called by basic for the

        // hidden View, to mark/switch on the visible View:

        case SID_TABLE_ACTIVATE:

            OSL_FAIL("old slot SID_TABLE_ACTIVATE");

            break;

        case SID_REPAINT:

            PaintGrid();

            PaintTop();

            PaintLeft();

            PaintExtras();

            rReq.Done();

            break;

        case FID_NORMALVIEWMODE:

        case FID_PAGEBREAKMODE:

            {

                bool bWantPageBreak = nSlot == FID_PAGEBREAKMODE;

                // check whether there is an explicit argument, use it

                const SfxPoolItem* pItem;

                if ( pReqArgs && pReqArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET )

                {

                    bool bItemValue = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                    bWantPageBreak = (nSlot == FID_PAGEBREAKMODE) == bItemValue;

                }

                if( GetViewData().IsPagebreakMode() != bWantPageBreak )

                {

                    SetPagebreakMode( bWantPageBreak );

                    UpdatePageBreakData();

                    SetCurSubShell( GetCurObjectSelectionType(), true );

                    PaintGrid();

                    PaintTop();

                    PaintLeft();

                    rBindings.Invalidate( nSlot );

                    rReq.AppendItem( SfxBoolItem( nSlot, true ) );

                    rReq.Done();

                }

            }

            break;

        case FID_FUNCTION_BOX:

            {

                // First make sure that the sidebar is visible

                rThisFrame.ShowChildWindow(SID_SIDEBAR);

                ::sfx2::sidebar::Sidebar::ShowPanel(u"ScFunctionsPanel",

                                                    rThisFrame.GetFrame().GetFrameInterface(),

                                                    true);

                rReq.Done ();

            }

            break;

        case FID_TOGGLESYNTAX:

            {

                bool bSet = !GetViewData().IsSyntaxMode();

                const SfxPoolItem* pItem;

                if ( pReqArgs && pReqArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET )

                    bSet = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                GetViewData().SetSyntaxMode( bSet );

                PaintGrid();

                rBindings.Invalidate( FID_TOGGLESYNTAX );

                rReq.AppendItem( SfxBoolItem( nSlot, bSet ) );

                rReq.Done();

            }

            break;

        case FID_HANDLEDUPLICATERECORDS:

            {

                using namespace com::sun::star;

                table::CellRangeAddress aCellRange;

                rtl::Reference<ScTableSheetObj> xActiveSheet;

                DuplicatesResponse aResponse;

                bool bHasData = true;

                if (pReqArgs)

                {

                    const SfxPoolItem* pItem;

                    if (pReqArgs->HasItem(FID_HANDLEDUPLICATERECORDS, &pItem))

                        aResponse.bRemove = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_1, &pItem))

                        aResponse.bIncludesHeaders = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_2, &pItem))

                        aResponse.bDuplicateRows = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_3, &pItem))

                        aCellRange.StartColumn = static_cast<const SfxInt32Item*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_4, &pItem))

                        aCellRange.StartRow = static_cast<const SfxInt32Item*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_5, &pItem))

                        aCellRange.EndColumn = static_cast<const SfxInt32Item*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_6, &pItem))

                        aCellRange.EndRow = static_cast<const SfxInt32Item*>(pItem)->GetValue();

                    if (pReqArgs->HasItem(FN_PARAM_7, &pItem))

                        aCellRange.Sheet = static_cast<const SfxInt32Item*>(pItem)->GetValue();

                    // check for the tab range here