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

#include <com/sun/star/beans/XPropertySet.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <com/sun/star/document/XEventListener.hpp>

#include <com/sun/star/container/XChild.hpp>

#include <com/sun/star/document/XStorageBasedDocument.hpp>

#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>

#include <cppuhelper/exc_hlp.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <svtools/colorcfg.hxx>

#include <svtools/embedhlp.hxx>

#include <sfx2/objsh.hxx>

#include <sfx2/ipclient.hxx>

#include <sfx2/lnkbase.hxx>

#include <sfx2/linkmgr.hxx>

#include <tools/debug.hxx>

#include <tools/globname.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/classids.hxx>

#include <comphelper/propertyvalue.hxx>

#include <sot/formats.hxx>

#include <cppuhelper/implbase.hxx>

#include <vcl/svapp.hxx>

#include <vcl/unohelp.hxx>

#include <svx/svdmodel.hxx>

#include <svx/dialmgr.hxx>

#include <svx/strings.hrc>

#include <svx/svdetc.hxx>

#include <unomlstr.hxx>

#include <sdr/contact/viewcontactofsdrole2obj.hxx>

#include <svx/svdograf.hxx>

#include <sdr/properties/oleproperties.hxx>

#include <svx/unoshape.hxx>

#include <svx/xlineit0.hxx>

#include <svx/xlnclit.hxx>

#include <svx/xbtmpit.hxx>

#include <svx/xfillit0.hxx>

#include <svx/xflbmtit.hxx>

#include <svx/xflbstit.hxx>

#include <basegfx/matrix/b2dhommatrix.hxx>

#include <basegfx/polygon/b2dpolypolygon.hxx>

#include <editeng/outlobj.hxx>

#include <svx/svdpage.hxx>

#include <rtl/ustrbuf.hxx>

#include <rtl/ref.hxx>

#include <bitmaps.hlst>

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

static uno::Reference < beans::XPropertySet > lcl_getFrame_throw(const SdrOle2Obj* _pObject)

{

    uno::Reference < beans::XPropertySet > xFrame;

    if ( _pObject )

    {

        uno::Reference< frame::XController> xController = _pObject->GetParentXModel()->getCurrentController();

        if ( xController.is() )

        {

            xFrame.set( xController->getFrame(),uno::UNO_QUERY_THROW);

        }

    } // if ( _pObject )

    return xFrame;

}

namespace {

class SdrLightEmbeddedClient_Impl : public ::cppu::WeakImplHelper

                                                            < embed::XStateChangeListener

                                                            , document::XEventListener

                                                            , embed::XInplaceClient

                                                            , embed::XEmbeddedClient

                                                            , embed::XWindowSupplier

