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

/*

 * This file is part of the LibreOffice project.

 *

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

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

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

 *

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

 *

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

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

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

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

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

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

 */

#include <config_features.h>

#include <com/sun/star/embed/XTransactedObject.hpp>

#include <com/sun/star/embed/Aspects.hpp>

#include <com/sun/star/embed/XEmbedObjectClipboardCreator.hpp>

#include <com/sun/star/embed/NoVisualAreaSizeException.hpp>

#include <com/sun/star/embed/MSOLEObjectSystemCreator.hpp>

#include <com/sun/star/text/XPasteListener.hpp>

#include <officecfg/Office/Writer.hxx>

#include <svtools/embedtransfer.hxx>

#include <svtools/insdlg.hxx>

#include <unotools/tempfile.hxx>

#include <comphelper/fileformat.h>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertyvalue.hxx>

#include <comphelper/servicehelper.hxx>

#include <comphelper/storagehelper.hxx>

#include <comphelper/string.hxx>

#include <o3tl/deleter.hxx>

#include <o3tl/temporary.hxx>

#include <unotools/ucbstreamhelper.hxx>

#include <sot/filelist.hxx>

#include <svx/svxdlg.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <sfx2/linkmgr.hxx>

#include <tools/urlobj.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/viewfrm.hxx>

#include <svl/stritem.hxx>

#include <vcl/imap.hxx>

#include <sot/storage.hxx>

#include <vcl/graph.hxx>

#include <svl/urihelper.hxx>

#include <svx/svdmodel.hxx>

#include <svx/xmlexchg.hxx>

#include <svx/dbaexchange.hxx>

#include <svx/clipfmtitem.hxx>

#include <sfx2/mieclip.hxx>

#include <svl/urlbmk.hxx>

#include <unicode/regex.h>

#include <vcl/inetimg.hxx>

#include <svx/fmview.hxx>

#include <sfx2/docfilt.hxx>

#include <vcl/imapobj.hxx>

#include <sfx2/docfile.hxx>

#include <unotools/transliterationwrapper.hxx>

#include <unotools/streamwrap.hxx>

#include <vcl/graphicfilter.hxx>

#ifdef _WIN32

#include <prewin.h>

#include <postwin.h>

#include <o3tl/char16_t2wchar_t.hxx>

#include <osl/file.hxx>

#include <systools/win32/extended_max_path.hxx>

#endif

#include <svx/unomodel.hxx>

#include <fmturl.hxx>

#include <fmtinfmt.hxx>

#include <swdtflvr.hxx>

#include <shellio.hxx>

#include <ddefld.hxx>

#include <doc.hxx>

#include <IDocumentUndoRedo.hxx>

#include <IDocumentDrawModelAccess.hxx>

#include <IDocumentFieldsAccess.hxx>

#include <IDocumentRedlineAccess.hxx>

#include <IDocumentState.hxx>

#include <IMark.hxx>

#include <section.hxx>

#include <ndtxt.hxx>

#include <edtdd.hxx>

#include <edtwin.hxx>

#include <navicont.hxx>

#include <swcont.hxx>

#include <wrtsh.hxx>

#include <swmodule.hxx>

#include <view.hxx>

#include <docsh.hxx>

#include <wdocsh.hxx>

#include <fldbas.hxx>

#include <swundo.hxx>

#include <pam.hxx>

#include <ndole.hxx>

#include <swwait.hxx>

#include <viewopt.hxx>

#include <SwCapObjType.hxx>

#include <cmdid.h>

#include <strings.hrc>

#include <svx/svditer.hxx>

#include <editeng/eeitem.hxx>

#include <editeng/fhgtitem.hxx>

#include <editeng/prntitem.hxx>

#include <svx/svdpage.hxx>

#include <avmedia/mediawindow.hxx>

#include <swcrsr.hxx>

#include <SwRewriter.hxx>

#include <vcl/svapp.hxx>

#include <swserv.hxx>

#include <fmtmeta.hxx>

#include <itabenum.hxx>

#include <iodetect.hxx>

#include <unotextrange.hxx>

#include <unoframe.hxx>

#include <txatbase.hxx>

#include <unoparaframeenum.hxx>

#include <vcl/uitest/logger.hxx>

#include <vcl/uitest/eventdescription.hxx>

