Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1352 insertions, 0 deletions

diff --git a/sc/source/ui/view/tabvwsh3.cxx b/sc/source/ui/view/tabvwsh3.cxx
new file mode 100644
index 000000000..766f6c762
--- /dev/null
+++ b/sc/source/ui/view/tabvwsh3.cxx
@@ -0,0 +1,1352 @@
+/* -*- 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 <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/vclenum.hxx>
+#include <vcl/uitest/logger.hxx>
+#include <vcl/uitest/eventdescription.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 <markdata.hxx>
+
+#include <svl/ilstitem.hxx>
+#include <vector>
+
+#include <svx/zoomslideritem.hxx>
+#include <svx/svxdlg.hxx>
+#include <comphelper/lok.hxx>
+#include <comphelper/string.hxx>
+#include <sfx2/lokhelper.hxx>
+#include <scabstdlg.hxx>
+
+#include <basegfx/utils/zoomtools.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::Execute( SfxRequest& rReq )
+{
+    SfxViewFrame*       pThisFrame  = GetViewFrame();
+    SfxBindings&        rBindings   = pThisFrame->GetBindings();
+    ScModule*           pScMod      = SC_MOD();
+    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 = pThisFrame->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().GetTabNo() );
+            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.GetTabNo();
+                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 )
+                            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:
+            {
+                SCTAB nTab;
+                ScViewData& rViewData = GetViewData();
+                ScDocument& rDoc = rViewData.GetDocument();
+                SCTAB nTabCount = rDoc.GetTableCount();
+                if ( pReqArgs ) // command from Navigator with nTab
+                {
+                    // sheet for basic is one-based
+                    nTab = static_cast<const SfxUInt16Item&>(pReqArgs->Get(nSlot)).GetValue() - 1;
+                }
+                else            // command from Menu: ask for nTab
+                {
+                    ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
+
+                    ScopedVclPtr<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.GetTabNo() == nTab );
+                        }
+                    }
+
+                    if( pDlg->Execute() == RET_OK )
+                    {
+                        if( !rDoc.GetTable( pDlg->GetSelectedEntry(), nTab ) )
+                            nTab = nTabCount;
+                        pDlg.disposeAndClear();
+                    }
+                    else
+                    {
+                        rReq.Ignore();
+                    }
+                }
+                if ( nTab < nTabCount )
+                {
+                    SetTabNo( nTab );
+                    rBindings.Update( nSlot );
+
+                    if( ! rReq.IsAPI() )
+                        rReq.Done();
+                }
+                //! 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 ( !pThisFrame->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();
+
+                    pThisFrame->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
+                pThisFrame->ShowChildWindow(SID_SIDEBAR);
+
+                ::sfx2::sidebar::Sidebar::ShowPanel(u"ScFunctionsPanel",
+                                                    pThisFrame->GetFrame().GetFrameInterface());
+                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_TOGGLEHEADERS:
+            {
+                bool bSet = !GetViewData().IsHeaderMode();
+                const SfxPoolItem* pItem;
+                if ( pReqArgs && pReqArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET )
+                    bSet = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                GetViewData().SetHeaderMode( bSet );
+                RepeatResize();
+                rBindings.Invalidate( FID_TOGGLEHEADERS );
+                rReq.AppendItem( SfxBoolItem( nSlot, bSet ) );
+                rReq.Done();
+            }
+            break;
+
+        case FID_TOGGLEFORMULA:
+            {
+                ScViewData& rViewData = GetViewData();
+                const ScViewOptions& rOpts = rViewData.GetOptions();
+                bool bFormulaMode = !rOpts.GetOption( VOPT_FORMULAS );
+                const SfxPoolItem *pItem;
+                if( pReqArgs && pReqArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET )
+                    bFormulaMode = static_cast<const SfxBoolItem *>(pItem)->GetValue();
+
+                ScViewOptions aSetOpts = rOpts;
+                aSetOpts.SetOption( VOPT_FORMULAS, bFormulaMode );
+                rViewData.SetOptions( aSetOpts );
+
+                rViewData.GetDocShell()->PostPaintGridAll();
+
+                rBindings.Invalidate( FID_TOGGLEFORMULA );
+                rReq.AppendItem( SfxBoolItem( nSlot, bFormulaMode ) );
+                rReq.Done();
+            }
+            break;
+
+        case FID_TOGGLEINPUTLINE:
+            {
+                sal_uInt16          nId  = ScInputWindowWrapper::GetChildWindowId();
+                SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId );
+                bool bSet = ( pWnd == nullptr );
+                const SfxPoolItem* pItem;
+                if ( pReqArgs && pReqArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET )
+                    bSet = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+
+                pThisFrame->SetChildWindow( nId, bSet );
+                rBindings.Invalidate( FID_TOGGLEINPUTLINE );
+                rReq.AppendItem( SfxBoolItem( nSlot, bSet ) );
+                rReq.Done();
+            }
+            break;
+
+        // handling for SID_ZOOM_IN and SID_ZOOM_OUT is ScTabView::ScrollCommand
+        // CommandWheelMode::ZOOM inspired
+        case SID_ZOOM_IN:
+        case SID_ZOOM_OUT:
+            {
+                HideNoteMarker();
+
+                if (!GetViewData().GetViewShell()->GetViewFrame()->GetFrame().IsInPlace())
+                {
+                    //  for ole inplace editing, the scale is defined by the visarea and client size
+                    //  and can't be changed directly
+
+                    const Fraction& rOldY = GetViewData().GetZoomY();
+                    tools::Long nOld = tools::Long(rOldY * 100);
+                    tools::Long nNew;
+                    if (SID_ZOOM_OUT == nSlot)
+                        nNew = std::max(tools::Long(MINZOOM), basegfx::zoomtools::zoomOut(nOld));
+                    else
+                        nNew = std::min(tools::Long(MAXZOOM), basegfx::zoomtools::zoomIn(nOld));
+                    if ( nNew != nOld)
+                    {
+                        bool bSyncZoom = SC_MOD()->GetAppOptions().GetSynchronizeZoom();
+                        SetZoomType(SvxZoomType::PERCENT, bSyncZoom);
+                        Fraction aFract(nNew, 100);
+                        SetZoom(aFract, aFract, bSyncZoom);
+                        PaintGrid();
+                        PaintTop();
+                        PaintLeft();
+                        rBindings.Invalidate(SID_ATTR_ZOOM);
+                        rBindings.Invalidate(SID_ATTR_ZOOMSLIDER);
+                        rBindings.Invalidate(SID_ZOOM_IN);
+                        rBindings.Invalidate(SID_ZOOM_OUT);
+                        rReq.Done();
+                    }
+                }
+            }
+            break;
+
+        case SID_ATTR_ZOOM: // status row
+        case FID_SCALE:
+            {
+                bool bSyncZoom = SC_MOD()->GetAppOptions().GetSynchronizeZoom();
+                SvxZoomType eOldZoomType = GetZoomType();
+                SvxZoomType eNewZoomType = eOldZoomType;
+                const Fraction& rOldY = GetViewData().GetZoomY();  // Y is shown
+                sal_uInt16 nOldZoom = static_cast<sal_uInt16>(tools::Long( rOldY * 100 ));
+                sal_uInt16 nZoom = nOldZoom;
+                bool bCancel = false;
+
+                if ( pReqArgs )
+                {
+                    const SvxZoomItem& rZoomItem = pReqArgs->Get(SID_ATTR_ZOOM);
+
+                    eNewZoomType = rZoomItem.GetType();
+                    nZoom     = rZoomItem.GetValue();
+                }
+                else
+                {
+                    SfxItemSetFixed<SID_ATTR_ZOOM, SID_ATTR_ZOOM> aSet( GetPool() );
+                    SvxZoomItem     aZoomItem( eOldZoomType, nOldZoom, SID_ATTR_ZOOM );
+                    ScopedVclPtr<AbstractSvxZoomDialog> pDlg;
+                    ScMarkData&     rMark = GetViewData().GetMarkData();
+                    SvxZoomEnableFlags nBtnFlags = SvxZoomEnableFlags::N50
+                                                | SvxZoomEnableFlags::N75
+                                                | SvxZoomEnableFlags::N100
+                                                | SvxZoomEnableFlags::N150
+                                                | SvxZoomEnableFlags::N200
+                                                | SvxZoomEnableFlags::WHOLEPAGE
+                                                | SvxZoomEnableFlags::PAGEWIDTH;
+
+                    if ( rMark.IsMarked() || rMark.IsMultiMarked() )
+                        nBtnFlags = nBtnFlags | SvxZoomEnableFlags::OPTIMAL;
+
+                    aZoomItem.SetValueSet( nBtnFlags );
+                    aSet.Put( aZoomItem );
+                    SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+                    pDlg.disposeAndReset(pFact->CreateSvxZoomDialog(GetFrameWeld(), aSet));
+                    pDlg->SetLimits( MINZOOM, MAXZOOM );
+
+                    bCancel = ( RET_CANCEL == pDlg->Execute() );
+
+                    // bCancel is True only if we were in the previous if block,
+                    // so no need to check again pDlg
+                    if ( !bCancel )
+                    {
+                        const SvxZoomItem&  rZoomItem = pDlg->GetOutputItemSet()->
+                                                    Get( SID_ATTR_ZOOM );
+
+                        eNewZoomType = rZoomItem.GetType();
+                        nZoom     = rZoomItem.GetValue();
+                    }
+                }
+
+                if ( !bCancel )
+                {
+                    if ( eNewZoomType == SvxZoomType::PERCENT )
+                    {
+                        if ( nZoom < MINZOOM )  nZoom = MINZOOM;
+                        if ( nZoom > MAXZOOM )  nZoom = MAXZOOM;
+                    }
+                    else
+                    {
+                        nZoom = CalcZoom( eNewZoomType, nOldZoom );
+                        bCancel = nZoom == 0;
+                    }
+
+                    switch ( eNewZoomType )
+                    {
+                        case SvxZoomType::WHOLEPAGE:
+                        case SvxZoomType::PAGEWIDTH:
+                            SetZoomType( eNewZoomType, bSyncZoom );
+                            break;
+
+                        default:
+                            SetZoomType( SvxZoomType::PERCENT, bSyncZoom );
+                    }
+                }
+
+                if ( nZoom != nOldZoom && !bCancel )
+                {
+                    if (!GetViewData().IsPagebreakMode())
+                    {
+                        ScAppOptions aNewOpt = pScMod->GetAppOptions();
+                        aNewOpt.SetZoom( nZoom );
+                        aNewOpt.SetZoomType( GetZoomType() );
+                        pScMod->SetAppOptions( aNewOpt );
+                    }
+                    Fraction aFract( nZoom, 100 );
+                    SetZoom( aFract, aFract, bSyncZoom );
+                    PaintGrid();
+                    PaintTop();
+                    PaintLeft();
+                    rBindings.Invalidate( SID_ATTR_ZOOM );
+                    rReq.AppendItem( SvxZoomItem( GetZoomType(), nZoom, nSlot ) );
+                    rReq.Done();
+                }
+            }
+            break;
+
+        case SID_ATTR_ZOOMSLIDER:
+            {
+                const SfxPoolItem* pItem = nullptr;
+                bool bSyncZoom = SC_MOD()->GetAppOptions().GetSynchronizeZoom();
+                if ( pReqArgs && pReqArgs->GetItemState(SID_ATTR_ZOOMSLIDER, true, &pItem) == SfxItemState::SET )
+                {
+                    const sal_uInt16 nCurrentZoom = static_cast<const SvxZoomSliderItem *>(pItem)->GetValue();
+                    if( nCurrentZoom )
+                    {
+                        SetZoomType( SvxZoomType::PERCENT, bSyncZoom );
+                        if (!GetViewData().IsPagebreakMode())
+                        {
+                            ScAppOptions aNewOpt = pScMod->GetAppOptions();
+                            aNewOpt.SetZoom( nCurrentZoom );
+                            collectUIInformation(OUString::number(nCurrentZoom));
+                            aNewOpt.SetZoomType( GetZoomType() );
+                            pScMod->SetAppOptions( aNewOpt );
+                        }
+                        Fraction aFract( nCurrentZoom,100 );
+                        SetZoom( aFract, aFract, bSyncZoom );
+                        PaintGrid();
+                        PaintTop();
+                        PaintLeft();
+                        rBindings.Invalidate( SID_ATTR_ZOOMSLIDER );
+                        rBindings.Invalidate( SID_ZOOM_IN );
+                        rBindings.Invalidate( SID_ZOOM_OUT );
+                        rReq.Done();
+                    }
+                }
+            }
+            break;
+
+        case FID_TAB_SELECTALL:
+            SelectAllTables();
+            rReq.Done();
+            break;
+
+        case FID_TAB_DESELECTALL:
+            DeselectAllTables();
+            rReq.Done();
+            break;
+
+        case SID_SELECT_TABLES:
+        {
+            ScViewData& rViewData = GetViewData();
+            ScDocument& rDoc = rViewData.GetDocument();
+            ScMarkData& rMark = rViewData.GetMarkData();
+            SCTAB nTabCount = rDoc.GetTableCount();
+            SCTAB nTab;
+
+            ::std::vector < sal_Int32 > aIndexList;
+            const SfxIntegerListItem* pItem = rReq.GetArg<SfxIntegerListItem>(SID_SELECT_TABLES);
+            if ( pItem )
+                aIndexList = pItem->GetList();
+            else
+            {
+                ScAbstractDialogFactory* pFact = ScAbstractDialogFactory::Create();
+
+                ScopedVclPtr<AbstractScShowTabDlg> pDlg(pFact->CreateScShowTabDlg(GetFrameWeld()));
+                pDlg->SetDescription(
+                    ScResId( STR_DLG_SELECTTABLES_TITLE ),
+                    ScResId( STR_DLG_SELECTTABLES_LBNAME ),
+                    GetStaticInterface()->GetSlot(SID_SELECT_TABLES)->GetCommand(), HID_SELECTTABLES );
+
+                // fill all table names with selection state
+                OUString aTabName;
+                for( nTab = 0; nTab < nTabCount; ++nTab )
+                {
+                    rDoc.GetName( nTab, aTabName );
+                    pDlg->Insert( aTabName, rMark.GetTableSelect( nTab ) );
+                }
+
+                if( pDlg->Execute() == RET_OK )
+                {
+                    aIndexList = pDlg->GetSelectedRows();
+                    pDlg.disposeAndClear();
+                    rReq.AppendItem( SfxIntegerListItem( SID_SELECT_TABLES, std::vector(aIndexList) ) );
+                }
+                else
+                    rReq.Ignore();
+            }
+
+            if ( !aIndexList.empty() )
+            {
+                sal_uInt16 nSelCount = aIndexList.size();
+                sal_uInt16 nSelIx;
+                SCTAB nFirstVisTab = 0;
+
+                // special case: only hidden tables selected -> do nothing
+                bool bVisSelected = false;
+                for( nSelIx = 0; !bVisSelected && (nSelIx < nSelCount); ++nSelIx )
+                {
+                    nFirstVisTab = static_cast<SCTAB>(aIndexList[nSelIx]);
+                    bVisSelected = rDoc.IsVisible( nFirstVisTab );
+                }
+                if( !bVisSelected )
+                    nSelCount = 0;
+
+                // select the tables
+                if( nSelCount )
+                {
+                    for( nTab = 0; nTab < nTabCount; ++nTab )
+                        rMark.SelectTable( nTab, false );
+
+                    for( nSelIx = 0; nSelIx < nSelCount; ++nSelIx )
+                        rMark.SelectTable( static_cast<SCTAB>(aIndexList[nSelIx]), true );
+
+                    // activate another table, if current is deselected
+                    if( !rMark.GetTableSelect( rViewData.GetTabNo() ) )
+                    {
+                        rMark.SelectTable( nFirstVisTab, true );
+                        SetTabNo( nFirstVisTab );
+                    }
+
+                    rViewData.GetDocShell()->PostPaintExtras();
+                    SfxBindings& rBind = rViewData.GetBindings();
+                    rBind.Invalidate( FID_FILL_TAB );
+                    rBind.Invalidate( FID_TAB_DESELECTALL );
+                }
+
+                rReq.Done();
+            }
+        }
+        break;
+
+        case SID_OUTLINE_DELETEALL:
+            RemoveAllOutlines();
+            rReq.Done();
+            break;
+
+        case SID_AUTO_OUTLINE:
+            AutoOutline();
+            rReq.Done();
+            break;
+
+        case SID_WINDOW_SPLIT:
+            {
+                ScSplitMode eHSplit = GetViewData().GetHSplitMode();
+                ScSplitMode eVSplit = GetViewData().GetVSplitMode();
+                if ( eHSplit == SC_SPLIT_NORMAL || eVSplit == SC_SPLIT_NORMAL )     // remove
+                    RemoveSplit();
+                else if ( eHSplit == SC_SPLIT_FIX || eVSplit == SC_SPLIT_FIX )      // normal
+                    FreezeSplitters( false );
+                else                                                                // create
+                    SplitAtCursor();
+                rReq.Done();
+
+                InvalidateSplit();
+            }
+            break;
+
+        case SID_WINDOW_FIX:
+            {
+                if (!comphelper::LibreOfficeKit::isActive())
+                {
+                    ScSplitMode eHSplit = GetViewData().GetHSplitMode();
+                    ScSplitMode eVSplit = GetViewData().GetVSplitMode();
+                    if ( eHSplit == SC_SPLIT_FIX || eVSplit == SC_SPLIT_FIX )           // remove
+                        RemoveSplit();
+                    else
+                        FreezeSplitters( true, SC_SPLIT_METHOD_CURSOR);                 // create or fixate
+                    rReq.Done();
+                    InvalidateSplit();
+                }
+                else
+                {
+                    ScViewData& rViewData = GetViewData();
+                    SCTAB nThisTab = rViewData.GetTabNo();
+                    bool bChangedX = false, bChangedY = false;
+                    if (rViewData.GetLOKSheetFreezeIndex(true) > 0 ||
+                        rViewData.GetLOKSheetFreezeIndex(false) > 0 )                             // remove freeze
+                    {
+                        bChangedX = rViewData.RemoveLOKFreeze();
+                    }                                                                            // create or fixate
+                    else
+                    {
+                        bChangedX = rViewData.SetLOKSheetFreezeIndex(rViewData.GetCurX(), true);    // Freeze column
+                        bChangedY = rViewData.SetLOKSheetFreezeIndex(rViewData.GetCurY(), false);   // Freeze row
+                    }
+
+                    rReq.Done();
+                    if (bChangedX || bChangedY)
+                    {
+                        rBindings.Invalidate( SID_WINDOW_FIX );
+                        rBindings.Invalidate( SID_WINDOW_FIX_COL );
+                        rBindings.Invalidate( SID_WINDOW_FIX_ROW );
+                        // Invalidate the slot for all views on the same tab of the document.
+                        SfxLokHelper::forEachOtherView(this, [nThisTab](ScTabViewShell* pOther) {
+                            ScViewData& rOtherViewData = pOther->GetViewData();
+                            if (rOtherViewData.GetTabNo() != nThisTab)
+                                return;
+
+                            SfxBindings& rOtherBind = rOtherViewData.GetBindings();
+                            rOtherBind.Invalidate( SID_WINDOW_FIX );
+                            rOtherBind.Invalidate( SID_WINDOW_FIX_COL );
+                            rOtherBind.Invalidate( SID_WINDOW_FIX_ROW );
+                        });
+                        if (!GetViewData().GetDocShell()->IsReadOnly())
+                            GetViewData().GetDocShell()->SetDocumentModified();
+                    }
+                }
+            }
+            break;
+
+        case SID_WINDOW_FIX_COL:
+        case SID_WINDOW_FIX_ROW:
+            {
+                bool bIsCol = (nSlot == SID_WINDOW_FIX_COL);
+                sal_Int32 nFreezeIndex = 1;
+                if (const SfxInt32Item* pItem = rReq.GetArg<SfxInt32Item>(nSlot))
+                {
+                    nFreezeIndex = pItem->GetValue();
+                    if (nFreezeIndex < 0)
+                        nFreezeIndex = 0;
+                }
+
+                if (comphelper::LibreOfficeKit::isActive())
+                {
+                    ScViewData& rViewData = GetViewData();
+                    SCTAB nThisTab = rViewData.GetTabNo();
+                    bool bChanged = rViewData.SetLOKSheetFreezeIndex(nFreezeIndex, bIsCol);
+                    rReq.Done();
+                    if (bChanged)
+                    {
+                        rBindings.Invalidate( SID_WINDOW_FIX );
+                        rBindings.Invalidate(nSlot);
+                        // Invalidate the slot for all views on the same tab of the document.
+                        SfxLokHelper::forEachOtherView(this, [nSlot, nThisTab](ScTabViewShell* pOther) {
+                            ScViewData& rOtherViewData = pOther->GetViewData();
+                            if (rOtherViewData.GetTabNo() != nThisTab)
+                                return;
+
+                            SfxBindings& rOtherBind = rOtherViewData.GetBindings();
+                            rOtherBind.Invalidate( SID_WINDOW_FIX );
+                            rOtherBind.Invalidate(nSlot);
+                        });
+                        if (!GetViewData().GetDocShell()->IsReadOnly())
+                            GetViewData().GetDocShell()->SetDocumentModified();
+                    }
+                }
+                else
+                {
+                    FreezeSplitters( true, bIsCol ? SC_SPLIT_METHOD_COL : SC_SPLIT_METHOD_ROW, nFreezeIndex);
+                    rReq.Done();
+                    InvalidateSplit();
+                }
+            }
+            break;
+
+        case FID_CHG_SHOW:
+            {
+                sal_uInt16          nId  = ScHighlightChgDlgWrapper::GetChildWindowId();
+                SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId );
+
+                pScMod->SetRefDialog( nId, pWnd == nullptr );
+            }
+            break;
+
+        case FID_CHG_ACCEPT:
+            {
+                pThisFrame->ToggleChildWindow(ScAcceptChgDlgWrapper::GetChildWindowId());
+                GetViewFrame()->GetBindings().Invalidate(FID_CHG_ACCEPT);
+                rReq.Done ();
+
+                /*
+                sal_uInt16          nId  = ScAcceptChgDlgWrapper::GetChildWindowId();
+                SfxChildWindow* pWnd = pThisFrame->GetChildWindow( nId );
+
+                pScMod->SetRefDialog( nId, pWnd ? sal_False : sal_True );
+                */
+            }
+            break;
+
+        case FID_CHG_COMMENT:
+            {
+                ScViewData& rData = GetViewData();
+                ScAddress aCursorPos( rData.GetCurX(), rData.GetCurY(), rData.GetTabNo() );
+                ScDocShell* pDocSh = rData.GetDocShell();
+
+                ScChangeAction* pAction = pDocSh->GetChangeAction( aCursorPos );
+                if ( pAction )
+                {
+                    const SfxPoolItem* pItem;
+                    if ( pReqArgs &&
+                         pReqArgs->GetItemState( nSlot, true, &pItem ) == SfxItemState::SET &&
+                         dynamic_cast<const SfxStringItem*>( pItem) !=  nullptr )
+                    {
+                        OUString aComment = static_cast<const SfxStringItem*>(pItem)->GetValue();
+                        pDocSh->SetChangeComment( pAction, aComment );
+                        rReq.Done();
+                    }
+                    else
+                    {
+                        pDocSh->ExecuteChangeCommentDialog(pAction, GetFrameWeld());
+                        rReq.Done();
+                    }
+                }
+            }
+            break;
+
+        case SID_CREATE_SW_DRAWVIEW:
+            //  is called by Forms, when the DrawView has to be created with all
+            //  the extras
+            if (!GetScDrawView())
+            {
+                GetViewData().GetDocShell()->MakeDrawLayer();
+                rBindings.InvalidateAll(false);
+            }
+            break;
+
+        case FID_PROTECT_DOC:
+            {
+                ScDocument& rDoc = GetViewData().GetDocument();
+
+                if( pReqArgs )
+                {
+                    const SfxPoolItem* pItem;
+                    if( pReqArgs->HasItem( FID_PROTECT_DOC, &pItem ) &&
+                        static_cast<const SfxBoolItem*>(pItem)->GetValue() == rDoc.IsDocProtected() )
+                    {
+                        rReq.Ignore();
+                        break;
+                    }
+                }
+
+                ScDocProtection* pProtect = rDoc.GetDocProtection();
+                if (pProtect && pProtect->isProtected())
+                {
+                    bool bCancel = false;
+                    OUString aPassword;
+
+                    if (pProtect->isProtectedWithPass())
+                    {
+                        OUString aText(ScResId(SCSTR_PASSWORD));
+
+                        SfxPasswordDialog aDlg(GetFrameWeld(), &aText);
+                        aDlg.set_title(ScResId(SCSTR_UNPROTECTDOC));
+                        aDlg.SetMinLen(0);
+                        aDlg.set_help_id(GetStaticInterface()->GetSlot(FID_PROTECT_DOC)->GetCommand());
+                        aDlg.SetEditHelpId(HID_PASSWD_DOC);
+
+                        if (aDlg.run() == RET_OK)
+                            aPassword = aDlg.GetPassword();
+                        else
+                            bCancel = true;
+                    }
+                    if (!bCancel)
+                    {
+                        Unprotect( TABLEID_DOC, aPassword );
+                        rReq.AppendItem( SfxBoolItem( FID_PROTECT_DOC, false ) );
+                        rReq.Done();
+                    }
+                }
+                else
+                {
+                    OUString aText(ScResId(SCSTR_PASSWORDOPT));
+
+                    SfxPasswordDialog aDlg(GetFrameWeld(), &aText);
+                    aDlg.set_title(ScResId(SCSTR_PROTECTDOC));
+                    aDlg.SetMinLen( 0 );
+                    aDlg.set_help_id(GetStaticInterface()->GetSlot(FID_PROTECT_DOC)->GetCommand());
+                    aDlg.SetEditHelpId(HID_PASSWD_DOC);
+                    aDlg.ShowExtras(SfxShowExtras::CONFIRM);
+                    aDlg.SetConfirmHelpId(HID_PASSWD_DOC_CONFIRM);
+
+                    if (aDlg.run() == RET_OK)
+                    {
+                        OUString aPassword = aDlg.GetPassword();
+                        ProtectDoc( aPassword );
+                        rReq.AppendItem( SfxBoolItem( FID_PROTECT_DOC, true ) );
+                        rReq.Done();
+                    }
+                }
+                rBindings.Invalidate( FID_PROTECT_DOC );
+            }
+            break;
+
+        case FID_PROTECT_TABLE:
+        {
+            ScDocument& rDoc = GetViewData().GetDocument();
+            SCTAB       nTab = GetViewData().GetTabNo();
+            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();
+                    break;
+                }
+            }
+
+            if (bOldProtection)
+            {
+                // Unprotect a protected sheet.
+
+                const ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);
+                if (pProtect && pProtect->isProtectedWithPass())
+                {
+                    OUString aText( ScResId(SCSTR_PASSWORDOPT) );
+                    SfxPasswordDialog aDlg(GetFrameWeld(), &aText);
+                    aDlg.set_title(ScResId(SCSTR_UNPROTECTTAB));
+                    aDlg.SetMinLen(0);
+                    aDlg.set_help_id(GetStaticInterface()->GetSlot(FID_PROTECT_TABLE)->GetCommand());
+                    aDlg.SetEditHelpId(HID_PASSWD_TABLE);
+
+                    if (aDlg.run() == RET_OK)
+                    {
+                        OUString aPassword = aDlg.GetPassword();
+                        Unprotect(nTab, aPassword);
+                    }
+                }
+                else
+                    // this sheet is not password-protected.
+                    Unprotect(nTab, OUString());
+
+                if (!pReqArgs)
+                {
+                    rReq.AppendItem( SfxBoolItem(FID_PROTECT_TABLE, false) );
+                    rReq.Done();
+                }
+            }
+            else
+            {
+                // Protect a current sheet.
+
+                ScTableProtectionDlg aDlg(GetFrameWeld());
+
+                const ScTableProtection* pProtect = rDoc.GetTabProtection(nTab);
+                if (pProtect)
+                    aDlg.SetDialogData(*pProtect);
+
+                if (aDlg.run() == RET_OK)
+                {
+                    pScMod->InputEnterHandler();
+
+                    ScTableProtection aNewProtect;
+                    aDlg.WriteData(aNewProtect);
+                    ProtectSheet(nTab, aNewProtect);
+                    if (!pReqArgs)
+                    {
+                        rReq.AppendItem( SfxBoolItem(FID_PROTECT_TABLE, true) );
+                        rReq.Done();
+                    }
+                }
+            }
+            TabChanged();
+            UpdateInputHandler(true);   // to immediately enable input again
+            SelectionChanged();
+        }
+        break;
+
+        case SID_OPT_LOCALE_CHANGED :
+            {   // locale changed, SYSTEM number formats changed => repaint cell contents
+                PaintGrid();
+                rReq.Done();
+            }
+            break;
+
+        default:
+            OSL_FAIL("Unknown Slot at ScTabViewShell::Execute");
+            break;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */