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