#include <vcl/GraphicNativeTransform.hxx>

#include <vcl/GraphicNativeMetadata.hxx>

#include <vcl/TypeSerializer.hxx>

#include <comphelper/lok.hxx>

#include <sfx2/classificationhelper.hxx>

#include <sfx2/sfxdlg.hxx>

#include <comphelper/classids.hxx>

#include <osl/diagnose.h>

#include <memory>

/* default (A4 format) width of 210mm - 2 * border size (border on both sides) */

constexpr tools::Long constOleWidthInMm = 210 - 2 * lMinBorderInMm;

constexpr Size constOleSize100mm(

    constOleWidthInMm * 100, // convert from mm to 100mm

    3000 // 3 cm

);

constexpr Size constOleSizeTwip = o3tl::convert(constOleSize100mm, o3tl::Length::mm100, o3tl::Length::twip);

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_DRAWMODEL = 0x00000001;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_HTML      = 0x00000002;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_RTF       = 0x00000004;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_STRING    = 0x00000008;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_SWOLE     = 0x00000010;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_DDE       = 0x00000020;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_RICHTEXT  = 0x00000040;

constexpr sal_uInt32 SWTRANSFER_OBJECTTYPE_MARKDOWN  = 0x00000080;

using namespace ::svx;

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

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

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

namespace {

void collectUIInformation(const OUString& rAction, const OUString& aParameters)

{

    EventDescription aDescription;

    aDescription.aAction = rAction;

    aDescription.aParameters = {{"parameters", aParameters}};

    aDescription.aID = "writer_edit";

    aDescription.aKeyWord = "SwEditWinUIObject";

    aDescription.aParent = "MainWindow";

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

}

}

class SwTransferDdeLink : public ::sfx2::SvBaseLink

{

    OUString m_sName;

    ::sfx2::SvLinkSourceRef m_xRefObj;

    SwTransferable& m_rTransfer;

    SwDocShell* m_pDocShell;

    sal_uLong m_nOldTimeOut;

    bool m_bDelBookmark : 1;

    bool m_bInDisconnect : 1;

    bool FindDocShell();

    using sfx2::SvBaseLink::Disconnect;

protected:

    virtual ~SwTransferDdeLink() override;

public:

    SwTransferDdeLink( SwTransferable& rTrans, SwWrtShell& rSh );

    virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(

        const OUString& rMimeType, const css::uno::Any & rValue ) override;

    virtual void Closed() override;

    bool WriteData( SvStream& rStrm );

    void Disconnect( bool bRemoveDataAdvise );

};

/// Tracks the boundaries of pasted content and notifies listeners.

class SwPasteContext

{

public:

    SwPasteContext(SwWrtShell& rWrtShell);

    ~SwPasteContext();

    void remember();

    void forget();

private:

    SwWrtShell& m_rWrtShell;

    std::optional<SwPaM> m_oPaM;

    sal_Int32 m_nStartContent = 0;

};

namespace {

// helper class for Action and Undo enclosing

class SwTrnsfrActionAndUndo

{

    SwWrtShell *pSh;

public:

    SwTrnsfrActionAndUndo( SwWrtShell *pS, bool bDelSel = false, SwPasteContext* pContext = nullptr)

        : pSh( pS )

    {

        pSh->StartUndo( SwUndoId::PASTE_CLIPBOARD );

        if( bDelSel )

        {

            if (pContext)

                pContext->forget();

            pSh->DelRight();

            if (pContext)

                pContext->remember();

        }

        pSh->StartAllAction();

    }

    ~SwTrnsfrActionAndUndo() COVERITY_NOEXCEPT_FALSE

    {

        pSh->EndUndo();

        pSh->EndAllAction();

    }

};

}

SwTransferable::SwTransferable( SwWrtShell& rSh )

    : m_pWrtShell( &rSh ),

    m_pCreatorView( nullptr ),

    m_pOrigGraphic( nullptr ),

    m_eBufferType( TransferBufferType::NONE ),

    m_bOldIdle(false),

    m_bCleanUp(false)

