/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */

/*

 * 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 <address.hxx>

#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/justifyitem.hxx>

#include <o3tl/unit_conversion.hxx>

#include <sfx2/bindings.hxx>

#include <svl/numformat.hxx>

#include <svl/zforlist.hxx>

#include <svl/zformat.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <vcl/weld/weld.hxx>

#include <vcl/virdev.hxx>

#include <stdlib.h>

#include <unotools/charclass.hxx>

#include <vcl/uitest/logger.hxx>

#include <vcl/uitest/eventdescription.hxx>

#include <vcl/weld/TextView.hxx>

#include <osl/diagnose.h>

#include <viewfunc.hxx>

#include <tabvwsh.hxx>

#include <docsh.hxx>

#include <attrib.hxx>

#include <patattr.hxx>

#include <sc.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 <stringutil.hxx>

#include <SparklineList.hxx>

#include <SheetViewManager.hxx>

#include <SheetViewOperationsTester.hxx>

#include <memory>

static void ShowFilteredRows(ScDocument& rDoc, SCTAB nTab, SCCOLROW nStartNo, SCCOLROW nEndNo,

                             bool bShow)

{

    SCROW nFirstRow = nStartNo;

    SCROW nLastRow = nStartNo;

    do

    {

        if (!rDoc.RowFiltered(nFirstRow, nTab, nullptr, &nLastRow))

            rDoc.ShowRows(nFirstRow, nLastRow < nEndNo ? nLastRow : nEndNo, nTab, bShow);

        nFirstRow = nLastRow + 1;

    } while (nFirstRow <= nEndNo);

}

static void lcl_PostRepaintCondFormat( const ScConditionalFormat *pCondFmt, ScDocShell *pDocSh )

{

    if( pCondFmt )

    {

        const ScRangeList& rRanges = pCondFmt->GetRange();

        pDocSh->PostPaint( rRanges, PaintPartFlags::All );

    }

}

static void lcl_PostRepaintSparkLine(sc::SparklineList* pSparklineList, const ScRange& rRange,

                                     ScDocShell* pDocSh)

{

    if (pSparklineList)

    {

        for (auto& rSparkLineGroup : pSparklineList->getSparklineGroups())

        {

            for (auto& rSparkline : pSparklineList->getSparklinesFor(rSparkLineGroup))

            {

                if (rSparkline->getInputRange().Contains(rRange))

                {

                    pDocSh->PostPaint(

                        ScRange(rSparkline->getColumn(), rSparkline->getRow(), rRange.aStart.Tab()),

                        PaintPartFlags::All, SC_PF_TESTMERGE);

                }

            }

        }

    }

}

ScViewFunc::ScViewFunc( vcl::Window* pParent, ScDocShell& rDocSh, ScTabViewShell* pViewShell ) :

    ScTabView( pParent, rDocSh, pViewShell ),

    bFormatValid( false )

{

}

ScViewFunc::~ScViewFunc()

{

}

bool ScViewFunc::CheckSheetViewProtection(sc::Operation eOperation)

{

    sc::SheetViewOperationsTester aSheetViewTester(&GetViewData());

    return aSheetViewTester.check(eOperation);

}

namespace

{

struct FormulaProcessingContext

{

    std::shared_ptr<ScAddress> aPos;

    std::shared_ptr<ScCompiler> aComp;

    std::shared_ptr<ScDocShellModificator> aModificator;

    std::shared_ptr<ScTokenArray> pArr;

    std::shared_ptr<ScTokenArray> pArrFirst;

    std::shared_ptr<EditTextObject> xTextObject;

    ScMarkData aMark;

    ScViewFunc& rViewFunc;

    OUString aCorrectedFormula;

    OUString aFormula;

    OUString aString;

    SCCOL nCol;

    SCROW nRow;

    SCTAB nTab;

    bool bMatrixExpand;

    bool bNumFmtChanged;

    bool bRecord;

    ScViewData& GetViewData() const

    {

        return rViewFunc.GetViewData();

    }

    ScDocFunc& GetDocFunc() const

    {

        return GetViewData().GetDocFunc();

    }

    ScDocument& GetDoc() const

    {

        return GetViewData().GetDocument();

    }

};

void collectUIInformation(std::map<OUString, OUString>&& aParameters, const OUString& rAction)

{

    EventDescription aDescription;

    aDescription.aID = "grid_window";

    aDescription.aAction = rAction;

    aDescription.aParameters = std::move(aParameters);

    aDescription.aParent = "MainWindow";

    aDescription.aKeyWord = "ScGridWinUIObject";

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

}

} // end anonymous namespace

void ScViewFunc::StartFormatArea()

{

    //  anything to do?

    if (!ScModule::get()->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 (!ScModule::get()->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.GetSheetLimits());

        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

void ScViewData::setupSizeDeviceProviderForColWidth(const ScSizeDeviceProvider& rProv, Fraction& rZoomX, Fraction& rZoomY, double& rPPTX, double &rPPTY)

{

    if (rProv.IsPrinter())

    {

        rPPTX = rProv.GetPPTX();

        rPPTY = rProv.GetPPTY();

        rZoomX = rZoomY = Fraction(1, 1);

    }

    else

    {

        rPPTX = GetPPTX();

        rPPTY = GetPPTY();

        rZoomX = GetZoomX();

        rZoomY = GetZoomY();

    }

}

sal_uInt16 ScViewFunc::GetOptimalColWidth(SCCOL nCol, SCTAB nTab, bool bFormula, const ScMarkData& rMark)

{

    ScDocShell* pDocSh = GetViewData().GetDocShell();

    ScDocument& rDoc = pDocSh->GetDocument();

    ScSizeDeviceProvider aProv(*pDocSh);

    Fraction aZoomX, aZoomY;

    double nPPTX, nPPTY;

    GetViewData().setupSizeDeviceProviderForColWidth(aProv, aZoomX, aZoomY, nPPTX, nPPTY);

    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& rDoc = GetViewData().GetDocument();

    ScMarkData& rMark = GetViewData().GetMarkData();

    if (rMark.IsMarked() || rMark.IsMultiMarked())

        bRet = rDoc.IsSelectionEditable( rMark, pOnlyNotBecauseOfMatrix );

    else

    {

        SCCOL nCol = GetViewData().GetCurX();

        SCROW nRow = GetViewData().GetCurY();

        SCTAB nTab = GetViewData().CurrentTabForData();

        bRet = rDoc.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, const ScMarkData& rMark,

                                         SCCOL nCol, SCROW nRow, const OUString& rType = u"cell-change"_ustr)

    {

        ScModelObj* pModelObj = rDocShell.GetModel();

        ScRangeList aChangeRanges;

        for (const auto& rTab : rMark)

            aChangeRanges.push_back( ScRange( nCol, nRow, rTab ) );

        if (getMustPropagateChangesModel(pModelObj))

            Notify(*pModelObj, aChangeRanges, rType);

        else

        {

            Notify(*pModelObj, aChangeRanges, isDataAreaInvalidateType(rType)

                    ? u"data-area-invalidate"_ustr : u"data-area-extend"_ustr);

        }

    }

}

namespace

{

class AutoCorrectQuery : public weld::MessageDialogController

{

private:

    std::unique_ptr<weld::TextView> m_xError;

public:

    AutoCorrectQuery(weld::Window* pParent, const OUString& rFormula)

        : weld::MessageDialogController(pParent, u"modules/scalc/ui/warnautocorrect.ui"_ustr, u"WarnAutoCorrect"_ustr, u"grid"_ustr)

        , m_xError(m_xBuilder->weld_text_view(u"error"_ustr))

    {

        m_xDialog->set_default_response(RET_YES);

        const int nMaxWidth = m_xError->get_approximate_digit_width() * 65;

        const int nMaxHeight = m_xError->get_height_rows(6);

        m_xError->set_size_request(nMaxWidth, nMaxHeight);

        m_xError->set_text(rFormula);

    }

};

void runAutoCorrectQueryAsync(const std::shared_ptr<FormulaProcessingContext>& context);

void performAutoFormatAndUpdate(std::u16string_view rString, const ScMarkData& rMark, SCCOL nCol,

                                SCROW nRow, SCTAB nTab, bool bNumFmtChanged, bool bRecord,

                                const std::shared_ptr<ScDocShellModificator>& pModificator,

                                ScViewFunc& rViewFunc)

{

    bool bAutoFormat = rViewFunc.TestFormatArea(nCol, nRow, nTab, bNumFmtChanged);

    if (bAutoFormat)

        rViewFunc.DoAutoAttributes(nCol, nRow, nTab, bNumFmtChanged);

    ScViewData& rViewData = rViewFunc.GetViewData();

    ScDocShell* pDocSh = rViewData.GetDocShell();

    pDocSh->UpdateOle(rViewData);

    const OUString aType(rString.empty() ? u"delete-content" : u"cell-change");

    HelperNotifyChanges::NotifyIfChangesListeners(*pDocSh, rMark, nCol, nRow, aType);

    if (bRecord)

    {

        ScDocFunc &rFunc = rViewData.GetDocFunc();

        rFunc.EndListAction();

    }

    pModificator->SetDocumentModified();

    ScDocument& rDoc = rViewData.GetDocument();

    lcl_PostRepaintCondFormat(rDoc.GetCondFormat(nCol, nRow, nTab), pDocSh);

    lcl_PostRepaintSparkLine(rDoc.GetSparklineList(nTab), ScRange(nCol, nRow, nTab), pDocSh);

}

void finalizeFormulaProcessing(const std::shared_ptr<FormulaProcessingContext>& context)

{

    // 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 = context->pArr->GetCodeError();

    if ( nError == FormulaError::NONE )

    {

        //  update list of recent functions with all functions that

        //  are not within parentheses

        ScModule* pScMod = ScModule::get();

        ScAppOptions aAppOpt = pScMod->GetAppOptions();

        bool bOptChanged = false;

        formula::FormulaToken** ppToken = context->pArr->GetArray();

        sal_uInt16 nTokens = context->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);

        }

        if (context->bMatrixExpand)

        {

            // If the outer function/operator returns an array/matrix then

            // enter a matrix formula. ScViewFunc::EnterMatrix() takes care

            // of selection/mark of the result dimensions or preselected

            // mark. If the user wanted less or a single cell then should

            // mark such prior to entering the formula.

            const formula::FormulaToken* pToken = context->pArr->LastRPNToken();

            if (pToken && (formula::FormulaCompiler::IsMatrixFunction( pToken->GetOpCode())

                        || pToken->IsInForceArray()))

            {

                // Discard this (still empty here) Undo action,

                // EnterMatrix() will create its own.

                if (context->bRecord)

                    context->GetDocFunc().EndListAction();

                // Use corrected formula string.

                context->rViewFunc.EnterMatrix( context->aFormula, context->GetDoc().GetGrammar());

                return;

            }

        }

    }

    ScFormulaCell aCell(context->GetDoc(), *context->aPos, std::move(*context->pArr), formula::FormulaGrammar::GRAM_DEFAULT, ScMatrixMode::NONE);

    SCTAB i;

    SvNumberFormatter* pFormatter = context->GetDoc().GetFormatTable();

    for (const auto& rTab : context->aMark)

    {

        i = rTab;

        context->aPos->SetTab( i );

        const sal_uInt32 nIndex = context->GetDoc().GetAttr(

                    context->nCol, context->nRow, i, ATTR_VALUE_FORMAT ).GetValue();

        const SvNumFormatType nType = pFormatter->GetType( nIndex);

        if (nType == SvNumFormatType::TEXT ||

                ((context->aString[0] == '+' || context->aString[0] == '-') && nError != FormulaError::NONE && context->aString == context->aFormula))

        {

            if ( context->xTextObject )

            {

                // A clone of context->xTextObject will be stored in the cell.

                context->GetDocFunc().SetEditCell(*(context->aPos), *context->xTextObject, true);

            }

            else

                context->GetDocFunc().SetStringCell(*(context->aPos), context->aFormula, true);

        }

        else

        {

            ScFormulaCell* pCell = new ScFormulaCell( aCell, context->GetDoc(), *(context->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(context->GetDoc().getCellAttributeHelper());

                aPattern.ItemSetPut(SfxUInt32Item(ATTR_VALUE_FORMAT, nFormat));

                ScMarkData aMark(context->GetDoc().GetSheetLimits());

                aMark.SelectTable( i, true);

                aMark.SetMarkArea( ScRange( *(context->aPos)));

                context->GetDocFunc().ApplyAttributes( aMark, aPattern, false);

                context->bNumFmtChanged = true;

            }

            context->GetDocFunc().SetFormulaCell(*(context->aPos), pCell, true);

        }

    }

    performAutoFormatAndUpdate(context->aString, context->aMark, context->nCol,

                               context->nRow, context->nTab, context->bNumFmtChanged,

                               context->bRecord, context->aModificator, context->rViewFunc);

}

void parseAndCorrectFormula(std::shared_ptr<FormulaProcessingContext> context)

{

    bool bAddEqual = false;

    context->pArr = context->aComp->CompileString(context->aFormula);

    bool bCorrected = context->aComp->IsCorrected();

    if (bCorrected) {

        context->pArrFirst = context->pArr;

        context->pArr = context->aComp->CompileString(context->aComp->GetCorrectedFormula());

    }

    if (context->pArr->GetCodeError() == FormulaError::NONE) {

        bAddEqual = true;

        context->aComp->CompileTokenArray();

        bCorrected |= context->aComp->IsCorrected();

    }

    if (bCorrected) {

        context->aCorrectedFormula = bAddEqual ? "=" + context->aComp->GetCorrectedFormula()

                                               : context->aComp->GetCorrectedFormula();

        if (context->aCorrectedFormula.getLength() == 1) {

            // empty formula, just '='

            if (context->pArrFirst)

                context->pArr = context->pArrFirst;

        }

        else

        {

            runAutoCorrectQueryAsync(context);

            return;

        }

    }

    finalizeFormulaProcessing(context);

}

void runAutoCorrectQueryAsync(const std::shared_ptr<FormulaProcessingContext>& context)

{

    auto aQueryBox = std::make_shared<AutoCorrectQuery>(context->GetViewData().GetDialogParent(), context->aCorrectedFormula);

    weld::DialogController::runAsync(aQueryBox, [context] (int nResult)

    {

        if (nResult == RET_YES) {

            context->aFormula = context->aCorrectedFormula;

            parseAndCorrectFormula(context);

        } else {

            if (context->pArrFirst)

                context->pArr = context->pArrFirst;

            finalizeFormulaProcessing(context);

        }

    });

}

} // end anonymous namespace

void ScViewFunc::EnterDataToCurrentCell(const OUString& rString, const EditTextObject* pData, bool bMatrixExpand)

{

    SCCOL nCol = GetViewData().GetCurX();

    SCROW nRow = GetViewData().GetCurY();

    SCTAB nTab = GetViewData().CurrentTabForData();

    EnterData(nCol, nRow, nTab, rString, pData, bMatrixExpand);

}

namespace

{

bool checkFormula(ScDocument& rDoc, SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString& rString)

{

    // do not check formula if it is a text cell

    sal_uInt32 format = rDoc.GetNumberFormat(nCol, nRow, nTab );

    SvNumberFormatter* pFormatter = rDoc.GetFormatTable();

    // a single '=' character is handled as string (needed for special filters)

    if ( pFormatter->GetType(format) != SvNumFormatType::TEXT && rString.getLength() > 1 )

    {

        if ( rString[0] == '=' )

        {

            // handle as formula

            return 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, u"" );

            // if the remaining part without the leading '+' or '-' character

            // is non-empty and not a number, handle as formula

            if ( aString.getLength() > 1 )

            {

                double fNumber = 0;

                if ( !pFormatter->IsNumberFormat( aString, format, fNumber ) )

                {

                    return true;

                }

            }

        }

    }

    return false;

}

void applyFormulaToCell(ScViewFunc& rViewFunc, SCCOL nCol, SCROW nRow, SCTAB nTab, OUString const& rString,

                        const EditTextObject* pData, const std::shared_ptr<ScDocShellModificator>& rModificator,

                        ScMarkData const& rMark, bool bMatrixExpand, bool bRecord, bool& rbNumFmtChanged)

{

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

    // formula, compile with autoCorrection

    auto xPosPtr = std::make_shared<ScAddress>(nCol, nRow, nTab);

    auto xCompPtr = std::make_shared<ScCompiler>(rDoc, *xPosPtr, rDoc.GetGrammar(), true, false);

    std::unique_ptr<EditTextObject> xTextObject(pData ? pData->Clone() : nullptr);

    //2do: enable/disable autoCorrection via calcoptions

    xCompPtr->SetAutoCorrection( true );

    if (rString[0] == '+' || rString[0] == '-')

    {

        xCompPtr->SetExtendedErrorDetection( ScCompiler::EXTENDED_ERROR_DETECTION_NAME_BREAK );

    }

    OUString aFormula(rString);

    FormulaProcessingContext context_instance{

        std::move(xPosPtr), std::move(xCompPtr),    rModificator, nullptr,

        nullptr,            std::move(xTextObject), rMark,        rViewFunc,

        OUString(),         aFormula,               rString,                 nCol,

        nRow,               nTab,                   bMatrixExpand,           rbNumFmtChanged,

        bRecord

    };

    parseAndCorrectFormula(std::make_shared<FormulaProcessingContext>(context_instance));

}

void applyText(ScViewFunc& rViewFunc, SCCOL nCol, SCROW nRow, SCTAB nTab, OUString const& rString, bool& rbNumFmtChanged)

{

    ScViewData& rViewData = rViewFunc.GetViewData();

    ScDocument& rDoc = rViewData.GetDocument();

    ScDocShell* pDocSh = rViewData.GetDocShell();

    ScFieldEditEngine& rEngine = rDoc.GetEditEngine();

    ScDocFunc& rFunc = rViewData.GetDocFunc();

    bool bNumFmtSet = false;

    const ScAddress aAddress(nCol, nRow, nTab);

    // tdf#104902 - handle embedded newline

    if (ScStringUtil::isMultiline(rString))

    {

        rEngine.SetTextCurrentDefaults(rString);

        rDoc.SetEditText(aAddress, rEngine.CreateTextObject());

        pDocSh->AdjustRowHeight(nRow, nRow, nTab);

    }

    else

    {

        rFunc.SetNormalString(bNumFmtSet, aAddress, rString, false);

    }

    if (bNumFmtSet)

    {

        /* FIXME: if set on any sheet results in changed only on

         * sheet nTab for TestFormatArea() and DoAutoAttributes() */

        rbNumFmtChanged = true;

    }

}

} // end anonymous namespace

