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