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

#include <svx/svdpage.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/viewfrm.hxx>

#include <comphelper/classids.hxx>

#include <comphelper/lok.hxx>

#include <sot/formats.hxx>

#include <sot/storage.hxx>

#include <vcl/graph.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <tools/urlobj.hxx>

#include <sot/exchange.hxx>

#include <memory>

#include <vcl/uitest/logger.hxx>

#include <vcl/uitest/eventdescription.hxx>

#include <vcl/TypeSerializer.hxx>

#include <osl/diagnose.h>

#include <attrib.hxx>

#include <patattr.hxx>

#include <dociter.hxx>

#include <viewfunc.hxx>

#include <tabvwsh.hxx>

#include <docsh.hxx>

#include <docfunc.hxx>

#include <dbdata.hxx>

#include <undoblk.hxx>

#include <refundo.hxx>

#include <globstr.hrc>

#include <scresid.hxx>

#include <global.hxx>

#include <transobj.hxx>

#include <drwtrans.hxx>

#include <chgtrack.hxx>

#include <waitoff.hxx>

#include <scmod.hxx>

#include <inputopt.hxx>

#include <warnbox.hxx>

#include <drwlayer.hxx>

#include <editable.hxx>

#include <docuno.hxx>

#include <clipparam.hxx>

#include <formulacell.hxx>

#include <undodat.hxx>

#include <drawview.hxx>

#include <cliputil.hxx>

#include <clipoptions.hxx>

#include <gridwin.hxx>

#include <SheetViewManager.hxx>

#include <uiitems.hxx>

#include <com/sun/star/util/XCloneable.hpp>

#include <sfx2/lokhelper.hxx>

#include <sc.hrc>

#include <sfx2/bindings.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

using namespace com::sun::star;

namespace {

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

{

    EventDescription aDescription;

    aDescription.aID = "grid_window";

    aDescription.aAction = action;

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

    aDescription.aParent = "MainWindow";

    aDescription.aKeyWord = "ScGridWinUIObject";

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

}

/// Result of scanning a selection for matrix formula overlap.

struct MatrixOverlapInfo

{

    ScRangeList maOriginMatrixRanges; ///< Full matrix ranges whose origin IS in the selection

    ScRangeList maNonOriginRanges;    ///< Non-origin matrix ranges (origin - top left cell - NOT in selection)

    bool hasNonOriginMatrices() const { return !maNonOriginRanges.empty(); }

};

/// Scan the selection for ALL matrix formula cells and classify them.

/// The selection range (rRange) is NOT modified.

/// Matrices whose origin IS in the selection are collected in maOriginMatrixRanges.

/// Matrices whose origin is NOT in the selection are collected in maNonOriginRanges.

MatrixOverlapInfo lcl_DetectMatrixOverlap(ScDocument& rDoc, const ScRange& rRange)

{

    MatrixOverlapInfo aInfo;

    std::vector<ScRange> aAllMatrices;

    auto isKnownMatrix = [&aAllMatrices](const ScRange& rMat) {

        return std::find(aAllMatrices.begin(), aAllMatrices.end(), rMat) != aAllMatrices.end();

    };

    auto isInsideKnownMatrix = [&aAllMatrices](const ScAddress& rPos) {

        return std::any_of(aAllMatrices.begin(), aAllMatrices.end(), [&rPos](const auto& rMat) {

            return rMat.Contains(rPos);

        });

    };

    // Single pass: scan the original selection for matrix cells.

    for (SCCOL nCol = rRange.aStart.Col(); nCol <= rRange.aEnd.Col(); ++nCol)

    {

        for (SCROW nRow = rRange.aStart.Row(); nRow <= rRange.aEnd.Row(); ++nRow)

        {

            ScAddress aPos(nCol, nRow, rRange.aStart.Tab());

            if (isInsideKnownMatrix(aPos))

                continue;

            ScFormulaCell* pFC = rDoc.GetFormulaCell(aPos);

            if (!pFC || pFC->GetMatrixFlag() == ScMatrixMode::NONE)

                continue;

            ScRange aMatRange;

            if (!rDoc.GetMatrixFormulaRange(aPos, aMatRange))

                continue;

            if (isKnownMatrix(aMatRange))

                continue;

            aAllMatrices.push_back(aMatRange);

        }

    }

    // Categorise each matrix: origin in selection vs. not.

    // Matrices fully contained by the selection need no special handling —

    // normal copy/paste already works (HasSelectedBlockMatrixFragment would

    // have returned false for these).  See tdf#100582.

    for (const auto& rMat : aAllMatrices)

    {

        if (rRange.Contains(rMat))

            continue;

        if (rRange.Contains(rMat.aStart))

            aInfo.maOriginMatrixRanges.push_back(rMat);

        else

            aInfo.maNonOriginRanges.push_back(rMat);

    }

    return aInfo;

}

/// For non-origin matrix overlap, try to narrow the clip doc's maRanges to a

/// single sub-range that excludes the matrix intersection.  This is only

/// attempted for a single non-origin matrix where the geometric subtraction

/// yields exactly one rectangle.  For multiple matrices or complex geometry,

/// maRanges is left unchanged and paste-time handles it via a temp doc.

void lcl_NarrowClipRangesForNonOrigin(ScDocument* pClipDoc,

                                      const ScRange& rOriginalRange,

                                      const ScRangeList& rMatrixRanges)

{

    // Narrowing optimisation: only for a single non-origin matrix.

    // Multiple matrices produce complex shapes — let paste-time handle it.

    if (rMatrixRanges.size() != 1)

        return;

    ScRangeList aSubRanges = rOriginalRange.Subtract(rMatrixRanges[0]);

    // For a single sub-range, the normal single-range paste handles it.

    // For 0 or 2+ sub-ranges, keep the original range — paste-time will

    // use the temp doc fallback (clear matrix intersections, bSkipEmpty).

    ScClipParam& rStoredParam = pClipDoc->GetClipParam();

    if (aSubRanges.size() == 1)

        rStoredParam.maRanges = std::move(aSubRanges);

}

}

