Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

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

1 files changed, 3006 insertions, 0 deletions

diff --git a/sc/source/ui/view/viewfunc.cxx b/sc/source/ui/view/viewfunc.cxx
new file mode 100644
index 000000000..6e4be285c
--- /dev/null
+++ b/sc/source/ui/view/viewfunc.cxx
@@ -0,0 +1,3006 @@
+/* -*- 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 <config_features.h>
+
+#include <scitems.hxx>
+
+#include <sfx2/app.hxx>
+#include <svx/algitem.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/editobj.hxx>
+#include <editeng/langitem.hxx>
+#include <editeng/shaditem.hxx>
+#include <editeng/justifyitem.hxx>
+#include <sfx2/bindings.hxx>
+#include <svl/zforlist.hxx>
+#include <svl/zformat.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/waitobj.hxx>
+#include <stdlib.h>
+#include <unotools/charclass.hxx>
+#include <vcl/uitest/logger.hxx>
+#include <vcl/uitest/eventdescription.hxx>
+
+#include <viewfunc.hxx>
+#include <tabvwsh.hxx>
+#include <docsh.hxx>
+#include <attrib.hxx>
+#include <patattr.hxx>
+#include <docpool.hxx>
+#include <sc.hrc>
+#include <strings.hrc>
+#include <undocell.hxx>
+#include <undoblk.hxx>
+#include <refundo.hxx>
+#include <olinetab.hxx>
+#include <rangenam.hxx>
+#include <globstr.hrc>
+#include <global.hxx>
+#include <stlsheet.hxx>
+#include <editutil.hxx>
+#include <formulacell.hxx>
+#include <scresid.hxx>
+#include <inputhdl.hxx>
+#include <scmod.hxx>
+#include <inputopt.hxx>
+#include <compiler.hxx>
+#include <docfunc.hxx>
+#include <appoptio.hxx>
+#include <sizedev.hxx>
+#include <editable.hxx>
+#include <scui_def.hxx>
+#include <funcdesc.hxx>
+#include <docuno.hxx>
+#include <cellsuno.hxx>
+#include <tokenarray.hxx>
+#include <rowheightcontext.hxx>
+#include <comphelper/lok.hxx>
+#include <conditio.hxx>
+#include <columnspanset.hxx>
+
+#include <memory>
+
+static void lcl_PostRepaintCondFormat( const ScConditionalFormat *pCondFmt, ScDocShell *pDocSh )
+{
+    if( pCondFmt )
+    {
+        const ScRangeList& rRanges = pCondFmt->GetRange();
+
+        pDocSh->PostPaint( rRanges, PaintPartFlags::All );
+    }
+}
+
+ScViewFunc::ScViewFunc( vcl::Window* pParent, ScDocShell& rDocSh, ScTabViewShell* pViewShell ) :
+    ScTabView( pParent, rDocSh, pViewShell ),
+    bFormatValid( false )
+{
+}
+
+ScViewFunc::~ScViewFunc()
+{
+}
+
+namespace {
+
+void collectUIInformation(const std::map<OUString, OUString>& aParameters, const OUString& rAction)
+{
+    EventDescription aDescription;
+    aDescription.aID = "grid_window";
+    aDescription.aAction = rAction;
+    aDescription.aParameters = aParameters;
+    aDescription.aParent = "MainWindow";
+    aDescription.aKeyWord = "ScGridWinUIObject";
+
+    UITestLogger::getInstance().logEvent(aDescription);
+}
+
+}
+
+void ScViewFunc::StartFormatArea()
+{
+    //  anything to do?
+    if ( !SC_MOD()->GetInputOptions().GetExtendFormat() )
+        return;
+
+    //  start only with single cell (marked or cursor position)
+    ScRange aMarkRange;
+    bool bOk = (GetViewData().GetSimpleArea( aMarkRange ) == SC_MARK_SIMPLE);
+    if ( bOk && aMarkRange.aStart != aMarkRange.aEnd )
+        bOk = false;
+
+    if (bOk)
+    {
+        bFormatValid = true;
+        aFormatSource = aMarkRange.aStart;
+        aFormatArea = ScRange( aFormatSource );
+    }
+    else
+        bFormatValid = false;       // discard old range
+}
+
+bool ScViewFunc::TestFormatArea( SCCOL nCol, SCROW nRow, SCTAB nTab, bool bAttrChanged )
+{
+    //  anything to do?
+    if ( !SC_MOD()->GetInputOptions().GetExtendFormat() )
+        return false;
+
+    //  Test: treat input with numberformat (bAttrChanged) always as new Attribute
+    //  (discard old Area ). If not wanted, discard if-statement
+    if ( bAttrChanged )
+    {
+        StartFormatArea();
+        return false;
+    }
+
+    //! Test if cell empty ???
+
+    bool bFound = false;
+    ScRange aNewRange = aFormatArea;
+    if ( bFormatValid && nTab == aFormatSource.Tab() )
+    {
+        if ( nRow >= aFormatArea.aStart.Row() && nRow <= aFormatArea.aEnd.Row() )
+        {
+            //  within range?
+            if ( nCol >= aFormatArea.aStart.Col() && nCol <= aFormatArea.aEnd.Col() )
+            {
+                bFound = true;          // do not change range
+            }
+            //  left ?
+            if ( nCol+1 == aFormatArea.aStart.Col() )
+            {
+                bFound = true;
+                aNewRange.aStart.SetCol( nCol );
+            }
+            //  right ?
+            if ( nCol == aFormatArea.aEnd.Col()+1 )
+            {
+                bFound = true;
+                aNewRange.aEnd.SetCol( nCol );
+            }
+        }
+        if ( nCol >= aFormatArea.aStart.Col() && nCol <= aFormatArea.aEnd.Col() )
+        {
+            //  top ?
+            if ( nRow+1 == aFormatArea.aStart.Row() )
+            {
+                bFound = true;
+                aNewRange.aStart.SetRow( nRow );
+            }
+            //  bottom ?
+            if ( nRow == aFormatArea.aEnd.Row()+1 )
+            {
+                bFound = true;
+                aNewRange.aEnd.SetRow( nRow );
+            }
+        }
+    }
+
+    if (bFound)
+        aFormatArea = aNewRange;    // extend
+    else
+        bFormatValid = false;       // outside of range -> break
+
+    return bFound;
+}
+
+void ScViewFunc::DoAutoAttributes( SCCOL nCol, SCROW nRow, SCTAB nTab,
+                                   bool bAttrChanged )
+{
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+
+    const ScPatternAttr* pSource = rDoc.GetPattern(
+                            aFormatSource.Col(), aFormatSource.Row(), nTab );
+    if ( !pSource->GetItem(ATTR_MERGE).IsMerged() )
+    {
+        ScRange aRange( nCol, nRow, nTab, nCol, nRow, nTab );
+        ScMarkData aMark(rDoc.MaxRow(), rDoc.MaxCol());
+        aMark.SetMarkArea( aRange );
+
+        ScDocFunc &rFunc = GetViewData().GetDocFunc();
+
+        // pOldPattern is only valid until call to ApplyAttributes!
+        const ScPatternAttr* pOldPattern = rDoc.GetPattern( nCol, nRow, nTab );
+        const ScStyleSheet* pSrcStyle = pSource->GetStyleSheet();
+        if ( pSrcStyle && pSrcStyle != pOldPattern->GetStyleSheet() )
+            rFunc.ApplyStyle( aMark, pSrcStyle->GetName(), false );
+
+        rFunc.ApplyAttributes( aMark, *pSource, false );
+    }
+
+    if ( bAttrChanged )                             // value entered with number format?
+        aFormatSource.Set( nCol, nRow, nTab );      // then set a new source
+}
+
+//      additional routines
+
+sal_uInt16 ScViewFunc::GetOptimalColWidth( SCCOL nCol, SCTAB nTab, bool bFormula )
+{
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    ScMarkData& rMark = GetViewData().GetMarkData();
+
+    double nPPTX = GetViewData().GetPPTX();
+    double nPPTY = GetViewData().GetPPTY();
+    Fraction aZoomX = GetViewData().GetZoomX();
+    Fraction aZoomY = GetViewData().GetZoomY();
+
+    ScSizeDeviceProvider aProv(pDocSh);
+    if (aProv.IsPrinter())
+    {
+        nPPTX = aProv.GetPPTX();
+        nPPTY = aProv.GetPPTY();
+        aZoomX = aZoomY = Fraction( 1, 1 );
+    }
+
+    sal_uInt16 nTwips = rDoc.GetOptimalColWidth( nCol, nTab, aProv.GetDevice(),
+                                nPPTX, nPPTY, aZoomX, aZoomY, bFormula, &rMark );
+    return nTwips;
+}
+
+bool ScViewFunc::SelectionEditable( bool* pOnlyNotBecauseOfMatrix /* = NULL */ )
+{
+    bool bRet;
+    ScDocument* pDoc = GetViewData().GetDocument();
+    ScMarkData& rMark = GetViewData().GetMarkData();
+    if (rMark.IsMarked() || rMark.IsMultiMarked())
+        bRet = pDoc->IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix );
+    else
+    {
+        SCCOL nCol = GetViewData().GetCurX();
+        SCROW nRow = GetViewData().GetCurY();
+        SCTAB nTab = GetViewData().GetTabNo();
+        bRet = pDoc->IsBlockEditable( nTab, nCol, nRow, nCol, nRow,
+            pOnlyNotBecauseOfMatrix );
+    }
+    return bRet;
+}
+
+static bool lcl_FunctionKnown( sal_uInt16 nOpCode )
+{
+    const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
+    if ( pFuncList )
+    {
+        sal_uLong nCount = pFuncList->GetCount();
+        for (sal_uLong i=0; i<nCount; i++)
+            if ( pFuncList->GetFunction(i)->nFIndex == nOpCode )
+                return true;
+    }
+    return false;
+}
+
+static bool lcl_AddFunction( ScAppOptions& rAppOpt, sal_uInt16 nOpCode )
+{
+    sal_uInt16 nOldCount = rAppOpt.GetLRUFuncListCount();
+    sal_uInt16* pOldList = rAppOpt.GetLRUFuncList();
+    sal_uInt16 nPos;
+    for (nPos=0; nPos<nOldCount; nPos++)
+        if (pOldList[nPos] == nOpCode)          // is the function already in the list?
+        {
+            if ( nPos == 0 )
+                return false;                   // already at the top -> no change
+
+            //  count doesn't change, so the original array is modified
+
+            for (sal_uInt16 nCopy=nPos; nCopy>0; nCopy--)
+                pOldList[nCopy] = pOldList[nCopy-1];
+            pOldList[0] = nOpCode;
+
+            return true;                        // list has changed
+        }
+
+    if ( !lcl_FunctionKnown( nOpCode ) )
+        return false;                           // not in function list -> no change
+
+    sal_uInt16 nNewCount = std::min( static_cast<sal_uInt16>(nOldCount + 1), sal_uInt16(LRU_MAX) );
+    sal_uInt16 nNewList[LRU_MAX];
+    nNewList[0] = nOpCode;
+    for (nPos=1; nPos<nNewCount; nPos++)
+        nNewList[nPos] = pOldList[nPos-1];
+    rAppOpt.SetLRUFuncList( nNewList, nNewCount );
+
+    return true;                                // list has changed
+}
+
+namespace HelperNotifyChanges
+{
+    static void NotifyIfChangesListeners(const ScDocShell &rDocShell, ScMarkData& rMark, SCCOL nCol, SCROW nRow)
+    {
+        if (ScModelObj *pModelObj = getMustPropagateChangesModel(rDocShell))
+        {
+            ScRangeList aChangeRanges;
+            for (const auto& rTab : rMark)
+                aChangeRanges.push_back( ScRange( nCol, nRow, rTab ) );
+
+            HelperNotifyChanges::Notify(*pModelObj, aChangeRanges, "cell-change");
+        }
+    }
+}
+
+//      actual functions
+
+//  input - undo OK
+void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab,
+                            const OUString& rString,
+                            const EditTextObject* pData )
+{
+    ScDocument* pDoc = GetViewData().GetDocument();
+    ScMarkData rMark(GetViewData().GetMarkData());
+    bool bRecord = pDoc->IsUndoEnabled();
+    SCTAB i;
+
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocFunc &rFunc = GetViewData().GetDocFunc();
+    ScDocShellModificator aModificator( *pDocSh );
+
+    ScEditableTester aTester( pDoc, nCol,nRow, nCol,nRow, rMark );
+    if (!aTester.IsEditable())
+    {
+        ErrorMessage(aTester.GetMessageId());
+        PaintArea(nCol, nRow, nCol, nRow);        // possibly the edit-engine is still painted there
+        return;
+    }
+
+    if ( bRecord )
+        rFunc.EnterListAction( STR_UNDO_ENTERDATA );
+
+    bool bFormula = false;
+
+    // a single '=' character is handled as string (needed for special filters)
+    if ( rString.getLength() > 1 )
+    {
+        if ( rString[0] == '=' )
+        {
+            // handle as formula
+            bFormula = true;
+        }
+        else if ( rString[0] == '+' || rString[0] == '-' )
+        {
+            // if there is more than one leading '+' or '-' character, remove the additional ones
+            sal_Int32 nIndex = 1;
+            sal_Int32 nLen = rString.getLength();
+            while ( nIndex < nLen && ( rString[ nIndex ] == '+' || rString[ nIndex ] == '-' ) )
+            {
+                ++nIndex;
+            }
+            OUString aString = rString.replaceAt( 1, nIndex - 1, "" );
+
+            // if the remaining part without the leading '+' or '-' character
+            // is non-empty and not a number, handle as formula
+            if ( aString.getLength() > 1 )
+            {
+                sal_uInt32 nFormat = 0;
+                pDoc->GetNumberFormat( nCol, nRow, nTab, nFormat );
+                SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
+                double fNumber = 0;
+                if ( !pFormatter->IsNumberFormat( aString, nFormat, fNumber ) )
+                {
+                    bFormula = true;
+                }
+            }
+        }
+    }
+
+    bool bNumFmtChanged = false;
+    if ( bFormula )
+    {   // formula, compile with autoCorrection
+        i = rMark.GetFirstSelected();
+        ScAddress aPos( nCol, nRow, i );
+        ScCompiler aComp( pDoc, aPos, pDoc->GetGrammar(), true, false );
+//2do: enable/disable autoCorrection via calcoptions
+        aComp.SetAutoCorrection( true );
+        if ( rString[0] == '+' || rString[0] == '-' )
+        {
+            aComp.SetExtendedErrorDetection( ScCompiler::EXTENDED_ERROR_DETECTION_NAME_BREAK );
+        }
+        OUString aFormula( rString );
+        std::unique_ptr< ScTokenArray > pArr;
+        bool bAgain;
+        do
+        {
+            bAgain = false;
+            bool bAddEqual = false;
+            pArr = aComp.CompileString( aFormula );
+            bool bCorrected = aComp.IsCorrected();
+            std::unique_ptr< ScTokenArray > pArrFirst;
+            if ( bCorrected )
+            {   // try to parse with first parser-correction
+                pArrFirst = std::move( pArr );
+                pArr = aComp.CompileString( aComp.GetCorrectedFormula() );
+            }
+            if ( pArr->GetCodeError() == FormulaError::NONE )
+            {
+                bAddEqual = true;
+                aComp.CompileTokenArray();
+                bCorrected |= aComp.IsCorrected();
+            }
+            if ( bCorrected )
+            {
+                OUString aCorrectedFormula;
+                if ( bAddEqual )
+                {
+                    aCorrectedFormula = "=" + aComp.GetCorrectedFormula();
+                }
+                else
+                    aCorrectedFormula = aComp.GetCorrectedFormula();
+                short nResult;
+                if ( aCorrectedFormula.getLength() == 1 )
+                    nResult = RET_NO;   // empty formula, just '='
+                else
+                {
+                    OUString aMessage = ScResId( SCSTR_FORMULA_AUTOCORRECTION ) + aCorrectedFormula;
+
+                    std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(GetViewData().GetDialogParent(),
+                                                                   VclMessageType::Question, VclButtonsType::YesNo,
+                                                                   aMessage));
+                    xQueryBox->set_default_response(RET_YES);
+                    nResult = xQueryBox->run();
+                }
+                if ( nResult == RET_YES )
+                {
+                    aFormula = aCorrectedFormula;
+                    bAgain = true;
+                }
+                else
+                {
+                    if ( pArrFirst )
+                        pArr = std::move( pArrFirst );
+                }
+            }
+        } while ( bAgain );
+        // to be used in multiple tabs, the formula must be compiled anew
+        // via ScFormulaCell copy-ctor because of RangeNames,
+        // the same code-array for all cells is not possible.
+        // If the array has an error, (it) must be RPN-erased in the newly generated
+        // cells and the error be set explicitly, so that
+        // via FormulaCell copy-ctor and Interpreter it will be, when possible,
+        // ironed out again, too intelligent... e.g.: =1))
+        FormulaError nError = pArr->GetCodeError();
+        if ( nError == FormulaError::NONE )
+        {
+            //  update list of recent functions with all functions that
+            //  are not within parentheses
+
+            ScModule* pScMod = SC_MOD();
+            ScAppOptions aAppOpt = pScMod->GetAppOptions();
+            bool bOptChanged = false;
+
+            formula::FormulaToken** ppToken = pArr->GetArray();
+            sal_uInt16 nTokens = pArr->GetLen();
+            sal_uInt16 nLevel = 0;
+            for (sal_uInt16 nTP=0; nTP<nTokens; nTP++)
+            {
+                formula::FormulaToken* pTok = ppToken[nTP];
+                OpCode eOp = pTok->GetOpCode();
+                if ( eOp == ocOpen )
+                    ++nLevel;
+                else if ( eOp == ocClose && nLevel )
+                    --nLevel;
+                if ( nLevel == 0 && pTok->IsFunction() &&
+                        lcl_AddFunction( aAppOpt, sal::static_int_cast<sal_uInt16>( eOp ) ) )
+                    bOptChanged = true;
+            }
+
+            if ( bOptChanged )
+            {
+                pScMod->SetAppOptions(aAppOpt);
+            }
+        }
+
+        ScFormulaCell aCell(pDoc, aPos, std::move( pArr ), formula::FormulaGrammar::GRAM_DEFAULT, ScMatrixMode::NONE);
+
+        SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
+        for (const auto& rTab : rMark)
+        {
+            i = rTab;
+            aPos.SetTab( i );
+            const sal_uInt32 nIndex = pDoc->GetAttr(
+                        nCol, nRow, i, ATTR_VALUE_FORMAT )->GetValue();
+            const SvNumFormatType nType = pFormatter->GetType( nIndex);
+            if (nType == SvNumFormatType::TEXT ||
+                    ((rString[0] == '+' || rString[0] == '-') && nError != FormulaError::NONE && rString == aFormula))
+            {
+                if ( pData )
+                {
+                    // A clone of pData will be stored in the cell.
+                    rFunc.SetEditCell(aPos, *pData, true);
+                }
+                else
+                    rFunc.SetStringCell(aPos, aFormula, true);
+            }
+            else
+            {
+                ScFormulaCell* pCell = new ScFormulaCell( aCell, *pDoc, aPos );
+                if ( nError != FormulaError::NONE )
+                {
+                    pCell->GetCode()->DelRPN();
+                    pCell->SetErrCode( nError );
+                    if(pCell->GetCode()->IsHyperLink())
+                        pCell->GetCode()->SetHyperLink(false);
+                }
+                if (nType == SvNumFormatType::LOGICAL)
+                {
+                    // Reset to General so the actual format can be determined
+                    // after the cell has been interpreted. A sticky boolean
+                    // number format is highly likely unwanted... see tdf#75650.
+                    // General of same locale as current number format.
+                    const SvNumberformat* pEntry = pFormatter->GetEntry( nIndex);
+                    const LanguageType nLang = (pEntry ? pEntry->GetLanguage() : ScGlobal::eLnge);
+                    const sal_uInt32 nFormat = pFormatter->GetStandardFormat( SvNumFormatType::NUMBER, nLang);
+                    ScPatternAttr aPattern( pDoc->GetPool());
+                    aPattern.GetItemSet().Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nFormat));
+                    ScMarkData aMark(pDoc->MaxRow(), pDoc->MaxCol());
+                    aMark.SelectTable( i, true);
+                    aMark.SetMarkArea( ScRange( aPos));
+                    rFunc.ApplyAttributes( aMark, aPattern, false);
+                    bNumFmtChanged = true;
+                }
+                rFunc.SetFormulaCell(aPos, pCell, true);
+            }
+        }
+    }
+    else
+    {
+        for (const auto& rTab : rMark)
+        {
+            bool bNumFmtSet = false;
+            rFunc.SetNormalString( bNumFmtSet, ScAddress( nCol, nRow, rTab ), rString, false );
+            if (bNumFmtSet)
+            {
+                /* FIXME: if set on any sheet results in changed only on
+                 * sheet nTab for TestFormatArea() and DoAutoAttributes() */
+                bNumFmtChanged = true;
+            }
+        }
+    }
+
+    bool bAutoFormat = TestFormatArea(nCol, nRow, nTab, bNumFmtChanged);
+
+    if (bAutoFormat)
+        DoAutoAttributes(nCol, nRow, nTab, bNumFmtChanged);
+
+    pDocSh->UpdateOle(&GetViewData());
+
+    HelperNotifyChanges::NotifyIfChangesListeners(*pDocSh, rMark, nCol, nRow);
+
+    if ( bRecord )
+        rFunc.EndListAction();
+
+    aModificator.SetDocumentModified();
+    lcl_PostRepaintCondFormat( pDoc->GetCondFormat( nCol, nRow, nTab ), pDocSh );
+}
+
+// enter value in single cell (on nTab only)
+
+void ScViewFunc::EnterValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rValue )
+{
+    ScDocument* pDoc = GetViewData().GetDocument();
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+
+    if ( pDoc && pDocSh )
+    {
+        bool bUndo(pDoc->IsUndoEnabled());
+        ScDocShellModificator aModificator( *pDocSh );
+
+        ScEditableTester aTester( pDoc, nTab, nCol,nRow, nCol,nRow );
+        if (aTester.IsEditable())
+        {
+            ScAddress aPos( nCol, nRow, nTab );
+            ScCellValue aUndoCell;
+            if (bUndo)
+                aUndoCell.assign(*pDoc, aPos);
+
+            pDoc->SetValue( nCol, nRow, nTab, rValue );
+
+            // because of ChangeTrack after change in document
+            if (bUndo)
+            {
+                pDocSh->GetUndoManager()->AddUndoAction(
+                    std::make_unique<ScUndoEnterValue>(pDocSh, aPos, aUndoCell, rValue));
+            }
+
+            pDocSh->PostPaintCell( aPos );
+            pDocSh->UpdateOle(&GetViewData());
+            aModificator.SetDocumentModified();
+        }
+        else
+            ErrorMessage(aTester.GetMessageId());
+    }
+}
+
+void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab,
+                            const EditTextObject& rData, bool bTestSimple )
+{
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScMarkData& rMark = GetViewData().GetMarkData();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    bool bRecord = rDoc.IsUndoEnabled();
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    ScEditableTester aTester( &rDoc, nTab, nCol,nRow, nCol,nRow );
+    if (aTester.IsEditable())
+    {
+
+        //      test for attribute
+
+        bool bSimple = false;
+        bool bCommon = false;
+        std::unique_ptr<ScPatternAttr> pCellAttrs;
+        OUString aString;
+
+        const ScPatternAttr* pOldPattern = rDoc.GetPattern( nCol, nRow, nTab );
+        ScTabEditEngine aEngine( *pOldPattern, rDoc.GetEnginePool(), &rDoc );
+        aEngine.SetTextCurrentDefaults(rData);
+
+        if (bTestSimple)                    // test, if simple string without attribute
+        {
+            ScEditAttrTester aAttrTester( &aEngine );
+            bSimple = !aAttrTester.NeedsObject();
+            bCommon = aAttrTester.NeedsCellAttr();
+
+            // formulas have to be recognized even if they're formatted
+            // (but common attributes are still collected)
+
+            if ( !bSimple && aEngine.GetParagraphCount() == 1 )
+            {
+                OUString aParStr(aEngine.GetText( 0 ));
+                if ( aParStr[0] == '=' )
+                    bSimple = true;
+            }
+
+            if (bCommon)                // attribute for tab
+            {
+                pCellAttrs.reset(new ScPatternAttr( *pOldPattern ));
+                pCellAttrs->GetFromEditItemSet( &aAttrTester.GetAttribs() );
+                //! remove common attributes from EditEngine?
+            }
+        }
+
+        // #i97726# always get text for "repeat" of undo action
+        aString = ScEditUtil::GetSpaceDelimitedString(aEngine);
+
+        //      undo
+
+        std::unique_ptr<EditTextObject> pUndoData;
+        ScUndoEnterData::ValuesType aOldValues;
+
+        if (bRecord && !bSimple)
+        {
+            for (const auto& rTab : rMark)
+            {
+                ScUndoEnterData::Value aOldValue;
+                aOldValue.mnTab = rTab;
+                aOldValue.maCell.assign(rDoc, ScAddress(nCol, nRow, rTab));
+                aOldValues.push_back(aOldValue);
+            }
+
+            pUndoData = rData.Clone();
+        }
+
+        //      enter data
+
+        if (bCommon)
+            rDoc.ApplyPattern(nCol,nRow,nTab,*pCellAttrs);         //! undo
+
+        if (bSimple)
+        {
+            if (bCommon)
+                AdjustRowHeight(nRow,nRow);
+
+            EnterData(nCol,nRow,nTab,aString);
+        }
+        else
+        {
+            for (const auto& rTab : rMark)
+            {
+                ScAddress aPos(nCol, nRow, rTab);
+                rDoc.SetEditText(aPos, rData, rDoc.GetEditPool());
+            }
+
+            if ( bRecord )
+            {   //  because of ChangeTrack current first
+                pDocSh->GetUndoManager()->AddUndoAction(
+                    std::make_unique<ScUndoEnterData>(pDocSh, ScAddress(nCol,nRow,nTab), aOldValues, aString, std::move(pUndoData)));
+            }
+
+            HideAllCursors();
+
+            AdjustRowHeight(nRow,nRow);
+
+            for (const auto& rTab : rMark)
+                pDocSh->PostPaintCell( nCol, nRow, rTab );
+
+            ShowAllCursors();
+
+            pDocSh->UpdateOle(&GetViewData());
+
+            HelperNotifyChanges::NotifyIfChangesListeners(*pDocSh, rMark, nCol, nRow);
+
+            aModificator.SetDocumentModified();
+        }
+        lcl_PostRepaintCondFormat( rDoc.GetCondFormat( nCol, nRow, nTab ), pDocSh );
+    }
+    else
+    {
+        ErrorMessage(aTester.GetMessageId());
+        PaintArea( nCol, nRow, nCol, nRow );        // possibly the edit-engine is still painted there
+    }
+}
+
+void ScViewFunc::EnterDataAtCursor( const OUString& rString )
+{
+    SCCOL nPosX = GetViewData().GetCurX();
+    SCROW nPosY = GetViewData().GetCurY();
+    SCTAB nTab = GetViewData().GetTabNo();
+
+    EnterData( nPosX, nPosY, nTab, rString );
+}
+
+void ScViewFunc::EnterMatrix( const OUString& rString, ::formula::FormulaGrammar::Grammar eGram )
+{
+    ScViewData& rData = GetViewData();
+    const SCCOL nCol = rData.GetCurX();
+    const SCROW nRow = rData.GetCurY();
+    const ScMarkData& rMark = rData.GetMarkData();
+    if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
+    {
+        //  nothing marked -> temporarily calculate block
+        //  with size of result formula to get the size
+
+        ScDocument* pDoc = rData.GetDocument();
+        SCTAB nTab = rData.GetTabNo();
+        ScFormulaCell aFormCell( pDoc, ScAddress(nCol,nRow,nTab), rString, eGram, ScMatrixMode::Formula );
+
+        SCSIZE nSizeX;
+        SCSIZE nSizeY;
+        aFormCell.GetResultDimensions( nSizeX, nSizeY );
+        if ( nSizeX != 0 && nSizeY != 0 &&
+             nCol+nSizeX-1 <= sal::static_int_cast<SCSIZE>(pDoc->MaxCol()) &&
+             nRow+nSizeY-1 <= sal::static_int_cast<SCSIZE>(pDoc->MaxRow()) )
+        {
+            ScRange aResult( nCol, nRow, nTab,
+                             sal::static_int_cast<SCCOL>(nCol+nSizeX-1),
+                             sal::static_int_cast<SCROW>(nRow+nSizeY-1), nTab );
+            MarkRange( aResult, false );
+        }
+    }
+
+    ScRange aRange;
+    if (rData.GetSimpleArea(aRange) == SC_MARK_SIMPLE)
+    {
+        ScDocShell* pDocSh = rData.GetDocShell();
+        bool bSuccess = pDocSh->GetDocFunc().EnterMatrix(
+            aRange, &rMark, nullptr, rString, false, false, EMPTY_OUSTRING, eGram );
+        if (bSuccess)
+            pDocSh->UpdateOle(&GetViewData());
+        else
+            PaintArea(nCol, nRow, nCol, nRow);        // possibly the edit-engine is still painted there
+    }
+    else
+        ErrorMessage(STR_NOMULTISELECT);
+}
+
+SvtScriptType ScViewFunc::GetSelectionScriptType()
+{
+    SvtScriptType nScript = SvtScriptType::NONE;
+
+    ScDocument* pDoc = GetViewData().GetDocument();
+    const ScMarkData& rMark = GetViewData().GetMarkData();
+    if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )
+    {
+        // no selection -> cursor
+
+        nScript = pDoc->GetScriptType( GetViewData().GetCurX(),
+                            GetViewData().GetCurY(), GetViewData().GetTabNo());
+    }
+    else
+    {
+        ScRangeList aRanges;
+        rMark.FillRangeListWithMarks( &aRanges, false );
+        nScript = pDoc->GetRangeScriptType(aRanges);
+    }
+
+    if (nScript == SvtScriptType::NONE)
+        nScript = ScGlobal::GetDefaultScriptType();
+
+    return nScript;
+}
+
+const ScPatternAttr* ScViewFunc::GetSelectionPattern()
+{
+    // Don't use UnmarkFiltered in slot state functions, for performance reasons.
+    // The displayed state is always that of the whole selection including filtered rows.
+
+    const ScMarkData& rMark = GetViewData().GetMarkData();
+    ScDocument* pDoc = GetViewData().GetDocument();
+    if ( rMark.IsMarked() || rMark.IsMultiMarked() )
+    {
+        //  MarkToMulti is no longer necessary for pDoc->GetSelectionPattern
+        const ScPatternAttr* pAttr = pDoc->GetSelectionPattern( rMark );
+        return pAttr;
+    }
+    else
+    {
+        SCCOL  nCol = GetViewData().GetCurX();
+        SCROW  nRow = GetViewData().GetCurY();
+        SCTAB  nTab = GetViewData().GetTabNo();
+
+        ScMarkData aTempMark( rMark );      // copy sheet selection
+        aTempMark.SetMarkArea( ScRange( nCol, nRow, nTab ) );
+        const ScPatternAttr* pAttr = pDoc->GetSelectionPattern( aTempMark );
+        return pAttr;
+    }
+}
+
+void ScViewFunc::GetSelectionFrame(
+    std::shared_ptr<SvxBoxItem>& rLineOuter,
+    std::shared_ptr<SvxBoxInfoItem>& rLineInner )
+{
+    ScDocument* pDoc = GetViewData().GetDocument();
+    const ScMarkData& rMark = GetViewData().GetMarkData();
+
+    if ( rMark.IsMarked() || rMark.IsMultiMarked() )
+    {
+        pDoc->GetSelectionFrame( rMark, *rLineOuter, *rLineInner );
+    }
+    else
+    {
+        const ScPatternAttr* pAttrs =
+                    pDoc->GetPattern( GetViewData().GetCurX(),
+                                      GetViewData().GetCurY(),
+                                      GetViewData().GetTabNo() );
+
+        rLineOuter.reset(pAttrs->GetItem(ATTR_BORDER).Clone());
+        rLineInner.reset(pAttrs->GetItem(ATTR_BORDER_INNER).Clone());
+
+        rLineInner->SetTable(false);
+        rLineInner->SetDist(true);
+        rLineInner->SetMinDist(false);
+    }
+}
+
+//  apply attribute - undo OK
+//
+//  complete set ( ATTR_STARTINDEX, ATTR_ENDINDEX )
+
+void ScViewFunc::ApplyAttributes( const SfxItemSet* pDialogSet,
+                                  const SfxItemSet* pOldSet,
+                                  bool bAdjustBlockHeight)
+{
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    ScPatternAttr aOldAttrs( std::make_unique<SfxItemSet>(*pOldSet) );
+    ScPatternAttr aNewAttrs( std::make_unique<SfxItemSet>(*pDialogSet) );
+    aNewAttrs.DeleteUnchanged( &aOldAttrs );
+
+    if ( pDialogSet->GetItemState( ATTR_VALUE_FORMAT ) == SfxItemState::SET )
+    {   // don't reset to default SYSTEM GENERAL if not intended
+        sal_uInt32 nOldFormat =
+            pOldSet->Get( ATTR_VALUE_FORMAT ).GetValue();
+        sal_uInt32 nNewFormat =
+            pDialogSet->Get( ATTR_VALUE_FORMAT ).GetValue();
+        if ( nNewFormat != nOldFormat )
+        {
+            SvNumberFormatter* pFormatter =
+                GetViewData().GetDocument()->GetFormatTable();
+            const SvNumberformat* pOldEntry = pFormatter->GetEntry( nOldFormat );
+            LanguageType eOldLang =
+                pOldEntry ? pOldEntry->GetLanguage() : LANGUAGE_DONTKNOW;
+            const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewFormat );
+            LanguageType eNewLang =
+                pNewEntry ? pNewEntry->GetLanguage() : LANGUAGE_DONTKNOW;
+            if ( eNewLang != eOldLang )
+            {
+                aNewAttrs.GetItemSet().Put(
+                    SvxLanguageItem( eNewLang, ATTR_LANGUAGE_FORMAT ) );
+
+                //  only the language has changed -> do not touch numberformat-attribute
+                sal_uInt32 nNewMod = nNewFormat % SV_COUNTRY_LANGUAGE_OFFSET;
+                if ( nNewMod == ( nOldFormat % SV_COUNTRY_LANGUAGE_OFFSET ) &&
+                     nNewMod <= SV_MAX_COUNT_STANDARD_FORMATS )
+                    aNewAttrs.GetItemSet().ClearItem( ATTR_VALUE_FORMAT );
+            }
+        }
+    }
+
+    if (pDialogSet->HasItem(ATTR_FONT_LANGUAGE))
+        // font language has changed.  Redo the online spelling.
+        ResetAutoSpell();
+
+    const SvxBoxItem&     rOldOuter = pOldSet->Get(ATTR_BORDER);
+    const SvxBoxItem&     rNewOuter = pDialogSet->Get(ATTR_BORDER);
+    const SvxBoxInfoItem& rOldInner = pOldSet->Get(ATTR_BORDER_INNER);
+    const SvxBoxInfoItem& rNewInner = pDialogSet->Get(ATTR_BORDER_INNER);
+    SfxItemSet&           rNewSet   = aNewAttrs.GetItemSet();
+    SfxItemPool*          pNewPool  = rNewSet.GetPool();
+
+    pNewPool->Put(rNewOuter);        // don't delete yet
+    pNewPool->Put(rNewInner);
+    rNewSet.ClearItem( ATTR_BORDER );
+    rNewSet.ClearItem( ATTR_BORDER_INNER );
+
+    /*
+     * establish whether border attribute is to be set:
+     * 1. new != old
+     * 2. is one of the borders not-DontCare (since 238.f: IsxxValid())
+     *
+     */
+
+    bool bFrame =    (pDialogSet->GetItemState( ATTR_BORDER ) != SfxItemState::DEFAULT)
+                  || (pDialogSet->GetItemState( ATTR_BORDER_INNER ) != SfxItemState::DEFAULT);
+
+    if (&rNewOuter == &rOldOuter && &rNewInner == &rOldInner)
+        bFrame = false;
+
+    //  this should be intercepted by the pool: ?!??!??
+
+    if (bFrame && rNewOuter == rOldOuter && rNewInner == rOldInner)
+        bFrame = false;
+
+    bFrame =   bFrame
+            && (   rNewInner.IsValid(SvxBoxInfoItemValidFlags::LEFT)
+                || rNewInner.IsValid(SvxBoxInfoItemValidFlags::RIGHT)
+                || rNewInner.IsValid(SvxBoxInfoItemValidFlags::TOP)
+                || rNewInner.IsValid(SvxBoxInfoItemValidFlags::BOTTOM)
+                || rNewInner.IsValid(SvxBoxInfoItemValidFlags::HORI)
+                || rNewInner.IsValid(SvxBoxInfoItemValidFlags::VERT) );
+
+    if (!bFrame)
+        ApplySelectionPattern( aNewAttrs );            // standard only
+    else
+    {
+        // if new items are default-items, overwrite the old items:
+
+        bool bDefNewOuter = IsStaticDefaultItem(&rNewOuter);
+        bool bDefNewInner = IsStaticDefaultItem(&rNewInner);
+
+        ApplyPatternLines( aNewAttrs,
+                           bDefNewOuter ? rOldOuter : rNewOuter,
+                           bDefNewInner ? &rOldInner : &rNewInner );
+    }
+
+    pNewPool->Remove(rNewOuter);         // release
+    pNewPool->Remove(rNewInner);
+
+    //  adjust height only if needed
+    if (bAdjustBlockHeight)
+        AdjustBlockHeight();
+
+    // CellContentChanged is called in ApplySelectionPattern / ApplyPatternLines
+}
+
+void ScViewFunc::ApplyAttr( const SfxPoolItem& rAttrItem, bool bAdjustBlockHeight )
+{
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    ScPatternAttr aNewAttrs( std::make_unique<SfxItemSet>( *GetViewData().GetDocument()->GetPool(),
+                                            svl::Items<ATTR_PATTERN_START, ATTR_PATTERN_END>{} ) );
+
+    aNewAttrs.GetItemSet().Put( rAttrItem );
+    //  if justify is set (with Buttons), always indentation 0
+    if ( rAttrItem.Which() == ATTR_HOR_JUSTIFY )
+        aNewAttrs.GetItemSet().Put( ScIndentItem( 0 ) );
+    ApplySelectionPattern( aNewAttrs );
+
+    // Prevent useless compute
+    if (bAdjustBlockHeight)
+        AdjustBlockHeight();
+
+    // CellContentChanged is called in ApplySelectionPattern
+}
+
+//  patterns and borders
+
+void ScViewFunc::ApplyPatternLines( const ScPatternAttr& rAttr, const SvxBoxItem& rNewOuter,
+                                    const SvxBoxInfoItem* pNewInner )
+{
+    ScDocument* pDoc = GetViewData().GetDocument();
+    ScMarkData aFuncMark( GetViewData().GetMarkData() );       // local copy for UnmarkFiltered
+    ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
+    bool bRecord = true;
+    if (!pDoc->IsUndoEnabled())
+        bRecord = false;
+
+    bool bRemoveAdjCellBorder = rNewOuter.IsRemoveAdjacentCellBorder();
+    ScRange aMarkRange, aMarkRangeWithEnvelope;
+    aFuncMark.MarkToSimple();
+    bool bMulti = aFuncMark.IsMultiMarked();
+    if (bMulti)
+        aFuncMark.GetMultiMarkArea( aMarkRange );
+    else if (aFuncMark.IsMarked())
+        aFuncMark.GetMarkArea( aMarkRange );
+    else
+    {
+        aMarkRange = ScRange( GetViewData().GetCurX(),
+                            GetViewData().GetCurY(), GetViewData().GetTabNo() );
+        DoneBlockMode();
+        InitOwnBlockMode();
+        aFuncMark.SetMarkArea(aMarkRange);
+        MarkDataChanged();
+    }
+    if( bRemoveAdjCellBorder )
+        aFuncMark.GetSelectionCover( aMarkRangeWithEnvelope );
+    else
+        aMarkRangeWithEnvelope = aMarkRange;
+
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    if (bRecord)
+    {
+        ScDocumentUniquePtr pUndoDoc(new ScDocument( SCDOCMODE_UNDO ));
+        SCTAB nStartTab = aMarkRange.aStart.Tab();
+        SCTAB nTabCount = pDoc->GetTableCount();
+        bool bCopyOnlyMarked = false;
+        if( !bRemoveAdjCellBorder )
+            bCopyOnlyMarked = bMulti;
+        pUndoDoc->InitUndo( pDoc, nStartTab, nStartTab );
+        for (const auto& rTab : aFuncMark)
+            if (rTab != nStartTab)
+                pUndoDoc->AddUndoTab( rTab, rTab );
+
+        ScRange aCopyRange = aMarkRangeWithEnvelope;
+        aCopyRange.aStart.SetTab(0);
+        aCopyRange.aEnd.SetTab(nTabCount-1);
+        pDoc->CopyToDocument( aCopyRange, InsertDeleteFlags::ATTRIB, bCopyOnlyMarked, *pUndoDoc, &aFuncMark );
+
+        pDocSh->GetUndoManager()->AddUndoAction(
+            std::make_unique<ScUndoSelectionAttr>(
+                pDocSh, aFuncMark,
+                aMarkRange.aStart.Col(), aMarkRange.aStart.Row(), aMarkRange.aStart.Tab(),
+                aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(), aMarkRange.aEnd.Tab(),
+                std::move(pUndoDoc), bCopyOnlyMarked, &rAttr, &rNewOuter, pNewInner, &aMarkRangeWithEnvelope ) );
+    }
+
+    sal_uInt16 nExt = SC_PF_TESTMERGE;
+    pDocSh->UpdatePaintExt( nExt, aMarkRangeWithEnvelope ); // content before the change
+
+    pDoc->ApplySelectionFrame(aFuncMark, rNewOuter, pNewInner);
+
+    pDocSh->UpdatePaintExt( nExt, aMarkRangeWithEnvelope ); // content after the change
+
+    aFuncMark.MarkToMulti();
+    pDoc->ApplySelectionPattern( rAttr, aFuncMark );
+
+    pDocSh->PostPaint( aMarkRange, PaintPartFlags::Grid, nExt );
+    pDocSh->UpdateOle(&GetViewData());
+    aModificator.SetDocumentModified();
+    CellContentChanged();
+
+    StartFormatArea();
+}
+
+//  pattern only
+
+void ScViewFunc::ApplySelectionPattern( const ScPatternAttr& rAttr, bool bCursorOnly )
+{
+    ScViewData& rViewData   = GetViewData();
+    ScDocShell* pDocSh      = rViewData.GetDocShell();
+    ScDocument& rDoc        = pDocSh->GetDocument();
+    ScMarkData aFuncMark( rViewData.GetMarkData() );       // local copy for UnmarkFiltered
+    ScViewUtil::UnmarkFiltered( aFuncMark, &rDoc );
+
+    bool bRecord = true;
+    if (!rDoc.IsUndoEnabled())
+        bRecord = false;
+
+    //  State from old ItemSet doesn't matter for paint flags, as any change will be
+    //  from SfxItemState::SET in the new ItemSet (default is ignored in ApplyPattern).
+    //  New alignment is checked (check in PostPaint isn't enough) in case a right
+    //  alignment is changed to left.
+    const SfxItemSet& rNewSet = rAttr.GetItemSet();
+    bool bSetLines = rNewSet.GetItemState( ATTR_BORDER ) == SfxItemState::SET ||
+                     rNewSet.GetItemState( ATTR_SHADOW ) == SfxItemState::SET;
+    bool bSetAlign = rNewSet.GetItemState( ATTR_HOR_JUSTIFY ) == SfxItemState::SET;
+
+    sal_uInt16 nExtFlags = 0;
+    if ( bSetLines )
+        nExtFlags |= SC_PF_LINES;
+    if ( bSetAlign )
+        nExtFlags |= SC_PF_WHOLEROWS;
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    bool bMulti = aFuncMark.IsMultiMarked();
+    aFuncMark.MarkToMulti();
+    bool bOnlyTab = (!aFuncMark.IsMultiMarked() && !bCursorOnly && aFuncMark.GetSelectCount() > 1);
+    if (bOnlyTab)
+    {
+        SCCOL nCol = rViewData.GetCurX();
+        SCROW nRow = rViewData.GetCurY();
+        SCTAB nTab = rViewData.GetTabNo();
+        aFuncMark.SetMarkArea(ScRange(nCol,nRow,nTab));
+        aFuncMark.MarkToMulti();
+    }
+
+    ScRangeList aChangeRanges;
+
+    if (aFuncMark.IsMultiMarked() && !bCursorOnly)
+    {
+        ScRange aMarkRange;
+        aFuncMark.GetMultiMarkArea( aMarkRange );
+        SCTAB nTabCount = rDoc.GetTableCount();
+        for (const auto& rTab : aFuncMark)
+        {
+            ScRange aChangeRange( aMarkRange );
+            aChangeRange.aStart.SetTab( rTab );
+            aChangeRange.aEnd.SetTab( rTab );
+            aChangeRanges.push_back( aChangeRange );
+        }
+
+        SCCOL nStartCol = aMarkRange.aStart.Col();
+        SCROW nStartRow = aMarkRange.aStart.Row();
+        SCTAB nStartTab = aMarkRange.aStart.Tab();
+        SCCOL nEndCol = aMarkRange.aEnd.Col();
+        SCROW nEndRow = aMarkRange.aEnd.Row();
+        SCTAB nEndTab = aMarkRange.aEnd.Tab();
+
+        ScUndoSelectionAttr* pUndoAttr = nullptr;
+        ScEditDataArray* pEditDataArray = nullptr;
+        if (bRecord)
+        {
+            ScRange aCopyRange = aMarkRange;
+            aCopyRange.aStart.SetTab(0);
+            aCopyRange.aEnd.SetTab(nTabCount-1);
+
+            ScDocumentUniquePtr pUndoDoc(new ScDocument( SCDOCMODE_UNDO ));
+            pUndoDoc->InitUndo( &rDoc, nStartTab, nStartTab );
+            for (const auto& rTab : aFuncMark)
+                if (rTab != nStartTab)
+                    pUndoDoc->AddUndoTab( rTab, rTab );
+            rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::ATTRIB, bMulti, *pUndoDoc, &aFuncMark );
+
+            aFuncMark.MarkToMulti();
+
+            pUndoAttr = new ScUndoSelectionAttr(
+                pDocSh, aFuncMark, nStartCol, nStartRow, nStartTab,
+                nEndCol, nEndRow, nEndTab, std::move(pUndoDoc), bMulti, &rAttr );
+            pDocSh->GetUndoManager()->AddUndoAction(std::unique_ptr<ScUndoSelectionAttr>(pUndoAttr));
+            pEditDataArray = pUndoAttr->GetDataArray();
+        }
+
+        rDoc.ApplySelectionPattern( rAttr, aFuncMark, pEditDataArray );
+
+        pDocSh->PostPaint( nStartCol, nStartRow, nStartTab,
+                           nEndCol,   nEndRow,   nEndTab,
+                           PaintPartFlags::Grid, nExtFlags | SC_PF_TESTMERGE );
+        pDocSh->UpdateOle(&GetViewData());
+        aModificator.SetDocumentModified();
+        CellContentChanged();
+    }
+    else                            // single cell - simpler undo
+    {
+        SCCOL nCol = rViewData.GetCurX();
+        SCROW nRow = rViewData.GetCurY();
+        SCTAB nTab = rViewData.GetTabNo();
+
+        std::unique_ptr<EditTextObject> pOldEditData;
+        std::unique_ptr<EditTextObject> pNewEditData;
+        ScAddress aPos(nCol, nRow, nTab);
+        ScRefCellValue aCell(rDoc, aPos);
+        if (aCell.meType == CELLTYPE_EDIT)
+        {
+            const EditTextObject* pEditObj = aCell.mpEditText;
+            pOldEditData = pEditObj->Clone();
+            rDoc.RemoveEditTextCharAttribs(aPos, rAttr);
+            pEditObj = rDoc.GetEditText(aPos);
+            pNewEditData = pEditObj->Clone();
+        }
+
+        aChangeRanges.push_back(aPos);
+        std::unique_ptr<ScPatternAttr> pOldPat(new ScPatternAttr(*rDoc.GetPattern( nCol, nRow, nTab )));
+
+        rDoc.ApplyPattern( nCol, nRow, nTab, rAttr );
+
+        const ScPatternAttr* pNewPat = rDoc.GetPattern( nCol, nRow, nTab );
+
+        if (bRecord)
+        {
+            std::unique_ptr<ScUndoCursorAttr> pUndo(new ScUndoCursorAttr(
+                pDocSh, nCol, nRow, nTab, pOldPat.get(), pNewPat, &rAttr ));
+            pUndo->SetEditData(std::move(pOldEditData), std::move(pNewEditData));
+            pDocSh->GetUndoManager()->AddUndoAction(std::move(pUndo));
+        }
+        pOldPat.reset();     // is copied in undo (Pool)
+
+        pDocSh->PostPaint( nCol,nRow,nTab, nCol,nRow,nTab, PaintPartFlags::Grid, nExtFlags | SC_PF_TESTMERGE );
+        pDocSh->UpdateOle(&GetViewData());
+        aModificator.SetDocumentModified();
+        CellContentChanged();
+    }
+
+    ScModelObj* pModelObj = HelperNotifyChanges::getMustPropagateChangesModel(*pDocSh);
+    if (pModelObj)
+    {
+        css::uno::Sequence< css::beans::PropertyValue > aProperties;
+        sal_Int32 nCount = 0;
+        const SfxItemPropertyMap& rMap = ScCellObj::GetCellPropertyMap();
+        PropertyEntryVector_t aPropVector = rMap.getPropertyEntries();
+        for ( sal_uInt16 nWhich = ATTR_PATTERN_START; nWhich <= ATTR_PATTERN_END; ++nWhich )
+        {
+            const SfxPoolItem* pItem = nullptr;
+            if ( rNewSet.GetItemState( nWhich, true, &pItem ) == SfxItemState::SET && pItem )
+            {
+                for ( const auto& rProp : aPropVector)
+                {
+                    if ( rProp.nWID == nWhich )
+                    {
+                        css::uno::Any aVal;
+                        pItem->QueryValue( aVal, rProp.nMemberId );
+                        aProperties.realloc( nCount + 1 );
+                        aProperties[ nCount ].Name = rProp.sName;
+                        aProperties[ nCount ].Value = aVal;
+                        ++nCount;
+                    }
+                }
+            }
+        }
+        HelperNotifyChanges::Notify(*pModelObj, aChangeRanges, "attribute", aProperties);
+    }
+
+    StartFormatArea();
+}
+
+void ScViewFunc::ApplyUserItemSet( const SfxItemSet& rItemSet )
+{
+    //  ItemSet from UI, may have different pool
+
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    ScPatternAttr aNewAttrs( GetViewData().GetDocument()->GetPool() );
+    SfxItemSet& rNewSet = aNewAttrs.GetItemSet();
+    rNewSet.Put( rItemSet, false );
+    ApplySelectionPattern( aNewAttrs );
+
+    AdjustBlockHeight();
+}
+
+const SfxStyleSheet* ScViewFunc::GetStyleSheetFromMarked()
+{
+    // Don't use UnmarkFiltered in slot state functions, for performance reasons.
+    // The displayed state is always that of the whole selection including filtered rows.
+
+    const ScStyleSheet* pSheet      = nullptr;
+    ScViewData&         rViewData   = GetViewData();
+    ScDocument*         pDoc        = rViewData.GetDocument();
+    ScMarkData&         rMark       = rViewData.GetMarkData();
+
+    if ( rMark.IsMarked() || rMark.IsMultiMarked() )
+        pSheet = pDoc->GetSelectionStyle( rMark );                  // MarkToMulti isn't necessary
+    else
+        pSheet = pDoc->GetStyle( rViewData.GetCurX(),
+                                 rViewData.GetCurY(),
+                                 rViewData.GetTabNo() );
+
+    return pSheet;
+}
+
+void ScViewFunc::SetStyleSheetToMarked( const SfxStyleSheet* pStyleSheet )
+{
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    if ( !pStyleSheet) return;
+
+    ScViewData& rViewData   = GetViewData();
+    ScDocShell* pDocSh      = rViewData.GetDocShell();
+    ScDocument& rDoc        = pDocSh->GetDocument();
+    ScMarkData aFuncMark( rViewData.GetMarkData() );       // local copy for UnmarkFiltered
+    ScViewUtil::UnmarkFiltered( aFuncMark, &rDoc );
+    SCTAB nTabCount     = rDoc.GetTableCount();
+    bool bRecord = true;
+    if (!rDoc.IsUndoEnabled())
+        bRecord = false;
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    if ( aFuncMark.IsMarked() || aFuncMark.IsMultiMarked() )
+    {
+        ScRange aMarkRange;
+        aFuncMark.MarkToMulti();
+        aFuncMark.GetMultiMarkArea( aMarkRange );
+
+        if ( bRecord )
+        {
+            SCTAB nTab = rViewData.GetTabNo();
+            ScDocumentUniquePtr pUndoDoc(new ScDocument( SCDOCMODE_UNDO ));
+            pUndoDoc->InitUndo( &rDoc, nTab, nTab );
+            for (const auto& rTab : aFuncMark)
+                if (rTab != nTab)
+                    pUndoDoc->AddUndoTab( rTab, rTab );
+
+            ScRange aCopyRange = aMarkRange;
+            aCopyRange.aStart.SetTab(0);
+            aCopyRange.aEnd.SetTab(nTabCount-1);
+            rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::ATTRIB, true, *pUndoDoc, &aFuncMark );
+            aFuncMark.MarkToMulti();
+
+            OUString aName = pStyleSheet->GetName();
+            pDocSh->GetUndoManager()->AddUndoAction(
+                std::make_unique<ScUndoSelectionStyle>( pDocSh, aFuncMark, aMarkRange, aName, std::move(pUndoDoc) ) );
+        }
+
+        rDoc.ApplySelectionStyle( static_cast<const ScStyleSheet&>(*pStyleSheet), aFuncMark );
+
+        if (!AdjustBlockHeight())
+            rViewData.GetDocShell()->PostPaint( aMarkRange, PaintPartFlags::Grid );
+
+        aFuncMark.MarkToSimple();
+    }
+    else
+    {
+        SCCOL nCol = rViewData.GetCurX();
+        SCROW nRow = rViewData.GetCurY();
+        SCTAB nTab = rViewData.GetTabNo();
+
+        if ( bRecord )
+        {
+            ScDocumentUniquePtr pUndoDoc(new ScDocument( SCDOCMODE_UNDO ));
+            pUndoDoc->InitUndo( &rDoc, nTab, nTab );
+            for (const auto& rTab : aFuncMark)
+                if (rTab != nTab)
+                    pUndoDoc->AddUndoTab( rTab, rTab );
+
+            ScRange aCopyRange( nCol, nRow, 0, nCol, nRow, nTabCount-1 );
+            rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::ATTRIB, false, *pUndoDoc );
+
+            ScRange aMarkRange ( nCol, nRow, nTab );
+            ScMarkData aUndoMark = aFuncMark;
+            aUndoMark.SetMultiMarkArea( aMarkRange );
+
+            OUString aName = pStyleSheet->GetName();
+            pDocSh->GetUndoManager()->AddUndoAction(
+                std::make_unique<ScUndoSelectionStyle>( pDocSh, aUndoMark, aMarkRange, aName, std::move(pUndoDoc) ) );
+        }
+
+        for (const auto& rTab : aFuncMark)
+            rDoc.ApplyStyle( nCol, nRow, rTab, static_cast<const ScStyleSheet&>(*pStyleSheet) );
+
+        if (!AdjustBlockHeight())
+            rViewData.GetDocShell()->PostPaintCell( nCol, nRow, nTab );
+
+    }
+
+    aModificator.SetDocumentModified();
+
+    StartFormatArea();
+}
+
+void ScViewFunc::RemoveStyleSheetInUse( const SfxStyleSheetBase* pStyleSheet )
+{
+    if ( !pStyleSheet) return;
+
+    ScViewData& rViewData   = GetViewData();
+    ScDocument* pDoc        = rViewData.GetDocument();
+    ScDocShell* pDocSh      = rViewData.GetDocShell();
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    ScopedVclPtrInstance< VirtualDevice > pVirtDev;
+    pVirtDev->SetMapMode(MapMode(MapUnit::MapPixel));
+    pDoc->StyleSheetChanged( pStyleSheet, true, pVirtDev,
+                                rViewData.GetPPTX(),
+                                rViewData.GetPPTY(),
+                                rViewData.GetZoomX(),
+                                rViewData.GetZoomY() );
+
+    pDocSh->PostPaint( 0,0,0, pDoc->MaxCol(), pDoc->MaxRow(), MAXTAB, PaintPartFlags::Grid|PaintPartFlags::Left );
+    aModificator.SetDocumentModified();
+
+    ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
+    if (pHdl)
+        pHdl->ForgetLastPattern();
+}
+
+void ScViewFunc::UpdateStyleSheetInUse( const SfxStyleSheetBase* pStyleSheet )
+{
+    if ( !pStyleSheet) return;
+
+    ScViewData& rViewData   = GetViewData();
+    ScDocument* pDoc        = rViewData.GetDocument();
+    ScDocShell* pDocSh      = rViewData.GetDocShell();
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    ScopedVclPtrInstance< VirtualDevice > pVirtDev;
+    pVirtDev->SetMapMode(MapMode(MapUnit::MapPixel));
+    pDoc->StyleSheetChanged( pStyleSheet, false, pVirtDev,
+                                rViewData.GetPPTX(),
+                                rViewData.GetPPTY(),
+                                rViewData.GetZoomX(),
+                                rViewData.GetZoomY() );
+
+    pDocSh->PostPaint( 0,0,0, pDoc->MaxCol(), pDoc->MaxRow(), MAXTAB, PaintPartFlags::Grid|PaintPartFlags::Left );
+    aModificator.SetDocumentModified();
+
+    ScInputHandler* pHdl = SC_MOD()->GetInputHdl();
+    if (pHdl)
+        pHdl->ForgetLastPattern();
+}
+
+
+void ScViewFunc::OnLOKInsertDeleteColumn(SCCOL nStartCol, long nOffset)
+{
+    if (!comphelper::LibreOfficeKit::isActive() || nOffset == 0)
+        return;
+
+    SCTAB nCurrentTabIndex = GetViewData().GetTabNo();
+    SfxViewShell* pViewShell = SfxViewShell::GetFirst();
+    while (pViewShell)
+    {
+        ScTabViewShell* pTabViewShell = dynamic_cast<ScTabViewShell*>(pViewShell);
+        if (pTabViewShell)
+        {
+            pTabViewShell->GetViewData().GetLOKWidthHelper(nCurrentTabIndex)->invalidateByIndex(nStartCol);
+
+            // if we remove a column the cursor position  and the current selection
+            // in other views could need to be moved on the left by one column.
+            if (pTabViewShell != this)
+            {
+                if (pTabViewShell->getPart() == nCurrentTabIndex)
+                {
+                    SCCOL nX = pTabViewShell->GetViewData().GetCurX();
+                    if (nX > nStartCol || (nX == nStartCol && nOffset > 0))
+                    {
+                        ScInputHandler* pInputHdl = pTabViewShell->GetInputHandler();
+                        SCROW nY = pTabViewShell->GetViewData().GetCurY();
+                        pTabViewShell->SetCursor(nX + nOffset, nY);
+                        if (pInputHdl && pInputHdl->IsInputMode())
+                        {
+                            pInputHdl->SetModified();
+                        }
+                    }
+
+                    ScMarkData aMultiMark( pTabViewShell->GetViewData().GetMarkData() );
+                    aMultiMark.SetMarking( false );
+                    aMultiMark.MarkToMulti();
+                    if (aMultiMark.IsMultiMarked())
+                    {
+                        aMultiMark.ShiftCols(pTabViewShell->GetViewData().GetDocument(), nStartCol, nOffset);
+                        pTabViewShell->SetMarkData(aMultiMark);
+                    }
+                }
+                else
+                {
+                    SCROW nX = pTabViewShell->GetViewData().GetCurXForTab(nCurrentTabIndex);
+                    if (nX > nStartCol || (nX == nStartCol && nOffset > 0))
+                    {
+                        pTabViewShell->GetViewData().SetCurXForTab(nX + nOffset, nCurrentTabIndex);
+                    }
+                }
+            }
+        }
+        pViewShell = SfxViewShell::GetNext(*pViewShell);
+    }
+}
+
+void ScViewFunc::OnLOKInsertDeleteRow(SCROW nStartRow, long nOffset)
+{
+    if (!comphelper::LibreOfficeKit::isActive() || nOffset == 0)
+        return;
+
+    SCTAB nCurrentTabIndex = GetViewData().GetTabNo();
+    SfxViewShell* pViewShell = SfxViewShell::GetFirst();
+    while (pViewShell)
+    {
+        ScTabViewShell* pTabViewShell = dynamic_cast<ScTabViewShell*>(pViewShell);
+        if (pTabViewShell)
+        {
+            pTabViewShell->GetViewData().GetLOKHeightHelper(nCurrentTabIndex)->invalidateByIndex(nStartRow);
+
+            // if we remove a row the cursor position and the current selection
+            // in other views could need to be moved up by one row.
+            if (pTabViewShell != this)
+            {
+                if (pTabViewShell->getPart() == nCurrentTabIndex)
+                {
+                    SCROW nY = pTabViewShell->GetViewData().GetCurY();
+                    if (nY > nStartRow || (nY == nStartRow && nOffset > 0))
+                    {
+                        ScInputHandler* pInputHdl = pTabViewShell->GetInputHandler();
+                        SCCOL nX = pTabViewShell->GetViewData().GetCurX();
+                        pTabViewShell->SetCursor(nX, nY + nOffset);
+                        if (pInputHdl && pInputHdl->IsInputMode())
+                        {
+                            pInputHdl->SetModified();
+                        }
+                    }
+
+                    ScMarkData aMultiMark( pTabViewShell->GetViewData().GetMarkData() );
+                    aMultiMark.SetMarking( false );
+                    aMultiMark.MarkToMulti();
+                    if (aMultiMark.IsMultiMarked())
+                    {
+                        aMultiMark.ShiftRows(pTabViewShell->GetViewData().GetDocument(), nStartRow, nOffset);
+                        pTabViewShell->SetMarkData(aMultiMark);
+                    }
+                }
+                else
+                {
+                    SCROW nY = pTabViewShell->GetViewData().GetCurYForTab(nCurrentTabIndex);
+                    if (nY > nStartRow || (nY == nStartRow && nOffset > 0))
+                    {
+                        pTabViewShell->GetViewData().SetCurYForTab(nY + nOffset, nCurrentTabIndex);
+                    }
+                }
+            }
+        }
+        pViewShell = SfxViewShell::GetNext(*pViewShell);
+    }
+}
+
+void ScViewFunc::OnLOKSetWidthOrHeight(SCCOLROW nStart, bool bWidth)
+{
+    if (!comphelper::LibreOfficeKit::isActive())
+        return;
+
+    SCTAB nCurTab = GetViewData().GetTabNo();
+    SfxViewShell* pViewShell = SfxViewShell::GetFirst();
+    while (pViewShell)
+    {
+        ScTabViewShell* pTabViewShell = dynamic_cast<ScTabViewShell*>(pViewShell);
+        if (pTabViewShell)
+        {
+            if (bWidth)
+                pTabViewShell->GetViewData().GetLOKWidthHelper(nCurTab)->invalidateByIndex(nStart);
+            else
+                pTabViewShell->GetViewData().GetLOKHeightHelper(nCurTab)->invalidateByIndex(nStart);
+        }
+        pViewShell = SfxViewShell::GetNext(*pViewShell);
+    }
+}
+
+//  insert cells - undo OK
+
+bool ScViewFunc::InsertCells( InsCellCmd eCmd, bool bRecord, bool bPartOfPaste )
+{
+    ScRange aRange;
+    if (GetViewData().GetSimpleArea(aRange) == SC_MARK_SIMPLE)
+    {
+        ScDocShell* pDocSh = GetViewData().GetDocShell();
+        const ScMarkData& rMark = GetViewData().GetMarkData();
+        bool bSuccess = pDocSh->GetDocFunc().InsertCells( aRange, &rMark, eCmd, bRecord, false, bPartOfPaste );
+        if (bSuccess)
+        {
+            bool bInsertCols = ( eCmd == INS_INSCOLS_BEFORE || eCmd == INS_INSCOLS_AFTER);
+            bool bInsertRows = ( eCmd == INS_INSROWS_BEFORE || eCmd == INS_INSROWS_AFTER );
+
+            pDocSh->UpdateOle(&GetViewData());
+            CellContentChanged();
+            ResetAutoSpell();
+
+            if ( bInsertCols || bInsertRows )
+            {
+                OUString aOperation = bInsertRows ?
+                    OUString("insert-rows"):
+                    OUString("insert-columns");
+                HelperNotifyChanges::NotifyIfChangesListeners(*pDocSh, aRange, aOperation);
+            }
+
+            if (comphelper::LibreOfficeKit::isActive())
+            {
+                if (bInsertCols)
+                    ScTabViewShell::notifyAllViewsHeaderInvalidation(COLUMN_HEADER, GetViewData().GetTabNo());
+
+                if (bInsertRows)
+                    ScTabViewShell::notifyAllViewsHeaderInvalidation(ROW_HEADER, GetViewData().GetTabNo());
+            }
+        }
+        OUString aStartAddress =  aRange.aStart.GetColRowString();
+        OUString aEndAddress = aRange.aEnd.GetColRowString();
+        collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, "INSERT_CELLS");
+        return bSuccess;
+    }
+    else
+    {
+        ErrorMessage(STR_NOMULTISELECT);
+        return false;
+    }
+}
+
+//  delete cells - undo OK
+
+void ScViewFunc::DeleteCells( DelCellCmd eCmd )
+{
+    ScRange aRange;
+    if ( GetViewData().GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
+    {
+        ScDocShell* pDocSh = GetViewData().GetDocShell();
+        const ScMarkData& rMark = GetViewData().GetMarkData();
+
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+        // #i94841# [Collaboration] if deleting rows is rejected, the content is sometimes wrong
+        if ( pDocSh->IsDocShared() && ( eCmd == DelCellCmd::Rows || eCmd == DelCellCmd::Cols ) )
+        {
+            ScRange aDelRange( aRange.aStart );
+            SCCOLROW nCount = 0;
+            if ( eCmd == DelCellCmd::Rows )
+            {
+                nCount = sal::static_int_cast< SCCOLROW >( aRange.aEnd.Row() - aRange.aStart.Row() + 1 );
+            }
+            else
+            {
+                nCount = sal::static_int_cast< SCCOLROW >( aRange.aEnd.Col() - aRange.aStart.Col() + 1 );
+            }
+            while ( nCount > 0 )
+            {
+                pDocSh->GetDocFunc().DeleteCells( aDelRange, &rMark, eCmd, false );
+                --nCount;
+            }
+        }
+        else
+#endif
+        {
+            pDocSh->GetDocFunc().DeleteCells( aRange, &rMark, eCmd, false );
+        }
+
+        pDocSh->UpdateOle(&GetViewData());
+        CellContentChanged();
+        ResetAutoSpell();
+
+        if ( eCmd == DelCellCmd::Rows || eCmd == DelCellCmd::Cols )
+        {
+            OUString aOperation = ( eCmd == DelCellCmd::Rows) ?
+              OUString("delete-rows"):
+              OUString("delete-columns");
+            HelperNotifyChanges::NotifyIfChangesListeners(*pDocSh, aRange, aOperation);
+        }
+
+        //  put cursor directly behind deleted range
+        SCCOL nCurX = GetViewData().GetCurX();
+        SCROW nCurY = GetViewData().GetCurY();
+        if ( eCmd==DelCellCmd::CellsLeft || eCmd==DelCellCmd::Cols )
+            nCurX = aRange.aStart.Col();
+        else
+            nCurY = aRange.aStart.Row();
+        SetCursor( nCurX, nCurY );
+
+        if (comphelper::LibreOfficeKit::isActive())
+        {
+            if (eCmd == DelCellCmd::Cols)
+                ScTabViewShell::notifyAllViewsHeaderInvalidation(COLUMN_HEADER, GetViewData().GetTabNo());
+
+            if (eCmd == DelCellCmd::Rows)
+                ScTabViewShell::notifyAllViewsHeaderInvalidation(ROW_HEADER, GetViewData().GetTabNo());
+        }
+    }
+    else
+    {
+        if (eCmd == DelCellCmd::Cols)
+            DeleteMulti( false );
+        else if (eCmd == DelCellCmd::Rows)
+            DeleteMulti( true );
+        else
+            ErrorMessage(STR_NOMULTISELECT);
+    }
+
+    OUString aStartAddress =  aRange.aStart.GetColRowString();
+    OUString aEndAddress = aRange.aEnd.GetColRowString();
+    collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, "DELETE_CELLS");
+
+    Unmark();
+}
+
+void ScViewFunc::DeleteMulti( bool bRows )
+{
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocShellModificator aModificator( *pDocSh );
+    SCTAB nTab = GetViewData().GetTabNo();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    ScMarkData aFuncMark( GetViewData().GetMarkData() );       // local copy for UnmarkFiltered
+    ScViewUtil::UnmarkFiltered( aFuncMark, &rDoc );
+
+    bool bRecord = true;
+    if (!rDoc.IsUndoEnabled())
+        bRecord = false;
+
+    std::vector<sc::ColRowSpan> aSpans;
+    if (bRows)
+        aSpans = aFuncMark.GetMarkedRowSpans();
+    else
+        aSpans = aFuncMark.GetMarkedColSpans();
+
+    if (aSpans.empty())
+    {
+        SCCOLROW nCurPos = bRows ? GetViewData().GetCurY() : GetViewData().GetCurX();
+        aSpans.emplace_back(nCurPos, nCurPos);
+    }
+
+    //  test if allowed
+
+    const char* pErrorId = nullptr;
+    bool bNeedRefresh = false;
+    for (size_t i = 0, n = aSpans.size(); i < n && !pErrorId; ++i)
+    {
+        SCCOLROW nStart = aSpans[i].mnStart;
+        SCCOLROW nEnd = aSpans[i].mnEnd;
+
+        SCCOL nStartCol, nEndCol;
+        SCROW nStartRow, nEndRow;
+        if ( bRows )
+        {
+            nStartCol = 0;
+            nEndCol   = rDoc.MaxCol();
+            nStartRow = static_cast<SCROW>(nStart);
+            nEndRow   = static_cast<SCROW>(nEnd);
+        }
+        else
+        {
+            nStartCol = static_cast<SCCOL>(nStart);
+            nEndCol   = static_cast<SCCOL>(nEnd);
+            nStartRow = 0;
+            nEndRow   = rDoc.MaxRow();
+        }
+
+        // cell protection (only needed for first range, as all following cells are moved)
+        if (i == 0)
+        {
+            // test to the end of the sheet
+            ScEditableTester aTester( &rDoc, nTab, nStartCol, nStartRow, rDoc.MaxCol(), rDoc.MaxRow() );
+            if (!aTester.IsEditable())
+                pErrorId = aTester.GetMessageId();
+        }
+
+        // merged cells
+        SCCOL nMergeStartX = nStartCol;
+        SCROW nMergeStartY = nStartRow;
+        SCCOL nMergeEndX   = nEndCol;
+        SCROW nMergeEndY   = nEndRow;
+        rDoc.ExtendMerge( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, nTab );
+        rDoc.ExtendOverlapped( nMergeStartX, nMergeStartY, nMergeEndX, nMergeEndY, nTab );
+
+        if ( nMergeStartX != nStartCol || nMergeStartY != nStartRow )
+        {
+            // Disallow deleting parts of a merged cell.
+            // Deleting the start is allowed (merge is removed), so the end doesn't have to be checked.
+
+            pErrorId = STR_MSSG_DELETECELLS_0;
+        }
+        if ( nMergeEndX != nEndCol || nMergeEndY != nEndRow )
+        {
+            // detect if the start of a merged cell is deleted, so the merge flags can be refreshed
+
+            bNeedRefresh = true;
+        }
+    }
+
+    if (pErrorId)
+    {
+        ErrorMessage(pErrorId);
+        return;
+    }
+
+    //  proceed
+
+    WaitObject aWait( GetFrameWin() );      // important for TrackFormulas in UpdateReference
+
+    ScDocumentUniquePtr pUndoDoc;
+    std::unique_ptr<ScRefUndoData> pUndoData;
+    if (bRecord)
+    {
+        pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
+        pUndoDoc->InitUndo( &rDoc, nTab, nTab, !bRows, bRows );      // row height
+
+        for (const sc::ColRowSpan & rSpan : aSpans)
+        {
+            SCCOLROW nStart = rSpan.mnStart;
+            SCCOLROW nEnd = rSpan.mnEnd;
+            if (bRows)
+                rDoc.CopyToDocument( 0,nStart,nTab, rDoc.MaxCol(), nEnd,nTab, InsertDeleteFlags::ALL,false,*pUndoDoc );
+            else
+                rDoc.CopyToDocument( static_cast<SCCOL>(nStart),0,nTab,
+                        static_cast<SCCOL>(nEnd), rDoc.MaxRow(), nTab,
+                        InsertDeleteFlags::ALL,false,*pUndoDoc );
+        }
+
+        //  all Formulas because of references
+        SCTAB nTabCount = rDoc.GetTableCount();
+        pUndoDoc->AddUndoTab( 0, nTabCount-1 );
+        rDoc.CopyToDocument( 0,0,0, rDoc.MaxCol(), rDoc.MaxRow(), MAXTAB, InsertDeleteFlags::FORMULA,false,*pUndoDoc );
+
+        pUndoData.reset(new ScRefUndoData( &rDoc ));
+
+        rDoc.BeginDrawUndo();
+    }
+
+    std::vector<sc::ColRowSpan>::const_reverse_iterator ri = aSpans.rbegin(), riEnd = aSpans.rend();
+    aFuncMark.SelectOneTable(nTab);
+    for (; ri != riEnd; ++ri)
+    {
+        SCCOLROW nEnd = ri->mnEnd;
+        SCCOLROW nStart = ri->mnStart;
+
+        if (bRows)
+        {
+            rDoc.DeleteObjectsInArea(0, nStart, rDoc.MaxCol(), nEnd, aFuncMark, true);
+            rDoc.DeleteRow(0, nTab, rDoc.MaxCol(), nTab, nStart, static_cast<SCSIZE>(nEnd - nStart + 1));
+        }
+        else
+        {
+            rDoc.DeleteObjectsInArea(nStart, 0, nEnd, rDoc.MaxRow(), aFuncMark, true);
+            rDoc.DeleteCol(0, nTab, rDoc.MaxRow(), nTab, static_cast<SCCOL>(nStart), static_cast<SCSIZE>(nEnd - nStart + 1));
+        }
+    }
+
+    if (bNeedRefresh)
+    {
+        SCCOLROW nFirstStart = aSpans[0].mnStart;
+        SCCOL nStartCol = bRows ? 0 : static_cast<SCCOL>(nFirstStart);
+        SCROW nStartRow = bRows ? static_cast<SCROW>(nFirstStart) : 0;
+        SCCOL nEndCol = rDoc.MaxCol();
+        SCROW nEndRow = rDoc.MaxRow();
+
+        rDoc.RemoveFlagsTab( nStartCol, nStartRow, nEndCol, nEndRow, nTab, ScMF::Hor | ScMF::Ver );
+        rDoc.ExtendMerge( nStartCol, nStartRow, nEndCol, nEndRow, nTab, true );
+    }
+
+    if (bRecord)
+    {
+        pDocSh->GetUndoManager()->AddUndoAction(
+            std::make_unique<ScUndoDeleteMulti>(
+                pDocSh, bRows, bNeedRefresh, nTab, aSpans, std::move(pUndoDoc), std::move(pUndoData)));
+    }
+
+    if (!AdjustRowHeight(0, rDoc.MaxRow()))
+    {
+        if (bRows)
+        {
+            pDocSh->PostPaint(
+                0, aSpans[0].mnStart, nTab,
+                rDoc.MaxCol(), rDoc.MaxRow(), nTab, (PaintPartFlags::Grid | PaintPartFlags::Left));
+        }
+        else
+        {
+            pDocSh->PostPaint(
+                static_cast<SCCOL>(aSpans[0].mnStart), 0, nTab,
+                rDoc.MaxCol(), rDoc.MaxRow(), nTab, (PaintPartFlags::Grid | PaintPartFlags::Top));
+        }
+    }
+
+    ResetAutoSpell();
+    aModificator.SetDocumentModified();
+
+    CellContentChanged();
+
+    //  put cursor directly behind the first deleted range
+    SCCOL nCurX = GetViewData().GetCurX();
+    SCROW nCurY = GetViewData().GetCurY();
+    if ( bRows )
+        nCurY = aSpans[0].mnStart;
+    else
+        nCurX = static_cast<SCCOL>(aSpans[0].mnStart);
+    SetCursor( nCurX, nCurY );
+
+    SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreaLinksChanged ) );
+}
+
+//  delete contents
+
+void ScViewFunc::DeleteContents( InsertDeleteFlags nFlags )
+{
+    ScViewData& rViewData = GetViewData();
+    rViewData.SetPasteMode( ScPasteFlags::NONE );
+    rViewData.GetViewShell()->UpdateCopySourceOverlay();
+
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    bool bEditable = SelectionEditable( &bOnlyNotBecauseOfMatrix );
+    if ( !bEditable )
+    {
+        if ( !(bOnlyNotBecauseOfMatrix &&
+                ((nFlags & (InsertDeleteFlags::ATTRIB | InsertDeleteFlags::EDITATTR)) == nFlags)) )
+        {
+            ErrorMessage(bOnlyNotBecauseOfMatrix ? STR_MATRIXFRAGMENTERR : STR_PROTECTIONERR);
+            return;
+        }
+    }
+
+    ScRange aMarkRange;
+    bool bSimple = false;
+
+    ScDocument* pDoc = GetViewData().GetDocument();
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScMarkData aFuncMark( GetViewData().GetMarkData() );       // local copy for UnmarkFiltered
+    ScViewUtil::UnmarkFiltered( aFuncMark, pDoc );
+
+    bool bRecord =true;
+    if (!pDoc->IsUndoEnabled())
+        bRecord = false;
+
+    if ( !aFuncMark.IsMarked() && !aFuncMark.IsMultiMarked() )
+    {
+        aMarkRange.aStart.SetCol(GetViewData().GetCurX());
+        aMarkRange.aStart.SetRow(GetViewData().GetCurY());
+        aMarkRange.aStart.SetTab(GetViewData().GetTabNo());
+        aMarkRange.aEnd = aMarkRange.aStart;
+        if ( pDoc->HasAttrib( aMarkRange, HasAttrFlags::Merged ) )
+        {
+            aFuncMark.SetMarkArea( aMarkRange );
+        }
+        else
+            bSimple = true;
+    }
+
+    HideAllCursors();   // for if summary is cancelled
+
+    ScDocFunc& rDocFunc = pDocSh->GetDocFunc();
+    if (bSimple)
+        rDocFunc.DeleteCell(aMarkRange.aStart, aFuncMark, nFlags, bRecord);
+    else
+        rDocFunc.DeleteContents(aFuncMark, nFlags, bRecord, false);
+
+    pDocSh->UpdateOle(&GetViewData());
+
+    if (ScModelObj *pModelObj = HelperNotifyChanges::getMustPropagateChangesModel(*pDocSh))
+    {
+        ScRangeList aChangeRanges;
+        if ( bSimple )
+        {
+            aChangeRanges.push_back( aMarkRange );
+        }
+        else
+        {
+            aFuncMark.FillRangeListWithMarks( &aChangeRanges, false );
+        }
+        HelperNotifyChanges::Notify(*pModelObj, aChangeRanges);
+    }
+
+    CellContentChanged();
+    ShowAllCursors();
+
+    if ( nFlags & InsertDeleteFlags::ATTRIB )
+    {
+        if ( nFlags & InsertDeleteFlags::CONTENTS )
+            bFormatValid = false;
+        else
+            StartFormatArea();              // delete attribute is also attribute-change
+    }
+    OUString aStartAddress =  aMarkRange.aStart.GetColRowString();
+    OUString aEndAddress = aMarkRange.aEnd.GetColRowString();
+    collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, "DELETE");
+}
+
+//  column width/row height (via header) - undo OK
+
+void ScViewFunc::SetWidthOrHeight(
+    bool bWidth, const std::vector<sc::ColRowSpan>& rRanges, ScSizeMode eMode,
+    sal_uInt16 nSizeTwips, bool bRecord, const ScMarkData* pMarkData )
+{
+    if (rRanges.empty())
+        return;
+
+    // Use view's mark if none specified, but do not modify the original data,
+    // i.e. no MarkToMulti() on that.
+    ScMarkData aMarkData( pMarkData ? *pMarkData : GetViewData().GetMarkData());
+
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    SCCOL nCurX = GetViewData().GetCurX();
+    SCROW nCurY = GetViewData().GetCurY();
+    SCTAB nFirstTab = aMarkData.GetFirstSelected();
+    SCTAB nCurTab = GetViewData().GetTabNo();
+    if (bRecord && !rDoc.IsUndoEnabled())
+        bRecord = false;
+
+    ScDocShellModificator aModificator( *pDocSh );
+
+    bool bAllowed = true;
+    for (const SCTAB& nTab : aMarkData)
+    {
+        bAllowed = std::all_of(rRanges.begin(), rRanges.end(),
+            [&bWidth, &rDoc, &nTab](const sc::ColRowSpan& rRange) {
+                bool bOnlyMatrix;
+                bool bIsBlockEditable;
+                if (bWidth)
+                    bIsBlockEditable = rDoc.IsBlockEditable(nTab, rRange.mnStart, 0, rRange.mnEnd, rDoc.MaxRow(), &bOnlyMatrix);
+                else
+                    bIsBlockEditable = rDoc.IsBlockEditable(nTab, 0, rRange.mnStart, rDoc.MaxCol(), rRange.mnEnd, &bOnlyMatrix);
+                return bIsBlockEditable || bOnlyMatrix;
+            });
+        if (!bAllowed)
+            break;
+    }
+
+    // Allow users to resize cols/rows in readonly docs despite the r/o state.
+    // It is frustrating to be unable to see content in mis-sized cells.
+    if( !bAllowed && !pDocSh->IsReadOnly() )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    SCCOLROW nStart = rRanges.front().mnStart;
+    SCCOLROW nEnd = rRanges.back().mnEnd;
+
+    OnLOKSetWidthOrHeight(nStart, bWidth);
+
+    bool bFormula = false;
+    if ( eMode == SC_SIZE_OPTIMAL )
+    {
+        const ScViewOptions& rOpts = GetViewData().GetOptions();
+        bFormula = rOpts.GetOption( VOPT_FORMULAS );
+    }
+
+    ScDocumentUniquePtr pUndoDoc;
+    std::unique_ptr<ScOutlineTable> pUndoTab;
+    std::vector<sc::ColRowSpan> aUndoRanges;
+
+    if ( bRecord )
+    {
+        rDoc.BeginDrawUndo();                          // Drawing Updates
+
+        pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
+        for (const SCTAB& nTab : aMarkData)
+        {
+            if (bWidth)
+            {
+                if ( nTab == nFirstTab )
+                    pUndoDoc->InitUndo( &rDoc, nTab, nTab, true );
+                else
+                    pUndoDoc->AddUndoTab( nTab, nTab, true );
+                rDoc.CopyToDocument( static_cast<SCCOL>(nStart), 0, nTab,
+                        static_cast<SCCOL>(nEnd), rDoc.MaxRow(), nTab, InsertDeleteFlags::NONE,
+                        false, *pUndoDoc );
+            }
+            else
+            {
+                if ( nTab == nFirstTab )
+                    pUndoDoc->InitUndo( &rDoc, nTab, nTab, false, true );
+                else
+                    pUndoDoc->AddUndoTab( nTab, nTab, false, true );
+                rDoc.CopyToDocument( 0, nStart, nTab, rDoc.MaxCol(), nEnd, nTab, InsertDeleteFlags::NONE, false, *pUndoDoc );
+            }
+        }
+
+        aUndoRanges = rRanges;
+
+        //! outlines from all tab?
+        ScOutlineTable* pTable = rDoc.GetOutlineTable( nCurTab );
+        if (pTable)
+            pUndoTab.reset(new ScOutlineTable( *pTable ));
+    }
+
+    if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
+        aMarkData.MarkToMulti();
+
+    bool bShow = nSizeTwips > 0 || eMode != SC_SIZE_DIRECT;
+    bool bOutline = false;
+
+    for (const SCTAB& nTab : aMarkData)
+    {
+        for (const sc::ColRowSpan & rRange : rRanges)
+        {
+            SCCOLROW nStartNo = rRange.mnStart;
+            SCCOLROW nEndNo = rRange.mnEnd;
+
+            if ( !bWidth )                      // height always blockwise
+            {
+                if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
+                {
+                    bool bAll = ( eMode==SC_SIZE_OPTIMAL );
+                    if (!bAll)
+                    {
+                        //  delete CRFlags::ManualSize for all in range,
+                        //  then SetOptimalHeight with bShrink = FALSE
+                        for (SCROW nRow = nStartNo; nRow <= nEndNo; ++nRow)
+                        {
+                            SCROW nLastRow = nRow;
+                            if (rDoc.RowHidden(nRow, nTab, nullptr, &nLastRow))
+                            {
+                                nRow = nLastRow;
+                                continue;
+                            }
+
+                            CRFlags nOld = rDoc.GetRowFlags(nRow, nTab);
+                            if (nOld & CRFlags::ManualSize)
+                                rDoc.SetRowFlags(nRow, nTab, nOld & ~CRFlags::ManualSize);
+                        }
+                    }
+
+                    double nPPTX = GetViewData().GetPPTX();
+                    double nPPTY = GetViewData().GetPPTY();
+                    Fraction aZoomX = GetViewData().GetZoomX();
+                    Fraction aZoomY = GetViewData().GetZoomY();
+
+                    ScSizeDeviceProvider aProv(pDocSh);
+                    if (aProv.IsPrinter())
+                    {
+                        nPPTX = aProv.GetPPTX();
+                        nPPTY = aProv.GetPPTY();
+                        aZoomX = aZoomY = Fraction( 1, 1 );
+                    }
+
+                    sc::RowHeightContext aCxt(rDoc.MaxRow(), nPPTX, nPPTY, aZoomX, aZoomY, aProv.GetDevice());
+                    aCxt.setForceAutoSize(bAll);
+                    aCxt.setExtraHeight(nSizeTwips);
+                    rDoc.SetOptimalHeight(aCxt, nStartNo, nEndNo, nTab);
+                    if (bAll)
+                        rDoc.ShowRows( nStartNo, nEndNo, nTab, true );
+
+                    //  Manual-Flag already (re)set in SetOptimalHeight in case of bAll=sal_True
+                    //  (set for Extra-Height, else reset).
+                }
+                else if ( eMode==SC_SIZE_DIRECT )
+                {
+                    if (nSizeTwips)
+                    {
+                        rDoc.SetRowHeightRange( nStartNo, nEndNo, nTab, nSizeTwips );
+                        rDoc.SetManualHeight( nStartNo, nEndNo, nTab, true );          // height was set manually
+                    }
+
+                    rDoc.ShowRows( nStartNo, nEndNo, nTab, nSizeTwips != 0 );
+
+                    if (!bShow && nStartNo <= nCurY && nCurY <= nEndNo && nTab == nCurTab)
+                    {
+                        nCurY = -1;
+                    }
+                }
+                else if ( eMode==SC_SIZE_SHOW )
+                {
+                    rDoc.ShowRows( nStartNo, nEndNo, nTab, true );
+                }
+            }
+            else                                // column width
+            {
+                for (SCCOL nCol=static_cast<SCCOL>(nStartNo); nCol<=static_cast<SCCOL>(nEndNo); nCol++)
+                {
+                    if ( eMode != SC_SIZE_VISOPT || !rDoc.ColHidden(nCol, nTab) )
+                    {
+                        sal_uInt16 nThisSize = nSizeTwips;
+
+                        if ( eMode==SC_SIZE_OPTIMAL || eMode==SC_SIZE_VISOPT )
+                            nThisSize = nSizeTwips + GetOptimalColWidth( nCol, nTab, bFormula );
+                        if ( nThisSize )
+                            rDoc.SetColWidth( nCol, nTab, nThisSize );
+
+                        rDoc.ShowCol( nCol, nTab, bShow );
+
+                        if (!bShow && nCol == nCurX && nTab == nCurTab)
+                        {
+                            nCurX = -1;
+                        }
+                    }
+                }
+            }
+
+            //  adjust outline
+            if (bWidth)
+            {
+                if ( rDoc.UpdateOutlineCol( static_cast<SCCOL>(nStartNo),
+                            static_cast<SCCOL>(nEndNo), nTab, bShow ) )
+                    bOutline = true;
+            }
+            else
+            {
+                if ( rDoc.UpdateOutlineRow( nStartNo, nEndNo, nTab, bShow ) )
+                    bOutline = true;
+            }
+        }
+        rDoc.SetDrawPageSize(nTab);
+    }
+
+    if (!bOutline)
+        pUndoTab.reset();
+
+    if (bRecord)
+    {
+        pDocSh->GetUndoManager()->AddUndoAction(
+            std::make_unique<ScUndoWidthOrHeight>(
+                pDocSh, aMarkData, nStart, nCurTab, nEnd, nCurTab,
+                std::move(pUndoDoc), aUndoRanges, std::move(pUndoTab), eMode, nSizeTwips, bWidth));
+    }
+
+    if (nCurX < 0)
+    {
+        MoveCursorRel( 1, 0, SC_FOLLOW_LINE, false );
+    }
+
+    if (nCurY < 0)
+    {
+        MoveCursorRel( 0, 1, SC_FOLLOW_LINE, false );
+    }
+
+    // fdo#36247 Ensure that the drawing layer's map mode scaling factors match
+    // the new heights and widths.
+    GetViewData().GetView()->RefreshZoom();
+
+    for (const SCTAB& nTab : aMarkData)
+        rDoc.UpdatePageBreaks( nTab );
+
+    GetViewData().GetView()->UpdateScrollBars(bWidth ? COLUMN_HEADER : ROW_HEADER);
+
+    {
+        for (const SCTAB& nTab : aMarkData)
+        {
+            if (bWidth)
+            {
+                if (rDoc.HasAttrib( static_cast<SCCOL>(nStart),0,nTab,
+                            static_cast<SCCOL>(nEnd), rDoc.MaxRow(), nTab,
+                            HasAttrFlags::Merged | HasAttrFlags::Overlapped ))
+                    nStart = 0;
+                if (nStart > 0)             // go upwards because of Lines and cursor
+                    --nStart;
+                pDocSh->PostPaint( static_cast<SCCOL>(nStart), 0, nTab,
+                        rDoc.MaxCol(), rDoc.MaxRow(), nTab, PaintPartFlags::Grid | PaintPartFlags::Top );
+            }
+            else
+            {
+                if (rDoc.HasAttrib( 0,nStart,nTab, rDoc.MaxCol(), nEnd,nTab, HasAttrFlags::Merged | HasAttrFlags::Overlapped ))
+                    nStart = 0;
+                if (nStart != 0)
+                    --nStart;
+                pDocSh->PostPaint( 0, nStart, nTab, rDoc.MaxCol(), rDoc.MaxRow(), nTab, PaintPartFlags::Grid | PaintPartFlags::Left );
+            }
+        }
+
+        pDocSh->UpdateOle(&GetViewData());
+        if( !pDocSh->IsReadOnly() )
+            aModificator.SetDocumentModified();
+    }
+
+    if ( bWidth )
+    {
+        if (ScModelObj* pModelObj = HelperNotifyChanges::getMustPropagateChangesModel(*pDocSh))
+        {
+            ScRangeList aChangeRanges;
+            for (const SCTAB& nTab : aMarkData)
+            {
+                for (const sc::ColRowSpan & rRange : rRanges)
+                {
+                    SCCOL nStartCol = rRange.mnStart;
+                    SCCOL nEndCol   = rRange.mnEnd;
+                    for ( SCCOL nCol = nStartCol; nCol <= nEndCol; ++nCol )
+                    {
+                        aChangeRanges.push_back( ScRange( nCol, 0, nTab ) );
+                    }
+                }
+            }
+            HelperNotifyChanges::Notify(*pModelObj, aChangeRanges, "column-resize");
+        }
+    }
+}
+
+//  column width/row height (via marked range)
+
+void ScViewFunc::SetMarkedWidthOrHeight( bool bWidth, ScSizeMode eMode, sal_uInt16 nSizeTwips )
+{
+    ScMarkData& rMark = GetViewData().GetMarkData();
+
+    rMark.MarkToMulti();
+    if (!rMark.IsMultiMarked())
+    {
+        SCCOL nCol = GetViewData().GetCurX();
+        SCROW nRow = GetViewData().GetCurY();
+        SCTAB nTab = GetViewData().GetTabNo();
+        DoneBlockMode();
+        InitOwnBlockMode();
+        rMark.SetMultiMarkArea( ScRange( nCol,nRow,nTab ) );
+        MarkDataChanged();
+    }
+
+    std::vector<sc::ColRowSpan> aRanges =
+        bWidth ? rMark.GetMarkedColSpans() : rMark.GetMarkedRowSpans();
+
+    SetWidthOrHeight(bWidth, aRanges, eMode, nSizeTwips);
+
+    rMark.MarkToSimple();
+}
+
+void ScViewFunc::ModifyCellSize( ScDirection eDir, bool bOptimal )
+{
+    //! step size adjustable
+    //  step size is also minimum
+    sal_uInt16 nStepX = STD_COL_WIDTH / 5;
+    sal_uInt16 nStepY = ScGlobal::nStdRowHeight;
+
+    ScModule* pScMod = SC_MOD();
+    bool bAnyEdit = pScMod->IsInputMode();
+    SCCOL nCol = GetViewData().GetCurX();
+    SCROW nRow = GetViewData().GetCurY();
+    SCTAB nTab = GetViewData().GetTabNo();
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+
+    bool bAllowed, bOnlyMatrix;
+    if ( eDir == DIR_LEFT || eDir == DIR_RIGHT )
+        bAllowed = rDoc.IsBlockEditable( nTab, nCol,0, nCol,rDoc.MaxRow(), &bOnlyMatrix );
+    else
+        bAllowed = rDoc.IsBlockEditable( nTab, 0,nRow, rDoc.MaxCol(), nRow, &bOnlyMatrix );
+    if ( !bAllowed && !bOnlyMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    HideAllCursors();
+
+    sal_uInt16 nWidth = rDoc.GetColWidth( nCol, nTab );
+    sal_uInt16 nHeight = rDoc.GetRowHeight( nRow, nTab );
+    std::vector<sc::ColRowSpan> aRange(1, sc::ColRowSpan(0,0));
+    if ( eDir == DIR_LEFT || eDir == DIR_RIGHT )
+    {
+        if (bOptimal)               // width of this single cell
+        {
+            if ( bAnyEdit )
+            {
+                //  when editing the actual entered width
+                ScInputHandler* pHdl = pScMod->GetInputHdl( GetViewData().GetViewShell() );
+                if (pHdl)
+                {
+                    long nEdit = pHdl->GetTextSize().Width();       // in 0.01 mm
+
+                    const ScPatternAttr* pPattern = rDoc.GetPattern( nCol, nRow, nTab );
+                    const SvxMarginItem& rMItem = pPattern->GetItem(ATTR_MARGIN);
+                    sal_uInt16 nMargin = rMItem.GetLeftMargin() + rMItem.GetRightMargin();
+                    if ( pPattern->GetItem( ATTR_HOR_JUSTIFY ).GetValue() == SvxCellHorJustify::Left )
+                        nMargin = sal::static_int_cast<sal_uInt16>(
+                            nMargin + pPattern->GetItem(ATTR_INDENT).GetValue() );
+
+                    nWidth = static_cast<sal_uInt16>(nEdit * pDocSh->GetOutputFactor() / HMM_PER_TWIPS)
+                                + nMargin + STD_EXTRA_WIDTH;
+                }
+            }
+            else
+            {
+                double nPPTX = GetViewData().GetPPTX();
+                double nPPTY = GetViewData().GetPPTY();
+                Fraction aZoomX = GetViewData().GetZoomX();
+                Fraction aZoomY = GetViewData().GetZoomY();
+
+                ScSizeDeviceProvider aProv(pDocSh);
+                if (aProv.IsPrinter())
+                {
+                    nPPTX = aProv.GetPPTX();
+                    nPPTY = aProv.GetPPTY();
+                    aZoomX = aZoomY = Fraction( 1, 1 );
+                }
+
+                long nPixel = rDoc.GetNeededSize( nCol, nRow, nTab, aProv.GetDevice(),
+                                            nPPTX, nPPTY, aZoomX, aZoomY, true );
+                sal_uInt16 nTwips = static_cast<sal_uInt16>( nPixel / nPPTX );
+                if (nTwips != 0)
+                    nWidth = nTwips + STD_EXTRA_WIDTH;
+                else
+                    nWidth = STD_COL_WIDTH;
+            }
+        }
+        else                        // increment / decrement
+        {
+            if ( eDir == DIR_RIGHT )
+                nWidth = sal::static_int_cast<sal_uInt16>( nWidth + nStepX );
+            else if ( nWidth > nStepX )
+                nWidth = sal::static_int_cast<sal_uInt16>( nWidth - nStepX );
+            if ( nWidth < nStepX ) nWidth = nStepX;
+            if ( nWidth > MAX_COL_WIDTH ) nWidth = MAX_COL_WIDTH;
+        }
+        aRange[0].mnStart = nCol;
+        aRange[0].mnEnd = nCol;
+        SetWidthOrHeight(true, aRange, SC_SIZE_DIRECT, nWidth);
+
+        //  adjust height of this row if width demands/allows this
+
+        if (!bAnyEdit)
+        {
+            const ScPatternAttr* pPattern = rDoc.GetPattern( nCol, nRow, nTab );
+            bool bNeedHeight =
+                    pPattern->GetItem( ATTR_LINEBREAK ).GetValue() ||
+                    pPattern->GetItem( ATTR_HOR_JUSTIFY ).GetValue() == SvxCellHorJustify::Block;
+            if (bNeedHeight)
+                AdjustRowHeight( nRow, nRow );
+        }
+    }
+    else
+    {
+        ScSizeMode eMode;
+        if (bOptimal)
+        {
+            eMode = SC_SIZE_OPTIMAL;
+            nHeight = 0;
+        }
+        else
+        {
+            eMode = SC_SIZE_DIRECT;
+            if ( eDir == DIR_BOTTOM )
+                nHeight = sal::static_int_cast<sal_uInt16>( nHeight + nStepY );
+            else if ( nHeight > nStepY )
+                nHeight = sal::static_int_cast<sal_uInt16>( nHeight - nStepY );
+            if ( nHeight < nStepY ) nHeight = nStepY;
+            if ( nHeight > MAX_ROW_HEIGHT ) nHeight = MAX_ROW_HEIGHT;
+        }
+        aRange[0].mnStart = nRow;
+        aRange[0].mnEnd = nRow;
+        SetWidthOrHeight(false, aRange, eMode, nHeight);
+    }
+
+    if ( bAnyEdit )
+    {
+        UpdateEditView();
+        if ( rDoc.HasAttrib( nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::NeedHeight ) )
+        {
+            ScInputHandler* pHdl = pScMod->GetInputHdl( GetViewData().GetViewShell() );
+            if (pHdl)
+                pHdl->SetModified();    // so that the height is adjusted with Enter
+        }
+    }
+
+    ShowAllCursors();
+}
+
+void ScViewFunc::ProtectSheet( SCTAB nTab, const ScTableProtection& rProtect )
+{
+    if (nTab == TABLEID_DOC)
+        return;
+
+    ScMarkData& rMark = GetViewData().GetMarkData();
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    ScDocFunc &rFunc = pDocSh->GetDocFunc();
+    bool bUndo(rDoc.IsUndoEnabled());
+
+    //  modifying several tabs is handled here
+
+    if (bUndo)
+    {
+        OUString aUndo = ScResId( STR_UNDO_PROTECT_TAB );
+        pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId() );
+    }
+
+    for (const auto& rTab : rMark)
+    {
+        rFunc.ProtectSheet(rTab, rProtect);
+        SetTabProtectionSymbol(rTab, true);
+    }
+
+    if (bUndo)
+        pDocSh->GetUndoManager()->LeaveListAction();
+
+    UpdateLayerLocks();         //! broadcast to all views
+}
+
+void ScViewFunc::Protect( SCTAB nTab, const OUString& rPassword )
+{
+    ScMarkData& rMark = GetViewData().GetMarkData();
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    ScDocFunc &rFunc = pDocSh->GetDocFunc();
+    bool bUndo(rDoc.IsUndoEnabled());
+
+    if ( nTab == TABLEID_DOC || rMark.GetSelectCount() <= 1 )
+        rFunc.Protect( nTab, rPassword );
+    else
+    {
+        //  modifying several tabs is handled here
+
+        if (bUndo)
+        {
+            OUString aUndo = ScResId( STR_UNDO_PROTECT_TAB );
+            pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId() );
+        }
+
+        for (const auto& rTab : rMark)
+            rFunc.Protect( rTab, rPassword );
+
+        if (bUndo)
+            pDocSh->GetUndoManager()->LeaveListAction();
+    }
+
+    UpdateLayerLocks();         //! broadcast to all views
+}
+
+bool ScViewFunc::Unprotect( SCTAB nTab, const OUString& rPassword )
+{
+    ScMarkData& rMark = GetViewData().GetMarkData();
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    ScDocFunc &rFunc = pDocSh->GetDocFunc();
+    bool bChanged = false;
+    bool bUndo (rDoc.IsUndoEnabled());
+
+    if ( nTab == TABLEID_DOC || rMark.GetSelectCount() <= 1 )
+    {
+        bChanged = rFunc.Unprotect( nTab, rPassword, false );
+        if (bChanged && nTab != TABLEID_DOC)
+            SetTabProtectionSymbol(nTab, false);
+    }
+    else
+    {
+        //  modifying several tabs is handled here
+
+        if (bUndo)
+        {
+            OUString aUndo = ScResId( STR_UNDO_UNPROTECT_TAB );
+            pDocSh->GetUndoManager()->EnterListAction( aUndo, aUndo, 0, GetViewData().GetViewShell()->GetViewShellId() );
+        }
+
+        for (const auto& rTab : rMark)
+        {
+            if ( rFunc.Unprotect( rTab, rPassword, false ) )
+            {
+                bChanged = true;
+                SetTabProtectionSymbol( rTab, false);
+            }
+        }
+
+        if (bUndo)
+            pDocSh->GetUndoManager()->LeaveListAction();
+    }
+
+    if (bChanged)
+        UpdateLayerLocks();     //! broadcast to all views
+
+    return bChanged;
+}
+
+void ScViewFunc::SetNoteText( const ScAddress& rPos, const OUString& rNoteText )
+{
+    GetViewData().GetDocShell()->GetDocFunc().SetNoteText( rPos, rNoteText, false );
+}
+
+void ScViewFunc::ReplaceNote( const ScAddress& rPos, const OUString& rNoteText, const OUString* pAuthor, const OUString* pDate )
+{
+    GetViewData().GetDocShell()->GetDocFunc().ReplaceNote( rPos, rNoteText, pAuthor, pDate, false );
+}
+
+void ScViewFunc::SetNumberFormat( SvNumFormatType nFormatType, sal_uLong nAdd )
+{
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    sal_uInt32          nNumberFormat = 0;
+    ScViewData&         rViewData = GetViewData();
+    ScDocument*         pDoc = rViewData.GetDocument();
+    SvNumberFormatter*  pNumberFormatter = pDoc->GetFormatTable();
+    LanguageType        eLanguage = ScGlobal::eLnge;
+    ScPatternAttr       aNewAttrs( pDoc->GetPool() );
+
+    //  always take language from cursor position, even if there is a selection
+
+    sal_uInt32 nCurrentNumberFormat;
+    pDoc->GetNumberFormat( rViewData.GetCurX(),
+                           rViewData.GetCurY(),
+                           rViewData.GetTabNo(),
+                           nCurrentNumberFormat );
+    const SvNumberformat* pEntry = pNumberFormatter->GetEntry( nCurrentNumberFormat );
+    if (pEntry)
+        eLanguage = pEntry->GetLanguage();      // else keep ScGlobal::eLnge
+
+    nNumberFormat = pNumberFormatter->GetStandardFormat( nFormatType, eLanguage ) + nAdd;
+
+    SfxItemSet& rSet = aNewAttrs.GetItemSet();
+    rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumberFormat ) );
+    //  ATTR_LANGUAGE_FORMAT not
+    ApplySelectionPattern( aNewAttrs );
+}
+
+void ScViewFunc::SetNumFmtByStr( const OUString& rCode )
+{
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    ScViewData&         rViewData = GetViewData();
+    ScDocument*         pDoc = rViewData.GetDocument();
+    SvNumberFormatter*  pFormatter = pDoc->GetFormatTable();
+
+    //  language always from cursor position
+
+    sal_uInt32 nCurrentNumberFormat;
+    pDoc->GetNumberFormat( rViewData.GetCurX(), rViewData.GetCurY(),
+                           rViewData.GetTabNo(), nCurrentNumberFormat );
+    const SvNumberformat* pEntry = pFormatter->GetEntry( nCurrentNumberFormat );
+    LanguageType eLanguage = pEntry ? pEntry->GetLanguage() : ScGlobal::eLnge;
+
+    //  determine index for String
+
+    bool bOk = true;
+    sal_uInt32 nNumberFormat = pFormatter->GetEntryKey( rCode, eLanguage );
+    if ( nNumberFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+    {
+        //  enter new
+
+        OUString    aFormat = rCode;    // will be changed
+        sal_Int32   nErrPos = 0;
+        SvNumFormatType nType   = SvNumFormatType::ALL;        //! ???
+        bOk = pFormatter->PutEntry( aFormat, nErrPos, nType, nNumberFormat, eLanguage );
+    }
+
+    if ( bOk )          // valid format?
+    {
+        ScPatternAttr aNewAttrs( pDoc->GetPool() );
+        SfxItemSet& rSet = aNewAttrs.GetItemSet();
+        rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNumberFormat ) );
+        rSet.Put( SvxLanguageItem( eLanguage, ATTR_LANGUAGE_FORMAT ) );
+        ApplySelectionPattern( aNewAttrs );
+    }
+
+    //! else return error / issue warning ???
+}
+
+void ScViewFunc::ChangeNumFmtDecimals( bool bIncrement )
+{
+    // not editable because of matrix only? attribute OK nonetheless
+    bool bOnlyNotBecauseOfMatrix;
+    if ( !SelectionEditable( &bOnlyNotBecauseOfMatrix ) && !bOnlyNotBecauseOfMatrix )
+    {
+        ErrorMessage(STR_PROTECTIONERR);
+        return;
+    }
+
+    ScDocument*         pDoc = GetViewData().GetDocument();
+    SvNumberFormatter*  pFormatter = pDoc->GetFormatTable();
+
+    SCCOL nCol = GetViewData().GetCurX();
+    SCROW nRow = GetViewData().GetCurY();
+    SCTAB nTab = GetViewData().GetTabNo();
+
+    sal_uInt32 nOldFormat;
+    pDoc->GetNumberFormat( nCol, nRow, nTab, nOldFormat );
+    const SvNumberformat* pOldEntry = pFormatter->GetEntry( nOldFormat );
+    if (!pOldEntry)
+    {
+        OSL_FAIL("numberformat not found !!!");
+        return;
+    }
+
+    //  what have we got here?
+
+    sal_uInt32 nNewFormat = nOldFormat;
+    bool bError = false;
+
+    LanguageType eLanguage = pOldEntry->GetLanguage();
+    bool bThousand, bNegRed;
+    sal_uInt16 nPrecision, nLeading;
+    pOldEntry->GetFormatSpecialInfo( bThousand, bNegRed, nPrecision, nLeading );
+
+    SvNumFormatType nOldType = pOldEntry->GetType();
+    if ( SvNumFormatType::ALL == ( nOldType & (
+                SvNumFormatType::NUMBER |  SvNumFormatType::CURRENCY | SvNumFormatType::PERCENT | SvNumFormatType::SCIENTIFIC | SvNumFormatType::TIME ) ) )
+    {
+        //  date, fraction, logical, text can not be changed
+        bError = true;
+    }
+
+    //! SvNumberformat has a Member bStandard, but doesn't disclose it
+    bool bWasStandard = ( nOldFormat == pFormatter->GetStandardIndex( eLanguage ) );
+    OUString sExponentialStandardFormat = "";
+    if (bWasStandard)
+    {
+        //  with "Standard" the decimal places depend on cell content
+        //  0 if empty or text -> no decimal places
+        double nVal = pDoc->GetValue( ScAddress( nCol, nRow, nTab ) );
+
+        //  the ways of the Numberformatters are unfathomable, so try:
+        OUString aOut;
+        Color* pCol;
+        const_cast<SvNumberformat*>(pOldEntry)->GetOutputString( nVal, aOut, &pCol );
+
+        nPrecision = 0;
+        // 'E' for exponential is fixed in Numberformatter
+        sal_Int32 nIndexE = aOut.indexOf('E');
+        if ( nIndexE >= 0 )
+        {
+          sExponentialStandardFormat = aOut.copy( nIndexE ).replace( '-', '+' );
+          for ( sal_Int32 i=1 ; i<sExponentialStandardFormat.getLength() ; i++ )
+          {
+            if ( sExponentialStandardFormat[i] >= '1' && sExponentialStandardFormat[i] <= '9' )
+              sExponentialStandardFormat = sExponentialStandardFormat.replaceAt( i, 1, "0" );
+          }
+          aOut = aOut.copy( 0, nIndexE ); // remove exponential part
+        }
+        OUString aDecSep( pFormatter->GetFormatDecimalSep( nOldFormat ) );
+        sal_Int32 nPos = aOut.indexOf( aDecSep );
+        if ( nPos >= 0 )
+            nPrecision = aOut.getLength() - nPos - aDecSep.getLength();
+        // else keep 0
+    }
+    else
+    {
+        if ( (nOldType & SvNumFormatType::SCIENTIFIC) && !bThousand &&
+             (pOldEntry->GetFormatIntegerDigits()%3 == 0) && pOldEntry->GetFormatIntegerDigits() > 0 )
+            bThousand =  true;
+    }
+
+    if (!bError)
+    {
+        if (bIncrement)
+        {
+            if (nPrecision<20)
+                ++nPrecision;           // increment
+            else
+                bError = true;          // 20 is maximum
+        }
+        else
+        {
+            if (nPrecision)
+                --nPrecision;           // decrement
+            else
+                bError = true;          // 0 is minimum
+        }
+    }
+
+    if (!bError)
+    {
+        OUString aNewPicture = pFormatter->GenerateFormat(nOldFormat, eLanguage,
+                                                          bThousand, bNegRed,
+                                                          nPrecision, nLeading)
+                                + sExponentialStandardFormat;
+
+        nNewFormat = pFormatter->GetEntryKey( aNewPicture, eLanguage );
+        if ( nNewFormat == NUMBERFORMAT_ENTRY_NOT_FOUND )
+        {
+            sal_Int32 nErrPos = 0;
+            SvNumFormatType nNewType = SvNumFormatType::ALL;
+            bool bOk = pFormatter->PutEntry( aNewPicture, nErrPos,
+                                                nNewType, nNewFormat, eLanguage );
+            OSL_ENSURE( bOk, "incorrect numberformat generated" );
+            if (!bOk)
+                bError = true;
+        }
+    }
+
+    if (!bError)
+    {
+        ScPatternAttr aNewAttrs( pDoc->GetPool() );
+        SfxItemSet& rSet = aNewAttrs.GetItemSet();
+        rSet.Put( SfxUInt32Item( ATTR_VALUE_FORMAT, nNewFormat ) );
+        //  ATTR_LANGUAGE_FORMAT not
+        ApplySelectionPattern( aNewAttrs );
+    }
+}
+
+void ScViewFunc::ChangeIndent( bool bIncrement )
+{
+    ScViewData& rViewData = GetViewData();
+    ScDocShell* pDocSh  = rViewData.GetDocShell();
+    ScMarkData& rMark   = rViewData.GetMarkData();
+
+    ScMarkData aWorkMark = rMark;
+    ScViewUtil::UnmarkFiltered( aWorkMark, &pDocSh->GetDocument() );
+    aWorkMark.MarkToMulti();
+    if (!aWorkMark.IsMultiMarked())
+    {
+        SCCOL nCol = rViewData.GetCurX();
+        SCROW nRow = rViewData.GetCurY();
+        SCTAB nTab = rViewData.GetTabNo();
+        aWorkMark.SetMultiMarkArea( ScRange(nCol,nRow,nTab) );
+    }
+
+    bool bSuccess = pDocSh->GetDocFunc().ChangeIndent( aWorkMark, bIncrement, false );
+    if (bSuccess)
+    {
+        pDocSh->UpdateOle(&rViewData);
+        StartFormatArea();
+
+        // stuff for sidebar panels
+        SfxBindings& rBindings = GetViewData().GetBindings();
+        rBindings.Invalidate( SID_H_ALIGNCELL );
+        rBindings.Invalidate( SID_ATTR_ALIGN_INDENT );
+    }
+}
+
+bool ScViewFunc::InsertName( const OUString& rName, const OUString& rSymbol,
+                                const OUString& rType )
+{
+    //  Type = P,R,C,F (and combinations)
+    //! undo...
+
+    bool bOk = false;
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    ScDocument& rDoc = pDocSh->GetDocument();
+    SCTAB nTab = GetViewData().GetTabNo();
+    ScRangeName* pList = rDoc.GetRangeName();
+
+    ScRangeData::Type nType = ScRangeData::Type::Name;
+    auto pNewEntry = std::make_unique<ScRangeData>(
+        &rDoc, rName, rSymbol, ScAddress( GetViewData().GetCurX(),
+        GetViewData().GetCurY(), nTab), nType );
+    OUString aUpType = rType.toAsciiUpperCase();
+    if ( aUpType.indexOf( 'P' ) != -1 )
+        nType |= ScRangeData::Type::PrintArea;
+    if ( aUpType.indexOf( 'R' ) != -1 )
+        nType |= ScRangeData::Type::RowHeader;
+    if ( aUpType.indexOf( 'C' ) != -1 )
+        nType |= ScRangeData::Type::ColHeader;
+    if ( aUpType.indexOf( 'F' ) != -1 )
+        nType |= ScRangeData::Type::Criteria;
+    pNewEntry->AddType(nType);
+
+    if ( pNewEntry->GetErrCode() == FormulaError::NONE )     //  text valid?
+    {
+        ScDocShellModificator aModificator( *pDocSh );
+
+        rDoc.PreprocessRangeNameUpdate();
+
+        // input available yet? Then remove beforehand (=change)
+        ScRangeData* pData = pList->findByUpperName(ScGlobal::getCharClassPtr()->uppercase(rName));
+        if (pData)
+        {                                   // take old Index
+            pNewEntry->SetIndex(pData->GetIndex());
+            pList->erase(*pData);
+        }
+
+        // don't delete, insert took ownership, even on failure!
+        if ( pList->insert( pNewEntry.release() ) )
+            bOk = true;
+
+        rDoc.CompileHybridFormula();
+
+        aModificator.SetDocumentModified();
+        SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreasChanged ) );
+    }
+
+    return bOk;
+}
+
+void ScViewFunc::CreateNames( CreateNameFlags nFlags )
+{
+    bool bDone = false;
+    ScRange aRange;
+    if ( GetViewData().GetSimpleArea(aRange) == SC_MARK_SIMPLE )
+        bDone = GetViewData().GetDocShell()->GetDocFunc().CreateNames( aRange, nFlags, false );
+
+    if (!bDone)
+        ErrorMessage(STR_CREATENAME_MARKERR);
+}
+
+CreateNameFlags ScViewFunc::GetCreateNameFlags()
+{
+    CreateNameFlags nFlags = CreateNameFlags::NONE;
+
+    SCCOL nStartCol, nEndCol;
+    SCROW nStartRow, nEndRow;
+    SCTAB nDummy;
+    if (GetViewData().GetSimpleArea(nStartCol,nStartRow,nDummy,nEndCol,nEndRow,nDummy) == SC_MARK_SIMPLE)
+    {
+        ScDocument* pDoc = GetViewData().GetDocument();
+        SCTAB nTab = GetViewData().GetTabNo();
+        bool bOk;
+        SCCOL i;
+        SCROW j;
+
+        bOk = true;
+        SCCOL nFirstCol = nStartCol;
+        SCCOL nLastCol  = nEndCol;
+        if (nStartCol+1 < nEndCol) { ++nFirstCol; --nLastCol; }
+        for (i=nFirstCol; i<=nLastCol && bOk; i++)
+            if (!pDoc->HasStringData( i,nStartRow,nTab ))
+                bOk = false;
+        if (bOk)
+            nFlags |= CreateNameFlags::Top;
+        else                            // Bottom only if not Top
+        {
+            bOk = true;
+            for (i=nFirstCol; i<=nLastCol && bOk; i++)
+                if (!pDoc->HasStringData( i,nEndRow,nTab ))
+                    bOk = false;
+            if (bOk)
+                nFlags |= CreateNameFlags::Bottom;
+        }
+
+        bOk = true;
+        SCROW nFirstRow = nStartRow;
+        SCROW nLastRow  = nEndRow;
+        if (nStartRow+1 < nEndRow) { ++nFirstRow; --nLastRow; }
+        for (j=nFirstRow; j<=nLastRow && bOk; j++)
+            if (!pDoc->HasStringData( nStartCol,j,nTab ))
+                bOk = false;
+        if (bOk)
+            nFlags |= CreateNameFlags::Left;
+        else                            // Right only if not Left
+        {
+            bOk = true;
+            for (j=nFirstRow; j<=nLastRow && bOk; j++)
+                if (!pDoc->HasStringData( nEndCol,j,nTab ))
+                    bOk = false;
+            if (bOk)
+                nFlags |= CreateNameFlags::Right;
+        }
+    }
+
+    if (nStartCol == nEndCol)
+        nFlags &= ~CreateNameFlags( CreateNameFlags::Left | CreateNameFlags::Right );
+    if (nStartRow == nEndRow)
+        nFlags &= ~CreateNameFlags( CreateNameFlags::Top | CreateNameFlags::Bottom );
+
+    return nFlags;
+}
+
+void ScViewFunc::InsertNameList()
+{
+    ScAddress aPos( GetViewData().GetCurX(), GetViewData().GetCurY(), GetViewData().GetTabNo() );
+    ScDocShell* pDocSh = GetViewData().GetDocShell();
+    if ( pDocSh->GetDocFunc().InsertNameList( aPos, false ) )
+        pDocSh->UpdateOle(&GetViewData());
+}
+
+void ScViewFunc::UpdateSelectionArea( const ScMarkData& rSel, ScPatternAttr* pAttr  )
+{
+    ScDocShell* pDocShell = GetViewData().GetDocShell();
+    ScRange aMarkRange;
+    if (rSel.IsMultiMarked() )
+        rSel.GetMultiMarkArea( aMarkRange );
+    else
+        rSel.GetMarkArea( aMarkRange );
+
+    bool bSetLines = false;
+    bool bSetAlign = false;
+    if ( pAttr )
+    {
+        const SfxItemSet& rNewSet = pAttr->GetItemSet();
+        bSetLines = rNewSet.GetItemState( ATTR_BORDER ) == SfxItemState::SET ||
+        rNewSet.GetItemState( ATTR_SHADOW ) == SfxItemState::SET;
+        bSetAlign = rNewSet.GetItemState( ATTR_HOR_JUSTIFY ) == SfxItemState::SET;
+    }
+
+    sal_uInt16 nExtFlags = 0;
+    if ( bSetLines )
+        nExtFlags |= SC_PF_LINES;
+    if ( bSetAlign )
+        nExtFlags |= SC_PF_WHOLEROWS;
+
+    SCCOL nStartCol = aMarkRange.aStart.Col();
+    SCROW nStartRow = aMarkRange.aStart.Row();
+    SCTAB nStartTab = aMarkRange.aStart.Tab();
+    SCCOL nEndCol = aMarkRange.aEnd.Col();
+    SCROW nEndRow = aMarkRange.aEnd.Row();
+    SCTAB nEndTab = aMarkRange.aEnd.Tab();
+    pDocShell->PostPaint( nStartCol, nStartRow, nStartTab,
+        nEndCol,   nEndRow,   nEndTab,
+        PaintPartFlags::Grid, nExtFlags | SC_PF_TESTMERGE );
+    ScTabViewShell* pTabViewShell = GetViewData().GetViewShell();
+    pTabViewShell->AdjustBlockHeight(false, const_cast<ScMarkData*>(&rSel));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */