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

#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/lang/XComponent.hpp>

#include <sot/filelist.hxx>

#include <editeng/editdata.hxx>

#include <svx/xfillit0.hxx>

#include <svx/xflclit.hxx>

#include <svx/xlnclit.hxx>

#include <svx/svdpagv.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/mieclip.hxx>

#include <svx/svdoole2.hxx>

#include <svx/svdograf.hxx>

#include <svx/svdundo.hxx>

#include <svl/itempool.hxx>

#include <sot/formats.hxx>

#include <editeng/outliner.hxx>

#include <svx/obj3d.hxx>

#include <svx/e3dundo.hxx>

#include <svx/unomodel.hxx>

#include <svx/ImageMapInfo.hxx>

#include <unotools/streamwrap.hxx>

#include <vcl/graph.hxx>

#include <vcl/metaact.hxx>

#include <vcl/metaactiontypes.hxx>

#include <vcl/pdfread.hxx>

#include <vcl/TypeSerializer.hxx>

#include <svx/svxids.hrc>

#include <toolkit/helper/vclunohelper.hxx>

#include <svtools/embedhlp.hxx>

#include <osl/diagnose.h>

#include <DrawDocShell.hxx>

#include <fupoor.hxx>

#include <tablefunction.hxx>

#include <Window.hxx>

#include <sdxfer.hxx>

#include <sdpage.hxx>

#include <drawdoc.hxx>

#include <sdmod.hxx>

#include <sdresid.hxx>

#include <strings.hrc>

#include <NotesPanelViewShell.hxx>

#include <SlideSorterViewShell.hxx>

#include <unomodel.hxx>

#include <ViewClipboard.hxx>

#include <sfx2/ipclient.hxx>

#include <sfx2/classificationhelper.hxx>

#include <comphelper/scopeguard.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <comphelper/storagehelper.hxx>

#include <comphelper/processfactory.hxx>

#include <svx/sdrhittesthelper.hxx>

#include <svx/xbtmpit.hxx>

#include <memory>

#include <SlideSorter.hxx>

#include <controller/SlideSorterController.hxx>

#include <controller/SlsClipboard.hxx>

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

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

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

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

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

namespace sd {

/*************************************************************************

|*

|* Paste

|*

\************************************************************************/

namespace {

struct ImpRememberOrigAndClone

{

    SdrObject*      pOrig;

