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

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <sfx2/app.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <vcl/weld/weld.hxx>

#include <svx/dataaccessdescriptor.hxx>

#include <svx/svdpage.hxx>

#include <svx/svdoole2.hxx>

#include <com/sun/star/sdb/CommandType.hpp>

#include <unotools/charclass.hxx>

#include <comphelper/lok.hxx>

#include <osl/diagnose.h>

#include <dbdocfun.hxx>

#include <dbdata.hxx>

#include <undodat.hxx>

#include <docsh.hxx>

#include <docfunc.hxx>

#include <globstr.hrc>

#include <scresid.hxx>

#include <globalnames.hxx>

#include <tabvwsh.hxx>

#include <patattr.hxx>

#include <rangenam.hxx>

#include <olinetab.hxx>

#include <dpobject.hxx>

#include <dpsave.hxx>

#include <dociter.hxx>

#include <editable.hxx>

#include <attrib.hxx>

#include <drwlayer.hxx>

#include <dpshttab.hxx>

#include <hints.hxx>

#include <queryentry.hxx>

#include <markdata.hxx>

#include <progress.hxx>

#include <undosort.hxx>

#include <inputopt.hxx>

#include <scmod.hxx>

#include <chartlis.hxx>

#include <ChartTools.hxx>

#include <SheetViewOperationsTester.hxx>

#include <memory>

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

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

{

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

    return aSheetViewTester.check(eOperation);

}

bool ScDBDocFunc::AddDBTable(const OUString& rName, const ScRange& rRange, bool bHeader,

                             bool bRecord, bool bApi, const OUString& rStyleName)

{

    ScDocShellModificator aModificator(rDocShell);

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pDocColl = rDoc.GetDBCollection();

    if (bRecord && !rDoc.IsUndoEnabled())

        bRecord = false;

    if (rStyleName.isEmpty())

    {

        if (!bApi)

            rDocShell.ErrorMessage(STR_TABLE_ERR_ADD);

        return false;

    }

    std::unique_ptr<ScDBCollection> pUndoColl;

    if (bRecord)

        pUndoColl.reset(new ScDBCollection(*pDocColl));

    std::unique_ptr<ScDBData> pNew(new ScDBData(rName, rRange.aStart.Tab(), rRange.aStart.Col(),

                                                rRange.aStart.Row(), rRange.aEnd.Col(), rRange.aEnd.Row(),

                                                true, bHeader, false, u""_ustr, rStyleName));

    if (pNew)

    {

        pNew->SetAutoFilter(true);

        rDoc.ApplyFlagsTab(rRange.aStart.Col(), rRange.aStart.Row(), rRange.aEnd.Col(),

                           rRange.aStart.Row(), rRange.aStart.Tab(), ScMF::Auto);

    }

    bool bCompile = !rDoc.IsImportingXML();

    if (bCompile)

        rDoc.PreprocessDBDataUpdate();

    bool bOk = pDocColl->getNamedDBs().insert(std::move(pNew));

    if (bCompile)

        rDoc.CompileHybridFormula();

    if (!bOk && !bApi)

    {

        rDocShell.ErrorMessage(STR_TABLE_ERR_ADD);

        return false;

    }

    rDocShell.PostPaint(rRange, PaintPartFlags::Grid | PaintPartFlags::Left | PaintPartFlags::Top | PaintPartFlags::Size);

    if (bRecord)

    {

        rDocShell.GetUndoManager()->AddUndoAction(

            std::make_unique<ScUndoDBTable>(rDocShell, rName, true/*bInsert*/, std::move(pUndoColl),

                                           std::make_unique<ScDBCollection>(*pDocColl)));

    }

    aModificator.SetDocumentModified();

    SfxGetpApp()->Broadcast(SfxHint(SfxHintId::ScDbAreasChanged));

    return true;

}

bool ScDBDocFunc::DeleteDBTable(const ScDBData* pDBObj, bool bRecord, bool bApi)