{

    rSh.GetView().AddTransferable(*this);

    SwDocShell* pDShell = rSh.GetDoc()->GetDocShell();

    if( !pDShell )

        return;

    pDShell->FillTransferableObjectDescriptor( m_aObjDesc );

    if( pDShell->GetMedium() )

    {

        const INetURLObject& rURLObj = pDShell->GetMedium()->GetURLObject();

        m_aObjDesc.maDisplayName = URIHelper::removePassword(

                            rURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ),

                            INetURLObject::EncodeMechanism::WasEncoded,

                            INetURLObject::DecodeMechanism::Unambiguous );

    }

    PrepareOLE( m_aObjDesc );

}

SwTransferable::~SwTransferable()

{

    SolarMutexGuard aSolarGuard;

    // the DDELink still needs the WrtShell!

    DisconnectDDE();

    m_pWrtShell = nullptr;

    // release reference to the document so that aDocShellRef will delete

    // it (if aDocShellRef is set). Otherwise, the OLE nodes keep references

    // to their sub-storage when the storage is already dead.

    m_pClpDocFac.reset();

    // first close, then the Ref. can be cleared as well, so that

    // the DocShell really gets deleted!

    if( m_aDocShellRef.Is() )

    {

        SfxObjectShell * pObj = m_aDocShellRef;

        SwDocShell* pDocSh = static_cast<SwDocShell*>(pObj);

        pDocSh->DoClose();

    }

    m_aDocShellRef.Clear();

    if (SwModule* pMod = SwModule::get())

    {

        if ( pMod->m_pDragDrop == this )

            pMod->m_pDragDrop = nullptr;

        else if ( pMod->m_pXSelection == this )

            pMod->m_pXSelection = nullptr;

    }

    m_eBufferType = TransferBufferType::NONE;

}

static SwDoc& lcl_GetDoc(SwDocFac & rDocFac)

{

    SwDoc& rDoc = rDocFac.GetDoc();

    rDoc.SetClipBoard( true );

    return rDoc;

}

void SwTransferable::ObjectReleased()

{

    SwModule* pMod = SwModule::get();

    if (!pMod)

        return;

    if( this == pMod->m_pDragDrop )

        pMod->m_pDragDrop = nullptr;

    else if( this == pMod->m_pXSelection )

        pMod->m_pXSelection = nullptr;

}

void SwTransferable::AddSupportedFormats()

{

    // only need if we are the current XSelection Object

    if (this == SwModule::get()->m_pXSelection || comphelper::LibreOfficeKit::isActive())

    {

        SetDataForDragAndDrop( Point( 0,0) );

    }

}

void SwTransferable::InitOle( SfxObjectShell* pDoc )

{

    //set OleVisArea. Upper left corner of the page and size of

    //RealSize in Twips.

    const Size aSz(constOleSizeTwip);

    SwRect aVis( Point( DOCUMENTBORDER, DOCUMENTBORDER ), aSz );

    pDoc->SetVisArea( aVis.SVRect() );

}

uno::Reference < embed::XEmbeddedObject > SwTransferable::FindOLEObj( sal_Int64& nAspect ) const

{

    uno::Reference < embed::XEmbeddedObject > xObj;

    if( m_pClpDocFac )

    {

        SwIterator<SwContentNode,SwFormatColl> aIter( *m_pClpDocFac->GetDoc().GetDfltGrfFormatColl() );

        for( SwContentNode* pNd = aIter.First(); pNd; pNd = aIter.Next() )

            if( SwNodeType::Ole == pNd->GetNodeType() )

            {

                xObj = static_cast<SwOLENode*>(pNd)->GetOLEObj().GetOleRef();

                nAspect = static_cast<SwOLENode*>(pNd)->GetAspect();

                break;

            }

    }

    return xObj;

}

const Graphic* SwTransferable::FindOLEReplacementGraphic() const

{

    if( m_pClpDocFac )

    {

        SwIterator<SwContentNode,SwFormatColl> aIter( *m_pClpDocFac->GetDoc().GetDfltGrfFormatColl() );

        for( SwContentNode* pNd = aIter.First(); pNd; pNd = aIter.Next() )

            if( SwNodeType::Ole == pNd->GetNodeType() )

            {

                return static_cast<SwOLENode*>(pNd)->GetGraphic();

            }

    }

    return nullptr;

}

void SwTransferable::RemoveDDELinkFormat(vcl::Window& rWin)

{

    RemoveFormat( SotClipboardFormatId::LINK );

    if (rWin.GetClipboard()->getContents().get() == this)

        CopyToClipboard(&rWin);

}