    SdrObject*      pClone;

};

}

static SdrObject* ImpGetClone(std::vector<ImpRememberOrigAndClone>& aConnectorContainer, SdrObject const * pConnObj)

{

    for(const ImpRememberOrigAndClone& rImp : aConnectorContainer)

    {

        if(pConnObj == rImp.pOrig)

            return rImp.pClone;

    }

    return nullptr;

}

// restrict movement to WorkArea

static void ImpCheckInsertPos(Point& rPos, const Size& rSize, const ::tools::Rectangle& rWorkArea)

{

    if(rWorkArea.IsEmpty())

        return;

    ::tools::Rectangle aMarkRect(Point(rPos.X() - (rSize.Width() / 2), rPos.Y() - (rSize.Height() / 2)), rSize);

    if(aMarkRect.Contains(rWorkArea))

        return;

    if(aMarkRect.Left() < rWorkArea.Left())

    {

        rPos.AdjustX(rWorkArea.Left() - aMarkRect.Left() );

    }

    if(aMarkRect.Right() > rWorkArea.Right())

    {

        rPos.AdjustX( -(aMarkRect.Right() - rWorkArea.Right()) );

    }

    if(aMarkRect.Top() < rWorkArea.Top())

    {

        rPos.AdjustY(rWorkArea.Top() - aMarkRect.Top() );

    }

    if(aMarkRect.Bottom() > rWorkArea.Bottom())

    {

        rPos.AdjustY( -(aMarkRect.Bottom() - rWorkArea.Bottom()) );

    }

}

bool View::InsertMetaFile( const TransferableDataHelper& rDataHelper, const Point& rPos, ImageMap const * pImageMap, bool bOptimize )

{

    GDIMetaFile aMtf;

    if( !rDataHelper.GetGDIMetaFile( SotClipboardFormatId::GDIMETAFILE, aMtf ) )

        return false;

    bool bVector = false;

    Graphic aGraphic;

    // check if metafile only contains a pixel image, if so insert a bitmap instead

    if( bOptimize )

    {

        MetaAction* pAction = aMtf.FirstAction();

        while( pAction && !bVector )

        {

            switch( pAction->GetType() )

            {

                case MetaActionType::POINT:

                case MetaActionType::LINE:

                case MetaActionType::RECT:

                case MetaActionType::ROUNDRECT:

                case MetaActionType::ELLIPSE:

                case MetaActionType::ARC:

                case MetaActionType::PIE:

                case MetaActionType::CHORD:

                case MetaActionType::POLYLINE:

                case MetaActionType::POLYGON:

                case MetaActionType::POLYPOLYGON:

                case MetaActionType::TEXT:

                case MetaActionType::TEXTARRAY:

                case MetaActionType::STRETCHTEXT:

                case MetaActionType::TEXTRECT:

                case MetaActionType::GRADIENT:

                case MetaActionType::HATCH:

                case MetaActionType::WALLPAPER:

                case MetaActionType::EPS:

                case MetaActionType::TEXTLINE:

                case MetaActionType::FLOATTRANSPARENT:

                case MetaActionType::GRADIENTEX:

                case MetaActionType::BMPSCALEPART:

                case MetaActionType::BMPEXSCALEPART:

                    bVector = true;

                    break;

                case MetaActionType::BMP:

                case MetaActionType::BMPSCALE:

                case MetaActionType::BMPEX:

                case MetaActionType::BMPEXSCALE:

                    if( aGraphic.GetType() != GraphicType::NONE )

                    {

                        bVector = true;

                    }

                    else switch( pAction->GetType() )

                    {

                        case MetaActionType::BMP:

                            {

                                MetaBmpAction* pBmpAction = dynamic_cast< MetaBmpAction* >( pAction );

                                if( pBmpAction )

                                    aGraphic = Graphic(pBmpAction->GetBitmap());

                            }

                            break;

                        case MetaActionType::BMPSCALE:

                            {

                                MetaBmpScaleAction* pBmpScaleAction = dynamic_cast< MetaBmpScaleAction* >( pAction );

                                if( pBmpScaleAction )

                                    aGraphic = Graphic(pBmpScaleAction->GetBitmap());

                            }

                            break;

                        case MetaActionType::BMPEX:

                            {

                                MetaBmpExAction* pBmpExAction = dynamic_cast< MetaBmpExAction* >( pAction );

                                if( pBmpExAction )

                                    aGraphic = Graphic(pBmpExAction->GetBitmap());

                            }

                            break;

                        case MetaActionType::BMPEXSCALE:

                            {

                                MetaBmpExScaleAction* pBmpExScaleAction = dynamic_cast< MetaBmpExScaleAction* >( pAction );

                                if( pBmpExScaleAction )

                                    aGraphic = Graphic( pBmpExScaleAction->GetBitmap() );

                            }

                            break;

                        default: break;

                    }

                    break;

                default: break;

            }

            pAction = aMtf.NextAction();

        }

    }

    // it is not a vector metafile but it also has no graphic?

    if( !bVector && (aGraphic.GetType() == GraphicType::NONE) )

        bVector = true;

    // restrict movement to WorkArea

    Point aInsertPos( rPos );

    Size aImageSize = bVector ? aMtf.GetPrefSize() : aGraphic.GetSizePixel();

    ImpCheckInsertPos(aInsertPos, aImageSize, GetWorkArea());

    if( bVector )

        aGraphic = Graphic( aMtf );

    aGraphic.SetPrefMapMode( aMtf.GetPrefMapMode() );

    aGraphic.SetPrefSize( aMtf.GetPrefSize() );

    InsertGraphic( aGraphic, mnAction, aInsertPos, nullptr, pImageMap );

    return true;

}

bool View::InsertData( const TransferableDataHelper& rDataHelper,

                         const Point& rPos, sal_Int8& rDnDAction, bool bDrag,

                         SotClipboardFormatId nFormat, sal_uInt16 nPage, SdrLayerID nLayer )

{

    maDropPos = rPos;

    mnAction = rDnDAction;

    mbIsDropAllowed = false;

    bool                    bLink = ( ( mnAction & DND_ACTION_LINK ) != 0 );

    bool                    bCopy = ( ( ( mnAction & DND_ACTION_COPY ) != 0 ) || bLink );

    SdrInsertFlags          nPasteOptions = SdrInsertFlags::SETDEFLAYER;

    if (mpViewSh != nullptr)

    {

        OSL_ASSERT (mpViewSh->GetViewShell()!=nullptr);

        SfxInPlaceClient* pIpClient = mpViewSh->GetViewShell()->GetIPClient();

        if( dynamic_cast< ::sd::slidesorter::SlideSorterViewShell *>( mpViewSh ) !=  nullptr

            || (pIpClient!=nullptr && pIpClient->IsObjectInPlaceActive()))

            nPasteOptions |= SdrInsertFlags::DONTMARK;

    }

    SdrObject* pPickObj = nullptr;

    if( bDrag )

    {

        SdrPageView* pPV = nullptr;

        pPickObj = PickObj(rPos, getHitTolLog(), pPV);

    }

    SdPage* pPage = nullptr;

    if( nPage != SDRPAGE_NOTFOUND )

        pPage = static_cast<SdPage*>( mrDoc.GetPage( nPage ) );

    SdTransferable* pOwnData = nullptr;

    SdTransferable* pImplementation = SdTransferable::getImplementation( rDataHelper.GetTransferable() );

    if(pImplementation && (rDnDAction & DND_ACTION_LINK))

    {

        // suppress own data when it's intention is to use it as fill information

        pImplementation = nullptr;

    }

    bool bSelfDND = false;

    // try to get own transfer data

    if( pImplementation )

    {

        SdModule* mod = SdModule::get();

        if (mod->pTransferClip == pImplementation)

            pOwnData = mod->pTransferClip;

        else if (mod->pTransferDrag == pImplementation)

        {

            pOwnData = mod->pTransferDrag;

            bSelfDND = true;

        }

        else if (mod->pTransferSelection == pImplementation)

            pOwnData = mod->pTransferSelection;

    }

    const bool bGroupUndoFromDragWithDrop = bSelfDND && mpDragSrcMarkList && IsUndoEnabled();

    if (bGroupUndoFromDragWithDrop)

    {

        OUString aStr(SdResId(STR_UNDO_DRAGDROP));

        BegUndo(aStr + " " + mpDragSrcMarkList->GetMarkDescription());

    }

    // ImageMap?

    std::unique_ptr<ImageMap> pImageMap;

    if (!pOwnData && rDataHelper.HasFormat(SotClipboardFormatId::SVIM))

    {

        if (std::unique_ptr<SvStream> xStm = rDataHelper.GetSotStorageStream( SotClipboardFormatId::SVIM ) )

        {

            pImageMap.reset(new ImageMap);

            // mba: clipboard always must contain absolute URLs (could be from alien source)

            pImageMap->Read( *xStm );

        }

    }

    bool bTable = false;

    // check special cases for pasting table formats as RTL

    if( !bLink && (nFormat == SotClipboardFormatId::NONE || (nFormat == SotClipboardFormatId::RTF) || (nFormat == SotClipboardFormatId::RICHTEXT)) )

    {

        // if the object supports rtf and there is a table involved, default is to create a table

        bool bIsRTF = rDataHelper.HasFormat(SotClipboardFormatId::RTF);

        if( ( bIsRTF || rDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) )

            && ! rDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )

        {

            auto nFormatId = bIsRTF ? SotClipboardFormatId::RTF : SotClipboardFormatId::RICHTEXT;

            if (std::unique_ptr<SvStream> xStm = rDataHelper.GetSotStorageStream(nFormatId))

            {

                xStm->Seek( 0 );

                OStringBuffer aLine;

                while (xStm->ReadLine(aLine))

                {

                    size_t x = std::string_view(aLine).find( "\\trowd" );

                    if (x != std::string_view::npos)

                    {

                        bTable = true;

                        nFormat = bIsRTF ? SotClipboardFormatId::RTF : SotClipboardFormatId::RICHTEXT;

                        break;

                    }

                }

            }

        }

    }