                                                            >

{

    uno::Reference< awt::XWindow > m_xWindow;

    SdrOle2Obj* mpObj;

    Fraction m_aScaleWidth;

    Fraction m_aScaleHeight;

public:

    explicit SdrLightEmbeddedClient_Impl( SdrOle2Obj* pObj );

    virtual ~SdrLightEmbeddedClient_Impl() override;

    void SetSizeScale( const Fraction& aScaleWidth, const Fraction& aScaleHeight )

    {

        m_aScaleWidth = aScaleWidth;

        m_aScaleHeight = aScaleHeight;

    }

    const Fraction& GetScaleWidth() const { return m_aScaleWidth; }

    const Fraction& GetScaleHeight() const { return m_aScaleHeight; }

    void setWindow(const uno::Reference< awt::XWindow >& _xWindow);

    void disconnect();

private:

    tools::Rectangle impl_getScaledRect_nothrow() const;

    // XStateChangeListener

    virtual void SAL_CALL changingState( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override;

    virtual void SAL_CALL stateChanged( const css::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) override;

    virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override;

    // document::XEventListener

    virtual void SAL_CALL       notifyEvent( const document::EventObject& aEvent ) override;

    // XEmbeddedClient

    virtual void SAL_CALL saveObject() override;

    virtual void SAL_CALL visibilityChanged( sal_Bool bVisible ) override;

    // XComponentSupplier

    virtual uno::Reference< util::XCloseable > SAL_CALL getComponent() override;

    // XInplaceClient

    virtual sal_Bool SAL_CALL canInplaceActivate() override;

    virtual void SAL_CALL activatingInplace() override;

    virtual void SAL_CALL activatingUI() override;

    virtual void SAL_CALL deactivatedInplace() override;

    virtual void SAL_CALL deactivatedUI() override;

    virtual uno::Reference< css::frame::XLayoutManager > SAL_CALL getLayoutManager() override;

    virtual uno::Reference< frame::XDispatchProvider > SAL_CALL getInplaceDispatchProvider() override;

    virtual awt::Rectangle SAL_CALL getPlacement() override;

    virtual awt::Rectangle SAL_CALL getClipRectangle() override;

    virtual void SAL_CALL translateAccelerators( const uno::Sequence< awt::KeyEvent >& aKeys ) override;

    virtual void SAL_CALL scrollObject( const awt::Size& aOffset ) override;

    virtual void SAL_CALL changedPlacement( const awt::Rectangle& aPosRect ) override;

    // XWindowSupplier

    virtual uno::Reference< awt::XWindow > SAL_CALL getWindow() override;

};

}

SdrLightEmbeddedClient_Impl::SdrLightEmbeddedClient_Impl( SdrOle2Obj* pObj )

: mpObj( pObj )

{

}

SdrLightEmbeddedClient_Impl::~SdrLightEmbeddedClient_Impl()

{

    assert(!mpObj);

}

tools::Rectangle SdrLightEmbeddedClient_Impl::impl_getScaledRect_nothrow() const

{

    tools::Rectangle aLogicRect( mpObj->GetLogicRect() );

    // apply scaling to object area and convert to pixels

    aLogicRect.SetSize( Size( tools::Long( aLogicRect.GetWidth() * m_aScaleWidth),

                              tools::Long( aLogicRect.GetHeight() * m_aScaleHeight) ) );

    return aLogicRect;

}

void SAL_CALL SdrLightEmbeddedClient_Impl::changingState( const css::lang::EventObject& /*aEvent*/, ::sal_Int32 /*nOldState*/, ::sal_Int32 /*nNewState*/ )

{

}

void SAL_CALL SdrLightEmbeddedClient_Impl::stateChanged( const css::lang::EventObject& /*aEvent*/, ::sal_Int32 nOldState, ::sal_Int32 nNewState )

{

    SolarMutexGuard aGuard;

    if ( mpObj && nOldState == embed::EmbedStates::LOADED && nNewState == embed::EmbedStates::RUNNING )

    {

        mpObj->ObjectLoaded();

        GetSdrGlobalData().GetOLEObjCache().InsertObj(mpObj);

    }

    else if ( mpObj && nNewState == embed::EmbedStates::LOADED && nOldState == embed::EmbedStates::RUNNING )

    {

        GetSdrGlobalData().GetOLEObjCache().RemoveObj(mpObj);

    }

}

void SdrLightEmbeddedClient_Impl::disconnect()

{

    SolarMutexGuard aGuard;

    if (!mpObj)

        return;

    GetSdrGlobalData().GetOLEObjCache().RemoveObj(mpObj);

    mpObj = nullptr;

}

void SAL_CALL SdrLightEmbeddedClient_Impl::disposing( const css::lang::EventObject& /*aEvent*/ )

{

    disconnect();

}

void SAL_CALL SdrLightEmbeddedClient_Impl::notifyEvent( const document::EventObject& aEvent )

{

    // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl

    SolarMutexGuard aGuard;

    // the code currently makes sense only in case there is no other client

    if ( !(mpObj && mpObj->GetAspect() != embed::Aspects::MSOLE_ICON && aEvent.EventName == "OnVisAreaChanged"

      && mpObj->GetObjRef().is() && mpObj->GetObjRef()->getClientSite() == uno::Reference< embed::XEmbeddedClient >( this )) )

        return;

    try

    {

        MapUnit aContainerMapUnit( MapUnit::Map100thMM );

        uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY );

        if ( xParentVis.is() )

            aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) );

        MapUnit aObjMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpObj->GetObjRef()->getMapUnit( mpObj->GetAspect() ) );

        tools::Rectangle          aVisArea;

        awt::Size aSz;

        try

        {

            aSz = mpObj->GetObjRef()->getVisualAreaSize( mpObj->GetAspect() );

        }

        catch( embed::NoVisualAreaSizeException& )

        {

            TOOLS_WARN_EXCEPTION("svx.svdraw", "No visual area size!");

            aSz.Width = 5000;

            aSz.Height = 5000;

        }

        catch( uno::Exception& )

        {

            TOOLS_WARN_EXCEPTION("svx.svdraw", "");

            aSz.Width = 5000;

            aSz.Height = 5000;

        }

        aVisArea.SetSize( Size( aSz.Width, aSz.Height ) );

        aVisArea = OutputDevice::LogicToLogic(aVisArea, MapMode(aObjMapUnit), MapMode(aContainerMapUnit));

        Size aScaledSize( static_cast< tools::Long >( m_aScaleWidth * Fraction( aVisArea.GetWidth() ) ),

                            static_cast< tools::Long >( m_aScaleHeight * Fraction( aVisArea.GetHeight() ) ) );

        tools::Rectangle aLogicRect( mpObj->GetLogicRect() );

        // react to the change if the difference is bigger than one pixel

        Size aPixelDiff =

            Application::GetDefaultDevice()->LogicToPixel(

                Size( aLogicRect.GetWidth() - aScaledSize.Width(),

                      aLogicRect.GetHeight() - aScaledSize.Height() ),

                MapMode(aContainerMapUnit));

        if( aPixelDiff.Width() || aPixelDiff.Height() )

        {

            mpObj->SetLogicRect( tools::Rectangle( aLogicRect.TopLeft(), aScaledSize ) );

            mpObj->BroadcastObjectChange();

        }

        else

            mpObj->ActionChanged();

    }

    catch( uno::Exception& )

    {

        TOOLS_WARN_EXCEPTION("svx.svdraw", "");

    }

}