void SwTransferable::DisconnectDDE()

{

    if( m_xDdeLink.is() )

    {

        m_xDdeLink->Disconnect( true );

        m_xDdeLink.clear();

    }

}

namespace

{

    //Resolves: fdo#40717 surely when we create a clipboard document we should

    //overwrite the clipboard documents styles and settings with that of the

    //source, so that we can WYSIWYG paste. If we want that the destinations

    //styles are used over the source styles, that's a matter of the

    //destination paste code to handle, not the source paste code.

    void lclOverWriteDoc(SwWrtShell &rSrcWrtShell, SwDoc &rDest, bool bDeleteRedlines = true)

    {

        const SwDoc &rSrc = *rSrcWrtShell.GetDoc();

        rDest.ReplaceCompatibilityOptions(rSrc);

        rDest.ReplaceDefaults(rSrc);

        //It would probably make most sense here to only insert the styles used

        //by the selection, e.g. apply SwDoc::IsUsed on styles ?

        rDest.ReplaceStyles(rSrc, false);

        rSrcWrtShell.Copy(rDest, /*pNewClpText=*/nullptr, bDeleteRedlines);

        rDest.GetMetaFieldManager().copyDocumentProperties(rSrc);

    }

    void lclCheckAndPerformRotation(Graphic& aGraphic)

    {

        GraphicNativeMetadata aMetadata;

        if ( !aMetadata.read(aGraphic) )

            return;

        Degree10 aRotation = aMetadata.getRotation();

        if (aRotation)

        {

            GraphicNativeTransform aTransform( aGraphic );

            aTransform.rotate( aRotation );

        }

    }

}

sal_Bool SAL_CALL SwTransferable::isComplex()

{

    sal_Int32 nTextLength = 0;

    SwNodes& aNodes = m_pWrtShell->GetDoc()->GetNodes();

    for (SwPaM& rPaM : m_pWrtShell->GetCursor()->GetRingContainer())

    {

        for (SwNodeOffset nIndex = rPaM.GetMark()->GetNodeIndex();

             nIndex <= rPaM.GetPoint()->GetNodeIndex(); ++nIndex)

        {

            SwNode& rNd = *aNodes[nIndex];

            SwTextNode* pTextNode = rNd.GetTextNode();

            if (pTextNode)

            {

                if (pTextNode->HasHints())

                {

                    for (size_t nHint = 0; nHint < pTextNode->GetSwpHints().Count(); ++nHint)

                    {

                        SwTextAttr* pHint = pTextNode->GetSwpHints().Get(nHint);

                        if (pHint->Which() == RES_TXTATR_FLYCNT)

                        {

                            return true; // Complex

                        }

                    }

                }

                FrameClientSortList_t vFrames;

                ::CollectFrameAtNode(rNd, vFrames, true);

                if (!vFrames.empty())

                {

                    // There is an at-char anchored object to this node, that's complex.

                    return true;

                }

                nTextLength += pTextNode->GetText().getLength();

                if (nTextLength >= 1024 * 512)

                    return true; // Complex

            }

        }

    }

    if (m_pWrtShell->GetSelectionType() == SelectionType::DrawObject)

        return true; // Complex

    // Simple

    return false;

}

bool SwTransferable::GetData( const DataFlavor& rFlavor, const OUString& rDestDoc )