//  input - undo OK

void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab,

                            const OUString& rString,

                            const EditTextObject* pData,

                            bool bMatrixExpand )

{

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

    ScMarkData aMark(GetViewData().GetMarkData());

    bool bRecord = rDoc.IsUndoEnabled();

    ScDocFunc &rFunc = GetViewData().GetDocFunc();

    std::shared_ptr<ScDocShellModificator> xModificator = std::make_shared<ScDocShellModificator>(*GetViewData().GetDocShell());

    if (!CheckSheetViewProtection(sc::Operation::EnterData))

        return;

    ScEditableTester aTester = ScEditableTester::CreateAndTestSelectedBlock(rDoc, nCol, nRow, nCol, nRow, aMark);

    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 = checkFormula(rDoc, nCol, nRow, nTab, rString);

    bool bNumFmtChanged = false;

    if (bFormula)

    {

        SCTAB nSelectedTab = aMark.GetFirstSelected();

        applyFormulaToCell(*this, nCol, nRow, nTab, rString, pData, xModificator, aMark, bMatrixExpand, bRecord, bNumFmtChanged);

        if (rDoc.IsSheetViewHolder(nSelectedTab))

            return;

        auto pManager = rDoc.GetSheetViewManager(nSelectedTab);

        for (auto const& pSheetView : pManager->getSheetViews())

        {

            if (!pSheetView)

                continue;

            SCTAB nSheetViewTab = pSheetView->getTableNumber();

            ScMarkData aSheetViewMark(rDoc.GetSheetLimits());

            aSheetViewMark.SelectTable(nSheetViewTab, false);

            ScRange aSheetViewRange(aMark.GetMarkArea());

            aSheetViewRange.aStart.SetTab(nSheetViewTab);

            aSheetViewRange.aEnd.SetTab(nSheetViewTab);

            aSheetViewMark.SetMarkArea(aSheetViewRange);

            applyFormulaToCell(*this, nCol, nRow, nSheetViewTab, rString, pData, xModificator, aSheetViewMark, bMatrixExpand, bRecord, bNumFmtChanged);

        }

    }

    else

    {

        sc::SheetViewID nSheetViewID = GetViewData().GetSheetViewID();

        for (const auto& rTab : aMark)

        {

            if (rDoc.IsSheetViewHolder(rTab))

                continue;

            auto pManager = rDoc.GetSheetViewManager(rTab);

            for (auto const& pSheetView : pManager->getSheetViews())

            {

                if (!pSheetView)

                    continue;

                SCTAB nSheetViewTab = pSheetView->getTableNumber();

                if (GetViewData().GetSheetViewID() == sc::DefaultSheetViewID)

                {

                    SCROW nUnsortedRow = nRow;

                    if (pManager->getSortOrder())

                        nUnsortedRow = pManager->getSortOrder()->unsort(nUnsortedRow);

                    applyText(*this, nCol, nUnsortedRow, nSheetViewTab, rString, bNumFmtChanged);

                }

                else if (GetViewData().GetSheetViewID() == pSheetView->getID())

                {

                    applyText(*this, nCol, nRow, nSheetViewTab, rString, bNumFmtChanged);

                }

                else

                {

                    // TODO - we need to update other sheet views as well, test case needed

                }

            }

            {

                SCROW nUnsortedRow = nRow;

                if (nSheetViewID != sc::DefaultSheetViewID)

                {

                    auto pSheetView = pManager->get(nSheetViewID);

                    if (pSheetView->getSortOrder())

                        nUnsortedRow = pSheetView->getSortOrder()->unsort(nUnsortedRow);

                    if (pManager->getSortOrder())

                        nUnsortedRow = pManager->getSortOrder()->resort(nUnsortedRow);

                }

                applyText(*this, nCol, nUnsortedRow, rTab, rString, bNumFmtChanged);

            }

        }

        performAutoFormatAndUpdate(rString, aMark, nCol, nRow, nTab, bNumFmtChanged, bRecord, xModificator, *this);

    }

}

// enter value in single cell (on nTab only)

void ScViewFunc::EnterValue( SCCOL nCol, SCROW nRow, SCTAB nTab, const double& rValue )

{

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

    ScDocShell* pDocSh = GetViewData().GetDocShell();

    if (!pDocSh)

        return;

    bool bUndo(rDoc.IsUndoEnabled());

    ScDocShellModificator aModificator( *pDocSh );

    ScEditableTester aTester = ScEditableTester::CreateAndTestBlock(rDoc, nTab, nCol, nRow, nCol, nRow);

    if (aTester.IsEditable())