void SAL_CALL SdrLightEmbeddedClient_Impl::saveObject()

{

    // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl

    uno::Reference< embed::XCommonEmbedPersist > xPersist;

    uno::Reference< util::XModifiable > xModifiable;

    {

        SolarMutexGuard aGuard;

        if ( !mpObj )

            throw embed::ObjectSaveVetoException();

        // the common persistence is supported by objects and links

        xPersist.set( mpObj->GetObjRef(), uno::UNO_QUERY_THROW );

        xModifiable.set( mpObj->GetParentXModel(), uno::UNO_QUERY );

    }

    xPersist->storeOwn();

    if ( xModifiable.is() )

        xModifiable->setModified( true );

}

void SAL_CALL SdrLightEmbeddedClient_Impl::visibilityChanged( sal_Bool /*bVisible*/ )

{

    // nothing to do currently

    // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl

    if ( mpObj )

    {

        tools::Rectangle aLogicRect( mpObj->GetLogicRect() );

        Size aLogicSize( aLogicRect.GetWidth(), aLogicRect.GetHeight() );

        if( mpObj->IsChart() )

        {

            //charts never should be stretched see #i84323# for example

            mpObj->SetLogicRect( tools::Rectangle( aLogicRect.TopLeft(), aLogicSize ) );

            mpObj->BroadcastObjectChange();

        } // if( mpObj->IsChart() )

    }

}

uno::Reference< util::XCloseable > SAL_CALL SdrLightEmbeddedClient_Impl::getComponent()

{

    uno::Reference< util::XCloseable > xResult;

    SolarMutexGuard aGuard;

    if ( mpObj )

        xResult.set( mpObj->GetParentXModel(), uno::UNO_QUERY );

    return xResult;

}

// XInplaceClient

sal_Bool SAL_CALL SdrLightEmbeddedClient_Impl::canInplaceActivate()

{

    bool bRet = false;

    SolarMutexGuard aGuard;

    if ( mpObj )

    {

        uno::Reference< embed::XEmbeddedObject > xObject = mpObj->GetObjRef();

        if ( !xObject.is() )

            throw uno::RuntimeException();

        // we don't want to switch directly from outplace to inplace mode

        bRet = ( xObject->getCurrentState() != embed::EmbedStates::ACTIVE && mpObj->GetAspect() != embed::Aspects::MSOLE_ICON );

    } // if ( mpObj )

    return bRet;

}

void SAL_CALL SdrLightEmbeddedClient_Impl::activatingInplace()

{

}

void SAL_CALL SdrLightEmbeddedClient_Impl::activatingUI()