{

    bool bDone = false;

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pDocColl = rDoc.GetDBCollection();

    if (bRecord && !rDoc.IsUndoEnabled())

        bRecord = false;

    ScDBCollection::NamedDBs& rDBs = pDocColl->getNamedDBs();

    auto const iter = rDBs.findByPointer(pDBObj);

    if (iter != rDBs.end())

    {

        ScDocShellModificator aModificator(rDocShell);

        std::unique_ptr<ScDBCollection> pUndoColl;

        if (bRecord)

            pUndoColl.reset(new ScDBCollection(*pDocColl));

        OUString aTableName = iter->get()->GetName();

        ScRange aRange;

        iter->get()->GetArea(aRange);

        rDoc.PreprocessDBDataUpdate();

        rDBs.erase(iter);

        rDoc.CompileHybridFormula();

        if (aRange.IsValid())

        {

            rDoc.RemoveFlagsTab(aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Col(),

                                aRange.aStart.Row(), aRange.aStart.Tab(), ScMF::Auto);

            rDocShell.PostPaint(aRange, PaintPartFlags::Grid | PaintPartFlags::Left

                                            | PaintPartFlags::Top | PaintPartFlags::Size);

        }

        if (bRecord)

        {

            rDocShell.GetUndoManager()->AddUndoAction(

                std::make_unique<ScUndoDBTable>(rDocShell, aTableName, false/*bInsert*/, std::move(pUndoColl),

                                                std::make_unique<ScDBCollection>(*pDocColl)));

        }

        aModificator.SetDocumentModified();

        SfxGetpApp()->Broadcast(SfxHint(SfxHintId::ScDbAreasChanged));

        bDone = true;

    }

    else if (!bApi)

    {

        rDocShell.ErrorMessage(STR_TABLE_ERR_DEL);

    }

    return bDone;

}

bool ScDBDocFunc::AddDBRange( const OUString& rName, const ScRange& rRange )

{

    ScDocShellModificator aModificator( rDocShell );

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pDocColl = rDoc.GetDBCollection();

    bool bUndo (rDoc.IsUndoEnabled());

    std::unique_ptr<ScDBCollection> pUndoColl;

    if (bUndo)

        pUndoColl.reset( new ScDBCollection( *pDocColl ) );

    std::unique_ptr<ScDBData> pNew(new ScDBData( rName, rRange.aStart.Tab(),

                                    rRange.aStart.Col(), rRange.aStart.Row(),

                                    rRange.aEnd.Col(), rRange.aEnd.Row() ));

    // #i55926# While loading XML, formula cells only have a single string token,

    // so CompileDBFormula would never find any name (index) tokens, and would

    // unnecessarily loop through all cells.

    bool bCompile = !rDoc.IsImportingXML();

    bool bOk;

    if ( bCompile )

        rDoc.PreprocessDBDataUpdate();

    if ( rName == STR_DB_LOCAL_NONAME )

    {

        rDoc.SetAnonymousDBData(rRange.aStart.Tab(), std::move(pNew));

        bOk = true;

    }

    else

    {

        bOk = pDocColl->getNamedDBs().insert(std::move(pNew));

    }

    if ( bCompile )

        rDoc.CompileHybridFormula();

    if (!bOk)

    {

        return false;

    }

    if (bUndo)

    {

        rDocShell.GetUndoManager()->AddUndoAction(

                        std::make_unique<ScUndoDBData>( rDocShell, rName, std::move(pUndoColl),

                            rName, std::make_unique<ScDBCollection>( *pDocColl ) ) );

    }

    aModificator.SetDocumentModified();

    SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScDbAreasChanged ) );

    return true;

}

bool ScDBDocFunc::DeleteDBRange(const OUString& rName)

{

    bool bDone = false;

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pDocColl = rDoc.GetDBCollection();

    bool bUndo = rDoc.IsUndoEnabled();

    ScDBCollection::NamedDBs& rDBs = pDocColl->getNamedDBs();

    auto const iter = rDBs.findByUpperName2(ScGlobal::getCharClass().uppercase(rName));

    if (iter != rDBs.end())

    {

        ScDocShellModificator aModificator( rDocShell );

        std::unique_ptr<ScDBCollection> pUndoColl;

        if (bUndo)

            pUndoColl.reset( new ScDBCollection( *pDocColl ) );

        ScRange aRange;

        iter->get()->GetArea(aRange);

        rDoc.PreprocessDBDataUpdate();

        rDBs.erase(iter);

        rDoc.CompileHybridFormula();

        if (bUndo)

        {

            rDocShell.GetUndoManager()->AddUndoAction(

                            std::make_unique<ScUndoDBData>( rDocShell, rName, std::move(pUndoColl),

                                rName, std::make_unique<ScDBCollection>( *pDocColl ) ) );

        }

        aModificator.SetDocumentModified();

        SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScDbAreasChanged ) );

        bDone = true;

    }

    return bDone;

}

bool ScDBDocFunc::RenameDBRange( const OUString& rOld, const OUString& rNew )