//  GlobalName of writer-DocShell from comphelper/classids.hxx

//      C U T

void ScViewFunc::CutToClip()

{

    UpdateInputLine();

    ScEditableTester aTester = ScEditableTester::CreateAndTestView(this);

    if (!aTester.IsEditable())                  // selection editable?

    {

        ErrorMessage( aTester.GetMessageId() );

        return;

    }

    ScRange aRange;                             // delete this range

    if ( GetViewData().GetSimpleArea( aRange ) == SC_MARK_SIMPLE )

    {

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

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

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

        const bool bRecord(rDoc.IsUndoEnabled());                  // Undo/Redo

        ScDocShellModificator aModificator( *pDocSh );

        if ( !rMark.IsMarked() && !rMark.IsMultiMarked() )          // mark the range if not marked yet

        {

            DoneBlockMode();

            InitOwnBlockMode( aRange );

            rMark.SetMarkArea( aRange );

            MarkDataChanged();

        }

        CopyToClip( nullptr, true, false, true/*bIncludeObjects*/ );           // copy to clipboard

        ScAddress aOldEnd( aRange.aEnd );       //  combined cells in this range?

        rDoc.ExtendMerge( aRange, true );

        ScDocumentUniquePtr pUndoDoc;

        if ( bRecord )

        {

            pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));

            pUndoDoc->InitUndoSelected( rDoc, rMark );

            // all sheets - CopyToDocument skips those that don't exist in pUndoDoc

            ScRange aCopyRange = aRange;

            aCopyRange.aStart.SetTab(0);

            aCopyRange.aEnd.SetTab(rDoc.GetTableCount()-1);

            rDoc.CopyToDocument( aCopyRange, (InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS) | InsertDeleteFlags::NOCAPTIONS, false, *pUndoDoc );

            rDoc.BeginDrawUndo();

        }

        sal_uInt16 nExtFlags = 0;

        pDocSh->UpdatePaintExt( nExtFlags, aRange );

        rMark.MarkToMulti();

        rDoc.DeleteSelection( InsertDeleteFlags::ALL, rMark );

        rDoc.DeleteObjectsInSelection( rMark );

        rMark.MarkToSimple();

        if ( !AdjustRowHeight( aRange.aStart.Row(), aRange.aEnd.Row(), true ) )

            pDocSh->PostPaint( aRange, PaintPartFlags::Grid, nExtFlags );

        if ( bRecord )                          // Draw-Undo now available

            pDocSh->GetUndoManager()->AddUndoAction(

                std::make_unique<ScUndoCut>( *pDocSh, aRange, aOldEnd, rMark, std::move(pUndoDoc) ) );

        aModificator.SetDocumentModified();

        pDocSh->UpdateOle(GetViewData());

        CellContentChanged();

        pDocSh->ResolveSpilledOutputs();

        OUString aStartAddress =  aRange.aStart.GetColRowString();

        OUString aEndAddress = aRange.aEnd.GetColRowString();

        collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, u"CUT"_ustr);

    }

    else

        ErrorMessage( STR_NOMULTISELECT );

}

