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