{

    bool bDone = false;

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pDocColl = rDoc.GetDBCollection();

    bool bUndo = rDoc.IsUndoEnabled();

    ScDBCollection::NamedDBs& rDBs = pDocColl->getNamedDBs();

    auto const iterOld = rDBs.findByUpperName2(ScGlobal::getCharClass().uppercase(rOld));

    const ScDBData* pNew = rDBs.findByUpperName(ScGlobal::getCharClass().uppercase(rNew));

    if (iterOld != rDBs.end() && !pNew)

    {

        ScDocShellModificator aModificator( rDocShell );

        std::unique_ptr<ScDBData> pNewData(new ScDBData(rNew, **iterOld));

        OUString aUndoName = rOld;

        std::unique_ptr<ScDBCollection> pUndoColl( new ScDBCollection( *pDocColl ) );

        rDoc.PreprocessDBDataUpdate();

        rDBs.erase(iterOld);

        bool bInserted = rDBs.insert(std::move(pNewData));

        if (!bInserted)                             // error -> restore old state

        {

            rDoc.SetDBCollection(std::move(pUndoColl));       // belongs to the document then

        }

        rDoc.CompileHybridFormula();

        if (bInserted)                              // insertion worked

        {

            if (bUndo)

            {

                rDocShell.GetUndoManager()->AddUndoAction(

                                std::make_unique<ScUndoDBData>( rDocShell, aUndoName, std::move(pUndoColl),

                                    rNew, std::make_unique<ScDBCollection>( *pDocColl ) ) );

            }

            else

                pUndoColl.reset();

            aModificator.SetDocumentModified();

            SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScDbAreasChanged ) );

            bDone = true;

        }

    }

    return bDone;

}

void ScDBDocFunc::ModifyDBData( const ScDBData& rNewData )

{

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pDocColl = rDoc.GetDBCollection();

    bool bUndo = rDoc.IsUndoEnabled();

    ScDBData* pData = nullptr;

    if (rNewData.GetName() == STR_DB_LOCAL_NONAME)

    {

        ScRange aRange;

        rNewData.GetArea(aRange);

        SCTAB nTab = aRange.aStart.Tab();

        pData = rDoc.GetAnonymousDBData(nTab);

    }

    else

        pData = pDocColl->getNamedDBs().findByUpperName(rNewData.GetUpperName());

    if (!pData)

        return;

    ScDocShellModificator aModificator( rDocShell );

    ScRange aOldRange, aNewRange;

    pData->GetArea(aOldRange);

    rNewData.GetArea(aNewRange);

    bool bAreaChanged = ( aOldRange != aNewRange );     // then a recompilation is needed

    bool bOldAutoFilter = pData->HasAutoFilter();

    bool bNewAutoFilter = rNewData.HasAutoFilter();

    std::unique_ptr<ScDBCollection> pUndoColl;

    OUString sOldName;

    if (bUndo)

    {

        pUndoColl.reset( new ScDBCollection( *pDocColl ) );

        sOldName = pData->GetName();

    }

    *pData = rNewData;

    if (bAreaChanged || bOldAutoFilter != bNewAutoFilter) {

        if (bAreaChanged)

            rDoc.CompileDBFormula();

        if (bOldAutoFilter && !bNewAutoFilter)

        {

            rDoc.RemoveFlagsTab(aOldRange.aStart.Col(), aOldRange.aStart.Row(), aOldRange.aEnd.Col(), aOldRange.aEnd.Row(), aOldRange.aStart.Tab(), ScMF::Auto);

        }

        else if (bOldAutoFilter && bNewAutoFilter)

        {

            rDoc.RemoveFlagsTab(aOldRange.aStart.Col(), aOldRange.aStart.Row(), aOldRange.aEnd.Col(), aOldRange.aEnd.Row(), aOldRange.aStart.Tab(), ScMF::Auto);

            rDoc.ApplyFlagsTab(aNewRange.aStart.Col(), aNewRange.aStart.Row(), aNewRange.aEnd.Col(), aNewRange.aStart.Row(), aNewRange.aStart.Tab(), ScMF::Auto);

        }

        else if (!bOldAutoFilter && bNewAutoFilter)

        {

            rDoc.ApplyFlagsTab(aNewRange.aStart.Col(), aNewRange.aStart.Row(), aNewRange.aEnd.Col(), aNewRange.aStart.Row(), aNewRange.aStart.Tab(), ScMF::Auto);

        }

    }

    rDocShell.PostPaint(ScRange(0, 0, aOldRange.aStart.Tab(), rDoc.MaxCol(), rDoc.MaxRow(), aOldRange.aEnd.Tab()),

        PaintPartFlags::Grid | PaintPartFlags::Left | PaintPartFlags::Top | PaintPartFlags::Size);

    if (bUndo)

    {

        rDocShell.GetUndoManager()->AddUndoAction(

                        std::make_unique<ScUndoDBData>( rDocShell, sOldName, std::move(pUndoColl),

                            rNewData.GetName(), std::make_unique<ScDBCollection>( *pDocColl ) ) );

    }

    aModificator.SetDocumentModified();

}