{

    SolarMutexGuard aGuard;

    uno::Reference < beans::XPropertySet > xFrame( lcl_getFrame_throw(mpObj));

    uno::Reference < frame::XFrame > xOwnFrame( xFrame,uno::UNO_QUERY);

    uno::Reference < frame::XFramesSupplier > xParentFrame = xOwnFrame->getCreator();

    if ( xParentFrame.is() )

        xParentFrame->setActiveFrame( xOwnFrame );

    OLEObjCache& rObjCache = GetSdrGlobalData().GetOLEObjCache();

    const size_t nCount = rObjCache.size();

    for(sal_Int32 i = nCount-1 ; i >= 0;--i)

    {

        SdrOle2Obj* pObj = rObjCache[i];

        if ( pObj != mpObj )

        {

            // only deactivate ole objects which belongs to the same frame

            if ( xFrame == lcl_getFrame_throw(pObj) )

            {

                const uno::Reference< embed::XEmbeddedObject >& xObject = pObj->GetObjRef();

                try

                {

                    if ( xObject->getStatus( pObj->GetAspect() ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE )

                        xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );

                    else

                    {

                        // the links should not stay in running state for long time because of locking

                        uno::Reference< embed::XLinkageSupport > xLink( xObject, uno::UNO_QUERY );

                        if ( xLink.is() && xLink->isLink() )

                            xObject->changeState( embed::EmbedStates::LOADED );

                        else

                            xObject->changeState( embed::EmbedStates::RUNNING );

                    }

                }

                catch (css::uno::Exception& )

                {}

            }

        }

    } // for(sal_Int32 i = nCount-1 ; i >= 0;--i)

}

void SAL_CALL SdrLightEmbeddedClient_Impl::deactivatedInplace()

{

}

void SAL_CALL SdrLightEmbeddedClient_Impl::deactivatedUI()

{

    SolarMutexGuard aGuard;

    css::uno::Reference< css::frame::XLayoutManager > xLayoutManager(getLayoutManager());

    if ( xLayoutManager.is() )

    {

        static constexpr OUString aMenuBarURL = u"private:resource/menubar/menubar"_ustr;

        if ( !xLayoutManager->isElementVisible( aMenuBarURL ) )

            xLayoutManager->createElement( aMenuBarURL );

    }

}

uno::Reference< css::frame::XLayoutManager > SAL_CALL SdrLightEmbeddedClient_Impl::getLayoutManager()

{

    uno::Reference< css::frame::XLayoutManager > xMan;

    SolarMutexGuard aGuard;

    uno::Reference < beans::XPropertySet > xFrame( lcl_getFrame_throw(mpObj));

    try

    {

        xMan.set(xFrame->getPropertyValue(u"LayoutManager"_ustr),uno::UNO_QUERY);

    }

    catch ( uno::Exception& ex )

    {

        css::uno::Any anyEx = cppu::getCaughtException();

        throw css::lang::WrappedTargetRuntimeException( ex.Message,

                        nullptr, anyEx );

    }

    return xMan;

}

uno::Reference< frame::XDispatchProvider > SAL_CALL SdrLightEmbeddedClient_Impl::getInplaceDispatchProvider()

{

    SolarMutexGuard aGuard;

    return uno::Reference < frame::XDispatchProvider >( lcl_getFrame_throw(mpObj), uno::UNO_QUERY_THROW );

}

awt::Rectangle SAL_CALL SdrLightEmbeddedClient_Impl::getPlacement()

{

    SolarMutexGuard aGuard;

    if ( !mpObj )

        throw uno::RuntimeException();

    tools::Rectangle aLogicRect = impl_getScaledRect_nothrow();

    MapUnit aContainerMapUnit( MapUnit::Map100thMM );

    uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY );

    if ( xParentVis.is() )

        aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) );

    aLogicRect = Application::GetDefaultDevice()->LogicToPixel(aLogicRect, MapMode(aContainerMapUnit));

    return vcl::unohelper::ConvertToAWTRect(aLogicRect);

}

awt::Rectangle SAL_CALL SdrLightEmbeddedClient_Impl::getClipRectangle()

{

    return getPlacement();

}

void SAL_CALL SdrLightEmbeddedClient_Impl::translateAccelerators( const uno::Sequence< awt::KeyEvent >& /*aKeys*/ )

{

}

void SAL_CALL SdrLightEmbeddedClient_Impl::scrollObject( const awt::Size& /*aOffset*/ )