//      C O P Y

bool ScViewFunc::CopyToClip( ScDocument* pClipDoc, bool bCut, bool bApi, bool bIncludeObjects, bool bStopEdit )

{

    ScRange aRange;

    ScMarkType eMarkType = GetViewData().GetSimpleArea( aRange );

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

    bool bDone = false;

    if ( eMarkType == SC_MARK_SIMPLE || eMarkType == SC_MARK_SIMPLE_FILTERED )

    {

       ScRangeList aRangeList( aRange );

       bDone = CopyToClip( pClipDoc, aRangeList, bCut, bApi, bIncludeObjects, bStopEdit );

    }

    else if (eMarkType == SC_MARK_MULTI)

    {

        ScRangeList aRangeList;

        rMark.MarkToSimple();

        rMark.FillRangeListWithMarks(&aRangeList, false);

        bDone = CopyToClip( pClipDoc, aRangeList, bCut, bApi, bIncludeObjects, bStopEdit );

    }

    else

    {

        if (!bApi)

            ErrorMessage(STR_NOMULTISELECT);

    }

    if( !bCut ){

        OUString aStartAddress =  aRange.aStart.GetColRowString();

        OUString aEndAddress = aRange.aEnd.GetColRowString();

        collectUIInformation({{"RANGE", aStartAddress + ":" + aEndAddress}}, u"COPY"_ustr);

    }

    return bDone;

}

// Copy the content of the Range into clipboard.

bool ScViewFunc::CopyToClip( ScDocument* pClipDoc, const ScRangeList& rRanges, bool bCut, bool bApi, bool bIncludeObjects, bool bStopEdit )

{

    if ( rRanges.empty() )

        return false;

    if ( bStopEdit )

        UpdateInputLine();

    bool bDone;

    if (rRanges.size() > 1) // isMultiRange

        bDone = CopyToClipMultiRange(pClipDoc, rRanges, bCut, bApi, bIncludeObjects);

    else

        bDone = CopyToClipSingleRange(pClipDoc, rRanges, bCut, bIncludeObjects);

    return bDone;

}

bool ScViewFunc::CopyToClipSingleRange( ScDocument* pClipDoc, const ScRangeList& rRanges, bool bCut, bool bIncludeObjects )