void ScDBDocFunc::ModifyAllDBData( const ScDBCollection& rNewColl, const std::vector<ScRange>& rDelAreaList )

{

    ScDocShellModificator aModificator(rDocShell);

    ScDocument& rDoc = rDocShell.GetDocument();

    ScDBCollection* pOldColl = rDoc.GetDBCollection();

    std::unique_ptr<ScDBCollection> pUndoColl;

    bool bRecord = rDoc.IsUndoEnabled();

    for (const auto& rDelArea : rDelAreaList)

    {

        // unregistering target in SBA no longer necessary

        const ScAddress& rStart = rDelArea.aStart;

        const ScAddress& rEnd   = rDelArea.aEnd;

        rDocShell.DBAreaDeleted(

            rStart.Tab(), rStart.Col(), rStart.Row(), rEnd.Col());

    }

    if (bRecord)

        pUndoColl.reset( new ScDBCollection( *pOldColl ) );

    //  register target in SBA no longer necessary

    rDoc.PreprocessDBDataUpdate();

    rDoc.SetDBCollection( std::unique_ptr<ScDBCollection>(new ScDBCollection( rNewColl )) );

    rDoc.CompileHybridFormula();

    pOldColl = nullptr;

    rDocShell.PostPaint(ScRange(0, 0, 0, rDoc.MaxCol(), rDoc.MaxRow(), MAXTAB), PaintPartFlags::Grid);

    aModificator.SetDocumentModified();

    SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScDbAreasChanged ) );

    if (bRecord)

    {

        rDocShell.GetUndoManager()->AddUndoAction(

            std::make_unique<ScUndoDBData>(rDocShell, u""_ustr, std::move(pUndoColl),

                 u""_ustr, std::make_unique<ScDBCollection>(rNewColl)));

    }

}

bool ScDBDocFunc::RepeatDB( const OUString& rDBName, bool bApi, bool bIsUnnamed, SCTAB aTab )