    comphelper::ScopeGuard cleanupGuard(

        [this, &rDnDAction, bGroupUndoFromDragWithDrop]

        {

            MarkListHasChanged();

            mbIsDropAllowed = true;

            rDnDAction = mnAction;

            if (bGroupUndoFromDragWithDrop)

            {

                // this is called eventually by the underlying toolkit anyway in the case of a self-dnd

                // but we call it early in this case to group its undo actions into this open dnd undo group

                // and rely on that repeated calls to View::DragFinished are safe to do

                DragFinished(mnAction);

                EndUndo();

            }

        });

    auto ShouldTry = [nFormat, &rDataHelper](SotClipboardFormatId _def_Type)

    {

        return (nFormat == _def_Type || nFormat == SotClipboardFormatId::NONE)

               && rDataHelper.HasFormat(_def_Type);

    };

    if (pOwnData)

    {

        // Paste only if SfxClassificationHelper recommends so.

        const SfxObjectShellRef& pSource = pOwnData->GetDocShell();

        SfxObjectShell* pDestination = mrDoc.GetDocSh();

        if (pSource.is() && pDestination)

        {

            SfxClassificationCheckPasteResult eResult = SfxClassificationHelper::CheckPaste(pSource->getDocProperties(), pDestination->getDocProperties());

            if (!SfxClassificationHelper::ShowPasteInfo(eResult))

                return true;

        }

    }