{

    ScRange aRange = rRanges[0];

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

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

    // Check for partial matrix overlap (fragment).  Fully-contained

    // matrices are fine — only fragments need special handling.

    bool bHasFragment = rDoc.HasSelectedBlockMatrixFragment(

            aRange.aStart.Col(), aRange.aStart.Row(),

            aRange.aEnd.Col(), aRange.aEnd.Row(), rMark);

    MatrixOverlapInfo aMatInfo;

    ScRange aCopyRange = aRange;

    if (bHasFragment)

    {

        // Classify each partial overlap as origin-in-selection vs. not.

        aMatInfo = lcl_DetectMatrixOverlap(rDoc, aRange);

        // Expand the internal copy range to include origin matrices

        // so their formulas end up in the clip doc.

        for (size_t i = 0; i < aMatInfo.maOriginMatrixRanges.size(); ++i)

            aCopyRange.ExtendTo(aMatInfo.maOriginMatrixRanges[i]);

    }

    ScClipParam aClipParam( aCopyRange, bCut );

    if (bHasFragment)

    {

        aClipParam.maOriginalRange = aRange;

        aClipParam.maMatrixRanges = aMatInfo.maNonOriginRanges;

        aClipParam.maOriginMatrixRanges = aMatInfo.maOriginMatrixRanges;

    }

    std::shared_ptr<ScDocument> pSysClipDoc;

    if ( !pClipDoc )                                    // no clip doc specified

    {

        // Create one (deleted by ScTransferObj), and copy into system.

        pSysClipDoc = std::make_shared<ScDocument>( SCDOCMODE_CLIP );

        pClipDoc = pSysClipDoc.get();

    }

    if ( !bCut )

    {

        ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();

        if ( pChangeTrack )

            pChangeTrack->ResetLastCut();

    }

    if ( pSysClipDoc && bIncludeObjects )

    {

        bool bAnyOle = rDoc.HasOLEObjectsInArea( aCopyRange );

        // Update ScGlobal::xDrawClipDocShellRef.

        ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle, pSysClipDoc ) );

    }

    // is this necessary?, will setting the doc id upset the

    // following paste operation with range? would be nicer to just set this always

    // and lose the 'if' above

    aClipParam.setSourceDocID( rDoc.GetDocumentID() );

    if (ScDocShell* pObjectShell = rDoc.GetDocumentShell())

    {

        // Copy document properties from pObjectShell to pClipDoc (to its clip options, as it has no object shell).

        uno::Reference<util::XCloneable> xCloneable(pObjectShell->getDocProperties(), uno::UNO_QUERY_THROW);

        std::unique_ptr<ScClipOptions> pOptions(new ScClipOptions);

        pOptions->m_xDocumentProperties.set(xCloneable->createClone(), uno::UNO_QUERY);

        pClipDoc->SetClipOptions(std::move(pOptions));

    }

    rDoc.CopyToClip( aClipParam, pClipDoc, &rMark, false, bIncludeObjects );

    if (bHasFragment)

    {

        // Reset maRanges in the clip doc to the original selection so that

        // marching ants (UpdateCopySourceOverlay) show only what the user selected.

        pClipDoc->GetClipParam().maRanges = ScRangeList( aRange );

    }

    if (ScDrawLayer* pDrawLayer = pClipDoc->GetDrawLayer())

    {

        ScClipParam& rClipDocClipParam = pClipDoc->GetClipParam();

        ScRangeListVector& rRangesVector = rClipDocClipParam.maProtectedChartRangesVector;

        SCTAB nTabCount = pClipDoc->GetTableCount();

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

        {

            SdrPage* pPage = pDrawLayer->GetPage( static_cast< sal_uInt16 >( nTab ) );

            if ( pPage )

            {

                ScChartHelper::FillProtectedChartRangesVector( rRangesVector, rDoc, pPage );

            }

        }

    }

    if ( pSysClipDoc )

    {

        ScDrawLayer::SetGlobalDrawPersist(nullptr);

        ScGlobal::SetClipDocName( rDoc.GetDocumentShell()->GetTitle( SFX_TITLE_FULLNAME ) );

    }

    pClipDoc->ExtendMerge( aCopyRange, true );

    if (bHasFragment && aMatInfo.hasNonOriginMatrices())

        lcl_NarrowClipRangesForNonOrigin(pClipDoc, aRange, aMatInfo.maNonOriginRanges);

    if ( pSysClipDoc )

    {

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

        TransferableObjectDescriptor aObjDesc;

        pDocSh->FillTransferableObjectDescriptor( aObjDesc );

        aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();

        // maSize is set in ScTransferObj ctor

        rtl::Reference<ScTransferObj> pTransferObj(new ScTransferObj( pSysClipDoc, std::move(aObjDesc) ));

        if ( ScGlobal::xDrawClipDocShellRef.is() )

        {

            SfxObjectShellRef aPersistRef(ScGlobal::xDrawClipDocShellRef);

            pTransferObj->SetDrawPersist( aPersistRef );// keep persist for ole objects alive

        }

        pTransferObj->CopyToClipboard( GetActiveWin() );

    }

    return true;

}

bool ScViewFunc::CopyToClipMultiRange( const ScDocument* pInputClipDoc, const ScRangeList& rRanges, bool bCut, bool bApi, bool bIncludeObjects )