{

    SotClipboardFormatId nFormat = SotExchange::GetFormat( rFlavor );

    // we can only fulfil the request if

    // 1) we have data for this format

    // 2) we have either a clipboard document (pClpDocFac), or

    //    we have a SwWrtShell (so we can generate a new clipboard document)

    if( !HasFormat( nFormat ) || ( m_pClpDocFac == nullptr && m_pWrtShell == nullptr ) )

        return false;

    if( !m_pClpDocFac )

    {

        SelectionType nSelectionType = m_pWrtShell->GetSelectionType();

        // when pending we will not get the correct type, but SelectionType::Text

        // as fallback. This *happens* during D&D, so we need to check if we are in

        // the fallback and just try to get a graphic

        const bool bPending(m_pWrtShell->ActionPend());

        // SEL_GRF is from ContentType of editsh

        if(bPending || ((SelectionType::Graphic | SelectionType::DrawObject | SelectionType::DbForm) & nSelectionType))

        {

            m_oClpGraphic.emplace();

            if( !m_pWrtShell->GetDrawObjGraphic( SotClipboardFormatId::GDIMETAFILE, *m_oClpGraphic ))

                m_pOrigGraphic = &*m_oClpGraphic;

            m_oClpBitmap.emplace();

            if( !m_pWrtShell->GetDrawObjGraphic( SotClipboardFormatId::BITMAP, *m_oClpBitmap ))

                m_pOrigGraphic = &*m_oClpBitmap;

            // is it a URL-Button ?

            OUString sURL;

            OUString sDesc;

            if( m_pWrtShell->GetURLFromButton( sURL, sDesc ) )

            {

                m_oBookmark.emplace( sURL, sDesc );

                m_eBufferType = TransferBufferType::InetField;

            }

        }

        m_pClpDocFac.reset(new SwDocFac);

        SwDoc& rTmpDoc = lcl_GetDoc(*m_pClpDocFac);

        rTmpDoc.getIDocumentFieldsAccess().LockExpFields();     // never update fields - leave text as it is

        lclOverWriteDoc(*m_pWrtShell, rTmpDoc);

        // in CORE a new one was created (OLE-objects copied!)

        m_aDocShellRef = rTmpDoc.GetTmpDocShell();

        if( m_aDocShellRef.Is() )

            SwTransferable::InitOle( m_aDocShellRef );

        rTmpDoc.SetTmpDocShell( nullptr );

        if( nSelectionType & SelectionType::Text && !m_pWrtShell->HasMark() )

        {

            SwContentAtPos aContentAtPos( IsAttrAtPos::InetAttr );

            Point aPos( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY());

            bool bSelect = g_bExecuteDrag &&

                            m_pWrtShell->GetView().GetDocShell() &&

                            !m_pWrtShell->GetView().GetDocShell()->IsReadOnly();

            if( m_pWrtShell->GetContentAtPos( aPos, aContentAtPos, bSelect ) )

            {

                m_oBookmark.emplace(

                        static_cast<const SwFormatINetFormat*>(aContentAtPos.aFnd.pAttr)->GetValue(),

                        aContentAtPos.sStr );

                m_eBufferType = TransferBufferType::InetField;

                if( bSelect )

                    m_pWrtShell->SelectTextAttr( RES_TXTATR_INETFMT );

            }

        }

        if( m_pWrtShell->IsFrameSelected() )

        {

            SfxItemSet aSet(SfxItemSet::makeFixedSfxItemSet<RES_URL, RES_URL>( m_pWrtShell->GetAttrPool() ));

            m_pWrtShell->GetFlyFrameAttr( aSet );

            const SwFormatURL& rURL = aSet.Get( RES_URL );

            if( rURL.GetMap() )

                m_pImageMap.reset(new ImageMap( *rURL.GetMap() ));

            else if( !rURL.GetURL().isEmpty() )

                m_pTargetURL.reset(new INetImage(OUString(), rURL.GetURL(),

                                            rURL.GetTargetFrameName() ));

        }

    }

    bool bOK = false;

    if( TransferBufferType::Ole == m_eBufferType )

    {

        //TODO/MBA: testing - is this the "single OLE object" case?!

        // get OLE-Object from ClipDoc and get the data from that.

        sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT; // will be set in the next statement

        uno::Reference < embed::XEmbeddedObject > xObj = FindOLEObj( nAspect );

        const Graphic* pOLEGraph = FindOLEReplacementGraphic();

        if( xObj.is() )

        {

            TransferableDataHelper aD( new SvEmbedTransferHelper( xObj, pOLEGraph, nAspect ) );

            uno::Any aAny = aD.GetAny(rFlavor, rDestDoc);

            if( aAny.hasValue() )

                bOK = SetAny( aAny );

        }

        // the following solution will be used in the case when the object can not generate the image

        // TODO/LATER: in future the transferhelper must probably be created based on object and the replacement stream

        // TODO: Block not required now, SvEmbedTransferHelper should be able to handle GDIMetaFile format

        if ( nFormat == SotClipboardFormatId::GDIMETAFILE )

        {

            pOLEGraph = FindOLEReplacementGraphic();

            if ( pOLEGraph )

                bOK = SetGDIMetaFile( pOLEGraph->GetGDIMetaFile() );

        }

    }

    else

    {

        switch( nFormat )

        {

        case SotClipboardFormatId::LINK:

            if( m_xDdeLink.is() )

                bOK = SetObject( m_xDdeLink.get(), SWTRANSFER_OBJECTTYPE_DDE, rFlavor );

            break;

        case SotClipboardFormatId::OBJECTDESCRIPTOR:

        case SotClipboardFormatId::LINKSRCDESCRIPTOR:

            bOK = SetTransferableObjectDescriptor( m_aObjDesc );

            break;

        case SotClipboardFormatId::DRAWING:

            {

                SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

                bOK = SetObject( rDoc.getIDocumentDrawModelAccess().GetDrawModel(),

                                SWTRANSFER_OBJECTTYPE_DRAWMODEL, rFlavor );

            }

            break;

        case SotClipboardFormatId::STRING:

        {

            SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

            bOK = SetObject( &rDoc, SWTRANSFER_OBJECTTYPE_STRING, rFlavor );

        }

        break;

        case SotClipboardFormatId::RTF:

        {

            SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

            bOK = SetObject( &rDoc, SWTRANSFER_OBJECTTYPE_RTF, rFlavor );

        }

        break;

        case SotClipboardFormatId::RICHTEXT:

        {

            SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

            bOK = SetObject( &rDoc, SWTRANSFER_OBJECTTYPE_RICHTEXT, rFlavor );

        }

        break;

        case SotClipboardFormatId::MARKDOWN:

        {

            SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

            bOK = SetObject(&rDoc, SWTRANSFER_OBJECTTYPE_MARKDOWN, rFlavor);

            break;

        }

        case SotClipboardFormatId::HTML:

        {

            SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

            bOK = SetObject( &rDoc, SWTRANSFER_OBJECTTYPE_HTML, rFlavor );

        }

            break;

        case SotClipboardFormatId::SVXB:

            if( m_eBufferType & TransferBufferType::Graphic && m_pOrigGraphic )

                bOK = SetGraphic( *m_pOrigGraphic );

            break;

        case SotClipboardFormatId::GDIMETAFILE:

            if( m_eBufferType & TransferBufferType::Graphic )

                bOK = SetGDIMetaFile( m_oClpGraphic->GetGDIMetaFile() );

            break;

        case SotClipboardFormatId::BITMAP:

        case SotClipboardFormatId::PNG:

            // Neither pClpBitmap nor pClpGraphic are necessarily set

            if( (m_eBufferType & TransferBufferType::Graphic) && (m_oClpBitmap || m_oClpGraphic))

                bOK = SetBitmap((m_oClpBitmap ? m_oClpBitmap : m_oClpGraphic)->GetBitmap(), rFlavor);

            break;

        case SotClipboardFormatId::SVIM:

            if( m_pImageMap )

                bOK = SetImageMap( *m_pImageMap );

            break;

        case SotClipboardFormatId::INET_IMAGE:

            if( m_pTargetURL )

                bOK = SetINetImage( *m_pTargetURL, rFlavor );

            break;

        case SotClipboardFormatId::SOLK:

        case SotClipboardFormatId::NETSCAPE_BOOKMARK:

        case SotClipboardFormatId::FILEGRPDESCRIPTOR:

        case SotClipboardFormatId::FILECONTENT:

        case SotClipboardFormatId::UNIFORMRESOURCELOCATOR:

        case SotClipboardFormatId::SIMPLE_FILE:

            if( (TransferBufferType::InetField & m_eBufferType) && m_oBookmark )

                bOK = SetINetBookmark( *m_oBookmark, rFlavor );

            break;

        case SotClipboardFormatId::EMBED_SOURCE:

            if( !m_aDocShellRef.Is() )

            {

                SwDoc& rDoc = lcl_GetDoc(*m_pClpDocFac);

                m_aDocShellRef = new SwDocShell(rDoc, SfxObjectCreateMode::EMBEDDED);

                m_aDocShellRef->DoInitNew();

                SwTransferable::InitOle( m_aDocShellRef );

            }

            bOK = SetObject( &m_aDocShellRef, SWTRANSFER_OBJECTTYPE_SWOLE,

                            rFlavor );

            break;

        default: break;

        }

    }

    return bOK;

}