    if (pOwnData && nFormat == SotClipboardFormatId::NONE)

    {

        const View* pSourceView = pOwnData->GetView();

        if( pOwnData->GetDocShell().is() && pOwnData->IsPageTransferable() )

        {

            mpClipboard->HandlePageDrop (*pOwnData);

            return true;

        }

        else if( pSourceView )

        {

            if( pSourceView == this )

            {

                // same view

                if( nLayer != SDRLAYER_NOTFOUND )

                {

                    // drop on layer tab bar

                    SdrLayerAdmin&  rLayerAdmin = mrDoc.GetLayerAdmin();

                    SdrLayer*       pLayer = rLayerAdmin.GetLayerPerID( nLayer );

                    SdrPageView*    pPV = GetSdrPageView();

                    OUString        aLayer = pLayer->GetName();

                    if( !pPV->IsLayerLocked( aLayer ) )

                    {

                        pOwnData->SetInternalMove( true );

                        const SdrMarkList& rMarkList = GetMarkedObjectList();

                        rMarkList.ForceSort();

                        for( size_t nM = 0; nM < rMarkList.GetMarkCount(); ++nM )

                        {

                            SdrMark*    pM = rMarkList.GetMark( nM );

                            SdrObject*  pO = pM->GetMarkedSdrObj();

                            if( pO )

                            {

                                // #i11702#

                                if( IsUndoEnabled() )

                                {

                                    BegUndo(SdResId(STR_MODIFYLAYER));

                                    AddUndo(GetModel().GetSdrUndoFactory().CreateUndoObjectLayerChange(*pO, pO->GetLayer(), nLayer));

                                    EndUndo();

                                }

                                pO->SetLayer( nLayer );

                            }

                        }

                        return true;

                    }

                }

                else

                {

                    SdrPageView*    pPV = GetSdrPageView();

                    bool            bDropOnTabBar = true;

                    if( !pPage && pPV->GetPage()->GetPageNum() != mnDragSrcPgNum )

                    {

                        pPage = static_cast<SdPage*>( pPV->GetPage() );

                        bDropOnTabBar = false;

                    }

                    if( pPage )

                    {

                        // drop on other page

                        OUString aActiveLayer = GetActiveLayer();

                        if( !pPV->IsLayerLocked( aActiveLayer ) )

                        {

                            if( !IsPresObjSelected() )

                            {

                                SdrMarkList* pMarkList;

                                if( (mnDragSrcPgNum != SDRPAGE_NOTFOUND) && (mnDragSrcPgNum != pPV->GetPage()->GetPageNum()) )

                                {

                                    pMarkList = mpDragSrcMarkList.get();

                                }

                                else

                                {

                                    // actual mark list is used

                                    pMarkList = new SdrMarkList( GetMarkedObjectList());

                                }

                                pMarkList->ForceSort();

                                // stuff to remember originals and clones

                                std::vector<ImpRememberOrigAndClone> aConnectorContainer;

                                size_t nConnectorCount = 0;

                                Point       aCurPos;

                                // calculate real position of current

                                // source objects, if necessary (#103207)

                                if (pOwnData == SdModule::get()->pTransferSelection)

                                {

                                    ::tools::Rectangle aCurBoundRect;

                                    if( pMarkList->TakeBoundRect( pPV, aCurBoundRect ) )

                                        aCurPos = aCurBoundRect.TopLeft();

                                    else

                                        aCurPos = pOwnData->GetStartPos();

                                }

                                else

                                    aCurPos = pOwnData->GetStartPos();

                                const Size aVector( maDropPos.X() - aCurPos.X(), maDropPos.Y() - aCurPos.Y() );

                                std::unordered_set<rtl::OUString> aNameSet;

                                for(size_t a = 0; a < pMarkList->GetMarkCount(); ++a)

                                {

                                    SdrMark* pM = pMarkList->GetMark(a);

                                    rtl::Reference<SdrObject> pObj(pM->GetMarkedSdrObj()->CloneSdrObject(pPage->getSdrModelFromSdrPage()));

                                    if(pObj)

                                    {

                                        if(!bDropOnTabBar)

                                        {

                                            // do a NbcMove(...) instead of setting SnapRects here

                                            pObj->NbcMove(aVector);

                                        }

                                        SdrObject* pMarkParent = pM->GetMarkedSdrObj()->getParentSdrObjectFromSdrObject();

                                        if (bCopy || (pMarkParent && pMarkParent->IsGroupObject()))

                                            pPage->InsertObjectThenMakeNameUnique(pObj.get(), aNameSet);

                                        else

                                            pPage->InsertObject(pObj.get());

                                        if( IsUndoEnabled() )

                                        {

                                            BegUndo(SdResId(STR_UNDO_DRAGDROP));

                                            AddUndo(GetModel().GetSdrUndoFactory().CreateUndoNewObject(*pObj));

                                            EndUndo();

                                        }

                                        ImpRememberOrigAndClone aRem;

                                        aRem.pOrig = pM->GetMarkedSdrObj();

                                        aRem.pClone = pObj.get();

                                        aConnectorContainer.push_back(aRem);

                                        if(dynamic_cast< SdrEdgeObj *>( pObj.get() ) !=  nullptr)

                                            nConnectorCount++;

                                    }

                                }

                                // try to re-establish connections at clones

                                if(nConnectorCount)

                                {

                                    for(size_t a = 0; a < aConnectorContainer.size(); ++a)

                                    {

                                        ImpRememberOrigAndClone* pRem = &aConnectorContainer[a];

                                        if(auto pCloneEdge = dynamic_cast<SdrEdgeObj *>( pRem->pClone ))

                                        {

                                            SdrEdgeObj* pOrigEdge = static_cast<SdrEdgeObj*>(pRem->pOrig);

                                            // test first connection

                                            SdrObjConnection& rConn0 = pOrigEdge->GetConnection(false);

                                            SdrObject* pConnObj = rConn0.GetSdrObject();

                                            if(pConnObj)

                                            {

                                                SdrObject* pConnClone = ImpGetClone(aConnectorContainer, pConnObj);

                                                if(pConnClone)

                                                {

                                                    // if dest obj was cloned, too, re-establish connection

                                                    pCloneEdge->ConnectToNode(false, pConnClone);

                                                    pCloneEdge->GetConnection(false).SetConnectorId(rConn0.GetConnectorId());

                                                }

                                                else

                                                {

                                                    // set position of connection point of original connected object

                                                    const SdrGluePointList* pGlueList = pConnObj->GetGluePointList();

                                                    if(pGlueList)

                                                    {

                                                        sal_uInt16 nInd = pGlueList->FindGluePoint(rConn0.GetConnectorId());

                                                        if(SDRGLUEPOINT_NOTFOUND != nInd)

                                                        {

                                                            const SdrGluePoint& rGluePoint = (*pGlueList)[nInd];

                                                            Point aPosition = rGluePoint.GetAbsolutePos(*pConnObj);

                                                            aPosition.AdjustX(aVector.Width() );

                                                            aPosition.AdjustY(aVector.Height() );

                                                            pCloneEdge->SetTailPoint(false, aPosition);

                                                        }

                                                    }

                                                }

                                            }

                                            // test second connection

                                            SdrObjConnection& rConn1 = pOrigEdge->GetConnection(true);

                                            pConnObj = rConn1.GetSdrObject();

                                            if(pConnObj)

                                            {

                                                SdrObject* pConnClone = ImpGetClone(aConnectorContainer, pConnObj);

                                                if(pConnClone)

                                                {

                                                    // if dest obj was cloned, too, re-establish connection

                                                    pCloneEdge->ConnectToNode(true, pConnClone);

                                                    pCloneEdge->GetConnection(true).SetConnectorId(rConn1.GetConnectorId());

                                                }

                                                else

                                                {

                                                    // set position of connection point of original connected object

                                                    const SdrGluePointList* pGlueList = pConnObj->GetGluePointList();

                                                    if(pGlueList)

                                                    {

                                                        sal_uInt16 nInd = pGlueList->FindGluePoint(rConn1.GetConnectorId());

                                                        if(SDRGLUEPOINT_NOTFOUND != nInd)

                                                        {

                                                            const SdrGluePoint& rGluePoint = (*pGlueList)[nInd];

                                                            Point aPosition = rGluePoint.GetAbsolutePos(*pConnObj);

                                                            aPosition.AdjustX(aVector.Width() );

                                                            aPosition.AdjustY(aVector.Height() );

                                                            pCloneEdge->SetTailPoint(true, aPosition);

                                                        }

                                                    }

                                                }

                                            }

                                        }

                                    }

                                }

                                if( pMarkList != mpDragSrcMarkList.get() )

                                    delete pMarkList;

                                return true;

                            }

                            else

                            {

                                maDropErrorIdle.Start();

                            }

                        }

                    }

                    else

                    {

                        pOwnData->SetInternalMove( true );

                        MoveAllMarked( Size( maDropPos.X() - pOwnData->GetStartPos().X(),

                                             maDropPos.Y() - pOwnData->GetStartPos().Y() ), bCopy );

                        return true;

                    }

                }

            }

            else

            {

                // different views

                if( !pSourceView->IsPresObjSelected() )

                {

                    // model is owned by from AllocModel() created DocShell

                    SdDrawDocument* pSourceDoc = static_cast<SdDrawDocument*>(&pSourceView->GetModel());

                    pSourceDoc->CreatingDataObj( pOwnData );

                    SdDrawDocument* pModel = static_cast<SdDrawDocument*>( pSourceView->CreateMarkedObjModel().release() );

                    bool bReturn = Paste(*pModel, maDropPos, pPage, nPasteOptions);

                    if( !pPage )

                        pPage = static_cast<SdPage*>( GetSdrPageView()->GetPage() );

                    OUString aLayout = pPage->GetLayoutName();

                    sal_Int32 nPos = aLayout.indexOf(SD_LT_SEPARATOR);

                    if (nPos != -1)

                        aLayout = aLayout.copy(0, nPos);

                    pPage->SetPresentationLayout( aLayout, false, false );

                    pSourceDoc->CreatingDataObj( nullptr );

                    if (bReturn)

                        return true;

                }

                else

                {

                    maDropErrorIdle.Start();

                }

            }

        }

        else

        {

            SdDrawDocument* pWorkModel = const_cast<SdDrawDocument*>(pOwnData->GetWorkDocument());

            SdPage*         pWorkPage = pWorkModel->GetSdPage( 0, PageKind::Standard );

            pWorkPage->SetSdrObjListRectsDirty();

            // tdf#118171 - snap rectangles of objects without line width

            const Size aSize(pWorkPage->GetAllObjSnapRect().GetSize());

            maDropPos.setX( pOwnData->GetBoundStartPos().X() + ( aSize.Width() >> 1 ) );

            maDropPos.setY( pOwnData->GetBoundStartPos().Y() + ( aSize.Height() >> 1 ) );

            // delete pages, that are not of any interest for us

            for( ::tools::Long i = pWorkModel->GetPageCount() - 1; i >= 0; i-- )

            {

                SdPage* pP = static_cast< SdPage* >( pWorkModel->GetPage( static_cast<sal_uInt16>(i) ) );

                if( pP->GetPageKind() != PageKind::Standard )

                    pWorkModel->DeletePage( static_cast<sal_uInt16>(i) );

            }

            bool bReturn = Paste(*pWorkModel, maDropPos, pPage, nPasteOptions);

            if( !pPage )

                pPage = static_cast<SdPage*>( GetSdrPageView()->GetPage() );

            OUString aLayout = pPage->GetLayoutName();

            sal_Int32 nPos = aLayout.indexOf(SD_LT_SEPARATOR);

            if (nPos != -1)

                aLayout = aLayout.copy(0, nPos);

            pPage->SetPresentationLayout( aLayout, false, false );

            if (bReturn)

                return true;

        }

    }