{

    if (bCut)

    {

        // We don't support cutting of multi-selections.

        if (!bApi)

            ErrorMessage(STR_NOMULTISELECT);

        return false;

    }

    if (pInputClipDoc)

    {

        // TODO: What's this for?

        if (!bApi)

            ErrorMessage(STR_NOMULTISELECT);

        return false;

    }

    ScClipParam aClipParam( rRanges[0], bCut );

    aClipParam.maRanges = rRanges;

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

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

    bool bDone = false;

    bool bSuccess = false;

    aClipParam.mbCutMode = false;

    do

    {

        ScDocumentUniquePtr pDocClip(new ScDocument(SCDOCMODE_CLIP));

        // Check for geometrical feasibility of the ranges.

        bool bValidRanges = true;

        ScRange const * p = &aClipParam.maRanges.front();

        SCCOL nPrevColDelta = 0;

        SCROW nPrevRowDelta = 0;

        SCCOL nPrevCol = p->aStart.Col();

        SCROW nPrevRow = p->aStart.Row();

        SCCOL nPrevColSize = p->aEnd.Col() - p->aStart.Col() + 1;

        SCROW nPrevRowSize = p->aEnd.Row() - p->aStart.Row() + 1;

        for ( size_t i = 1; i < aClipParam.maRanges.size(); ++i )

        {

            p = &aClipParam.maRanges[i];

            // Multi-range copy has no origin-matrix expansion logic,

            // so block copies that include matrix fragments.

            if ( rDoc.HasSelectedBlockMatrixFragment(

                p->aStart.Col(), p->aStart.Row(), p->aEnd.Col(), p->aEnd.Row(), rMark) )

            {

                if (!bApi)

                    ErrorMessage(STR_MATRIXFRAGMENTERR);

                return false;

            }

            SCCOL nColDelta = p->aStart.Col() - nPrevCol;

            SCROW nRowDelta = p->aStart.Row() - nPrevRow;

            if ((nColDelta && nRowDelta) || (nPrevColDelta && nRowDelta) || (nPrevRowDelta && nColDelta))

            {

                bValidRanges = false;

                break;

            }

            if (aClipParam.meDirection == ScClipParam::Unspecified)

            {

                if (nColDelta)

                    aClipParam.meDirection = ScClipParam::Column;

                if (nRowDelta)

                    aClipParam.meDirection = ScClipParam::Row;

            }

            SCCOL nColSize = p->aEnd.Col() - p->aStart.Col() + 1;

            SCROW nRowSize = p->aEnd.Row() - p->aStart.Row() + 1;

            if (aClipParam.meDirection == ScClipParam::Column && nRowSize != nPrevRowSize)

            {

                // column-oriented ranges must have identical row size.

                bValidRanges = false;

                break;

            }

            if (aClipParam.meDirection == ScClipParam::Row && nColSize != nPrevColSize)

            {

                // likewise, row-oriented ranges must have identical

                // column size.

                bValidRanges = false;

                break;

            }

            nPrevCol = p->aStart.Col();

            nPrevRow = p->aStart.Row();

            nPrevColDelta = nColDelta;

            nPrevRowDelta = nRowDelta;

            nPrevColSize  = nColSize;

            nPrevRowSize  = nRowSize;

        }

        if (!bValidRanges)

            break;

        rDoc.CopyToClip(aClipParam, pDocClip.get(), &rMark, false, bIncludeObjects );

        ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();

        if ( pChangeTrack )

            pChangeTrack->ResetLastCut();   // no more cut-mode

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

        TransferableObjectDescriptor aObjDesc;

        pDocSh->FillTransferableObjectDescriptor( aObjDesc );

        aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();

        // maSize is set in ScTransferObj ctor

        rtl::Reference<ScTransferObj> pTransferObj(new ScTransferObj( std::move(pDocClip), std::move(aObjDesc) ));

        if ( ScGlobal::xDrawClipDocShellRef.is() )

        {

            SfxObjectShellRef aPersistRef(ScGlobal::xDrawClipDocShellRef);

            pTransferObj->SetDrawPersist( aPersistRef );    // keep persist for ole objects alive

        }

        pTransferObj->CopyToClipboard( GetActiveWin() );    // system clipboard

        bSuccess = true;

    }

    while (false);

    if (!bSuccess && !bApi)

        ErrorMessage(STR_NOMULTISELECT);

    bDone = bSuccess;

    return bDone;

}

rtl::Reference<ScTransferObj> ScViewFunc::CopyToTransferable()