bool SwTransferable::WriteObject( SvStream& rOStream,

                                    void* pObject, sal_uInt32 nObjectType,

                                    const DataFlavor& /*rFlavor*/ )

{

    bool bRet = false;

    WriterRef xWrt;

    switch( nObjectType )

    {

    case SWTRANSFER_OBJECTTYPE_DRAWMODEL:

        {

            // don't change the sequence of commands

            SdrModel *pModel = static_cast<SdrModel*>(pObject);

            rOStream.SetBufferSize( 16348 );

            // for the changed pool defaults from drawing layer pool set those

            // attributes as hard attributes to preserve them for saving

            const SfxItemPool& rItemPool = pModel->GetItemPool();

            const SvxFontHeightItem& rDefaultFontHeight = rItemPool.GetUserOrPoolDefaultItem(EE_CHAR_FONTHEIGHT);

            // SW should have no MasterPages

            OSL_ENSURE(0 == pModel->GetMasterPageCount(), "SW with MasterPages (!)");

            for(sal_uInt16 a(0); a < pModel->GetPageCount(); a++)

            {

                const SdrPage* pPage = pModel->GetPage(a);

                SdrObjListIter aIter(pPage, SdrIterMode::DeepNoGroups);

                while(aIter.IsMore())

                {

                    SdrObject* pObj = aIter.Next();

                    const SvxFontHeightItem& rItem = pObj->GetMergedItem(EE_CHAR_FONTHEIGHT);

                    if(rItem.GetHeight() == rDefaultFontHeight.GetHeight())

                    {

                        pObj->SetMergedItem(rDefaultFontHeight);

                    }

                }

            }

            {

                uno::Reference<io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( rOStream ) );

                bRet = SvxDrawingLayerExport( pModel, xDocOut );

            }

            if (bRet)

                bRet = ERRCODE_NONE == rOStream.GetError();

        }

        break;

    case SWTRANSFER_OBJECTTYPE_SWOLE:

        {

            SfxObjectShell*   pEmbObj = static_cast<SfxObjectShell*>(pObject);

            try

            {

                ::utl::TempFileFast aTempFile;

                SvStream* pTempStream = aTempFile.GetStream(StreamMode::READWRITE);

                uno::Reference< embed::XStorage > xWorkStore =

                    ::comphelper::OStorageHelper::GetStorageFromStream( new utl::OStreamWrapper(*pTempStream), embed::ElementModes::READWRITE );

                // write document storage

                pEmbObj->SetupStorage( xWorkStore, SOFFICE_FILEFORMAT_CURRENT, false );

                // mba: no BaseURL for clipboard

                SfxMedium aMedium( xWorkStore, OUString() );

                pEmbObj->DoSaveObjectAs( aMedium, false );

                pEmbObj->DoSaveCompleted();

                uno::Reference< embed::XTransactedObject > xTransact( xWorkStore, uno::UNO_QUERY );

                if ( xTransact.is() )

                    xTransact->commit();

                rOStream.SetBufferSize( 0xff00 );

                rOStream.WriteStream( *pTempStream );

                xWorkStore->dispose();

                xWorkStore.clear();

            }

            catch (const uno::Exception&)

            {

            }

            bRet = ( rOStream.GetError() == ERRCODE_NONE );

        }

        break;

    case SWTRANSFER_OBJECTTYPE_DDE:

        {

            rOStream.SetBufferSize( 1024 );

            SwTransferDdeLink* pDdeLnk = static_cast<SwTransferDdeLink*>(pObject);

            if( pDdeLnk->WriteData( rOStream ) )

            {

                bRet = ERRCODE_NONE == rOStream.GetError();

            }

        }

        break;

    case SWTRANSFER_OBJECTTYPE_HTML:

    {

        // LOK is interested in getting images embedded for copy/paste support.

        GetHTMLWriter( comphelper::LibreOfficeKit::isActive() ? u"EmbedImages;NoPrettyPrint"_ustr : OUString(), OUString(), xWrt );

        break;

    }

    case SWTRANSFER_OBJECTTYPE_RTF:

    case SWTRANSFER_OBJECTTYPE_RICHTEXT:

        GetRTFWriter(std::u16string_view(), OUString(), xWrt);

        break;

    case SWTRANSFER_OBJECTTYPE_MARKDOWN:

    {

        GetMDWriter(std::u16string_view(), OUString(), xWrt);

        break;

    }

    case SWTRANSFER_OBJECTTYPE_STRING:

        GetASCWriter(std::u16string_view(), OUString(), xWrt);

        if( xWrt.is() )

        {

            SwAsciiOptions aAOpt;

            aAOpt.SetCharSet( RTL_TEXTENCODING_UTF8 );

            xWrt->SetAsciiOptions( aAOpt );

            // no start char for clipboard

            xWrt->m_bUCS2_WithStartChar = false;

        }

        break;

    default: break;

    }

    if( xWrt.is() )

    {

        SwDoc* pDoc = static_cast<SwDoc*>(pObject);

        xWrt->m_bWriteClipboardDoc = true;

        xWrt->m_bWriteOnlyFirstTable = bool(TransferBufferType::Table & m_eBufferType);

        xWrt->SetShowProgress(false);

#if defined(DEBUGPASTE)

        SvFileStream aPasteDebug(

            u"PASTEBUFFER.debug"_ustr, StreamMode::WRITE|StreamMode::TRUNC);

        SwWriter aDbgWrt( aPasteDebug, *pDoc );

        aDbgWrt.Write( xWrt );

#endif

        SwWriter aWrt( rOStream, *pDoc );

        if( ! aWrt.Write( xWrt ).IsError() )

        {

            rOStream.WriteChar( '\0' );               // terminate with a zero

            bRet = true;

        }

    }

    return bRet;

}