{

}

void SAL_CALL SdrLightEmbeddedClient_Impl::changedPlacement( const awt::Rectangle& aPosRect )

{

    SolarMutexGuard aGuard;

    if ( !mpObj )

        throw uno::RuntimeException();

    uno::Reference< embed::XInplaceObject > xInplace( mpObj->GetObjRef(), uno::UNO_QUERY_THROW );

    // check if the change is at least one pixel in size

    awt::Rectangle aOldRect = getPlacement();

    tools::Rectangle aNewPixelRect = vcl::unohelper::ConvertToVCLRect(aPosRect);

    tools::Rectangle aOldPixelRect = vcl::unohelper::ConvertToVCLRect(aOldRect);

    if ( aOldPixelRect == aNewPixelRect )

        // nothing has changed

        return;

    // new scaled object area

    MapUnit aContainerMapUnit( MapUnit::Map100thMM );

    uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY );

    if ( xParentVis.is() )

        aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) );

    tools::Rectangle aNewLogicRect = Application::GetDefaultDevice()->PixelToLogic(aNewPixelRect, MapMode(aContainerMapUnit));

    tools::Rectangle aLogicRect = impl_getScaledRect_nothrow();

    if ( aNewLogicRect == aLogicRect )

        return;

    // the calculation of the object area has not changed the object size

    // it should be done here then

    //SfxBooleanFlagGuard aGuard( m_bResizeNoScale, true );

    // new size of the object area without scaling

    Size aNewObjSize( tools::Long( aNewLogicRect.GetWidth() / m_aScaleWidth ),

                      tools::Long( aNewLogicRect.GetHeight() / m_aScaleHeight ) );

    // now remove scaling from new placement and keep this at the new object area

    aNewLogicRect.SetSize( aNewObjSize );

    // react to the change if the difference is bigger than one pixel

    Size aPixelDiff =

        Application::GetDefaultDevice()->LogicToPixel(

            Size( aLogicRect.GetWidth() - aNewObjSize.Width(),

                  aLogicRect.GetHeight() - aNewObjSize.Height() ),

            MapMode(aContainerMapUnit));

    if( aPixelDiff.Width() || aPixelDiff.Height() )

    {

        mpObj->SetLogicRect( tools::Rectangle( aLogicRect.TopLeft(), aNewObjSize ) );

        mpObj->BroadcastObjectChange();

    }

    else

        mpObj->ActionChanged();

}

// XWindowSupplier

uno::Reference< awt::XWindow > SAL_CALL SdrLightEmbeddedClient_Impl::getWindow()

{

    SolarMutexGuard aGuard;

    uno::Reference< awt::XWindow > xCurrent = m_xWindow;

    if ( !xCurrent.is() )

    {

        if ( !mpObj )

            throw uno::RuntimeException();

        uno::Reference< frame::XFrame> xFrame(lcl_getFrame_throw(mpObj),uno::UNO_QUERY_THROW);

        xCurrent = xFrame->getComponentWindow();

    } // if ( !xCurrent.is() )

    return xCurrent;

}

void SdrLightEmbeddedClient_Impl::setWindow(const uno::Reference< awt::XWindow >& _xWindow)

{

    m_xWindow = _xWindow;

}

SdrEmbedObjectLink::SdrEmbedObjectLink(SdrOle2Obj* pObject):

    ::sfx2::SvBaseLink( ::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB ),

    m_pObj(pObject)

{

    SetSynchron( false );

}

SdrEmbedObjectLink::~SdrEmbedObjectLink()

{

}

::sfx2::SvBaseLink::UpdateResult SdrEmbedObjectLink::DataChanged(

    const OUString& /*rMimeType*/, const css::uno::Any & /*rValue*/ )

{

    if ( !m_pObj->UpdateLinkURL_Impl() )

    {

        // the link URL was not changed

        uno::Reference< embed::XEmbeddedObject > xObject = m_pObj->GetObjRef();

        OSL_ENSURE( xObject.is(), "The object must exist always!" );

        if ( xObject.is() )

        {

            // let the object reload the link

            // TODO/LATER: reload call could be used for this case

            try

            {

                sal_Int32 nState = xObject->getCurrentState();

                if ( nState != embed::EmbedStates::LOADED )

                {

                    // in some cases the linked file probably is not locked so it could be changed

                    xObject->changeState( embed::EmbedStates::LOADED );

                    xObject->changeState( nState );

                }

            }

            catch ( uno::Exception& )

            {

            }

        }

    }

    m_pObj->GetNewReplacement();

    m_pObj->SetChanged();

    return SUCCESS;

}