    if (ShouldTry(SotClipboardFormatId::PDF))

    {

        if (std::unique_ptr<SvStream> xStm = rDataHelper.GetSotStorageStream( SotClipboardFormatId::PDF ))

        {

            Point aInsertPos(rPos);

            Graphic aGraphic;

            if (vcl::ImportPDF(*xStm, aGraphic))

            {

                const sal_uInt64 nGraphicContentSize(xStm->Tell());

                xStm->Seek(0);

                BinaryDataContainer aGraphicContent(*xStm, nGraphicContentSize);

                aGraphic.SetGfxLink(std::make_shared<GfxLink>(aGraphicContent, GfxLinkType::NativePdf));

                InsertGraphic(aGraphic, mnAction, aInsertPos, nullptr, nullptr);

                return true;

            }

        }

    }

    if (ShouldTry(SotClipboardFormatId::EMBED_SOURCE))

    {

        if (::sd::slidesorter::SlideSorterViewShell* pSlideSorterViewShell =

                ::sd::slidesorter::SlideSorterViewShell::GetSlideSorter(

                    mrDoc.GetDocSh()->GetViewShell()->GetViewShellBase()))

        {

            if (pSlideSorterViewShell->GetSlideSorter().GetController().GetClipboard().PasteSlidesFromSystemClipboard())

                return true;

        }

    }