int SwTransferable::Cut()

{

    int nRet = Copy( true );

    if( nRet )

        DeleteSelection();

    collectUIInformation(u"CUT"_ustr, u"parameter"_ustr);

    return nRet;

}

void SwTransferable::DeleteSelection()

{

    if(!m_pWrtShell)

        return;

    // ask for type of selection before action-bracketing

    const SelectionType nSelection = m_pWrtShell->GetSelectionType();

    // cut rows or columns selected by enhanced table selection and wholly selected tables

    bool bCutMode = ( SelectionType::TableCell & nSelection ) && ( (SelectionType::TableRow | SelectionType::TableCol) & nSelection ||

        m_pWrtShell->HasWholeTabSelection() );

    m_pWrtShell->StartUndo( SwUndoId::START );

    if( bCutMode )

    {

        if( !(SelectionType::TableCol & nSelection) )

            m_pWrtShell->DeleteTable();

        else

        {

            SfxDispatcher* pDispatch = m_pWrtShell->GetView().GetViewFrame().GetDispatcher();

            pDispatch->Execute(FN_TABLE_DELETE_COL, SfxCallMode::SYNCHRON);

        }

    }

    else

    {

        if( ( SelectionType::Text | SelectionType::Table ) & nSelection )

            m_pWrtShell->IntelligentCut( nSelection );

        m_pWrtShell->DelRight();

    }

    m_pWrtShell->EndUndo( SwUndoId::END );

}