{

    ScRange aRange;

    auto eMarkType = GetViewData().GetSimpleArea( aRange );

    if ( eMarkType == SC_MARK_SIMPLE || eMarkType == SC_MARK_SIMPLE_FILTERED )

    {

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

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

        bool bHasFragment = rDoc.HasSelectedBlockMatrixFragment(

                aRange.aStart.Col(), aRange.aStart.Row(),

                aRange.aEnd.Col(), aRange.aEnd.Row(), rMark);

        MatrixOverlapInfo aMatInfo;

        ScRange aCopyRange = aRange;

        if (bHasFragment)

        {

            aMatInfo = lcl_DetectMatrixOverlap(rDoc, aRange);

            for (size_t i = 0; i < aMatInfo.maOriginMatrixRanges.size(); ++i)

                aCopyRange.ExtendTo(aMatInfo.maOriginMatrixRanges[i]);

        }

        ScDocumentUniquePtr pClipDoc(new ScDocument( SCDOCMODE_CLIP ));    // create one (deleted by ScTransferObj)

        bool bAnyOle = rDoc.HasOLEObjectsInArea( aCopyRange, &rMark );

        ScDrawLayer::SetGlobalDrawPersist( ScTransferObj::SetDrawClipDoc( bAnyOle ) );

        ScClipParam aClipParam(aCopyRange, false);

        if (bHasFragment)

        {

            aClipParam.maOriginalRange = aRange;

            aClipParam.maMatrixRanges = aMatInfo.maNonOriginRanges;

            aClipParam.maOriginMatrixRanges = aMatInfo.maOriginMatrixRanges;

        }

        rDoc.CopyToClip(aClipParam, pClipDoc.get(), &rMark, false, true);

        if (bHasFragment)

            pClipDoc->GetClipParam().maRanges = ScRangeList( aRange );

        ScDrawLayer::SetGlobalDrawPersist(nullptr);

        pClipDoc->ExtendMerge( aCopyRange, true );

        if (bHasFragment && aMatInfo.hasNonOriginMatrices())

            lcl_NarrowClipRangesForNonOrigin(pClipDoc.get(), aRange, aMatInfo.maNonOriginRanges);

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

        TransferableObjectDescriptor aObjDesc;

        pDocSh->FillTransferableObjectDescriptor( aObjDesc );

        aObjDesc.maDisplayName = pDocSh->GetMedium()->GetURLObject().GetURLNoPass();

        return new ScTransferObj( std::move(pClipDoc), std::move(aObjDesc) );

    }

    else if (eMarkType == SC_MARK_MULTI)

    {

        ScDocumentUniquePtr pClipDoc(new ScDocument(SCDOCMODE_CLIP));

        // This takes care of the input line and calls CopyToClipMultiRange() for us.

        CopyToClip(pClipDoc.get(), aRange, /*bCut=*/false, /*bApi=*/true);

        TransferableObjectDescriptor aObjDesc;

        return new ScTransferObj(std::move(pClipDoc), std::move(aObjDesc));

    }

    return nullptr;

}

//      P A S T E

void ScViewFunc::PasteDraw()

{

    ScViewData& rViewData = GetViewData();

    SCCOL nPosX = rViewData.GetCurX();

    SCROW nPosY = rViewData.GetCurY();

    vcl::Window* pWin = GetActiveWin();

    Point aPos = pWin->PixelToLogic( rViewData.GetScrPos( nPosX, nPosY,

                                     rViewData.GetActivePart() ) );

    const ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard(ScTabViewShell::GetClipData(rViewData.GetActiveWin()));

    if (pDrawClip)

    {

        const OUString& aSrcShellID = pDrawClip->GetShellID();

        OUString aDestShellID = SfxObjectShell::CreateShellID(rViewData.GetDocShell());

        PasteDraw(aPos, pDrawClip->GetModel(), false, aSrcShellID, aDestShellID);

    }

}

void ScViewFunc::PasteFromSystem(bool useSavedPrefs)