void SdrEmbedObjectLink::Closed()

{

    m_pObj->BreakFileLink_Impl();

    SvBaseLink::Closed();

}

SdrIFrameLink::SdrIFrameLink(SdrOle2Obj* pObject)

    : ::sfx2::SvBaseLink(::SfxLinkUpdateMode::ONCALL, SotClipboardFormatId::SVXB)

    , m_pObject(pObject)

{

    SetSynchron( false );

}

::sfx2::SvBaseLink::UpdateResult SdrIFrameLink::DataChanged(

    const OUString&, const uno::Any& )

{

    uno::Reference<embed::XEmbeddedObject> xObject = m_pObject->GetObjRef();

    uno::Reference<embed::XCommonEmbedPersist> xPersObj(xObject, uno::UNO_QUERY);

    if (xPersObj.is())

    {

        // let the IFrameObject reload the link

        try

        {

            xPersObj->reload(uno::Sequence<beans::PropertyValue>(), uno::Sequence<beans::PropertyValue>());

        }

        catch (const uno::Exception&)

        {

        }

        m_pObject->SetChanged();

    }

    return SUCCESS;

}

class SdrOle2ObjImpl

{

public:

    svt::EmbeddedObjectRef mxObjRef;

    std::optional<Graphic> moGraphic;

    OUString        maProgName;

    OUString        aPersistName;       // name of object in persist

    rtl::Reference<SdrLightEmbeddedClient_Impl> mxLightClient; // must be registered as client only using AddOwnLightClient() call

    bool mbFrame:1; // Due to compatibility at SdrTextObj for now

    bool mbSuppressSetVisAreaSize:1; // #i118524#

    mutable bool mbTypeAsked:1;

    mutable bool mbIsChart:1;

    bool mbLoadingOLEObjectFailed:1; // New local var to avoid repeated loading if load of OLE2 fails

    bool mbConnected:1;

    bool mbIgnoreOLEObjectScale : 1 = false; // See SdXMLObjectShapeContext::createFastChildContext

    sfx2::SvBaseLink* mpObjectLink;

    OUString maLinkURL;

    rtl::Reference<SvxUnoShapeModifyListener> mxModifyListener;

    explicit SdrOle2ObjImpl( bool bFrame ) :

        mbFrame(bFrame),

        mbSuppressSetVisAreaSize(false),

        mbTypeAsked(false),

        mbIsChart(false),

        mbLoadingOLEObjectFailed(false),

        mbConnected(false),

        mpObjectLink(nullptr)

    {

        mxObjRef.Lock();

    }

    SdrOle2ObjImpl( bool bFrame, const svt::EmbeddedObjectRef& rObjRef ) :

        mxObjRef(rObjRef),

        mbFrame(bFrame),

        mbSuppressSetVisAreaSize(false),

        mbTypeAsked(false),

        mbIsChart(false),

        mbLoadingOLEObjectFailed(false),

        mbConnected(false),

        mpObjectLink(nullptr)

    {

        mxObjRef.Lock();

    }

    ~SdrOle2ObjImpl()

    {

        moGraphic.reset();

        if (mxModifyListener.is())

        {

            mxModifyListener->invalidate();

        }

    }

};

// Predicate determining whether the given OLE is an internal math

// object

static bool ImplIsMathObj( const uno::Reference < embed::XEmbeddedObject >& rObjRef )

{

    if ( !rObjRef.is() )

        return false;

    SvGlobalName aClassName( rObjRef->getClassID() );

    return aClassName == SvGlobalName(SO3_SM_CLASSID_30) ||

        aClassName == SvGlobalName(SO3_SM_CLASSID_40) ||

        aClassName == SvGlobalName(SO3_SM_CLASSID_50) ||

        aClassName == SvGlobalName(SO3_SM_CLASSID_60) ||

        aClassName == SvGlobalName(SO3_SM_CLASSID);

}

// BaseProperties section

std::unique_ptr<sdr::properties::BaseProperties> SdrOle2Obj::CreateObjectSpecificProperties()

