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 _SVX_USE_UNOGLOBALS_
28 #include <cppuhelper/typeprovider.hxx>
29 #include <com/sun/star/awt/XBitmap.hpp>
30 #include <com/sun/star/awt/Rectangle.hpp>
31 #include <com/sun/star/drawing/CircleKind.hpp>
32 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
33 #include <vcl/svapp.hxx>
34 #include <svl/itemprop.hxx>
35 #include <svtools/fltcall.hxx>
36 #include <vos/mutex.hxx>
37 #include <editeng/unotext.hxx>
38 #include <svx/svdobj.hxx>
39 #include <svx/svdoole2.hxx>
40 #include <osl/mutex.hxx>
41 #include <comphelper/extract.hxx>
42 #include "svx/shapepropertynotifier.hxx"
43 #include <comphelper/serviceinfohelper.hxx>
44 #include <toolkit/unohlp.hxx>
45 #include <comphelper/serviceinfohelper.hxx>
46 #include <rtl/uuid.h>
47 #include <rtl/memory.h>
48 #include <vcl/gfxlink.hxx>
49 #include <vcl/virdev.hxx>
50 #include <sfx2/objsh.hxx>
51 #include <sfx2/viewsh.hxx>
52 #include "svx/svdopage.hxx"
53 #include "svx/xflbstit.hxx"
54 #include "svx/xflbmtit.hxx"
55 #include "svx/xlnstit.hxx"
56 #include "svx/xlnedit.hxx"
57 #include "svx/svdogrp.hxx"
58 #include "svx/scene3d.hxx"
59 #include "svx/svdmodel.hxx"
60 #include "svx/globl3d.hxx"
61 #include "svx/fmglob.hxx"
62 #include "svx/unopage.hxx"
63 #include "svx/view3d.hxx"
64 #include "svx/unoshape.hxx"
65 #include "svx/svxids.hrc"
66 #include "svx/unoshtxt.hxx"
67 #include "svx/svdpage.hxx"
68 #include "svx/unoshprp.hxx"
69 #include "svx/sxciaitm.hxx" // todo: remove
70 #include "svx/svdograf.hxx"
71 #include "svx/unoapi.hxx"
72 #include "svx/svdomeas.hxx"
73 #include "svx/svdpagv.hxx"
74 #include "svx/svdpool.hxx"
75 #include <tools/shl.hxx> //
76 #include "svx/dialmgr.hxx" // not nice, we need our own resources some day
77 #include "svx/dialogs.hrc" //
78 #include "svx/svdocapt.hxx"
79 #include <svx/obj3d.hxx>
80 #include <tools/diagnose_ex.h>
81 #include "svx/xflftrit.hxx"
82 #include "svx/xtable.hxx"
83 #include "svx/xbtmpit.hxx"
84 #include "svx/xflgrit.hxx"
85 #include "svx/xflhtit.hxx"
86 #include "svx/xlnedit.hxx"
87 #include "svx/xlnstit.hxx"
88 #include "svx/xlndsit.hxx"
89 #include "svx/svdglob.hxx"
90 #include "svx/svdstr.hrc"
91 #include "svx/unomaster.hxx"
92 #include <editeng/outlobj.hxx>
93 #include <basegfx/matrix/b2dhommatrix.hxx>
94 #include <basegfx/matrix/b2dhommatrixtools.hxx>
95 #include <basegfx/polygon/b2dpolypolygontools.hxx>
96
97 #include <vector>
98
99 // #i68523#
100 #include "svx/lathe3d.hxx"
101 #include "svx/extrud3d.hxx"
102 #include "unopolyhelper.hxx"
103
104 #include <comphelper/scopeguard.hxx>
105 #include <boost/bind.hpp>
106
107 using ::rtl::OUString;
108 using namespace ::osl;
109 using namespace ::vos;
110 using namespace ::cppu;
111 using namespace ::com::sun::star;
112 using namespace ::com::sun::star::uno;
113 using namespace ::com::sun::star::lang;
114 using namespace ::com::sun::star::container;
115 using ::svx::PropertyValueProvider;
116 using ::svx::IPropertyValueProvider;
117
118 #define QUERYINT( xint ) \
119 if( rType == ::getCppuType((const uno::Reference< xint >*)0) ) \
120 aAny <<= uno::Reference< xint >(this)
121
122 class GDIMetaFile;
123 class SvStream;
124 sal_Bool ConvertGDIMetaFileToWMF( const GDIMetaFile & rMTF, SvStream & rTargetStream,
125 FilterConfigItem* pFilterConfigItem = NULL, sal_Bool bPlaceable = sal_True );
126
127 uno::Reference< uno::XInterface > SAL_CALL SvxUnoGluePointAccess_createInstance( SdrObject* pObject );
128
129 /***********************************************************************
130 * class SvxShapeImpl *
131 ***********************************************************************/
132
133 struct SvxShapeImpl
134 {
135 SvxShape& mrAntiImpl;
136 SfxItemSet* mpItemSet;
137 sal_uInt32 mnObjId;
138 SvxShapeMaster* mpMaster;
139 bool mbHasSdrObjectOwnership;
140 bool mbDisposing;
141
142 /** CL, OD 2005-07-19 #i52126# - this is initially 0 and set when
143 * a SvxShape::Create() call is executed. It is then set to the created
144 * SdrObject so a multiple call to SvxShape::Create() with same SdrObject
145 * is prohibited.
146 */
147 ::tools::WeakReference< SdrObject > mpCreatedObj;
148
149 // for xComponent
150 ::cppu::OInterfaceContainerHelper maDisposeListeners;
151 ::svx::PropertyChangeNotifier maPropertyNotifier;
152
SvxShapeImplSvxShapeImpl153 SvxShapeImpl( SvxShape& _rAntiImpl, ::osl::Mutex& _rMutex )
154 :mrAntiImpl( _rAntiImpl )
155 ,mpItemSet( NULL )
156 ,mnObjId( 0 )
157 ,mpMaster( NULL )
158 ,mbHasSdrObjectOwnership( false )
159 ,mbDisposing( false )
160 ,mpCreatedObj()
161 ,maDisposeListeners( _rMutex )
162 ,maPropertyNotifier( _rAntiImpl, _rMutex )
163 {
164 }
165 };
166
167 /**********************************************************************/
168 class ShapePositionProvider : public PropertyValueProvider
169 {
170 public:
ShapePositionProvider(const SvxShapeImpl & _shapeImpl)171 ShapePositionProvider( const SvxShapeImpl& _shapeImpl )
172 :PropertyValueProvider( _shapeImpl.mrAntiImpl, "Position" )
173 {
174 }
175
176 protected:
getCurrentValue(Any & _out_rCurrentValue) const177 virtual void getCurrentValue( Any& _out_rCurrentValue ) const
178 {
179 _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getPosition();
180 }
181 };
182
183 //----------------------------------------------------------------------
184 class ShapeSizeProvider : public PropertyValueProvider
185 {
186 public:
ShapeSizeProvider(const SvxShapeImpl & _shapeImpl)187 ShapeSizeProvider( const SvxShapeImpl& _shapeImpl )
188 :PropertyValueProvider( _shapeImpl.mrAntiImpl, "Size" )
189 {
190 }
191
192 protected:
getCurrentValue(Any & _out_rCurrentValue) const193 virtual void getCurrentValue( Any& _out_rCurrentValue ) const
194 {
195 _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getSize();
196 }
197 };
198
199 /***********************************************************************
200 * class SvxShape *
201 ***********************************************************************/
202
DBG_NAME(SvxShape)203 DBG_NAME(SvxShape)
204
205 SvxShape::SvxShape( SdrObject* pObject ) throw()
206 : maSize(100,100)
207 , mpImpl( new SvxShapeImpl( *this, maMutex ) )
208 , mbIsMultiPropertyCall(false)
209 , mpPropSet(aSvxMapProvider.GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
210 , maPropMapEntries(aSvxMapProvider.GetMap(SVXMAP_SHAPE))
211 , mpObj(pObject)
212 , mpModel(NULL)
213 , mnLockCount(0)
214 {
215 DBG_CTOR(SvxShape,NULL);
216 impl_construct();
217 }
218
219 //----------------------------------------------------------------------
SvxShape(SdrObject * pObject,const SfxItemPropertyMapEntry * pEntries,const SvxItemPropertySet * pPropertySet)220 SvxShape::SvxShape( SdrObject* pObject, const SfxItemPropertyMapEntry* pEntries, const SvxItemPropertySet* pPropertySet ) throw()
221 : maSize(100,100)
222 , mpImpl( new SvxShapeImpl( *this, maMutex ) )
223 , mbIsMultiPropertyCall(false)
224 , mpPropSet(pPropertySet)
225 , maPropMapEntries(pEntries)
226 , mpObj(pObject)
227 , mpModel(NULL)
228 , mnLockCount(0)
229 {
230 DBG_CTOR(SvxShape,NULL);
231 impl_construct();
232 }
233
234 //----------------------------------------------------------------------
SvxShape()235 SvxShape::SvxShape() throw()
236 : maSize(100,100)
237 , mpImpl( new SvxShapeImpl( *this, maMutex ) )
238 , mbIsMultiPropertyCall(false)
239 , mpPropSet(aSvxMapProvider.GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
240 , maPropMapEntries(aSvxMapProvider.GetMap(SVXMAP_SHAPE))
241 , mpObj(NULL)
242 , mpModel(NULL)
243 , mnLockCount(0)
244 {
245 DBG_CTOR(SvxShape,NULL);
246 impl_construct();
247 }
248
249 //----------------------------------------------------------------------
~SvxShape()250 SvxShape::~SvxShape() throw()
251 {
252 OGuard aGuard( Application::GetSolarMutex() );
253
254 DBG_ASSERT( mnLockCount == 0, "Locked shape was disposed!" );
255
256 if ( mpModel )
257 EndListening( *mpModel );
258
259 if ( mpImpl->mpMaster )
260 mpImpl->mpMaster->dispose();
261
262 if ( mpObj.is() )
263 mpObj->setUnoShape( NULL, SdrObject::GrantXShapeAccess() );
264
265 if( HasSdrObjectOwnership() && mpObj.is() )
266 {
267 mpImpl->mbHasSdrObjectOwnership = false;
268 SdrObject* pObject = mpObj.get();
269 SdrObject::Free( pObject );
270 }
271
272 delete mpImpl, mpImpl = NULL;
273
274 DBG_DTOR(SvxShape,NULL);
275 }
276
277 //----------------------------------------------------------------------
278
TakeSdrObjectOwnership()279 void SvxShape::TakeSdrObjectOwnership()
280 {
281 mpImpl->mbHasSdrObjectOwnership = true;
282 }
283
284 //----------------------------------------------------------------------
285
HasSdrObjectOwnership() const286 bool SvxShape::HasSdrObjectOwnership() const
287 {
288 if ( !mpImpl->mbHasSdrObjectOwnership )
289 return false;
290
291 OSL_ENSURE( mpObj.is(), "SvxShape::HasSdrObjectOwnership: have the ownership of an object which I don't know!" );
292 return mpObj.is();
293 }
294
295 //----------------------------------------------------------------------
296
setShapeKind(sal_uInt32 nKind)297 void SvxShape::setShapeKind( sal_uInt32 nKind )
298 {
299 mpImpl->mnObjId = nKind;
300 }
301
302 //----------------------------------------------------------------------
303
getShapeKind() const304 sal_uInt32 SvxShape::getShapeKind() const
305 {
306 return mpImpl->mnObjId;
307 }
308
309 //----------------------------------------------------------------------
310
setMaster(SvxShapeMaster * pMaster)311 void SvxShape::setMaster( SvxShapeMaster* pMaster )
312 {
313 mpImpl->mpMaster = pMaster;
314 }
315
getMaster()316 SvxShapeMaster* SvxShape::getMaster()
317 {
318 return mpImpl->mpMaster;
319 }
320
getMaster() const321 const SvxShapeMaster* SvxShape::getMaster() const
322 {
323 return mpImpl->mpMaster;
324 }
325
326 //----------------------------------------------------------------------
327
queryAggregation(const uno::Type & rType)328 uno::Any SAL_CALL SvxShape::queryAggregation( const uno::Type& rType ) throw (uno::RuntimeException)
329 {
330 if( mpImpl->mpMaster )
331 {
332 uno::Any aAny;
333 if( mpImpl->mpMaster->queryAggregation( rType, aAny ) )
334 return aAny;
335 }
336
337 return SvxShape_UnoImplHelper::queryAggregation(rType);
338 }
339
340 //----------------------------------------------------------------------
getUnoTunnelId()341 const ::com::sun::star::uno::Sequence< sal_Int8 > & SvxShape::getUnoTunnelId() throw()
342 {
343 static ::com::sun::star::uno::Sequence< sal_Int8 > * pSeq = 0;
344 if( !pSeq )
345 {
346 ::osl::Guard< ::osl::Mutex > aGuard( ::osl::Mutex::getGlobalMutex() );
347 if( !pSeq )
348 {
349 static ::com::sun::star::uno::Sequence< sal_Int8 > aSeq( 16 );
350 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
351 pSeq = &aSeq;
352 }
353 }
354 return *pSeq;
355 }
356
357 //----------------------------------------------------------------------
getImplementation(const uno::Reference<uno::XInterface> & xInt)358 SvxShape* SvxShape::getImplementation( const uno::Reference< uno::XInterface >& xInt )
359 {
360 uno::Reference< lang::XUnoTunnel > xUT( xInt, ::com::sun::star::uno::UNO_QUERY );
361 if( xUT.is() )
362 return reinterpret_cast<SvxShape*>(sal::static_int_cast<sal_uIntPtr>(xUT->getSomething( SvxShape::getUnoTunnelId())));
363 else
364 return NULL;
365 }
366
367 //----------------------------------------------------------------------
getSomething(const::com::sun::star::uno::Sequence<sal_Int8> & rId)368 sal_Int64 SAL_CALL SvxShape::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw(::com::sun::star::uno::RuntimeException) \
369 {
370 if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) )
371 {
372 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
373 }
374 else
375 {
376 return 0;
377 }
378 }
379
380 //----------------------------------------------------------------------
GetShapeForSdrObj(SdrObject * pObj)381 SvxShape* SvxShape::GetShapeForSdrObj( SdrObject* pObj ) throw()
382 {
383 return getImplementation( pObj->getUnoShape() );
384 }
385
386 //----------------------------------------------------------------------
getShapePropertyChangeNotifier()387 ::svx::PropertyChangeNotifier& SvxShape::getShapePropertyChangeNotifier()
388 {
389 return mpImpl->maPropertyNotifier;
390 }
391
392 //----------------------------------------------------------------------
impl_construct()393 void SvxShape::impl_construct()
394 {
395 mpImpl->maPropertyNotifier.registerProvider( ::svx::eShapePosition,
396 ::svx::PPropertyValueProvider( new ShapePositionProvider( *mpImpl ) ) );
397 mpImpl->maPropertyNotifier.registerProvider( ::svx::eShapeSize,
398 ::svx::PPropertyValueProvider( new ShapeSizeProvider( *mpImpl ) ) );
399
400 if ( mpObj.is() )
401 impl_initFromSdrObject();
402 }
403
404 //----------------------------------------------------------------------
impl_initFromSdrObject()405 void SvxShape::impl_initFromSdrObject()
406 {
407 DBG_TESTSOLARMUTEX();
408 OSL_PRECOND( mpObj.is(), "SvxShape::impl_initFromSdrObject: not to be called without SdrObject!" );
409 if ( !mpObj.is() )
410 return;
411
412 osl_incrementInterlockedCount( &m_refCount );
413 {
414 mpObj->setUnoShape( *this, SdrObject::GrantXShapeAccess() );
415 }
416 osl_decrementInterlockedCount( &m_refCount );
417
418 mpModel = mpObj->GetModel();
419
420 // #i40944#
421 // Do not simply return when no model but do the type corrections
422 // following below.
423 if(mpModel)
424 {
425 StartListening( *mpModel );
426 }
427
428 const sal_uInt32 nInventor = mpObj->GetObjInventor();
429
430 // is it one of ours (svx) ?
431 if( nInventor == SdrInventor || nInventor == E3dInventor || nInventor == FmFormInventor )
432 {
433 if(nInventor == FmFormInventor)
434 {
435 mpImpl->mnObjId = OBJ_UNO;
436 }
437 else
438 {
439 mpImpl->mnObjId = mpObj->GetObjIdentifier();
440 if( nInventor == E3dInventor )
441 mpImpl->mnObjId |= E3D_INVENTOR_FLAG;
442 }
443
444 switch(mpImpl->mnObjId)
445 {
446 case OBJ_CCUT: // Kreisabschnitt
447 case OBJ_CARC: // Kreisbogen
448 case OBJ_SECT: // Kreissektor
449 mpImpl->mnObjId = OBJ_CIRC;
450 break;
451
452 case E3D_SCENE_ID | E3D_INVENTOR_FLAG:
453 mpImpl->mnObjId = E3D_POLYSCENE_ID | E3D_INVENTOR_FLAG;
454 break;
455 }
456 }
457 }
458
459 //----------------------------------------------------------------------
Create(SdrObject * pNewObj,SvxDrawPage *)460 void SvxShape::Create( SdrObject* pNewObj, SvxDrawPage* /*pNewPage*/ )
461 {
462 DBG_TESTSOLARMUTEX();
463
464 OSL_PRECOND( pNewObj, "SvxShape::Create: invalid new object!" );
465 if ( !pNewObj )
466 return;
467
468 SdrObject* pCreatedObj = mpImpl->mpCreatedObj.get();
469 OSL_ENSURE( ( pCreatedObj == NULL ) || ( pCreatedObj == pNewObj ),
470 "SvxShape::Create: the same shape used for two different objects?! Strange ..." );
471
472 // --> CL, OD 2005-07-19 #i52126# - correct condition
473 if ( pCreatedObj != pNewObj )
474 // <--
475 {
476 DBG_ASSERT( pNewObj->GetModel(), "no model for SdrObject?" );
477 // --> CL, OD 2005-07-19 #i52126#
478 mpImpl->mpCreatedObj = pNewObj;
479 // <--
480
481 if( mpObj.is() && mpObj->GetModel() )
482 {
483 EndListening( *mpObj->GetModel() );
484 }
485
486 mpObj.reset( pNewObj );
487
488 OSL_ENSURE( !mbIsMultiPropertyCall, "SvxShape::Create: hmm?" );
489 // this was previously set in impl_initFromSdrObject, but I think it was superfluous
490 // (it definitely was in the other context where it was called, but I strongly suppose
491 // it was also superfluous when called from here)
492 impl_initFromSdrObject();
493
494 ObtainSettingsFromPropertySet( *mpPropSet );
495
496 // save user call
497 SdrObjUserCall* pUser = mpObj->GetUserCall();
498 mpObj->SetUserCall(NULL);
499
500 setPosition( maPosition );
501 setSize( maSize );
502
503 // restore user call after we set the initial size
504 mpObj->SetUserCall( pUser );
505
506 // if this shape was already named, use this name
507 if( maShapeName.getLength() )
508 {
509 mpObj->SetName( maShapeName );
510 maShapeName = OUString();
511 }
512 }
513 }
514
515 //----------------------------------------------------------------------
516
ChangeModel(SdrModel * pNewModel)517 void SvxShape::ChangeModel( SdrModel* pNewModel )
518 {
519 DBG_TESTSOLARMUTEX();
520 if( mpObj.is() && mpObj->GetModel() )
521 {
522 if( mpObj->GetModel() != pNewModel )
523 {
524 EndListening( *mpObj->GetModel() );
525 }
526 }
527
528 // --> CL, OD 2005-07-19 #i52126# - always listen to new model
529 if( pNewModel )
530 {
531 StartListening( *pNewModel );
532 }
533 // <--
534
535 // HACK #i53696# ChangeModel should be virtual, but it isn't. can't change that for 2.0.1
536 SvxShapeText* pShapeText = dynamic_cast< SvxShapeText* >( this );
537 if( pShapeText )
538 {
539 SvxTextEditSource* pTextEditSource = dynamic_cast< SvxTextEditSource* >( pShapeText->GetEditSource() );
540 if( pTextEditSource )
541 pTextEditSource->ChangeModel( pNewModel );
542 }
543
544 mpModel = pNewModel;
545
546 if( mpImpl->mpMaster )
547 mpImpl->mpMaster->modelChanged( pNewModel );
548 }
549
550 //----------------------------------------------------------------------
551
ForceMetricToItemPoolMetric(Pair & rPoint) const552 void SvxShape::ForceMetricToItemPoolMetric(Pair& rPoint) const throw()
553 {
554 DBG_TESTSOLARMUTEX();
555 if(mpModel)
556 {
557 SfxMapUnit eMapUnit = mpModel->GetItemPool().GetMetric(0);
558 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
559 {
560 switch(eMapUnit)
561 {
562 case SFX_MAPUNIT_TWIP :
563 {
564 rPoint.A() = MM_TO_TWIPS(rPoint.A());
565 rPoint.B() = MM_TO_TWIPS(rPoint.B());
566 break;
567 }
568 default:
569 {
570 DBG_ERROR("AW: Missing unit translation to PoolMetric!");
571 }
572 }
573 }
574 }
575 }
576
577 //----------------------------------------------------------------------
578 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue i59051
ForceMetricToItemPoolMetric(basegfx::B2DPolyPolygon & rPolyPolygon) const579 void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DPolyPolygon& rPolyPolygon) const throw()
580 {
581 DBG_TESTSOLARMUTEX();
582 if(mpModel)
583 {
584 SfxMapUnit eMapUnit = mpModel->GetItemPool().GetMetric(0);
585 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
586 {
587 switch(eMapUnit)
588 {
589 case SFX_MAPUNIT_TWIP :
590 {
591 basegfx::B2DHomMatrix aTransform;
592 const double fMMToTWIPS(72.0 / 127.0);
593
594 aTransform.scale(fMMToTWIPS, fMMToTWIPS);
595 rPolyPolygon.transform(aTransform);
596 break;
597 }
598 default:
599 {
600 DBG_ERROR("Missing unit translation to PoolMetric!");
601 }
602 }
603 }
604 }
605 }
606 // <--
607
608 //----------------------------------------------------------------------
ForceMetricTo100th_mm(Pair & rPoint) const609 void SvxShape::ForceMetricTo100th_mm(Pair& rPoint) const throw()
610 {
611 DBG_TESTSOLARMUTEX();
612 SfxMapUnit eMapUnit = SFX_MAPUNIT_100TH_MM;
613 if(mpModel)
614 {
615 eMapUnit = mpModel->GetItemPool().GetMetric(0);
616 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
617 {
618 switch(eMapUnit)
619 {
620 case SFX_MAPUNIT_TWIP :
621 {
622 rPoint.A() = TWIPS_TO_MM(rPoint.A());
623 rPoint.B() = TWIPS_TO_MM(rPoint.B());
624 break;
625 }
626 default:
627 {
628 DBG_ERROR("AW: Missing unit translation to 100th mm!");
629 }
630 }
631 }
632 }
633 }
634
635 //----------------------------------------------------------------------
636 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue i59051
ForceMetricTo100th_mm(basegfx::B2DPolyPolygon & rPolyPolygon) const637 void SvxShape::ForceMetricTo100th_mm(basegfx::B2DPolyPolygon& rPolyPolygon) const throw()
638 {
639 DBG_TESTSOLARMUTEX();
640 SfxMapUnit eMapUnit = SFX_MAPUNIT_100TH_MM;
641 if(mpModel)
642 {
643 eMapUnit = mpModel->GetItemPool().GetMetric(0);
644 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
645 {
646 switch(eMapUnit)
647 {
648 case SFX_MAPUNIT_TWIP :
649 {
650 basegfx::B2DHomMatrix aTransform;
651 const double fTWIPSToMM(127.0 / 72.0);
652 aTransform.scale(fTWIPSToMM, fTWIPSToMM);
653 rPolyPolygon.transform(aTransform);
654 break;
655 }
656 default:
657 {
658 DBG_ERROR("Missing unit translation to 100th mm!");
659 }
660 }
661 }
662 }
663 }
664 // <--
665 //----------------------------------------------------------------------
666
667
668 //----------------------------------------------------------------------
SvxItemPropertySet_ObtainSettingsFromPropertySet(const SvxItemPropertySet & rPropSet,SfxItemSet & rSet,uno::Reference<beans::XPropertySet> xSet,const SfxItemPropertyMap * pMap)669 void SvxItemPropertySet_ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet,
670 SfxItemSet& rSet, uno::Reference< beans::XPropertySet > xSet, const SfxItemPropertyMap* pMap )
671 {
672 if(rPropSet.AreThereOwnUsrAnys())
673 {
674 const SfxItemPropertyMap* pSrc = rPropSet.getPropertyMap();
675 PropertyEntryVector_t aSrcPropVector = pSrc->getPropertyEntries();
676 PropertyEntryVector_t::const_iterator aSrcIt = aSrcPropVector.begin();
677 while(aSrcIt != aSrcPropVector.end())
678 {
679 if(aSrcIt->nWID)
680 {
681 uno::Any* pUsrAny = rPropSet.GetUsrAnyForID(aSrcIt->nWID);
682 if(pUsrAny)
683 {
684 // Aequivalenten Eintrag in pDst suchen
685 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( aSrcIt->sName );
686 if(pEntry)
687 {
688 // entry found
689 if(pEntry->nWID >= OWN_ATTR_VALUE_START && pEntry->nWID <= OWN_ATTR_VALUE_END)
690 {
691 // Special ID im PropertySet, kann nur direkt am
692 // Objekt gesetzt werden+
693 xSet->setPropertyValue( aSrcIt->sName, *pUsrAny);
694 }
695 else
696 {
697 if(rSet.GetPool()->IsWhich(pEntry->nWID))
698 rSet.Put(rSet.GetPool()->GetDefaultItem(pEntry->nWID));
699 // setzen
700 SvxItemPropertySet_setPropertyValue(rPropSet, pEntry, *pUsrAny, rSet);
701 }
702 }
703 }
704 }
705
706 // next entry
707 ++aSrcIt;
708 }
709 const_cast< SvxItemPropertySet& >(rPropSet).ClearAllUsrAny();
710 }
711 }
712
713
ObtainSettingsFromPropertySet(const SvxItemPropertySet & rPropSet)714 void SvxShape::ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet)
715 {
716 DBG_TESTSOLARMUTEX();
717 if(mpObj.is() && rPropSet.AreThereOwnUsrAnys() && mpModel)
718 {
719 SfxItemSet aSet( mpModel->GetItemPool(), SDRATTR_START, SDRATTR_END, 0);
720 Reference< beans::XPropertySet > xShape( (OWeakObject*)this, UNO_QUERY );
721 SvxItemPropertySet_ObtainSettingsFromPropertySet(rPropSet, aSet, xShape, mpPropSet->getPropertyMap() );
722
723 mpObj->SetMergedItemSetAndBroadcast(aSet);
724
725 mpObj->ApplyNotPersistAttr( aSet );
726 }
727 }
728
729 //----------------------------------------------------------------------
730
GetBitmap(sal_Bool bMetaFile) const731 uno::Any SvxShape::GetBitmap( sal_Bool bMetaFile /* = sal_False */ ) const throw()
732 {
733 DBG_TESTSOLARMUTEX();
734 uno::Any aAny;
735
736 if( !mpObj.is() || mpModel == NULL || !mpObj->IsInserted() || NULL == mpObj->GetPage() )
737 return aAny;
738
739 VirtualDevice aVDev;
740 aVDev.SetMapMode(MapMode(MAP_100TH_MM));
741
742 SdrModel* pModel = mpObj->GetModel();
743 SdrPage* pPage = mpObj->GetPage();
744
745 E3dView* pView = new E3dView( pModel, &aVDev );
746 pView->hideMarkHandles();
747 SdrPageView* pPageView = pView->ShowSdrPage(pPage);
748
749 SdrObject *pTempObj = mpObj.get();
750 pView->MarkObj(pTempObj,pPageView);
751
752 Rectangle aRect(pTempObj->GetCurrentBoundRect());
753 aRect.Justify();
754 Size aSize(aRect.GetSize());
755
756 GDIMetaFile aMtf( pView->GetMarkedObjMetaFile() );
757 if( bMetaFile )
758 {
759 SvMemoryStream aDestStrm( 65535, 65535 );
760 ConvertGDIMetaFileToWMF( aMtf, aDestStrm, NULL, sal_False );
761 const uno::Sequence<sal_Int8> aSeq(
762 static_cast< const sal_Int8* >(aDestStrm.GetData()),
763 aDestStrm.GetEndOfData());
764 aAny.setValue( &aSeq, ::getCppuType((const uno::Sequence< sal_Int8 >*)0) );
765 }
766 else
767 {
768 Graphic aGraph(aMtf);
769 aGraph.SetPrefSize(aSize);
770 aGraph.SetPrefMapMode(MAP_100TH_MM);
771
772 Reference< awt::XBitmap > xBmp( aGraph.GetXGraphic(), UNO_QUERY );
773 aAny <<= xBmp;
774 }
775
776 pView->UnmarkAll();
777 delete pView;
778
779 return aAny;
780 }
781
782 //----------------------------------------------------------------------
783
getTypes()784 uno::Sequence< uno::Type > SAL_CALL SvxShape::getTypes()
785 throw (uno::RuntimeException)
786 {
787 if( mpImpl->mpMaster )
788 {
789 return mpImpl->mpMaster->getTypes();
790 }
791 else
792 {
793 return _getTypes();
794 }
795 }
796
797 //----------------------------------------------------------------------
798
_getTypes()799 uno::Sequence< uno::Type > SAL_CALL SvxShape::_getTypes()
800 throw(uno::RuntimeException)
801 {
802 switch( mpImpl->mnObjId )
803 {
804 // shapes without text
805 case OBJ_PAGE:
806 case OBJ_FRAME:
807 case OBJ_OLE2_PLUGIN:
808 case OBJ_OLE2_APPLET:
809 case E3D_CUBEOBJ_ID|E3D_INVENTOR_FLAG:
810 case E3D_SPHEREOBJ_ID|E3D_INVENTOR_FLAG:
811 case E3D_LATHEOBJ_ID|E3D_INVENTOR_FLAG:
812 case E3D_EXTRUDEOBJ_ID|E3D_INVENTOR_FLAG:
813 case E3D_POLYGONOBJ_ID|E3D_INVENTOR_FLAG:
814 case OBJ_MEDIA:
815 {
816 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
817
818 if( aTypeSequence.getLength() == 0 )
819 {
820 // Ready for multithreading; get global mutex for first call of this method only! see before
821 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
822
823 // Control these pointer again ... it can be, that another instance will be faster then these!
824 if( aTypeSequence.getLength() == 0 )
825 {
826 aTypeSequence.realloc( 12 );
827 uno::Type* pTypes = aTypeSequence.getArray();
828
829 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
830 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
831 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
832 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
833 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
834 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
835 *pTypes++ = beans::XMultiPropertyStates::static_type();
836 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
837 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
838 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
839 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
840 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
841 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
842 }
843 }
844 return aTypeSequence;
845 }
846 // group shape
847 case OBJ_GRUP:
848 {
849 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
850
851 if( aTypeSequence.getLength() == 0 )
852 {
853 // Ready for multithreading; get global mutex for first call of this method only! see before
854 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
855
856 // Control these pointer again ... it can be, that another instance will be faster then these!
857 if( aTypeSequence.getLength() == 0 )
858 {
859 aTypeSequence.realloc( 14 );
860 uno::Type* pTypes = aTypeSequence.getArray();
861
862 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
863 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
864 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
865 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
866 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
867 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
868 *pTypes++ = beans::XMultiPropertyStates::static_type();
869 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
870 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
871 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
872 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
873 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
874 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
875 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShapes>*)0);
876 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShapeGroup>*)0);
877 }
878 }
879 return aTypeSequence;
880 }
881 // connector shape
882 case OBJ_EDGE:
883 {
884 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
885
886 if( aTypeSequence.getLength() == 0 )
887 {
888 // Ready for multithreading; get global mutex for first call of this method only! see before
889 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
890
891 // Control these pointer again ... it can be, that another instance will be faster then these!
892 if( aTypeSequence.getLength() == 0 )
893 {
894 aTypeSequence.realloc( 17 );
895 uno::Type* pTypes = aTypeSequence.getArray();
896
897 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
898 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
899 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
900 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
901 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
902 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
903 *pTypes++ = beans::XMultiPropertyStates::static_type();
904 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
905 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
906 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
907 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
908 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
909 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
910 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XConnectorShape>*)0);
911 // from SvxUnoTextBase::getTypes()
912 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextAppend >*)0);
913 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextCopy >*)0);
914 *pTypes++ = ::getCppuType(( const uno::Reference< container::XEnumerationAccess >*)0);
915 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRangeMover >*)0);
916 }
917 }
918 return aTypeSequence;
919 }
920 // control shape
921 case OBJ_UNO:
922 {
923 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
924
925 if( aTypeSequence.getLength() == 0 )
926 {
927 // Ready for multithreading; get global mutex for first call of this method only! see before
928 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
929
930 // Control these pointer again ... it can be, that another instance will be faster then these!
931 if( aTypeSequence.getLength() == 0 )
932 {
933 aTypeSequence.realloc( 13 );
934 uno::Type* pTypes = aTypeSequence.getArray();
935
936 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
937 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
938 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
939 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
940 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
941 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
942 *pTypes++ = beans::XMultiPropertyStates::static_type();
943 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
944 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
945 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
946 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
947 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
948 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
949 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XControlShape>*)0);
950 }
951 }
952 return aTypeSequence;
953 }
954 // 3d scene shape
955 case E3D_POLYSCENE_ID|E3D_INVENTOR_FLAG:
956 {
957 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
958
959 if( aTypeSequence.getLength() == 0 )
960 {
961 // Ready for multithreading; get global mutex for first call of this method only! see before
962 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
963
964 // Control these pointer again ... it can be, that another instance will be faster then these!
965 if( aTypeSequence.getLength() == 0 )
966 {
967 aTypeSequence.realloc( 13 );
968 uno::Type* pTypes = aTypeSequence.getArray();
969
970 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
971 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
972 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
973 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
974 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
975 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
976 *pTypes++ = beans::XMultiPropertyStates::static_type();
977 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
978 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
979 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
980 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
981 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
982 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
983 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShapes>*)0);
984 }
985 }
986 return aTypeSequence;
987 }
988 case OBJ_CUSTOMSHAPE:
989 {
990 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
991
992 if( aTypeSequence.getLength() == 0 )
993 {
994 // Ready for multithreading; get global mutex for first call of this method only! see before
995 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
996
997 // Control these pointer again ... it can be, that another instance will be faster then these!
998 if( aTypeSequence.getLength() == 0 )
999 {
1000 aTypeSequence.realloc( 16 );
1001 uno::Type* pTypes = aTypeSequence.getArray();
1002
1003 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
1004 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
1005 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
1006 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
1007 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
1008 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
1009 *pTypes++ = beans::XMultiPropertyStates::static_type();
1010 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
1011 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
1012 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
1013 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
1014 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
1015 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
1016 // from SvxUnoTextBase::getTypes()
1017 *pTypes++ = ::getCppuType(( const uno::Reference< text::XText >*)0);
1018 *pTypes++ = ::getCppuType(( const uno::Reference< container::XEnumerationAccess >*)0);
1019 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRangeMover >*)0);
1020 *pTypes++ = ::getCppuType(( const uno::Reference< drawing::XEnhancedCustomShapeDefaulter >*)0);
1021 }
1022 }
1023 return aTypeSequence;
1024 }
1025 // shapes with text
1026 case OBJ_RECT:
1027 case OBJ_CIRC:
1028 case OBJ_MEASURE:
1029 case OBJ_LINE:
1030 case OBJ_POLY:
1031 case OBJ_PLIN:
1032 case OBJ_PATHLINE:
1033 case OBJ_PATHFILL:
1034 case OBJ_FREELINE:
1035 case OBJ_FREEFILL:
1036 case OBJ_PATHPOLY:
1037 case OBJ_PATHPLIN:
1038 case OBJ_GRAF:
1039 case OBJ_TEXT:
1040 case OBJ_CAPTION:
1041 case OBJ_TABLE:
1042 case OBJ_OLE2: // #i118485# Moved to shapes with text, was at (shapes without text) before, see above
1043 default:
1044 {
1045 static ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > aTypeSequence;
1046
1047 if( aTypeSequence.getLength() == 0 )
1048 {
1049 // Ready for multithreading; get global mutex for first call of this method only! see before
1050 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
1051
1052 // Control these pointer again ... it can be, that another instance will be faster then these!
1053 if( aTypeSequence.getLength() == 0 )
1054 {
1055 aTypeSequence.realloc( 16 );
1056 uno::Type* pTypes = aTypeSequence.getArray();
1057
1058 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XShape >*)0);
1059 *pTypes++ = ::getCppuType((const uno::Reference< lang::XComponent >*)0);
1060 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertySet >*)0);
1061 *pTypes++ = ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0);
1062 // *pTypes++ = ::getCppuType((const uno::Reference< beans::XTolerantMultiPropertySet >*)0);
1063 *pTypes++ = ::getCppuType((const uno::Reference< beans::XPropertyState >*)0);
1064 *pTypes++ = beans::XMultiPropertyStates::static_type();
1065 *pTypes++ = ::getCppuType((const uno::Reference< drawing::XGluePointsSupplier >*)0);
1066 *pTypes++ = ::getCppuType((const uno::Reference< container::XChild >*)0);
1067 *pTypes++ = ::getCppuType((const uno::Reference< lang::XServiceInfo >*)0);
1068 *pTypes++ = ::getCppuType((const uno::Reference< lang::XTypeProvider >*)0);
1069 *pTypes++ = ::getCppuType((const uno::Reference< lang::XUnoTunnel >*)0);
1070 *pTypes++ = ::getCppuType((const uno::Reference< container::XNamed >*)0);
1071 // from SvxUnoTextBase::getTypes()
1072 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextAppend >*)0);
1073 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextCopy >*)0);
1074 *pTypes++ = ::getCppuType(( const uno::Reference< container::XEnumerationAccess >*)0);
1075 *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRangeMover >*)0);
1076 }
1077 }
1078 return aTypeSequence;
1079 }
1080 }
1081 }
1082
1083 //----------------------------------------------------------------------
1084
getImplementationId()1085 uno::Sequence< sal_Int8 > SAL_CALL SvxShape::getImplementationId()
1086 throw (uno::RuntimeException)
1087 {
1088 static ::cppu::OImplementationId* pID = NULL ;
1089
1090 if ( pID == NULL )
1091 {
1092 // Ready for multithreading; get global mutex for first call of this method only! see before
1093 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
1094
1095 // Control these pointer again ... it can be, that another instance will be faster then these!
1096 if ( pID == NULL )
1097 {
1098 // Create a new static ID ...
1099 static ::cppu::OImplementationId aID( sal_False ) ;
1100 // ... and set his address to static pointer!
1101 pID = &aID ;
1102 }
1103 }
1104
1105 return pID->getImplementationId() ;
1106 }
1107
1108 //----------------------------------------------------------------------
1109
SvxShape_NewInstance()1110 Reference< uno::XInterface > SvxShape_NewInstance()
1111 {
1112 return uno::Reference< uno::XInterface >(static_cast< OWeakObject* >( new SvxShape() ) );
1113 }
1114
1115 //----------------------------------------------------------------------
1116
onUserCall(SdrUserCallType,const Rectangle &)1117 void SvxShape::onUserCall(SdrUserCallType /*_eUserCall*/, const Rectangle& /*_rNewBoundRect*/ )
1118 {
1119 // obsolete, not called anymore
1120 }
1121
1122 //----------------------------------------------------------------------
1123 // SfxListener
1124 //----------------------------------------------------------------------
1125
Notify(SfxBroadcaster &,const SfxHint & rHint)1126 void SvxShape::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
1127 {
1128 DBG_TESTSOLARMUTEX();
1129 if( !mpObj.is() )
1130 return;
1131
1132 // #i55919# HINT_OBJCHG is only interesting if it's for this object
1133
1134 const SdrHint* pSdrHint = PTR_CAST( SdrHint, &rHint );
1135 if (!pSdrHint || ( /* (pSdrHint->GetKind() != HINT_OBJREMOVED) && */
1136 (pSdrHint->GetKind() != HINT_MODELCLEARED) &&
1137 // #110094#-9 (pSdrHint->GetKind() != HINT_OBJLISTCLEAR) &&
1138 ((pSdrHint->GetKind() != HINT_OBJCHG || pSdrHint->GetObject() != mpObj.get() ))))
1139 return;
1140
1141 uno::Reference< uno::XInterface > xSelf( mpObj->getWeakUnoShape() );
1142 if( !xSelf.is() )
1143 {
1144 mpObj.reset( NULL );
1145 return;
1146 }
1147
1148 sal_Bool bClearMe = sal_False;
1149
1150 switch( pSdrHint->GetKind() )
1151 {
1152 case HINT_OBJCHG:
1153 {
1154 updateShapeKind();
1155 break;
1156 }
1157 case HINT_MODELCLEARED:
1158 {
1159 bClearMe = sal_True;
1160 mpModel = NULL;
1161 break;
1162 }
1163 default:
1164 break;
1165 };
1166
1167 if( bClearMe )
1168 {
1169 if( !HasSdrObjectOwnership() )
1170 mpObj.reset( NULL );
1171 if ( !mpImpl->mbDisposing )
1172 dispose();
1173 }
1174 }
1175
1176 // XShape
1177
1178 //----------------------------------------------------------------------
1179 // The "*LogicRectHack" functions also existed in sch, and those
1180 // duplicate symbols cause Bad Things To Happen (TM) #i9462#.
1181 // Prefixing with 'svx' and marking static to make sure name collisions
1182 // do not occur.
1183
svx_needLogicRectHack(SdrObject * pObj)1184 static sal_Bool svx_needLogicRectHack( SdrObject* pObj )
1185 {
1186 if( pObj->GetObjInventor() == SdrInventor)
1187 {
1188 switch(pObj->GetObjIdentifier())
1189 {
1190 case OBJ_GRUP:
1191 case OBJ_LINE:
1192 case OBJ_POLY:
1193 case OBJ_PLIN:
1194 case OBJ_PATHLINE:
1195 case OBJ_PATHFILL:
1196 case OBJ_FREELINE:
1197 case OBJ_FREEFILL:
1198 case OBJ_SPLNLINE:
1199 case OBJ_SPLNFILL:
1200 case OBJ_EDGE:
1201 case OBJ_PATHPOLY:
1202 case OBJ_PATHPLIN:
1203 case OBJ_MEASURE:
1204 return sal_True;
1205 }
1206 }
1207 return sal_False;
1208 }
1209
1210 //----------------------------------------------------------------------
1211
svx_getLogicRectHack(SdrObject * pObj)1212 static Rectangle svx_getLogicRectHack( SdrObject* pObj )
1213 {
1214 if(svx_needLogicRectHack(pObj))
1215 {
1216 return pObj->GetSnapRect();
1217 }
1218 else
1219 {
1220 return pObj->GetLogicRect();
1221 }
1222 }
1223
1224 //----------------------------------------------------------------------
1225
svx_setLogicRectHack(SdrObject * pObj,const Rectangle & rRect)1226 static void svx_setLogicRectHack( SdrObject* pObj, const Rectangle& rRect )
1227 {
1228 if(svx_needLogicRectHack(pObj))
1229 {
1230 pObj->SetSnapRect( rRect );
1231 }
1232 else
1233 {
1234 pObj->SetLogicRect( rRect );
1235 }
1236 }
1237
1238 //----------------------------------------------------------------------
1239
getPosition()1240 awt::Point SAL_CALL SvxShape::getPosition() throw(uno::RuntimeException)
1241 {
1242 OGuard aGuard( Application::GetSolarMutex() );
1243
1244 if( mpObj.is() && mpModel)
1245 {
1246 Rectangle aRect( svx_getLogicRectHack(mpObj.get()) );
1247 Point aPt( aRect.Left(), aRect.Top() );
1248
1249 // Position is relativ to anchor, so recalc to absolut position
1250 if( mpModel->IsWriter() )
1251 aPt -= mpObj->GetAnchorPos();
1252
1253 ForceMetricTo100th_mm(aPt);
1254 return ::com::sun::star::awt::Point( aPt.X(), aPt.Y() );
1255 }
1256 else
1257 {
1258 return maPosition;
1259 }
1260 }
1261
1262 //----------------------------------------------------------------------
setPosition(const awt::Point & Position)1263 void SAL_CALL SvxShape::setPosition( const awt::Point& Position ) throw(uno::RuntimeException)
1264 {
1265 OGuard aGuard( Application::GetSolarMutex() );
1266
1267 if( mpObj.is() && mpModel )
1268 {
1269 // do NOT move 3D objects, this would change the homogen
1270 // transformation matrix
1271 if(!mpObj->ISA(E3dCompoundObject))
1272 {
1273 Rectangle aRect( svx_getLogicRectHack(mpObj.get()) );
1274 Point aLocalPos( Position.X, Position.Y );
1275 ForceMetricToItemPoolMetric(aLocalPos);
1276
1277 // Position ist absolut, relativ zum Anker stellen
1278 if( mpModel->IsWriter() )
1279 aLocalPos += mpObj->GetAnchorPos();
1280
1281 long nDX = aLocalPos.X() - aRect.Left();
1282 long nDY = aLocalPos.Y() - aRect.Top();
1283
1284 mpObj->Move( Size( nDX, nDY ) );
1285 mpModel->SetChanged();
1286 }
1287 }
1288
1289 maPosition = Position;
1290 }
1291
1292 //----------------------------------------------------------------------
getSize()1293 awt::Size SAL_CALL SvxShape::getSize() throw(uno::RuntimeException)
1294 {
1295 OGuard aGuard( Application::GetSolarMutex() );
1296
1297 if( mpObj.is() && mpModel)
1298 {
1299 Rectangle aRect( svx_getLogicRectHack(mpObj.get()) );
1300 Size aObjSize( aRect.getWidth(), aRect.getHeight() );
1301 ForceMetricTo100th_mm(aObjSize);
1302 return ::com::sun::star::awt::Size( aObjSize.getWidth(), aObjSize.getHeight() );
1303 }
1304 else
1305 return maSize;
1306 }
1307
1308 //----------------------------------------------------------------------
setSize(const awt::Size & rSize)1309 void SAL_CALL SvxShape::setSize( const awt::Size& rSize )
1310 throw(beans::PropertyVetoException, uno::RuntimeException)
1311 {
1312 OGuard aGuard( Application::GetSolarMutex() );
1313
1314 if( mpObj.is() && mpModel)
1315 {
1316 // #123539# optimization for 3D chart object generation: do not use UNO
1317 // API commmands to get the range, this is too expensive since for 3D
1318 // scenes it may recalculate the whole scene since in AOO this depends
1319 // on the contained geometry (layouted to show all content)
1320 const bool b3DConstruction(dynamic_cast< E3dObject* >(mpObj.get()) && mpModel->isLocked());
1321 Rectangle aRect(
1322 b3DConstruction ?
1323 Rectangle(maPosition.X, maPosition.Y, maSize.Width, maSize.Height) :
1324 svx_getLogicRectHack(mpObj.get()) );
1325 Size aLocalSize( rSize.Width, rSize.Height );
1326 ForceMetricToItemPoolMetric(aLocalSize);
1327
1328 if(mpObj->GetObjInventor() == SdrInventor && mpObj->GetObjIdentifier() == OBJ_MEASURE )
1329 {
1330 Fraction aWdt(aLocalSize.Width(),aRect.Right()-aRect.Left());
1331 Fraction aHgt(aLocalSize.Height(),aRect.Bottom()-aRect.Top());
1332 Point aPt = mpObj->GetSnapRect().TopLeft();
1333 mpObj->Resize(aPt,aWdt,aHgt);
1334 }
1335 else
1336 {
1337 //aRect.SetSize(aLocalSize); // this call substract 1 // http://www.openoffice.org/issues/show_bug.cgi?id=83193
1338 if ( !aLocalSize.Width() )
1339 {
1340 aRect.Right() = RECT_EMPTY;
1341 }
1342 else
1343 aRect.setWidth(aLocalSize.Width());
1344 if ( !aLocalSize.Height() )
1345 {
1346 aRect.Bottom() = RECT_EMPTY;
1347 }
1348 else
1349 aRect.setHeight(aLocalSize.Height());
1350
1351 svx_setLogicRectHack( mpObj.get(), aRect );
1352 }
1353
1354 mpModel->SetChanged();
1355 }
1356 maSize = rSize;
1357 }
1358
1359 //----------------------------------------------------------------------
1360
1361 // XNamed
getName()1362 OUString SAL_CALL SvxShape::getName( ) throw(::com::sun::star::uno::RuntimeException)
1363 {
1364 OGuard aGuard( Application::GetSolarMutex() );
1365 if( mpObj.is() )
1366 {
1367 return mpObj->GetName();
1368 }
1369 else
1370 {
1371 return maShapeName;
1372 }
1373 }
1374
1375 //----------------------------------------------------------------------
1376
setName(const::rtl::OUString & aName)1377 void SAL_CALL SvxShape::setName( const ::rtl::OUString& aName ) throw(::com::sun::star::uno::RuntimeException)
1378 {
1379 OGuard aGuard( Application::GetSolarMutex() );
1380 if( mpObj.is() )
1381 {
1382 mpObj->SetName( aName );
1383 }
1384 else
1385 {
1386 maShapeName = aName;
1387 }
1388 }
1389
1390 // XShapeDescriptor
1391
1392 //----------------------------------------------------------------------
getShapeType()1393 OUString SAL_CALL SvxShape::getShapeType() throw(uno::RuntimeException)
1394 {
1395 if( 0 == maShapeType.getLength() )
1396 {
1397 UHashMapEntry* pMap = pSdrShapeIdentifierMap;
1398 while ( ( pMap->nId != mpImpl->mnObjId ) && pMap->aIdentifier.getLength() )
1399 ++pMap;
1400
1401 if ( pMap->aIdentifier.getLength() )
1402 {
1403 return pMap->aIdentifier;
1404 }
1405 else
1406 {
1407 DBG_ERROR("[CL] unknown SdrObjekt identifier");
1408 }
1409 }
1410
1411 return maShapeType;
1412 }
1413
1414 // XComponent
1415
1416 //----------------------------------------------------------------------
dispose()1417 void SAL_CALL SvxShape::dispose() throw(uno::RuntimeException)
1418 {
1419 OGuard aGuard( Application::GetSolarMutex() );
1420
1421 if( mpImpl->mbDisposing )
1422 return; // caught a recursion
1423
1424 mpImpl->mbDisposing = true;
1425
1426 lang::EventObject aEvt;
1427 aEvt.Source = *(OWeakAggObject*) this;
1428 mpImpl->maDisposeListeners.disposeAndClear(aEvt);
1429 mpImpl->maPropertyNotifier.disposing();
1430
1431 if ( mpObj.is() )
1432 {
1433 bool bFreeSdrObject = false;
1434
1435 if ( mpObj->IsInserted() && mpObj->GetPage() )
1436 {
1437 OSL_ENSURE( HasSdrObjectOwnership(), "SvxShape::dispose: is the below code correct?" );
1438 // normally, we are allowed to free the SdrObject only if we have its ownership.
1439 // Why isn't this checked here?
1440
1441 SdrPage* pPage = mpObj->GetPage();
1442 // SdrObject aus der Page loeschen
1443 sal_uInt32 nCount = pPage->GetObjCount();
1444 for ( sal_uInt32 nNum = 0; nNum < nCount; ++nNum )
1445 {
1446 if ( pPage->GetObj( nNum ) == mpObj.get() )
1447 {
1448 OSL_VERIFY( pPage->RemoveObject( nNum ) == mpObj.get() );
1449 bFreeSdrObject = true;
1450 break;
1451 }
1452 }
1453 }
1454
1455 mpObj->setUnoShape( NULL, SdrObject::GrantXShapeAccess() );
1456
1457 if ( bFreeSdrObject )
1458 {
1459 // in case we have the ownership of the SdrObject, a Free
1460 // would do nothing. So ensure the ownership is reset.
1461 mpImpl->mbHasSdrObjectOwnership = false;
1462 SdrObject* pObject = mpObj.get();
1463 SdrObject::Free( pObject );
1464 }
1465 }
1466
1467 if( mpModel )
1468 {
1469 EndListening( *mpModel );
1470 mpModel = NULL;
1471 }
1472 }
1473
1474 //----------------------------------------------------------------------
1475
addEventListener(const Reference<lang::XEventListener> & xListener)1476 void SAL_CALL SvxShape::addEventListener( const Reference< lang::XEventListener >& xListener )
1477 throw(uno::RuntimeException)
1478 {
1479 mpImpl->maDisposeListeners.addInterface(xListener);
1480 }
1481
1482 //----------------------------------------------------------------------
1483
removeEventListener(const Reference<lang::XEventListener> & aListener)1484 void SAL_CALL SvxShape::removeEventListener( const Reference< lang::XEventListener >& aListener ) throw(uno::RuntimeException)
1485 {
1486 mpImpl->maDisposeListeners.removeInterface(aListener);
1487 }
1488
1489 // XPropertySet
1490
1491 //----------------------------------------------------------------------
1492
1493 Reference< beans::XPropertySetInfo > SAL_CALL
getPropertySetInfo()1494 SvxShape::getPropertySetInfo() throw(uno::RuntimeException)
1495 {
1496 if( mpImpl->mpMaster )
1497 {
1498 return mpImpl->mpMaster->getPropertySetInfo();
1499 }
1500 else
1501 {
1502 return _getPropertySetInfo();
1503 }
1504 }
1505
1506 Reference< beans::XPropertySetInfo > SAL_CALL
_getPropertySetInfo()1507 SvxShape::_getPropertySetInfo() throw(uno::RuntimeException)
1508 {
1509 return mpPropSet->getPropertySetInfo();
1510 }
1511
1512 //----------------------------------------------------------------------
1513
addPropertyChangeListener(const OUString & _propertyName,const Reference<beans::XPropertyChangeListener> & _listener)1514 void SAL_CALL SvxShape::addPropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1515 {
1516 ::osl::MutexGuard aGuard( maMutex );
1517 mpImpl->maPropertyNotifier.addPropertyChangeListener( _propertyName, _listener );
1518 }
1519
1520 //----------------------------------------------------------------------
1521
removePropertyChangeListener(const OUString & _propertyName,const Reference<beans::XPropertyChangeListener> & _listener)1522 void SAL_CALL SvxShape::removePropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1523 {
1524 ::osl::MutexGuard aGuard( maMutex );
1525 mpImpl->maPropertyNotifier.removePropertyChangeListener( _propertyName, _listener );
1526 }
1527
1528 //----------------------------------------------------------------------
1529
addVetoableChangeListener(const OUString &,const Reference<beans::XVetoableChangeListener> &)1530 void SAL_CALL SvxShape::addVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1531 {
1532 OSL_ENSURE( false, "SvxShape::addVetoableChangeListener: don't have any vetoable properties, so why ...?" );
1533 }
1534
1535 //----------------------------------------------------------------------
1536
removeVetoableChangeListener(const OUString &,const Reference<beans::XVetoableChangeListener> &)1537 void SAL_CALL SvxShape::removeVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1538 {
1539 OSL_ENSURE( false, "SvxShape::removeVetoableChangeListener: don't have any vetoable properties, so why ...?" );
1540 }
1541
1542 //----------------------------------------------------------------------
1543
SetFillAttribute(sal_Int32 nWID,const OUString & rName)1544 sal_Bool SAL_CALL SvxShape::SetFillAttribute( sal_Int32 nWID, const OUString& rName )
1545 {
1546 SfxItemSet aSet( mpModel->GetItemPool(), (sal_uInt16)nWID, (sal_uInt16)nWID );
1547
1548 if( SetFillAttribute( nWID, rName, aSet, mpModel ) )
1549 {
1550 //mpObj->SetItemSetAndBroadcast(aSet);
1551 mpObj->SetMergedItemSetAndBroadcast(aSet);
1552
1553 return sal_True;
1554 }
1555 else
1556 {
1557 return sal_False;
1558 }
1559 }
1560
1561 //----------------------------------------------------------------------
1562
SetFillAttribute(sal_Int32 nWID,const::rtl::OUString & rName,SfxItemSet & rSet,SdrModel * pModel)1563 sal_Bool SAL_CALL SvxShape::SetFillAttribute( sal_Int32 nWID, const ::rtl::OUString& rName, SfxItemSet& rSet, SdrModel* pModel )
1564 {
1565 // check if an item with the given name and which id is inside the models
1566 // pool or the stylesheet pool, if found its puttet in the itemse
1567 if( !SetFillAttribute( nWID, rName, rSet ) )
1568 {
1569 // we did not find such item in one of the pools, so we check
1570 // the property lists that are loaded for the model for items
1571 // that support such.
1572 String aStrName;
1573 SvxUnogetInternalNameForItem( (sal_Int16)nWID, rName, aStrName );
1574
1575 switch( nWID )
1576 {
1577 case XATTR_FILLBITMAP:
1578 {
1579 XBitmapListSharedPtr aBitmapList = pModel->GetBitmapListFromSdrModel();
1580
1581 if( !aBitmapList.get() )
1582 return sal_False;
1583
1584 long nPos = aBitmapList->GetIndex(aStrName);
1585 if( nPos == -1 )
1586 return sal_False;
1587
1588 XBitmapEntry* pEntry = aBitmapList->GetBitmap( nPos );
1589 XFillBitmapItem aBmpItem;
1590 aBmpItem.SetWhich( XATTR_FILLBITMAP );
1591 aBmpItem.SetName( rName );
1592 aBmpItem.SetGraphicObject(pEntry->GetGraphicObject());
1593 rSet.Put( aBmpItem );
1594 break;
1595 }
1596 case XATTR_FILLGRADIENT:
1597 {
1598 XGradientListSharedPtr aGradientList = pModel->GetGradientListFromSdrModel();
1599
1600 if( !aGradientList.get() )
1601 return sal_False;
1602
1603 long nPos = aGradientList->GetIndex(aStrName);
1604 if( nPos == -1 )
1605 return sal_False;
1606
1607 XGradientEntry* pEntry = aGradientList->GetGradient( nPos );
1608 XFillGradientItem aGrdItem;
1609 aGrdItem.SetWhich( XATTR_FILLGRADIENT );
1610 aGrdItem.SetName( rName );
1611 aGrdItem.SetGradientValue( pEntry->GetGradient() );
1612 rSet.Put( aGrdItem );
1613 break;
1614 }
1615 case XATTR_FILLHATCH:
1616 {
1617 XHatchListSharedPtr aHatchList = pModel->GetHatchListFromSdrModel();
1618
1619 if( !aHatchList.get() )
1620 return sal_False;
1621
1622 long nPos = aHatchList->GetIndex(aStrName);
1623 if( nPos == -1 )
1624 return sal_False;
1625
1626 XHatchEntry* pEntry = aHatchList->GetHatch( nPos );
1627 XFillHatchItem aHatchItem;
1628 aHatchItem.SetWhich( XATTR_FILLHATCH );
1629 aHatchItem.SetName( rName );
1630 aHatchItem.SetHatchValue( pEntry->GetHatch() );
1631 rSet.Put( aHatchItem );
1632 break;
1633 }
1634 case XATTR_LINEEND:
1635 case XATTR_LINESTART:
1636 {
1637 XLineEndListSharedPtr aLineEndList = pModel->GetLineEndListFromSdrModel();
1638
1639 if( !aLineEndList.get() )
1640 return sal_False;
1641
1642 long nPos = aLineEndList->GetIndex(aStrName);
1643 if( nPos == -1 )
1644 return sal_False;
1645
1646 XLineEndEntry* pEntry = aLineEndList->GetLineEnd( nPos );
1647 if( XATTR_LINEEND == nWID )
1648 {
1649 XLineEndItem aLEItem;
1650 aLEItem.SetWhich( XATTR_LINEEND );
1651 aLEItem.SetName( rName );
1652 aLEItem.SetLineEndValue( pEntry->GetLineEnd() );
1653 rSet.Put( aLEItem );
1654 }
1655 else
1656 {
1657 XLineStartItem aLSItem;
1658 aLSItem.SetWhich( XATTR_LINESTART );
1659 aLSItem.SetName( rName );
1660 aLSItem.SetLineStartValue( pEntry->GetLineEnd() );
1661 rSet.Put( aLSItem );
1662 }
1663
1664 break;
1665 }
1666 case XATTR_LINEDASH:
1667 {
1668 XDashListSharedPtr aDashList = pModel->GetDashListFromSdrModel();
1669
1670 if( !aDashList.get() )
1671 return sal_False;
1672
1673 long nPos = aDashList->GetIndex(aStrName);
1674 if( nPos == -1 )
1675 return sal_False;
1676
1677 XDashEntry* pEntry = aDashList->GetDash( nPos );
1678 XLineDashItem aDashItem;
1679 aDashItem.SetWhich( XATTR_LINEDASH );
1680 aDashItem.SetName( rName );
1681 aDashItem.SetDashValue( pEntry->GetDash() );
1682 rSet.Put( aDashItem );
1683 break;
1684 }
1685 default:
1686 return sal_False;
1687 }
1688 }
1689
1690 return sal_True;
1691 }
1692
1693 //----------------------------------------------------------------------
1694
SetFillAttribute(sal_Int32 nWID,const OUString & rName,SfxItemSet & rSet)1695 sal_Bool SAL_CALL SvxShape::SetFillAttribute( sal_Int32 nWID, const OUString& rName, SfxItemSet& rSet )
1696 {
1697 String aName;
1698 SvxUnogetInternalNameForItem( (sal_Int16)nWID, rName, aName );
1699
1700 if( aName.Len() == 0 )
1701 {
1702 switch( nWID )
1703 {
1704 case XATTR_LINEEND:
1705 case XATTR_LINESTART:
1706 {
1707 const String aEmpty;
1708 const basegfx::B2DPolyPolygon aEmptyPoly;
1709 if( nWID == XATTR_LINEEND )
1710 rSet.Put( XLineEndItem( aEmpty, aEmptyPoly ) );
1711 else
1712 rSet.Put( XLineStartItem( aEmpty, aEmptyPoly ) );
1713
1714 return sal_True;
1715 }
1716 case XATTR_FILLFLOATTRANSPARENCE:
1717 {
1718 // #85953# Set a disabled XFillFloatTransparenceItem
1719 rSet.Put(XFillFloatTransparenceItem());
1720
1721 return sal_True;
1722 }
1723 }
1724
1725 return sal_False;
1726 }
1727
1728 const SfxItemPool* pPool = rSet.GetPool();
1729
1730 const String aSearchName( aName );
1731 const sal_uInt32 nCount = pPool->GetItemCount2((sal_uInt16)nWID);
1732 const NameOrIndex* pItem;
1733
1734 for( sal_uInt32 nSurrogate = 0; nSurrogate < nCount; nSurrogate++ )
1735 {
1736 pItem = (NameOrIndex*)pPool->GetItem2((sal_uInt16)nWID, nSurrogate);
1737 if( pItem && ( pItem->GetName() == aSearchName ) )
1738 {
1739 rSet.Put( *pItem );
1740 return sal_True;
1741 }
1742 }
1743
1744 return sal_False;
1745 }
1746
1747 //----------------------------------------------------------------------
1748
setPropertyValue(const OUString & rPropertyName,const uno::Any & rVal)1749 void SAL_CALL SvxShape::setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal )
1750 throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
1751 {
1752 if( mpImpl->mpMaster )
1753 {
1754 mpImpl->mpMaster->setPropertyValue( rPropertyName, rVal );
1755 }
1756 else
1757 {
1758 _setPropertyValue( rPropertyName, rVal );
1759 }
1760 }
1761
_setPropertyValue(const OUString & rPropertyName,const uno::Any & rVal)1762 void SAL_CALL SvxShape::_setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal )
1763 throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
1764 {
1765 OGuard aGuard( Application::GetSolarMutex() );
1766
1767 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName);
1768
1769 if( mpObj.is() && mpModel )
1770 {
1771 if( pMap == NULL )
1772 throw beans::UnknownPropertyException();
1773
1774 if( (pMap->nFlags & beans::PropertyAttribute::READONLY ) != 0 )
1775 throw beans::PropertyVetoException();
1776
1777 mpModel->SetChanged();
1778
1779 if(!setPropertyValueImpl( rPropertyName, pMap, rVal ) )
1780 {
1781 DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST, "Not persist item not handled!" );
1782 DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" );
1783
1784 sal_Bool bIsNotPersist = pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST && pMap->nWID != SDRATTR_TEXTDIRECTION;
1785
1786 if( pMap->nWID == SDRATTR_ECKENRADIUS )
1787 {
1788 sal_Int32 nCornerRadius = 0;
1789 if( !(rVal >>= nCornerRadius) || (nCornerRadius < 0) || (nCornerRadius > 5000000))
1790 throw IllegalArgumentException();
1791 }
1792
1793 SfxItemSet* pSet;
1794 if( mbIsMultiPropertyCall && !bIsNotPersist )
1795 {
1796 if( mpImpl->mpItemSet == NULL )
1797 {
1798 pSet = mpImpl->mpItemSet = mpObj->GetMergedItemSet().Clone();
1799 }
1800 else
1801 {
1802 pSet = mpImpl->mpItemSet;
1803 }
1804 }
1805 else
1806 {
1807 pSet = new SfxItemSet( mpModel->GetItemPool(), pMap->nWID, pMap->nWID);
1808 }
1809
1810 if( pSet->GetItemState( pMap->nWID ) != SFX_ITEM_SET )
1811 pSet->Put(mpObj->GetMergedItem(pMap->nWID));
1812
1813 if( !SvxUnoTextRangeBase::SetPropertyValueHelper( *pSet, pMap, rVal, *pSet ))
1814 {
1815 if( pSet->GetItemState( pMap->nWID ) != SFX_ITEM_SET )
1816 {
1817 if(bIsNotPersist)
1818 {
1819 // Not-Persistant Attribute, hole diese extra
1820 mpObj->TakeNotPersistAttr(*pSet, sal_False);
1821 }
1822 }
1823
1824 if( pSet->GetItemState( pMap->nWID ) != SFX_ITEM_SET )
1825 {
1826 // Default aus ItemPool holen
1827 if(mpModel->GetItemPool().IsWhich(pMap->nWID))
1828 pSet->Put(mpModel->GetItemPool().GetDefaultItem(pMap->nWID));
1829 }
1830
1831 if( pSet->GetItemState( pMap->nWID ) == SFX_ITEM_SET )
1832 {
1833 SvxItemPropertySet_setPropertyValue( *mpPropSet, pMap, rVal, *pSet );
1834 }
1835 }
1836
1837 if(bIsNotPersist)
1838 {
1839 // Not-Persist Attribute extra setzen
1840 mpObj->ApplyNotPersistAttr( *pSet );
1841 delete pSet;
1842 }
1843 else
1844 {
1845 // if we have a XMultiProperty call then the item set
1846 // will be set in setPropertyValues later
1847 if( !mbIsMultiPropertyCall )
1848 {
1849 mpObj->SetMergedItemSetAndBroadcast( *pSet );
1850
1851 delete pSet;
1852 }
1853 }
1854 return;
1855 }
1856 }
1857 else
1858 {
1859 // since we have no actual sdr object right now
1860 // remember all properties in a list. These
1861 // properties will be set when the sdr object is
1862 // created
1863
1864 if(pMap && pMap->nWID)
1865 // Fixme: We should throw a UnknownPropertyException here.
1866 // But since this class is aggregated from classes
1867 // that support additional properties that we don't
1868 // know here we silently store *all* properties, even
1869 // if they may be not supported after creation
1870 mpPropSet->setPropertyValue( pMap, rVal );
1871 }
1872 }
1873
1874 //----------------------------------------------------------------------
1875
getPropertyValue(const OUString & PropertyName)1876 uno::Any SAL_CALL SvxShape::getPropertyValue( const OUString& PropertyName )
1877 throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1878 {
1879 if ( mpImpl->mpMaster )
1880 return mpImpl->mpMaster->getPropertyValue( PropertyName );
1881 else
1882 return _getPropertyValue( PropertyName );
1883 }
1884
1885 //----------------------------------------------------------------------
1886
_getPropertyValue(const OUString & PropertyName)1887 uno::Any SvxShape::_getPropertyValue( const OUString& PropertyName )
1888 throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1889 {
1890 OGuard aGuard( Application::GetSolarMutex() );
1891
1892 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
1893
1894 uno::Any aAny;
1895 if( mpObj.is() && mpModel )
1896 {
1897 if(pMap == NULL )
1898 throw beans::UnknownPropertyException();
1899
1900 if( !getPropertyValueImpl( PropertyName, pMap, aAny ) )
1901 {
1902 DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || (pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST), "Not persist item not handled!" );
1903 DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" );
1904
1905 SfxItemSet aSet( mpModel->GetItemPool(), pMap->nWID, pMap->nWID);
1906 aSet.Put(mpObj->GetMergedItem(pMap->nWID));
1907
1908 if(SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pMap, aAny ))
1909 return aAny;
1910
1911 if(!aSet.Count())
1912 {
1913 if(pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST)
1914 {
1915 // Not-Persistant Attribute, hole diese extra
1916 mpObj->TakeNotPersistAttr(aSet, sal_False);
1917 }
1918 }
1919
1920 if(!aSet.Count())
1921 {
1922 // Default aus ItemPool holen
1923 if(mpModel->GetItemPool().IsWhich(pMap->nWID))
1924 aSet.Put(mpModel->GetItemPool().GetDefaultItem(pMap->nWID));
1925 }
1926
1927 if(aSet.Count())
1928 aAny = GetAnyForItem( aSet, pMap );
1929 }
1930 }
1931 else
1932 {
1933
1934 // Fixme: we should return default values for OWN_ATTR !
1935
1936 if(pMap && pMap->nWID)
1937 // FixMe: see setPropertyValue
1938 aAny = mpPropSet->getPropertyValue( pMap );
1939
1940 }
1941 return aAny;
1942 }
1943
1944 //----------------------------------------------------------------------
1945
1946 // XMultiPropertySet
setPropertyValues(const::com::sun::star::uno::Sequence<::rtl::OUString> & aPropertyNames,const::com::sun::star::uno::Sequence<::com::sun::star::uno::Any> & aValues)1947 void SAL_CALL SvxShape::setPropertyValues( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aPropertyNames, const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aValues ) throw (::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
1948 {
1949 OGuard aSolarGuard( Application::GetSolarMutex() );
1950
1951 const sal_Int32 nCount = aPropertyNames.getLength();
1952 const OUString* pNames = aPropertyNames.getConstArray();
1953
1954 const uno::Any* pValues = aValues.getConstArray();
1955
1956 // make sure mbIsMultiPropertyCall and mpImpl->mpItemSet are
1957 // reseted even when an execption is thrown
1958 const ::comphelper::ScopeGuard aGuard( boost::bind( &SvxShape::endSetPropertyValues, this ) );
1959
1960 mbIsMultiPropertyCall = sal_True;
1961
1962 if( mpImpl->mpMaster )
1963 {
1964 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
1965 {
1966 try
1967 {
1968 setPropertyValue( *pNames, *pValues );
1969 }
1970 catch( beans::UnknownPropertyException& e )
1971 {
1972 (void)e;
1973 }
1974 catch( uno::Exception& ex )
1975 {
1976 (void)ex;
1977 }
1978 }
1979 }
1980 else
1981 {
1982 uno::Reference< beans::XPropertySet > xSet;
1983 queryInterface( ::getCppuType( (const uno::Reference< beans::XPropertySet >*) 0) ) >>= xSet;
1984
1985 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
1986 {
1987 try
1988 {
1989 xSet->setPropertyValue( *pNames, *pValues );
1990 }
1991 catch( beans::UnknownPropertyException& e )
1992 {
1993 (void)e;
1994 }
1995 catch( uno::Exception& ex )
1996 {
1997 (void)ex;
1998 }
1999 }
2000 }
2001
2002 if( mpImpl->mpItemSet && mpObj.is() )
2003 mpObj->SetMergedItemSetAndBroadcast( *mpImpl->mpItemSet );
2004 }
2005
2006 //----------------------------------------------------------------------
2007
endSetPropertyValues()2008 void SvxShape::endSetPropertyValues()
2009 {
2010 mbIsMultiPropertyCall = sal_False;
2011 if( mpImpl->mpItemSet )
2012 {
2013 delete mpImpl->mpItemSet;
2014 mpImpl->mpItemSet = 0;
2015 }
2016 }
2017
2018 //----------------------------------------------------------------------
2019
getPropertyValues(const::com::sun::star::uno::Sequence<::rtl::OUString> & aPropertyNames)2020 ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > SAL_CALL SvxShape::getPropertyValues( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aPropertyNames ) throw (::com::sun::star::uno::RuntimeException)
2021 {
2022 const sal_Int32 nCount = aPropertyNames.getLength();
2023 const OUString* pNames = aPropertyNames.getConstArray();
2024
2025 uno::Sequence< uno::Any > aRet( nCount );
2026 uno::Any* pValue = aRet.getArray();;
2027
2028 if( mpImpl->mpMaster )
2029 {
2030 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
2031 {
2032 try
2033 {
2034 *pValue = getPropertyValue( *pNames );
2035 }
2036 catch( uno::Exception& )
2037 {
2038 DBG_ERROR( "SvxShape::getPropertyValues, unknown property asked" );
2039 }
2040 }
2041 }
2042 else
2043 {
2044 uno::Reference< beans::XPropertySet > xSet;
2045 queryInterface( ::getCppuType( (const uno::Reference< beans::XPropertySet >*) 0) ) >>= xSet;
2046
2047 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
2048 {
2049 try
2050 {
2051 *pValue = xSet->getPropertyValue( *pNames );
2052 }
2053 catch( uno::Exception& )
2054 {
2055 DBG_ERROR( "SvxShape::getPropertyValues, unknown property asked" );
2056 }
2057 }
2058 }
2059
2060 return aRet;
2061 }
2062
addPropertiesChangeListener(const::com::sun::star::uno::Sequence<::rtl::OUString> &,const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertiesChangeListener> &)2063 void SAL_CALL SvxShape::addPropertiesChangeListener( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& , const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertiesChangeListener >& ) throw (::com::sun::star::uno::RuntimeException)
2064 {
2065 }
2066
removePropertiesChangeListener(const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertiesChangeListener> &)2067 void SAL_CALL SvxShape::removePropertiesChangeListener( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertiesChangeListener >& ) throw (::com::sun::star::uno::RuntimeException)
2068 {
2069 }
2070
firePropertiesChangeEvent(const::com::sun::star::uno::Sequence<::rtl::OUString> &,const::com::sun::star::uno::Reference<::com::sun::star::beans::XPropertiesChangeListener> &)2071 void SAL_CALL SvxShape::firePropertiesChangeEvent( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& , const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertiesChangeListener >& ) throw (::com::sun::star::uno::RuntimeException)
2072 {
2073 }
2074
2075 //----------------------------------------------------------------------
2076
GetAnyForItem(SfxItemSet & aSet,const SfxItemPropertySimpleEntry * pMap) const2077 uno::Any SvxShape::GetAnyForItem( SfxItemSet& aSet, const SfxItemPropertySimpleEntry* pMap ) const
2078 {
2079 DBG_TESTSOLARMUTEX();
2080 uno::Any aAny;
2081
2082 switch(pMap->nWID)
2083 {
2084 case SDRATTR_CIRCSTARTANGLE:
2085 {
2086 const SfxPoolItem* pPoolItem=NULL;
2087 if(aSet.GetItemState(SDRATTR_CIRCSTARTANGLE,sal_False,&pPoolItem)==SFX_ITEM_SET)
2088 {
2089 sal_Int32 nAngle = ((SdrCircStartAngleItem*)pPoolItem)->GetValue();
2090 aAny <<= nAngle;
2091 }
2092 break;
2093 }
2094
2095 case SDRATTR_CIRCENDANGLE:
2096 {
2097 const SfxPoolItem* pPoolItem=NULL;
2098 if (aSet.GetItemState(SDRATTR_CIRCENDANGLE,sal_False,&pPoolItem)==SFX_ITEM_SET)
2099 {
2100 sal_Int32 nAngle = ((SdrCircEndAngleItem*)pPoolItem)->GetValue();
2101 aAny <<= nAngle;
2102 }
2103 break;
2104 }
2105
2106 case SDRATTR_CIRCKIND:
2107 {
2108 if( mpObj->GetObjInventor() == SdrInventor)
2109 {
2110 drawing::CircleKind eKind;
2111 switch(mpObj->GetObjIdentifier())
2112 {
2113 case OBJ_CIRC: // Kreis, Ellipse
2114 eKind = drawing::CircleKind_FULL;
2115 break;
2116 case OBJ_CCUT: // Kreisabschnitt
2117 eKind = drawing::CircleKind_CUT;
2118 break;
2119 case OBJ_CARC: // Kreisbogen
2120 eKind = drawing::CircleKind_ARC;
2121 break;
2122 case OBJ_SECT: // Kreissektor
2123 eKind = drawing::CircleKind_SECTION;
2124 break;
2125 }
2126 aAny <<= eKind;
2127 }
2128 break;
2129 }
2130 default:
2131 {
2132 // Hole Wert aus ItemSet
2133 aAny = SvxItemPropertySet_getPropertyValue( *mpPropSet, pMap, aSet );
2134
2135 if( *pMap->pType != aAny.getValueType() )
2136 {
2137 // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
2138 if( ( *pMap->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) )
2139 {
2140 sal_Int32 nValue = 0;
2141 aAny >>= nValue;
2142 aAny <<= (sal_Int16)nValue;
2143 }
2144 else
2145 {
2146 DBG_ERROR("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" );
2147 }
2148 }
2149
2150 }
2151 }
2152
2153 return aAny;
2154 }
2155
2156 //----------------------------------------------------------------------
2157
2158 // XPropertyState
getPropertyState(const OUString & PropertyName)2159 beans::PropertyState SAL_CALL SvxShape::getPropertyState( const OUString& PropertyName )
2160 throw(beans::UnknownPropertyException, uno::RuntimeException)
2161 {
2162 if( mpImpl->mpMaster )
2163 {
2164 return mpImpl->mpMaster->getPropertyState( PropertyName );
2165 }
2166 else
2167 {
2168 return _getPropertyState( PropertyName );
2169 }
2170 }
2171
_getPropertyState(const OUString & PropertyName)2172 beans::PropertyState SAL_CALL SvxShape::_getPropertyState( const OUString& PropertyName )
2173 throw(beans::UnknownPropertyException, uno::RuntimeException)
2174 {
2175 OGuard aGuard( Application::GetSolarMutex() );
2176
2177 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
2178
2179 if( !mpObj.is() || pMap == NULL )
2180 throw beans::UnknownPropertyException();
2181
2182 beans::PropertyState eState;
2183 if( !getPropertyStateImpl( pMap, eState ) )
2184 {
2185 const SfxItemSet& rSet = mpObj->GetMergedItemSet();
2186
2187 switch( rSet.GetItemState( pMap->nWID, sal_False ) )
2188 {
2189 case SFX_ITEM_READONLY:
2190 case SFX_ITEM_SET:
2191 eState = beans::PropertyState_DIRECT_VALUE;
2192 break;
2193 case SFX_ITEM_DEFAULT:
2194 eState = beans::PropertyState_DEFAULT_VALUE;
2195 break;
2196 // case SFX_ITEM_UNKNOWN:
2197 // case SFX_ITEM_DONTCARE:
2198 // case SFX_ITEM_DISABLED:
2199 default:
2200 eState = beans::PropertyState_AMBIGUOUS_VALUE;
2201 break;
2202 }
2203
2204 // if a item is set, this doesn't mean we want it :)
2205 if( ( beans::PropertyState_DIRECT_VALUE == eState ) )
2206 {
2207 switch( pMap->nWID )
2208 {
2209 // the following items are disabled by changing the
2210 // fill style or the line style. so there is no need
2211 // to export items without names which should be empty
2212 case XATTR_FILLBITMAP:
2213 case XATTR_FILLGRADIENT:
2214 case XATTR_FILLHATCH:
2215 case XATTR_LINEDASH:
2216 {
2217 NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((sal_uInt16)pMap->nWID);
2218 if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) )
2219 eState = beans::PropertyState_DEFAULT_VALUE;
2220 }
2221 break;
2222
2223 // #i36115#
2224 // If e.g. the LineStart is on NONE and thus the string has length 0, it still
2225 // may be a hard attribute covering the set LineStart of the parent (Style).
2226 // #i37644#
2227 // same is for fill float transparency
2228 case XATTR_LINEEND:
2229 case XATTR_LINESTART:
2230 case XATTR_FILLFLOATTRANSPARENCE:
2231 {
2232 NameOrIndex* pItem = (NameOrIndex*)rSet.GetItem((sal_uInt16)pMap->nWID);
2233 if( pItem == NULL )
2234 eState = beans::PropertyState_DEFAULT_VALUE;
2235 }
2236 break;
2237 }
2238 }
2239 }
2240 return eState;
2241 }
2242
2243 //----------------------------------------------------------------------
2244
setPropertyValueImpl(const::rtl::OUString &,const SfxItemPropertySimpleEntry * pProperty,const::com::sun::star::uno::Any & rValue)2245 bool SvxShape::setPropertyValueImpl( const ::rtl::OUString&, const SfxItemPropertySimpleEntry* pProperty, const ::com::sun::star::uno::Any& rValue ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
2246 {
2247 switch( pProperty->nWID )
2248 {
2249 case OWN_ATTR_CAPTION_POINT:
2250 {
2251 awt::Point aPnt;
2252 if( rValue >>= aPnt )
2253 {
2254 Point aVclPoint( aPnt.X, aPnt.Y );
2255
2256 // #90763# position is relative to top left, make it absolute
2257 basegfx::B2DPolyPolygon aNewPolyPolygon;
2258 basegfx::B2DHomMatrix aNewHomogenMatrix;
2259 mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2260
2261 aVclPoint.X() += basegfx::fround(aNewHomogenMatrix.get(0, 2));
2262 aVclPoint.Y() += basegfx::fround(aNewHomogenMatrix.get(1, 2));
2263
2264 // #88657# metric of pool maybe twips (writer)
2265 ForceMetricToItemPoolMetric(aVclPoint);
2266
2267 // #88491# position relative to anchor
2268 if( mpModel->IsWriter() )
2269 {
2270 aVclPoint += mpObj->GetAnchorPos();
2271 }
2272
2273 ((SdrCaptionObj*)mpObj.get())->SetTailPos(aVclPoint);
2274
2275 return true;
2276 }
2277 break;
2278 }
2279 case OWN_ATTR_TRANSFORMATION:
2280 {
2281 drawing::HomogenMatrix3 aMatrix;
2282 if(rValue >>= aMatrix)
2283 {
2284 basegfx::B2DPolyPolygon aNewPolyPolygon;
2285 basegfx::B2DHomMatrix aNewHomogenMatrix;
2286
2287 mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2288
2289 aNewHomogenMatrix.set(0, 0, aMatrix.Line1.Column1);
2290 aNewHomogenMatrix.set(0, 1, aMatrix.Line1.Column2);
2291 aNewHomogenMatrix.set(0, 2, aMatrix.Line1.Column3);
2292 aNewHomogenMatrix.set(1, 0, aMatrix.Line2.Column1);
2293 aNewHomogenMatrix.set(1, 1, aMatrix.Line2.Column2);
2294 aNewHomogenMatrix.set(1, 2, aMatrix.Line2.Column3);
2295 aNewHomogenMatrix.set(2, 0, aMatrix.Line3.Column1);
2296 aNewHomogenMatrix.set(2, 1, aMatrix.Line3.Column2);
2297 aNewHomogenMatrix.set(2, 2, aMatrix.Line3.Column3);
2298
2299 mpObj->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2300 return true;
2301 }
2302 break;
2303 }
2304
2305 case OWN_ATTR_ZORDER:
2306 {
2307 sal_Int32 nNewOrdNum = 0;
2308 if(rValue >>= nNewOrdNum)
2309 {
2310 SdrObjList* pObjList = mpObj->GetObjList();
2311 if( pObjList )
2312 {
2313 #ifdef DBG_UTIL
2314 SdrObject* pCheck =
2315 #endif
2316 pObjList->SetObjectOrdNum( mpObj->GetOrdNum(), (sal_uIntPtr)nNewOrdNum );
2317 DBG_ASSERT( pCheck == mpObj.get(), "GetOrdNum() failed!" );
2318 }
2319 return true;
2320 }
2321 break;
2322 }
2323 case OWN_ATTR_FRAMERECT:
2324 {
2325 awt::Rectangle aUnoRect;
2326 if(rValue >>= aUnoRect)
2327 {
2328 Point aTopLeft( aUnoRect.X, aUnoRect.Y );
2329 Size aObjSize( aUnoRect.Width, aUnoRect.Height );
2330 ForceMetricToItemPoolMetric(aTopLeft);
2331 ForceMetricToItemPoolMetric(aObjSize);
2332 Rectangle aRect;
2333 aRect.SetPos(aTopLeft);
2334 aRect.SetSize(aObjSize);
2335 mpObj->SetSnapRect(aRect);
2336 return true;
2337 }
2338 break;
2339 }
2340 case OWN_ATTR_MIRRORED:
2341 {
2342 sal_Bool bMirror = sal_Bool();
2343 if(rValue >>= bMirror )
2344 {
2345 SdrGrafObj* pObj = dynamic_cast< SdrGrafObj* >( mpObj.get() );
2346 if( pObj )
2347 pObj->SetMirrored(bMirror);
2348 return true;
2349 }
2350 break;
2351 }
2352 case OWN_ATTR_EDGE_START_OBJ:
2353 case OWN_ATTR_EDGE_END_OBJ:
2354 case OWN_ATTR_GLUEID_HEAD:
2355 case OWN_ATTR_GLUEID_TAIL:
2356 case OWN_ATTR_EDGE_START_POS:
2357 case OWN_ATTR_EDGE_END_POS:
2358 case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2359 {
2360 SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >(mpObj.get());
2361 if(pEdgeObj)
2362 {
2363 switch(pProperty->nWID)
2364 {
2365 case OWN_ATTR_EDGE_START_OBJ:
2366 case OWN_ATTR_EDGE_END_OBJ:
2367 {
2368 Reference< drawing::XShape > xShape;
2369 if( rValue >>= xShape )
2370 {
2371 SdrObject* pNode = GetSdrObjectFromXShape( xShape );
2372 if( pNode )
2373 {
2374 pEdgeObj->ConnectToNode( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ, pNode );
2375 pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ, -1 );
2376 return true;
2377 }
2378 }
2379 break;
2380 }
2381
2382 case OWN_ATTR_EDGE_START_POS:
2383 case OWN_ATTR_EDGE_END_POS:
2384 {
2385 awt::Point aUnoPoint;
2386 if( rValue >>= aUnoPoint )
2387 {
2388 Point aPoint( aUnoPoint.X, aUnoPoint.Y );
2389
2390 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue i59051
2391 // perform metric change before applying anchor position,
2392 // because the anchor position is in pool metric.
2393 ForceMetricToItemPoolMetric( aPoint );
2394 // <--
2395 if( mpModel->IsWriter() )
2396 aPoint += mpObj->GetAnchorPos();
2397
2398 pEdgeObj->SetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS, aPoint );
2399 return true;
2400 }
2401 break;
2402 }
2403
2404 case OWN_ATTR_GLUEID_HEAD:
2405 case OWN_ATTR_GLUEID_TAIL:
2406 {
2407 sal_Int32 nId = 0;
2408 if( rValue >>= nId )
2409 {
2410 pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD, nId );
2411 return true;
2412 }
2413 break;
2414 }
2415 case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2416 {
2417 basegfx::B2DPolyPolygon aNewPolyPolygon;
2418
2419 // #123616# be a little bit more flexible regardin gthe data type used
2420 if( rValue.getValueType() == ::getCppuType(( const drawing::PointSequenceSequence*)0))
2421 {
2422 // get polygpon data from PointSequenceSequence
2423 aNewPolyPolygon = basegfx::tools::UnoPointSequenceSequenceToB2DPolyPolygon(
2424 *(const drawing::PointSequenceSequence*)rValue.getValue());
2425 }
2426 else if( rValue.getValueType() == ::getCppuType(( const drawing::PolyPolygonBezierCoords*)0))
2427 {
2428 // get polygpon data from PolyPolygonBezierCoords
2429 aNewPolyPolygon = basegfx::tools::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
2430 *(const drawing::PolyPolygonBezierCoords*)rValue.getValue());
2431 }
2432
2433 if(aNewPolyPolygon.count())
2434 {
2435 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue i59051
2436 ForceMetricToItemPoolMetric( aNewPolyPolygon );
2437 // <--
2438 if( mpModel->IsWriter() )
2439 {
2440 Point aPoint( mpObj->GetAnchorPos() );
2441 aNewPolyPolygon.transform(basegfx::tools::createTranslateB2DHomMatrix(aPoint.X(), aPoint.Y()));
2442 }
2443 pEdgeObj->SetEdgeTrackPath( aNewPolyPolygon );
2444 return true;
2445 }
2446 }
2447 }
2448 }
2449 break;
2450 }
2451 case OWN_ATTR_MEASURE_START_POS:
2452 case OWN_ATTR_MEASURE_END_POS:
2453 {
2454 SdrMeasureObj* pMeasureObj = dynamic_cast< SdrMeasureObj* >(mpObj.get());
2455 awt::Point aUnoPoint;
2456 if(pMeasureObj && ( rValue >>= aUnoPoint ) )
2457 {
2458 Point aPoint( aUnoPoint.X, aUnoPoint.Y );
2459
2460 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue i59051
2461 ForceMetricToItemPoolMetric( aPoint );
2462 // <--
2463 if( mpModel->IsWriter() )
2464 aPoint += mpObj->GetAnchorPos();
2465
2466 pMeasureObj->NbcSetPoint( aPoint, pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0L : 1L );
2467 pMeasureObj->SetChanged();
2468 pMeasureObj->BroadcastObjectChange();
2469 return true;
2470 }
2471 break;
2472 }
2473 case OWN_ATTR_FILLBMP_MODE:
2474 {
2475 drawing::BitmapMode eMode;
2476 if(!(rValue >>= eMode) )
2477 {
2478 sal_Int32 nMode = 0;
2479 if(!(rValue >>= nMode))
2480 break;
2481
2482 eMode = (drawing::BitmapMode)nMode;
2483 }
2484 mpObj->SetMergedItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
2485 mpObj->SetMergedItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
2486 return true;
2487 }
2488
2489 case SDRATTR_LAYERID:
2490 {
2491 sal_Int16 nLayerId = sal_Int16();
2492 if( rValue >>= nLayerId )
2493 {
2494 SdrLayer* pLayer = mpModel->GetLayerAdmin().GetLayerPerID((unsigned char)nLayerId);
2495 if( pLayer )
2496 {
2497 mpObj->SetLayer((unsigned char)nLayerId);
2498 return true;
2499 }
2500 }
2501 break;
2502 }
2503
2504 case SDRATTR_LAYERNAME:
2505 {
2506 OUString aLayerName;
2507 if( rValue >>= aLayerName )
2508 {
2509 const SdrLayer* pLayer=mpModel->GetLayerAdmin().GetLayer(aLayerName, sal_True);
2510 if( pLayer != NULL )
2511 {
2512 mpObj->SetLayer( pLayer->GetID() );
2513 return true;
2514 }
2515 }
2516 break;
2517 }
2518 case SDRATTR_ROTATEANGLE:
2519 {
2520 sal_Int32 nAngle = 0;
2521 if( rValue >>= nAngle )
2522 {
2523 Point aRef1(mpObj->GetSnapRect().Center());
2524 nAngle -= mpObj->GetRotateAngle();
2525 if (nAngle!=0)
2526 {
2527 double nSin=sin(nAngle*nPi180);
2528 double nCos=cos(nAngle*nPi180);
2529 mpObj->Rotate(aRef1,nAngle,nSin,nCos);
2530 }
2531 return true;
2532 }
2533
2534 break;
2535 }
2536
2537 case SDRATTR_SHEARANGLE:
2538 {
2539 sal_Int32 nShear = 0;
2540 if( rValue >>= nShear )
2541 {
2542 nShear -= mpObj->GetShearAngle();
2543 if(nShear != 0 )
2544 {
2545 Point aRef1(mpObj->GetSnapRect().Center());
2546 double nTan=tan(nShear*nPi180);
2547 mpObj->Shear(aRef1,nShear,nTan,sal_False);
2548 return true;
2549 }
2550 }
2551
2552 break;
2553 }
2554
2555 case SDRATTR_OBJMOVEPROTECT:
2556 {
2557 sal_Bool bMoveProtect = sal_Bool();
2558 if( rValue >>= bMoveProtect )
2559 {
2560 mpObj->SetMoveProtect(bMoveProtect);
2561 return true;
2562 }
2563 break;
2564 }
2565 case SDRATTR_OBJECTNAME:
2566 {
2567 OUString aName;
2568 if( rValue >>= aName )
2569 {
2570 mpObj->SetName( aName );
2571 return true;
2572 }
2573 break;
2574 }
2575
2576 // #i68101#
2577 case OWN_ATTR_MISC_OBJ_TITLE:
2578 {
2579 OUString aTitle;
2580 if( rValue >>= aTitle )
2581 {
2582 mpObj->SetTitle( aTitle );
2583 return true;
2584 }
2585 break;
2586 }
2587 case OWN_ATTR_MISC_OBJ_DESCRIPTION:
2588 {
2589 OUString aDescription;
2590 if( rValue >>= aDescription )
2591 {
2592 mpObj->SetDescription( aDescription );
2593 return true;
2594 }
2595 break;
2596 }
2597
2598 case SDRATTR_OBJPRINTABLE:
2599 {
2600 sal_Bool bPrintable = sal_Bool();
2601 if( rValue >>= bPrintable )
2602 {
2603 mpObj->SetPrintable(bPrintable);
2604 return true;
2605 }
2606 break;
2607 }
2608 case SDRATTR_OBJVISIBLE:
2609 {
2610 sal_Bool bVisible = sal_Bool();
2611 if( rValue >>= bVisible )
2612 {
2613 mpObj->SetVisible(bVisible);
2614 return true;
2615 }
2616 break;
2617 }
2618 case SDRATTR_OBJSIZEPROTECT:
2619 {
2620 sal_Bool bResizeProtect = sal_Bool();
2621 if( rValue >>= bResizeProtect )
2622 {
2623 mpObj->SetResizeProtect(bResizeProtect);
2624 return true;
2625 }
2626 break;
2627 }
2628 case OWN_ATTR_PAGE_NUMBER:
2629 {
2630 sal_Int32 nPageNum = 0;
2631 if( (rValue >>= nPageNum) && ( nPageNum >= 0 ) && ( nPageNum <= 0xffff ) )
2632 {
2633 SdrPageObj* pPageObj = dynamic_cast< SdrPageObj* >(mpObj.get());
2634 if( pPageObj )
2635 {
2636 SdrModel* pModel = pPageObj->GetModel();
2637 SdrPage* pNewPage = 0L;
2638 const sal_uInt16 nDestinationPageNum((sal_uInt16)((nPageNum << 1L) - 1L));
2639
2640 if(pModel)
2641 {
2642 if(nDestinationPageNum < pModel->GetPageCount())
2643 {
2644 pNewPage = pModel->GetPage(nDestinationPageNum);
2645 }
2646 }
2647
2648 pPageObj->SetReferencedPage(pNewPage);
2649 }
2650
2651 return true;
2652 }
2653 break;
2654 }
2655 case XATTR_FILLBITMAP:
2656 case XATTR_FILLGRADIENT:
2657 case XATTR_FILLHATCH:
2658 case XATTR_FILLFLOATTRANSPARENCE:
2659 case XATTR_LINEEND:
2660 case XATTR_LINESTART:
2661 case XATTR_LINEDASH:
2662 {
2663 if( pProperty->nMemberId == MID_NAME )
2664 {
2665 OUString aApiName;
2666 if( rValue >>= aApiName )
2667 {
2668 if( SetFillAttribute( pProperty->nWID, aApiName ) )
2669 return true;
2670 }
2671 break;
2672 }
2673 else
2674 {
2675 return false;
2676 }
2677 }
2678 default:
2679 {
2680 return false;
2681 }
2682 }
2683 throw lang::IllegalArgumentException();
2684 }
2685
2686 //----------------------------------------------------------------------
2687
getPropertyValueImpl(const::rtl::OUString &,const SfxItemPropertySimpleEntry * pProperty,::com::sun::star::uno::Any & rValue)2688 bool SvxShape::getPropertyValueImpl( const ::rtl::OUString&, const SfxItemPropertySimpleEntry* pProperty, ::com::sun::star::uno::Any& rValue ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
2689 {
2690 switch( pProperty->nWID )
2691 {
2692 /*
2693 case OWN_ATTR_HASLEVELS:
2694 {
2695 rValue <<= SvxTextEditSource::hasLevels( mpObj.get() );
2696 break;
2697 }
2698 */
2699 case OWN_ATTR_CAPTION_POINT:
2700 {
2701 Point aVclPoint = ((SdrCaptionObj*)mpObj.get())->GetTailPos();
2702
2703 // #88491# make pos relative to anchor
2704 if( mpModel->IsWriter() )
2705 {
2706 aVclPoint -= mpObj->GetAnchorPos();
2707 }
2708
2709 // #88657# metric of pool maybe twips (writer)
2710 ForceMetricTo100th_mm(aVclPoint);
2711
2712 // #90763# pos is absolute, make it relative to top left
2713 basegfx::B2DPolyPolygon aNewPolyPolygon;
2714 basegfx::B2DHomMatrix aNewHomogenMatrix;
2715 mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2716
2717 aVclPoint.X() -= basegfx::fround(aNewHomogenMatrix.get(0, 2));
2718 aVclPoint.Y() -= basegfx::fround(aNewHomogenMatrix.get(1, 2));
2719
2720 awt::Point aPnt( aVclPoint.X(), aVclPoint.Y() );
2721 rValue <<= aPnt;
2722 break;
2723 }
2724
2725 case OWN_ATTR_TRANSFORMATION:
2726 {
2727 basegfx::B2DPolyPolygon aNewPolyPolygon;
2728 basegfx::B2DHomMatrix aNewHomogenMatrix;
2729 mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
2730 drawing::HomogenMatrix3 aMatrix;
2731
2732 aMatrix.Line1.Column1 = aNewHomogenMatrix.get(0, 0);
2733 aMatrix.Line1.Column2 = aNewHomogenMatrix.get(0, 1);
2734 aMatrix.Line1.Column3 = aNewHomogenMatrix.get(0, 2);
2735 aMatrix.Line2.Column1 = aNewHomogenMatrix.get(1, 0);
2736 aMatrix.Line2.Column2 = aNewHomogenMatrix.get(1, 1);
2737 aMatrix.Line2.Column3 = aNewHomogenMatrix.get(1, 2);
2738 aMatrix.Line3.Column1 = aNewHomogenMatrix.get(2, 0);
2739 aMatrix.Line3.Column2 = aNewHomogenMatrix.get(2, 1);
2740 aMatrix.Line3.Column3 = aNewHomogenMatrix.get(2, 2);
2741
2742 rValue <<= aMatrix;
2743
2744 break;
2745 }
2746
2747 case OWN_ATTR_ZORDER:
2748 {
2749 rValue <<= (sal_Int32)mpObj->GetOrdNum();
2750 break;
2751 }
2752
2753 case OWN_ATTR_BITMAP:
2754 {
2755 rValue = GetBitmap();
2756 if(!rValue.hasValue())
2757 throw uno::RuntimeException();
2758
2759 break;
2760 }
2761
2762 case OWN_ATTR_ISFONTWORK:
2763 {
2764 rValue <<= (sal_Bool)(mpObj->ISA(SdrTextObj) && ((SdrTextObj*)mpObj.get())->IsFontwork());
2765 break;
2766 }
2767
2768 case OWN_ATTR_FRAMERECT:
2769 {
2770 Rectangle aRect( mpObj->GetSnapRect() );
2771 Point aTopLeft( aRect.TopLeft() );
2772 Size aObjSize( aRect.GetWidth(), aRect.GetHeight() );
2773 ForceMetricTo100th_mm(aTopLeft);
2774 ForceMetricTo100th_mm(aObjSize);
2775 ::com::sun::star::awt::Rectangle aUnoRect(
2776 aTopLeft.X(), aTopLeft.Y(),
2777 aObjSize.getWidth(), aObjSize.getHeight() );
2778 rValue <<= aUnoRect;
2779 break;
2780 }
2781
2782 case OWN_ATTR_BOUNDRECT:
2783 {
2784 Rectangle aRect( mpObj->GetCurrentBoundRect() );
2785 Point aTopLeft( aRect.TopLeft() );
2786 Size aObjSize( aRect.GetWidth(), aRect.GetHeight() );
2787 ForceMetricTo100th_mm(aTopLeft);
2788 ForceMetricTo100th_mm(aObjSize);
2789 ::com::sun::star::awt::Rectangle aUnoRect(
2790 aTopLeft.X(), aTopLeft.Y(),
2791 aObjSize.getWidth(), aObjSize.getHeight() );
2792 rValue <<= aUnoRect;
2793 break;
2794 }
2795
2796 case OWN_ATTR_LDNAME:
2797 {
2798 OUString aName( mpObj->GetName() );
2799 rValue <<= aName;
2800 break;
2801 }
2802
2803 case OWN_ATTR_LDBITMAP:
2804 {
2805 sal_uInt16 nId;
2806 if( mpObj->GetObjInventor() == SdrInventor && mpObj->GetObjIdentifier() == OBJ_OLE2 )
2807 {
2808 nId = RID_UNODRAW_OLE2;
2809 }
2810 else if( mpObj->GetObjInventor() == SdrInventor && mpObj->GetObjIdentifier() == OBJ_GRAF )
2811 {
2812 nId = RID_UNODRAW_GRAPHICS;
2813 }
2814 else
2815 {
2816 nId = RID_UNODRAW_OBJECTS;
2817 }
2818
2819 BitmapEx aBmp( SVX_RES(nId) );
2820 Reference< awt::XBitmap > xBmp( VCLUnoHelper::CreateBitmap( aBmp ) );
2821
2822 rValue <<= xBmp;
2823 break;
2824 }
2825
2826 case OWN_ATTR_MIRRORED:
2827 {
2828 sal_Bool bMirror = sal_False;
2829 if( mpObj.is() && mpObj->ISA(SdrGrafObj) )
2830 bMirror = ((SdrGrafObj*)mpObj.get())->IsMirrored();
2831
2832 rValue <<= bMirror;
2833 }
2834
2835 case OWN_ATTR_EDGE_START_OBJ:
2836 case OWN_ATTR_EDGE_START_POS:
2837 case OWN_ATTR_EDGE_END_POS:
2838 case OWN_ATTR_EDGE_END_OBJ:
2839 case OWN_ATTR_GLUEID_HEAD:
2840 case OWN_ATTR_GLUEID_TAIL:
2841 case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2842 {
2843 SdrEdgeObj* pEdgeObj = dynamic_cast<SdrEdgeObj*>(mpObj.get());
2844 if(pEdgeObj)
2845 {
2846 switch(pProperty->nWID)
2847 {
2848 case OWN_ATTR_EDGE_START_OBJ:
2849 case OWN_ATTR_EDGE_END_OBJ:
2850 {
2851 SdrObject* pNode = pEdgeObj->GetConnectedNode(pProperty->nWID == OWN_ATTR_EDGE_START_OBJ);
2852 if(pNode)
2853 {
2854 Reference< drawing::XShape > xShape( GetXShapeForSdrObject( pNode ) );
2855 if(xShape.is())
2856 rValue <<= xShape;
2857
2858 }
2859 break;
2860 }
2861
2862 case OWN_ATTR_EDGE_START_POS:
2863 case OWN_ATTR_EDGE_END_POS:
2864 {
2865 Point aPoint( pEdgeObj->GetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS ) );
2866 if( mpModel->IsWriter() )
2867 aPoint -= mpObj->GetAnchorPos();
2868
2869 ForceMetricTo100th_mm( aPoint );
2870 awt::Point aUnoPoint( aPoint.X(), aPoint.Y() );
2871
2872 rValue <<= aUnoPoint;
2873 break;
2874 }
2875 case OWN_ATTR_GLUEID_HEAD:
2876 case OWN_ATTR_GLUEID_TAIL:
2877 {
2878 rValue <<= pEdgeObj->getGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD );
2879 break;
2880 }
2881 case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
2882 {
2883 basegfx::B2DPolyPolygon aPolyPoly( pEdgeObj->GetEdgeTrackPath() );
2884 if( mpModel->IsWriter() )
2885 {
2886 Point aPoint( mpObj->GetAnchorPos() );
2887 aPolyPoly.transform(basegfx::tools::createTranslateB2DHomMatrix(-aPoint.X(), -aPoint.Y()));
2888 }
2889 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue 59051
2890 ForceMetricTo100th_mm( aPolyPoly );
2891 // <--
2892 drawing::PolyPolygonBezierCoords aRetval;
2893 SvxConvertB2DPolyPolygonToPolyPolygonBezier( aPolyPoly, aRetval);
2894 rValue <<= aRetval;
2895 break;
2896 }
2897 }
2898 }
2899 break;
2900 }
2901
2902 case OWN_ATTR_MEASURE_START_POS:
2903 case OWN_ATTR_MEASURE_END_POS:
2904 {
2905 SdrMeasureObj* pMeasureObj = dynamic_cast<SdrMeasureObj*>(mpObj.get());
2906 if(pMeasureObj)
2907 {
2908 Point aPoint( pMeasureObj->GetPoint( pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 ) );
2909 if( mpModel->IsWriter() )
2910 aPoint -= mpObj->GetAnchorPos();
2911
2912 // --> OD 2010-02-19 #i108851# - reintroduction of fix for issue 59051
2913 ForceMetricTo100th_mm( aPoint );
2914 // <--
2915 awt::Point aUnoPoint( aPoint.X(), aPoint.Y() );
2916
2917 rValue <<= aUnoPoint;
2918 break;
2919 }
2920 break;
2921 }
2922
2923 case OWN_ATTR_FILLBMP_MODE:
2924 {
2925 const SfxItemSet& rObjItemSet = mpObj->GetMergedItemSet();
2926
2927 XFillBmpStretchItem* pStretchItem = (XFillBmpStretchItem*)&rObjItemSet.Get(XATTR_FILLBMP_STRETCH);
2928 XFillBmpTileItem* pTileItem = (XFillBmpTileItem*)&rObjItemSet.Get(XATTR_FILLBMP_TILE);
2929
2930 if( pTileItem && pTileItem->GetValue() )
2931 {
2932 rValue <<= drawing::BitmapMode_REPEAT;
2933 }
2934 else if( pStretchItem && pStretchItem->GetValue() )
2935 {
2936 rValue <<= drawing::BitmapMode_STRETCH;
2937 }
2938 else
2939 {
2940 rValue <<= drawing::BitmapMode_NO_REPEAT;
2941 }
2942 break;
2943 }
2944 case SDRATTR_LAYERID:
2945 rValue <<= (sal_Int16)mpObj->GetLayer();
2946 break;
2947
2948 case SDRATTR_LAYERNAME:
2949 {
2950 SdrLayer* pLayer = mpModel->GetLayerAdmin().GetLayerPerID(mpObj->GetLayer());
2951 if( pLayer )
2952 {
2953 OUString aName( pLayer->GetName() );
2954 rValue <<= aName;
2955 }
2956 break;
2957 }
2958
2959 case SDRATTR_ROTATEANGLE:
2960 rValue <<= mpObj->GetRotateAngle();
2961 break;
2962
2963 case SDRATTR_SHEARANGLE:
2964 rValue <<= mpObj->GetShearAngle();
2965 break;
2966
2967 case SDRATTR_OBJMOVEPROTECT:
2968 rValue = uno::makeAny( (sal_Bool) mpObj->IsMoveProtect() );
2969 break;
2970
2971 case SDRATTR_OBJECTNAME:
2972 {
2973 OUString aName( mpObj->GetName() );
2974 rValue <<= aName;
2975 break;
2976 }
2977
2978 // #i68101#
2979 case OWN_ATTR_MISC_OBJ_TITLE:
2980 {
2981 OUString aTitle( mpObj->GetTitle() );
2982 rValue <<= aTitle;
2983 break;
2984 }
2985
2986 case OWN_ATTR_MISC_OBJ_DESCRIPTION:
2987 {
2988 OUString aDescription( mpObj->GetDescription() );
2989 rValue <<= aDescription;
2990 break;
2991 }
2992
2993 case SDRATTR_OBJPRINTABLE:
2994 rValue <<= static_cast<sal_Bool>( mpObj->IsPrintable() );
2995 break;
2996
2997 case SDRATTR_OBJVISIBLE:
2998 rValue <<= static_cast<sal_Bool>( mpObj->IsVisible() );
2999 break;
3000
3001 case SDRATTR_OBJSIZEPROTECT:
3002 rValue <<= static_cast<sal_Bool>( mpObj->IsResizeProtect() );
3003 break;
3004
3005 case OWN_ATTR_PAGE_NUMBER:
3006 {
3007 SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(mpObj.get());
3008 if(pPageObj)
3009 {
3010 SdrPage* pPage = pPageObj->GetReferencedPage();
3011 sal_Int32 nPageNumber = (pPage) ? pPage->GetPageNum() : 0L;
3012 nPageNumber++;
3013 nPageNumber >>= 1;
3014 rValue <<= nPageNumber;
3015 }
3016 break;
3017 }
3018
3019 case OWN_ATTR_UINAME_SINGULAR:
3020 {
3021 String aTmp;
3022 mpObj->TakeObjNameSingul( aTmp );
3023 rValue <<= OUString( aTmp );
3024 break;
3025 }
3026
3027 case OWN_ATTR_UINAME_PLURAL:
3028 {
3029 String aTmp;
3030 mpObj->TakeObjNamePlural( aTmp );
3031 rValue <<= OUString( aTmp );
3032 break;
3033 }
3034 case OWN_ATTR_METAFILE:
3035 {
3036 SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>(mpObj.get());
3037 if( pObj )
3038 {
3039 Graphic* pGraphic = pObj->GetGraphic();
3040 if( pGraphic )
3041 {
3042 sal_Bool bIsWMF = sal_False;
3043 if ( pGraphic->IsLink() )
3044 {
3045 GfxLink aLnk = pGraphic->GetLink();
3046 if ( aLnk.GetType() == GFX_LINK_TYPE_NATIVE_WMF )
3047 {
3048 bIsWMF = sal_True;
3049 uno::Sequence<sal_Int8> aSeq((sal_Int8*)aLnk.GetData(), (sal_Int32) aLnk.GetDataSize());
3050 rValue <<= aSeq;
3051 }
3052 }
3053 if ( !bIsWMF )
3054 {
3055 // #119735# just use GetGDIMetaFile, it will create a bufferd version of contained bitmap now automatically
3056 GDIMetaFile aMtf(pObj->GetGraphic()->GetGDIMetaFile());
3057 SvMemoryStream aDestStrm( 65535, 65535 );
3058 ConvertGDIMetaFileToWMF( aMtf, aDestStrm, NULL, sal_False );
3059 const uno::Sequence<sal_Int8> aSeq(
3060 static_cast< const sal_Int8* >(aDestStrm.GetData()),
3061 aDestStrm.GetEndOfData());
3062 rValue <<= aSeq;
3063 }
3064 }
3065 }
3066 else
3067 {
3068 rValue = GetBitmap( sal_True );
3069 }
3070 break;
3071 }
3072
3073
3074 default:
3075 return false;
3076 }
3077 return true;
3078 }
3079
3080 //----------------------------------------------------------------------
3081
getPropertyStateImpl(const SfxItemPropertySimpleEntry * pProperty,::com::sun::star::beans::PropertyState & rState)3082 bool SvxShape::getPropertyStateImpl( const SfxItemPropertySimpleEntry* pProperty, ::com::sun::star::beans::PropertyState& rState ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException)
3083 {
3084 if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE )
3085 {
3086 const SfxItemSet& rSet = mpObj->GetMergedItemSet();
3087
3088 if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET ||
3089 rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET )
3090 {
3091 rState = beans::PropertyState_DIRECT_VALUE;
3092 }
3093 else
3094 {
3095 rState = beans::PropertyState_AMBIGUOUS_VALUE;
3096 }
3097 }
3098 else if((( pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) ||
3099 ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST )) && ( pProperty->nWID != SDRATTR_TEXTDIRECTION ) )
3100 {
3101 rState = beans::PropertyState_DIRECT_VALUE;
3102 }
3103 else
3104 {
3105 return false;
3106 }
3107
3108 return true;
3109 }
3110
3111 //----------------------------------------------------------------------
3112
setPropertyToDefaultImpl(const SfxItemPropertySimpleEntry * pProperty)3113 bool SvxShape::setPropertyToDefaultImpl( const SfxItemPropertySimpleEntry* pProperty ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException)
3114 {
3115 if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE )
3116 {
3117 mpObj->ClearMergedItem( XATTR_FILLBMP_STRETCH );
3118 mpObj->ClearMergedItem( XATTR_FILLBMP_TILE );
3119 return true;
3120 }
3121 else if((pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) ||
3122 ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST ))
3123 {
3124 return true;
3125 }
3126 else
3127 {
3128 return false;
3129 }
3130 }
3131
3132 //----------------------------------------------------------------------
3133
getPropertyStates(const uno::Sequence<OUString> & aPropertyName)3134 uno::Sequence< beans::PropertyState > SAL_CALL SvxShape::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
3135 throw(beans::UnknownPropertyException, uno::RuntimeException)
3136 {
3137 const sal_Int32 nCount = aPropertyName.getLength();
3138 const OUString* pNames = aPropertyName.getConstArray();
3139
3140 uno::Sequence< beans::PropertyState > aRet( nCount );
3141 beans::PropertyState* pState = aRet.getArray();
3142
3143 if( mpImpl->mpMaster )
3144 {
3145 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++ )
3146 pState[nIdx] = getPropertyState( pNames[nIdx] );
3147
3148 }
3149 else
3150 {
3151 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++ )
3152 pState[nIdx] = getPropertyState( pNames[nIdx] );
3153 }
3154
3155 return aRet;
3156 }
3157
3158 //----------------------------------------------------------------------
3159
setPropertyToDefault(const OUString & PropertyName)3160 void SAL_CALL SvxShape::setPropertyToDefault( const OUString& PropertyName )
3161 throw(beans::UnknownPropertyException, uno::RuntimeException)
3162 {
3163 if( mpImpl->mpMaster )
3164 {
3165 mpImpl->mpMaster->setPropertyToDefault( PropertyName );
3166 }
3167 else
3168 {
3169 _setPropertyToDefault( PropertyName );
3170 }
3171 }
3172
_setPropertyToDefault(const OUString & PropertyName)3173 void SAL_CALL SvxShape::_setPropertyToDefault( const OUString& PropertyName )
3174 throw(beans::UnknownPropertyException, uno::RuntimeException)
3175 {
3176 OGuard aGuard( Application::GetSolarMutex() );
3177
3178 const SfxItemPropertySimpleEntry* pProperty = mpPropSet->getPropertyMapEntry(PropertyName);
3179
3180 if( !mpObj.is() || mpModel == NULL || pProperty == NULL )
3181 throw beans::UnknownPropertyException();
3182
3183 if( !setPropertyToDefaultImpl( pProperty ) )
3184 {
3185 mpObj->ClearMergedItem( pProperty->nWID );
3186 }
3187
3188 mpModel->SetChanged();
3189 }
3190
3191 //----------------------------------------------------------------------
3192
getPropertyDefault(const OUString & aPropertyName)3193 uno::Any SAL_CALL SvxShape::getPropertyDefault( const OUString& aPropertyName )
3194 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
3195 {
3196 if( mpImpl->mpMaster )
3197 {
3198 return mpImpl->mpMaster->getPropertyDefault( aPropertyName );
3199 }
3200 else
3201 {
3202 return _getPropertyDefault( aPropertyName );
3203 }
3204 }
3205
_getPropertyDefault(const OUString & aPropertyName)3206 uno::Any SAL_CALL SvxShape::_getPropertyDefault( const OUString& aPropertyName )
3207 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
3208 {
3209 OGuard aGuard( Application::GetSolarMutex() );
3210
3211 const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName);
3212
3213 if( !mpObj.is() || pMap == NULL || mpModel == NULL )
3214 throw beans::UnknownPropertyException();
3215
3216 if(( pMap->nWID >= OWN_ATTR_VALUE_START && pMap->nWID <= OWN_ATTR_VALUE_END ) ||
3217 ( pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST ))
3218 {
3219 return getPropertyValue( aPropertyName );
3220 }
3221
3222 // Default aus ItemPool holen
3223 if(!mpModel->GetItemPool().IsWhich(pMap->nWID))
3224 throw beans::UnknownPropertyException();
3225
3226 SfxItemSet aSet( mpModel->GetItemPool(), pMap->nWID, pMap->nWID);
3227 aSet.Put(mpModel->GetItemPool().GetDefaultItem(pMap->nWID));
3228
3229 return GetAnyForItem( aSet, pMap );
3230 }
3231
3232 // XMultiPropertyStates
setAllPropertiesToDefault()3233 void SvxShape::setAllPropertiesToDefault() throw (uno::RuntimeException)
3234 {
3235 OGuard aGuard( Application::GetSolarMutex() );
3236
3237 if( !mpObj.is() )
3238 throw lang::DisposedException();
3239 mpObj->ClearMergedItem(); // nWhich == 0 => all
3240
3241 if(mpObj->ISA(SdrGrafObj))
3242 {
3243 // defaults for graphic objects have changed:
3244 mpObj->SetMergedItem( XFillStyleItem( XFILL_NONE ) );
3245 mpObj->SetMergedItem( XLineStyleItem( XLINE_NONE ) );
3246 }
3247
3248 // #i68523# special handling for Svx3DCharacterModeItem, this is not saved
3249 // but needs to be sal_True in svx, pool default (false) in sch. Since sch
3250 // does not load lathe or extrude objects, it is possible to set the items
3251 // here.
3252 // For other solution possibilities, see task description.
3253 if(mpObj->ISA(E3dLatheObj) || mpObj->ISA(E3dExtrudeObj))
3254 {
3255 mpObj->SetMergedItem(Svx3DCharacterModeItem(true));
3256 }
3257
3258 mpModel->SetChanged();
3259 }
3260
setPropertiesToDefault(const uno::Sequence<OUString> & aPropertyNames)3261 void SvxShape::setPropertiesToDefault(
3262 const uno::Sequence<OUString>& aPropertyNames )
3263 throw (beans::UnknownPropertyException, uno::RuntimeException)
3264 {
3265 for ( sal_Int32 pos = 0; pos < aPropertyNames.getLength(); ++pos )
3266 setPropertyToDefault( aPropertyNames[pos] );
3267 }
3268
getPropertyDefaults(const uno::Sequence<OUString> & aPropertyNames)3269 uno::Sequence<uno::Any> SvxShape::getPropertyDefaults(
3270 const uno::Sequence<OUString>& aPropertyNames )
3271 throw (beans::UnknownPropertyException, lang::WrappedTargetException,
3272 uno::RuntimeException)
3273 {
3274 ::std::vector<uno::Any> ret;
3275 for ( sal_Int32 pos = 0; pos < aPropertyNames.getLength(); ++pos )
3276 ret.push_back( getPropertyDefault( aPropertyNames[pos] ) );
3277 return uno::Sequence<uno::Any>( &ret[0], ret.size() );
3278 }
3279
3280 //----------------------------------------------------------------------
3281
3282 //----------------------------------------------------------------------
3283 // XServiceInfo
3284 //----------------------------------------------------------------------
getImplementationName()3285 OUString SAL_CALL SvxShape::getImplementationName()
3286 throw(uno::RuntimeException)
3287 {
3288 static OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM("SvxShape") );
3289 return aServiceName;
3290 }
3291
3292 #define STAR_NAMESPACE "com.sun.star."
3293
3294 const char* sUNO_service_style_ParagraphProperties = STAR_NAMESPACE "style.ParagraphProperties";
3295 const char* sUNO_service_style_ParagraphPropertiesComplex = STAR_NAMESPACE "style.ParagraphPropertiesComplex";
3296 const char* sUNO_service_style_ParagraphPropertiesAsian = STAR_NAMESPACE "style.ParagraphPropertiesAsian";
3297 const char* sUNO_service_style_CharacterProperties = STAR_NAMESPACE "style.CharacterProperties";
3298 const char* sUNO_service_style_CharacterPropertiesComplex = STAR_NAMESPACE "style.CharacterPropertiesComplex";
3299 const char* sUNO_service_style_CharacterPropertiesAsian = STAR_NAMESPACE "style.CharacterPropertiesAsian";
3300
3301 const char* sUNO_service_drawing_FillProperties = STAR_NAMESPACE "drawing.FillProperties";
3302 const char* sUNO_service_drawing_TextProperties = STAR_NAMESPACE "drawing.TextProperties";
3303 const char* sUNO_service_drawing_LineProperties = STAR_NAMESPACE "drawing.LineProperties";
3304 const char* sUNO_service_drawing_ConnectorProperties = STAR_NAMESPACE "drawing.ConnectorProperties";
3305 const char* sUNO_service_drawing_MeasureProperties = STAR_NAMESPACE "drawing.MeasureProperties";
3306 const char* sUNO_service_drawing_ShadowProperties = STAR_NAMESPACE "drawing.ShadowProperties";
3307
3308 const char* sUNO_service_drawing_RotationDescriptor = STAR_NAMESPACE "drawing.RotationDescriptor";
3309
3310 const char* sUNO_service_drawing_Text = STAR_NAMESPACE "drawing.Text";
3311 const char* sUNO_service_drawing_GroupShape = STAR_NAMESPACE "drawing.GroupShape";
3312
3313 const char* sUNO_service_drawing_CustomShapeProperties = STAR_NAMESPACE "drawing.CustomShapeProperties";
3314 const char* sUNO_service_drawing_CustomShape = STAR_NAMESPACE "drawing.CustomShape";
3315
3316 const char* sUNO_service_drawing_PolyPolygonDescriptor = STAR_NAMESPACE "drawing.PolyPolygonDescriptor";
3317 const char* sUNO_service_drawing_PolyPolygonBezierDescriptor= STAR_NAMESPACE "drawing.PolyPolygonBezierDescriptor";
3318
3319 const char* sUNO_service_drawing_LineShape = STAR_NAMESPACE "drawing.LineShape";
3320 const char* sUNO_service_drawing_Shape = STAR_NAMESPACE "drawing.Shape";
3321 const char* sUNO_service_drawing_RectangleShape = STAR_NAMESPACE "drawing.RectangleShape";
3322 const char* sUNO_service_drawing_EllipseShape = STAR_NAMESPACE "drawing.EllipseShape";
3323 const char* sUNO_service_drawing_PolyPolygonShape = STAR_NAMESPACE "drawing.PolyPolygonShape";
3324 const char* sUNO_service_drawing_PolyLineShape = STAR_NAMESPACE "drawing.PolyLineShape";
3325 const char* sUNO_service_drawing_OpenBezierShape = STAR_NAMESPACE "drawing.OpenBezierShape";
3326 const char* sUNO_service_drawing_ClosedBezierShape = STAR_NAMESPACE "drawing.ClosedBezierShape";
3327 const char* sUNO_service_drawing_TextShape = STAR_NAMESPACE "drawing.TextShape";
3328 const char* sUNO_service_drawing_GraphicObjectShape = STAR_NAMESPACE "drawing.GraphicObjectShape";
3329 const char* sUNO_service_drawing_OLE2Shape = STAR_NAMESPACE "drawing.OLE2Shape";
3330 const char* sUNO_service_drawing_PageShape = STAR_NAMESPACE "drawing.PageShape";
3331 const char* sUNO_service_drawing_CaptionShape = STAR_NAMESPACE "drawing.CaptionShape";
3332 const char* sUNO_service_drawing_MeasureShape = STAR_NAMESPACE "drawing.MeasureShape";
3333 const char* sUNO_service_drawing_FrameShape = STAR_NAMESPACE "drawing.FrameShape";
3334 const char* sUNO_service_drawing_ControlShape = STAR_NAMESPACE "drawing.ControlShape";
3335 const char* sUNO_service_drawing_ConnectorShape = STAR_NAMESPACE "drawing.ConnectorShape";
3336 const char* sUNO_service_drawing_MediaShape = STAR_NAMESPACE "drawing.MediaShape";
3337
3338
getSupportedServiceNames()3339 uno::Sequence< OUString > SAL_CALL SvxShape::getSupportedServiceNames()
3340 throw(uno::RuntimeException)
3341 {
3342 if( mpImpl->mpMaster )
3343 {
3344 return mpImpl->mpMaster->getSupportedServiceNames();
3345 }
3346 else
3347 {
3348 return _getSupportedServiceNames();
3349 }
3350 }
3351
_getSupportedServiceNames()3352 uno::Sequence< OUString > SAL_CALL SvxShape::_getSupportedServiceNames()
3353 throw(uno::RuntimeException)
3354 {
3355 OGuard aGuard( Application::GetSolarMutex() );
3356
3357 if( mpObj.is() && mpObj->GetObjInventor() == SdrInventor)
3358 {
3359 const sal_uInt16 nIdent = mpObj->GetObjIdentifier();
3360
3361 switch(nIdent)
3362 {
3363 case OBJ_GRUP:
3364 {
3365 static uno::Sequence< OUString > *pSeq = 0;
3366 if( 0 == pSeq )
3367 {
3368 // OGuard aGuard( Application::GetSolarMutex() );
3369 // if( 0 == pSeq )
3370 {
3371 static uno::Sequence< OUString > SvxShape_GroupServices;
3372
3373 comphelper::ServiceInfoHelper::addToSequence( SvxShape_GroupServices, 2,
3374 sUNO_service_drawing_GroupShape,
3375 sUNO_service_drawing_Shape );
3376
3377 pSeq = &SvxShape_GroupServices;
3378 }
3379 }
3380
3381 return *pSeq;
3382 }
3383 case OBJ_CUSTOMSHAPE:
3384 {
3385 static uno::Sequence< OUString > *pSeq = 0;
3386 if( 0 == pSeq )
3387 {
3388 // OGuard aGuard( Application::GetSolarMutex() );
3389 // if( 0 == pSeq )
3390 {
3391 static uno::Sequence< OUString > SvxShape_CustomShapeServices;
3392
3393 comphelper::ServiceInfoHelper::addToSequence( SvxShape_CustomShapeServices, 13,
3394 sUNO_service_drawing_CustomShape,
3395 sUNO_service_drawing_Shape,
3396 sUNO_service_drawing_CustomShapeProperties,
3397 sUNO_service_drawing_FillProperties,
3398 sUNO_service_drawing_LineProperties,
3399 sUNO_service_drawing_Text,
3400 sUNO_service_drawing_TextProperties,
3401 sUNO_service_style_ParagraphProperties,
3402 sUNO_service_style_ParagraphPropertiesComplex,
3403 sUNO_service_style_ParagraphPropertiesAsian,
3404 sUNO_service_style_CharacterProperties,
3405 sUNO_service_style_CharacterPropertiesComplex,
3406 sUNO_service_style_CharacterPropertiesAsian,
3407 sUNO_service_drawing_ShadowProperties,
3408 sUNO_service_drawing_RotationDescriptor);
3409 pSeq = &SvxShape_CustomShapeServices;
3410 }
3411 }
3412 return *pSeq;
3413 }
3414 case OBJ_LINE:
3415 {
3416 static uno::Sequence< OUString > *pSeq = 0;
3417 if( 0 == pSeq )
3418 {
3419 // OGuard aGuard( Application::GetSolarMutex() );
3420 // if( 0 == pSeq )
3421 {
3422 static uno::Sequence< OUString > SvxShape_LineServices;
3423
3424 comphelper::ServiceInfoHelper::addToSequence( SvxShape_LineServices,14,
3425 sUNO_service_drawing_LineShape,
3426
3427 sUNO_service_drawing_Shape,
3428 sUNO_service_drawing_LineProperties,
3429
3430 sUNO_service_drawing_Text,
3431 sUNO_service_drawing_TextProperties,
3432 sUNO_service_style_ParagraphProperties,
3433 sUNO_service_style_ParagraphPropertiesComplex,
3434 sUNO_service_style_ParagraphPropertiesAsian,
3435 sUNO_service_style_CharacterProperties,
3436 sUNO_service_style_CharacterPropertiesComplex,
3437 sUNO_service_style_CharacterPropertiesAsian,
3438
3439 sUNO_service_drawing_PolyPolygonDescriptor,
3440 sUNO_service_drawing_ShadowProperties,
3441 sUNO_service_drawing_RotationDescriptor);
3442
3443 pSeq = &SvxShape_LineServices;
3444 }
3445 }
3446 return *pSeq;
3447 }
3448
3449 case OBJ_RECT:
3450 {
3451 static uno::Sequence< OUString > *pSeq = 0;
3452 if( 0 == pSeq )
3453 {
3454 // OGuard aGuard( Application::GetSolarMutex() );
3455 // if( 0 == pSeq )
3456 {
3457 static uno::Sequence< OUString > SvxShape_RectServices;
3458
3459 comphelper::ServiceInfoHelper::addToSequence( SvxShape_RectServices,14,
3460 sUNO_service_drawing_RectangleShape,
3461
3462 sUNO_service_drawing_Shape,
3463 sUNO_service_drawing_FillProperties,
3464 sUNO_service_drawing_LineProperties,
3465 sUNO_service_drawing_Text,
3466 sUNO_service_drawing_TextProperties,
3467 sUNO_service_style_ParagraphProperties,
3468 sUNO_service_style_ParagraphPropertiesComplex,
3469 sUNO_service_style_ParagraphPropertiesAsian,
3470 sUNO_service_style_CharacterProperties,
3471 sUNO_service_style_CharacterPropertiesComplex,
3472 sUNO_service_style_CharacterPropertiesAsian,
3473
3474 sUNO_service_drawing_ShadowProperties,
3475 sUNO_service_drawing_RotationDescriptor);
3476 pSeq = &SvxShape_RectServices;
3477 }
3478
3479 }
3480 return *pSeq;
3481 }
3482
3483 case OBJ_CIRC:
3484 case OBJ_SECT:
3485 case OBJ_CARC:
3486 case OBJ_CCUT:
3487 {
3488 static uno::Sequence< OUString > *pSeq = 0;
3489 if( 0 == pSeq )
3490 {
3491 // OGuard aGuard( Application::GetSolarMutex() );
3492 // if( 0 == pSeq )
3493 {
3494 static uno::Sequence< OUString > SvxShape_CircServices;
3495
3496 comphelper::ServiceInfoHelper::addToSequence( SvxShape_CircServices,14,
3497 sUNO_service_drawing_EllipseShape,
3498
3499 sUNO_service_drawing_Shape,
3500 sUNO_service_drawing_FillProperties,
3501 sUNO_service_drawing_LineProperties,
3502
3503 sUNO_service_drawing_Text,
3504 sUNO_service_drawing_TextProperties,
3505 sUNO_service_style_ParagraphProperties,
3506 sUNO_service_style_ParagraphPropertiesComplex,
3507 sUNO_service_style_ParagraphPropertiesAsian,
3508 sUNO_service_style_CharacterProperties,
3509 sUNO_service_style_CharacterPropertiesComplex,
3510 sUNO_service_style_CharacterPropertiesAsian,
3511
3512 sUNO_service_drawing_ShadowProperties,
3513 sUNO_service_drawing_RotationDescriptor);
3514
3515 pSeq = &SvxShape_CircServices;
3516 }
3517 }
3518
3519 return *pSeq;
3520 }
3521
3522 case OBJ_PATHPLIN:
3523 case OBJ_PLIN:
3524 {
3525 static uno::Sequence< OUString > *pSeq = 0;
3526 if( 0 == pSeq )
3527 {
3528 // OGuard aGuard( Application::GetSolarMutex() );
3529 // if( 0 == pSeq )
3530 {
3531 static uno::Sequence< OUString > SvxShape_PathServices;
3532 comphelper::ServiceInfoHelper::addToSequence( SvxShape_PathServices,14,
3533 sUNO_service_drawing_PolyLineShape,
3534
3535 sUNO_service_drawing_Shape,
3536 sUNO_service_drawing_LineProperties,
3537
3538 sUNO_service_drawing_PolyPolygonDescriptor,
3539
3540 sUNO_service_drawing_Text,
3541 sUNO_service_drawing_TextProperties,
3542 sUNO_service_style_ParagraphProperties,
3543 sUNO_service_style_ParagraphPropertiesComplex,
3544 sUNO_service_style_ParagraphPropertiesAsian,
3545 sUNO_service_style_CharacterProperties,
3546 sUNO_service_style_CharacterPropertiesComplex,
3547 sUNO_service_style_CharacterPropertiesAsian,
3548
3549 sUNO_service_drawing_ShadowProperties,
3550 sUNO_service_drawing_RotationDescriptor);
3551 pSeq = &SvxShape_PathServices;
3552 }
3553 }
3554 return *pSeq;
3555 }
3556
3557 case OBJ_PATHPOLY:
3558 case OBJ_POLY:
3559 {
3560 static uno::Sequence< OUString > *pSeq = 0;
3561 if( 0 == pSeq )
3562 {
3563 // OGuard aGuard( Application::GetSolarMutex() );
3564 // if( 0 == pSeq )
3565 {
3566 static uno::Sequence< OUString > SvxShape_PolyServices;
3567 comphelper::ServiceInfoHelper::addToSequence( SvxShape_PolyServices,15,
3568 sUNO_service_drawing_PolyPolygonShape,
3569
3570 sUNO_service_drawing_Shape,
3571 sUNO_service_drawing_LineProperties,
3572 sUNO_service_drawing_FillProperties,
3573
3574 sUNO_service_drawing_PolyPolygonDescriptor,
3575
3576 sUNO_service_drawing_Text,
3577 sUNO_service_drawing_TextProperties,
3578 sUNO_service_style_ParagraphProperties,
3579 sUNO_service_style_ParagraphPropertiesComplex,
3580 sUNO_service_style_ParagraphPropertiesAsian,
3581 sUNO_service_style_CharacterProperties,
3582 sUNO_service_style_CharacterPropertiesComplex,
3583 sUNO_service_style_CharacterPropertiesAsian,
3584
3585 sUNO_service_drawing_ShadowProperties,
3586 sUNO_service_drawing_RotationDescriptor);
3587
3588 pSeq = &SvxShape_PolyServices;
3589 }
3590 }
3591 return *pSeq;
3592 }
3593
3594 case OBJ_FREELINE:
3595 case OBJ_PATHLINE:
3596 {
3597 static uno::Sequence< OUString > *pSeq = 0;
3598 if( 0 == pSeq )
3599 {
3600 // OGuard aGuard( Application::GetSolarMutex() );
3601 // if( 0 == pSeq )
3602 {
3603 static uno::Sequence< OUString > SvxShape_FreeLineServices;
3604
3605 comphelper::ServiceInfoHelper::addToSequence( SvxShape_FreeLineServices,15,
3606 sUNO_service_drawing_OpenBezierShape,
3607
3608 sUNO_service_drawing_Shape,
3609 sUNO_service_drawing_LineProperties,
3610 sUNO_service_drawing_FillProperties,
3611
3612 sUNO_service_drawing_PolyPolygonBezierDescriptor,
3613
3614 sUNO_service_drawing_Text,
3615 sUNO_service_drawing_TextProperties,
3616 sUNO_service_style_ParagraphProperties,
3617 sUNO_service_style_ParagraphPropertiesComplex,
3618 sUNO_service_style_ParagraphPropertiesAsian,
3619 sUNO_service_style_CharacterProperties,
3620 sUNO_service_style_CharacterPropertiesComplex,
3621 sUNO_service_style_CharacterPropertiesAsian,
3622
3623 sUNO_service_drawing_ShadowProperties,
3624 sUNO_service_drawing_RotationDescriptor);
3625
3626 pSeq = &SvxShape_FreeLineServices;
3627 }
3628 }
3629
3630 return *pSeq;
3631 }
3632
3633 case OBJ_FREEFILL:
3634 case OBJ_PATHFILL:
3635 {
3636 static uno::Sequence< OUString > *pSeq = 0;
3637 if( 0 == pSeq )
3638 {
3639 // OGuard aGuard( Application::GetSolarMutex() );
3640 // if( 0 == pSeq )
3641 {
3642 static uno::Sequence< OUString > SvxShape_FreeFillServices;
3643 comphelper::ServiceInfoHelper::addToSequence( SvxShape_FreeFillServices,15,
3644 sUNO_service_drawing_ClosedBezierShape,
3645
3646 sUNO_service_drawing_Shape,
3647 sUNO_service_drawing_LineProperties,
3648 sUNO_service_drawing_FillProperties,
3649
3650 sUNO_service_drawing_PolyPolygonBezierDescriptor,
3651
3652 sUNO_service_drawing_Text,
3653 sUNO_service_drawing_TextProperties,
3654 sUNO_service_style_ParagraphProperties,
3655 sUNO_service_style_ParagraphPropertiesComplex,
3656 sUNO_service_style_ParagraphPropertiesAsian,
3657 sUNO_service_style_CharacterProperties,
3658 sUNO_service_style_CharacterPropertiesComplex,
3659 sUNO_service_style_CharacterPropertiesAsian,
3660
3661 sUNO_service_drawing_ShadowProperties,
3662 sUNO_service_drawing_RotationDescriptor);
3663
3664 pSeq = &SvxShape_FreeFillServices;
3665 }
3666 }
3667 return *pSeq;
3668 }
3669
3670 case OBJ_OUTLINETEXT:
3671 case OBJ_TITLETEXT:
3672 case OBJ_TEXT:
3673 {
3674 static uno::Sequence< OUString > *pSeq = 0;
3675 if( 0 == pSeq )
3676 {
3677 // OGuard aGuard( Application::GetSolarMutex() );
3678 // if( 0 == pSeq )
3679 {
3680 static uno::Sequence< OUString > SvxShape_TextServices;
3681 comphelper::ServiceInfoHelper::addToSequence( SvxShape_TextServices,14,
3682 sUNO_service_drawing_TextShape,
3683
3684 sUNO_service_drawing_Shape,
3685 sUNO_service_drawing_FillProperties,
3686 sUNO_service_drawing_LineProperties,
3687
3688 sUNO_service_drawing_Text,
3689 sUNO_service_drawing_TextProperties,
3690 sUNO_service_style_ParagraphProperties,
3691 sUNO_service_style_ParagraphPropertiesComplex,
3692 sUNO_service_style_ParagraphPropertiesAsian,
3693 sUNO_service_style_CharacterProperties,
3694 sUNO_service_style_CharacterPropertiesComplex,
3695 sUNO_service_style_CharacterPropertiesAsian,
3696
3697 sUNO_service_drawing_ShadowProperties,
3698 sUNO_service_drawing_RotationDescriptor);
3699
3700 pSeq = &SvxShape_TextServices;
3701 }
3702 }
3703 return *pSeq;
3704 }
3705
3706 case OBJ_GRAF:
3707 {
3708 static uno::Sequence< OUString > *pSeq = 0;
3709 if( 0 == pSeq )
3710 {
3711 // OGuard aGuard( Application::GetSolarMutex() );
3712 // if( 0 == pSeq )
3713 {
3714 static uno::Sequence< OUString > SvxShape_GrafServices;
3715 comphelper::ServiceInfoHelper::addToSequence( SvxShape_GrafServices, 12,
3716 sUNO_service_drawing_GraphicObjectShape,
3717
3718 sUNO_service_drawing_Shape,
3719
3720 sUNO_service_drawing_Text,
3721 sUNO_service_drawing_TextProperties,
3722 sUNO_service_style_ParagraphProperties,
3723 sUNO_service_style_ParagraphPropertiesComplex,
3724 sUNO_service_style_ParagraphPropertiesAsian,
3725 sUNO_service_style_CharacterProperties,
3726 sUNO_service_style_CharacterPropertiesComplex,
3727 sUNO_service_style_CharacterPropertiesAsian,
3728
3729 sUNO_service_drawing_ShadowProperties,
3730 sUNO_service_drawing_RotationDescriptor);
3731
3732 pSeq = &SvxShape_GrafServices;
3733 }
3734 }
3735 return *pSeq;
3736 }
3737
3738 case OBJ_OLE2:
3739 {
3740 static uno::Sequence< OUString > *pSeq = 0;
3741 if( 0 == pSeq )
3742 {
3743 // OGuard aGuard( Application::GetSolarMutex() );
3744 // if( 0 == pSeq )
3745 {
3746 static uno::Sequence< OUString > SvxShape_Ole2Services;
3747
3748 comphelper::ServiceInfoHelper::addToSequence( SvxShape_Ole2Services, 2,
3749 sUNO_service_drawing_OLE2Shape,
3750 sUNO_service_drawing_Shape,
3751
3752 // #i118485# Added Text, Shadow and Rotation
3753 sUNO_service_drawing_Text,
3754 sUNO_service_drawing_TextProperties,
3755 sUNO_service_style_ParagraphProperties,
3756 sUNO_service_style_ParagraphPropertiesComplex,
3757 sUNO_service_style_ParagraphPropertiesAsian,
3758 sUNO_service_style_CharacterProperties,
3759 sUNO_service_style_CharacterPropertiesComplex,
3760 sUNO_service_style_CharacterPropertiesAsian,
3761
3762 sUNO_service_drawing_ShadowProperties,
3763 sUNO_service_drawing_RotationDescriptor);
3764
3765 pSeq = &SvxShape_Ole2Services;
3766 }
3767 }
3768 return *pSeq;
3769 }
3770
3771 case OBJ_CAPTION:
3772 {
3773 static uno::Sequence< OUString > *pSeq = 0;
3774 if( 0 == pSeq )
3775 {
3776 // OGuard aGuard( Application::GetSolarMutex() );
3777 // if( 0 == pSeq )
3778 {
3779 static uno::Sequence< OUString > SvxShape_CaptionServices;
3780
3781 comphelper::ServiceInfoHelper::addToSequence( SvxShape_CaptionServices,14,
3782 sUNO_service_drawing_CaptionShape,
3783
3784 sUNO_service_drawing_Shape,
3785 sUNO_service_drawing_FillProperties,
3786 sUNO_service_drawing_LineProperties,
3787
3788 sUNO_service_drawing_Text,
3789 sUNO_service_drawing_TextProperties,
3790 sUNO_service_style_ParagraphProperties,
3791 sUNO_service_style_ParagraphPropertiesComplex,
3792 sUNO_service_style_ParagraphPropertiesAsian,
3793 sUNO_service_style_CharacterProperties,
3794 sUNO_service_style_CharacterPropertiesComplex,
3795 sUNO_service_style_CharacterPropertiesAsian,
3796
3797 sUNO_service_drawing_ShadowProperties,
3798 sUNO_service_drawing_RotationDescriptor);
3799
3800 pSeq = &SvxShape_CaptionServices;
3801 }
3802 }
3803
3804 return *pSeq;
3805 }
3806
3807 case OBJ_PAGE:
3808 {
3809 static uno::Sequence< OUString > *pSeq = 0;
3810 if( 0 == pSeq )
3811 {
3812 // OGuard aGuard( Application::GetSolarMutex() );
3813 // if( 0 == pSeq )
3814 {
3815 static uno::Sequence< OUString > SvxShape_PageServices;
3816
3817 comphelper::ServiceInfoHelper::addToSequence( SvxShape_PageServices, 2,
3818 sUNO_service_drawing_PageShape,
3819 sUNO_service_drawing_Shape );
3820
3821 pSeq = &SvxShape_PageServices;
3822 }
3823 }
3824
3825 return *pSeq;
3826 }
3827
3828 case OBJ_MEASURE:
3829 {
3830 static uno::Sequence< OUString > *pSeq = 0;
3831 if( 0 == pSeq )
3832 {
3833 // OGuard aGuard( Application::GetSolarMutex() );
3834 // if( 0 == pSeq )
3835 {
3836 static uno::Sequence< OUString > SvxShape_MeasureServices;
3837 comphelper::ServiceInfoHelper::addToSequence( SvxShape_MeasureServices,15,
3838 sUNO_service_drawing_MeasureShape,
3839
3840 sUNO_service_drawing_MeasureProperties,
3841
3842 sUNO_service_drawing_Shape,
3843 sUNO_service_drawing_LineProperties,
3844
3845 sUNO_service_drawing_Text,
3846 sUNO_service_drawing_TextProperties,
3847 sUNO_service_style_ParagraphProperties,
3848 sUNO_service_style_ParagraphPropertiesComplex,
3849 sUNO_service_style_ParagraphPropertiesAsian,
3850 sUNO_service_style_CharacterProperties,
3851 sUNO_service_style_CharacterPropertiesComplex,
3852 sUNO_service_style_CharacterPropertiesAsian,
3853
3854 sUNO_service_drawing_PolyPolygonDescriptor,
3855 sUNO_service_drawing_ShadowProperties,
3856 sUNO_service_drawing_RotationDescriptor);
3857
3858 pSeq = &SvxShape_MeasureServices;
3859 }
3860 }
3861
3862 return *pSeq;
3863 }
3864
3865 case OBJ_FRAME:
3866 {
3867 static uno::Sequence< OUString > *pSeq = 0;
3868 if( 0 == pSeq )
3869 {
3870 // OGuard aGuard( Application::GetSolarMutex() );
3871 // if( 0 == pSeq )
3872 {
3873 static uno::Sequence< OUString > SvxShape_FrameServices;
3874
3875 comphelper::ServiceInfoHelper::addToSequence( SvxShape_FrameServices, 2,
3876 sUNO_service_drawing_FrameShape,
3877 sUNO_service_drawing_Shape );
3878
3879 pSeq = &SvxShape_FrameServices;
3880 }
3881 }
3882
3883 return *pSeq;
3884 }
3885
3886 case OBJ_UNO:
3887 {
3888 static uno::Sequence< OUString > *pSeq = 0;
3889 if( 0 == pSeq )
3890 {
3891 // OGuard _aGuard( Application::GetSolarMutex() );
3892 // if( 0 == pSeq )
3893 {
3894 static uno::Sequence< OUString > SvxShape_UnoServices;
3895 comphelper::ServiceInfoHelper::addToSequence( SvxShape_UnoServices, 2,
3896 sUNO_service_drawing_ControlShape,
3897 sUNO_service_drawing_Shape );
3898
3899 pSeq = &SvxShape_UnoServices;
3900 }
3901 }
3902 return *pSeq;
3903 }
3904
3905 case OBJ_EDGE:
3906 {
3907 static uno::Sequence< OUString > *pSeq = 0;
3908 if( 0 == pSeq )
3909 {
3910 // OGuard aGuard( Application::GetSolarMutex() );
3911 // if( 0 == pSeq )
3912 {
3913 static uno::Sequence< OUString > SvxShape_EdgeServices;
3914
3915 comphelper::ServiceInfoHelper::addToSequence( SvxShape_EdgeServices,15,
3916 sUNO_service_drawing_ConnectorShape,
3917 sUNO_service_drawing_ConnectorProperties,
3918
3919 sUNO_service_drawing_Shape,
3920 sUNO_service_drawing_LineProperties,
3921
3922 sUNO_service_drawing_Text,
3923 sUNO_service_drawing_TextProperties,
3924 sUNO_service_style_ParagraphProperties,
3925 sUNO_service_style_ParagraphPropertiesComplex,
3926 sUNO_service_style_ParagraphPropertiesAsian,
3927 sUNO_service_style_CharacterProperties,
3928 sUNO_service_style_CharacterPropertiesComplex,
3929 sUNO_service_style_CharacterPropertiesAsian,
3930
3931 sUNO_service_drawing_PolyPolygonDescriptor,
3932 sUNO_service_drawing_ShadowProperties,
3933 sUNO_service_drawing_RotationDescriptor);
3934
3935 pSeq = &SvxShape_EdgeServices;
3936 }
3937 }
3938 return *pSeq;
3939 }
3940 case OBJ_MEDIA:
3941 {
3942 static uno::Sequence< OUString > *pSeq = 0;
3943 if( 0 == pSeq )
3944 {
3945 // OGuard aGuard( Application::GetSolarMutex() );
3946 // if( 0 == pSeq )
3947 {
3948 static uno::Sequence< OUString > SvxShape_MediaServices;
3949
3950 comphelper::ServiceInfoHelper::addToSequence( SvxShape_MediaServices, 2,
3951 sUNO_service_drawing_MediaShape,
3952 sUNO_service_drawing_Shape);
3953
3954 pSeq = &SvxShape_MediaServices;
3955 }
3956 }
3957 return *pSeq;
3958 }
3959 }
3960 }
3961 else if( mpObj.is() && mpObj->GetObjInventor() == FmFormInventor)
3962 {
3963 #if OSL_DEBUG_LEVEL > 0
3964 const sal_uInt16 nIdent = mpObj->GetObjIdentifier();
3965 OSL_ENSURE( nIdent == OBJ_UNO, "SvxShape::_getSupportedServiceNames: FmFormInventor, but no UNO object?" );
3966 #endif
3967 static uno::Sequence< OUString > *pSeq = 0;
3968 if( 0 == pSeq )
3969 {
3970 // OGuard aGuard( Application::GetSolarMutex() );
3971 // if( 0 == pSeq )
3972 {
3973 static uno::Sequence< OUString > SvxShape_UnoServices;
3974 comphelper::ServiceInfoHelper::addToSequence( SvxShape_UnoServices, 2,
3975 sUNO_service_drawing_ControlShape,
3976 sUNO_service_drawing_Shape );
3977
3978 pSeq = &SvxShape_UnoServices;
3979 }
3980 }
3981 return *pSeq;
3982 }
3983 OSL_ENSURE( false, "SvxShape::_getSupportedServiceNames: could not determine object type!" );
3984 uno::Sequence< OUString > aSeq;
3985 return aSeq;
3986 }
3987
3988 //----------------------------------------------------------------------
supportsService(const OUString & ServiceName)3989 sal_Bool SAL_CALL SvxShape::supportsService( const OUString& ServiceName ) throw ( uno::RuntimeException )
3990 {
3991 Sequence< OUString > SupportedServices( getSupportedServiceNames() );
3992 const ::rtl::OUString * pArray = SupportedServices.getConstArray();
3993 const sal_Int32 nCount = SupportedServices.getLength();
3994 sal_Int32 i;
3995 for( i = 0; i < nCount; i++ )
3996 if( *pArray++ == ServiceName )
3997 return sal_True;
3998 return sal_False;
3999 }
4000
4001 //----------------------------------------------------------------------
4002
4003 // XGluePointsSupplier
getGluePoints()4004 uno::Reference< container::XIndexContainer > SAL_CALL SvxShape::getGluePoints()
4005 throw(uno::RuntimeException)
4006 {
4007 OGuard aGuard( Application::GetSolarMutex() );
4008 uno::Reference< container::XIndexContainer > xGluePoints( mxGluePoints );
4009
4010 if( mpObj.is() && !xGluePoints.is() )
4011 {
4012 uno::Reference< container::XIndexContainer > xNew( SvxUnoGluePointAccess_createInstance( mpObj.get() ), uno::UNO_QUERY );
4013 mxGluePoints = xGluePoints = xNew;
4014 }
4015
4016 return xGluePoints;
4017 }
4018
4019 //----------------------------------------------------------------------
4020
4021 // XChild
getParent()4022 uno::Reference< uno::XInterface > SAL_CALL SvxShape::getParent( )
4023 throw(uno::RuntimeException)
4024 {
4025 OGuard aGuard( Application::GetSolarMutex() );
4026
4027 if( mpObj.is() && mpObj->GetObjList() )
4028 {
4029 SdrObjList* pObjList = mpObj->GetObjList();
4030
4031 switch( pObjList->GetListKind() )
4032 {
4033 case SDROBJLIST_GROUPOBJ:
4034 if( pObjList->GetOwnerObj()->ISA( SdrObjGroup ) )
4035 return PTR_CAST( SdrObjGroup, pObjList->GetOwnerObj())->getUnoShape();
4036 else if( pObjList->GetOwnerObj()->ISA( E3dScene ) )
4037 return PTR_CAST( E3dScene, pObjList->GetOwnerObj())->getUnoShape();
4038 break;
4039 case SDROBJLIST_DRAWPAGE:
4040 case SDROBJLIST_MASTERPAGE:
4041 return PTR_CAST( SdrPage, pObjList )->getUnoPage();
4042 default:
4043 DBG_ERROR( "SvxShape::getParent( ): unexpected SdrObjListKind" );
4044 break;
4045 }
4046 }
4047
4048 uno::Reference< uno::XInterface > xParent;
4049 return xParent;
4050 }
4051
4052 //----------------------------------------------------------------------
4053
setParent(const::com::sun::star::uno::Reference<::com::sun::star::uno::XInterface> &)4054 void SAL_CALL SvxShape::setParent( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& )
4055 throw(lang::NoSupportException, uno::RuntimeException)
4056 {
4057 throw lang::NoSupportException();
4058 }
4059
4060 //----------------------------------------------------------------------
4061
4062 /** called from the XActionLockable interface methods on initial locking */
lock()4063 void SvxShape::lock()
4064 {
4065 }
4066
4067 //----------------------------------------------------------------------
4068
4069 /** called from the XActionLockable interface methods on final unlock */
unlock()4070 void SvxShape::unlock()
4071 {
4072 }
4073
4074 //----------------------------------------------------------------------
4075
4076 // XActionLockable
isActionLocked()4077 sal_Bool SAL_CALL SvxShape::isActionLocked( ) throw (::com::sun::star::uno::RuntimeException)
4078 {
4079 OGuard aGuard( Application::GetSolarMutex() );
4080
4081 return mnLockCount != 0;
4082 }
4083
4084 //----------------------------------------------------------------------
4085
addActionLock()4086 void SAL_CALL SvxShape::addActionLock( ) throw (::com::sun::star::uno::RuntimeException)
4087 {
4088 OGuard aGuard( Application::GetSolarMutex() );
4089
4090 DBG_ASSERT( mnLockCount < 0xffff, "lock overflow in SvxShape!" );
4091 mnLockCount++;
4092
4093 if( mnLockCount == 1 )
4094 lock();
4095 }
4096
4097 //----------------------------------------------------------------------
4098
removeActionLock()4099 void SAL_CALL SvxShape::removeActionLock( ) throw (::com::sun::star::uno::RuntimeException)
4100 {
4101 OGuard aGuard( Application::GetSolarMutex() );
4102
4103 DBG_ASSERT( mnLockCount > 0, "lock underflow in SvxShape!" );
4104 mnLockCount--;
4105
4106 if( mnLockCount == 0 )
4107 unlock();
4108 }
4109
4110 //----------------------------------------------------------------------
4111
setActionLocks(sal_Int16 nLock)4112 void SAL_CALL SvxShape::setActionLocks( sal_Int16 nLock ) throw (::com::sun::star::uno::RuntimeException )
4113 {
4114 OGuard aGuard( Application::GetSolarMutex() );
4115
4116 if( (mnLockCount == 0) && (nLock != 0) )
4117 unlock();
4118
4119 if( (mnLockCount != 0) && (nLock == 0) )
4120 lock();
4121
4122 mnLockCount = (sal_uInt16)nLock;
4123 }
4124
4125 //----------------------------------------------------------------------
4126
resetActionLocks()4127 sal_Int16 SAL_CALL SvxShape::resetActionLocks( ) throw (::com::sun::star::uno::RuntimeException)
4128 {
4129 OGuard aGuard( Application::GetSolarMutex() );
4130
4131 if( mnLockCount != 0 )
4132 unlock();
4133
4134 sal_Int16 nOldLocks = (sal_Int16)mnLockCount;
4135 mnLockCount = 0;
4136
4137 return nOldLocks;
4138 }
4139
4140 //----------------------------------------------------------------------
4141
4142 /** since polygon shapes can change theire kind during editing, we have
4143 to recheck it here.
4144 Circle shapes also change theire kind, but theire all treated equal
4145 so no update is necessary.
4146 */
updateShapeKind()4147 void SvxShape::updateShapeKind()
4148 {
4149 switch( mpImpl->mnObjId )
4150 {
4151 case OBJ_LINE:
4152 case OBJ_POLY:
4153 case OBJ_PLIN:
4154 case OBJ_PATHLINE:
4155 case OBJ_PATHFILL:
4156 case OBJ_FREELINE:
4157 case OBJ_FREEFILL:
4158 case OBJ_PATHPOLY:
4159 case OBJ_PATHPLIN:
4160 {
4161 const sal_uInt32 nId = mpObj->GetObjIdentifier();
4162
4163 if( nId != mpImpl->mnObjId )
4164 {
4165 mpImpl->mnObjId = nId;
4166
4167 }
4168 break;
4169 }
4170 };
4171 }
4172
4173 /***********************************************************************
4174 * class SvxShapeText *
4175 ***********************************************************************/
SvxShapeText()4176 SvxShapeText::SvxShapeText() throw ()
4177 : SvxShape(NULL, aSvxMapProvider.GetMap(SVXMAP_TEXT), aSvxMapProvider.GetPropertySet(SVXMAP_TEXT, SdrObject::GetGlobalDrawObjectItemPool()) ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
4178 {
4179 }
4180
4181 //----------------------------------------------------------------------
SvxShapeText(SdrObject * pObject)4182 SvxShapeText::SvxShapeText( SdrObject* pObject ) throw ()
4183 : SvxShape( pObject, aSvxMapProvider.GetMap(SVXMAP_TEXT), aSvxMapProvider.GetPropertySet(SVXMAP_TEXT, SdrObject::GetGlobalDrawObjectItemPool()) ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
4184 {
4185 if( pObject && pObject->GetModel() )
4186 SetEditSource( new SvxTextEditSource( pObject, 0, static_cast< uno::XWeak * >( this ) ) );
4187 }
4188
4189 //----------------------------------------------------------------------
SvxShapeText(SdrObject * pObject,const SfxItemPropertyMapEntry * pPropertyMap,const SvxItemPropertySet * pPropertySet)4190 SvxShapeText::SvxShapeText( SdrObject* pObject, const SfxItemPropertyMapEntry* pPropertyMap, const SvxItemPropertySet* pPropertySet ) throw ()
4191 : SvxShape( pObject, pPropertyMap, pPropertySet ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
4192 {
4193 if( pObject && pObject->GetModel() )
4194 SetEditSource( new SvxTextEditSource( pObject, 0, static_cast< uno::XWeak * >( this ) ) );
4195 }
4196
4197 //----------------------------------------------------------------------
~SvxShapeText()4198 SvxShapeText::~SvxShapeText() throw ()
4199 {
4200 // check if only this instance is registered at the ranges
4201 DBG_ASSERT( (NULL == GetEditSource()) || (GetEditSource()->getRanges().size()==1),
4202 "svx::SvxShapeText::~SvxShapeText(), text shape with living text ranges destroyed!");
4203 }
4204
Create(SdrObject * pNewObj,SvxDrawPage * pNewPage)4205 void SvxShapeText::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
4206 {
4207 if( pNewObj && (NULL == GetEditSource()))
4208 SetEditSource( new SvxTextEditSource( pNewObj, 0, static_cast< uno::XWeak* >(this) ) );
4209
4210 SvxShape::Create( pNewObj, pNewPage );
4211 }
4212
4213 // XInterface
4214 //----------------------------------------------------------------------
queryInterface(const uno::Type & rType)4215 uno::Any SAL_CALL SvxShapeText::queryInterface( const uno::Type & rType )
4216 throw( uno::RuntimeException )
4217 {
4218 return SvxShape::queryInterface( rType );
4219 }
4220
4221 //----------------------------------------------------------------------
4222
queryAggregation(const uno::Type & rType)4223 uno::Any SAL_CALL SvxShapeText::queryAggregation( const uno::Type & rType )
4224 throw( uno::RuntimeException )
4225 {
4226 uno::Any aAny( SvxShape::queryAggregation( rType ) );
4227 if( aAny.hasValue() )
4228 return aAny;
4229
4230 return SvxUnoTextBase::queryAggregation( rType );
4231 }
4232
4233 //----------------------------------------------------------------------
4234
acquire()4235 void SAL_CALL SvxShapeText::acquire() throw()
4236 {
4237 SvxShape::acquire();
4238 }
4239
4240 //----------------------------------------------------------------------
release()4241 void SAL_CALL SvxShapeText::release() throw()
4242 {
4243 SvxShape::release();
4244 }
4245
4246 // XServiceInfo
4247 //----------------------------------------------------------------------
getImplementationName()4248 OUString SAL_CALL SvxShapeText::getImplementationName() throw( uno::RuntimeException )
4249 {
4250 static OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM("SvxShapeText") );
4251 return aServiceName;
4252 }
4253
4254 //----------------------------------------------------------------------
getSupportedServiceNames()4255 uno::Sequence< OUString > SAL_CALL SvxShapeText::getSupportedServiceNames() throw( uno::RuntimeException )
4256 {
4257 return SvxShape::getSupportedServiceNames();
4258 }
4259
4260 //----------------------------------------------------------------------
supportsService(const OUString & ServiceName)4261 sal_Bool SAL_CALL SvxShapeText::supportsService( const OUString& ServiceName ) throw ( uno::RuntimeException )
4262 {
4263 return SvxShape::supportsService(ServiceName);
4264 }
4265
4266 // XTypeProvider
4267 //----------------------------------------------------------------------
getTypes()4268 uno::Sequence< uno::Type > SAL_CALL SvxShapeText::getTypes()
4269 throw( uno::RuntimeException )
4270 {
4271 return SvxShape::getTypes();
4272 }
4273
getSomething(const::com::sun::star::uno::Sequence<sal_Int8> & rId)4274 sal_Int64 SAL_CALL SvxShapeText::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw(::com::sun::star::uno::RuntimeException) \
4275 {
4276 const sal_Int64 nReturn = SvxShape::getSomething( rId );
4277 if( nReturn )
4278 return nReturn;
4279
4280 return SvxUnoTextBase::getSomething( rId );
4281 }
4282
4283 //----------------------------------------------------------------------
getImplementationId()4284 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeText::getImplementationId()
4285 throw( uno::RuntimeException )
4286 {
4287 static ::cppu::OImplementationId* pID = NULL ;
4288
4289 if ( pID == NULL )
4290 {
4291 // Ready for multithreading; get global mutex for first call of this method only! see before
4292 MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
4293
4294 // Control these pointer again ... it can be, that another instance will be faster then these!
4295 if ( pID == NULL )
4296 {
4297 // Create a new static ID ...
4298 static ::cppu::OImplementationId aID( sal_False ) ;
4299 // ... and set his address to static pointer!
4300 pID = &aID ;
4301 }
4302 }
4303
4304 return pID->getImplementationId() ;
4305 }
4306
4307 //----------------------------------------------------------------------
4308
4309 /** called from the XActionLockable interface methods on initial locking */
lock()4310 void SvxShapeText::lock()
4311 {
4312 SvxTextEditSource* pEditSource = (SvxTextEditSource*)GetEditSource();
4313 if( pEditSource )
4314 pEditSource->lock();
4315 }
4316
4317 //----------------------------------------------------------------------
4318
4319 /** called from the XActionLockable interface methods on final unlock */
unlock()4320 void SvxShapeText::unlock()
4321 {
4322 SvxTextEditSource* pEditSource = (SvxTextEditSource*)GetEditSource();
4323 if( pEditSource )
4324 pEditSource->unlock();
4325 }
4326
4327 // ::com::sun::star::text::XTextRange
getStart()4328 uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getStart() throw(uno::RuntimeException)
4329 {
4330 ::vos::OGuard aGuard( Application::GetSolarMutex() );
4331 SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
4332 if( pForwarder )
4333 ::GetSelection( maSelection, pForwarder );
4334 return SvxUnoTextBase::getStart();
4335
4336 }
4337
getEnd()4338 uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getEnd() throw(uno::RuntimeException)
4339 {
4340 ::vos::OGuard aGuard( Application::GetSolarMutex() );
4341 SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
4342 if( pForwarder )
4343 ::GetSelection( maSelection, pForwarder );
4344 return SvxUnoTextBase::getEnd();
4345 }
4346
getString()4347 OUString SAL_CALL SvxShapeText::getString() throw(uno::RuntimeException)
4348 {
4349 ::vos::OGuard aGuard( Application::GetSolarMutex() );
4350 SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
4351 if( pForwarder )
4352 ::GetSelection( maSelection, pForwarder );
4353 return SvxUnoTextBase::getString();
4354 }
4355
4356
setString(const OUString & aString)4357 void SAL_CALL SvxShapeText::setString( const OUString& aString ) throw(uno::RuntimeException)
4358 {
4359 ::vos::OGuard aGuard( Application::GetSolarMutex() );
4360 SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
4361 if( pForwarder )
4362 ::GetSelection( maSelection, pForwarder );
4363 SvxUnoTextBase::setString( aString );
4364 }
4365
4366 // overide these for special property handling in subcasses. Return true if property is handled
setPropertyValueImpl(const::rtl::OUString & rName,const SfxItemPropertySimpleEntry * pProperty,const::com::sun::star::uno::Any & rValue)4367 bool SvxShapeText::setPropertyValueImpl( const ::rtl::OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const ::com::sun::star::uno::Any& rValue ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
4368 {
4369 // HACK-fix #99090#
4370 // since SdrTextObj::SetVerticalWriting exchanges
4371 // SDRATTR_TEXT_AUTOGROWWIDTH and SDRATTR_TEXT_AUTOGROWHEIGHT,
4372 // we have to set the textdirection here
4373
4374 if( pProperty->nWID == SDRATTR_TEXTDIRECTION )
4375 {
4376 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObj.get() );
4377 if( pTextObj )
4378 {
4379 com::sun::star::text::WritingMode eMode;
4380 if( rValue >>= eMode )
4381 {
4382 pTextObj->SetVerticalWriting( eMode == com::sun::star::text::WritingMode_TB_RL );
4383 }
4384 }
4385 return true;
4386 }
4387 return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
4388 }
4389
getPropertyValueImpl(const::rtl::OUString & rName,const SfxItemPropertySimpleEntry * pProperty,::com::sun::star::uno::Any & rValue)4390 bool SvxShapeText::getPropertyValueImpl( const ::rtl::OUString& rName, const SfxItemPropertySimpleEntry* pProperty, ::com::sun::star::uno::Any& rValue ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
4391 {
4392 if( pProperty->nWID == SDRATTR_TEXTDIRECTION )
4393 {
4394 SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObj.get() );
4395 if( pTextObj && pTextObj->IsVerticalWriting() )
4396 rValue <<= com::sun::star::text::WritingMode_TB_RL;
4397 else
4398 rValue <<= com::sun::star::text::WritingMode_LR_TB;
4399 return true;
4400 }
4401
4402 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
4403 }
4404
getPropertyStateImpl(const SfxItemPropertySimpleEntry * pProperty,::com::sun::star::beans::PropertyState & rState)4405 bool SvxShapeText::getPropertyStateImpl( const SfxItemPropertySimpleEntry* pProperty, ::com::sun::star::beans::PropertyState& rState ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException)
4406 {
4407 return SvxShape::getPropertyStateImpl( pProperty, rState );
4408 }
4409
setPropertyToDefaultImpl(const SfxItemPropertySimpleEntry * pProperty)4410 bool SvxShapeText::setPropertyToDefaultImpl( const SfxItemPropertySimpleEntry* pProperty ) throw(::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException)
4411 {
4412 return SvxShape::setPropertyToDefaultImpl( pProperty );
4413 }
4414
4415 /***********************************************************************
4416 * class SvxShapeRect *
4417 ***********************************************************************/
DBG_NAME(SvxShapeRect)4418 DBG_NAME(SvxShapeRect)
4419 SvxShapeRect::SvxShapeRect( SdrObject* pObj ) throw()
4420 : SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_SHAPE), aSvxMapProvider.GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
4421 {
4422 DBG_CTOR(SvxShapeRect,NULL);
4423 }
4424
~SvxShapeRect()4425 SvxShapeRect::~SvxShapeRect() throw()
4426 {
4427 DBG_DTOR(SvxShapeRect,NULL);
4428 }
4429
queryInterface(const uno::Type & rType)4430 uno::Any SAL_CALL SvxShapeRect::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException)
4431 {
4432 return SvxShapeText::queryInterface( rType );
4433 }
4434
queryAggregation(const uno::Type & rType)4435 uno::Any SAL_CALL SvxShapeRect::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
4436 {
4437 return SvxShapeText::queryAggregation( rType );
4438 }
4439
acquire()4440 void SAL_CALL SvxShapeRect::acquire() throw()
4441 {
4442 OWeakAggObject::acquire();
4443 }
4444
release()4445 void SAL_CALL SvxShapeRect::release() throw()
4446 {
4447 OWeakAggObject::release();
4448 }
4449 //----------------------------------------------------------------------
4450 // XServiceInfo
4451 //----------------------------------------------------------------------
getSupportedServiceNames(void)4452 uno::Sequence< OUString > SvxShapeRect::getSupportedServiceNames(void) throw( uno::RuntimeException )
4453 {
4454 return SvxShape::getSupportedServiceNames();
4455 }
4456
4457 /** returns a StarOffice API wrapper for the given SdrObject */
GetXShapeForSdrObject(SdrObject * pObj)4458 uno::Reference< drawing::XShape > GetXShapeForSdrObject( SdrObject* pObj ) throw ()
4459 {
4460 uno::Reference< drawing::XShape > xShape( pObj->getUnoShape(), uno::UNO_QUERY );
4461 return xShape;
4462 }
4463
4464 /** returns the SdrObject from the given StarOffice API wrapper */
GetSdrObjectFromXShape(uno::Reference<drawing::XShape> xShape)4465 SdrObject* GetSdrObjectFromXShape( uno::Reference< drawing::XShape > xShape ) throw()
4466 {
4467 SvxShape* pShape = SvxShape::getImplementation( xShape );
4468 return pShape ? pShape->GetSdrObject() : 0;
4469 }
4470
4471 //----------------------------------------------------------------------
4472
getSdrObjectFromXShape(const::com::sun::star::uno::Reference<::com::sun::star::uno::XInterface> & xInt)4473 SdrObject* SdrObject::getSdrObjectFromXShape( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xInt )
4474 {
4475 SvxShape* pSvxShape = SvxShape::getImplementation( xInt );
4476 return pSvxShape ? pSvxShape->GetSdrObject() : 0;
4477 }
4478
SvxItemPropertySet_getPropertyValue(const SvxItemPropertySet & rPropSet,const SfxItemPropertySimpleEntry * pMap,const SfxItemSet & rSet)4479 uno::Any SvxItemPropertySet_getPropertyValue( const SvxItemPropertySet& rPropSet, const SfxItemPropertySimpleEntry* pMap, const SfxItemSet& rSet )
4480 {
4481 if(!pMap || !pMap->nWID)
4482 return uno::Any();
4483
4484 // Check is for items that store either metric values if thei are positiv or percentage if thei are negativ.
4485 bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY );
4486 return rPropSet.getPropertyValue( pMap, rSet, (pMap->nWID != SDRATTR_XMLATTRIBUTES), bDontConvertNegativeValues );
4487 }
4488
SvxItemPropertySet_setPropertyValue(const SvxItemPropertySet & rPropSet,const SfxItemPropertySimpleEntry * pMap,const uno::Any & rVal,SfxItemSet & rSet)4489 void SvxItemPropertySet_setPropertyValue( const SvxItemPropertySet& rPropSet, const SfxItemPropertySimpleEntry* pMap, const uno::Any& rVal, SfxItemSet& rSet )
4490 {
4491 if(!pMap || !pMap->nWID)
4492 return;
4493
4494 bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY );
4495 rPropSet.setPropertyValue( pMap, rVal, rSet, bDontConvertNegativeValues );
4496 }
4497