{

    UpdateInputLine();

    vcl::Window* pWin = GetActiveWin();

    css::uno::Reference<css::datatransfer::XTransferable2> xTransferable2(ScTabViewShell::GetClipData(pWin));

    const ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard(xTransferable2);

    // keep a reference in case the clipboard is changed during PasteFromClip

    const ScDrawTransferObj* pDrawClip = ScDrawTransferObj::GetOwnClipboard(xTransferable2);

    if (pOwnClip)

    {

        PasteFromClip( InsertDeleteFlags::ALL, pOwnClip->GetDocument(),

                        ScPasteFunc::NONE, false, false, false, INS_NONE, InsertDeleteFlags::NONE,

                        true );     // allow warning dialog

    }

    else if (pDrawClip)

        PasteDraw();

    else

    {

        TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pWin ) );

        {

            SotClipboardFormatId nBiff12= SotExchange::RegisterFormatName(u"Biff12"_ustr);

            SotClipboardFormatId nBiff8 = SotExchange::RegisterFormatName(u"Biff8"_ustr);

            SotClipboardFormatId nBiff5 = SotExchange::RegisterFormatName(u"Biff5"_ustr);

            SotClipboardFormatId nFormat; // output param for GetExchangeAction

            sal_uInt8 nEventAction;      // output param for GetExchangeAction

            uno::Reference<css::datatransfer::XTransferable> xTransferable( aDataHelper.GetXTransferable() );

            sal_uInt8 nAction = SotExchange::GetExchangeAction(

                                    aDataHelper.GetDataFlavorExVector(),

                                    SotExchangeDest::SCDOC_FREE_AREA,

                                    EXCHG_IN_ACTION_COPY,

                                    EXCHG_IN_ACTION_DEFAULT,

                                    nFormat, nEventAction, SotClipboardFormatId::NONE,

                                    &xTransferable );

            if ( nAction != EXCHG_INOUT_ACTION_NONE )

            {

                switch( nAction )

                {

                case EXCHG_OUT_ACTION_INSERT_SVXB:

                case EXCHG_OUT_ACTION_INSERT_GDIMETAFILE:

                case EXCHG_OUT_ACTION_INSERT_BITMAP:

                case EXCHG_OUT_ACTION_INSERT_GRAPH:

                    // SotClipboardFormatId::BITMAP

                    // SotClipboardFormatId::PNG

                    // SotClipboardFormatId::GDIMETAFILE

                    // SotClipboardFormatId::SVXB

                    PasteFromSystem(nFormat);

                    break;

                default:

                    nAction = EXCHG_INOUT_ACTION_NONE;

                }

            }

            if ( nAction == EXCHG_INOUT_ACTION_NONE )

            {

                //  first SvDraw-model, then drawing

                //  (only one drawing is allowed)

                if (aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ))

                {

                    // special case for tables from drawing

                    if( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) )

                    {

                        PasteFromSystem( SotClipboardFormatId::RTF );

                    }

                    else if( aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) )

                    {

                        PasteFromSystem( SotClipboardFormatId::RICHTEXT );

                    }

                    else

                    {

                        PasteFromSystem( SotClipboardFormatId::DRAWING );

                    }

                }

                else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE ))

                {

                    //  If it's a Writer object, insert RTF instead of OLE

                    //  Else, if the class id is all-zero, and SYLK is available,

                    //  it probably is spreadsheet cells that have been put

                    //  on the clipboard by OOo, so use the SYLK. (fdo#31077)

                    bool bDoRtf = false;

                    TransferableObjectDescriptor aObjDesc;

                    if( aDataHelper.GetTransferableObjectDescriptor( SotClipboardFormatId::OBJECTDESCRIPTOR, aObjDesc ) )

                    {

                        bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||

                                     aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )

                                   && ( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) ) );

                    }

                    if ( bDoRtf )

                        PasteFromSystem( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) ? SotClipboardFormatId::RTF : SotClipboardFormatId::RICHTEXT );

                    else if ( aObjDesc.maClassName == SvGlobalName( 0,0,0,0,0,0,0,0,0,0,0 )

                              && aDataHelper.HasFormat( SotClipboardFormatId::SYLK ))

                        PasteFromSystem( SotClipboardFormatId::SYLK );

                    else

                        PasteFromSystem( SotClipboardFormatId::EMBED_SOURCE );

                }

                else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE ))

                    PasteFromSystem( SotClipboardFormatId::LINK_SOURCE );

                    // the following format can not affect scenario from #89579#

                else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBEDDED_OBJ_OLE ))

                    PasteFromSystem( SotClipboardFormatId::EMBEDDED_OBJ_OLE );

                    // SotClipboardFormatId::PRIVATE no longer here (can't work if pOwnClip is NULL)

                else if (aDataHelper.HasFormat(nBiff12))      // before xxx_OLE formats

                    PasteFromSystem(nBiff12);

                else if (aDataHelper.HasFormat(nBiff8))

                    PasteFromSystem(nBiff8);

                else if (aDataHelper.HasFormat(nBiff5))

                    PasteFromSystem(nBiff5);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::RTF))

                    PasteFromSystem(SotClipboardFormatId::RTF);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::RICHTEXT))

                    PasteFromSystem(SotClipboardFormatId::RICHTEXT);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML))

                    PasteFromSystem(SotClipboardFormatId::HTML, false, useSavedPrefs);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::BITMAP))

                    PasteFromSystem(SotClipboardFormatId::BITMAP);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML_SIMPLE))

                    PasteFromSystem(SotClipboardFormatId::HTML_SIMPLE);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::SYLK))

                    PasteFromSystem(SotClipboardFormatId::SYLK);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING_TSVC))

                    PasteFromSystem(SotClipboardFormatId::STRING_TSVC);

                else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING))

                    PasteFromSystem(SotClipboardFormatId::STRING);

                // xxx_OLE formats come last, like in SotExchange tables

                else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE_OLE ))

                    PasteFromSystem( SotClipboardFormatId::EMBED_SOURCE_OLE );

                else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE_OLE ))

                    PasteFromSystem( SotClipboardFormatId::LINK_SOURCE_OLE );

            }

        }

    }

    //  no exception-> SID_PASTE has FastCall-flag from idl

    //  will be called in case of empty clipboard (#42531#)

}