static void DeleteDDEAndReminderMarks(SwDoc & rDest)

{

    IDocumentMarkAccess *const pMarkAccess = rDest.getIDocumentMarkAccess();

    std::vector< ::sw::mark::MarkBase* > vMarks;

    // find all DDE-Bookmarks and Navigator-Reminders

    for (auto ppMark = pMarkAccess->getAllMarksBegin();

        ppMark != pMarkAccess->getAllMarksEnd();

        ++ppMark)

    {

        IDocumentMarkAccess::MarkType eMarkType = IDocumentMarkAccess::GetType(**ppMark);

        if (eMarkType == IDocumentMarkAccess::MarkType::DDE_BOOKMARK

            || eMarkType == IDocumentMarkAccess::MarkType::NAVIGATOR_REMINDER)

        {

            vMarks.push_back(*ppMark);

        }

    }

    // remove all DDE-Bookmarks, they are invalid inside the clipdoc!

    // and remove all Navigator-Reminders (tdf#165223)

    for (const auto& rpMark : vMarks)

    {

        pMarkAccess->deleteMark(rpMark);

    }

}

void SwTransferable::PrepareForCopyTextRange(SwPaM & rPaM)

{

    std::optional<SwWait> oWait;

    if (m_pWrtShell->ShouldWait())