{

    //! use also for ScDBFunc::RepeatDB !

    bool bDone = false;

    ScDocument& rDoc = rDocShell.GetDocument();

    bool bRecord = true;

    if (!rDoc.IsUndoEnabled())

        bRecord = false;

    ScDBData* pDBData = nullptr;

    if (bIsUnnamed)

    {

        pDBData = rDoc.GetAnonymousDBData( aTab );

    }

    else

    {

        ScDBCollection* pColl = rDoc.GetDBCollection();

        if (pColl)

            pDBData = pColl->getNamedDBs().findByUpperName(ScGlobal::getCharClass().uppercase(rDBName));

    }

    if ( pDBData )

    {

        ScQueryParam aQueryParam;

        pDBData->GetQueryParam( aQueryParam );

        bool bQuery = aQueryParam.GetEntry(0).bDoQuery;

        ScSortParam aSortParam;

        pDBData->GetSortParam( aSortParam );

        bool bSort = aSortParam.maKeyState[0].bDoSort;

        ScSubTotalParam aSubTotalParam;

        pDBData->GetSubTotalParam( aSubTotalParam );

        bool bSubTotal = aSubTotalParam.aGroups[0].bActive && !aSubTotalParam.bRemoveOnly;

        if ( bQuery || bSort || bSubTotal )

        {

            bool bQuerySize = false;

            ScRange aOldQuery;

            ScRange aNewQuery;

            if (bQuery && !aQueryParam.bInplace)

            {

                ScDBData* pDest = rDoc.GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,

                                                        aQueryParam.nDestTab, ScDBDataPortion::TOP_LEFT );

                if (pDest && pDest->IsDoSize())

                {

                    pDest->GetArea( aOldQuery );

                    bQuerySize = true;

                }

            }

            SCTAB nTab;

            SCCOL nStartCol;

            SCROW nStartRow;

            SCCOL nEndCol;

            SCROW nEndRow;

            pDBData->GetArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow );

            //!     Undo needed data only ?

            ScDocumentUniquePtr pUndoDoc;

            std::unique_ptr<ScOutlineTable> pUndoTab;

            std::unique_ptr<ScRangeName> pUndoRange;

            std::unique_ptr<ScDBCollection> pUndoDB;

            if (bRecord)

            {

                SCTAB nTabCount = rDoc.GetTableCount();

                pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));

                ScOutlineTable* pTable = rDoc.GetOutlineTable( nTab );

                if (pTable)

                {

                    pUndoTab.reset(new ScOutlineTable( *pTable ));

                    // column/row state

                    SCCOLROW nOutStartCol, nOutEndCol;

                    SCCOLROW nOutStartRow, nOutEndRow;

                    pTable->GetColArray().GetRange( nOutStartCol, nOutEndCol );

                    pTable->GetRowArray().GetRange( nOutStartRow, nOutEndRow );

                    pUndoDoc->InitUndo( rDoc, nTab, nTab, true, true );

                    rDoc.CopyToDocument(static_cast<SCCOL>(nOutStartCol), 0,

                                        nTab, static_cast<SCCOL>(nOutEndCol), rDoc.MaxRow(), nTab,

                                        InsertDeleteFlags::NONE, false, *pUndoDoc);

                    rDoc.CopyToDocument(0, static_cast<SCROW>(nOutStartRow),

                                        nTab, rDoc.MaxCol(), static_cast<SCROW>(nOutEndRow), nTab,

                                        InsertDeleteFlags::NONE, false, *pUndoDoc);

                }

                else

                    pUndoDoc->InitUndo( rDoc, nTab, nTab, false, true );

                //  secure data range - incl. filtering result

                rDoc.CopyToDocument(0, nStartRow, nTab, rDoc.MaxCol(), nEndRow, nTab, InsertDeleteFlags::ALL, false, *pUndoDoc);

                //  all formulas because of references

                rDoc.CopyToDocument(0, 0, 0, rDoc.MaxCol(), rDoc.MaxRow(), nTabCount-1, InsertDeleteFlags::FORMULA, false, *pUndoDoc);

                //  ranges of DB and other

                ScRangeName* pDocRange = rDoc.GetRangeName();

                if (!pDocRange->empty())

                    pUndoRange.reset(new ScRangeName( *pDocRange ));

                ScDBCollection* pDocDB = rDoc.GetDBCollection();

                if (!pDocDB->empty())

                    pUndoDB.reset(new ScDBCollection( *pDocDB ));

            }

            if (bSort && bSubTotal)

            {

                //  sort without SubTotals

                aSubTotalParam.bRemoveOnly = true;      // will be reset again further down

                DoSubTotals( nTab, aSubTotalParam, false, bApi );

            }

            if (bSort)

            {

                pDBData->GetSortParam( aSortParam );            // range may have changed

                (void)Sort( nTab, aSortParam, false, false, bApi );

            }

            if (bQuery)

            {

                pDBData->GetQueryParam( aQueryParam );          // range may have changed

                ScRange aAdvSource;

                if (pDBData->GetAdvancedQuerySource(aAdvSource))

                    Query( nTab, aQueryParam, &aAdvSource, false, bApi );

                else

                    Query( nTab, aQueryParam, nullptr, false, bApi );

                //  at not-inplace the table may have been converted

//              if ( !aQueryParam.bInplace && aQueryParam.nDestTab != nTab )

//                  SetTabNo( nTab );

            }

            if (bSubTotal)

            {

                pDBData->GetSubTotalParam( aSubTotalParam );    // range may have changed

                aSubTotalParam.bRemoveOnly = false;

                DoSubTotals( nTab, aSubTotalParam, false, bApi );

            }

            if (bRecord)

            {

                SCTAB nDummyTab;

                SCCOL nDummyCol;

                SCROW nDummyRow;

                SCROW nNewEndRow;

                pDBData->GetArea( nDummyTab, nDummyCol,nDummyRow, nDummyCol,nNewEndRow );

                const ScRange* pOld = nullptr;

                const ScRange* pNew = nullptr;

                if (bQuerySize)

                {

                    ScDBData* pDest = rDoc.GetDBAtCursor( aQueryParam.nDestCol, aQueryParam.nDestRow,

                                                            aQueryParam.nDestTab, ScDBDataPortion::TOP_LEFT );

                    if (pDest)

                    {

                        pDest->GetArea( aNewQuery );

                        pOld = &aOldQuery;

                        pNew = &aNewQuery;

                    }

                }

                rDocShell.GetUndoManager()->AddUndoAction(

                    std::make_unique<ScUndoRepeatDB>( rDocShell, nTab,

                                            nStartCol, nStartRow, nEndCol, nEndRow,

                                            nNewEndRow,

                                            //nCurX, nCurY,

                                            nStartCol, nStartRow,

                                            std::move(pUndoDoc), std::move(pUndoTab),

                                            std::move(pUndoRange), std::move(pUndoDB),

                                            pOld, pNew ) );

            }

            rDocShell.PostPaint(ScRange(0, 0, nTab, rDoc.MaxCol(), rDoc.MaxRow(), nTab),

                                PaintPartFlags::Grid | PaintPartFlags::Left | PaintPartFlags::Top | PaintPartFlags::Size);

            bDone = true;

        }

        else if (!bApi)     // "Don't execute any operations"

            rDocShell.ErrorMessage(STR_MSSG_REPEATDB_0);

    }

    return bDone;

}