void ScViewFunc::PasteFromTransferable( const uno::Reference<datatransfer::XTransferable>& rxTransferable )

{

    if (auto pOwnClip = dynamic_cast<ScTransferObj*>(rxTransferable.get()))

    {

        PasteFromClip( InsertDeleteFlags::ALL, pOwnClip->GetDocument(),

                        ScPasteFunc::NONE, false, false, false, INS_NONE, InsertDeleteFlags::NONE,

                        true );     // allow warning dialog

    }

    else if (auto pDrawClip = dynamic_cast<ScDrawTransferObj*>(rxTransferable.get()))

    {

        ScViewData& rViewData = GetViewData();

        SCCOL nPosX = rViewData.GetCurX();

        SCROW nPosY = rViewData.GetCurY();

        vcl::Window* pWin = GetActiveWin();

        Point aPos = pWin->PixelToLogic( rViewData.GetScrPos( nPosX, nPosY, rViewData.GetActivePart() ) );

        PasteDraw(

            aPos, pDrawClip->GetModel(), false,

            pDrawClip->GetShellID(), SfxObjectShell::CreateShellID(rViewData.GetDocShell()));

    }

    else

    {

            TransferableDataHelper aDataHelper( rxTransferable );

            SotClipboardFormatId nBiff12 = SotExchange::RegisterFormatName(u"Biff12"_ustr);

            SotClipboardFormatId nBiff8 = SotExchange::RegisterFormatName(u"Biff8"_ustr);

            SotClipboardFormatId nBiff5 = SotExchange::RegisterFormatName(u"Biff5"_ustr);

            SotClipboardFormatId nFormatId = SotClipboardFormatId::NONE;

                //  first SvDraw-model, then drawing

                //  (only one drawing is allowed)

            if (aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ))

                nFormatId = SotClipboardFormatId::DRAWING;

            else if (aDataHelper.HasFormat( SotClipboardFormatId::SVXB ))

                nFormatId = SotClipboardFormatId::SVXB;

            else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBED_SOURCE ))

            {

                //  If it's a Writer object, insert RTF instead of OLE

                bool bDoRtf = false;

                TransferableObjectDescriptor aObjDesc;

                if( aDataHelper.GetTransferableObjectDescriptor( SotClipboardFormatId::OBJECTDESCRIPTOR, aObjDesc ) )

                {

                    bDoRtf = ( ( aObjDesc.maClassName == SvGlobalName( SO3_SW_CLASSID ) ||

                                 aObjDesc.maClassName == SvGlobalName( SO3_SWWEB_CLASSID ) )

                               && ( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) ));

                }

                if ( bDoRtf )

                    nFormatId = aDataHelper.HasFormat( SotClipboardFormatId::RTF ) ? SotClipboardFormatId::RTF : SotClipboardFormatId::RICHTEXT;

                else

                    nFormatId = SotClipboardFormatId::EMBED_SOURCE;

            }

            else if (aDataHelper.HasFormat( SotClipboardFormatId::LINK_SOURCE ))

                nFormatId = SotClipboardFormatId::LINK_SOURCE;

            // the following format can not affect scenario from #89579#

            else if (aDataHelper.HasFormat( SotClipboardFormatId::EMBEDDED_OBJ_OLE ))

                nFormatId = SotClipboardFormatId::EMBEDDED_OBJ_OLE;

            // SotClipboardFormatId::PRIVATE no longer here (can't work if pOwnClip is NULL)

            else if (aDataHelper.HasFormat(nBiff12))      // before xxx_OLE formats

                nFormatId = nBiff12;

            else if (aDataHelper.HasFormat(nBiff8))

                nFormatId = nBiff8;

            else if (aDataHelper.HasFormat(nBiff5))

                nFormatId = nBiff5;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::RTF))

                nFormatId = SotClipboardFormatId::RTF;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::RICHTEXT))

                nFormatId = SotClipboardFormatId::RICHTEXT;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML))

                nFormatId = SotClipboardFormatId::HTML;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::HTML_SIMPLE))

                nFormatId = SotClipboardFormatId::HTML_SIMPLE;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::SYLK))

                nFormatId = SotClipboardFormatId::SYLK;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING_TSVC))

                nFormatId = SotClipboardFormatId::STRING_TSVC;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::STRING))

                nFormatId = SotClipboardFormatId::STRING;

            else if (aDataHelper.HasFormat(SotClipboardFormatId::GDIMETAFILE))