xref: /aoo4110/main/svx/source/svdraw/svdograf.cxx (revision b1cdbd2c)
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 #define _ANIMATION
28 #include <unotools/streamwrap.hxx>
29 
30 #include <sfx2/lnkbase.hxx>
31 #include <math.h>
32 #include <vcl/salbtype.hxx>
33 #include <sot/formats.hxx>
34 #include <sot/storage.hxx>
35 #include <unotools/ucbstreamhelper.hxx>
36 #include <unotools/localfilehelper.hxx>
37 #include <svl/style.hxx>
38 #include <svtools/filter.hxx>
39 #include <svl/urihelper.hxx>
40 #include <svtools/grfmgr.hxx>
41 #include <vcl/svapp.hxx>
42 
43 #include <sfx2/linkmgr.hxx>
44 #include <sfx2/docfile.hxx>
45 #include <svx/svdetc.hxx>
46 #include "svx/svdglob.hxx"
47 #include "svx/svdstr.hrc"
48 #include <svx/svdpool.hxx>
49 #include <svx/svdmodel.hxx>
50 #include <svx/svdpage.hxx>
51 #include <svx/svdmrkv.hxx>
52 #include <svx/svdpagv.hxx>
53 #include "svx/svdviter.hxx"
54 #include <svx/svdview.hxx>
55 #include "svtools/filter.hxx"
56 #include <svx/svdograf.hxx>
57 #include <svx/svdogrp.hxx>
58 #include <svx/xbtmpit.hxx>
59 #include <svx/xflbmtit.hxx>
60 #include <svx/svdundo.hxx>
61 #include "svdfmtf.hxx"
62 #include <svx/sdgcpitm.hxx>
63 #include <editeng/eeitem.hxx>
64 #include <svx/sdr/properties/graphicproperties.hxx>
65 #include <svx/sdr/contact/viewcontactofgraphic.hxx>
66 #include <basegfx/polygon/b2dpolygon.hxx>
67 #include <basegfx/polygon/b2dpolygontools.hxx>
68 #include <osl/thread.hxx>
69 #include <vos/mutex.hxx>
70 #include <drawinglayer/processor2d/objectinfoextractor2d.hxx>
71 #include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
72 #include <unotools/cacheoptions.hxx>
73 #include <basegfx/matrix/b2dhommatrixtools.hxx>
74 
75 using namespace ::com::sun::star::uno;
76 using namespace ::com::sun::star::io;
77 
78 // -----------
79 // - Defines -
80 // -----------
81 
82 #define GRAFSTREAMPOS_INVALID   0xffffffff
83 #define SWAPGRAPHIC_TIMEOUT     5000
84 
85 // #122985# it is not correct to se the swap-timeout to a hard-coded 5000ms as it was before.
86 // Added code and experimented what to do as a good compromize, see description
getCacheTimeInMs()87 sal_uInt32 getCacheTimeInMs()
88 {
89     static bool bSetAtAll(true);
90 
91     if(bSetAtAll)
92     {
93         static bool bSetToPreferenceTime(true);
94 
95         if(bSetToPreferenceTime)
96         {
97             const SvtCacheOptions aCacheOptions;
98             const sal_Int32 nSeconds(aCacheOptions.GetGraphicManagerObjectReleaseTime());
99 
100             // the default is 10 minutes. The minimum is one minute, thus 60 seconds. When the minimum
101             // should match to the former hard-coded 5 seconds, we have a divisor of 12 to use. For the
102             // default of 10 minutes this would mean 50 seconds. Compared to before this is ten times
103             // more (would allow better navigation by switching through pages) and is controllable
104             // by the user by setting the tools/options/memory/Remove_from_memory_after setting. Seems
105             // to be a good compromize to me.
106             return nSeconds * 1000 / 12;
107         }
108         else
109         {
110             return SWAPGRAPHIC_TIMEOUT;
111         }
112     }
113 
114     return 0;
115 }
116 
117 // ------------------
118 // - SdrGraphicLink	-
119 // ------------------
120 
121 
ImpLoadLinkedGraphic(const String aFileName,const String aFilterName)122 const Graphic ImpLoadLinkedGraphic( const String aFileName, const String aFilterName )
123 {
124 	Graphic aGraphic;
125 
126 	SfxMedium xMed( aFileName, STREAM_STD_READ, sal_True );
127 	xMed.DownLoad();
128 
129 	SvStream* pInStrm = xMed.GetInStream();
130 	if ( pInStrm )
131 	{
132 		pInStrm->Seek( STREAM_SEEK_TO_BEGIN );
133 		GraphicFilter* pGF = GraphicFilter::GetGraphicFilter();
134 
135 		const sal_uInt16 nFilter = aFilterName.Len() && pGF->GetImportFormatCount()
136 							? pGF->GetImportFormatNumber( aFilterName )
137 							: GRFILTER_FORMAT_DONTKNOW;
138 
139 		com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue > aFilterData( 1 );
140 
141 		// Room for improvment:
142 		// As this is a linked graphic the GfxLink is not needed if saving/loading our own format.
143 		// But this link is required by some filters to access the native graphic (pdf export/ms export),
144 		// there we should create a new service to provide this data if needed
145 		aFilterData[ 0 ].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "CreateNativeLink" ) );
146 		aFilterData[ 0 ].Value = Any( sal_True );
147 
148         // #123042# for e.g SVG the path is needed, so hand it over here. I have no real idea
149         // what consequences this may have; maybe this is not handed over by purpose here. Not
150         // handing it over means that any GraphicFormat that internallv needs a path as base
151         // to interpret included links may fail.
152         // Alternatively the path may be set at the result after this call when it is known
153         // that it is a SVG graphic, but only because noone yet tried to interpret it.
154         pGF->ImportGraphic( aGraphic, aFileName, *pInStrm, nFilter, NULL, 0, &aFilterData );
155 	}
156 	return aGraphic;
157 }
158 
159 class SdrGraphicUpdater;
160 class SdrGraphicLink : public sfx2::SvBaseLink
161 {
162 	SdrGrafObj*			pGrafObj;
163 	SdrGraphicUpdater*	pGraphicUpdater;
164 
165 public:
166 						SdrGraphicLink(SdrGrafObj* pObj);
167 	virtual				~SdrGraphicLink();
168 
169 	virtual void		Closed();
170 	virtual void		DataChanged( const String& rMimeType,
171 								const ::com::sun::star::uno::Any & rValue );
172 	void				DataChanged( const Graphic& rGraphic );
173 
Connect()174 	sal_Bool				Connect() { return 0 != GetRealObject(); }
175 	void				UpdateAsynchron();
176 	void				RemoveGraphicUpdater();
177 };
178 
179 class SdrGraphicUpdater : public ::osl::Thread
180 {
181 public:
182     SdrGraphicUpdater( const String& rFileName, const String& rFilterName, SdrGraphicLink& );
183     virtual ~SdrGraphicUpdater( void );
184 
185 	void SAL_CALL Terminate( void );
186 
GraphicLinkChanged(const String & rFileName)187     sal_Bool GraphicLinkChanged( const String& rFileName ){ return maFileName != rFileName;	};
188 
189 protected:
190 
191 	/**	is called from the inherited create method and acts as the
192 		main function of this thread.
193 	*/
194 	virtual void SAL_CALL run(void);
195 
196     /**	Called after the thread is terminated via the terminate
197     	method.  Used to kill the thread by calling delete on this.
198     */
199     virtual void SAL_CALL onTerminated(void);
200 
201 private:
202 
203     const String	maFileName;
204 	const String	maFilterName;
205 	SdrGraphicLink& mrGraphicLink;
206 
207 	volatile bool mbIsTerminated;
208 };
209 
SdrGraphicUpdater(const String & rFileName,const String & rFilterName,SdrGraphicLink & rGraphicLink)210 SdrGraphicUpdater::SdrGraphicUpdater( const String& rFileName, const String& rFilterName, SdrGraphicLink& rGraphicLink )
211 : maFileName( rFileName )
212 , maFilterName( rFilterName )
213 , mrGraphicLink( rGraphicLink )
214 , mbIsTerminated( sal_False )
215 {
216 	create();
217 }
218 
~SdrGraphicUpdater(void)219 SdrGraphicUpdater::~SdrGraphicUpdater( void )
220 {
221 }
222 
Terminate()223 void SdrGraphicUpdater::Terminate()
224 {
225     mbIsTerminated = sal_True;
226 }
227 
onTerminated(void)228 void SAL_CALL SdrGraphicUpdater::onTerminated(void)
229 {
230 	delete this;
231 }
232 
run(void)233 void SAL_CALL SdrGraphicUpdater::run(void)
234 {
235 	Graphic aGraphic( ImpLoadLinkedGraphic( maFileName, maFilterName ) );
236 	vos::OGuard aSolarGuard( Application::GetSolarMutex() );
237 	if ( !mbIsTerminated )
238 	{
239 		mrGraphicLink.DataChanged( aGraphic );
240 		mrGraphicLink.RemoveGraphicUpdater();
241 	}
242 }
243 
244 // -----------------------------------------------------------------------------
245 
SdrGraphicLink(SdrGrafObj * pObj)246 SdrGraphicLink::SdrGraphicLink(SdrGrafObj* pObj)
247 : ::sfx2::SvBaseLink( ::sfx2::LINKUPDATE_ONCALL, SOT_FORMATSTR_ID_SVXB )
248 , pGrafObj( pObj )
249 , pGraphicUpdater( NULL )
250 {
251 	SetSynchron( sal_False );
252 }
253 
254 // -----------------------------------------------------------------------------
255 
~SdrGraphicLink()256 SdrGraphicLink::~SdrGraphicLink()
257 {
258 	if ( pGraphicUpdater )
259 		pGraphicUpdater->Terminate();
260 }
261 
262 // -----------------------------------------------------------------------------
263 
DataChanged(const Graphic & rGraphic)264 void SdrGraphicLink::DataChanged( const Graphic& rGraphic )
265 {
266 	pGrafObj->ImpSetLinkedGraphic( rGraphic );
267 }
268 
269 // -----------------------------------------------------------------------------
270 
RemoveGraphicUpdater()271 void SdrGraphicLink::RemoveGraphicUpdater()
272 {
273 	pGraphicUpdater = NULL;
274 }
275 
276 // -----------------------------------------------------------------------------
277 
DataChanged(const String & rMimeType,const::com::sun::star::uno::Any & rValue)278 void SdrGraphicLink::DataChanged( const String& rMimeType,
279 								const ::com::sun::star::uno::Any & rValue )
280 {
281 	SdrModel*       pModel      = pGrafObj ? pGrafObj->GetModel() : 0;
282 	sfx2::LinkManager* pLinkManager= pModel  ? pModel->GetLinkManager() : 0;
283 
284 	if( pLinkManager && rValue.hasValue() )
285 	{
286 		pLinkManager->GetDisplayNames( this, 0, &pGrafObj->aFileName, 0, &pGrafObj->aFilterName );
287 
288 		Graphic aGraphic;
289 		if( sfx2::LinkManager::GetGraphicFromAny( rMimeType, rValue, aGraphic ))
290 		{
291    			pGrafObj->NbcSetGraphic( aGraphic );
292 			pGrafObj->ActionChanged();
293 		}
294 		else if( SotExchange::GetFormatIdFromMimeType( rMimeType ) != sfx2::LinkManager::RegisterStatusInfoId() )
295 		{
296 			// broadcasting, to update slidesorter
297 			pGrafObj->BroadcastObjectChange();
298 		}
299 	}
300 }
301 
302 // -----------------------------------------------------------------------------
303 
Closed()304 void SdrGraphicLink::Closed()
305 {
306 	// Die Verbindung wird aufgehoben; pLink des Objekts auf NULL setzen, da die Link-Instanz ja gerade destruiert wird.
307 	pGrafObj->ForceSwapIn();
308 	pGrafObj->pGraphicLink=NULL;
309 	pGrafObj->ReleaseGraphicLink();
310 	SvBaseLink::Closed();
311 }
312 
313 // -----------------------------------------------------------------------------
314 
UpdateAsynchron()315 void SdrGraphicLink::UpdateAsynchron()
316 {
317 	if( GetObj() )
318 	{
319 		if ( pGraphicUpdater )
320 		{
321 			if ( pGraphicUpdater->GraphicLinkChanged( pGrafObj->GetFileName() ) )
322 			{
323 				pGraphicUpdater->Terminate();
324 				pGraphicUpdater = new SdrGraphicUpdater( pGrafObj->GetFileName(), pGrafObj->GetFilterName(), *this );
325 			}
326 		}
327 		else
328 			pGraphicUpdater = new SdrGraphicUpdater( pGrafObj->GetFileName(), pGrafObj->GetFilterName(), *this );
329 	}
330 }
331 
332 // --------------
333 // - SdrGrafObj -
334 // --------------
335 
336 //////////////////////////////////////////////////////////////////////////////
337 // BaseProperties section
338 
CreateObjectSpecificProperties()339 sdr::properties::BaseProperties* SdrGrafObj::CreateObjectSpecificProperties()
340 {
341 	return new sdr::properties::GraphicProperties(*this);
342 }
343 
344 //////////////////////////////////////////////////////////////////////////////
345 // DrawContact section
346 
CreateObjectSpecificViewContact()347 sdr::contact::ViewContact* SdrGrafObj::CreateObjectSpecificViewContact()
348 {
349 	return new sdr::contact::ViewContactOfGraphic(*this);
350 }
351 
352 //////////////////////////////////////////////////////////////////////////////
353 // check if SVG and if try to get ObjectInfoPrimitive2D and extract info
354 
onGraphicChanged()355 void SdrGrafObj::onGraphicChanged()
356 {
357     String aName;
358     String aTitle;
359     String aDesc;
360 
361     if(pGraphic)
362     {
363         const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
364 
365         if(rSvgDataPtr.get())
366         {
367             const drawinglayer::primitive2d::Primitive2DSequence aSequence(rSvgDataPtr->getPrimitive2DSequence());
368 
369             if(aSequence.hasElements())
370             {
371                 drawinglayer::geometry::ViewInformation2D aViewInformation2D;
372                 drawinglayer::processor2d::ObjectInfoPrimitiveExtractor2D aProcessor(aViewInformation2D);
373 
374                 aProcessor.process(aSequence);
375 
376                 const drawinglayer::primitive2d::ObjectInfoPrimitive2D* pResult = aProcessor.getResult();
377 
378                 if(pResult)
379                 {
380                     aName = pResult->getName();
381 			        aTitle = pResult->getTitle();
382 			        aDesc = pResult->getDesc();
383                 }
384             }
385         }
386     }
387 
388     if(aName.Len())
389     {
390         SetName(aName);
391     }
392 
393     if(aTitle.Len())
394     {
395     	SetTitle(aTitle);
396     }
397 
398     if(aDesc.Len())
399     {
400     	SetDescription(aDesc);
401     }
402 }
403 
404 //////////////////////////////////////////////////////////////////////////////
405 
406 TYPEINIT1(SdrGrafObj,SdrRectObj);
407 
408 // -----------------------------------------------------------------------------
409 
SdrGrafObj()410 SdrGrafObj::SdrGrafObj()
411 :	SdrRectObj(),
412 	pGraphicLink	( NULL ),
413 	bMirrored		( sal_False )
414 {
415 	pGraphic = new GraphicObject;
416     mpReplacementGraphic = 0;
417 	pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() );
418     onGraphicChanged();
419 
420     // #i118485# Shear allowed and possible now
421     bNoShear = false;
422 
423 	// #111096#
424 	mbGrafAnimationAllowed = sal_True;
425 
426 	// #i25616#
427 	mbLineIsOutsideGeometry = sal_True;
428 	mbInsidePaint = sal_False;
429 	mbIsPreview = sal_False;
430 
431 	// #i25616#
432 	mbSupportTextIndentingOnLineWidthChange = sal_False;
433 }
434 
435 // -----------------------------------------------------------------------------
436 
SdrGrafObj(const Graphic & rGrf,const Rectangle & rRect)437 SdrGrafObj::SdrGrafObj(const Graphic& rGrf, const Rectangle& rRect)
438 :	SdrRectObj		( rRect ),
439 	pGraphicLink	( NULL ),
440 	bMirrored		( sal_False )
441 {
442 	pGraphic = new GraphicObject( rGrf );
443     mpReplacementGraphic = 0;
444 	pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() );
445     onGraphicChanged();
446 
447     // #i118485# Shear allowed and possible now
448     bNoShear = false;
449 
450 	// #111096#
451 	mbGrafAnimationAllowed = sal_True;
452 
453 	// #i25616#
454 	mbLineIsOutsideGeometry = sal_True;
455 	mbInsidePaint = sal_False;
456 	mbIsPreview	= sal_False;
457 
458 	// #i25616#
459 	mbSupportTextIndentingOnLineWidthChange = sal_False;
460 }
461 
462 // -----------------------------------------------------------------------------
463 
SdrGrafObj(const Graphic & rGrf)464 SdrGrafObj::SdrGrafObj( const Graphic& rGrf )
465 :	SdrRectObj(),
466 	pGraphicLink	( NULL ),
467 	bMirrored		( sal_False )
468 {
469 	pGraphic = new GraphicObject( rGrf );
470     mpReplacementGraphic = 0;
471 	pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() );
472     onGraphicChanged();
473 
474     // #i118485# Shear allowed and possible now
475     bNoShear = false;
476 
477 	// #111096#
478 	mbGrafAnimationAllowed = sal_True;
479 
480 	// #i25616#
481 	mbLineIsOutsideGeometry = sal_True;
482 	mbInsidePaint = sal_False;
483 	mbIsPreview	= sal_False;
484 
485 	// #i25616#
486 	mbSupportTextIndentingOnLineWidthChange = sal_False;
487 }
488 
489 // -----------------------------------------------------------------------------
490 
~SdrGrafObj()491 SdrGrafObj::~SdrGrafObj()
492 {
493 	delete pGraphic;
494     delete mpReplacementGraphic;
495 	ImpLinkAbmeldung();
496 }
497 
498 // -----------------------------------------------------------------------------
499 
SetGraphicObject(const GraphicObject & rGrfObj)500 void SdrGrafObj::SetGraphicObject( const GraphicObject& rGrfObj )
501 {
502 	*pGraphic = rGrfObj;
503     delete mpReplacementGraphic;
504     mpReplacementGraphic = 0;
505 	pGraphic->SetSwapStreamHdl( LINK( this, SdrGrafObj, ImpSwapHdl ), getCacheTimeInMs() );
506 	pGraphic->SetUserData();
507 	mbIsPreview = sal_False;
508 	SetChanged();
509 	BroadcastObjectChange();
510     onGraphicChanged();
511 }
512 
513 // -----------------------------------------------------------------------------
514 
GetGraphicObject(bool bForceSwapIn) const515 const GraphicObject& SdrGrafObj::GetGraphicObject(bool bForceSwapIn) const
516 {
517 	if(bForceSwapIn)
518 	{
519 		ForceSwapIn();
520 	}
521 
522 	return *pGraphic;
523 }
524 
GetReplacementGraphicObject() const525 const GraphicObject* SdrGrafObj::GetReplacementGraphicObject() const
526 {
527     if(!mpReplacementGraphic && pGraphic)
528     {
529         const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
530 
531         if(rSvgDataPtr.get())
532         {
533             const_cast< SdrGrafObj* >(this)->mpReplacementGraphic = new GraphicObject(rSvgDataPtr->getReplacement());
534         }
535     }
536 
537     return mpReplacementGraphic;
538 }
539 
540 // -----------------------------------------------------------------------------
541 
NbcSetGraphic(const Graphic & rGrf)542 void SdrGrafObj::NbcSetGraphic( const Graphic& rGrf )
543 {
544 	pGraphic->SetGraphic( rGrf );
545     delete mpReplacementGraphic;
546     mpReplacementGraphic = 0;
547 	pGraphic->SetUserData();
548 	mbIsPreview = sal_False;
549     onGraphicChanged();
550 }
551 
SetGraphic(const Graphic & rGrf)552 void SdrGrafObj::SetGraphic( const Graphic& rGrf )
553 {
554     NbcSetGraphic(rGrf);
555 	SetChanged();
556 	BroadcastObjectChange();
557 }
558 
559 // -----------------------------------------------------------------------------
560 
GetGraphic() const561 const Graphic& SdrGrafObj::GetGraphic() const
562 {
563 	ForceSwapIn();
564 	return pGraphic->GetGraphic();
565 }
566 
567 // -----------------------------------------------------------------------------
568 
GetTransformedGraphic(sal_uIntPtr nTransformFlags) const569 Graphic SdrGrafObj::GetTransformedGraphic( sal_uIntPtr nTransformFlags ) const
570 {
571     // #107947# Refactored most of the code to GraphicObject, where
572     // everybody can use e.g. the cropping functionality
573 
574 	GraphicType	    eType = GetGraphicType();
575     MapMode   		aDestMap( pModel->GetScaleUnit(), Point(), pModel->GetScaleFraction(), pModel->GetScaleFraction() );
576     const Size      aDestSize( GetLogicRect().GetSize() );
577     const sal_Bool      bMirror = ( nTransformFlags & SDRGRAFOBJ_TRANSFORMATTR_MIRROR ) != 0;
578     const sal_Bool      bRotate = ( ( nTransformFlags & SDRGRAFOBJ_TRANSFORMATTR_ROTATE ) != 0 ) &&
579         ( aGeo.nDrehWink && aGeo.nDrehWink != 18000 ) && ( GRAPHIC_NONE != eType );
580 
581     // #104115# Need cropping info earlier
582     ( (SdrGrafObj*) this )->ImpSetAttrToGrafInfo();
583     GraphicAttr aActAttr;
584 
585 	if( SDRGRAFOBJ_TRANSFORMATTR_NONE != nTransformFlags &&
586         GRAPHIC_NONE != eType )
587 	{
588         // actually transform the graphic only in this case. On the
589         // other hand, cropping will always happen
590         aActAttr = aGrafInfo;
591 
592         if( bMirror )
593 		{
594 			sal_uInt16		nMirrorCase = ( aGeo.nDrehWink == 18000 ) ? ( bMirrored ? 3 : 4 ) : ( bMirrored ? 2 : 1 );
595 			FASTBOOL	bHMirr = nMirrorCase == 2 || nMirrorCase == 4;
596 			FASTBOOL	bVMirr = nMirrorCase == 3 || nMirrorCase == 4;
597 
598 			aActAttr.SetMirrorFlags( ( bHMirr ? BMP_MIRROR_HORZ : 0 ) | ( bVMirr ? BMP_MIRROR_VERT : 0 ) );
599 		}
600 
601 		if( bRotate )
602 			aActAttr.SetRotation( sal_uInt16(aGeo.nDrehWink / 10) );
603 	}
604 
605     // #107947# Delegate to moved code in GraphicObject
606     return GetGraphicObject().GetTransformedGraphic( aDestSize, aDestMap, aActAttr );
607 }
608 
609 // -----------------------------------------------------------------------------
610 
GetGraphicType() const611 GraphicType SdrGrafObj::GetGraphicType() const
612 {
613 	return pGraphic->GetType();
614 }
615 
IsAnimated() const616 sal_Bool SdrGrafObj::IsAnimated() const
617 {
618 	return pGraphic->IsAnimated();
619 }
620 
IsEPS() const621 sal_Bool SdrGrafObj::IsEPS() const
622 {
623 	return pGraphic->IsEPS();
624 }
625 
IsSwappedOut() const626 sal_Bool SdrGrafObj::IsSwappedOut() const
627 {
628 	return mbIsPreview ? sal_True : pGraphic->IsSwappedOut();
629 }
630 
GetGrafPrefMapMode() const631 const MapMode& SdrGrafObj::GetGrafPrefMapMode() const
632 {
633 	return pGraphic->GetPrefMapMode();
634 }
635 
GetGrafPrefSize() const636 const Size& SdrGrafObj::GetGrafPrefSize() const
637 {
638 	return pGraphic->GetPrefSize();
639 }
640 
641 // -----------------------------------------------------------------------------
642 
SetGrafStreamURL(const String & rGraphicStreamURL)643 void SdrGrafObj::SetGrafStreamURL( const String& rGraphicStreamURL )
644 {
645 	mbIsPreview = sal_False;
646 	if( !rGraphicStreamURL.Len() )
647 	{
648 		pGraphic->SetUserData();
649 	}
650 	else if( pModel->IsSwapGraphics() )
651 	{
652 		pGraphic->SetUserData( rGraphicStreamURL );
653 
654 		// set state of graphic object to 'swapped out'
655 		if( pGraphic->GetType() == GRAPHIC_NONE )
656 			pGraphic->SetSwapState();
657 	}
658 }
659 
660 // -----------------------------------------------------------------------------
661 
GetGrafStreamURL() const662 String SdrGrafObj::GetGrafStreamURL() const
663 {
664 	return pGraphic->GetUserData();
665 }
666 
667 // -----------------------------------------------------------------------------
668 
SetFileName(const String & rFileName)669 void SdrGrafObj::SetFileName(const String& rFileName)
670 {
671 	aFileName = rFileName;
672 	SetChanged();
673 }
674 
675 // -----------------------------------------------------------------------------
676 
SetFilterName(const String & rFilterName)677 void SdrGrafObj::SetFilterName(const String& rFilterName)
678 {
679 	aFilterName = rFilterName;
680 	SetChanged();
681 }
682 
683 // -----------------------------------------------------------------------------
684 
ForceSwapIn() const685 void SdrGrafObj::ForceSwapIn() const
686 {
687 	if( mbIsPreview )
688 	{
689 		// removing preview graphic
690 		const String aUserData( pGraphic->GetUserData() );
691 
692 		Graphic aEmpty;
693 		pGraphic->SetGraphic( aEmpty );
694 		pGraphic->SetUserData( aUserData );
695 		pGraphic->SetSwapState();
696 
697 		const_cast< SdrGrafObj* >( this )->mbIsPreview = sal_False;
698 	}
699 	if ( pGraphicLink && pGraphic->IsSwappedOut() )
700 		ImpUpdateGraphicLink( sal_False );
701 	else
702 		pGraphic->FireSwapInRequest();
703 
704 	if( pGraphic->IsSwappedOut() ||
705 	    ( pGraphic->GetType() == GRAPHIC_NONE ) ||
706 		( pGraphic->GetType() == GRAPHIC_DEFAULT ) )
707 	{
708 		Graphic aDefaultGraphic;
709 		aDefaultGraphic.SetDefaultType();
710 		pGraphic->SetGraphic( aDefaultGraphic );
711 	}
712 }
713 
714 // -----------------------------------------------------------------------------
715 
ForceSwapOut() const716 void SdrGrafObj::ForceSwapOut() const
717 {
718 	pGraphic->FireSwapOutRequest();
719 }
720 
721 // -----------------------------------------------------------------------------
722 
ImpLinkAnmeldung()723 void SdrGrafObj::ImpLinkAnmeldung()
724 {
725 	sfx2::LinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL;
726 
727 	if( pLinkManager != NULL && pGraphicLink == NULL )
728 	{
729 		if( aFileName.Len() )
730 		{
731 			pGraphicLink = new SdrGraphicLink( this );
732 			pLinkManager->InsertFileLink( *pGraphicLink, OBJECT_CLIENT_GRF, aFileName, ( aFilterName.Len() ? &aFilterName : NULL ), NULL );
733 			pGraphicLink->Connect();
734 		}
735 	}
736 }
737 
738 // -----------------------------------------------------------------------------
739 
ImpLinkAbmeldung()740 void SdrGrafObj::ImpLinkAbmeldung()
741 {
742 	sfx2::LinkManager* pLinkManager = pModel != NULL ? pModel->GetLinkManager() : NULL;
743 
744 	if( pLinkManager != NULL && pGraphicLink!=NULL)
745 	{
746 		// Bei Remove wird *pGraphicLink implizit deleted
747 		pLinkManager->Remove( pGraphicLink );
748 		pGraphicLink=NULL;
749 	}
750 }
751 
752 // -----------------------------------------------------------------------------
753 
SetGraphicLink(const String & rFileName,const String & rFilterName)754 void SdrGrafObj::SetGraphicLink( const String& rFileName, const String& rFilterName )
755 {
756 	ImpLinkAbmeldung();
757 	aFileName = rFileName;
758 	aFilterName = rFilterName;
759 	ImpLinkAnmeldung();
760 	pGraphic->SetUserData();
761 
762     // #92205# A linked graphic is per definition swapped out (has to be loaded)
763     pGraphic->SetSwapState();
764 }
765 
766 // -----------------------------------------------------------------------------
767 
ReleaseGraphicLink()768 void SdrGrafObj::ReleaseGraphicLink()
769 {
770 	ImpLinkAbmeldung();
771 	aFileName = String();
772 	aFilterName = String();
773 }
774 
775 // -----------------------------------------------------------------------------
776 
TakeObjInfo(SdrObjTransformInfoRec & rInfo) const777 void SdrGrafObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
778 {
779 	FASTBOOL bNoPresGrf = ( pGraphic->GetType() != GRAPHIC_NONE ) && !bEmptyPresObj;
780 
781 	rInfo.bResizeFreeAllowed = aGeo.nDrehWink % 9000 == 0 ||
782 							   aGeo.nDrehWink % 18000 == 0 ||
783 							   aGeo.nDrehWink % 27000 == 0;
784 
785 	rInfo.bResizePropAllowed = sal_True;
786 	rInfo.bRotateFreeAllowed = bNoPresGrf;
787 	rInfo.bRotate90Allowed = bNoPresGrf;
788 	rInfo.bMirrorFreeAllowed = bNoPresGrf;
789 	rInfo.bMirror45Allowed = bNoPresGrf;
790 	rInfo.bMirror90Allowed = !bEmptyPresObj;
791 	rInfo.bTransparenceAllowed = sal_False;
792 	rInfo.bGradientAllowed = sal_False;
793 
794     // #i118485# Shear allowed and possible now
795 	rInfo.bShearAllowed = true;
796 
797     rInfo.bEdgeRadiusAllowed=sal_False;
798 	rInfo.bCanConvToPath = !IsEPS();
799 	rInfo.bCanConvToPathLineToArea = sal_False;
800 	rInfo.bCanConvToPolyLineToArea = sal_False;
801 	rInfo.bCanConvToPoly = !IsEPS();
802 	rInfo.bCanConvToContour = (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
803 }
804 
805 // -----------------------------------------------------------------------------
806 
GetObjIdentifier() const807 sal_uInt16 SdrGrafObj::GetObjIdentifier() const
808 {
809 	return sal_uInt16( OBJ_GRAF );
810 }
811 
812 // -----------------------------------------------------------------------------
813 
814 /* The graphic of the GraphicLink will be loaded. If it is called with
815    bAsynchron = true then the graphic will be set later via DataChanged
816 */
ImpUpdateGraphicLink(sal_Bool bAsynchron) const817 sal_Bool SdrGrafObj::ImpUpdateGraphicLink( sal_Bool bAsynchron ) const
818 {
819     sal_Bool bRet = sal_False;
820     if( pGraphicLink )
821 	{
822 		if ( bAsynchron )
823 			pGraphicLink->UpdateAsynchron();
824 		else
825 			pGraphicLink->DataChanged( ImpLoadLinkedGraphic( aFileName, aFilterName ) );
826         bRet = sal_True;
827     }
828 	return bRet;
829 }
830 
831 // -----------------------------------------------------------------------------
832 
ImpSetLinkedGraphic(const Graphic & rGraphic)833 void SdrGrafObj::ImpSetLinkedGraphic( const Graphic& rGraphic )
834 {
835 	const sal_Bool bIsChanged = GetModel()->IsChanged();
836 	NbcSetGraphic( rGraphic );
837 	ActionChanged();
838 	BroadcastObjectChange();
839 	GetModel()->SetChanged( bIsChanged );
840 }
841 
842 // -----------------------------------------------------------------------------
843 
TakeObjNameSingul(XubString & rName) const844 void SdrGrafObj::TakeObjNameSingul(XubString& rName) const
845 {
846     if(pGraphic)
847     {
848         const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
849 
850         if(rSvgDataPtr.get())
851         {
852             rName = ImpGetResStr(STR_ObjNameSingulGRAFSVG);
853         }
854         else
855         {
856 	        switch( pGraphic->GetType() )
857 	        {
858 		        case GRAPHIC_BITMAP:
859                 {
860                     const sal_uInt16 nId = ( ( pGraphic->IsTransparent() || ( (const SdrGrafTransparenceItem&) GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ?
861                                          ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPTRANSLNK : STR_ObjNameSingulGRAFBMPTRANS ) :
862                                          ( IsLinkedGraphic() ? STR_ObjNameSingulGRAFBMPLNK : STR_ObjNameSingulGRAFBMP ) );
863 
864                     rName=ImpGetResStr( nId );
865                 }
866                 break;
867 
868 		        case GRAPHIC_GDIMETAFILE:
869                     rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFMTFLNK : STR_ObjNameSingulGRAFMTF );
870                 break;
871 
872                 case GRAPHIC_NONE:
873                     rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNameSingulGRAFNONELNK : STR_ObjNameSingulGRAFNONE );
874                 break;
875 
876                 default:
877                     rName=ImpGetResStr(  IsLinkedGraphic() ? STR_ObjNameSingulGRAFLNK : STR_ObjNameSingulGRAF );
878                 break;
879 	        }
880         }
881 
882 	    const String aName(GetName());
883 
884 	    if( aName.Len() )
885 	    {
886 		    rName.AppendAscii( " '" );
887 		    rName += aName;
888 		    rName += sal_Unicode( '\'' );
889 	    }
890     }
891 }
892 
893 // -----------------------------------------------------------------------------
894 
TakeObjNamePlural(XubString & rName) const895 void SdrGrafObj::TakeObjNamePlural( XubString& rName ) const
896 {
897     if(pGraphic)
898     {
899         const SvgDataPtr& rSvgDataPtr = pGraphic->GetGraphic().getSvgData();
900 
901         if(rSvgDataPtr.get())
902         {
903             rName = ImpGetResStr(STR_ObjNamePluralGRAFSVG);
904         }
905         else
906         {
907 	        switch( pGraphic->GetType() )
908 	        {
909 		        case GRAPHIC_BITMAP:
910                 {
911                     const sal_uInt16 nId = ( ( pGraphic->IsTransparent() || ( (const SdrGrafTransparenceItem&) GetObjectItem( SDRATTR_GRAFTRANSPARENCE ) ).GetValue() ) ?
912                                          ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPTRANSLNK : STR_ObjNamePluralGRAFBMPTRANS ) :
913                                          ( IsLinkedGraphic() ? STR_ObjNamePluralGRAFBMPLNK : STR_ObjNamePluralGRAFBMP ) );
914 
915                     rName=ImpGetResStr( nId );
916                 }
917                 break;
918 
919 		        case GRAPHIC_GDIMETAFILE:
920                     rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFMTFLNK : STR_ObjNamePluralGRAFMTF );
921                 break;
922 
923                 case GRAPHIC_NONE:
924                     rName=ImpGetResStr( IsLinkedGraphic() ? STR_ObjNamePluralGRAFNONELNK : STR_ObjNamePluralGRAFNONE );
925                 break;
926 
927                 default:
928                     rName=ImpGetResStr(  IsLinkedGraphic() ? STR_ObjNamePluralGRAFLNK : STR_ObjNamePluralGRAF );
929                 break;
930 	        }
931         }
932 
933 	    const String aName(GetName());
934 
935 	    if( aName.Len() )
936 	    {
937 		    rName.AppendAscii( " '" );
938 		    rName += aName;
939 		    rName += sal_Unicode( '\'' );
940 	    }
941     }
942 }
943 
944 // -----------------------------------------------------------------------------
945 
getFullDragClone() const946 SdrObject* SdrGrafObj::getFullDragClone() const
947 {
948     // call parent
949     SdrGrafObj* pRetval = static_cast< SdrGrafObj* >(SdrRectObj::getFullDragClone());
950 
951     // #i103116# the full drag clone leads to problems
952     // with linked graphics, so reset the link in this
953     // temporary interaction object and load graphic
954     if(pRetval && IsLinkedGraphic())
955     {
956         pRetval->ForceSwapIn();
957         pRetval->ReleaseGraphicLink();
958     }
959 
960     return pRetval;
961 }
962 
operator =(const SdrObject & rObj)963 void SdrGrafObj::operator=( const SdrObject& rObj )
964 {
965 	SdrRectObj::operator=( rObj );
966 
967 	const SdrGrafObj& rGraf = (SdrGrafObj&) rObj;
968 
969 	pGraphic->SetGraphic( rGraf.GetGraphic(), &rGraf.GetGraphicObject() );
970 	aCropRect = rGraf.aCropRect;
971 	aFileName = rGraf.aFileName;
972 	aFilterName = rGraf.aFilterName;
973 	bMirrored = rGraf.bMirrored;
974 
975 	if( rGraf.pGraphicLink != NULL)
976 	{
977 		SetGraphicLink( aFileName, aFilterName );
978 	}
979 
980 	ImpSetAttrToGrafInfo();
981 }
982 
983 // -----------------------------------------------------------------------------
984 // #i25616#
985 
TakeXorPoly() const986 basegfx::B2DPolyPolygon SdrGrafObj::TakeXorPoly() const
987 {
988 	if(mbInsidePaint)
989 	{
990 		basegfx::B2DPolyPolygon aRetval;
991 
992 		// take grown rectangle
993 		const sal_Int32 nHalfLineWidth(ImpGetLineWdt() / 2);
994 		const Rectangle aGrownRect(
995 			aRect.Left() - nHalfLineWidth,
996 			aRect.Top() - nHalfLineWidth,
997 			aRect.Right() + nHalfLineWidth,
998 			aRect.Bottom() + nHalfLineWidth);
999 
1000 		XPolygon aXPoly(ImpCalcXPoly(aGrownRect, GetEckenradius()));
1001 		aRetval.append(aXPoly.getB2DPolygon());
1002 
1003 		return aRetval;
1004 	}
1005 	else
1006 	{
1007 		// call parent
1008 		return SdrRectObj::TakeXorPoly();
1009 	}
1010 }
1011 
1012 // -----------------------------------------------------------------------------
1013 
GetHdlCount() const1014 sal_uInt32 SdrGrafObj::GetHdlCount() const
1015 {
1016 	return 8L;
1017 }
1018 
1019 // -----------------------------------------------------------------------------
1020 
GetHdl(sal_uInt32 nHdlNum) const1021 SdrHdl* SdrGrafObj::GetHdl(sal_uInt32 nHdlNum) const
1022 {
1023 	return SdrRectObj::GetHdl( nHdlNum + 1L );
1024 }
1025 
1026 // -----------------------------------------------------------------------------
1027 
NbcResize(const Point & rRef,const Fraction & xFact,const Fraction & yFact)1028 void SdrGrafObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
1029 {
1030 	SdrRectObj::NbcResize( rRef, xFact, yFact );
1031 
1032 	FASTBOOL bMirrX = xFact.GetNumerator() < 0;
1033 	FASTBOOL bMirrY = yFact.GetNumerator() < 0;
1034 
1035 	if( bMirrX != bMirrY )
1036 		bMirrored = !bMirrored;
1037 }
1038 
1039 // -----------------------------------------------------------------------------
1040 
NbcRotate(const Point & rRef,long nWink,double sn,double cs)1041 void SdrGrafObj::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
1042 {
1043 	SdrRectObj::NbcRotate(rRef,nWink,sn,cs);
1044 }
1045 
1046 // -----------------------------------------------------------------------------
1047 
NbcMirror(const Point & rRef1,const Point & rRef2)1048 void SdrGrafObj::NbcMirror(const Point& rRef1, const Point& rRef2)
1049 {
1050 	SdrRectObj::NbcMirror(rRef1,rRef2);
1051 	bMirrored = !bMirrored;
1052 }
1053 
1054 // -----------------------------------------------------------------------------
1055 
NbcShear(const Point & rRef,long nWink,double tn,FASTBOOL bVShear)1056 void SdrGrafObj::NbcShear(const Point& rRef, long nWink, double tn, FASTBOOL bVShear)
1057 {
1058     // #i118485# Call Shear now, old version redirected to rotate
1059 	SdrRectObj::NbcShear(rRef, nWink, tn, bVShear);
1060 }
1061 
1062 // -----------------------------------------------------------------------------
1063 
NbcSetSnapRect(const Rectangle & rRect)1064 void SdrGrafObj::NbcSetSnapRect(const Rectangle& rRect)
1065 {
1066 	SdrRectObj::NbcSetSnapRect(rRect);
1067 }
1068 
1069 // -----------------------------------------------------------------------------
1070 
NbcSetLogicRect(const Rectangle & rRect)1071 void SdrGrafObj::NbcSetLogicRect( const Rectangle& rRect)
1072 {
1073 	//int bChg=rRect.GetSize()!=aRect.GetSize();
1074 	SdrRectObj::NbcSetLogicRect(rRect);
1075 }
1076 
1077 // -----------------------------------------------------------------------------
1078 
NewGeoData() const1079 SdrObjGeoData* SdrGrafObj::NewGeoData() const
1080 {
1081 	return new SdrGrafObjGeoData;
1082 }
1083 
1084 // -----------------------------------------------------------------------------
1085 
SaveGeoData(SdrObjGeoData & rGeo) const1086 void SdrGrafObj::SaveGeoData(SdrObjGeoData& rGeo) const
1087 {
1088 	SdrRectObj::SaveGeoData(rGeo);
1089 	SdrGrafObjGeoData& rGGeo=(SdrGrafObjGeoData&)rGeo;
1090 	rGGeo.bMirrored=bMirrored;
1091 }
1092 
1093 // -----------------------------------------------------------------------------
1094 
RestGeoData(const SdrObjGeoData & rGeo)1095 void SdrGrafObj::RestGeoData(const SdrObjGeoData& rGeo)
1096 {
1097 	//long		nDrehMerk = aGeo.nDrehWink;
1098 	//long		nShearMerk = aGeo.nShearWink;
1099 	//int	bMirrMerk = bMirrored;
1100 	Size		aSizMerk( aRect.GetSize() );
1101 
1102 	SdrRectObj::RestGeoData(rGeo);
1103 	SdrGrafObjGeoData& rGGeo=(SdrGrafObjGeoData&)rGeo;
1104 	bMirrored=rGGeo.bMirrored;
1105 }
1106 
1107 // -----------------------------------------------------------------------------
1108 
SetPage(SdrPage * pNewPage)1109 void SdrGrafObj::SetPage( SdrPage* pNewPage )
1110 {
1111 	FASTBOOL bRemove = pNewPage == NULL && pPage != NULL;
1112 	FASTBOOL bInsert = pNewPage != NULL && pPage == NULL;
1113 
1114 	if( bRemove )
1115 	{
1116 		// hier kein SwapIn noetig, weil wenn nicht geladen, dann auch nicht animiert.
1117 		if( pGraphic->IsAnimated())
1118 			pGraphic->StopAnimation();
1119 
1120 		if( pGraphicLink != NULL )
1121 			ImpLinkAbmeldung();
1122 	}
1123 
1124     if(!pModel && !GetStyleSheet() && pNewPage->GetModel())
1125     {
1126         // #119287# Set default StyleSheet for SdrGrafObj here, it is different from 'Default'. This
1127         // needs to be done before the style 'Default' is set from the :SetModel() call which is triggered
1128         // from the following :SetPage().
1129         // TTTT: Needs to be moved in branch aw080 due to having a SdrModel from the beginning, is at this
1130         // place for convenience currently (works in both versions, is not in the way)
1131 		SfxStyleSheet* pSheet = pNewPage->GetModel()->GetDefaultStyleSheetForSdrGrafObjAndSdrOle2Obj();
1132 
1133 		if(pSheet)
1134 		{
1135 			SetStyleSheet(pSheet, false);
1136 		}
1137         else
1138         {
1139 		    SetMergedItem(XFillStyleItem(XFILL_NONE));
1140 		    SetMergedItem(XLineStyleItem(XLINE_NONE));
1141         }
1142     }
1143 
1144 	SdrRectObj::SetPage( pNewPage );
1145 
1146 	if(aFileName.Len() && bInsert)
1147 		ImpLinkAnmeldung();
1148 }
1149 
1150 // -----------------------------------------------------------------------------
1151 
SetModel(SdrModel * pNewModel)1152 void SdrGrafObj::SetModel( SdrModel* pNewModel )
1153 {
1154 	FASTBOOL bChg = pNewModel != pModel;
1155 
1156 	if( bChg )
1157 	{
1158 		if( pGraphic->HasUserData() )
1159 		{
1160 			ForceSwapIn();
1161 			pGraphic->SetUserData();
1162 		}
1163 
1164 		if( pGraphicLink != NULL )
1165 			ImpLinkAbmeldung();
1166 	}
1167 
1168 	// Model umsetzen
1169 	SdrRectObj::SetModel(pNewModel);
1170 
1171 	if( bChg && aFileName.Len() )
1172 		ImpLinkAnmeldung();
1173 }
1174 
1175 // -----------------------------------------------------------------------------
1176 
StartAnimation(OutputDevice *,const Point &,const Size &,long)1177 void SdrGrafObj::StartAnimation( OutputDevice* /*pOutDev*/, const Point& /*rPoint*/, const Size& /*rSize*/, long /*nExtraData*/)
1178 {
1179 	// #111096#
1180 	// use new graf animation
1181 	SetGrafAnimationAllowed(sal_True);
1182 }
1183 
1184 // -----------------------------------------------------------------------------
1185 
StopAnimation(OutputDevice *,long)1186 void SdrGrafObj::StopAnimation(OutputDevice* /*pOutDev*/, long /*nExtraData*/)
1187 {
1188 	// #111096#
1189 	// use new graf animation
1190 	SetGrafAnimationAllowed(sal_False);
1191 }
1192 
1193 // -----------------------------------------------------------------------------
1194 
HasGDIMetaFile() const1195 FASTBOOL SdrGrafObj::HasGDIMetaFile() const
1196 {
1197 	return( pGraphic->GetType() == GRAPHIC_GDIMETAFILE );
1198 }
1199 
1200 // -----------------------------------------------------------------------------
1201 
GetGDIMetaFile() const1202 const GDIMetaFile* SdrGrafObj::GetGDIMetaFile() const
1203 {
1204 	DBG_ERROR( "Invalid return value! Don't use it! (KA)" );
1205 	return &GetGraphic().GetGDIMetaFile();
1206 }
1207 
1208 // -----------------------------------------------------------------------------
1209 
isEmbeddedSvg() const1210 bool SdrGrafObj::isEmbeddedSvg() const
1211 {
1212     return GRAPHIC_BITMAP == GetGraphicType() && GetGraphic().getSvgData().get();
1213 }
1214 
getMetafileFromEmbeddedSvg() const1215 GDIMetaFile SdrGrafObj::getMetafileFromEmbeddedSvg() const
1216 {
1217     GDIMetaFile aRetval;
1218 
1219     if(isEmbeddedSvg() && GetModel())
1220     {
1221         VirtualDevice aOut;
1222         const Rectangle aBoundRect(GetCurrentBoundRect());
1223         const MapMode aMap(GetModel()->GetScaleUnit(), Point(), GetModel()->GetScaleFraction(), GetModel()->GetScaleFraction());
1224 
1225         aOut.EnableOutput(false);
1226         aOut.SetMapMode(aMap);
1227         aRetval.Record(&aOut);
1228         SingleObjectPainter(aOut);
1229         aRetval.Stop();
1230         aRetval.WindStart();
1231         aRetval.Move(-aBoundRect.Left(), -aBoundRect.Top());
1232         aRetval.SetPrefMapMode(aMap);
1233         aRetval.SetPrefSize(aBoundRect.GetSize());
1234     }
1235 
1236     return aRetval;
1237 }
1238 
DoConvertToPolyObj(sal_Bool bBezier,bool bAddText) const1239 SdrObject* SdrGrafObj::DoConvertToPolyObj(sal_Bool bBezier, bool bAddText) const
1240 {
1241 	SdrObject* pRetval = NULL;
1242     GraphicType aGraphicType(GetGraphicType());
1243     GDIMetaFile aMtf;
1244 
1245     if(isEmbeddedSvg())
1246     {
1247         // Embedded Svg
1248         // There is currently no helper to create SdrObjects from primitives (even if I'm thinking
1249         // about writing one for some time). To get the roundtrip to SdrObjects it is necessary to
1250         // use the old converter path over the MetaFile mechanism. Create Metafile from Svg
1251         // primitives here pretty directly
1252         aMtf = getMetafileFromEmbeddedSvg();
1253         aGraphicType = GRAPHIC_GDIMETAFILE;
1254     }
1255     else if(GRAPHIC_GDIMETAFILE == aGraphicType)
1256     {
1257         aMtf = GetTransformedGraphic(SDRGRAFOBJ_TRANSFORMATTR_COLOR|SDRGRAFOBJ_TRANSFORMATTR_MIRROR).GetGDIMetaFile();
1258     }
1259 
1260 	switch(aGraphicType)
1261 	{
1262 		case GRAPHIC_GDIMETAFILE:
1263 		{
1264 			// NUR die aus dem MetaFile erzeugbaren Objekte in eine Gruppe packen und zurueckliefern
1265 			ImpSdrGDIMetaFileImport aFilter(*GetModel(), GetLayer(), aRect);
1266 			SdrObjGroup* pGrp = new SdrObjGroup();
1267 			sal_uInt32 nInsAnz = aFilter.DoImport(aMtf, *pGrp->GetSubList(), 0);
1268 
1269             if(nInsAnz)
1270 			{
1271                 {
1272                         // copy transformation
1273                 	GeoStat aGeoStat(GetGeoStat());
1274 
1275 	                if(aGeoStat.nShearWink)
1276                     {
1277                         aGeoStat.RecalcTan();
1278                         pGrp->NbcShear(aRect.TopLeft(), aGeoStat.nShearWink, aGeoStat.nTan, false);
1279                     }
1280 
1281 	                if(aGeoStat.nDrehWink)
1282                     {
1283 	                    aGeoStat.RecalcSinCos();
1284                         pGrp->NbcRotate(aRect.TopLeft(), aGeoStat.nDrehWink, aGeoStat.nSin, aGeoStat.nCos);
1285                     }
1286                 }
1287 
1288                 pRetval = pGrp;
1289 				pGrp->NbcSetLayer(GetLayer());
1290 				pGrp->SetModel(GetModel());
1291 
1292                 if(bAddText)
1293                 {
1294 				    pRetval = ImpConvertAddText(pRetval, bBezier);
1295                 }
1296 
1297                 // convert all children
1298                 if( pRetval )
1299                 {
1300                     SdrObject* pHalfDone = pRetval;
1301                     pRetval = pHalfDone->DoConvertToPolyObj(bBezier, bAddText);
1302                     SdrObject::Free( pHalfDone ); // resulting object is newly created
1303 
1304                     if( pRetval )
1305                     {
1306                         // flatten subgroups. As we call
1307                         // DoConvertToPolyObj() on the resulting group
1308                         // objects, subgroups can exist (e.g. text is
1309                         // a group object for every line).
1310                         SdrObjList* pList = pRetval->GetSubList();
1311                         if( pList )
1312                             pList->FlattenGroups();
1313                     }
1314                 }
1315 			}
1316 			else
1317             {
1318 				delete pGrp;
1319             }
1320 
1321             // #i118485# convert line and fill
1322             SdrObject* pLineFill = SdrRectObj::DoConvertToPolyObj(bBezier, false);
1323 
1324             if(pLineFill)
1325             {
1326                 if(pRetval)
1327                 {
1328                     pGrp = dynamic_cast< SdrObjGroup* >(pRetval);
1329 
1330                     if(!pGrp)
1331                     {
1332             			pGrp = new SdrObjGroup();
1333 
1334                         pGrp->NbcSetLayer(GetLayer());
1335 				        pGrp->SetModel(GetModel());
1336                         pGrp->GetSubList()->NbcInsertObject(pRetval);
1337                     }
1338 
1339                     pGrp->GetSubList()->NbcInsertObject(pLineFill, 0);
1340                 }
1341                 else
1342                 {
1343                     pRetval = pLineFill;
1344                 }
1345             }
1346 
1347 			break;
1348 		}
1349 		case GRAPHIC_BITMAP:
1350 		{
1351 			// Grundobjekt kreieren und Fuellung ergaenzen
1352 			pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
1353 
1354 			// Bitmap als Attribut retten
1355 			if(pRetval)
1356 			{
1357 				// Bitmap als Fuellung holen
1358 				SfxItemSet aSet(GetObjectItemSet());
1359 
1360 				aSet.Put(XFillStyleItem(XFILL_BITMAP));
1361 				const BitmapEx aBitmapEx(GetTransformedGraphic().GetBitmapEx());
1362 				aSet.Put(XFillBitmapItem(String(), Graphic(aBitmapEx)));
1363 				aSet.Put(XFillBmpTileItem(false));
1364 
1365 				pRetval->SetMergedItemSet(aSet);
1366 			}
1367 			break;
1368 		}
1369 		case GRAPHIC_NONE:
1370 		case GRAPHIC_DEFAULT:
1371 		{
1372 			pRetval = SdrRectObj::DoConvertToPolyObj(bBezier, bAddText);
1373 			break;
1374 		}
1375 	}
1376 
1377 	return pRetval;
1378 }
1379 
1380 // -----------------------------------------------------------------------------
1381 
Notify(SfxBroadcaster & rBC,const SfxHint & rHint)1382 void SdrGrafObj::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1383 {
1384 	SetXPolyDirty();
1385 	SdrRectObj::Notify( rBC, rHint );
1386 	ImpSetAttrToGrafInfo();
1387 }
1388 
ImpSetAttrToGrafInfo()1389 void SdrGrafObj::ImpSetAttrToGrafInfo()
1390 {
1391 	const SfxItemSet& rSet = GetObjectItemSet();
1392 	const sal_uInt16 nTrans = ( (SdrGrafTransparenceItem&) rSet.Get( SDRATTR_GRAFTRANSPARENCE ) ).GetValue();
1393 	const SdrGrafCropItem&	rCrop = (const SdrGrafCropItem&) rSet.Get( SDRATTR_GRAFCROP );
1394 
1395 	aGrafInfo.SetLuminance( ( (SdrGrafLuminanceItem&) rSet.Get( SDRATTR_GRAFLUMINANCE ) ).GetValue() );
1396 	aGrafInfo.SetContrast( ( (SdrGrafContrastItem&) rSet.Get( SDRATTR_GRAFCONTRAST ) ).GetValue() );
1397 	aGrafInfo.SetChannelR( ( (SdrGrafRedItem&) rSet.Get( SDRATTR_GRAFRED ) ).GetValue() );
1398 	aGrafInfo.SetChannelG( ( (SdrGrafGreenItem&) rSet.Get( SDRATTR_GRAFGREEN ) ).GetValue() );
1399 	aGrafInfo.SetChannelB( ( (SdrGrafBlueItem&) rSet.Get( SDRATTR_GRAFBLUE ) ).GetValue() );
1400 	aGrafInfo.SetGamma( ( (SdrGrafGamma100Item&) rSet.Get( SDRATTR_GRAFGAMMA ) ).GetValue() * 0.01 );
1401 	aGrafInfo.SetTransparency( (sal_uInt8) FRound( Min( nTrans, (sal_uInt16) 100 )  * 2.55 ) );
1402 	aGrafInfo.SetInvert( ( (SdrGrafInvertItem&) rSet.Get( SDRATTR_GRAFINVERT ) ).GetValue() );
1403 	aGrafInfo.SetDrawMode( ( (SdrGrafModeItem&) rSet.Get( SDRATTR_GRAFMODE ) ).GetValue() );
1404 	aGrafInfo.SetCrop( rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom() );
1405 
1406 	SetXPolyDirty();
1407 	SetRectsDirty();
1408 }
1409 
1410 // -----------------------------------------------------------------------------
1411 
ImpSetGrafInfoToAttr()1412 void SdrGrafObj::ImpSetGrafInfoToAttr()
1413 {
1414 	SetObjectItem( SdrGrafLuminanceItem( aGrafInfo.GetLuminance() ) );
1415 	SetObjectItem( SdrGrafContrastItem( aGrafInfo.GetContrast() ) );
1416 	SetObjectItem( SdrGrafRedItem( aGrafInfo.GetChannelR() ) );
1417 	SetObjectItem( SdrGrafGreenItem( aGrafInfo.GetChannelG() ) );
1418 	SetObjectItem( SdrGrafBlueItem( aGrafInfo.GetChannelB() ) );
1419 	SetObjectItem( SdrGrafGamma100Item( FRound( aGrafInfo.GetGamma() * 100.0 ) ) );
1420 	SetObjectItem( SdrGrafTransparenceItem( (sal_uInt16) FRound( aGrafInfo.GetTransparency() / 2.55 ) ) );
1421 	SetObjectItem( SdrGrafInvertItem( aGrafInfo.IsInvert() ) );
1422 	SetObjectItem( SdrGrafModeItem( aGrafInfo.GetDrawMode() ) );
1423 	SetObjectItem( SdrGrafCropItem( aGrafInfo.GetLeftCrop(), aGrafInfo.GetTopCrop(), aGrafInfo.GetRightCrop(), aGrafInfo.GetBottomCrop() ) );
1424 }
1425 
1426 // -----------------------------------------------------------------------------
1427 
AdjustToMaxRect(const Rectangle & rMaxRect,bool bShrinkOnly)1428 void SdrGrafObj::AdjustToMaxRect( const Rectangle& rMaxRect, bool bShrinkOnly )
1429 {
1430 	Size aSize;
1431 	Size aMaxSize( rMaxRect.GetSize() );
1432 	if ( pGraphic->GetPrefMapMode().GetMapUnit() == MAP_PIXEL )
1433 		aSize = Application::GetDefaultDevice()->PixelToLogic( pGraphic->GetPrefSize(), MAP_100TH_MM );
1434 	else
1435 		aSize = OutputDevice::LogicToLogic( pGraphic->GetPrefSize(),
1436 										    pGraphic->GetPrefMapMode(),
1437 										    MapMode( MAP_100TH_MM ) );
1438 
1439 	if( aSize.Height() != 0 && aSize.Width() != 0 )
1440 	{
1441 		Point aPos( rMaxRect.TopLeft() );
1442 
1443 		// Falls Grafik zu gross, wird die Grafik
1444 		// in die Seite eingepasst
1445 		if ( (!bShrinkOnly                          ||
1446 	    	 ( aSize.Height() > aMaxSize.Height() ) ||
1447 		 	( aSize.Width()  > aMaxSize.Width()  ) )&&
1448 		 	aSize.Height() && aMaxSize.Height() )
1449 		{
1450 			float fGrfWH =	(float)aSize.Width() /
1451 							(float)aSize.Height();
1452 			float fWinWH =	(float)aMaxSize.Width() /
1453 							(float)aMaxSize.Height();
1454 
1455 			// Grafik an Pagesize anpassen (skaliert)
1456 			if ( fGrfWH < fWinWH )
1457 			{
1458 				aSize.Width() = (long)(aMaxSize.Height() * fGrfWH);
1459 				aSize.Height()= aMaxSize.Height();
1460 			}
1461 			else if ( fGrfWH > 0.F )
1462 			{
1463 				aSize.Width() = aMaxSize.Width();
1464 				aSize.Height()= (long)(aMaxSize.Width() / fGrfWH);
1465 			}
1466 
1467 			aPos = rMaxRect.Center();
1468 		}
1469 
1470 		if( bShrinkOnly )
1471 			aPos = aRect.TopLeft();
1472 
1473 		aPos.X() -= aSize.Width() / 2;
1474 		aPos.Y() -= aSize.Height() / 2;
1475 		SetLogicRect( Rectangle( aPos, aSize ) );
1476 	}
1477 }
1478 
1479 // -----------------------------------------------------------------------------
1480 
IMPL_LINK(SdrGrafObj,ImpSwapHdl,GraphicObject *,pO)1481 IMPL_LINK( SdrGrafObj, ImpSwapHdl, GraphicObject*, pO )
1482 {
1483 	SvStream* pRet = GRFMGR_AUTOSWAPSTREAM_NONE;
1484 
1485 	if( pO->IsInSwapOut() )
1486 	{
1487 		if( pModel && !mbIsPreview && pModel->IsSwapGraphics() && pGraphic->GetSizeBytes() > 20480 )
1488 		{
1489 			// test if this object is visualized from someone
1490             // ## test only if there are VOCs other than the preview renderer
1491 			if(!GetViewContact().HasViewObjectContacts(true))
1492 			{
1493 				const sal_uIntPtr	nSwapMode = pModel->GetSwapGraphicsMode();
1494 
1495 				if( ( pGraphic->HasUserData() || pGraphicLink ) &&
1496 					( nSwapMode & SDR_SWAPGRAPHICSMODE_PURGE ) )
1497 				{
1498 					pRet = GRFMGR_AUTOSWAPSTREAM_LINK;
1499 				}
1500 				else if( nSwapMode & SDR_SWAPGRAPHICSMODE_TEMP )
1501 				{
1502 					pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1503 					pGraphic->SetUserData();
1504 				}
1505 
1506 				// #i102380#
1507 				sdr::contact::ViewContactOfGraphic* pVC = dynamic_cast< sdr::contact::ViewContactOfGraphic* >(&GetViewContact());
1508 
1509 				if(pVC)
1510 				{
1511 					pVC->flushGraphicObjects();
1512 				}
1513 			}
1514 		}
1515 	}
1516 	else if( pO->IsInSwapIn() )
1517 	{
1518 		// kann aus dem original Doc-Stream nachgeladen werden...
1519 		if( pModel != NULL )
1520 		{
1521 			if( pGraphic->HasUserData() )
1522 			{
1523 				SdrDocumentStreamInfo aStreamInfo;
1524 
1525 				aStreamInfo.mbDeleteAfterUse = sal_False;
1526 				aStreamInfo.maUserData = pGraphic->GetUserData();
1527 
1528 				SvStream* pStream = pModel->GetDocumentStream( aStreamInfo );
1529 
1530 				if( pStream != NULL )
1531 				{
1532 					Graphic aGraphic;
1533 
1534                     com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >* pFilterData = NULL;
1535 
1536 					if(mbInsidePaint && !GetViewContact().HasViewObjectContacts(true))
1537                     {
1538                         pFilterData = new com::sun::star::uno::Sequence< com::sun::star::beans::PropertyValue >( 3 );
1539 
1540                         const com::sun::star::awt::Size aPreviewSizeHint( 64, 64 );
1541                         const sal_Bool bAllowPartialStreamRead = sal_True;
1542                         // create <GfxLink> instance also for previews in order to avoid that its corresponding
1543                         // data is cleared in the graphic cache entry in case that the preview data equals the complete graphic data
1544                         const sal_Bool bCreateNativeLink = sal_True;
1545                         (*pFilterData)[ 0 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "PreviewSizeHint" ) );
1546                         (*pFilterData)[ 0 ].Value <<= aPreviewSizeHint;
1547                         (*pFilterData)[ 1 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "AllowPartialStreamRead" ) );
1548                         (*pFilterData)[ 1 ].Value <<= bAllowPartialStreamRead;
1549                         (*pFilterData)[ 2 ].Name = String( RTL_CONSTASCII_USTRINGPARAM( "CreateNativeLink" ) );
1550                         (*pFilterData)[ 2 ].Value <<= bCreateNativeLink;
1551 
1552                         mbIsPreview = sal_True;
1553                     }
1554 
1555                     if(!GraphicFilter::GetGraphicFilter()->ImportGraphic(
1556                         aGraphic, aStreamInfo.maUserData, *pStream,
1557                         GRFILTER_FORMAT_DONTKNOW, NULL, 0, pFilterData))
1558                     {
1559                         const String aUserData( pGraphic->GetUserData() );
1560 
1561                         pGraphic->SetGraphic( aGraphic );
1562                         pGraphic->SetUserData( aUserData );
1563 
1564                         // #142146# Graphic successfully swapped in.
1565                         pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
1566                     }
1567                     delete pFilterData;
1568 
1569                     pStream->ResetError();
1570 
1571                     if( aStreamInfo.mbDeleteAfterUse || aStreamInfo.mxStorageRef.is() )
1572                     {
1573                         if ( aStreamInfo.mxStorageRef.is() )
1574                         {
1575                             aStreamInfo.mxStorageRef->dispose();
1576                             aStreamInfo.mxStorageRef = 0;
1577                         }
1578 
1579                         delete pStream;
1580                     }
1581                 }
1582 			}
1583 			else if( !ImpUpdateGraphicLink( sal_False ) )
1584             {
1585 				pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1586             }
1587 			else
1588             {
1589                 pRet = GRFMGR_AUTOSWAPSTREAM_LOADED;
1590             }
1591 		}
1592 		else
1593 			pRet = GRFMGR_AUTOSWAPSTREAM_TEMP;
1594 	}
1595 
1596 	return (long)(void*) pRet;
1597 }
1598 
1599 // -----------------------------------------------------------------------------
1600 
1601 // #111096#
1602 // Access to GrafAnimationAllowed flag
IsGrafAnimationAllowed() const1603 sal_Bool SdrGrafObj::IsGrafAnimationAllowed() const
1604 {
1605 	return mbGrafAnimationAllowed;
1606 }
1607 
SetGrafAnimationAllowed(sal_Bool bNew)1608 void SdrGrafObj::SetGrafAnimationAllowed(sal_Bool bNew)
1609 {
1610 	if(mbGrafAnimationAllowed != bNew)
1611 	{
1612 		mbGrafAnimationAllowed = bNew;
1613 		ActionChanged();
1614 	}
1615 }
1616 
1617 // #i25616#
IsObjectTransparent() const1618 sal_Bool SdrGrafObj::IsObjectTransparent() const
1619 {
1620 	if(((const SdrGrafTransparenceItem&)GetObjectItem(SDRATTR_GRAFTRANSPARENCE)).GetValue()
1621 		|| pGraphic->IsTransparent())
1622 	{
1623 		return sal_True;
1624 	}
1625 
1626 	return sal_False;
1627 }
1628 
getInputStream()1629 Reference< XInputStream > SdrGrafObj::getInputStream()
1630 {
1631 	Reference< XInputStream > xStream;
1632 
1633 	if( pModel )
1634 	{
1635 //		if( !pGraphic->HasUserData() )
1636 //			pGraphic->SwapOut();
1637 
1638 		// kann aus dem original Doc-Stream nachgeladen werden...
1639 		if( pGraphic->HasUserData() )
1640 		{
1641 			SdrDocumentStreamInfo aStreamInfo;
1642 
1643 			aStreamInfo.mbDeleteAfterUse = sal_False;
1644 			aStreamInfo.maUserData = pGraphic->GetUserData();
1645 
1646 			SvStream* pStream = pModel->GetDocumentStream( aStreamInfo );
1647 
1648 			if( pStream )
1649 				xStream.set( new utl::OInputStreamWrapper( pStream, sal_True ) );
1650 		}
1651 		else if( pGraphic && GetGraphic().IsLink() )
1652 		{
1653 			Graphic aGraphic( GetGraphic() );
1654 			GfxLink aLink( aGraphic.GetLink() );
1655 			sal_uInt32 nSize = aLink.GetDataSize();
1656 			const void* pSourceData = (const void*)aLink.GetData();
1657 			if( nSize && pSourceData )
1658 			{
1659 				sal_uInt8 * pBuffer = new sal_uInt8[ nSize ];
1660 				if( pBuffer )
1661 				{
1662 					memcpy( pBuffer, pSourceData, nSize );
1663 
1664 					SvMemoryStream* pStream = new SvMemoryStream( (void*)pBuffer, (sal_Size)nSize, STREAM_READ );
1665 					pStream->ObjectOwnsMemory( sal_True );
1666 					xStream.set( new utl::OInputStreamWrapper( pStream, sal_True ) );
1667 				}
1668 			}
1669 		}
1670 
1671 		if( !xStream.is() && aFileName.Len() )
1672 		{
1673 			SvFileStream* pStream = new SvFileStream( aFileName, STREAM_READ );
1674 			if( pStream )
1675 				xStream.set( new utl::OInputStreamWrapper( pStream ) );
1676 		}
1677 	}
1678 
1679 	return xStream;
1680 }
1681 
1682 // moved crop handle creation here; this is the object type using them
addCropHandles(SdrHdlList & rTarget) const1683 void SdrGrafObj::addCropHandles(SdrHdlList& rTarget) const
1684 {
1685     basegfx::B2DHomMatrix aMatrix;
1686     basegfx::B2DPolyPolygon aPolyPolygon;
1687 
1688     // get object transformation
1689     TRGetBaseGeometry(aMatrix, aPolyPolygon);
1690 
1691     // part of object transformation correction, but used later, so defined outside next scope
1692     double fShearX(0.0), fRotate(0.0);
1693 
1694     {   // TTTT correct shear, it comes currently mirrored from TRGetBaseGeometry, can be removed with aw080
1695         basegfx::B2DTuple aScale;
1696         basegfx::B2DTuple aTranslate;
1697 
1698         aMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
1699 
1700         if(!basegfx::fTools::equalZero(fShearX))
1701         {
1702             // shearX is used, correct it
1703             fShearX = -fShearX;
1704         }
1705 
1706         aMatrix = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
1707             aScale,
1708             fShearX,
1709             fRotate,
1710             aTranslate);
1711     }
1712 
1713     // get crop values
1714     const SdrGrafCropItem& rCrop = static_cast< const SdrGrafCropItem& >(GetMergedItem(SDRATTR_GRAFCROP));
1715 
1716     if(rCrop.GetLeft() || rCrop.GetTop() || rCrop.GetRight() ||rCrop.GetBottom())
1717     {
1718         // decompose object transformation to have current translate and scale
1719         basegfx::B2DVector aScale, aTranslate;
1720         double fRotate, fShearX;
1721 
1722         aMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
1723 
1724         if(!aScale.equalZero())
1725         {
1726             // get crop scale
1727             const basegfx::B2DVector aCropScaleFactor(
1728                 GetGraphicObject().calculateCropScaling(
1729                     aScale.getX(),
1730                     aScale.getY(),
1731                     rCrop.GetLeft(),
1732                     rCrop.GetTop(),
1733                     rCrop.GetRight(),
1734                     rCrop.GetBottom()));
1735 
1736             // apply crop scale
1737             const double fCropLeft(rCrop.GetLeft() * aCropScaleFactor.getX());
1738             const double fCropTop(rCrop.GetTop() * aCropScaleFactor.getY());
1739             const double fCropRight(rCrop.GetRight() * aCropScaleFactor.getX());
1740             const double fCropBottom(rCrop.GetBottom() * aCropScaleFactor.getY());
1741             basegfx::B2DHomMatrix aMatrixForCropViewHdl(aMatrix);
1742 
1743             if(IsMirrored())
1744             {
1745                 // create corrected new matrix, TTTT can be removed with aw080
1746                 // the old mirror only can mirror horizontally; the vertical mirror
1747                 // is faked by using the horizontal and 180 degree rotation. Since
1748                 // the object can be rotated differently from 180 degree, this is
1749                 // not safe to detect. Just correct horizontal mirror (which is
1750                 // in IsMirrored()) and keep the rotation angle
1751                 // caution: Do not modify aMatrix, it is used below to calculate
1752                 // the exact handle positions
1753                 basegfx::B2DHomMatrix aPreMultiply;
1754 
1755                 // mirrored X, apply
1756                 aPreMultiply.translate(-0.5, 0.0);
1757                 aPreMultiply.scale(-1.0, 1.0);
1758                 aPreMultiply.translate(0.5, 0.0);
1759 
1760                 aMatrixForCropViewHdl = aMatrixForCropViewHdl * aPreMultiply;
1761             }
1762 
1763             rTarget.AddHdl(
1764                 new SdrCropViewHdl(
1765                     aMatrixForCropViewHdl,
1766                     GetGraphicObject().GetGraphic(),
1767                     fCropLeft,
1768                     fCropTop,
1769                     fCropRight,
1770                     fCropBottom));
1771         }
1772     }
1773 
1774     basegfx::B2DPoint aPos;
1775 
1776     aPos = aMatrix * basegfx::B2DPoint(0.0, 0.0);
1777     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPLFT, fShearX, fRotate));
1778     aPos = aMatrix * basegfx::B2DPoint(0.5, 0.0);
1779     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPPER, fShearX, fRotate));
1780     aPos = aMatrix * basegfx::B2DPoint(1.0, 0.0);
1781     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_UPRGT, fShearX, fRotate));
1782     aPos = aMatrix * basegfx::B2DPoint(0.0, 0.5);
1783     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LEFT , fShearX, fRotate));
1784     aPos = aMatrix * basegfx::B2DPoint(1.0, 0.5);
1785     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_RIGHT, fShearX, fRotate));
1786     aPos = aMatrix * basegfx::B2DPoint(0.0, 1.0);
1787     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LWLFT, fShearX, fRotate));
1788     aPos = aMatrix * basegfx::B2DPoint(0.5, 1.0);
1789     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LOWER, fShearX, fRotate));
1790     aPos = aMatrix * basegfx::B2DPoint(1.0, 1.0);
1791     rTarget.AddHdl(new SdrCropHdl(Point(basegfx::fround(aPos.getX()), basegfx::fround(aPos.getY())), HDL_LWRGT, fShearX, fRotate));
1792 }
1793 
1794 // eof
1795