{

    return std::make_unique<sdr::properties::OleProperties>(*this);

}

// DrawContact section

std::unique_ptr<sdr::contact::ViewContact> SdrOle2Obj::CreateObjectSpecificViewContact()

{

    return std::make_unique<sdr::contact::ViewContactOfSdrOle2Obj>(*this);

}

void SdrOle2Obj::Init()

{

    // Stuff that was done from old SetModel:

    // #i43086# #i85304 redo the change for charts for the above bugfix, as #i43086# does not occur anymore

    // so maybe the ImpSetVisAreaSize call can be removed here completely

    // Nevertheless I leave it in for other objects as I am not sure about the side effects when removing now

    if(!getSdrModelFromSdrObject().isLocked() && !IsChart())

    {

        ImpSetVisAreaSize();

    }

    ::comphelper::IEmbeddedHelper* pDestPers(getSdrModelFromSdrObject().GetPersist());

    if(pDestPers && !IsEmptyPresObj())

    {

        // object wasn't connected, now it should be

        Connect_Impl();

    }

    AddListeners_Impl();

}

SdrOle2Obj::SdrOle2Obj(

    SdrModel& rSdrModel,

    bool bFrame_)

:   SdrRectObj(rSdrModel),

    mpImpl(new SdrOle2ObjImpl(bFrame_))

{

    Init();

}

SdrOle2Obj::SdrOle2Obj(SdrModel& rSdrModel, SdrOle2Obj const & rSource)

:   SdrRectObj(rSdrModel, rSource),

    mpImpl(new SdrOle2ObjImpl(/*bFrame*/false))

{

    Init();

    // Manually copying bClosedObj attribute

    SetClosedObj( rSource.IsClosedObj() );

    mpImpl->aPersistName = rSource.mpImpl->aPersistName;

    mpImpl->maProgName = rSource.mpImpl->maProgName;

    mpImpl->mbFrame = rSource.mpImpl->mbFrame;

    if (rSource.mpImpl->moGraphic)

    {

        mpImpl->moGraphic.emplace(*rSource.mpImpl->moGraphic);

    }

    if( IsEmptyPresObj() )

        return;

    ::comphelper::IEmbeddedHelper* pDestPers(getSdrModelFromSdrObject().GetPersist());

    ::comphelper::IEmbeddedHelper* pSrcPers(rSource.getSdrModelFromSdrObject().GetPersist());

    if( !(pDestPers && pSrcPers) )

        return;

    DBG_ASSERT( !mpImpl->mxObjRef.is(), "Object already existing!" );

    comphelper::EmbeddedObjectContainer& rContainer = pSrcPers->getEmbeddedObjectContainer();

    uno::Reference < embed::XEmbeddedObject > xObj = rContainer.GetEmbeddedObject( mpImpl->aPersistName );

    if ( xObj.is() )

    {

        OUString aTmp;

        mpImpl->mxObjRef.Assign( pDestPers->getEmbeddedObjectContainer().CopyAndGetEmbeddedObject(

            rContainer, xObj, aTmp, pSrcPers->getDocumentBaseURL(), pDestPers->getDocumentBaseURL()), rSource.GetAspect());

        mpImpl->mbTypeAsked = false;

        mpImpl->aPersistName = aTmp;

        CheckFileLink_Impl();

    }

    Connect();

}

SdrOle2Obj::SdrOle2Obj(

    SdrModel& rSdrModel,

    const svt::EmbeddedObjectRef& rNewObjRef,

    const OUString& rNewObjName,

    const tools::Rectangle& rNewRect)

:   SdrRectObj(rSdrModel, rNewRect),

    mpImpl(new SdrOle2ObjImpl(false/*bFrame_*/, rNewObjRef))

{

    osl_atomic_increment(&m_refCount);

    mpImpl->aPersistName = rNewObjName;

    if (mpImpl->mxObjRef.is() && (mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::EMBED_NEVERRESIZE ) )

        m_bSizProt = true;

    // For math objects, set closed state to transparent

    SetClosedObj(!ImplIsMathObj( mpImpl->mxObjRef.GetObject() ));

    Init();

    osl_atomic_decrement(&m_refCount);

}

OUString SdrOle2Obj::GetStyleString()