bool ScDBDocFunc::Sort( SCTAB nTab, const ScSortParam& rSortParam,

                            bool bRecord, bool bPaint, bool bApi )

{

    ScDocShellModificator aModificator( rDocShell );

    ScDocument& rDoc = rDocShell.GetDocument();

    if (bRecord && !rDoc.IsUndoEnabled())

        bRecord = false;

    ScDBData* pDBData = rDoc.GetDBAtArea( nTab, rSortParam.nCol1, rSortParam.nRow1,

                                                    rSortParam.nCol2, rSortParam.nRow2 );

    if (!pDBData)

    {

        OSL_FAIL( "Sort: no DBData" );

        return false;

    }

    bool bCopy = !rSortParam.bInplace;

    if ( bCopy && rSortParam.nDestCol == rSortParam.nCol1 &&

                  rSortParam.nDestRow == rSortParam.nRow1 && rSortParam.nDestTab == nTab )

        bCopy = false;

    ScSortParam aLocalParam( rSortParam );

    if ( bCopy )

    {

        // Copy the data range to the destination then move the sort range to it.

        ScRange aSrcRange(rSortParam.nCol1, rSortParam.nRow1, nTab, rSortParam.nCol2, rSortParam.nRow2, nTab);

        ScAddress aDestPos(rSortParam.nDestCol,rSortParam.nDestRow,rSortParam.nDestTab);

        ScDocFunc& rDocFunc = rDocShell.GetDocFunc();

        bool bRet = rDocFunc.MoveBlock(aSrcRange, aDestPos, false, bRecord, bPaint, bApi);

        if (!bRet)

            return false;

        aLocalParam.MoveToDest();

        nTab = aLocalParam.nDestTab;

    }

    // tdf#119804: If there is a header row/column, it won't be affected by

    // sorting; so we can exclude it from the test.

    SCROW nStartingRowToEdit = aLocalParam.nRow1;

    SCCOL nStartingColToEdit = aLocalParam.nCol1;

    if ( aLocalParam.bHasHeader )

    {

        if ( aLocalParam.bByRow )

            nStartingRowToEdit++;

        else

            nStartingColToEdit++;

    }

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

        return false;

    ScEditableTester aTester = ScEditableTester::CreateAndTestBlock(

            rDoc, nTab, nStartingColToEdit, nStartingRowToEdit,

            aLocalParam.nCol2, aLocalParam.nRow2, true /*bNoMatrixAtAll*/);

    if (!aTester.IsEditable())

    {

        if (!bApi)

            rDocShell.ErrorMessage(aTester.GetMessageId());

        return false;

    }

    const ScInputOptions aInputOption = ScModule::get()->GetInputOptions();

    const bool bUpdateRefs = aInputOption.GetSortRefUpdate();

    // Adjust aLocalParam cols/rows to used data area. Keep sticky top row or

    // column (depending on direction) in any case, not just if it has headers,

    // so empty leading cells will be sorted to the end.

    // aLocalParam.nCol/Row will encompass data content only, extras in

    // aLocalParam.aDataAreaExtras.

    bool bShrunk = false;

    aLocalParam.aDataAreaExtras.resetArea();

    rDoc.ShrinkToUsedDataArea(bShrunk, nTab, aLocalParam.nCol1, aLocalParam.nRow1,

                              aLocalParam.nCol2, aLocalParam.nRow2, false, aLocalParam.bByRow,

                              !aLocalParam.bByRow,

                              (aLocalParam.aDataAreaExtras.anyExtrasWanted() ?

                               &aLocalParam.aDataAreaExtras : nullptr));

    SCROW nStartRow = aLocalParam.nRow1;

    if (aLocalParam.bByRow && aLocalParam.bHasHeader && nStartRow < aLocalParam.nRow2)

        ++nStartRow;

    SCCOL nOverallCol1 = aLocalParam.nCol1;

    SCROW nOverallRow1 = aLocalParam.nRow1;

    SCCOL nOverallCol2 = aLocalParam.nCol2;

    SCROW nOverallRow2 = aLocalParam.nRow2;

    if (aLocalParam.aDataAreaExtras.anyExtrasWanted())

    {

        // Trailing empty excess columns/rows are excluded from being sorted,

        // they stick at the end. Clip them.

        const ScDataAreaExtras::Clip eClip = (aLocalParam.bByRow ?

                ScDataAreaExtras::Clip::Row : ScDataAreaExtras::Clip::Col);

        aLocalParam.aDataAreaExtras.GetOverallRange( nOverallCol1, nOverallRow1, nOverallCol2, nOverallRow2, eClip);

        // Make it permanent.

        aLocalParam.aDataAreaExtras.SetOverallRange( nOverallCol1, nOverallRow1, nOverallCol2, nOverallRow2);

        if (bUpdateRefs)

        {

            // With update references the entire range needs to be handled as

            // one entity for references pointing within to be moved along,

            // even when there's no data content. For huge ranges we may be

            // DOOMed then.

            aLocalParam.nCol1 = nOverallCol1;

            aLocalParam.nRow1 = nOverallRow1;

            aLocalParam.nCol2 = nOverallCol2;

            aLocalParam.nRow2 = nOverallRow2;

        }

    }

    if (aLocalParam.aDataAreaExtras.mbCellFormats

            && rDoc.HasAttrib( nOverallCol1, nStartRow, nTab, nOverallCol2, nOverallRow2, nTab,

                HasAttrFlags::Merged | HasAttrFlags::Overlapped))

    {

        // Merge attributes would be mixed up during sorting.

        if (!bApi)

            rDocShell.ErrorMessage(STR_SORT_ERR_MERGED);

        return false;

    }

    //      execute

    weld::WaitObject aWait( ScDocShell::GetActiveDialogParent() );

    // Calculate the script types for all cells in the sort range beforehand.

    // This will speed up the row height adjustment that takes place after the

    // sort.

    rDoc.UpdateScriptTypes(

        ScAddress(aLocalParam.nCol1,nStartRow,nTab),

        aLocalParam.nCol2-aLocalParam.nCol1+1,

        aLocalParam.nRow2-nStartRow+1);

    // No point adjusting row heights after the sort when all rows have the same height.

    bool bUniformRowHeight = rDoc.HasUniformRowHeight(nTab, nStartRow, nOverallRow2);

    bool bRepeatQuery = false;                          // repeat existing filter?

    ScQueryParam aQueryParam;

    pDBData->GetQueryParam( aQueryParam );

    if ( aQueryParam.GetEntry(0).bDoQuery )

        bRepeatQuery = true;

    sc::ReorderParam aUndoParam;

    // don't call ScDocument::Sort with an empty SortParam (may be empty here if bCopy is set),

    // but always call it for random shuffle which doesn't need sort keys

    if (aLocalParam.meSortOrderType == SortOrderType::Random

        || (aLocalParam.GetSortKeyCount() && aLocalParam.maKeyState[0].bDoSort))

    {

        ScProgress aProgress(&rDocShell, ScResId(STR_PROGRESS_SORTING), 0, true);

        if (!bRepeatQuery)

            bRepeatQuery = rDoc.HasHiddenRows(aLocalParam.nRow1, aLocalParam.nRow2, nTab);

        rDoc.Sort(nTab, aLocalParam, bRepeatQuery, bUpdateRefs, &aProgress, &aUndoParam);

    }

    if (bRecord)

    {

        // Set up an undo object.

        rDocShell.GetUndoManager()->AddUndoAction(

            std::make_unique<sc::UndoSort>(rDocShell, aUndoParam));

    }

    ScSortParam aSortParamData(rSortParam);

    aSortParamData.meSortOrderType = SortOrderType::Ordered;

    pDBData->SetSortParam(aSortParamData);

    // Remember additional settings on anonymous database ranges.

    if (pDBData == rDoc.GetAnonymousDBData( nTab) || rDoc.GetDBCollection()->getAnonDBs().has( pDBData))

        pDBData->UpdateFromSortParam(aSortParamData);

    if (SfxViewShell* pKitSomeViewForThisDoc = comphelper::LibreOfficeKit::isActive() ?

                                               rDocShell.GetBestViewShell(false) : nullptr)

    {

        SfxViewShell* pViewShell = SfxViewShell::GetFirst();

        while (pViewShell)

        {

            ScTabViewShell* pTabViewShell = dynamic_cast<ScTabViewShell*>(pViewShell);

            if (pTabViewShell && pTabViewShell->GetDocId() == pKitSomeViewForThisDoc->GetDocId())

            {

                if (ScPositionHelper* pPosHelper = pTabViewShell->GetViewData().GetLOKHeightHelper(nTab))

                    pPosHelper->invalidateByIndex(nStartRow);

            }

            pViewShell = SfxViewShell::GetNext(*pViewShell);

        }

        ScTabViewShell::notifyAllViewsSheetGeomInvalidation(

            pKitSomeViewForThisDoc, false /* bColumns */, true /* bRows */, true /* bSizes*/,

            true /* bHidden */, true /* bFiltered */, true /* bGroups */, nTab);

    }

    if (nStartRow <= aLocalParam.nRow2)

    {

        ScRange aDirtyRange(

                aLocalParam.nCol1, nStartRow, nTab,

                aLocalParam.nCol2, aLocalParam.nRow2, nTab);

        rDoc.SetDirty( aDirtyRange, true );

    }

    if (bPaint)

    {

        PaintPartFlags nPaint = PaintPartFlags::Grid;

        SCCOL nStartX = nOverallCol1;

        SCROW nStartY = nOverallRow1;

        SCCOL nEndX = nOverallCol2;

        SCROW nEndY = nOverallRow2;

        if ( bRepeatQuery )

        {

            nPaint |= PaintPartFlags::Left;

            nStartX = 0;

            nEndX = rDoc.MaxCol();

        }

        rDocShell.PostPaint(ScRange(nStartX, nStartY, nTab, nEndX, nEndY, nTab), nPaint);

    }

    if (!bUniformRowHeight && nStartRow <= nOverallRow2)

        rDocShell.AdjustRowHeight(nStartRow, nOverallRow2, nTab);

    aModificator.SetDocumentModified();

    return true;

}

