LCOV - code coverage report
Current view: top level - svx/source/svdraw - svdoole2.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 364 924 39.4 %
Date: 2014-11-03 Functions: 61 121 50.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <svx/svdoole2.hxx>
      21             : 
      22             : #include <com/sun/star/util/XModifyBroadcaster.hpp>
      23             : #include <com/sun/star/util/XModifiable.hpp>
      24             : #include <com/sun/star/chart2/XChartDocument.hpp>
      25             : #include <com/sun/star/embed/EmbedStates.hpp>
      26             : #include <com/sun/star/embed/ElementModes.hpp>
      27             : #include <com/sun/star/embed/EmbedMisc.hpp>
      28             : #include <com/sun/star/embed/Aspects.hpp>
      29             : #include <com/sun/star/embed/XEmbedPersist2.hpp>
      30             : #include <com/sun/star/embed/XInplaceClient.hpp>
      31             : #include <com/sun/star/embed/XInplaceObject.hpp>
      32             : #include <com/sun/star/embed/XLinkageSupport.hpp>
      33             : #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
      34             : #include <com/sun/star/embed/XWindowSupplier.hpp>
      35             : #include <com/sun/star/document/XEventListener.hpp>
      36             : #include <com/sun/star/container/XChild.hpp>
      37             : #include <com/sun/star/document/XStorageBasedDocument.hpp>
      38             : 
      39             : #include <comphelper/processfactory.hxx>
      40             : #include <cppuhelper/exc_hlp.hxx>
      41             : #include <unotools/ucbstreamhelper.hxx>
      42             : 
      43             : #include <toolkit/helper/vclunohelper.hxx>
      44             : #include <toolkit/awt/vclxwindow.hxx>
      45             : #include <toolkit/helper/convert.hxx>
      46             : 
      47             : #include <vcl/graphicfilter.hxx>
      48             : #include <svtools/embedhlp.hxx>
      49             : 
      50             : #include <sfx2/objsh.hxx>
      51             : #include <sfx2/ipclient.hxx>
      52             : #include <sfx2/lnkbase.hxx>
      53             : #include <tools/stream.hxx>
      54             : #include <comphelper/anytostring.hxx>
      55             : #include <svx/svdpagv.hxx>
      56             : #include <tools/globname.hxx>
      57             : #include <vcl/jobset.hxx>
      58             : #include <comphelper/classids.hxx>
      59             : 
      60             : #include <sot/formats.hxx>
      61             : #include <sfx2/linkmgr.hxx>
      62             : #include <svtools/transfer.hxx>
      63             : #include <cppuhelper/implbase5.hxx>
      64             : 
      65             : #include <svl/solar.hrc>
      66             : #include <svl/urihelper.hxx>
      67             : #include <osl/mutex.hxx>
      68             : #include <vcl/svapp.hxx>
      69             : 
      70             : #include <svx/charthelper.hxx>
      71             : #include <svx/svdmodel.hxx>
      72             : #include "svdglob.hxx"
      73             : #include "svx/svdstr.hrc"
      74             : #include <svx/svdetc.hxx>
      75             : #include <svx/svdview.hxx>
      76             : #include "unomlstr.hxx"
      77             : #include <sdr/contact/viewcontactofsdrole2obj.hxx>
      78             : #include <svx/svdograf.hxx>
      79             : #include <sdr/properties/oleproperties.hxx>
      80             : #include <svx/xlnclit.hxx>
      81             : #include <svx/xbtmpit.hxx>
      82             : #include <svx/xflbmtit.hxx>
      83             : #include <svx/xflbstit.hxx>
      84             : #include <basegfx/matrix/b2dhommatrix.hxx>
      85             : #include <basegfx/polygon/b2dpolypolygon.hxx>
      86             : #include <editeng/outlobj.hxx>
      87             : #include <svx/svdpage.hxx>
      88             : 
      89             : using namespace ::com::sun::star;
      90             : 
      91           0 : static uno::Reference < beans::XPropertySet > lcl_getFrame_throw(const SdrOle2Obj* _pObject)
      92             : {
      93           0 :     uno::Reference < beans::XPropertySet > xFrame;
      94           0 :     if ( _pObject )
      95             :     {
      96           0 :         uno::Reference< frame::XController> xController = _pObject->GetParentXModel()->getCurrentController();
      97           0 :         if ( xController.is() )
      98             :         {
      99           0 :             xFrame.set( xController->getFrame(),uno::UNO_QUERY_THROW);
     100           0 :         }
     101             :     } // if ( _pObject )
     102           0 :     return xFrame;
     103             : }
     104             : 
     105         848 : class SdrLightEmbeddedClient_Impl : public ::cppu::WeakImplHelper5
     106             :                                                             < embed::XStateChangeListener
     107             :                                                             , document::XEventListener
     108             :                                                             , embed::XInplaceClient
     109             :                                                             , embed::XEmbeddedClient
     110             :                                                             , embed::XWindowSupplier
     111             :                                                             >
     112             : {
     113             :     uno::Reference< awt::XWindow > m_xWindow;
     114             :     SdrOle2Obj* mpObj;
     115             : 
     116             :     Fraction m_aScaleWidth;
     117             :     Fraction m_aScaleHeight;
     118             : 
     119             : 
     120             : public:
     121             :     SdrLightEmbeddedClient_Impl( SdrOle2Obj* pObj );
     122             :     void Release();
     123             : 
     124         244 :     void SetSizeScale( const Fraction& aScaleWidth, const Fraction& aScaleHeight )
     125             :     {
     126         244 :         m_aScaleWidth = aScaleWidth;
     127         244 :         m_aScaleHeight = aScaleHeight;
     128         244 :     }
     129             : 
     130           0 :     Fraction GetScaleWidth() const { return m_aScaleWidth; }
     131           0 :     Fraction GetScaleHeight() const { return m_aScaleHeight; }
     132             : 
     133             :     void setWindow(const uno::Reference< awt::XWindow >& _xWindow);
     134             : 
     135             : private:
     136             :     Rectangle impl_getScaledRect_nothrow() const;
     137             :     // XStateChangeListener
     138             :     virtual void SAL_CALL changingState( const ::com::sun::star::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (::com::sun::star::embed::WrongStateException, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     139             :     virtual void SAL_CALL stateChanged( const ::com::sun::star::lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     140             :     virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     141             : 
     142             :     // document::XEventListener
     143             :     virtual void SAL_CALL       notifyEvent( const document::EventObject& aEvent ) throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     144             : 
     145             :     // XEmbeddedClient
     146             :     virtual void SAL_CALL saveObject() throw ( embed::ObjectSaveVetoException, uno::Exception, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     147             :     virtual void SAL_CALL visibilityChanged( sal_Bool bVisible ) throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     148             : 
     149             :     // XComponentSupplier
     150             :     virtual uno::Reference< util::XCloseable > SAL_CALL getComponent() throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     151             : 
     152             :     // XInplaceClient
     153             :     virtual sal_Bool SAL_CALL canInplaceActivate() throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     154             :     virtual void SAL_CALL activatingInplace() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     155             :     virtual void SAL_CALL activatingUI() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     156             :     virtual void SAL_CALL deactivatedInplace() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     157             :     virtual void SAL_CALL deactivatedUI() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     158             :     virtual uno::Reference< ::com::sun::star::frame::XLayoutManager > SAL_CALL getLayoutManager() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     159             :     virtual uno::Reference< frame::XDispatchProvider > SAL_CALL getInplaceDispatchProvider() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     160             :     virtual awt::Rectangle SAL_CALL getPlacement() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     161             :     virtual awt::Rectangle SAL_CALL getClipRectangle() throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     162             :     virtual void SAL_CALL translateAccelerators( const uno::Sequence< awt::KeyEvent >& aKeys ) throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     163             :     virtual void SAL_CALL scrollObject( const awt::Size& aOffset ) throw ( embed::WrongStateException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     164             :     virtual void SAL_CALL changedPlacement( const awt::Rectangle& aPosRect ) throw ( embed::WrongStateException, uno::Exception, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     165             : 
     166             :     // XWindowSupplier
     167             :     virtual uno::Reference< awt::XWindow > SAL_CALL getWindow() throw ( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
     168             : };
     169             : 
     170             : 
     171         424 : SdrLightEmbeddedClient_Impl::SdrLightEmbeddedClient_Impl( SdrOle2Obj* pObj )
     172         424 : : mpObj( pObj )
     173             : {
     174         424 : }
     175           0 : Rectangle SdrLightEmbeddedClient_Impl::impl_getScaledRect_nothrow() const
     176             : {
     177           0 :     Rectangle aLogicRect( mpObj->GetLogicRect() );
     178             :     // apply scaling to object area and convert to pixels
     179           0 :     aLogicRect.SetSize( Size( Fraction( aLogicRect.GetWidth() ) * m_aScaleWidth,
     180           0 :                                 Fraction( aLogicRect.GetHeight() ) * m_aScaleHeight ) );
     181           0 :     return aLogicRect;
     182             : }
     183             : 
     184         242 : void SAL_CALL SdrLightEmbeddedClient_Impl::changingState( const ::com::sun::star::lang::EventObject& /*aEvent*/, ::sal_Int32 /*nOldState*/, ::sal_Int32 /*nNewState*/ ) throw (::com::sun::star::embed::WrongStateException, ::com::sun::star::uno::RuntimeException, std::exception)
     185             : {
     186         242 : }
     187             : 
     188             : 
     189         424 : void SdrLightEmbeddedClient_Impl::Release()
     190             : {
     191             :     {
     192         424 :         SolarMutexGuard aGuard;
     193         424 :         mpObj = NULL;
     194             :     }
     195             : 
     196         424 :     release();
     197         424 : }
     198             : 
     199             : 
     200         242 : void SAL_CALL SdrLightEmbeddedClient_Impl::stateChanged( const ::com::sun::star::lang::EventObject& /*aEvent*/, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (::com::sun::star::uno::RuntimeException, std::exception)
     201             : {
     202         242 :     SolarMutexGuard aGuard;
     203             : 
     204         242 :     if ( mpObj && nOldState == embed::EmbedStates::LOADED && nNewState == embed::EmbedStates::RUNNING )
     205             :     {
     206          68 :         mpObj->ObjectLoaded();
     207          68 :         GetSdrGlobalData().GetOLEObjCache().InsertObj(mpObj);
     208             :     }
     209         174 :     else if ( mpObj && nNewState == embed::EmbedStates::LOADED && nOldState == embed::EmbedStates::RUNNING )
     210             :     {
     211         174 :         GetSdrGlobalData().GetOLEObjCache().RemoveObj(mpObj);
     212         242 :     }
     213         242 : }
     214             : 
     215             : 
     216           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::disposing( const ::com::sun::star::lang::EventObject& /*aEvent*/ ) throw (::com::sun::star::uno::RuntimeException, std::exception)
     217             : {
     218           0 :     SolarMutexGuard aGuard;
     219             : 
     220           0 :     GetSdrGlobalData().GetOLEObjCache().RemoveObj(mpObj);
     221           0 : }
     222             : 
     223             : 
     224        1946 : void SAL_CALL SdrLightEmbeddedClient_Impl::notifyEvent( const document::EventObject& aEvent ) throw( uno::RuntimeException, std::exception )
     225             : {
     226             :     // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl
     227             : 
     228        1946 :     SolarMutexGuard aGuard;
     229             : 
     230             :     // the code currently makes sense only in case there is no other client
     231        6882 :     if ( mpObj && mpObj->GetAspect() != embed::Aspects::MSOLE_ICON && aEvent.EventName == "OnVisAreaChanged"
     232        5696 :       && mpObj->GetObjRef().is() && mpObj->GetObjRef()->getClientSite() == uno::Reference< embed::XEmbeddedClient >( this ) )
     233             :     {
     234             :         try
     235             :         {
     236         626 :             MapUnit aContainerMapUnit( MAP_100TH_MM );
     237         626 :             uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY );
     238         626 :             if ( xParentVis.is() )
     239         626 :                 aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) );
     240             : 
     241         626 :             MapUnit aObjMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpObj->GetObjRef()->getMapUnit( mpObj->GetAspect() ) );
     242             : 
     243         626 :             Rectangle          aVisArea;
     244         626 :             awt::Size aSz;
     245             :             try
     246             :             {
     247         626 :                 aSz = mpObj->GetObjRef()->getVisualAreaSize( mpObj->GetAspect() );
     248             :             }
     249           0 :             catch( embed::NoVisualAreaSizeException& )
     250             :             {
     251             :                 OSL_FAIL( "No visual area size!\n" );
     252           0 :                 aSz.Width = 5000;
     253           0 :                 aSz.Height = 5000;
     254             :             }
     255           0 :             catch( uno::Exception& )
     256             :             {
     257             :                 OSL_FAIL( "Unexpected exception!\n" );
     258           0 :                 aSz.Width = 5000;
     259           0 :                 aSz.Height = 5000;
     260             :             }
     261             : 
     262         626 :             aVisArea.SetSize( Size( aSz.Width, aSz.Height ) );
     263         626 :             aVisArea = OutputDevice::LogicToLogic( aVisArea, aObjMapUnit, aContainerMapUnit );
     264        1252 :             Size aScaledSize( static_cast< long >( m_aScaleWidth * Fraction( aVisArea.GetWidth() ) ),
     265        1878 :                                 static_cast< long >( m_aScaleHeight * Fraction( aVisArea.GetHeight() ) ) );
     266         626 :             Rectangle aLogicRect( mpObj->GetLogicRect() );
     267             : 
     268             :             // react to the change if the difference is bigger than one pixel
     269             :             Size aPixelDiff =
     270             :                 Application::GetDefaultDevice()->LogicToPixel(
     271         626 :                     Size( aLogicRect.GetWidth() - aScaledSize.Width(),
     272         626 :                           aLogicRect.GetHeight() - aScaledSize.Height() ),
     273        1878 :                     aContainerMapUnit );
     274         626 :             if( aPixelDiff.Width() || aPixelDiff.Height() )
     275             :             {
     276           0 :                 mpObj->SetLogicRect( Rectangle( aLogicRect.TopLeft(), aScaledSize ) );
     277           0 :                 mpObj->BroadcastObjectChange();
     278             :             }
     279             :             else
     280         626 :                 mpObj->ActionChanged();
     281             :         }
     282           0 :         catch( uno::Exception& )
     283             :         {
     284             :             OSL_FAIL( "Unexpected exception!\n" );
     285             :         }
     286        1946 :     }
     287        1946 : }
     288             : 
     289             : 
     290           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::saveObject()
     291             :     throw ( embed::ObjectSaveVetoException,
     292             :             uno::Exception,
     293             :             uno::RuntimeException, std::exception )
     294             : {
     295             :     // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl
     296           0 :     uno::Reference< embed::XCommonEmbedPersist > xPersist;
     297           0 :     uno::Reference< util::XModifiable > xModifiable;
     298             : 
     299             :     {
     300           0 :         SolarMutexGuard aGuard;
     301             : 
     302           0 :         if ( !mpObj )
     303           0 :             throw embed::ObjectSaveVetoException();
     304             : 
     305             :         // the common persistence is supported by objects and links
     306           0 :         xPersist = uno::Reference< embed::XCommonEmbedPersist >( mpObj->GetObjRef(), uno::UNO_QUERY_THROW );
     307           0 :         xModifiable = uno::Reference< util::XModifiable >( mpObj->GetParentXModel(), uno::UNO_QUERY );
     308             :     }
     309             : 
     310           0 :     xPersist->storeOwn();
     311             : 
     312           0 :     if ( xModifiable.is() )
     313           0 :         xModifiable->setModified( true );
     314           0 : }
     315             : 
     316             : 
     317           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::visibilityChanged( sal_Bool /*bVisible*/ )
     318             :     throw ( embed::WrongStateException,
     319             :             uno::RuntimeException, std::exception )
     320             : {
     321             :     // nothing to do currently
     322             :     // TODO/LATER: when writer uses this implementation the code could be shared with SfxInPlaceClient_Impl
     323           0 :     if ( mpObj )
     324             :     {
     325           0 :         Rectangle aLogicRect( mpObj->GetLogicRect() );
     326           0 :         Size aLogicSize( aLogicRect.GetWidth(), aLogicRect.GetHeight() );
     327             : 
     328           0 :         if( mpObj->IsChart() )
     329             :         {
     330             :             //charts never should be stretched see #i84323# for example
     331           0 :             mpObj->SetLogicRect( Rectangle( aLogicRect.TopLeft(), aLogicSize ) );
     332           0 :             mpObj->BroadcastObjectChange();
     333             :         } // if( mpObj->IsChart() )
     334             :     }
     335           0 : }
     336             : 
     337             : 
     338           0 : uno::Reference< util::XCloseable > SAL_CALL SdrLightEmbeddedClient_Impl::getComponent()
     339             :     throw ( uno::RuntimeException, std::exception )
     340             : {
     341           0 :     uno::Reference< util::XCloseable > xResult;
     342             : 
     343           0 :     SolarMutexGuard aGuard;
     344           0 :     if ( mpObj )
     345           0 :         xResult = uno::Reference< util::XCloseable >( mpObj->GetParentXModel(), uno::UNO_QUERY );
     346             : 
     347           0 :     return xResult;
     348             : }
     349             : // XInplaceClient
     350             : 
     351           0 : sal_Bool SAL_CALL SdrLightEmbeddedClient_Impl::canInplaceActivate()
     352             :     throw ( uno::RuntimeException, std::exception )
     353             : {
     354           0 :     bool bRet = false;
     355           0 :     SolarMutexGuard aGuard;
     356           0 :     if ( mpObj )
     357             :     {
     358           0 :         uno::Reference< embed::XEmbeddedObject > xObject = mpObj->GetObjRef();
     359           0 :         if ( !xObject.is() )
     360           0 :             throw uno::RuntimeException();
     361             :         // we don't want to switch directly from outplace to inplace mode
     362           0 :         bRet = !( xObject->getCurrentState() == embed::EmbedStates::ACTIVE || mpObj->GetAspect() == embed::Aspects::MSOLE_ICON );
     363             :     } // if ( mpObj )
     364           0 :     return bRet;
     365             : }
     366             : 
     367             : 
     368           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::activatingInplace()
     369             :     throw ( embed::WrongStateException,
     370             :             uno::RuntimeException, std::exception )
     371             : {
     372           0 : }
     373             : 
     374             : 
     375           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::activatingUI()
     376             :     throw ( embed::WrongStateException,
     377             :             uno::RuntimeException, std::exception )
     378             : {
     379           0 :     SolarMutexGuard aGuard;
     380             : 
     381           0 :     uno::Reference < beans::XPropertySet > xFrame( lcl_getFrame_throw(mpObj));
     382           0 :     uno::Reference < frame::XFrame > xOwnFrame( xFrame,uno::UNO_QUERY);
     383           0 :     uno::Reference < frame::XFramesSupplier > xParentFrame( xOwnFrame->getCreator(), uno::UNO_QUERY );
     384           0 :     if ( xParentFrame.is() )
     385           0 :         xParentFrame->setActiveFrame( xOwnFrame );
     386             : 
     387           0 :     OLEObjCache& rObjCache = GetSdrGlobalData().GetOLEObjCache();
     388           0 :     const sal_uIntPtr nCount = rObjCache.size();
     389           0 :     for(sal_Int32 i = nCount-1 ; i >= 0;--i)
     390             :     {
     391           0 :         SdrOle2Obj* pObj = rObjCache[i];
     392           0 :         if ( pObj != mpObj )
     393             :         {
     394             :             // only deactivate ole objects which belongs to the same frame
     395           0 :             if ( xFrame == lcl_getFrame_throw(pObj) )
     396             :             {
     397           0 :                 uno::Reference< embed::XEmbeddedObject > xObject = pObj->GetObjRef();
     398             :                 try
     399             :                 {
     400           0 :                     if ( (xObject->getStatus( pObj->GetAspect() ) & embed::EmbedMisc::MS_EMBED_ACTIVATEWHENVISIBLE) ||
     401           0 :                          svt::EmbeddedObjectRef::IsGLChart(xObject) )
     402           0 :                         xObject->changeState( embed::EmbedStates::INPLACE_ACTIVE );
     403             :                     else
     404             :                     {
     405             :                         // the links should not stay in running state for long time because of locking
     406           0 :                         uno::Reference< embed::XLinkageSupport > xLink( xObject, uno::UNO_QUERY );
     407           0 :                         if ( xLink.is() && xLink->isLink() )
     408           0 :                             xObject->changeState( embed::EmbedStates::LOADED );
     409             :                         else
     410           0 :                             xObject->changeState( embed::EmbedStates::RUNNING );
     411             :                     }
     412             :                 }
     413           0 :                 catch (com::sun::star::uno::Exception& )
     414           0 :                 {}
     415             :             }
     416             :         }
     417           0 :     } // for(sal_Int32 i = nCount-1 ; i >= 0;--i)
     418           0 : }
     419             : 
     420             : 
     421           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::deactivatedInplace()
     422             :     throw ( embed::WrongStateException,
     423             :             uno::RuntimeException, std::exception )
     424             : {
     425           0 : }
     426             : 
     427             : 
     428           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::deactivatedUI()
     429             :     throw ( embed::WrongStateException,
     430             :             uno::RuntimeException, std::exception )
     431             : {
     432           0 :     SolarMutexGuard aGuard;
     433           0 :     com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager(getLayoutManager());
     434           0 :     if ( xLayoutManager.is() )
     435             :     {
     436           0 :         const static OUString aMenuBarURL(  "private:resource/menubar/menubar" );
     437           0 :         if ( !xLayoutManager->isElementVisible( aMenuBarURL ) )
     438           0 :             xLayoutManager->createElement( aMenuBarURL );
     439           0 :     }
     440           0 : }
     441             : 
     442             : 
     443           0 : uno::Reference< ::com::sun::star::frame::XLayoutManager > SAL_CALL SdrLightEmbeddedClient_Impl::getLayoutManager()
     444             :     throw ( embed::WrongStateException,
     445             :             uno::RuntimeException, std::exception )
     446             : {
     447           0 :     uno::Reference< ::com::sun::star::frame::XLayoutManager > xMan;
     448           0 :     SolarMutexGuard aGuard;
     449           0 :     uno::Reference < beans::XPropertySet > xFrame( lcl_getFrame_throw(mpObj));
     450             :     try
     451             :     {
     452           0 :         xMan.set(xFrame->getPropertyValue("LayoutManager"),uno::UNO_QUERY);
     453             :     }
     454           0 :     catch ( uno::Exception& )
     455             :     {
     456           0 :         throw uno::RuntimeException();
     457             :     }
     458             : 
     459           0 :     return xMan;
     460             : }
     461             : 
     462             : 
     463           0 : uno::Reference< frame::XDispatchProvider > SAL_CALL SdrLightEmbeddedClient_Impl::getInplaceDispatchProvider()
     464             :     throw ( embed::WrongStateException,
     465             :             uno::RuntimeException, std::exception )
     466             : {
     467           0 :     SolarMutexGuard aGuard;
     468           0 :     return uno::Reference < frame::XDispatchProvider >( lcl_getFrame_throw(mpObj), uno::UNO_QUERY_THROW );
     469             : }
     470             : 
     471             : 
     472           0 : awt::Rectangle SAL_CALL SdrLightEmbeddedClient_Impl::getPlacement()
     473             :     throw ( embed::WrongStateException,
     474             :             uno::RuntimeException, std::exception )
     475             : {
     476           0 :     SolarMutexGuard aGuard;
     477           0 :     if ( !mpObj )
     478           0 :         throw uno::RuntimeException();
     479             : 
     480           0 :     Rectangle aLogicRect = impl_getScaledRect_nothrow();
     481           0 :     MapUnit aContainerMapUnit( MAP_100TH_MM );
     482           0 :     uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY );
     483           0 :     if ( xParentVis.is() )
     484           0 :         aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) );
     485             : 
     486           0 :     aLogicRect = Application::GetDefaultDevice()->LogicToPixel(aLogicRect,aContainerMapUnit);
     487           0 :     return AWTRectangle( aLogicRect );
     488             : }
     489             : 
     490             : 
     491           0 : awt::Rectangle SAL_CALL SdrLightEmbeddedClient_Impl::getClipRectangle()
     492             :     throw ( embed::WrongStateException,
     493             :             uno::RuntimeException, std::exception )
     494             : {
     495           0 :     return getPlacement();
     496             : }
     497             : 
     498             : 
     499           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::translateAccelerators( const uno::Sequence< awt::KeyEvent >& /*aKeys*/ )
     500             :     throw ( embed::WrongStateException,
     501             :             uno::RuntimeException, std::exception )
     502             : {
     503           0 : }
     504             : 
     505             : 
     506           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::scrollObject( const awt::Size& /*aOffset*/ )
     507             :     throw ( embed::WrongStateException,
     508             :             uno::RuntimeException, std::exception )
     509             : {
     510           0 : }
     511             : 
     512             : 
     513           0 : void SAL_CALL SdrLightEmbeddedClient_Impl::changedPlacement( const awt::Rectangle& aPosRect )
     514             :     throw ( embed::WrongStateException,
     515             :             uno::Exception,
     516             :             uno::RuntimeException, std::exception )
     517             : {
     518           0 :     SolarMutexGuard aGuard;
     519           0 :     if ( !mpObj )
     520           0 :         throw uno::RuntimeException();
     521             : 
     522           0 :     uno::Reference< embed::XInplaceObject > xInplace( mpObj->GetObjRef(), uno::UNO_QUERY );
     523           0 :     if ( !xInplace.is() )
     524           0 :         throw uno::RuntimeException();
     525             : 
     526             :     // check if the change is at least one pixel in size
     527           0 :     awt::Rectangle aOldRect = getPlacement();
     528           0 :     Rectangle aNewPixelRect = VCLRectangle( aPosRect );
     529           0 :     Rectangle aOldPixelRect = VCLRectangle( aOldRect );
     530           0 :     if ( aOldPixelRect == aNewPixelRect )
     531             :         // nothing has changed
     532           0 :         return;
     533             : 
     534             :     // new scaled object area
     535           0 :     MapUnit aContainerMapUnit( MAP_100TH_MM );
     536           0 :     uno::Reference< embed::XVisualObject > xParentVis( mpObj->GetParentXModel(), uno::UNO_QUERY );
     537           0 :     if ( xParentVis.is() )
     538           0 :         aContainerMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xParentVis->getMapUnit( mpObj->GetAspect() ) );
     539             : 
     540           0 :     Rectangle aNewLogicRect = Application::GetDefaultDevice()->PixelToLogic(aNewPixelRect,aContainerMapUnit);
     541           0 :     Rectangle aLogicRect = impl_getScaledRect_nothrow();
     542             : 
     543           0 :     if ( aNewLogicRect != aLogicRect )
     544             :     {
     545             :         // the calculation of the object area has not changed the object size
     546             :         // it should be done here then
     547             :         //SfxBooleanFlagGuard aGuard( m_bResizeNoScale, true );
     548             : 
     549             :         // new size of the object area without scaling
     550           0 :         Size aNewObjSize( Fraction( aNewLogicRect.GetWidth() ) / m_aScaleWidth,
     551           0 :                           Fraction( aNewLogicRect.GetHeight() ) / m_aScaleHeight );
     552             : 
     553             :         // now remove scaling from new placement and keep this a the new object area
     554           0 :         aNewLogicRect.SetSize( aNewObjSize );
     555             :         // react to the change if the difference is bigger than one pixel
     556             :         Size aPixelDiff =
     557             :             Application::GetDefaultDevice()->LogicToPixel(
     558           0 :                 Size( aLogicRect.GetWidth() - aNewObjSize.Width(),
     559           0 :                       aLogicRect.GetHeight() - aNewObjSize.Height() ),
     560           0 :                 aContainerMapUnit );
     561           0 :         if( aPixelDiff.Width() || aPixelDiff.Height() )
     562             :         {
     563           0 :             mpObj->SetLogicRect( Rectangle( aLogicRect.TopLeft(), aNewObjSize ) );
     564           0 :             mpObj->BroadcastObjectChange();
     565             :         }
     566             :         else
     567           0 :             mpObj->ActionChanged();
     568           0 :     }
     569             : }
     570             : // XWindowSupplier
     571             : 
     572           0 : uno::Reference< awt::XWindow > SAL_CALL SdrLightEmbeddedClient_Impl::getWindow()
     573             :     throw ( uno::RuntimeException, std::exception )
     574             : {
     575           0 :     SolarMutexGuard aGuard;
     576           0 :     uno::Reference< awt::XWindow > xCurrent = m_xWindow;
     577           0 :     if ( !xCurrent.is() )
     578             :     {
     579           0 :         if ( !mpObj )
     580           0 :             throw uno::RuntimeException();
     581           0 :         uno::Reference< frame::XFrame> xFrame(lcl_getFrame_throw(mpObj),uno::UNO_QUERY_THROW);
     582           0 :         xCurrent = xFrame->getComponentWindow();
     583             :     } // if ( !xCurrent.is() )
     584           0 :     return xCurrent;
     585             : }
     586           0 : void SdrLightEmbeddedClient_Impl::setWindow(const uno::Reference< awt::XWindow >& _xWindow)
     587             : {
     588           0 :     m_xWindow = _xWindow;
     589           0 : }
     590             : 
     591             : 
     592             : 
     593             : class SdrEmbedObjectLink : public sfx2::SvBaseLink
     594             : {
     595             :     SdrOle2Obj*         pObj;
     596             : 
     597             : public:
     598             :                         SdrEmbedObjectLink(SdrOle2Obj* pObj);
     599             :     virtual             ~SdrEmbedObjectLink();
     600             : 
     601             :     virtual void        Closed() SAL_OVERRIDE;
     602             :     virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(
     603             :         const OUString& rMimeType, const ::com::sun::star::uno::Any & rValue ) SAL_OVERRIDE;
     604             : 
     605           0 :     bool                Connect() { return GetRealObject() != NULL; }
     606             : };
     607             : 
     608             : 
     609             : 
     610           0 : SdrEmbedObjectLink::SdrEmbedObjectLink(SdrOle2Obj* pObject):
     611             :     ::sfx2::SvBaseLink( ::sfx2::LINKUPDATE_ONCALL, SOT_FORMATSTR_ID_SVXB ),
     612           0 :     pObj(pObject)
     613             : {
     614           0 :     SetSynchron( false );
     615           0 : }
     616             : 
     617             : 
     618             : 
     619           0 : SdrEmbedObjectLink::~SdrEmbedObjectLink()
     620             : {
     621           0 : }
     622             : 
     623             : 
     624             : 
     625           0 : ::sfx2::SvBaseLink::UpdateResult SdrEmbedObjectLink::DataChanged(
     626             :     const OUString& /*rMimeType*/, const ::com::sun::star::uno::Any & /*rValue*/ )
     627             : {
     628           0 :     if ( !pObj->UpdateLinkURL_Impl() )
     629             :     {
     630             :         // the link URL was not changed
     631           0 :         uno::Reference< embed::XEmbeddedObject > xObject = pObj->GetObjRef();
     632             :         OSL_ENSURE( xObject.is(), "The object must exist always!\n" );
     633           0 :         if ( xObject.is() )
     634             :         {
     635             :             // let the object reload the link
     636             :             // TODO/LATER: reload call could be used for this case
     637             : 
     638             :             try
     639             :             {
     640           0 :                 sal_Int32 nState = xObject->getCurrentState();
     641           0 :                 if ( nState != embed::EmbedStates::LOADED )
     642             :                 {
     643             :                     // in some cases the linked file probably is not locked so it could be changed
     644           0 :                     xObject->changeState( embed::EmbedStates::LOADED );
     645           0 :                     xObject->changeState( nState );
     646             :                 }
     647             :             }
     648           0 :             catch ( uno::Exception& )
     649             :             {
     650             :             }
     651           0 :         }
     652             :     }
     653             : 
     654           0 :     pObj->GetNewReplacement();
     655           0 :     pObj->SetChanged();
     656             : 
     657           0 :     return SUCCESS;
     658             : }
     659             : 
     660             : 
     661             : 
     662           0 : void SdrEmbedObjectLink::Closed()
     663             : {
     664           0 :     pObj->BreakFileLink_Impl();
     665           0 :     SvBaseLink::Closed();
     666           0 : }
     667             : 
     668             : 
     669             : 
     670             : class SdrOle2ObjImpl
     671             : {
     672             : public:
     673             :     svt::EmbeddedObjectRef mxObjRef;
     674             : 
     675             :     Graphic* mpGraphic;
     676             :     // TODO/LATER: do we really need this pointer?
     677             :     GraphicObject* mpGraphicObject;
     678             :     OUString maProgName;
     679             :     OUString        aPersistName;       // name of object in persist
     680             :     SdrLightEmbeddedClient_Impl* pLightClient; // must be registered as client only using AddOwnLightClient() call
     681             : 
     682             :     bool mbFrame:1; // Due to compatibility at SdrTextObj for now
     683             :     bool mbInDestruction:1;
     684             :     bool mbSuppressSetVisAreaSize:1; // #i118524#
     685             :     mutable bool mbTypeAsked:1;
     686             :     mutable bool mbIsChart:1;
     687             :     bool mbLoadingOLEObjectFailed:1; // New local var to avoid repeated loading if load of OLE2 fails
     688             :     bool mbConnected:1;
     689             : 
     690             :     SdrEmbedObjectLink* mpObjectLink;
     691             :     OUString maLinkURL;
     692             : 
     693             :     SvxUnoShapeModifyListener* mpModifyListener;
     694             : 
     695         322 :     SdrOle2ObjImpl( bool bFrame ) :
     696             :         mpGraphic(NULL),
     697             :         mpGraphicObject(NULL),
     698             :         pLightClient (NULL),
     699             :         mbFrame(bFrame),
     700             :         mbInDestruction(false),
     701             :         mbSuppressSetVisAreaSize(false),
     702             :         mbTypeAsked(false),
     703             :         mbIsChart(false),
     704             :         mbLoadingOLEObjectFailed(false),
     705             :         mbConnected(false),
     706             :         mpObjectLink(NULL),
     707         322 :         mpModifyListener(NULL)
     708             :     {
     709         322 :         mxObjRef.Lock(true);
     710         322 :     }
     711             : 
     712         142 :     SdrOle2ObjImpl( bool bFrame, const svt::EmbeddedObjectRef& rObjRef ) :
     713             :         mxObjRef(rObjRef),
     714             :         mpGraphic(NULL),
     715             :         mpGraphicObject(NULL),
     716             :         pLightClient (NULL),
     717             :         mbFrame(bFrame),
     718             :         mbInDestruction(false),
     719             :         mbSuppressSetVisAreaSize(false),
     720             :         mbTypeAsked(false),
     721             :         mbIsChart(false),
     722             :         mbLoadingOLEObjectFailed(false),
     723             :         mbConnected(false),
     724             :         mpObjectLink(NULL),
     725         142 :         mpModifyListener(NULL)
     726             :     {
     727         142 :         mxObjRef.Lock(true);
     728         142 :     }
     729             : 
     730         464 :     ~SdrOle2ObjImpl()
     731         464 :     {
     732         464 :         delete mpGraphic;
     733         464 :         delete mpGraphicObject;
     734             : 
     735         464 :         if (mpModifyListener)
     736             :         {
     737         402 :             mpModifyListener->invalidate();
     738         402 :             mpModifyListener->release();
     739             :         }
     740         464 :     }
     741             : };
     742             : 
     743             : 
     744             : 
     745             : // Predicate determining whether the given OLE is an internal math
     746             : // object
     747         142 : static bool ImplIsMathObj( const uno::Reference < embed::XEmbeddedObject >& rObjRef )
     748             : {
     749         142 :     if ( !rObjRef.is() )
     750           0 :         return false;
     751             : 
     752         142 :     SvGlobalName aClassName( rObjRef->getClassID() );
     753         852 :     if( aClassName == SvGlobalName(SO3_SM_CLASSID_30) ||
     754         710 :         aClassName == SvGlobalName(SO3_SM_CLASSID_40) ||
     755         710 :         aClassName == SvGlobalName(SO3_SM_CLASSID_50) ||
     756        1096 :         aClassName == SvGlobalName(SO3_SM_CLASSID_60) ||
     757         386 :         aClassName == SvGlobalName(SO3_SM_CLASSID)      )
     758             :     {
     759          20 :         return true;
     760             :     }
     761             :     else
     762             :     {
     763         122 :         return false;
     764         142 :     }
     765             : }
     766             : 
     767             : 
     768             : // BaseProperties section
     769             : 
     770         464 : sdr::properties::BaseProperties* SdrOle2Obj::CreateObjectSpecificProperties()
     771             : {
     772         464 :     return new sdr::properties::OleProperties(*this);
     773             : }
     774             : 
     775             : 
     776             : // DrawContact section
     777             : 
     778         464 : sdr::contact::ViewContact* SdrOle2Obj::CreateObjectSpecificViewContact()
     779             : {
     780         464 :     return new sdr::contact::ViewContactOfSdrOle2Obj(*this);
     781             : }
     782             : 
     783             : 
     784             : 
     785       63432 : TYPEINIT1(SdrOle2Obj,SdrRectObj);
     786             : 
     787         322 : SdrOle2Obj::SdrOle2Obj( bool bFrame_ ) :
     788         322 :     mpImpl(new SdrOle2ObjImpl(bFrame_))
     789             : {
     790         322 : }
     791             : 
     792         142 : SdrOle2Obj::SdrOle2Obj( const svt::EmbeddedObjectRef&  rNewObjRef, const OUString& rNewObjName, const Rectangle& rNewRect, bool bFrame_ ) :
     793             :     SdrRectObj(rNewRect),
     794         142 :     mpImpl(new SdrOle2ObjImpl(bFrame_, rNewObjRef))
     795             : {
     796         142 :     mpImpl->aPersistName = rNewObjName;
     797             : 
     798         142 :     if (mpImpl->mxObjRef.is() && (mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::EMBED_NEVERRESIZE ) )
     799           0 :         SetResizeProtect(true);
     800             : 
     801             :     // For math objects, set closed state to transparent
     802         142 :     SetClosedObj(!ImplIsMathObj( mpImpl->mxObjRef.GetObject() ));
     803         142 : }
     804             : 
     805           0 : OUString SdrOle2Obj::GetStyleString()
     806             : {
     807           0 :     OUString strStyle;
     808           0 :     if (mpImpl->mxObjRef.is() && mpImpl->mxObjRef.IsChart())
     809             :     {
     810           0 :         strStyle = mpImpl->mxObjRef.GetChartType();
     811             :     }
     812           0 :     return strStyle;
     813             : }
     814             : 
     815             : 
     816             : 
     817        1392 : SdrOle2Obj::~SdrOle2Obj()
     818             : {
     819         464 :     mpImpl->mbInDestruction = true;
     820             : 
     821         464 :     if ( mpImpl->mbConnected )
     822           0 :         Disconnect();
     823             : 
     824         464 :     DisconnectFileLink_Impl();
     825             : 
     826         464 :     if ( mpImpl->pLightClient )
     827             :     {
     828         424 :         mpImpl->pLightClient->Release();
     829         424 :         mpImpl->pLightClient = NULL;
     830             :     }
     831             : 
     832         464 :     delete mpImpl;
     833         928 : }
     834             : 
     835             : 
     836          86 : void SdrOle2Obj::SetAspect( sal_Int64 nAspect )
     837             : {
     838          86 :     mpImpl->mxObjRef.SetViewAspect( nAspect );
     839          86 : }
     840             : 
     841         558 : const svt::EmbeddedObjectRef& SdrOle2Obj::getEmbeddedObjectRef() const
     842             : {
     843         558 :     return mpImpl->mxObjRef;
     844             : }
     845             : 
     846        5321 : sal_Int64 SdrOle2Obj::GetAspect() const
     847             : {
     848        5321 :     return mpImpl->mxObjRef.GetViewAspect();
     849             : }
     850             : 
     851           0 : bool SdrOle2Obj::isInplaceActive() const
     852             : {
     853           0 :     return mpImpl->mxObjRef.is() && embed::EmbedStates::INPLACE_ACTIVE == mpImpl->mxObjRef->getCurrentState();
     854             : }
     855             : 
     856           0 : bool SdrOle2Obj::isUiActive() const
     857             : {
     858           0 :     return mpImpl->mxObjRef.is() && embed::EmbedStates::UI_ACTIVE == mpImpl->mxObjRef->getCurrentState();
     859             : }
     860             : 
     861          10 : void SdrOle2Obj::SetGraphic_Impl(const Graphic* pGrf)
     862             : {
     863          10 :     if (mpImpl->mpGraphic)
     864             :     {
     865           0 :         delete mpImpl->mpGraphic;
     866           0 :         mpImpl->mpGraphic = NULL;
     867           0 :         delete mpImpl->mpGraphicObject;
     868           0 :         mpImpl->mpGraphicObject = NULL;
     869             :     }
     870             : 
     871          10 :     if (pGrf)
     872             :     {
     873          10 :         mpImpl->mpGraphic = new Graphic(*pGrf);
     874          10 :         mpImpl->mpGraphicObject = new GraphicObject(*mpImpl->mpGraphic);
     875             :     }
     876             : 
     877          10 :     SetChanged();
     878          10 :     BroadcastObjectChange();
     879          10 : }
     880             : 
     881          10 : void SdrOle2Obj::SetGraphic(const Graphic* pGrf)
     882             : {
     883             :     // only for setting a preview graphic
     884          10 :     SetGraphic_Impl( pGrf );
     885          10 : }
     886             : 
     887           0 : void SdrOle2Obj::SetProgName( const OUString& rName )
     888             : {
     889           0 :     mpImpl->maProgName = rName;
     890           0 : }
     891             : 
     892           0 : const OUString& SdrOle2Obj::GetProgName() const
     893             : {
     894           0 :     return mpImpl->maProgName;
     895             : }
     896             : 
     897         488 : bool SdrOle2Obj::IsEmpty() const
     898             : {
     899         488 :     return !mpImpl->mxObjRef.is();
     900             : }
     901             : 
     902             : 
     903             : 
     904         878 : void SdrOle2Obj::Connect()
     905             : {
     906         878 :     if( IsEmptyPresObj() )
     907          10 :         return;
     908             : 
     909         868 :     if( mpImpl->mbConnected )
     910             :     {
     911             :         // currently there are situations where it seems to be unavoidable to have multiple connects
     912             :         // changing this would need a larger code rewrite, so for now I remove the assertion
     913             :         // OSL_FAIL("Connect() called on connected object!");
     914         244 :         return;
     915             :     }
     916             : 
     917         624 :     Connect_Impl();
     918         624 :     AddListeners_Impl();
     919             : }
     920             : 
     921             : 
     922             : 
     923           0 : bool SdrOle2Obj::UpdateLinkURL_Impl()
     924             : {
     925           0 :     bool bResult = false;
     926             : 
     927           0 :     if ( mpImpl->mpObjectLink )
     928             :     {
     929           0 :         sfx2::LinkManager* pLinkManager = pModel ? pModel->GetLinkManager() : NULL;
     930           0 :         if ( pLinkManager )
     931             :         {
     932           0 :             OUString aNewLinkURL;
     933           0 :             pLinkManager->GetDisplayNames( mpImpl->mpObjectLink, 0, &aNewLinkURL, 0, 0 );
     934           0 :             if ( !aNewLinkURL.equalsIgnoreAsciiCase( mpImpl->maLinkURL ) )
     935             :             {
     936           0 :                 const_cast<SdrOle2Obj*>(this)->GetObjRef_Impl();
     937           0 :                 uno::Reference<embed::XCommonEmbedPersist> xPersObj( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY );
     938             :                 OSL_ENSURE( xPersObj.is(), "The object must exist!\n" );
     939           0 :                 if ( xPersObj.is() )
     940             :                 {
     941             :                     try
     942             :                     {
     943           0 :                         sal_Int32 nCurState = mpImpl->mxObjRef->getCurrentState();
     944           0 :                         if ( nCurState != embed::EmbedStates::LOADED )
     945           0 :                             mpImpl->mxObjRef->changeState(embed::EmbedStates::LOADED);
     946             : 
     947             :                         // TODO/LATER: there should be possible to get current mediadescriptor settings from the object
     948           0 :                         uno::Sequence< beans::PropertyValue > aArgs( 1 );
     949           0 :                         aArgs[0].Name = "URL";
     950           0 :                         aArgs[0].Value <<= OUString( aNewLinkURL );
     951           0 :                         xPersObj->reload( aArgs, uno::Sequence< beans::PropertyValue >() );
     952             : 
     953           0 :                         mpImpl->maLinkURL = aNewLinkURL;
     954           0 :                         bResult = true;
     955             : 
     956           0 :                         if ( nCurState != embed::EmbedStates::LOADED )
     957           0 :                             mpImpl->mxObjRef->changeState(nCurState);
     958             :                     }
     959           0 :                     catch( ::com::sun::star::uno::Exception& )
     960             :                     {
     961             :                         OSL_FAIL(
     962             :                             OString(OString("SdrOle2Obj::UpdateLinkURL_Impl(), "
     963             :                                     "exception caught: ") +
     964             :                             OUStringToOString(
     965             :                                 comphelper::anyToString( cppu::getCaughtException() ),
     966             :                                 RTL_TEXTENCODING_UTF8 )).getStr() );
     967             :                     }
     968             :                 }
     969             : 
     970           0 :                 if ( !bResult )
     971             :                 {
     972             :                     // TODO/LATER: return the old name to the link manager, is it possible?
     973           0 :                 }
     974           0 :             }
     975             :         }
     976             :     }
     977             : 
     978           0 :     return bResult;
     979             : }
     980             : 
     981             : 
     982             : 
     983           0 : void SdrOle2Obj::BreakFileLink_Impl()
     984             : {
     985           0 :     uno::Reference<document::XStorageBasedDocument> xDoc;
     986           0 :     if ( pModel )
     987           0 :         xDoc.set( pModel->getUnoModel(),uno::UNO_QUERY);
     988             : 
     989           0 :     if ( xDoc.is() )
     990             :     {
     991           0 :         uno::Reference< embed::XStorage > xStorage = xDoc->getDocumentStorage();
     992           0 :         if ( xStorage.is() )
     993             :         {
     994             :             try
     995             :             {
     996           0 :                 uno::Reference< embed::XLinkageSupport > xLinkSupport( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY_THROW );
     997           0 :                 xLinkSupport->breakLink( xStorage, mpImpl->aPersistName );
     998           0 :                 DisconnectFileLink_Impl();
     999           0 :                 mpImpl->maLinkURL = "";
    1000             :             }
    1001           0 :             catch( ::com::sun::star::uno::Exception& )
    1002             :             {
    1003             :                 OSL_FAIL(
    1004             :                     OString(OString("SdrOle2Obj::BreakFileLink_Impl(), "
    1005             :                             "exception caught: ") +
    1006             :                     OUStringToOString(
    1007             :                         comphelper::anyToString( cppu::getCaughtException() ),
    1008             :                         RTL_TEXTENCODING_UTF8 )).getStr() );
    1009             :             }
    1010           0 :         }
    1011           0 :     }
    1012           0 : }
    1013             : 
    1014             : 
    1015             : 
    1016         638 : void SdrOle2Obj::DisconnectFileLink_Impl()
    1017             : {
    1018         638 :     sfx2::LinkManager* pLinkManager = pModel ? pModel->GetLinkManager() : NULL;
    1019         638 :     if ( pLinkManager && mpImpl->mpObjectLink )
    1020             :     {
    1021           0 :         pLinkManager->Remove( mpImpl->mpObjectLink );
    1022           0 :         mpImpl->mpObjectLink = NULL;
    1023             :     }
    1024         638 : }
    1025             : 
    1026             : 
    1027             : 
    1028         424 : void SdrOle2Obj::CheckFileLink_Impl()
    1029             : {
    1030         424 :     if (pModel && mpImpl->mxObjRef.GetObject().is() && !mpImpl->mpObjectLink)
    1031             :     {
    1032             :         try
    1033             :         {
    1034         424 :             uno::Reference< embed::XLinkageSupport > xLinkSupport( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY );
    1035         424 :             if ( xLinkSupport.is() && xLinkSupport->isLink() )
    1036             :             {
    1037           0 :                 OUString aLinkURL = xLinkSupport->getLinkURL();
    1038           0 :                 if ( !aLinkURL.isEmpty() )
    1039             :                 {
    1040             :                     // this is a file link so the model link manager should handle it
    1041           0 :                     sfx2::LinkManager* pLinkManager = pModel->GetLinkManager();
    1042           0 :                     if ( pLinkManager )
    1043             :                     {
    1044           0 :                         mpImpl->mpObjectLink = new SdrEmbedObjectLink( this );
    1045           0 :                         mpImpl->maLinkURL = aLinkURL;
    1046           0 :                         pLinkManager->InsertFileLink( *mpImpl->mpObjectLink, OBJECT_CLIENT_OLE, aLinkURL, NULL, NULL );
    1047           0 :                         mpImpl->mpObjectLink->Connect();
    1048             :                     }
    1049           0 :                 }
    1050         424 :             }
    1051             :         }
    1052           0 :         catch( ::com::sun::star::uno::Exception& )
    1053             :         {
    1054             :             OSL_FAIL(
    1055             :                 OString(OString("SdrOle2Obj::CheckFileLink_Impl(), "
    1056             :                         "exception caught: ") +
    1057             :                 OUStringToOString(
    1058             :                     comphelper::anyToString( cppu::getCaughtException() ),
    1059             :                     RTL_TEXTENCODING_UTF8 )).getStr() );
    1060             :         }
    1061             :     }
    1062         424 : }
    1063             : 
    1064             : 
    1065             : 
    1066           0 : void SdrOle2Obj::Reconnect_Impl()
    1067             : {
    1068             :     DBG_ASSERT( mpImpl->mbConnected, "Assigned unconnected object?!" );
    1069           0 :     Connect_Impl();
    1070           0 : }
    1071             : 
    1072        1048 : void SdrOle2Obj::Connect_Impl()
    1073             : {
    1074        1048 :     if( pModel && !mpImpl->aPersistName.isEmpty() )
    1075             :     {
    1076             :         try
    1077             :         {
    1078         424 :             ::comphelper::IEmbeddedHelper* pPers = pModel->GetPersist();
    1079         424 :             if ( pPers )
    1080             :             {
    1081         424 :                 comphelper::EmbeddedObjectContainer& rContainer = pPers->getEmbeddedObjectContainer();
    1082         848 :                 if ( !rContainer.HasEmbeddedObject( mpImpl->aPersistName )
    1083         424 :                   || ( mpImpl->mxObjRef.is() && !rContainer.HasEmbeddedObject( mpImpl->mxObjRef.GetObject() ) ) )
    1084             :                 {
    1085             :                     // object not known to container document
    1086             :                     // No object -> disaster!
    1087             :                     DBG_ASSERT( mpImpl->mxObjRef.is(), "No object in connect!");
    1088           0 :                     if ( mpImpl->mxObjRef.is() )
    1089             :                     {
    1090             :                         // object came from the outside, now add it to the container
    1091           0 :                         OUString aTmp;
    1092           0 :                         rContainer.InsertEmbeddedObject( mpImpl->mxObjRef.GetObject(), aTmp );
    1093           0 :                         mpImpl->aPersistName = aTmp;
    1094             :                     }
    1095             :                 }
    1096         424 :                 else if ( !mpImpl->mxObjRef.is() )
    1097             :                 {
    1098         312 :                     mpImpl->mxObjRef.Assign( rContainer.GetEmbeddedObject( mpImpl->aPersistName ), mpImpl->mxObjRef.GetViewAspect() );
    1099         312 :                     mpImpl->mbTypeAsked = false;
    1100             :                 }
    1101             : 
    1102         424 :                 if ( mpImpl->mxObjRef.GetObject().is() )
    1103             :                 {
    1104         424 :                     mpImpl->mxObjRef.AssignToContainer( &rContainer, mpImpl->aPersistName );
    1105         424 :                     mpImpl->mbConnected = true;
    1106         424 :                     mpImpl->mxObjRef.Lock( true );
    1107             :                 }
    1108             :             }
    1109             : 
    1110         424 :             if ( mpImpl->mxObjRef.is() )
    1111             :             {
    1112         424 :                 if ( !mpImpl->pLightClient )
    1113             :                 {
    1114         424 :                     mpImpl->pLightClient = new SdrLightEmbeddedClient_Impl( this );
    1115         424 :                     mpImpl->pLightClient->acquire();
    1116             :                 }
    1117             : 
    1118         424 :                 mpImpl->mxObjRef->addStateChangeListener( mpImpl->pLightClient );
    1119         424 :                 mpImpl->mxObjRef->addEventListener( uno::Reference< document::XEventListener >( mpImpl->pLightClient ) );
    1120             : 
    1121         424 :                 if ( mpImpl->mxObjRef->getCurrentState() != embed::EmbedStates::LOADED )
    1122         334 :                     GetSdrGlobalData().GetOLEObjCache().InsertObj(this);
    1123             : 
    1124         424 :                 CheckFileLink_Impl();
    1125             : 
    1126         424 :                 uno::Reference< container::XChild > xChild( mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY );
    1127         424 :                 if( xChild.is() )
    1128             :                 {
    1129         412 :                     uno::Reference< uno::XInterface > xParent( pModel->getUnoModel());
    1130         412 :                     if( xParent.is())
    1131         412 :                         xChild->setParent( pModel->getUnoModel() );
    1132         424 :                 }
    1133             : 
    1134             :             }
    1135             :         }
    1136           0 :         catch( ::com::sun::star::uno::Exception& )
    1137             :         {
    1138             :             OSL_FAIL(
    1139             :                 OString(OString("SdrOle2Obj::Connect_Impl(), "
    1140             :                         "exception caught: ") +
    1141             :                 OUStringToOString(
    1142             :                     comphelper::anyToString( cppu::getCaughtException() ),
    1143             :                     RTL_TEXTENCODING_UTF8 )).getStr() );
    1144             :         }
    1145             :     }
    1146             : 
    1147             :     //TODO/LATER: wait for definition of MiscStatus RESIZEONPRINTERCHANGE
    1148             :     //if ( xObjRef.is() && (*ppObjRef)->GetMiscStatus() & SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE )
    1149             :     {
    1150             :         //TODO/LATER: needs a new handling for OnPrinterChanged
    1151             :         /*
    1152             :         if (pModel && pModel->GetRefDevice() &&
    1153             :             pModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER)
    1154             :         {
    1155             :             // Kein RefDevice oder RefDevice kein Printer
    1156             :             bool bModified = (*ppObjRef)->IsModified();
    1157             :             Printer* pPrinter = (Printer*) pModel->GetRefDevice();
    1158             :             (*ppObjRef)->OnDocumentPrinterChanged( pPrinter );
    1159             :             (*ppObjRef)->SetModified( bModified );
    1160             :         }*/
    1161             :     }
    1162        1048 : }
    1163             : 
    1164          68 : void SdrOle2Obj::ObjectLoaded()
    1165             : {
    1166          68 :     AddListeners_Impl();
    1167          68 : }
    1168             : 
    1169        1126 : void SdrOle2Obj::AddListeners_Impl()
    1170             : {
    1171        1126 :     if( mpImpl->mxObjRef.is() && mpImpl->mxObjRef->getCurrentState() != embed::EmbedStates::LOADED )
    1172             :     {
    1173             :         // register modify listener
    1174         402 :         if (!mpImpl->mpModifyListener)
    1175             :         {
    1176         402 :             mpImpl->mpModifyListener = new SvxUnoShapeModifyListener(this);
    1177         402 :             mpImpl->mpModifyListener->acquire();
    1178             :         }
    1179             : 
    1180         402 :         uno::Reference< util::XModifyBroadcaster > xBC( getXModel(), uno::UNO_QUERY );
    1181         402 :         if (xBC.is() && mpImpl->mpModifyListener)
    1182             :         {
    1183         402 :             uno::Reference<util::XModifyListener> xListener(mpImpl->mpModifyListener);
    1184         402 :             xBC->addModifyListener( xListener );
    1185         402 :         }
    1186             :     }
    1187        1126 : }
    1188             : 
    1189             : 
    1190             : 
    1191         424 : void SdrOle2Obj::Disconnect()
    1192             : {
    1193         424 :     if( IsEmptyPresObj() )
    1194           0 :         return;
    1195             : 
    1196         424 :     if( !mpImpl->mbConnected )
    1197             :     {
    1198             :         OSL_FAIL("Disconnect() called on disconnected object!");
    1199           0 :         return;
    1200             :     }
    1201             : 
    1202         424 :     RemoveListeners_Impl();
    1203         424 :     Disconnect_Impl();
    1204             : }
    1205             : 
    1206         858 : void SdrOle2Obj::RemoveListeners_Impl()
    1207             : {
    1208         858 :     if ( mpImpl->mxObjRef.is() && !mpImpl->aPersistName.isEmpty() )
    1209             :     {
    1210             :         try
    1211             :         {
    1212         536 :             sal_Int32 nState = mpImpl->mxObjRef->getCurrentState();
    1213         536 :             if ( nState != embed::EmbedStates::LOADED )
    1214             :             {
    1215         508 :                 uno::Reference< util::XModifyBroadcaster > xBC( getXModel(), uno::UNO_QUERY );
    1216         508 :                 if (xBC.is() && mpImpl->mpModifyListener)
    1217             :                 {
    1218         402 :                     uno::Reference<util::XModifyListener> xListener(mpImpl->mpModifyListener);
    1219         402 :                     xBC->removeModifyListener( xListener );
    1220         508 :                 }
    1221             :             }
    1222             :         }
    1223           0 :         catch( ::com::sun::star::uno::Exception& )
    1224             :         {
    1225             :             OSL_FAIL(
    1226             :                 OString(OString("SdrOle2Obj::RemoveListeners_Impl(), "
    1227             :                         "exception caught: ") +
    1228             :                 OUStringToOString(
    1229             :                     comphelper::anyToString( cppu::getCaughtException() ),
    1230             :                     RTL_TEXTENCODING_UTF8 )).getStr() );
    1231             :         }
    1232             :     }
    1233         858 : }
    1234             : 
    1235         424 : void SdrOle2Obj::Disconnect_Impl()
    1236             : {
    1237             :     try
    1238             :     {
    1239         424 :         if ( pModel && !mpImpl->aPersistName.isEmpty() )
    1240             :         {
    1241         424 :             if( pModel->IsInDestruction() )
    1242             :             {
    1243             :                 // TODO/LATER: here we must assume that the destruction of the model is enough to make clear that we will not
    1244             :                 // remove the object from the container, even if the DrawingObject itself is not destroyed (unfortunately this
    1245             :                 // There is no real need to do the following removing of the object from the container
    1246             :                 // in case the model has correct persistence, but in case of problems such a removing
    1247             :                 // would make the behavior of the office more stable
    1248             : 
    1249         250 :                 comphelper::EmbeddedObjectContainer* pContainer = mpImpl->mxObjRef.GetContainer();
    1250         250 :                 if ( pContainer )
    1251             :                 {
    1252         250 :                     pContainer->CloseEmbeddedObject( mpImpl->mxObjRef.GetObject() );
    1253         250 :                     mpImpl->mxObjRef.AssignToContainer( NULL, mpImpl->aPersistName );
    1254             :                 }
    1255             : 
    1256             :                 // happens later than the destruction of the model, so we can't assert that).
    1257             :                 //DBG_ASSERT( bInDestruction, "Model is destroyed, but not me?!" );
    1258             :                 //TODO/LATER: should be make sure that the ObjectShell also forgets the object, because we will close it soon?
    1259             :                 /*
    1260             :                 uno::Reference < util::XCloseable > xClose( xObjRef, uno::UNO_QUERY );
    1261             :                 if ( xClose.is() )
    1262             :                 {
    1263             :                     try
    1264             :                     {
    1265             :                         xClose->close( true );
    1266             :                     }
    1267             :                     catch ( util::CloseVetoException& )
    1268             :                     {
    1269             :                         // there's still someone who needs the object!
    1270             :                     }
    1271             :                 }
    1272             : 
    1273             :                 xObjRef = NULL;*/
    1274             :             }
    1275         174 :             else if ( mpImpl->mxObjRef.is() )
    1276             :             {
    1277         174 :                 if ( pModel->getUnoModel().is() )
    1278             :                 {
    1279             :                     // remove object, but don't close it (that's up to someone else)
    1280         174 :                     comphelper::EmbeddedObjectContainer* pContainer = mpImpl->mxObjRef.GetContainer();
    1281         174 :                     if ( pContainer )
    1282             :                     {
    1283         174 :                         pContainer->RemoveEmbeddedObject( mpImpl->mxObjRef.GetObject(), false);
    1284             : 
    1285             :                         // TODO/LATER: mpImpl->aPersistName contains outdated information, to keep it updated
    1286             :                         // it should be returned from RemoveEmbeddedObject call. Currently it is no problem,
    1287             :                         // since no container is adjusted, actually the empty string could be provided as a name here
    1288         174 :                         mpImpl->mxObjRef.AssignToContainer( NULL, mpImpl->aPersistName );
    1289             :                     }
    1290             : 
    1291         174 :                     DisconnectFileLink_Impl();
    1292             :                 }
    1293             :             }
    1294             :         }
    1295             : 
    1296         424 :         if ( mpImpl->mxObjRef.is() && mpImpl->pLightClient )
    1297             :         {
    1298         424 :             mpImpl->mxObjRef->removeStateChangeListener ( mpImpl->pLightClient );
    1299         424 :             mpImpl->mxObjRef->removeEventListener( uno::Reference< document::XEventListener >( mpImpl->pLightClient ) );
    1300         424 :             mpImpl->mxObjRef->setClientSite( NULL );
    1301             : 
    1302         424 :             GetSdrGlobalData().GetOLEObjCache().RemoveObj(this);
    1303             :         }
    1304             :     }
    1305           0 :     catch( ::com::sun::star::uno::Exception& )
    1306             :     {
    1307             :         OSL_FAIL(
    1308             :             OString(OString("SdrOle2Obj::Disconnect_Impl(), "
    1309             :                     "exception caught: ") +
    1310             :             OUStringToOString(
    1311             :                 comphelper::anyToString( cppu::getCaughtException() ),
    1312             :                 RTL_TEXTENCODING_UTF8 )).getStr() );
    1313             :     }
    1314             : 
    1315         424 :     mpImpl->mbConnected = false;
    1316         424 : }
    1317             : 
    1318             : 
    1319             : 
    1320           0 : SdrObject* SdrOle2Obj::createSdrGrafObjReplacement(bool bAddText, bool /* bUseHCGraphic */) const
    1321             : {
    1322           0 :     const Graphic* pOLEGraphic = GetGraphic();
    1323             : 
    1324           0 :     if(pOLEGraphic)
    1325             :     {
    1326             :         // #i118485# allow creating a SdrGrafObj representation
    1327           0 :         SdrGrafObj* pClone = new SdrGrafObj(*pOLEGraphic);
    1328           0 :         pClone->SetModel(GetModel());
    1329             : 
    1330             :         // copy transformation
    1331           0 :         basegfx::B2DHomMatrix aMatrix;
    1332           0 :         basegfx::B2DPolyPolygon aPolyPolygon;
    1333             : 
    1334           0 :         TRGetBaseGeometry(aMatrix, aPolyPolygon);
    1335           0 :         pClone->TRSetBaseGeometry(aMatrix, aPolyPolygon);
    1336             : 
    1337             :         // copy all attributes to support graphic styles for OLEs
    1338           0 :         pClone->SetStyleSheet(GetStyleSheet(), false);
    1339           0 :         pClone->SetMergedItemSet(GetMergedItemSet());
    1340             : 
    1341           0 :         if(bAddText)
    1342             :         {
    1343             :             // #i118485# copy text (Caution! Model needed, as guaranteed in aw080)
    1344           0 :             OutlinerParaObject* pOPO = GetOutlinerParaObject();
    1345             : 
    1346           0 :             if(pOPO && GetModel())
    1347             :             {
    1348           0 :                 pClone->NbcSetOutlinerParaObject(new OutlinerParaObject(*pOPO));
    1349             :             }
    1350             :         }
    1351             : 
    1352           0 :         return pClone;
    1353             :     }
    1354             :     else
    1355             :     {
    1356             :         // #i100710# pOLEGraphic may be zero (no visualisation available),
    1357             :         // so we need to use the OLE replacement graphic
    1358           0 :         SdrRectObj* pClone = new SdrRectObj(GetSnapRect());
    1359           0 :         pClone->SetModel(GetModel());
    1360             : 
    1361             :         // gray outline
    1362           0 :         pClone->SetMergedItem(XLineStyleItem(XLINE_SOLID));
    1363           0 :         const svtools::ColorConfig aColorConfig;
    1364           0 :         const svtools::ColorConfigValue aColor(aColorConfig.GetColorValue(svtools::OBJECTBOUNDARIES));
    1365           0 :         pClone->SetMergedItem(XLineColorItem(OUString(), aColor.nColor));
    1366             : 
    1367             :         // bitmap fill
    1368           0 :         pClone->SetMergedItem(XFillStyleItem(drawing::FillStyle_BITMAP));
    1369           0 :         pClone->SetMergedItem(XFillBitmapItem(OUString(), GetEmptyOLEReplacementGraphic()));
    1370           0 :         pClone->SetMergedItem(XFillBmpTileItem(false));
    1371           0 :         pClone->SetMergedItem(XFillBmpStretchItem(false));
    1372             : 
    1373           0 :         return pClone;
    1374             :     }
    1375             : }
    1376             : 
    1377           0 : SdrObject* SdrOle2Obj::DoConvertToPolyObj(bool bBezier, bool bAddText) const
    1378             : {
    1379             :     // #i118485# missing converter added
    1380           0 :     if(GetModel())
    1381             :     {
    1382           0 :         SdrObject* pRetval = createSdrGrafObjReplacement(true, false);
    1383             : 
    1384           0 :         if(pRetval)
    1385             :         {
    1386           0 :             SdrObject* pRetval2 = pRetval->DoConvertToPolyObj(bBezier, bAddText);
    1387           0 :             SdrObject::Free(pRetval);
    1388             : 
    1389           0 :             return pRetval2;
    1390             :         }
    1391             :     }
    1392             : 
    1393           0 :     return 0;
    1394             : }
    1395             : 
    1396             : 
    1397             : 
    1398         768 : void SdrOle2Obj::SetModel(SdrModel* pNewModel)
    1399             : {
    1400         768 :     ::comphelper::IEmbeddedHelper* pDestPers = pNewModel ? pNewModel->GetPersist() : 0;
    1401         768 :     ::comphelper::IEmbeddedHelper* pSrcPers  = pModel ? pModel->GetPersist() : 0;
    1402             : 
    1403         768 :     if ( pNewModel == pModel )
    1404             :     {
    1405             :         // don't know if this is necessary or if it will ever happen, but who knows?!
    1406         312 :         SdrRectObj::SetModel( pNewModel );
    1407         312 :         return;
    1408             :     }
    1409             : 
    1410             :     // assignment to model has changed
    1411             :     DBG_ASSERT( pSrcPers || !mpImpl->mbConnected, "Connected object without a model?!" );
    1412             : 
    1413             :     DBG_ASSERT( pDestPers, "The destination model must have a persistence! Please submit an issue!" );
    1414             :     DBG_ASSERT( pDestPers != pSrcPers, "The source and the destination models should have different persistences! Problems are possible!" );
    1415             : 
    1416             :     // this is a bug if the target model has no persistence
    1417             :     // no error handling is possible so just do nothing in this method
    1418         456 :     if ( !pDestPers )
    1419          22 :         return;
    1420             : 
    1421         434 :     RemoveListeners_Impl();
    1422             : 
    1423         434 :     if( pDestPers && pSrcPers && !IsEmptyPresObj() )
    1424             :     {
    1425             :         try
    1426             :         {
    1427             :             // move the object's storage; ObjectRef remains the same, but PersistName may change
    1428           0 :             OUString aTmp;
    1429           0 :             comphelper::EmbeddedObjectContainer& rContainer = pSrcPers->getEmbeddedObjectContainer();
    1430           0 :             uno::Reference < embed::XEmbeddedObject > xObj = rContainer.GetEmbeddedObject( mpImpl->aPersistName );
    1431             :             DBG_ASSERT( !mpImpl->mxObjRef.is() || mpImpl->mxObjRef.GetObject() == xObj, "Wrong object identity!" );
    1432           0 :             if ( xObj.is() )
    1433             :             {
    1434           0 :                 pDestPers->getEmbeddedObjectContainer().MoveEmbeddedObject( rContainer, xObj, aTmp );
    1435           0 :                 mpImpl->aPersistName = aTmp;
    1436           0 :                 mpImpl->mxObjRef.AssignToContainer( &pDestPers->getEmbeddedObjectContainer(), aTmp );
    1437             :             }
    1438           0 :             DBG_ASSERT( !aTmp.isEmpty(), "Copying embedded object failed!" );
    1439             :         }
    1440           0 :         catch( ::com::sun::star::uno::Exception& )
    1441             :         {
    1442             :             OSL_FAIL(
    1443             :                 OString(OString("SdrOle2Obj::SetModel(), "
    1444             :                         "exception caught: ") +
    1445             :                 OUStringToOString(
    1446             :                     comphelper::anyToString( cppu::getCaughtException() ),
    1447             :                     RTL_TEXTENCODING_UTF8 )).getStr() );
    1448             :         }
    1449             :     }
    1450             : 
    1451         434 :     SdrRectObj::SetModel( pNewModel );
    1452             : 
    1453             :     // #i43086#
    1454             :     // #i85304 redo the change for charts for the above bugfix, as #i43086# does not occur anymore
    1455             :     //so maybe the ImpSetVisAreaSize call can be removed here completely
    1456             :     //Nevertheless I leave it in for other objects as I am not sure about the side effects when removing now
    1457         434 :     if( pModel && !pModel->isLocked() && !IsChart() )
    1458         208 :         ImpSetVisAreaSize();
    1459             : 
    1460         434 :     if( pDestPers && !IsEmptyPresObj() )
    1461             :     {
    1462         424 :         if ( !pSrcPers || IsEmptyPresObj() )
    1463             :             // object wasn't connected, now it should be
    1464         424 :             Connect_Impl();
    1465             :         else
    1466           0 :             Reconnect_Impl();
    1467             :     }
    1468             : 
    1469         434 :     AddListeners_Impl();
    1470             : }
    1471             : 
    1472             : 
    1473             : 
    1474         930 : void SdrOle2Obj::SetPage(SdrPage* pNewPage)
    1475             : {
    1476         930 :     bool bRemove=pNewPage==NULL && pPage!=NULL;
    1477         930 :     bool bInsert=pNewPage!=NULL && pPage==NULL;
    1478             : 
    1479         930 :     if (bRemove && mpImpl->mbConnected )
    1480         174 :         Disconnect();
    1481             : 
    1482         930 :     if(!pModel && !GetStyleSheet() && pNewPage && pNewPage->GetModel())
    1483             :     {
    1484             :         // #i119287# Set default StyleSheet for SdrGrafObj here, it is different from 'Default'. This
    1485             :         // needs to be done before the style 'Default' is set from the :SetModel() call which is triggered
    1486             :         // from the following :SetPage().
    1487             :         // TTTT: Needs to be moved in branch aw080 due to having a SdrModel from the beginning, is at this
    1488             :         // place for convenience currently (works in both versions, is not in the way)
    1489         336 :         SfxStyleSheet* pSheet = pNewPage->GetModel()->GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj();
    1490             : 
    1491         336 :         if(pSheet)
    1492             :         {
    1493          48 :             SetStyleSheet(pSheet, false);
    1494             :         }
    1495             :         else
    1496             :         {
    1497         288 :             SetMergedItem(XFillStyleItem(drawing::FillStyle_NONE));
    1498         288 :             SetMergedItem(XLineStyleItem(XLINE_NONE));
    1499             :         }
    1500             :     }
    1501             : 
    1502         930 :     SdrRectObj::SetPage(pNewPage);
    1503             : 
    1504         930 :     if (bInsert && !mpImpl->mbConnected )
    1505         322 :         Connect();
    1506         930 : }
    1507             : 
    1508             : 
    1509             : 
    1510          30 : void SdrOle2Obj::SetObjRef( const com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject >& rNewObjRef )
    1511             : {
    1512             :     DBG_ASSERT( !rNewObjRef.is() || !mpImpl->mxObjRef.GetObject().is(), "SetObjRef called on already initialized object!");
    1513          30 :     if( rNewObjRef == mpImpl->mxObjRef.GetObject() )
    1514          30 :         return;
    1515             : 
    1516             :     // the caller of the method is responsible to control the old object, it will not be closed here
    1517             :     // Otherwise WW8 import crashes because it transfers control to OLENode by this method
    1518          30 :     if ( mpImpl->mxObjRef.GetObject().is() )
    1519          30 :         mpImpl->mxObjRef.Lock( false );
    1520             : 
    1521             :     // avoid removal of object in Disconnect! It is definitely a HACK to call SetObjRef(0)!
    1522             :     // This call will try to close the objects; so if anybody else wants to keep it, it must be locked by a CloseListener
    1523          30 :     mpImpl->mxObjRef.Clear();
    1524             : 
    1525          30 :     if ( mpImpl->mbConnected )
    1526           0 :         Disconnect();
    1527             : 
    1528          30 :     mpImpl->mxObjRef.Assign( rNewObjRef, GetAspect() );
    1529          30 :     mpImpl->mbTypeAsked = false;
    1530             : 
    1531          30 :     if ( mpImpl->mxObjRef.is() )
    1532             :     {
    1533           0 :         DELETEZ(mpImpl->mpGraphic);
    1534             : 
    1535           0 :         if ( (mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::EMBED_NEVERRESIZE ) )
    1536           0 :             SetResizeProtect(true);
    1537             : 
    1538             :         // For math objects, set closed state to transparent
    1539           0 :         SetClosedObj(!ImplIsMathObj( rNewObjRef ));
    1540             : 
    1541           0 :         Connect();
    1542             :     }
    1543             : 
    1544          30 :     SetChanged();
    1545          30 :     BroadcastObjectChange();
    1546             : }
    1547             : 
    1548             : 
    1549             : 
    1550         142 : void SdrOle2Obj::SetClosedObj( bool bIsClosed )
    1551             : {
    1552             :     // TODO/LATER: do we still need this hack?
    1553             :     // Allow changes to the closed state of OLE objects
    1554         142 :     bClosedObj = bIsClosed;
    1555         142 : }
    1556             : 
    1557             : 
    1558             : 
    1559           0 : SdrObject* SdrOle2Obj::getFullDragClone() const
    1560             : {
    1561             :     // #i118485# use central replacement generator
    1562           0 :     return createSdrGrafObjReplacement(false, true);
    1563             : }
    1564             : 
    1565             : 
    1566             : 
    1567         312 : void SdrOle2Obj::SetPersistName( const OUString& rPersistName )
    1568             : {
    1569             :     DBG_ASSERT( mpImpl->aPersistName.isEmpty(), "Persist name changed!");
    1570             : 
    1571         312 :     mpImpl->aPersistName = rPersistName;
    1572         312 :     mpImpl->mbLoadingOLEObjectFailed = false;
    1573             : 
    1574         312 :     Connect();
    1575         312 :     SetChanged();
    1576         312 : }
    1577             : 
    1578          30 : void SdrOle2Obj::AbandonObject()
    1579             : {
    1580          30 :     mpImpl->aPersistName = "";
    1581          30 :     mpImpl->mbLoadingOLEObjectFailed = false;
    1582          30 :     SetObjRef(0);
    1583          30 : }
    1584             : 
    1585             : 
    1586             : 
    1587         774 : OUString SdrOle2Obj::GetPersistName() const
    1588             : {
    1589         774 :     return mpImpl->aPersistName;
    1590             : }
    1591             : 
    1592             : 
    1593             : 
    1594           0 : void SdrOle2Obj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
    1595             : {
    1596             :     // #i118485# Allowing much more attributes for OLEs
    1597           0 :     rInfo.bRotateFreeAllowed = true;
    1598           0 :     rInfo.bRotate90Allowed = true;
    1599           0 :     rInfo.bMirrorFreeAllowed = true;
    1600           0 :     rInfo.bMirror45Allowed = true;
    1601           0 :     rInfo.bMirror90Allowed = true;
    1602           0 :     rInfo.bTransparenceAllowed = true;
    1603           0 :     rInfo.bGradientAllowed = true;
    1604           0 :     rInfo.bShearAllowed = true;
    1605           0 :     rInfo.bEdgeRadiusAllowed = false;
    1606           0 :     rInfo.bNoOrthoDesired = false;
    1607           0 :     rInfo.bCanConvToPath = true;
    1608           0 :     rInfo.bCanConvToPoly = true;
    1609           0 :     rInfo.bCanConvToPathLineToArea = false;
    1610           0 :     rInfo.bCanConvToPolyLineToArea = false;
    1611           0 :     rInfo.bCanConvToContour = true;
    1612           0 : }
    1613             : 
    1614             : 
    1615             : 
    1616        4570 : sal_uInt16 SdrOle2Obj::GetObjIdentifier() const
    1617             : {
    1618        4570 :     return mpImpl->mbFrame ? sal_uInt16(OBJ_FRAME) : sal_uInt16(OBJ_OLE2);
    1619             : }
    1620             : 
    1621             : 
    1622             : 
    1623          62 : OUString SdrOle2Obj::TakeObjNameSingul() const
    1624             : {
    1625          62 :     OUStringBuffer sName(ImpGetResStr(mpImpl->mbFrame ? STR_ObjNameSingulFrame : STR_ObjNameSingulOLE2));
    1626             : 
    1627         124 :     const OUString aName(GetName());
    1628             : 
    1629          62 :     if (!aName.isEmpty())
    1630             :     {
    1631           0 :         sName.append(" '");
    1632           0 :         sName.append(aName);
    1633           0 :         sName.append('\'');
    1634             :     }
    1635             : 
    1636         124 :     return sName.makeStringAndClear();
    1637             : }
    1638             : 
    1639             : 
    1640             : 
    1641           0 : OUString SdrOle2Obj::TakeObjNamePlural() const
    1642             : {
    1643           0 :     return ImpGetResStr(mpImpl->mbFrame ? STR_ObjNamePluralFrame : STR_ObjNamePluralOLE2);
    1644             : }
    1645             : 
    1646             : 
    1647             : 
    1648           0 : SdrOle2Obj* SdrOle2Obj::Clone() const
    1649             : {
    1650           0 :     return CloneHelper< SdrOle2Obj >();
    1651             : }
    1652             : 
    1653           0 : SdrOle2Obj* SdrOle2Obj::CloneWithShellIDs( const OUString& rSrcShellID, const OUString& rDestShellID ) const
    1654             : {
    1655             :     SdrOle2Obj* pObj =
    1656             :         dynamic_cast<SdrOle2Obj*>(
    1657           0 :             SdrObjFactory::MakeNewObject(GetObjInventor(), GetObjIdentifier(), NULL));
    1658             : 
    1659           0 :     if (pObj)
    1660           0 :         pObj->assignFrom(*this, rSrcShellID, rDestShellID);
    1661             : 
    1662           0 :     return pObj;
    1663             : }
    1664             : 
    1665           0 : SdrOle2Obj& SdrOle2Obj::assignFrom(
    1666             :     const SdrOle2Obj& rObj, const OUString& rSrcShellID, const OUString& rDestShellID )
    1667             : {
    1668             :     //TODO/LATER: who takes over control of my old object?!
    1669           0 :     if( &rObj != this )
    1670             :     {
    1671             :         // #116235#
    1672             :         // ImpAssign( rObj );
    1673           0 :         const SdrOle2Obj& rOle2Obj = static_cast< const SdrOle2Obj& >( rObj );
    1674             : 
    1675           0 :         uno::Reference<util::XCloseable> xClose(mpImpl->mxObjRef.GetObject(), uno::UNO_QUERY);
    1676             : 
    1677           0 :         if( pModel && mpImpl->mbConnected )
    1678           0 :             Disconnect();
    1679             : 
    1680           0 :         SdrRectObj::operator=( rObj );
    1681             : 
    1682             :         // Manually copying bClosedObj attribute
    1683           0 :         SetClosedObj( rObj.IsClosedObj() );
    1684             : 
    1685           0 :         mpImpl->aPersistName = rOle2Obj.mpImpl->aPersistName;
    1686           0 :         mpImpl->maProgName = rOle2Obj.mpImpl->maProgName;
    1687           0 :         mpImpl->mbFrame = rOle2Obj.mpImpl->mbFrame;
    1688             : 
    1689           0 :         if (rOle2Obj.mpImpl->mpGraphic)
    1690             :         {
    1691           0 :             if (mpImpl->mpGraphic)
    1692             :             {
    1693           0 :                 delete mpImpl->mpGraphic;
    1694           0 :                 delete mpImpl->mpGraphicObject;
    1695             :             }
    1696             : 
    1697           0 :             mpImpl->mpGraphic = new Graphic(*rOle2Obj.mpImpl->mpGraphic);
    1698           0 :             mpImpl->mpGraphicObject = new GraphicObject(*mpImpl->mpGraphic);
    1699             :         }
    1700             : 
    1701           0 :         if( pModel && rObj.GetModel() && !IsEmptyPresObj() )
    1702             :         {
    1703           0 :             ::comphelper::IEmbeddedHelper* pDestPers = pModel->GetPersist();
    1704           0 :             ::comphelper::IEmbeddedHelper* pSrcPers = rObj.GetModel()->GetPersist();
    1705           0 :             if( pDestPers && pSrcPers )
    1706             :             {
    1707             :                 DBG_ASSERT( !mpImpl->mxObjRef.is(), "Object already existing!" );
    1708           0 :                 comphelper::EmbeddedObjectContainer& rContainer = pSrcPers->getEmbeddedObjectContainer();
    1709           0 :                 uno::Reference < embed::XEmbeddedObject > xObj = rContainer.GetEmbeddedObject( mpImpl->aPersistName );
    1710           0 :                 if ( xObj.is() )
    1711             :                 {
    1712           0 :                     OUString aTmp;
    1713           0 :                     mpImpl->mxObjRef.Assign( pDestPers->getEmbeddedObjectContainer().CopyAndGetEmbeddedObject(
    1714           0 :                         rContainer, xObj, aTmp, rSrcShellID, rDestShellID), rOle2Obj.GetAspect());
    1715           0 :                     mpImpl->mbTypeAsked = false;
    1716           0 :                     mpImpl->aPersistName = aTmp;
    1717           0 :                     CheckFileLink_Impl();
    1718             :                 }
    1719             : 
    1720           0 :                 Connect();
    1721             :             }
    1722           0 :         }
    1723             :     }
    1724           0 :     return *this;
    1725             : }
    1726             : 
    1727           0 : SdrOle2Obj& SdrOle2Obj::operator=(const SdrOle2Obj& rObj)
    1728             : {
    1729           0 :     return assignFrom(rObj, OUString(), OUString());
    1730             : }
    1731             : 
    1732         864 : void SdrOle2Obj::ImpSetVisAreaSize()
    1733             : {
    1734             :     // #i118524# do not again set VisAreaSize when the call comes from OLE client (e.g. ObjectAreaChanged)
    1735         864 :     if (mpImpl->mbSuppressSetVisAreaSize)
    1736           0 :         return;
    1737             : 
    1738             :     // currently there is no need to recalculate scaling for iconified objects
    1739             :     // TODO/LATER: it might be needed in future when it is possible to change the icon
    1740         864 :     if ( GetAspect() == embed::Aspects::MSOLE_ICON )
    1741           0 :         return;
    1742             : 
    1743             :     // the object area of an embedded object was changed, e.g. by user interaction an a selected object
    1744         864 :     GetObjRef();
    1745         864 :     if (mpImpl->mxObjRef.is())
    1746             :     {
    1747             :         OSL_ASSERT( pModel );
    1748           0 :         sal_Int64 nMiscStatus = mpImpl->mxObjRef->getStatus( GetAspect() );
    1749             : 
    1750             :         // the client is required to get access to scaling
    1751           0 :         SfxInPlaceClient* pClient = SfxInPlaceClient::GetClient( dynamic_cast<SfxObjectShell*>(pModel->GetPersist()), mpImpl->mxObjRef.GetObject() );
    1752             :         bool bHasOwnClient =
    1753             :                         ( mpImpl->pLightClient
    1754           0 :                         && mpImpl->mxObjRef->getClientSite() == uno::Reference< embed::XEmbeddedClient >( mpImpl->pLightClient ) );
    1755             : 
    1756           0 :         if ( pClient || bHasOwnClient )
    1757             :         {
    1758             :             // TODO: IMHO we need to do similar things when object is UIActive or OutplaceActive?!
    1759           0 :             if ( ((nMiscStatus & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE) &&
    1760           0 :                     svt::EmbeddedObjectRef::TryRunningState( mpImpl->mxObjRef.GetObject() ))
    1761           0 :                     || mpImpl->mxObjRef->getCurrentState() == embed::EmbedStates::INPLACE_ACTIVE
    1762             :                     )
    1763             :             {
    1764           0 :                 Fraction aScaleWidth;
    1765           0 :                 Fraction aScaleHeight;
    1766           0 :                 if ( pClient )
    1767             :                 {
    1768           0 :                     aScaleWidth = pClient->GetScaleWidth();
    1769           0 :                     aScaleHeight = pClient->GetScaleHeight();
    1770             :                 }
    1771             :                 else
    1772             :                 {
    1773           0 :                     aScaleWidth = mpImpl->pLightClient->GetScaleWidth();
    1774           0 :                     aScaleHeight = mpImpl->pLightClient->GetScaleHeight();
    1775             :                 }
    1776             : 
    1777             :                 // The object wants to resize itself (f.e. Chart wants to recalculate the layout)
    1778             :                 // or object is inplace active and so has a window that must be resized also
    1779             :                 // In these cases the change in the object area size will be reflected in a change of the
    1780             :                 // objects' visual area. The scaling will not change, but it might exist already and must
    1781             :                 // be used in calculations
    1782           0 :                 MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpImpl->mxObjRef->getMapUnit( GetAspect() ) );
    1783           0 :                 Size aVisSize( (long)( Fraction( aRect.GetWidth() ) / aScaleWidth ),
    1784           0 :                                 (long)( Fraction( aRect.GetHeight() ) / aScaleHeight ) );
    1785             : 
    1786           0 :                 aVisSize = OutputDevice::LogicToLogic( aVisSize, pModel->GetScaleUnit(), aMapUnit);
    1787           0 :                 awt::Size aSz;
    1788           0 :                 aSz.Width = aVisSize.Width();
    1789           0 :                 aSz.Height = aVisSize.Height();
    1790           0 :                 mpImpl->mxObjRef->setVisualAreaSize( GetAspect(), aSz );
    1791             : 
    1792             :                 try
    1793             :                 {
    1794           0 :                     aSz = mpImpl->mxObjRef->getVisualAreaSize( GetAspect() );
    1795             :                 }
    1796           0 :                 catch( embed::NoVisualAreaSizeException& )
    1797             :                 {}
    1798             : 
    1799           0 :                 Rectangle aAcceptedVisArea;
    1800           0 :                 aAcceptedVisArea.SetSize( Size( (long)( Fraction( long( aSz.Width ) ) * aScaleWidth ),
    1801           0 :                                                 (long)( Fraction( long( aSz.Height ) ) * aScaleHeight ) ) );
    1802           0 :                 if (aVisSize != aAcceptedVisArea.GetSize())
    1803             :                 {
    1804             :                     // server changed VisArea to its liking and the VisArea is different than the suggested one
    1805             :                     // store the new value as given by the object
    1806           0 :                     MapUnit aNewMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpImpl->mxObjRef->getMapUnit( GetAspect() ) );
    1807           0 :                     aRect.SetSize(OutputDevice::LogicToLogic( aAcceptedVisArea.GetSize(), aNewMapUnit, pModel->GetScaleUnit()));
    1808             :                 }
    1809             : 
    1810             :                 // make the new object area known to the client
    1811             :                 // compared to the "else" branch aRect might have been changed by the object and no additional scaling was applied
    1812             :                 // WHY this -> OSL_ASSERT( pClient );
    1813           0 :                 if( pClient )
    1814           0 :                     pClient->SetObjArea(aRect);
    1815             : 
    1816             :                 // we need a new replacement image as the object has resized itself
    1817             : 
    1818             :                 //#i79578# don't request a new replacement image for charts to often
    1819             :                 //a chart sends a modified call to the framework if it was changed
    1820             :                 //thus the replacement update is already handled there
    1821           0 :                 if( !IsChart() )
    1822           0 :                     mpImpl->mxObjRef.UpdateReplacement();
    1823             :             }
    1824             :             else
    1825             :             {
    1826             :                 // The object isn't active and does not want to resize itself so the changed object area size
    1827             :                 // will be reflected in a changed object scaling
    1828           0 :                 Fraction aScaleWidth;
    1829           0 :                 Fraction aScaleHeight;
    1830           0 :                 Size aObjAreaSize;
    1831           0 :                 if ( CalculateNewScaling( aScaleWidth, aScaleHeight, aObjAreaSize ) )
    1832             :                 {
    1833           0 :                     if ( pClient )
    1834             :                     {
    1835           0 :                         Rectangle aScaleRect(aRect.TopLeft(), aObjAreaSize);
    1836           0 :                         pClient->SetObjAreaAndScale( aScaleRect, aScaleWidth, aScaleHeight);
    1837             :                     }
    1838             :                     else
    1839             :                     {
    1840           0 :                         mpImpl->pLightClient->SetSizeScale( aScaleWidth, aScaleHeight );
    1841             :                     }
    1842             :                 }
    1843           0 :             }
    1844             :         }
    1845           0 :         else if( (nMiscStatus & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE) &&
    1846           0 :             svt::EmbeddedObjectRef::TryRunningState( mpImpl->mxObjRef.GetObject() ) )
    1847             :         {
    1848             :             //also handle not sfx based ole objects e.g. charts
    1849             :             //#i83860# resizing charts in impress distorts fonts
    1850           0 :             uno::Reference< embed::XVisualObject > xVisualObject( this->getXModel(), uno::UNO_QUERY );
    1851           0 :             if( xVisualObject.is() )
    1852             :             {
    1853           0 :                 MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( mpImpl->mxObjRef->getMapUnit( GetAspect() ) );
    1854           0 :                 Point aTL( aRect.TopLeft() );
    1855           0 :                 Point aBR( aRect.BottomRight() );
    1856           0 :                 Point aTL2( OutputDevice::LogicToLogic( aTL, pModel->GetScaleUnit(), aMapUnit) );
    1857           0 :                 Point aBR2( OutputDevice::LogicToLogic( aBR, pModel->GetScaleUnit(), aMapUnit) );
    1858           0 :                 Rectangle aNewRect( aTL2, aBR2 );
    1859           0 :                 xVisualObject->setVisualAreaSize( GetAspect(), awt::Size( aNewRect.GetWidth(), aNewRect.GetHeight() ) );
    1860           0 :             }
    1861             :         }
    1862             :     }
    1863             : }
    1864             : 
    1865             : 
    1866             : 
    1867           0 : void SdrOle2Obj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
    1868             : {
    1869           0 :     if( pModel && !pModel->isLocked() )
    1870             :     {
    1871           0 :         GetObjRef();
    1872           0 :         if ( mpImpl->mxObjRef.is() && ( mpImpl->mxObjRef->getStatus( GetAspect() ) & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE ) )
    1873             :         {
    1874             :             // if the object needs recompose on resize
    1875             :             // the client site should be created before the resize will take place
    1876             :             // check whether there is no client site and create it if necessary
    1877           0 :             AddOwnLightClient();
    1878             :         }
    1879             :     }
    1880             : 
    1881           0 :     SdrRectObj::NbcResize(rRef,xFact,yFact);
    1882           0 :     if( pModel && !pModel->isLocked() )
    1883           0 :         ImpSetVisAreaSize();
    1884           0 : }
    1885             : 
    1886             : 
    1887             : 
    1888           0 : void SdrOle2Obj::SetGeoData(const SdrObjGeoData& rGeo)
    1889             : {
    1890           0 :     SdrRectObj::SetGeoData(rGeo);
    1891             : 
    1892           0 :     if( pModel && !pModel->isLocked() )
    1893           0 :         ImpSetVisAreaSize();
    1894           0 : }
    1895             : 
    1896             : 
    1897             : 
    1898         622 : void SdrOle2Obj::NbcSetSnapRect(const Rectangle& rRect)
    1899             : {
    1900         622 :     SdrRectObj::NbcSetSnapRect(rRect);
    1901             : 
    1902         622 :     if( pModel && !pModel->isLocked() )
    1903         414 :         ImpSetVisAreaSize();
    1904             : 
    1905         622 :     if ( mpImpl->mxObjRef.is() && IsChart() )
    1906             :     {
    1907             :         //#i103460# charts do not necessarily have an own size within ODF files,
    1908             :         //for this case they need to use the size settings from the surrounding frame,
    1909             :         //which is made available with this method as there is no other way
    1910          70 :         mpImpl->mxObjRef.SetDefaultSizeForChart( Size( rRect.GetWidth(), rRect.GetHeight() ) );
    1911             :     }
    1912         622 : }
    1913             : 
    1914             : 
    1915             : 
    1916         372 : void SdrOle2Obj::NbcSetLogicRect(const Rectangle& rRect)
    1917             : {
    1918         372 :     SdrRectObj::NbcSetLogicRect(rRect);
    1919             : 
    1920         372 :     if( pModel && !pModel->isLocked() )
    1921         208 :         ImpSetVisAreaSize();
    1922         372 : }
    1923             : 
    1924          30 : const Graphic* SdrOle2Obj::GetGraphic() const
    1925             : {
    1926          30 :     if ( mpImpl->mxObjRef.is() )
    1927          30 :         return mpImpl->mxObjRef.GetGraphic();
    1928           0 :     return mpImpl->mpGraphic;
    1929             : }
    1930             : 
    1931           0 : void SdrOle2Obj::GetNewReplacement()
    1932             : {
    1933           0 :     if ( mpImpl->mxObjRef.is() )
    1934           0 :         mpImpl->mxObjRef.UpdateReplacement();
    1935           0 : }
    1936             : 
    1937             : 
    1938             : 
    1939           0 : Size SdrOle2Obj::GetOrigObjSize( MapMode* pTargetMapMode ) const
    1940             : {
    1941           0 :     return mpImpl->mxObjRef.GetSize( pTargetMapMode );
    1942             : }
    1943             : 
    1944           0 : void SdrOle2Obj::setSuppressSetVisAreaSize( bool bNew )
    1945             : {
    1946           0 :     mpImpl->mbSuppressSetVisAreaSize = bNew;
    1947           0 : }
    1948             : 
    1949         138 : void SdrOle2Obj::NbcMove(const Size& rSize)
    1950             : {
    1951         138 :     SdrRectObj::NbcMove(rSize);
    1952             : 
    1953         138 :     if( pModel && !pModel->isLocked() )
    1954          34 :         ImpSetVisAreaSize();
    1955         138 : }
    1956             : 
    1957             : 
    1958             : 
    1959           0 : bool SdrOle2Obj::CanUnloadRunningObj( const uno::Reference< embed::XEmbeddedObject >& xObj, sal_Int64 nAspect )
    1960             : {
    1961           0 :     uno::Reference<embed::XEmbedPersist2> xPersist(xObj, uno::UNO_QUERY);
    1962           0 :     if (xPersist.is())
    1963             :     {
    1964           0 :         if (!xPersist->isStored())
    1965             :             // It doesn't have persistent storage.  We can't unload this.
    1966           0 :             return false;
    1967             :     }
    1968             : 
    1969           0 :     bool bResult = false;
    1970             : 
    1971           0 :     sal_Int32 nState = xObj->getCurrentState();
    1972           0 :     if ( nState == embed::EmbedStates::LOADED )
    1973             :     {
    1974             :         // the object is already unloaded
    1975           0 :         bResult = true;
    1976             :     }
    1977             :     else
    1978             :     {
    1979           0 :         uno::Reference < util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY );
    1980           0 :         if ( !xModifiable.is() )
    1981           0 :             bResult = true;
    1982             :         else
    1983             :         {
    1984           0 :             sal_Int64 nMiscStatus = xObj->getStatus( nAspect );
    1985             : 
    1986           0 :             if ( embed::EmbedMisc::MS_EMBED_ALWAYSRUN != ( nMiscStatus & embed::EmbedMisc::MS_EMBED_ALWAYSRUN ) &&
    1987           0 :             embed::EmbedMisc::EMBED_ACTIVATEIMMEDIATELY != ( nMiscStatus & embed::EmbedMisc::EMBED_ACTIVATEIMMEDIATELY ) &&
    1988           0 :             !( xModifiable.is() && xModifiable->isModified() ) &&
    1989           0 :             !( nState == embed::EmbedStates::INPLACE_ACTIVE || nState == embed::EmbedStates::UI_ACTIVE || nState == embed::EmbedStates::ACTIVE ) )
    1990             :             {
    1991           0 :                 bResult = true;
    1992             :             }
    1993           0 :         }
    1994             :     }
    1995             : 
    1996           0 :     return bResult;
    1997             : }
    1998             : 
    1999             : 
    2000             : 
    2001           0 : bool SdrOle2Obj::Unload( const uno::Reference< embed::XEmbeddedObject >& xObj, sal_Int64 nAspect )
    2002             : {
    2003           0 :     bool bResult = false;
    2004             : 
    2005           0 :     if ( CanUnloadRunningObj( xObj, nAspect ) )
    2006             :     {
    2007             :         try
    2008             :         {
    2009           0 :             xObj->changeState( embed::EmbedStates::LOADED );
    2010           0 :             bResult = true;
    2011             :         }
    2012           0 :         catch( ::com::sun::star::uno::Exception& )
    2013             :         {
    2014             :             OSL_FAIL(
    2015             :                 OString(OString("SdrOle2Obj::Unload=(), "
    2016             :                         "exception caught: ") +
    2017             :                 OUStringToOString(
    2018             :                     comphelper::anyToString( cppu::getCaughtException() ),
    2019             :                     RTL_TEXTENCODING_UTF8 )).getStr() );
    2020             :         }
    2021             :     }
    2022             : 
    2023           0 :     return bResult;
    2024             : }
    2025             : 
    2026             : 
    2027             : 
    2028           0 : bool SdrOle2Obj::Unload()
    2029             : {
    2030           0 :     if (!mpImpl->mxObjRef.is())
    2031             :         // Already unloaded.
    2032           0 :         return true;
    2033             : 
    2034           0 :     bool bUnloaded = false;
    2035           0 :     if ( pModel && mpImpl->mxObjRef.is() )
    2036             :     {
    2037           0 :         bUnloaded = Unload( mpImpl->mxObjRef.GetObject(), GetAspect() );
    2038             :     }
    2039             : 
    2040           0 :     return bUnloaded;
    2041             : }
    2042             : 
    2043             : 
    2044             : 
    2045        6759 : void SdrOle2Obj::GetObjRef_Impl()
    2046             : {
    2047        6759 :     if ( !mpImpl->mxObjRef.is() && !mpImpl->aPersistName.isEmpty() && pModel && pModel->GetPersist() )
    2048             :     {
    2049             :         // Only try loading if it did not went wrong up to now
    2050           0 :         if(!mpImpl->mbLoadingOLEObjectFailed)
    2051             :         {
    2052           0 :             mpImpl->mxObjRef.Assign( pModel->GetPersist()->getEmbeddedObjectContainer().GetEmbeddedObject( mpImpl->aPersistName ), GetAspect() );
    2053           0 :             mpImpl->mbTypeAsked = false;
    2054           0 :             CheckFileLink_Impl();
    2055             : 
    2056             :             // If loading of OLE object failed, remember that to not invoke a endless
    2057             :             // loop trying to load it again and again.
    2058           0 :             if( mpImpl->mxObjRef.is() )
    2059             :             {
    2060           0 :                 mpImpl->mbLoadingOLEObjectFailed = true;
    2061             :             }
    2062             : 
    2063             :             // For math objects, set closed state to transparent
    2064           0 :             SetClosedObj(!ImplIsMathObj( mpImpl->mxObjRef.GetObject() ));
    2065             :         }
    2066             : 
    2067           0 :         if ( mpImpl->mxObjRef.is() )
    2068             :         {
    2069           0 :             if( !IsEmptyPresObj() )
    2070             :             {
    2071             :                 // remember modified status of model
    2072           0 :                 const bool bWasChanged = pModel && pModel->IsChanged();
    2073             : 
    2074             :                 // perhaps preview not valid anymore
    2075             :                 // This line changes the modified state of the model
    2076           0 :                 SetGraphic_Impl( NULL );
    2077             : 
    2078             :                 // if status was not set before, force it back
    2079             :                 // to not set, so that SetGraphic(0L) above does not
    2080             :                 // set the modified state of the model.
    2081           0 :                 if(!bWasChanged && pModel && pModel->IsChanged())
    2082             :                 {
    2083           0 :                     pModel->SetChanged( false );
    2084             :                 }
    2085             :             }
    2086             : 
    2087           0 :             sal_Int64 nMiscStatus = mpImpl->mxObjRef->getStatus( GetAspect() );
    2088             :             (void)nMiscStatus;
    2089             :             //TODO/LATER: wait until ResizeOnPrinterChange is defined
    2090             :             //if ( nMiscStatus & SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE )
    2091             :             {
    2092           0 :                 if (pModel && pModel->GetRefDevice() &&
    2093           0 :                     pModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER)
    2094             :                 {
    2095           0 :                     if (!mpImpl->mbInDestruction)
    2096             :                     {
    2097             :                         //TODO/LATER: printerchange notification
    2098             :                         /*
    2099             :                         // prevent SetModified (don't want no update here)
    2100             :                         bool bWasEnabled = (*ppObjRef)->IsEnableSetModified();
    2101             :                         if ( bWasEnabled )
    2102             :                             (*ppObjRef)->EnableSetModified( false );
    2103             : 
    2104             :                         // Kein RefDevice oder RefDevice kein Printer
    2105             :                         Printer* pPrinter = (Printer*) pModel->GetRefDevice();
    2106             :                         (*ppObjRef)->OnDocumentPrinterChanged( pPrinter );
    2107             : 
    2108             :                         // reset state
    2109             :                         (*ppObjRef)->EnableSetModified( bWasEnabled );*/
    2110             :                     }
    2111             :                 }
    2112             :             }
    2113             :         }
    2114             : 
    2115           0 :         if ( mpImpl->mxObjRef.is() )
    2116           0 :             Connect();
    2117             :     }
    2118             : 
    2119        6759 :     if ( mpImpl->mbConnected )
    2120             :         // move object to first position in cache
    2121        5729 :         GetSdrGlobalData().GetOLEObjCache().InsertObj(this);
    2122        6759 : }
    2123             : 
    2124        6759 : uno::Reference < embed::XEmbeddedObject > SdrOle2Obj::GetObjRef() const
    2125             : {
    2126        6759 :     const_cast<SdrOle2Obj*>(this)->GetObjRef_Impl();
    2127        6759 :     return mpImpl->mxObjRef.GetObject();
    2128             : }
    2129             : 
    2130           0 : uno::Reference < embed::XEmbeddedObject > SdrOle2Obj::GetObjRef_NoInit() const
    2131             : {
    2132           0 :     return mpImpl->mxObjRef.GetObject();
    2133             : }
    2134             : 
    2135             : 
    2136             : 
    2137        1285 : uno::Reference< frame::XModel > SdrOle2Obj::getXModel() const
    2138             : {
    2139        1285 :     GetObjRef();
    2140        1285 :     if ( svt::EmbeddedObjectRef::TryRunningState(mpImpl->mxObjRef.GetObject()) )
    2141        1285 :         return uno::Reference< frame::XModel >( mpImpl->mxObjRef->getComponent(), uno::UNO_QUERY );
    2142             :     else
    2143           0 :         return uno::Reference< frame::XModel >();
    2144             : }
    2145             : 
    2146             : 
    2147             : 
    2148        1444 : bool SdrOle2Obj::IsChart() const
    2149             : {
    2150        1444 :     if (!mpImpl->mbTypeAsked)
    2151             :     {
    2152         448 :         mpImpl->mbIsChart = mpImpl->mxObjRef.IsChart();
    2153         448 :         mpImpl->mbTypeAsked = true;
    2154             :     }
    2155        1444 :     return mpImpl->mbIsChart;
    2156             : }
    2157             : 
    2158          96 : bool SdrOle2Obj::IsReal3DChart() const
    2159             : {
    2160          96 :     if (!IsChart())
    2161           1 :         return false;
    2162             : 
    2163          95 :     uno::Reference<chart2::XChartDocument> xChart2Document(getXModel(), uno::UNO_QUERY);
    2164         190 :     uno::Reference<chart2::XDiagram> xChart2Diagram(xChart2Document->getFirstDiagram(), uno::UNO_QUERY);
    2165             : 
    2166          95 :     if (!xChart2Diagram.is())
    2167           1 :         return false;
    2168             : 
    2169         189 :     return ChartHelper::isGL3DDiagram(xChart2Diagram);
    2170             : }
    2171             : 
    2172           4 : void SdrOle2Obj::SetGraphicToObj( const Graphic& aGraphic, const OUString& aMediaType )
    2173             : {
    2174           4 :     mpImpl->mxObjRef.SetGraphic( aGraphic, aMediaType );
    2175           4 : }
    2176             : 
    2177             : 
    2178           0 : void SdrOle2Obj::SetGraphicToObj( const uno::Reference< io::XInputStream >& xGrStream, const OUString& aMediaType )
    2179             : {
    2180           0 :     mpImpl->mxObjRef.SetGraphicStream( xGrStream, aMediaType );
    2181           0 : }
    2182             : 
    2183             : 
    2184           0 : bool SdrOle2Obj::IsCalc() const
    2185             : {
    2186           0 :     if ( !mpImpl->mxObjRef.is() )
    2187           0 :         return false;
    2188             : 
    2189           0 :     SvGlobalName aObjClsId( mpImpl->mxObjRef->getClassID() );
    2190           0 :     if(    SvGlobalName(SO3_SC_CLASSID_30) == aObjClsId
    2191           0 :         || SvGlobalName(SO3_SC_CLASSID_40) == aObjClsId
    2192           0 :         || SvGlobalName(SO3_SC_CLASSID_50) == aObjClsId
    2193           0 :         || SvGlobalName(SO3_SC_CLASSID_60) == aObjClsId
    2194           0 :         || SvGlobalName(SO3_SC_OLE_EMBED_CLASSID_60) == aObjClsId
    2195           0 :         || SvGlobalName(SO3_SC_OLE_EMBED_CLASSID_8) == aObjClsId
    2196           0 :         || SvGlobalName(SO3_SC_CLASSID) == aObjClsId )
    2197             :     {
    2198           0 :         return true;
    2199             :     }
    2200             : 
    2201           0 :     return false;
    2202             : }
    2203             : 
    2204         626 : uno::Reference< frame::XModel > SdrOle2Obj::GetParentXModel() const
    2205             : {
    2206         626 :     uno::Reference< frame::XModel > xDoc;
    2207         626 :     if ( pModel )
    2208         626 :         xDoc.set( pModel->getUnoModel(),uno::UNO_QUERY);
    2209         626 :     return xDoc;
    2210             : }
    2211             : 
    2212             : 
    2213         244 : bool SdrOle2Obj::CalculateNewScaling( Fraction& aScaleWidth, Fraction& aScaleHeight, Size& aObjAreaSize )
    2214             : {
    2215             :     // TODO/LEAN: to avoid rounding errors scaling always uses the VisArea.
    2216             :     // If we don't cache it for own objects also we must load the object here
    2217         244 :     if ( !mpImpl->mxObjRef.is() || !pModel )
    2218           0 :         return false;
    2219             : 
    2220         244 :     MapMode aMapMode( pModel->GetScaleUnit() );
    2221         244 :     aObjAreaSize = mpImpl->mxObjRef.GetSize( &aMapMode );
    2222             : 
    2223         244 :     Size aSize = aRect.GetSize();
    2224         244 :     aScaleWidth = Fraction(aSize.Width(),  aObjAreaSize.Width() );
    2225         244 :     aScaleHeight = Fraction(aSize.Height(), aObjAreaSize.Height() );
    2226             : 
    2227             :     // reduce to 10 binary digits
    2228         244 :     Kuerzen(aScaleHeight, 10);
    2229         244 :     Kuerzen(aScaleWidth,  10);
    2230             : 
    2231         244 :     return true;
    2232             : }
    2233             : 
    2234             : 
    2235         438 : bool SdrOle2Obj::AddOwnLightClient()
    2236             : {
    2237             :     // The Own Light Client must be registered in object only using this method!
    2238        1314 :     if ( !SfxInPlaceClient::GetClient( dynamic_cast<SfxObjectShell*>(pModel->GetPersist()), mpImpl->mxObjRef.GetObject() )
    2239        1752 :       && !( mpImpl->pLightClient && mpImpl->mxObjRef->getClientSite() == uno::Reference< embed::XEmbeddedClient >( mpImpl->pLightClient ) ) )
    2240             :     {
    2241         244 :         Connect();
    2242             : 
    2243         244 :         if ( mpImpl->mxObjRef.is() && mpImpl->pLightClient )
    2244             :         {
    2245         244 :             Fraction aScaleWidth;
    2246         244 :             Fraction aScaleHeight;
    2247         244 :             Size aObjAreaSize;
    2248         244 :             if ( CalculateNewScaling( aScaleWidth, aScaleHeight, aObjAreaSize ) )
    2249             :             {
    2250         244 :                 mpImpl->pLightClient->SetSizeScale( aScaleWidth, aScaleHeight );
    2251             :                 try {
    2252         244 :                     mpImpl->mxObjRef->setClientSite( mpImpl->pLightClient );
    2253         244 :                     return true;
    2254           0 :                 } catch( uno::Exception& )
    2255             :                 {}
    2256             :             }
    2257             : 
    2258             :         }
    2259             : 
    2260           0 :         return false;
    2261             :     }
    2262             : 
    2263         194 :     return true;
    2264             : }
    2265             : 
    2266             : 
    2267             : 
    2268           0 : Graphic SdrOle2Obj::GetEmptyOLEReplacementGraphic()
    2269             : {
    2270           0 :     return Graphic(BitmapEx(ResId(BMP_SVXOLEOBJ, *ImpGetResMgr())));
    2271             : }
    2272             : 
    2273             : 
    2274             : 
    2275           0 : void SdrOle2Obj::SetWindow(const com::sun::star::uno::Reference < com::sun::star::awt::XWindow >& _xWindow)
    2276             : {
    2277           0 :     if ( mpImpl->mxObjRef.is() && mpImpl->pLightClient )
    2278             :     {
    2279           0 :         mpImpl->pLightClient->setWindow(_xWindow);
    2280             :     }
    2281         651 : }
    2282             : 
    2283             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10