    if (ShouldTry(SotClipboardFormatId::DRAWING))

    {

        if (std::unique_ptr<SvStream> xStm = rDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING ))

        {

            DrawDocShellRef xShell = new DrawDocShell(SfxObjectCreateMode::INTERNAL, false, DocumentType::Impress);

            xShell->DoInitNew();

            SdDrawDocument* pModel = xShell->GetDoc();

            pModel->InsertPage(pModel->AllocPage(false).get());

            Reference< XComponent > xComponent = xShell->GetModel();

            xStm->Seek( 0 );

            css::uno::Reference< css::io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) );

            bool bReturn = SvxDrawingLayerImport( pModel, xInputStream, xComponent, "com.sun.star.comp.Impress.XMLOasisImporter" );

            if( pModel->GetPageCount() == 0 )

            {

                OSL_FAIL("empty or invalid drawing xml document on clipboard!" );

            }

            else

            {

                bool bChanged = false;

                if (bReturn && (mnAction & (DND_ACTION_MOVE | DND_ACTION_LINK)))

                {

                    if( pModel->GetSdPage( 0, PageKind::Standard )->GetObjCount() == 1 )

                    {

                        // only one object

                        SdrObject*      pObj = pModel->GetSdPage( 0, PageKind::Standard )->GetObj( 0 );

                        SdrPageView*    pPV = nullptr;

                        SdrObject* pPickObj2 = PickObj(rPos, getHitTolLog(), pPV);

                        if( ( mnAction & DND_ACTION_MOVE ) && pPickObj2 && pObj )

                        {

                            // replace object

                            SdrPage* pWorkPage = GetSdrPageView()->GetPage();

                            rtl::Reference<SdrObject> pNewObj(pObj->CloneSdrObject(pWorkPage->getSdrModelFromSdrPage()));

                            ::tools::Rectangle   aPickObjRect( pPickObj2->GetCurrentBoundRect() );

                            Size        aPickObjSize( aPickObjRect.GetSize() );

                            Point       aVec( aPickObjRect.TopLeft() );

                            ::tools::Rectangle   aObjRect( pNewObj->GetCurrentBoundRect() );

                            Size        aObjSize( aObjRect.GetSize() );

                            double aScaleWidth = double( aPickObjSize.Width() ) / aObjSize.Width();

                            double aScaleHeight = double( aPickObjSize.Height() ) / aObjSize.Height();

                            pNewObj->NbcResize( aObjRect.TopLeft(), aScaleWidth, aScaleHeight );

                            aVec -= aObjRect.TopLeft();

                            pNewObj->NbcMove( Size( aVec.X(), aVec.Y() ) );

                            const bool bUndo = IsUndoEnabled();

                            if( bUndo )

                                BegUndo(SdResId(STR_UNDO_DRAGDROP));

                            pNewObj->NbcSetLayer( pPickObj2->GetLayer() );

                            pWorkPage->InsertObject( pNewObj.get() );

                            if( bUndo )

                            {

                                AddUndo( mrDoc.GetSdrUndoFactory().CreateUndoNewObject( *pNewObj ) );

                                AddUndo( mrDoc.GetSdrUndoFactory().CreateUndoDeleteObject( *pPickObj2 ) );

                            }

                            pWorkPage->RemoveObject( pPickObj2->GetOrdNum() );

                            if( bUndo )

                            {

                                EndUndo();

                            }

                            bChanged = true;

                            mnAction = DND_ACTION_COPY;

                        }

                        else if( ( mnAction & DND_ACTION_LINK ) && pPickObj2 && pObj &&

                            dynamic_cast< const SdrGrafObj *>( pPickObj2 ) ==  nullptr &&

                                dynamic_cast< const SdrOle2Obj *>( pPickObj2 ) ==  nullptr )

                        {

                            SfxItemSet aSet( mrDoc.GetPool() );

                            // set new attributes to object

                            const bool bUndo = IsUndoEnabled();

                            if( bUndo )

                            {

                                BegUndo( SdResId(STR_UNDO_DRAGDROP) );

                                AddUndo( mrDoc.GetSdrUndoFactory().CreateUndoAttrObject( *pPickObj2 ) );

                            }

                            aSet.Put( pObj->GetMergedItemSet() );

                            /* Do not take over corner radius. There are

                               gradients (rectangles) in the gallery with corner

                               radius of 0. We should not use that on the

                               object. */

                            aSet.ClearItem( SDRATTR_CORNER_RADIUS );

                            const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pObj);

                            if(pSdrGrafObj)

                            {

                                // If we have a graphic as source object, use its graphic

                                // content as fill style

                                aSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP));

                                aSet.Put(XFillBitmapItem(pSdrGrafObj->GetGraphic()));

                            }

                            pPickObj2->SetMergedItemSetAndBroadcast( aSet );

                            if( DynCastE3dObject( pPickObj2 ) && DynCastE3dObject( pObj ) )

                            {

                                // handle 3D attribute in addition

                                SfxItemSet aNewSet(SfxItemSet::makeFixedSfxItemSet<SID_ATTR_3D_START, SID_ATTR_3D_END>( mrDoc.GetPool() ));

                                SfxItemSet aOldSet(SfxItemSet::makeFixedSfxItemSet<SID_ATTR_3D_START, SID_ATTR_3D_END>( mrDoc.GetPool() ));

                                aOldSet.Put(pPickObj2->GetMergedItemSet());

                                aNewSet.Put( pObj->GetMergedItemSet() );

                                if( bUndo )

                                    AddUndo(

                                        std::make_unique<E3dAttributesUndoAction>(

                                            *static_cast< E3dObject* >(pPickObj2),

                                            aNewSet,

                                            aOldSet));

                                pPickObj2->SetMergedItemSetAndBroadcast( aNewSet );

                            }

                            if( bUndo )

                                EndUndo();

                            bChanged = true;

                        }

                    }

                }

                if( !bChanged )

                {

                    SdrPage* pWorkPage = pModel->GetSdPage( 0, PageKind::Standard );

                    pWorkPage->SetSdrObjListRectsDirty();