bool ScDBDocFunc::Query( SCTAB nTab, const ScQueryParam& rQueryParam,

                        const ScRange* pAdvSource, bool bRecord, bool bApi )

{

    ScDocShellModificator aModificator( rDocShell );

    ScDocument& rDoc = rDocShell.GetDocument();

    ScTabViewShell* pViewSh = rDocShell.GetBestViewShell();

    if (pViewSh && ScTabViewShell::isAnyEditViewInRange(pViewSh, /*bColumns*/ false, rQueryParam.nRow1, rQueryParam.nRow2))

    {

        return false;

    }

    if (bRecord && !rDoc.IsUndoEnabled())

        bRecord = false;

    ScDBData* pDBData = rDoc.GetDBAtArea( nTab, rQueryParam.nCol1, rQueryParam.nRow1,

                                                    rQueryParam.nCol2, rQueryParam.nRow2 );

    if (!pDBData)

    {

        OSL_FAIL( "Query: no DBData" );

        return false;

    }

    //  Change from Inplace to non-Inplace, only then cancel Inplace:

    //  (only if "Persistent"  is selected in the dialog)

    if ( !rQueryParam.bInplace && pDBData->HasQueryParam() && rQueryParam.bDestPers )

    {

        ScQueryParam aOldQuery;

        pDBData->GetQueryParam(aOldQuery);

        if (aOldQuery.bInplace)

        {

            //  cancel old filtering

            SCSIZE nEC = aOldQuery.GetEntryCount();

            for (SCSIZE i=0; i<nEC; i++)

                aOldQuery.GetEntry(i).bDoQuery = false;

            aOldQuery.bDuplicate = true;

            Query( nTab, aOldQuery, nullptr, bRecord, bApi );

        }

    }

    ScQueryParam aLocalParam( rQueryParam );        // for Paint / destination range

    bool bCopy = !rQueryParam.bInplace;             // copied in Table::Query

    ScDBData* pDestData = nullptr;                  // range to be copied to

    bool bDoSize = false;                           // adjust destination size (insert/delete)

    SCCOL nFormulaCols = 0;                         // only at bDoSize

    bool bKeepFmt = false;

    ScRange aOldDest;

    ScRange aDestTotal;

    if ( bCopy && rQueryParam.nDestCol == rQueryParam.nCol1 &&

                  rQueryParam.nDestRow == rQueryParam.nRow1 && rQueryParam.nDestTab == nTab )

        bCopy = false;

    SCTAB nDestTab = nTab;

    if ( bCopy )

    {

        aLocalParam.MoveToDest();

        nDestTab = rQueryParam.nDestTab;

        if ( !rDoc.ValidColRow( aLocalParam.nCol2, aLocalParam.nRow2 ) )

        {

            if (!bApi)

                rDocShell.ErrorMessage(STR_PASTE_FULL);

            return false;

        }