{

    OUString strStyle;

    if (mpImpl->mxObjRef.is() && mpImpl->mxObjRef.IsChart())

    {

        strStyle = mpImpl->mxObjRef.GetChartType();

    }

    return strStyle;

}

SdrOle2Obj::~SdrOle2Obj()

{

    if ( mpImpl->mbConnected )

        Disconnect();

    DisconnectFileLink_Impl();

    if (mpImpl->mxLightClient)

    {

        mpImpl->mxLightClient->disconnect();

        mpImpl->mxLightClient.clear();

    }

}

void SdrOle2Obj::SetAspect( sal_Int64 nAspect )

{

    mpImpl->mxObjRef.SetViewAspect( nAspect );

}

const svt::EmbeddedObjectRef& SdrOle2Obj::getEmbeddedObjectRef() const

{

    return mpImpl->mxObjRef;

}

sal_Int64 SdrOle2Obj::GetAspect() const

{

    return mpImpl->mxObjRef.GetViewAspect();

}

bool SdrOle2Obj::isInplaceActive() const

{

    return mpImpl->mxObjRef.is() && embed::EmbedStates::INPLACE_ACTIVE == mpImpl->mxObjRef->getCurrentState();

}

bool SdrOle2Obj::isUiActive() const

{

    return mpImpl->mxObjRef.is() && embed::EmbedStates::UI_ACTIVE == mpImpl->mxObjRef->getCurrentState();

}

void SdrOle2Obj::SetGraphic(const Graphic& rGrf)

{

    // only for setting a preview graphic

    mpImpl->moGraphic.emplace(rGrf);

    SetChanged();

    BroadcastObjectChange();

}

void SdrOle2Obj::ClearGraphic()

{

    mpImpl->moGraphic.reset();

    SetChanged();

    BroadcastObjectChange();

}

void SdrOle2Obj::SetProgName( const OUString& rName )

{

    mpImpl->maProgName = rName;

}

const OUString& SdrOle2Obj::GetProgName() const

{

    return mpImpl->maProgName;

}

bool SdrOle2Obj::IsEmpty() const

{

    return !mpImpl->mxObjRef.is();

}

void SdrOle2Obj::Connect(SvxOle2Shape* pCreator)

{

    if( IsEmptyPresObj() )

        return;

    if( mpImpl->mbConnected )

    {

        // currently there are situations where it seems to be unavoidable to have multiple connects

        // changing this would need a larger code rewrite, so for now I remove the assertion

        // OSL_FAIL("Connect() called on connected object!");

        return;

    }

    Connect_Impl(pCreator);

    AddListeners_Impl();

}

bool SdrOle2Obj::UpdateLinkURL_Impl()

{

    bool bResult = false;

    if ( mpImpl->mpObjectLink )

    {

        sfx2::LinkManager* pLinkManager(getSdrModelFromSdrObject().GetLinkManager());

        if ( pLinkManager )

        {

            OUString aNewLinkURL;

            sfx2::LinkManager::GetDisplayNames( mpImpl->mpObjectLink, nullptr, &aNewLinkURL );

            if ( !aNewLinkURL.equalsIgnoreAsciiCase( mpImpl->maLinkURL ) )

            {

                GetObjRef_Impl();

                uno::Reference<embed::XCommonEmbedPersist> xPersObj( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY );

                OSL_ENSURE( xPersObj.is(), "The object must exist!" );

                if ( xPersObj.is() )

                {

                    try

                    {

                        sal_Int32 nCurState = mpImpl->mxObjRef->getCurrentState();

                        if ( nCurState != embed::EmbedStates::LOADED )

                            mpImpl->mxObjRef->changeState(embed::EmbedStates::LOADED);

                        // TODO/LATER: there should be possible to get current mediadescriptor settings from the object

                        uno::Sequence< beans::PropertyValue > aArgs{ comphelper::makePropertyValue(

                            u"URL"_ustr, aNewLinkURL) };

                        xPersObj->reload( aArgs, uno::Sequence< beans::PropertyValue >() );

                        mpImpl->maLinkURL = aNewLinkURL;

                        bResult = true;

                        if ( nCurState != embed::EmbedStates::LOADED )

                            mpImpl->mxObjRef->changeState(nCurState);

                    }

                    catch( css::uno::Exception const & )

                    {

                        TOOLS_WARN_EXCEPTION( "svx", "SdrOle2Obj::UpdateLinkURL_Impl()" );