xref: /aoo42x/main/svx/source/unodraw/unoshap2.cxx (revision fe3fb480)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26 
27 #define _SVX_USE_UNOGLOBALS_
28 #include <com/sun/star/lang/DisposedException.hpp>
29 #include <com/sun/star/awt/FontSlant.hpp>
30 #include <com/sun/star/style/VerticalAlignment.hpp>
31 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
32 #include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp>
33 #include <com/sun/star/awt/TextAlign.hpp>  //added by BerryJia for fixing Bug102407 2002-11-4
34 #include <com/sun/star/style/ParagraphAdjust.hpp>   //added by BerryJia for fixing Bug102407 2002-11-4
35 #include <com/sun/star/drawing/PointSequenceSequence.hpp>
36 #include <com/sun/star/drawing/PointSequence.hpp>
37 #include <com/sun/star/graphic/XGraphic.hpp>
38 #include <tools/urlobj.hxx>
39 #include <unotools/localfilehelper.hxx>
40 #include <vcl/svapp.hxx>
41 #include <vos/mutex.hxx>
42 #include <svtools/fltcall.hxx>
43 #include <svtools/filter.hxx>
44 
45 #include <boost/scoped_ptr.hpp>
46 #include <svx/svdpool.hxx>
47 #include <rtl/uuid.h>
48 #include <rtl/memory.h>
49 #include <tools/urlobj.hxx>
50 
51 #include <editeng/unoprnms.hxx>
52 #include <svx/unoshape.hxx>
53 #include <svx/unopage.hxx>
54 #include <svx/svdobj.hxx>
55 #include <svx/svdpage.hxx>
56 #include <svx/svdmodel.hxx>
57 #include <svx/svdouno.hxx>
58 #include "shapeimpl.hxx"
59 #include "svx/unoshprp.hxx"
60 #include <svx/svdoashp.hxx>
61 #include "unopolyhelper.hxx"
62 
63 // #i29181#
64 #include "svx/svdviter.hxx"
65 #include <svx/svdview.hxx>
66 #include <basegfx/matrix/b2dhommatrix.hxx>
67 #include <basegfx/polygon/b2dpolygon.hxx>
68 #include <basegfx/point/b2dpoint.hxx>
69 #include <basegfx/polygon/b2dpolygontools.hxx>
70 
71 using ::rtl::OUString;
72 using namespace ::osl;
73 using namespace ::vos;
74 using namespace ::cppu;
75 using namespace ::com::sun::star;
76 using namespace ::com::sun::star::uno;
77 using namespace ::com::sun::star::lang;
78 using namespace ::com::sun::star::container;
79 
80 #define INTERFACE_TYPE( xint ) \
81 	::getCppuType((const Reference< xint >*)0)
82 
83 #define QUERYINT( xint ) \
84 	if( rType == ::getCppuType((const Reference< xint >*)0) ) \
85 		aAny <<= Reference< xint >(this)
86 
87 class GDIMetaFile;
88 class SvStream;
89 sal_Bool ConvertGDIMetaFileToWMF( const GDIMetaFile & rMTF, SvStream & rTargetStream,
90 							  FilterConfigItem* pFilterConfigItem = NULL, sal_Bool bPlaceable = sal_True );
91 
92 /***********************************************************************
93 * class SvxShapeGroup                                                  *
94 ***********************************************************************/
95 
96 SvxShapeGroup::SvxShapeGroup( SdrObject* pObj, SvxDrawPage* pDrawPage  )  throw() :
97 	SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_GROUP), aSvxMapProvider.GetPropertySet(SVXMAP_GROUP, SdrObject::GetGlobalDrawObjectItemPool()) ),
98 	mxPage( pDrawPage )
99 {
100 }
101 
102 //----------------------------------------------------------------------
103 SvxShapeGroup::~SvxShapeGroup() throw()
104 {
105 }
106 
107 //----------------------------------------------------------------------
108 void SvxShapeGroup::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
109 {
110 	SvxShape::Create( pNewObj, pNewPage );
111 	mxPage = pNewPage;
112 }
113 
114 //----------------------------------------------------------------------
115 uno::Any SAL_CALL SvxShapeGroup::queryInterface( const uno::Type & rType )
116 	throw(uno::RuntimeException)
117 {
118 	return SvxShape::queryInterface( rType );
119 }
120 
121 uno::Any SAL_CALL SvxShapeGroup::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
122 {
123 	uno::Any aAny;
124 
125 	QUERYINT( drawing::XShapeGroup );
126 	else QUERYINT( drawing::XShapes );
127 	else QUERYINT( container::XIndexAccess );
128 	else QUERYINT( container::XElementAccess );
129 	else
130 		return SvxShape::queryAggregation( rType );
131 
132 	return aAny;
133 }
134 
135 void SAL_CALL SvxShapeGroup::acquire() throw ( )
136 {
137 	SvxShape::acquire();
138 }
139 
140 void SAL_CALL SvxShapeGroup::release() throw ( )
141 {
142 	SvxShape::release();
143 }
144 
145 uno::Sequence< uno::Type > SAL_CALL SvxShapeGroup::getTypes()
146 	throw (uno::RuntimeException)
147 {
148 	return SvxShape::getTypes();
149 }
150 
151 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeGroup::getImplementationId()
152 	throw (uno::RuntimeException)
153 {
154 	static uno::Sequence< sal_Int8 > aId;
155 	if( aId.getLength() == 0 )
156 	{
157 		aId.realloc( 16 );
158 		rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
159 	}
160 	return aId;
161 }
162 
163 // ::com::sun::star::drawing::XShape
164 
165 //----------------------------------------------------------------------
166 OUString SAL_CALL SvxShapeGroup::getShapeType()
167 	throw( uno::RuntimeException )
168 {
169 	return SvxShape::getShapeType();
170 }
171 
172 //------------------------------------------------------------------1----
173 awt::Point SAL_CALL SvxShapeGroup::getPosition() throw(uno::RuntimeException)
174 {
175 	return SvxShape::getPosition();
176 }
177 
178 //----------------------------------------------------------------------
179 void SAL_CALL SvxShapeGroup::setPosition( const awt::Point& Position ) throw(uno::RuntimeException)
180 {
181 	SvxShape::setPosition(Position);
182 }
183 
184 //----------------------------------------------------------------------
185 
186 awt::Size SAL_CALL SvxShapeGroup::getSize() throw(uno::RuntimeException)
187 {
188 	return SvxShape::getSize();
189 }
190 
191 //----------------------------------------------------------------------
192 void SAL_CALL SvxShapeGroup::setSize( const awt::Size& rSize )
193 	throw(beans::PropertyVetoException, uno::RuntimeException)
194 {
195 	SvxShape::setSize( rSize );
196 }
197 
198 // drawing::XShapeGroup
199 
200 //----------------------------------------------------------------------
201 void SAL_CALL SvxShapeGroup::enterGroup(  ) throw(uno::RuntimeException)
202 {
203 	// Todo
204 //	pDrView->EnterMarkedGroup();
205 }
206 
207 //----------------------------------------------------------------------
208 void SAL_CALL SvxShapeGroup::leaveGroup(  ) throw(uno::RuntimeException)
209 {
210 	// Todo
211 //	pDrView->LeaveOneGroup();
212 }
213 
214 //----------------------------------------------------------------------
215 
216 // XShapes
217 void SAL_CALL SvxShapeGroup::add( const uno::Reference< drawing::XShape >& xShape )
218 	throw( uno::RuntimeException )
219 {
220 	OGuard aGuard( Application::GetSolarMutex() );
221 
222 	SvxShape* pShape = SvxShape::getImplementation( xShape );
223 
224 	if( mpObj.is()&& mxPage.is() && pShape )
225 	{
226 		SdrObject* pSdrShape = pShape->GetSdrObject();
227 		if( pSdrShape == NULL )
228 			pSdrShape = mxPage->_CreateSdrObject( xShape );
229 
230 		if( pSdrShape->IsInserted() )
231 			pSdrShape->GetObjList()->RemoveObject( pSdrShape->GetOrdNum() );
232 
233 		mpObj->GetSubList()->InsertObject( pSdrShape );
234 		pSdrShape->SetModel(mpObj->GetModel());
235 
236 		// #85922# It makes no sense to set the layer asked
237 		// from the group object since these is an iteration
238 		// over the contained objects. In consequence, this
239 		// statement erases all layer information from the draw
240 		// objects. Layers need to be set at draw objects directly
241 		// and have nothing to do with grouping at all.
242 		// pSdrShape->SetLayer(pObject->GetLayer());
243 
244         // Establish connection between new SdrObject and its wrapper before
245         // inserting the new shape into the group.  There a new wrapper
246         // would be created when this connection would not already exist.
247 		if(pShape)
248 			pShape->Create( pSdrShape, mxPage.get() );
249 
250 		if( mpModel )
251 			mpModel->SetChanged();
252 	}
253 	else
254 	{
255 		DBG_ERROR("could not add XShape to group shape!");
256 	}
257 }
258 
259 //----------------------------------------------------------------------
260 void SAL_CALL SvxShapeGroup::remove( const uno::Reference< drawing::XShape >& xShape )
261 	throw( uno::RuntimeException )
262 {
263 	OGuard aGuard( Application::GetSolarMutex() );
264 
265 	SdrObject* pSdrShape = NULL;
266 	SvxShape* pShape = SvxShape::getImplementation( xShape );
267 
268 	if( pShape )
269 		pSdrShape = pShape->GetSdrObject();
270 
271 	if( !mpObj.is() || pSdrShape == NULL || pSdrShape->GetObjList()->GetOwnerObj() != mpObj.get() )
272 		throw uno::RuntimeException();
273 
274 	SdrObjList& rList = *pSdrShape->GetObjList();
275 
276 	const sal_uInt32 nObjCount = rList.GetObjCount();
277 	sal_uInt32 nObjNum = 0;
278 	while( nObjNum < nObjCount )
279 	{
280 		if(rList.GetObj( nObjNum ) == pSdrShape )
281 			break;
282 		nObjNum++;
283 	}
284 
285 	if( nObjNum < nObjCount )
286 	{
287 		// #i29181#
288 		// If the SdrObject which is about to be deleted is in any selection,
289 		// deselect it first.
290         SdrViewIter aIter( pSdrShape );
291 
292 		for ( SdrView* pView = aIter.FirstView(); pView; pView = aIter.NextView() )
293 		{
294 			if(CONTAINER_ENTRY_NOTFOUND != pView->TryToFindMarkedObject(pSdrShape))
295 			{
296 				pView->MarkObj(pSdrShape, pView->GetSdrPageView(), sal_True, sal_False);
297 			}
298 		}
299 
300 		SdrObject* pObject = rList.NbcRemoveObject( nObjNum );
301         SdrObject::Free( pObject );
302 	}
303 	else
304 	{
305 		DBG_ASSERT( 0, "Fatality! SdrObject is not belonging to its SdrObjList! [CL]" );
306 	}
307 
308 	if( mpModel )
309 		mpModel->SetChanged();
310 }
311 
312 // XIndexAccess
313 
314 //----------------------------------------------------------------------
315 sal_Int32 SAL_CALL SvxShapeGroup::getCount() throw( uno::RuntimeException )
316 {
317 	OGuard aGuard( Application::GetSolarMutex() );
318 
319 	sal_Int32 nRetval = 0;
320 
321 	if(mpObj.is() && mpObj->GetSubList())
322 		nRetval = mpObj->GetSubList()->GetObjCount();
323 	else
324 		throw uno::RuntimeException();
325 
326 	return nRetval;
327 }
328 
329 //----------------------------------------------------------------------
330 uno::Any SAL_CALL SvxShapeGroup::getByIndex( sal_Int32 Index )
331 	throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException )
332 {
333 	OGuard aGuard( Application::GetSolarMutex() );
334 
335 	if( !mpObj.is() || mpObj->GetSubList() == NULL )
336 		throw uno::RuntimeException();
337 
338 	if( mpObj->GetSubList()->GetObjCount() <= (sal_uInt32)Index )
339 		throw lang::IndexOutOfBoundsException();
340 
341 	SdrObject* pDestObj = mpObj->GetSubList()->GetObj( Index );
342 
343 	if(pDestObj == NULL)
344 		throw lang::IndexOutOfBoundsException();
345 
346 	Reference< drawing::XShape > xShape( pDestObj->getUnoShape(), uno::UNO_QUERY );
347 	return uno::makeAny( xShape );
348 }
349 
350 // ::com::sun::star::container::XElementAccess
351 
352 //----------------------------------------------------------------------
353 uno::Type SAL_CALL SvxShapeGroup::getElementType() throw( uno::RuntimeException )
354 {
355 	return ::getCppuType(( const Reference< drawing::XShape >*)0);
356 }
357 
358 //----------------------------------------------------------------------
359 sal_Bool SAL_CALL SvxShapeGroup::hasElements() throw( uno::RuntimeException )
360 {
361 	OGuard aGuard( Application::GetSolarMutex() );
362 
363 	return mpObj.is() && mpObj->GetSubList() && (mpObj->GetSubList()->GetObjCount() > 0);
364 }
365 
366 //----------------------------------------------------------------------
367 // ::com::sun::star::lang::XServiceInfo
368 
369 uno::Sequence< OUString > SAL_CALL SvxShapeGroup::getSupportedServiceNames()
370 	throw(uno::RuntimeException)
371 {
372 	return SvxShape::getSupportedServiceNames();
373 }
374 
375 /***********************************************************************
376 *                                                                      *
377 ***********************************************************************/
378 
379 SvxShapeConnector::SvxShapeConnector( SdrObject* pObj )  throw() :
380 	SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_CONNECTOR), aSvxMapProvider.GetPropertySet(SVXMAP_CONNECTOR, SdrObject::GetGlobalDrawObjectItemPool()) )
381 {
382 }
383 
384 //----------------------------------------------------------------------
385 SvxShapeConnector::~SvxShapeConnector() throw()
386 {
387 }
388 
389 //----------------------------------------------------------------------
390 
391 uno::Any SAL_CALL SvxShapeConnector::queryInterface( const uno::Type & rType )
392 	throw(uno::RuntimeException)
393 {
394 	return SvxShapeText::queryInterface( rType );
395 }
396 
397 uno::Any SAL_CALL SvxShapeConnector::queryAggregation( const uno::Type & rType )
398 	throw(uno::RuntimeException)
399 {
400 	uno::Any aAny;
401 
402 	QUERYINT( drawing::XConnectorShape );
403 	else
404 		return SvxShapeText::queryAggregation( rType );
405 
406 	return aAny;
407 }
408 
409 void SAL_CALL SvxShapeConnector::acquire() throw ( )
410 {
411 	SvxShapeText::acquire();
412 }
413 
414 void SAL_CALL SvxShapeConnector::release() throw ( )
415 {
416 	SvxShapeText::release();
417 }
418 // XTypeProvider
419 
420 uno::Sequence< uno::Type > SAL_CALL SvxShapeConnector::getTypes()
421 	throw (uno::RuntimeException)
422 {
423 	return SvxShape::getTypes();
424 }
425 
426 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeConnector::getImplementationId()
427 	throw (uno::RuntimeException)
428 {
429 	static uno::Sequence< sal_Int8 > aId;
430 	if( aId.getLength() == 0 )
431 	{
432 		aId.realloc( 16 );
433 		rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
434 	}
435 	return aId;
436 }
437 
438 // ::com::sun::star::drawing::XShape
439 
440 //----------------------------------------------------------------------
441 OUString SAL_CALL SvxShapeConnector::getShapeType()
442 	throw( uno::RuntimeException )
443 {
444 	return SvxShapeText::getShapeType();
445 }
446 
447 //------------------------------------------------------------------1----
448 awt::Point SAL_CALL SvxShapeConnector::getPosition() throw(uno::RuntimeException)
449 {
450 	return SvxShapeText::getPosition();
451 }
452 
453 //----------------------------------------------------------------------
454 void SAL_CALL SvxShapeConnector::setPosition( const awt::Point& Position ) throw(uno::RuntimeException)
455 {
456 	SvxShapeText::setPosition(Position);
457 }
458 
459 //----------------------------------------------------------------------
460 
461 awt::Size SAL_CALL SvxShapeConnector::getSize() throw(uno::RuntimeException)
462 {
463 	return SvxShapeText::getSize();
464 }
465 
466 //----------------------------------------------------------------------
467 void SAL_CALL SvxShapeConnector::setSize( const awt::Size& rSize )
468 	throw(beans::PropertyVetoException, uno::RuntimeException)
469 {
470 	SvxShapeText::setSize( rSize );
471 }
472 
473 //----------------------------------------------------------------------
474 
475 // XConnectorShape
476 
477 void SAL_CALL SvxShapeConnector::connectStart( const uno::Reference< drawing::XConnectableShape >& xShape, drawing::ConnectionType ) throw( uno::RuntimeException )
478 {
479 	OGuard aGuard( Application::GetSolarMutex() );
480 
481 	Reference< drawing::XShape > xRef( xShape, UNO_QUERY );
482 	SvxShape* pShape = SvxShape::getImplementation( xRef );
483 
484 	if( pShape )
485 		mpObj->ConnectToNode( sal_True, pShape->mpObj.get() );
486 
487 	if( mpModel )
488 		mpModel->SetChanged();
489 }
490 
491 //----------------------------------------------------------------------
492 void SAL_CALL SvxShapeConnector::connectEnd( const uno::Reference< drawing::XConnectableShape >& xShape, drawing::ConnectionType  )
493 	throw( uno::RuntimeException )
494 {
495 	OGuard aGuard( Application::GetSolarMutex() );
496 
497 	Reference< drawing::XShape > xRef( xShape, UNO_QUERY );
498 	SvxShape* pShape = SvxShape::getImplementation( xRef );
499 
500 	if( mpObj.is() && pShape )
501 		mpObj->ConnectToNode( sal_False, pShape->mpObj.get() );
502 
503 	if( mpModel )
504 		mpModel->SetChanged();
505 }
506 
507 //----------------------------------------------------------------------
508 void SAL_CALL SvxShapeConnector::disconnectBegin( const uno::Reference< drawing::XConnectableShape >&  )
509 	throw( uno::RuntimeException )
510 {
511 	OGuard aGuard( Application::GetSolarMutex() );
512 
513 	if(mpObj.is())
514 		mpObj->DisconnectFromNode( sal_True );
515 
516 	if( mpModel )
517 		mpModel->SetChanged();
518 }
519 
520 //----------------------------------------------------------------------
521 void SAL_CALL SvxShapeConnector::disconnectEnd( const uno::Reference< drawing::XConnectableShape >& )
522 	throw( uno::RuntimeException )
523 {
524 	OGuard aGuard( Application::GetSolarMutex() );
525 
526 	if(mpObj.is())
527 		mpObj->DisconnectFromNode( sal_False );
528 
529 	if( mpModel )
530 		mpModel->SetChanged();
531 }
532 
533 //----------------------------------------------------------------------
534 // ::com::sun::star::lang::XServiceInfo
535 //----------------------------------------------------------------------
536 uno::Sequence< OUString > SAL_CALL SvxShapeConnector::getSupportedServiceNames() throw( uno::RuntimeException )
537 {
538 	return SvxShapeText::getSupportedServiceNames();
539 }
540 
541 /***********************************************************************
542 * class SvxShapeControl                                                *
543 ***********************************************************************/
544 DBG_NAME(SvxShapeControl)
545 
546 SvxShapeControl::SvxShapeControl( SdrObject* pObj )  throw() :
547 	SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_CONTROL), aSvxMapProvider.GetPropertySet(SVXMAP_CONTROL, SdrObject::GetGlobalDrawObjectItemPool()) )
548 {
549     DBG_CTOR(SvxShapeControl,NULL);
550 	setShapeKind( OBJ_UNO );
551 }
552 
553 //----------------------------------------------------------------------
554 SvxShapeControl::~SvxShapeControl() throw()
555 {
556     DBG_DTOR(SvxShapeControl,NULL);
557 }
558 
559 //----------------------------------------------------------------------
560 uno::Any SAL_CALL SvxShapeControl::queryInterface( const uno::Type & rType )
561 	throw(uno::RuntimeException)
562 {
563 	return SvxShapeText::queryInterface( rType );
564 }
565 
566 uno::Any SAL_CALL SvxShapeControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
567 {
568 	uno::Any aAny;
569 
570 	QUERYINT( drawing::XControlShape );
571 	else
572 		return SvxShapeText::queryAggregation( rType );
573 
574 	return aAny;
575 }
576 
577 void SAL_CALL SvxShapeControl::acquire() throw ( )
578 {
579 	SvxShapeText::acquire();
580 }
581 
582 void SAL_CALL SvxShapeControl::release() throw ( )
583 {
584 	SvxShapeText::release();
585 }
586 // XTypeProvider
587 
588 uno::Sequence< uno::Type > SAL_CALL SvxShapeControl::getTypes()
589 	throw (uno::RuntimeException)
590 {
591 	return SvxShape::getTypes();
592 }
593 
594 uno::Sequence< sal_Int8 > SAL_CALL SvxShapeControl::getImplementationId()
595 	throw (uno::RuntimeException)
596 {
597 	static uno::Sequence< sal_Int8 > aId;
598 	if( aId.getLength() == 0 )
599 	{
600 		aId.realloc( 16 );
601 		rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
602 	}
603 	return aId;
604 }
605 
606 // ::com::sun::star::drawing::XShape
607 
608 //----------------------------------------------------------------------
609 OUString SAL_CALL SvxShapeControl::getShapeType()
610 	throw( uno::RuntimeException )
611 {
612 	return SvxShapeText::getShapeType();
613 }
614 
615 //------------------------------------------------------------------1----
616 awt::Point SAL_CALL SvxShapeControl::getPosition() throw(uno::RuntimeException)
617 {
618 	return SvxShapeText::getPosition();
619 }
620 
621 //----------------------------------------------------------------------
622 void SAL_CALL SvxShapeControl::setPosition( const awt::Point& Position ) throw(uno::RuntimeException)
623 {
624 	SvxShapeText::setPosition(Position);
625 }
626 
627 //----------------------------------------------------------------------
628 
629 awt::Size SAL_CALL SvxShapeControl::getSize() throw(uno::RuntimeException)
630 {
631 	return SvxShapeText::getSize();
632 }
633 
634 //----------------------------------------------------------------------
635 void SAL_CALL SvxShapeControl::setSize( const awt::Size& rSize )
636 	throw(beans::PropertyVetoException, uno::RuntimeException)
637 {
638 	SvxShapeText::setSize( rSize );
639 }
640 
641 //----------------------------------------------------------------------
642 // XControlShape
643 
644 Reference< awt::XControlModel > SAL_CALL SvxShapeControl::getControl()
645 	throw( uno::RuntimeException )
646 {
647 	OGuard aGuard( Application::GetSolarMutex() );
648 
649 	Reference< awt::XControlModel > xModel;
650 
651 	SdrUnoObj* pUnoObj = dynamic_cast< SdrUnoObj * >(mpObj.get());
652 	if( pUnoObj )
653 		xModel = pUnoObj->GetUnoControlModel();
654 
655 	return xModel;
656 }
657 
658 //----------------------------------------------------------------------
659 void SAL_CALL SvxShapeControl::setControl( const Reference< awt::XControlModel >& xControl )
660 	throw( uno::RuntimeException )
661 {
662 	OGuard aGuard( Application::GetSolarMutex() );
663 
664 	SdrUnoObj* pUnoObj = dynamic_cast< SdrUnoObj * >(mpObj.get());
665 	if( pUnoObj )
666 		pUnoObj->SetUnoControlModel( xControl );
667 
668 	if( mpModel )
669 		mpModel->SetChanged();
670 }
671 
672 // XServiceInfo
673 uno::Sequence< OUString > SAL_CALL SvxShapeControl::getSupportedServiceNames() throw( uno::RuntimeException )
674 {
675 	return SvxShapeText::getSupportedServiceNames();
676 }
677 
678 static struct
679 {
680 	const sal_Char* mpAPIName;
681 	sal_uInt16 mnAPINameLen;
682 
683 	const sal_Char* mpFormName;
684 	sal_uInt16 mnFormNameLen;
685 }
686 SvxShapeControlPropertyMapping[] =
687 {
688 	// Warning: The first entry must be FontSlant because the any needs to be converted
689 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_POSTURE), MAP_CHAR_LEN("FontSlant")  }, //  const sal_Int16 => ::com::sun::star::awt::FontSlant
690 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_FONTNAME), MAP_CHAR_LEN("FontName") },
691 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_FONTSTYLENAME), MAP_CHAR_LEN("FontStyleName") },
692 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_FONTFAMILY), MAP_CHAR_LEN("FontFamily") },
693 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_FONTCHARSET), MAP_CHAR_LEN("FontCharset") },
694 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_HEIGHT), MAP_CHAR_LEN("FontHeight") },
695 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_FONTPITCH), MAP_CHAR_LEN("FontPitch" ) },
696 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_WEIGHT), MAP_CHAR_LEN("FontWeight" ) },
697 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_UNDERLINE), MAP_CHAR_LEN("FontUnderline") },
698 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_STRIKEOUT), MAP_CHAR_LEN("FontStrikeout") },
699 	{ MAP_CHAR_LEN("CharKerning"), MAP_CHAR_LEN("FontKerning") },
700 	{ MAP_CHAR_LEN("CharWordMode"), MAP_CHAR_LEN("FontWordLineMode" ) },
701 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_CHAR_COLOR),	MAP_CHAR_LEN("TextColor") },
702 	{ MAP_CHAR_LEN("CharRelief"),	MAP_CHAR_LEN("FontRelief") },
703 	{ MAP_CHAR_LEN("CharUnderlineColor"),	MAP_CHAR_LEN("TextLineColor") },
704 	{ MAP_CHAR_LEN(UNO_NAME_EDIT_PARA_ADJUST), MAP_CHAR_LEN("Align") },
705     { MAP_CHAR_LEN("TextVerticalAdjust"), MAP_CHAR_LEN("VerticalAlign") },
706 	{ MAP_CHAR_LEN("ControlBackground"), MAP_CHAR_LEN("BackgroundColor") },
707 	{ MAP_CHAR_LEN("ControlSymbolColor"), MAP_CHAR_LEN("SymbolColor") },
708 	{ MAP_CHAR_LEN("ControlBorder"), MAP_CHAR_LEN("Border") },
709 	{ MAP_CHAR_LEN("ControlBorderColor"), MAP_CHAR_LEN("BorderColor") },
710 	{ MAP_CHAR_LEN("ControlTextEmphasis"),	MAP_CHAR_LEN("FontEmphasisMark") },
711     { MAP_CHAR_LEN("ImageScaleMode"),  MAP_CHAR_LEN("ScaleMode") },
712 	{ MAP_CHAR_LEN("ControlWritingMode"), MAP_CHAR_LEN("WritingMode") },
713 	//added for exporting OCX control
714 	{ MAP_CHAR_LEN("ControlTypeinMSO"), MAP_CHAR_LEN("ControlTypeinMSO") },
715 	{ MAP_CHAR_LEN("ObjIDinMSO"), MAP_CHAR_LEN("ObjIDinMSO") },
716 	{ NULL,0, NULL, 0 }
717 };
718 
719 namespace
720 {
721     static bool lcl_convertPropertyName( const OUString& rApiName, OUString& rInternalName )
722     {
723 	    sal_uInt16 i = 0;
724 	    while( SvxShapeControlPropertyMapping[i].mpAPIName )
725 	    {
726 		    if( rApiName.reverseCompareToAsciiL( SvxShapeControlPropertyMapping[i].mpAPIName, SvxShapeControlPropertyMapping[i].mnAPINameLen ) == 0 )
727 		    {
728 			    rInternalName = OUString( SvxShapeControlPropertyMapping[i].mpFormName, SvxShapeControlPropertyMapping[i].mnFormNameLen, RTL_TEXTENCODING_ASCII_US );
729 		    }
730 		    ++i;
731 	    }
732         return rInternalName.getLength() > 0;
733     }
734 
735     struct EnumConversionMap
736     {
737         sal_Int16   nAPIValue;
738         sal_Int16   nFormValue;
739     };
740 
741     EnumConversionMap aMapAdjustToAlign[] =
742     {
743 	    // note that order matters:
744 	    // lcl_convertTextAlignmentToParaAdjustment and lcl_convertParaAdjustmentToTextAlignment search this map from the _beginning_
745 	    // and use the first matching entry
746 	    {style::ParagraphAdjust_LEFT,			(sal_Int16)awt::TextAlign::LEFT},
747 	    {style::ParagraphAdjust_CENTER,			(sal_Int16)awt::TextAlign::CENTER},
748 	    {style::ParagraphAdjust_RIGHT,			(sal_Int16)awt::TextAlign::RIGHT},
749 	    {style::ParagraphAdjust_BLOCK,			(sal_Int16)awt::TextAlign::RIGHT},
750 	    {style::ParagraphAdjust_STRETCH,		(sal_Int16)awt::TextAlign::LEFT},
751 	    {-1,-1}
752     };
753 
754     static void lcl_mapFormToAPIValue( Any& _rValue, const EnumConversionMap* _pMap )
755     {
756 	    sal_Int16 nValue = sal_Int16();
757 	    OSL_VERIFY( _rValue >>= nValue );
758 
759         const EnumConversionMap* pEntry = _pMap;
760         while ( pEntry && ( pEntry->nFormValue != -1 ) )
761 	    {
762 		    if ( nValue == pEntry->nFormValue )
763 		    {
764 			    _rValue <<= pEntry->nAPIValue;
765 			    return;
766 		    }
767             ++pEntry;
768 	    }
769     }
770 
771     static void lcl_mapAPIToFormValue( Any& _rValue, const EnumConversionMap* _pMap )
772     {
773 	    sal_Int32 nValue = 0;
774 	    OSL_VERIFY( _rValue >>= nValue );
775 
776         const EnumConversionMap* pEntry = _pMap;
777         while ( pEntry && ( pEntry->nAPIValue != -1 ) )
778 	    {
779 		    if ( nValue == pEntry->nAPIValue )
780 		    {
781 			    _rValue <<= pEntry->nFormValue;
782 			    return;
783 		    }
784             ++pEntry;
785 	    }
786     }
787 
788     static void lcl_convertTextAlignmentToParaAdjustment( Any& rValue )
789     {
790         lcl_mapFormToAPIValue( rValue, aMapAdjustToAlign );
791     }
792 
793     static void lcl_convertParaAdjustmentToTextAlignment( Any& rValue )
794     {
795         lcl_mapAPIToFormValue( rValue, aMapAdjustToAlign );
796     }
797 
798     void convertVerticalAdjustToVerticalAlign( Any& _rValue ) SAL_THROW( ( lang::IllegalArgumentException ) )
799     {
800         if ( !_rValue.hasValue() )
801             return;
802 
803         drawing::TextVerticalAdjust eAdjust = drawing::TextVerticalAdjust_TOP;
804         style::VerticalAlignment    eAlign  = style::VerticalAlignment_TOP;
805         if ( !( _rValue >>= eAdjust ) )
806             throw lang::IllegalArgumentException();
807         switch ( eAdjust )
808         {
809         case drawing::TextVerticalAdjust_TOP:    eAlign = style::VerticalAlignment_TOP; break;
810         case drawing::TextVerticalAdjust_BOTTOM: eAlign = style::VerticalAlignment_BOTTOM; break;
811         default:                                 eAlign = style::VerticalAlignment_MIDDLE; break;
812         }
813         _rValue <<= eAlign;
814     }
815 
816     void convertVerticalAlignToVerticalAdjust( Any& _rValue )
817     {
818         if ( !_rValue.hasValue() )
819             return;
820         style::VerticalAlignment    eAlign  = style::VerticalAlignment_TOP;
821         drawing::TextVerticalAdjust eAdjust = drawing::TextVerticalAdjust_TOP;
822         OSL_VERIFY( _rValue >>= eAlign );
823         switch ( eAlign )
824         {
825         case style::VerticalAlignment_TOP:    eAdjust = drawing::TextVerticalAdjust_TOP; break;
826         case style::VerticalAlignment_BOTTOM: eAdjust = drawing::TextVerticalAdjust_BOTTOM; break;
827         default:                              eAdjust = drawing::TextVerticalAdjust_CENTER; break;
828         }
829         _rValue <<= eAdjust;
830     }
831 }
832 
833 void SAL_CALL SvxShapeControl::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
834 	throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, com::sun::star::beans::PropertyVetoException, com::sun::star::lang::IllegalArgumentException)
835 {
836 	OUString aFormsName;
837 	if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
838 	{
839 		uno::Reference< beans::XPropertySet > xControl( getControl(), uno::UNO_QUERY );
840 		if( xControl.is() )
841 		{
842 			uno::Reference< beans::XPropertySetInfo > xInfo( xControl->getPropertySetInfo() );
843 			if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
844 			{
845                 uno::Any aConvertedValue( aValue );
846                 if ( aFormsName.equalsAscii( "FontSlant" ) )
847                 {
848                     awt::FontSlant nSlant;
849                     if( !(aValue >>= nSlant ) )
850                         throw lang::IllegalArgumentException();
851                     aConvertedValue <<= (sal_Int16)nSlant;
852                 }
853                 else if ( aFormsName.equalsAscii( "Align" ) )
854                 {
855                     lcl_convertParaAdjustmentToTextAlignment( aConvertedValue );
856                 }
857                 else if ( aFormsName.equalsAscii( "VerticalAlign" ) )
858                 {
859                     convertVerticalAdjustToVerticalAlign( aConvertedValue );
860                 }
861 
862                 xControl->setPropertyValue( aFormsName, aConvertedValue );
863 			}
864 		}
865 	}
866 	else
867 	{
868 		SvxShape::setPropertyValue( aPropertyName, aValue );
869 	}
870 }
871 
872 uno::Any SAL_CALL SvxShapeControl::getPropertyValue( const OUString& aPropertyName )
873 	throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
874 {
875 	OUString aFormsName;
876 	if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
877 	{
878 		uno::Reference< beans::XPropertySet > xControl( getControl(), uno::UNO_QUERY );
879 
880         uno::Any aValue;
881 		if( xControl.is() )
882 		{
883 			uno::Reference< beans::XPropertySetInfo > xInfo( xControl->getPropertySetInfo() );
884 			if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
885 			{
886                 aValue = xControl->getPropertyValue( aFormsName );
887                 if ( aFormsName.equalsAscii( "FontSlant" ) )
888 				{
889                     awt::FontSlant eSlant = awt::FontSlant_NONE;
890 					sal_Int16 nSlant = sal_Int16();
891                     if ( aValue >>= nSlant )
892                     {
893                         eSlant = (awt::FontSlant)nSlant;
894                     }
895                     else
896                     {
897                         OSL_VERIFY( aValue >>= eSlant );
898                     }
899                     aValue <<= eSlant;
900 				}
901 				else if ( aFormsName.equalsAscii( "Align" ) )
902 				{
903                     lcl_convertTextAlignmentToParaAdjustment( aValue );
904 				}
905                 else if ( aFormsName.equalsAscii( "VerticalAlign" ) )
906                 {
907                     convertVerticalAlignToVerticalAdjust( aValue );
908                 }
909 			}
910 		}
911 
912 		return aValue;
913 	}
914 	else
915 	{
916 		return SvxShape::getPropertyValue( aPropertyName );
917 	}
918 
919 }
920 
921 // XPropertyState
922 beans::PropertyState SAL_CALL SvxShapeControl::getPropertyState( const ::rtl::OUString& PropertyName ) throw( beans::UnknownPropertyException, uno::RuntimeException )
923 {
924 	OUString aFormsName;
925 	if ( lcl_convertPropertyName( PropertyName, aFormsName ) )
926 	{
927 		uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
928 		uno::Reference< beans::XPropertySet > xPropSet( getControl(), uno::UNO_QUERY );
929 
930 		if( xControl.is() && xPropSet.is() )
931 		{
932 			uno::Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
933 			if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
934 			{
935 				return xControl->getPropertyState( aFormsName );
936 			}
937 		}
938 
939 		return beans::PropertyState_DEFAULT_VALUE;
940 	}
941 	else
942 	{
943 		return SvxShape::getPropertyState( PropertyName );
944 	}
945 }
946 
947 void SAL_CALL SvxShapeControl::setPropertyToDefault( const ::rtl::OUString& PropertyName ) throw( beans::UnknownPropertyException, uno::RuntimeException )
948 {
949 	OUString aFormsName;
950 	if ( lcl_convertPropertyName( PropertyName, aFormsName ) )
951 	{
952 		uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
953 		uno::Reference< beans::XPropertySet > xPropSet( getControl(), uno::UNO_QUERY );
954 
955 		if( xControl.is() && xPropSet.is() )
956 		{
957 			uno::Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
958 			if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
959 			{
960 				xControl->setPropertyToDefault( aFormsName );
961 			}
962 		}
963 	}
964 	else
965 	{
966 		SvxShape::setPropertyToDefault( PropertyName );
967 	}
968 }
969 
970 uno::Any SAL_CALL SvxShapeControl::getPropertyDefault( const ::rtl::OUString& aPropertyName )
971 	throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
972 {
973 	OUString aFormsName;
974 	if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
975 	{
976 		uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
977 
978 		if( xControl.is() )
979 		{
980             Any aDefault( xControl->getPropertyDefault( aFormsName ) );
981             if ( aFormsName.equalsAscii( "FontSlant" ) )
982 			{
983 				sal_Int16 nSlant( 0 );
984 				aDefault >>= nSlant;
985                 aDefault <<= (awt::FontSlant)nSlant;
986 			}
987             else if ( aFormsName.equalsAscii( "Align" ) )
988             {
989                 lcl_convertTextAlignmentToParaAdjustment( aDefault );
990             }
991             else if ( aFormsName.equalsAscii( "VerticalAlign" ) )
992             {
993                 convertVerticalAlignToVerticalAdjust( aDefault );
994             }
995             return aDefault;
996 		}
997 
998 		throw beans::UnknownPropertyException();
999 	}
1000 	else
1001 	{
1002 		return SvxShape::getPropertyDefault( aPropertyName );
1003 	}
1004 }
1005 
1006 
1007 /***********************************************************************
1008 * class SvxShapeDimensioning                                           *
1009 ***********************************************************************/
1010 
1011 //----------------------------------------------------------------------
1012 SvxShapeDimensioning::SvxShapeDimensioning( SdrObject* pObj ) throw()
1013 :	SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_DIMENSIONING), aSvxMapProvider.GetPropertySet(SVXMAP_DIMENSIONING, SdrObject::GetGlobalDrawObjectItemPool()) )
1014 {
1015 }
1016 
1017 //----------------------------------------------------------------------
1018 SvxShapeDimensioning::~SvxShapeDimensioning() throw()
1019 {
1020 }
1021 
1022 // ::com::sun::star::lang::XServiceInfo
1023 uno::Sequence< OUString > SAL_CALL SvxShapeDimensioning::getSupportedServiceNames() throw( uno::RuntimeException )
1024 {
1025 	return SvxShapeText::getSupportedServiceNames();
1026 }
1027 
1028 /***********************************************************************
1029 *                                                                      *
1030 ***********************************************************************/
1031 
1032 //----------------------------------------------------------------------
1033 SvxShapeCircle::SvxShapeCircle( SdrObject* pObj ) throw()
1034 :	SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_CIRCLE), aSvxMapProvider.GetPropertySet(SVXMAP_CIRCLE, SdrObject::GetGlobalDrawObjectItemPool()) )
1035 {
1036 }
1037 
1038 //----------------------------------------------------------------------
1039 SvxShapeCircle::~SvxShapeCircle() throw()
1040 {
1041 }
1042 
1043 // ::com::sun::star::lang::XServiceInfo
1044 // XServiceInfo
1045 uno::Sequence< OUString > SAL_CALL SvxShapeCircle::getSupportedServiceNames() throw( uno::RuntimeException )
1046 {
1047 	return SvxShapeText::getSupportedServiceNames();
1048 }
1049 
1050 /***********************************************************************
1051 *                                                                      *
1052 ***********************************************************************/
1053 
1054 #include <svx/svdopath.hxx>
1055 
1056 //----------------------------------------------------------------------
1057 SvxShapePolyPolygon::SvxShapePolyPolygon( SdrObject* pObj , drawing::PolygonKind eNew )
1058  throw( com::sun::star::beans::PropertyVetoException, com::sun::star::lang::IllegalArgumentException)
1059 : SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_POLYPOLYGON), aSvxMapProvider.GetPropertySet(SVXMAP_POLYPOLYGON, SdrObject::GetGlobalDrawObjectItemPool()) )
1060 , mePolygonKind( eNew )
1061 {
1062 }
1063 
1064 //----------------------------------------------------------------------
1065 SvxShapePolyPolygon::~SvxShapePolyPolygon() throw()
1066 {
1067 }
1068 
1069 basegfx::B2DPolyPolygon SAL_CALL ImplSvxPointSequenceSequenceToB2DPolyPolygon( const drawing::PointSequenceSequence* pOuterSequence) throw()
1070 {
1071 	basegfx::B2DPolyPolygon aRetval;
1072 
1073 	// Zeiger auf innere sequences holen
1074 	const drawing::PointSequence* pInnerSequence = pOuterSequence->getConstArray();
1075 	const drawing::PointSequence* pInnerSeqEnd   = pInnerSequence + pOuterSequence->getLength();
1076 
1077 	for(;pInnerSequence != pInnerSeqEnd; ++pInnerSequence)
1078 	{
1079 		// Neues Polygon vorbereiten
1080 		basegfx::B2DPolygon aNewPolygon;
1081 
1082 		// Zeiger auf Arrays holen
1083 		const awt::Point* pArray	= pInnerSequence->getConstArray();
1084 		const awt::Point* pArrayEnd = pArray + pInnerSequence->getLength();
1085 
1086 		for(;pArray != pArrayEnd;++pArray)
1087 		{
1088 			aNewPolygon.append(basegfx::B2DPoint(pArray->X, pArray->Y));
1089 		}
1090 
1091 		// check for closed state flag
1092 		basegfx::tools::checkClosed(aNewPolygon);
1093 
1094 		// Neues Teilpolygon einfuegen
1095 		aRetval.append(aNewPolygon);
1096 	}
1097 
1098 	return aRetval;
1099 }
1100 
1101 //----------------------------------------------------------------------
1102 
1103 bool SvxShapePolyPolygon::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)
1104 {
1105 	switch( pProperty->nWID )
1106 	{
1107 	case OWN_ATTR_VALUE_POLYPOLYGON:
1108 	{
1109 		if( rValue.getValue() && (rValue.getValueType() == ::getCppuType(( const drawing::PointSequenceSequence*)0) ) )
1110 		{
1111 			basegfx::B2DPolyPolygon aNewPolyPolygon(ImplSvxPointSequenceSequenceToB2DPolyPolygon( (drawing::PointSequenceSequence*)rValue.getValue()));
1112 			SetPolygon(aNewPolyPolygon);
1113 			return true;
1114 		}
1115 		break;
1116 	}
1117 	case OWN_ATTR_BASE_GEOMETRY:
1118 	{
1119 		if( rValue.getValue() && (rValue.getValueType() == ::getCppuType(( const drawing::PointSequenceSequence*)0)))
1120 		{
1121 			if( mpObj.is() )
1122 			{
1123 				basegfx::B2DPolyPolygon aNewPolyPolygon;
1124 				basegfx::B2DHomMatrix aNewHomogenMatrix;
1125 
1126 				mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
1127 				aNewPolyPolygon = ImplSvxPointSequenceSequenceToB2DPolyPolygon((drawing::PointSequenceSequence*)rValue.getValue());
1128 				mpObj->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
1129 			}
1130 			return true;
1131 		}
1132 		break;
1133 	}
1134 	case OWN_ATTR_VALUE_POLYGON:
1135 	{
1136 		if( rValue.getValue() && (rValue.getValueType() == ::getCppuType(( const drawing::PointSequenceSequence*)0) ))
1137 		{
1138 			drawing::PointSequence* pSequence = (drawing::PointSequence*)rValue.getValue();
1139 
1140 			// Neues Polygon vorbereiten
1141 			basegfx::B2DPolygon aNewPolygon;
1142 
1143 			// Zeiger auf Arrays holen
1144 			// Zeiger auf Arrays holen
1145 			const awt::Point* pArray	= pSequence->getConstArray();
1146 			const awt::Point* pArrayEnd = pArray + pSequence->getLength();
1147 
1148 			for(;pArray != pArrayEnd;++pArray)
1149 			{
1150 				aNewPolygon.append(basegfx::B2DPoint(pArray->X, pArray->Y));
1151 			}
1152 
1153 			// check for closed state flag
1154 			basegfx::tools::checkClosed(aNewPolygon);
1155 
1156 			// Polygon setzen
1157 			SetPolygon(basegfx::B2DPolyPolygon(aNewPolygon));
1158 			return true;
1159 		}
1160 		break;
1161 	}
1162 	default:
1163         return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
1164 	}
1165 
1166 	throw lang::IllegalArgumentException();
1167 }
1168 
1169 void SAL_CALL B2DPolyPolygonToSvxPointSequenceSequence( const basegfx::B2DPolyPolygon& rPolyPoly, drawing::PointSequenceSequence& rRetval )
1170 {
1171 	if( (sal_uInt32)rRetval.getLength() != rPolyPoly.count() )
1172 		rRetval.realloc( rPolyPoly.count() );
1173 
1174 	// Zeiger auf aeussere Arrays holen
1175 	drawing::PointSequence* pOuterSequence = rRetval.getArray();
1176 
1177 	for(sal_uInt32 a(0L); a < rPolyPoly.count(); a++)
1178 	{
1179 		// Einzelpolygon holen
1180 		const basegfx::B2DPolygon aPoly(rPolyPoly.getB2DPolygon(a));
1181 
1182 		// #i75974# take closed stae into account, the API polygon still uses the old closed definition
1183 		// with last/first point are identical (cannot hold information about open polygons with identical
1184 		// first and last point, though)
1185 		const sal_uInt32 nPointCount(aPoly.count());
1186 		const bool bIsClosed(aPoly.isClosed());
1187 
1188 		// Platz in Arrays schaffen
1189 		pOuterSequence->realloc(bIsClosed ? nPointCount + 1 : nPointCount);
1190 
1191 		// Pointer auf arrays holen
1192 		awt::Point* pInnerSequence = pOuterSequence->getArray();
1193 
1194 		for(sal_uInt32 b(0L); b < nPointCount; b++)
1195 		{
1196 			const basegfx::B2DPoint aPoint(aPoly.getB2DPoint(b));
1197 			*pInnerSequence = awt::Point( basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY()) );
1198 			pInnerSequence++;
1199 		}
1200 
1201 		// #i75974# copy first point
1202 		if(bIsClosed)
1203 		{
1204 			*pInnerSequence = *pOuterSequence->getArray();
1205 		}
1206 
1207 		pOuterSequence++;
1208 	}
1209 }
1210 
1211 //----------------------------------------------------------------------
1212 
1213 bool SvxShapePolyPolygon::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)
1214 {
1215 	switch( pProperty->nWID )
1216 	{
1217 	case OWN_ATTR_VALUE_POLYPOLYGON:
1218 	{
1219 		// PolyPolygon in eine struct PolyPolygon packen
1220 		const basegfx::B2DPolyPolygon& rPolyPoly = GetPolygon();
1221 		drawing::PointSequenceSequence aRetval( rPolyPoly.count() );
1222 
1223 		B2DPolyPolygonToSvxPointSequenceSequence( rPolyPoly, aRetval );
1224 
1225 		rValue <<= aRetval;
1226 		break;
1227 	}
1228 	case OWN_ATTR_BASE_GEOMETRY:
1229 	{
1230 		// pack a PolyPolygon in struct PolyPolygon
1231 		basegfx::B2DPolyPolygon aNewPolyPolygon;
1232 		basegfx::B2DHomMatrix aNewHomogenMatrix;
1233 
1234 		if(mpObj.is())
1235 			mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
1236 
1237 		drawing::PointSequenceSequence aRetval(aNewPolyPolygon.count());
1238 		B2DPolyPolygonToSvxPointSequenceSequence(aNewPolyPolygon, aRetval);
1239 		rValue <<= aRetval;
1240 		break;
1241 	}
1242 	case OWN_ATTR_VALUE_POLYGON:
1243 	{
1244 		// PolyPolygon in eine struct PolyPolygon packen
1245 		const basegfx::B2DPolyPolygon& rPolyPoly = GetPolygon();
1246 
1247 		sal_Int32 nCount = 0;
1248 		if( rPolyPoly.count() > 0 )
1249 			nCount = rPolyPoly.getB2DPolygon(0L).count();
1250 
1251 		drawing::PointSequence aRetval( nCount );
1252 
1253 		if( nCount > 0 )
1254 		{
1255 			// Einzelpolygon holen
1256 			const basegfx::B2DPolygon aPoly(rPolyPoly.getB2DPolygon(0L));
1257 
1258 			// Pointer auf arrays holen
1259 			awt::Point* pSequence = aRetval.getArray();
1260 
1261 			for(sal_Int32 b=0;b<nCount;b++)
1262 			{
1263 				const basegfx::B2DPoint aPoint(aPoly.getB2DPoint(b));
1264 				*pSequence++ = awt::Point( basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY()) );
1265 			}
1266 		}
1267 
1268 		rValue <<= aRetval;
1269 		break;
1270 	}
1271 	case OWN_ATTR_VALUE_POLYGONKIND:
1272 	{
1273 		rValue <<= GetPolygonKind();
1274 		break;
1275 	}
1276 	default:
1277         return SvxShapeText::getPropertyValueImpl( rName, pProperty, rValue );
1278 	}
1279 
1280 	return true;
1281 }
1282 
1283 //----------------------------------------------------------------------
1284 drawing::PolygonKind SvxShapePolyPolygon::GetPolygonKind() const throw()
1285 {
1286 	return mePolygonKind;
1287 }
1288 
1289 //----------------------------------------------------------------------
1290 void SvxShapePolyPolygon::SetPolygon(const basegfx::B2DPolyPolygon& rNew) throw()
1291 {
1292 	OGuard aGuard( Application::GetSolarMutex() );
1293 
1294 	if(mpObj.is())
1295 		((SdrPathObj*)mpObj.get())->SetPathPoly(rNew);
1296 }
1297 
1298 //----------------------------------------------------------------------
1299 basegfx::B2DPolyPolygon SvxShapePolyPolygon::GetPolygon() const throw()
1300 {
1301 	OGuard aGuard( Application::GetSolarMutex() );
1302 
1303 	if(mpObj.is())
1304 	{
1305 		return ((SdrPathObj*)mpObj.get())->GetPathPoly();
1306 	}
1307 	else
1308 	{
1309 		return basegfx::B2DPolyPolygon();
1310 	}
1311 }
1312 
1313 // ::com::sun::star::lang::XServiceInfo
1314 uno::Sequence< OUString > SAL_CALL SvxShapePolyPolygon::getSupportedServiceNames() throw( uno::RuntimeException )
1315 {
1316 	return SvxShapeText::getSupportedServiceNames();
1317 }
1318 
1319 /***********************************************************************
1320 * class SvxShapePolyPolygonBezier                                      *
1321 ***********************************************************************/
1322 #include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
1323 #include <com/sun/star/drawing/FlagSequence.hpp>
1324 //----------------------------------------------------------------------
1325 SvxShapePolyPolygonBezier::SvxShapePolyPolygonBezier( SdrObject* pObj , drawing::PolygonKind eNew ) throw()
1326 :	SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_POLYPOLYGONBEZIER), aSvxMapProvider.GetPropertySet(SVXMAP_POLYPOLYGONBEZIER, SdrObject::GetGlobalDrawObjectItemPool()) )
1327 ,	mePolygonKind( eNew )
1328 {
1329 }
1330 
1331 //----------------------------------------------------------------------
1332 SvxShapePolyPolygonBezier::~SvxShapePolyPolygonBezier() throw()
1333 {
1334 }
1335 
1336 basegfx::B2DPolyPolygon SvxConvertPolyPolygonBezierToB2DPolyPolygon(const drawing::PolyPolygonBezierCoords* pSourcePolyPolygon)
1337 	throw( IllegalArgumentException )
1338 {
1339 	const sal_Int32 nOuterSequenceCount(pSourcePolyPolygon->Coordinates.getLength());
1340 	basegfx::B2DPolyPolygon aNewPolyPolygon;
1341 
1342 	if(pSourcePolyPolygon->Flags.getLength() != nOuterSequenceCount)
1343 	{
1344 		throw IllegalArgumentException();
1345 	}
1346 
1347 	// get pointers to inner sequence
1348 	const drawing::PointSequence* pInnerSequence = pSourcePolyPolygon->Coordinates.getConstArray();
1349 	const drawing::FlagSequence* pInnerSequenceFlags = pSourcePolyPolygon->Flags.getConstArray();
1350 
1351 	for(sal_Int32 a(0); a < nOuterSequenceCount; a++)
1352 	{
1353 		const sal_Int32 nInnerSequenceCount(pInnerSequence->getLength());
1354 
1355 		if(pInnerSequenceFlags->getLength() != nInnerSequenceCount)
1356 		{
1357 			throw IllegalArgumentException();
1358 		}
1359 
1360 		// prepare new polygon
1361 		basegfx::B2DPolygon aNewPolygon;
1362 		const awt::Point* pArray = pInnerSequence->getConstArray();
1363 		const drawing::PolygonFlags* pArrayFlags = pInnerSequenceFlags->getConstArray();
1364 
1365 		// get first point and flag
1366 		basegfx::B2DPoint aNewCoordinatePair(pArray->X, pArray->Y); pArray++;
1367 		XPolyFlags ePolyFlag((XPolyFlags)((sal_uInt16)*pArrayFlags)); pArrayFlags++;
1368 		basegfx::B2DPoint aControlA;
1369 		basegfx::B2DPoint aControlB;
1370 
1371 		// first point is not allowed to be a control point
1372 		if(XPOLY_CONTROL == ePolyFlag)
1373 		{
1374 			throw IllegalArgumentException();
1375 		}
1376 
1377 		// add first point as start point
1378 		aNewPolygon.append(aNewCoordinatePair);
1379 
1380 		for(sal_Int32 b(1); b < nInnerSequenceCount;)
1381 		{
1382 			// prepare loop
1383 			bool bControlA(false);
1384 			bool bControlB(false);
1385 
1386 			// get next point and flag
1387 			aNewCoordinatePair = basegfx::B2DPoint(pArray->X, pArray->Y);
1388 			ePolyFlag = XPolyFlags((XPolyFlags)((sal_uInt16)*pArrayFlags));
1389 			pArray++; pArrayFlags++; b++;
1390 
1391 			if(b < nInnerSequenceCount && XPOLY_CONTROL == ePolyFlag)
1392 			{
1393 				aControlA = aNewCoordinatePair;
1394 				bControlA = true;
1395 
1396 				// get next point and flag
1397 				aNewCoordinatePair = basegfx::B2DPoint(pArray->X, pArray->Y);
1398 				ePolyFlag = XPolyFlags((XPolyFlags)((sal_uInt16)*pArrayFlags));
1399 				pArray++; pArrayFlags++; b++;
1400 			}
1401 
1402 			if(b < nInnerSequenceCount && XPOLY_CONTROL == ePolyFlag)
1403 			{
1404 				aControlB = aNewCoordinatePair;
1405 				bControlB = true;
1406 
1407 				// get next point and flag
1408 				aNewCoordinatePair = basegfx::B2DPoint(pArray->X, pArray->Y);
1409 				ePolyFlag = XPolyFlags((XPolyFlags)((sal_uInt16)*pArrayFlags));
1410 				pArray++; pArrayFlags++; b++;
1411 			}
1412 
1413 			// two or no control points are consumed, another one would be an error.
1414 			// It's also an error if only one control point was read
1415 			if(XPOLY_CONTROL == ePolyFlag || bControlA != bControlB)
1416 			{
1417 				throw IllegalArgumentException();
1418 			}
1419 
1420 			// the previous writes used the B2DPolyPoygon -> PolyPolygon converter
1421 			// which did not create minimal PolyPolygons, but created all control points
1422 			// as null vectors (identical points). Because of the former P(CA)(CB)-norm of
1423 			// B2DPolygon and it's unused sign of being the zero-vector and CA and CB being
1424 			// relative to P, an empty edge was exported as P == CA == CB. Luckily, the new
1425 			// export format can be read without errors by the old OOo-versions, so we need only
1426 			// to correct here at read and do not need to export a wrong but compatible version
1427 			// for the future.
1428 			if(bControlA
1429 				&& aControlA.equal(aControlB)
1430 				&& aControlA.equal(aNewPolygon.getB2DPoint(aNewPolygon.count() - 1)))
1431 			{
1432 				bControlA = bControlB = false;
1433 			}
1434 
1435 			if(bControlA)
1436 			{
1437 				// add bezier edge
1438 				aNewPolygon.appendBezierSegment(aControlA, aControlB, aNewCoordinatePair);
1439 			}
1440 			else
1441 			{
1442 				// add edge
1443 				aNewPolygon.append(aNewCoordinatePair);
1444 			}
1445 		}
1446 
1447 		// next sequence
1448 		pInnerSequence++;
1449 		pInnerSequenceFlags++;
1450 
1451 		// #i72807# API import uses old line start/end-equal definition for closed,
1452 		// so we need to correct this to closed state here
1453 		basegfx::tools::checkClosed(aNewPolygon);
1454 
1455 		// add new subpolygon
1456 		aNewPolyPolygon.append(aNewPolygon);
1457 	}
1458 
1459 	return aNewPolyPolygon;
1460 }
1461 
1462 //----------------------------------------------------------------------
1463 
1464 bool SvxShapePolyPolygonBezier::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)
1465 {
1466 	switch( pProperty->nWID )
1467 	{
1468 	case OWN_ATTR_VALUE_POLYPOLYGONBEZIER:
1469 	{
1470 		if( rValue.getValue() && (rValue.getValueType() == ::getCppuType(( const drawing::PolyPolygonBezierCoords*)0) ) )
1471 		{
1472 			basegfx::B2DPolyPolygon aNewPolyPolygon(SvxConvertPolyPolygonBezierToB2DPolyPolygon( (drawing::PolyPolygonBezierCoords*)rValue.getValue()));
1473 			SetPolygon(aNewPolyPolygon);
1474 			return true;
1475 		}
1476 		break;
1477 	}
1478 	case OWN_ATTR_BASE_GEOMETRY:
1479 	{
1480 		if( rValue.getValue() && (rValue.getValueType() == ::getCppuType(( const drawing::PolyPolygonBezierCoords*)0)) )
1481 		{
1482 			if( mpObj.is() )
1483 			{
1484 				basegfx::B2DPolyPolygon aNewPolyPolygon;
1485 				basegfx::B2DHomMatrix aNewHomogenMatrix;
1486 
1487 				mpObj->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
1488 				aNewPolyPolygon = SvxConvertPolyPolygonBezierToB2DPolyPolygon((drawing::PolyPolygonBezierCoords*)rValue.getValue());
1489 				mpObj->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
1490 			}
1491 			return true;
1492 		}
1493 		break;
1494 	}
1495 	default:
1496         return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
1497 	}
1498 
1499 	throw IllegalArgumentException();
1500 }
1501 
1502 void SvxConvertB2DPolyPolygonToPolyPolygonBezier( const basegfx::B2DPolyPolygon& rPolyPoly, drawing::PolyPolygonBezierCoords& rRetval )
1503 {
1504 	// use PolyPolygon converter as base. Since PolyPolygonBezierCoords uses
1505 	// integer coordinates, this is no precision loss at all.
1506 	const PolyPolygon aPolyPoly(rPolyPoly);
1507 
1508 	// Polygone innerhalb vrobereiten
1509 	rRetval.Coordinates.realloc((sal_Int32)aPolyPoly.Count());
1510 	rRetval.Flags.realloc((sal_Int32)aPolyPoly.Count());
1511 
1512 	// Zeiger auf aeussere Arrays holen
1513 	drawing::PointSequence* pOuterSequence = rRetval.Coordinates.getArray();
1514 	drawing::FlagSequence*  pOuterFlags = rRetval.Flags.getArray();
1515 
1516 	for(sal_uInt16 a=0;a<aPolyPoly.Count();a++)
1517 	{
1518 		// Einzelpolygon holen
1519 		const Polygon& rPoly = aPolyPoly[a];
1520 
1521 		// Platz in Arrays schaffen
1522 		pOuterSequence->realloc((sal_Int32)rPoly.GetSize());
1523 		pOuterFlags->realloc((sal_Int32)rPoly.GetSize());
1524 
1525 		// Pointer auf arrays holen
1526 		awt::Point* pInnerSequence = pOuterSequence->getArray();
1527 		drawing::PolygonFlags* pInnerFlags = pOuterFlags->getArray();
1528 
1529 		for(sal_uInt16 b=0;b<rPoly.GetSize();b++)
1530 		{
1531 			*pInnerSequence++ = awt::Point( rPoly[b].X(), rPoly[b].Y() );
1532 			*pInnerFlags++ = (drawing::PolygonFlags)((sal_uInt16)rPoly.GetFlags(b));
1533 		}
1534 
1535 		pOuterSequence++;
1536 		pOuterFlags++;
1537 	}
1538 }
1539 
1540 //----------------------------------------------------------------------
1541 
1542 bool SvxShapePolyPolygonBezier::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)
1543 {
1544 	switch( pProperty->nWID )
1545 	{
1546 	case OWN_ATTR_VALUE_POLYPOLYGONBEZIER:
1547 	{
1548 		// PolyPolygon in eine struct PolyPolygon packen
1549 		const basegfx::B2DPolyPolygon& rPolyPoly = GetPolygon();
1550 		drawing::PolyPolygonBezierCoords aRetval;
1551 		SvxConvertB2DPolyPolygonToPolyPolygonBezier(rPolyPoly, aRetval );
1552 
1553 		rValue <<= aRetval;
1554 		break;
1555 	}
1556 	case OWN_ATTR_BASE_GEOMETRY:
1557 	{
1558 		// PolyPolygon in eine struct PolyPolygon packen
1559 		basegfx::B2DPolyPolygon aNewPolyPolygon;
1560 		basegfx::B2DHomMatrix aNewHomogenMatrix;
1561 		mpObj.get()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
1562 		drawing::PolyPolygonBezierCoords aRetval;
1563 		SvxConvertB2DPolyPolygonToPolyPolygonBezier(aNewPolyPolygon, aRetval);
1564 
1565 		rValue <<= aRetval;
1566 		break;
1567 	}
1568 	case OWN_ATTR_VALUE_POLYGONKIND:
1569 	{
1570 		rValue <<= mePolygonKind;
1571 		break;
1572 	}
1573 	default:
1574         return SvxShapeText::getPropertyValueImpl( rName, pProperty, rValue );
1575 	}
1576 	return true;
1577 }
1578 
1579 //----------------------------------------------------------------------
1580 drawing::PolygonKind SvxShapePolyPolygonBezier::GetPolygonKind() const throw()
1581 {
1582 	return mePolygonKind;
1583 }
1584 
1585 //----------------------------------------------------------------------
1586 void SvxShapePolyPolygonBezier::SetPolygon(const basegfx::B2DPolyPolygon& rNew) throw()
1587 {
1588 	OGuard aGuard( Application::GetSolarMutex() );
1589 
1590 	if(mpObj.is())
1591 		static_cast<SdrPathObj*>(mpObj.get())->SetPathPoly(rNew);
1592 }
1593 
1594 //----------------------------------------------------------------------
1595 basegfx::B2DPolyPolygon SvxShapePolyPolygonBezier::GetPolygon() const throw()
1596 {
1597 	OGuard aGuard( Application::GetSolarMutex() );
1598 
1599 	if(mpObj.is())
1600 	{
1601 		return static_cast<SdrPathObj*>(mpObj.get())->GetPathPoly();
1602 	}
1603 	else
1604 	{
1605 		return basegfx::B2DPolyPolygon();
1606 	}
1607 }
1608 
1609 
1610 // ::com::sun::star::lang::XServiceInfo
1611 uno::Sequence< OUString > SAL_CALL SvxShapePolyPolygonBezier::getSupportedServiceNames() throw( uno::RuntimeException )
1612 {
1613 	return SvxShapeText::getSupportedServiceNames();
1614 }
1615 
1616 /***********************************************************************
1617 * class SvxGraphicObject                                               *
1618 ***********************************************************************/
1619 #include <com/sun/star/awt/XBitmap.hpp>
1620 #include <vcl/cvtgrf.hxx>
1621 #include <svx/svdograf.hxx>
1622 #ifndef SVX_LIGHT
1623 #ifndef _SFXDOCFILE_HXX
1624 #include <sfx2/docfile.hxx>
1625 #endif
1626 #include <sfx2/app.hxx>
1627 #include <sfx2/fcontnr.hxx>
1628 #endif
1629 
1630 #include "toolkit/unohlp.hxx"
1631 
1632 //----------------------------------------------------------------------
1633 SvxGraphicObject::SvxGraphicObject( SdrObject* pObj ) throw()
1634 :	SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_GRAPHICOBJECT), aSvxMapProvider.GetPropertySet(SVXMAP_GRAPHICOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
1635 {
1636 }
1637 
1638 //----------------------------------------------------------------------
1639 SvxGraphicObject::~SvxGraphicObject() throw()
1640 {
1641 }
1642 
1643 //----------------------------------------------------------------------
1644 
1645 bool SvxGraphicObject::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)
1646 {
1647 	bool bOk = false;
1648 	switch( pProperty->nWID )
1649 	{
1650 	case OWN_ATTR_VALUE_FILLBITMAP:
1651 	{
1652 		if( rValue.getValue() )
1653 		{
1654 			if( rValue.getValueType() == ::getCppuType(( const uno::Sequence< sal_Int8 >*)0) )
1655 			{
1656 				uno::Sequence<sal_Int8>* pSeq( (uno::Sequence<sal_Int8>*)rValue.getValue() );
1657 				SvMemoryStream	aMemStm;
1658 				Graphic			aGraphic;
1659 
1660 				aMemStm.SetBuffer( (char*)pSeq->getConstArray(), pSeq->getLength(), sal_False, pSeq->getLength() );
1661 
1662 				if( GraphicConverter::Import( aMemStm, aGraphic ) == ERRCODE_NONE )
1663 				{
1664 					static_cast<SdrGrafObj*>(mpObj.get())->SetGraphic(aGraphic);
1665 					bOk = true;
1666 				}
1667 			}
1668 		}
1669 		else if( (rValue.getValueType() == awt::XBitmap::static_type()) || (rValue.getValueType() == graphic::XGraphic::static_type()))
1670 		{
1671 			Reference< graphic::XGraphic> xGraphic( rValue, UNO_QUERY );
1672 			if( xGraphic.is() )
1673 			{
1674 				((SdrGrafObj*)mpObj.get())->SetGraphic(Graphic(xGraphic));
1675 				bOk = true;
1676 			}
1677 			else
1678 			{
1679 				// Bitmap in das Objekt packen
1680 				Reference< awt::XBitmap > xBmp( rValue, UNO_QUERY );
1681 				if( xBmp.is() )
1682 				{
1683 					// Bitmap einsetzen
1684 					Graphic aGraphic(VCLUnoHelper::GetBitmap( xBmp ));
1685 					((SdrGrafObj*)mpObj.get())->SetGraphic(aGraphic);
1686 					bOk = true;
1687 				}
1688 			}
1689 		}
1690 		break;
1691 	}
1692 	case OWN_ATTR_GRAFURL:
1693 	{
1694 		OUString aURL;
1695 		if( rValue >>= aURL )
1696 		{
1697 			if( aURL.compareToAscii( UNO_NAME_GRAPHOBJ_URLPREFIX, RTL_CONSTASCII_LENGTH( UNO_NAME_GRAPHOBJ_URLPREFIX ) ) == 0 )
1698 			{
1699 				// graphic manager url
1700 				aURL = aURL.copy( sizeof( UNO_NAME_GRAPHOBJ_URLPREFIX ) - 1 );
1701 				String aTmpStr(aURL);
1702 				ByteString aUniqueID( aTmpStr, RTL_TEXTENCODING_UTF8 );
1703 				GraphicObject aGrafObj( aUniqueID );
1704 
1705 				// #101808# since loading a graphic can cause a reschedule of the office
1706 				//			it is possible that our shape is removed while where in this
1707 				//			method.
1708 				if( mpObj.is() )
1709 				{
1710 					static_cast<SdrGrafObj*>(mpObj.get())->ReleaseGraphicLink();
1711 					static_cast<SdrGrafObj*>(mpObj.get())->SetGraphicObject( aGrafObj );
1712 				}
1713 			}
1714 			else if( aURL.compareToAscii( UNO_NAME_GRAPHOBJ_URLPKGPREFIX, RTL_CONSTASCII_LENGTH( UNO_NAME_GRAPHOBJ_URLPKGPREFIX ) ) != 0 )
1715 			{
1716 				// normal link
1717 				String				aFilterName;
1718 				const SfxFilter*	pSfxFilter = NULL;
1719 				SfxMedium			aSfxMedium( aURL, STREAM_READ | STREAM_SHARE_DENYNONE, sal_False );
1720 
1721 				SFX_APP()->GetFilterMatcher().GuessFilter( aSfxMedium, &pSfxFilter, SFX_FILTER_IMPORT, SFX_FILTER_NOTINSTALLED | SFX_FILTER_EXECUTABLE );
1722 
1723 				if( !pSfxFilter )
1724 				{
1725 					INetURLObject aURLObj( aURL );
1726 
1727 					if( aURLObj.GetProtocol() == INET_PROT_NOT_VALID )
1728 					{
1729 						String aValidURL;
1730 
1731 						if( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aURL, aValidURL ) )
1732 							aURLObj = INetURLObject( aValidURL );
1733 					}
1734 
1735 					if( aURLObj.GetProtocol() != INET_PROT_NOT_VALID )
1736 					{
1737 						GraphicFilter* pGrfFilter = GraphicFilter::GetGraphicFilter();
1738 						aFilterName = pGrfFilter->GetImportFormatName( pGrfFilter->GetImportFormatNumberForShortName( aURLObj.getExtension() ) );
1739 					}
1740 				}
1741 				else
1742 					aFilterName = pSfxFilter->GetFilterName();
1743 
1744 				// #101808# since loading a graphic can cause a reschedule of the office
1745 				//			it is possible that our shape is removed while where in this
1746 				//			method.
1747 				if( mpObj.is() )
1748 					static_cast<SdrGrafObj*>(mpObj.get())->SetGraphicLink( aURL, aFilterName );
1749 
1750 			}
1751 			bOk = true;
1752 		}
1753 		break;
1754 	}
1755 
1756 	case OWN_ATTR_GRAFSTREAMURL:
1757 	{
1758 		OUString aStreamURL;
1759 
1760 		if( rValue >>= aStreamURL )
1761 		{
1762 			if( aStreamURL.compareToAscii( UNO_NAME_GRAPHOBJ_URLPKGPREFIX, RTL_CONSTASCII_LENGTH( UNO_NAME_GRAPHOBJ_URLPKGPREFIX ) ) != 0 )
1763 				aStreamURL = OUString();
1764 
1765 			if( mpObj.is() )
1766 			{
1767 				static_cast<SdrGrafObj*>(mpObj.get())->SetGrafStreamURL( aStreamURL );
1768 				static_cast<SdrGrafObj*>(mpObj.get())->ForceSwapOut();
1769 			}
1770 			bOk = true;
1771 		}
1772 		break;
1773 	}
1774 
1775 	case OWN_ATTR_VALUE_GRAPHIC:
1776     {
1777 		Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
1778 		if( xGraphic.is() )
1779 		{
1780 	    	static_cast< SdrGrafObj*>( mpObj.get() )->SetGraphic( xGraphic );
1781 			bOk = true;
1782 		}
1783 		break;
1784     }
1785 	default:
1786         return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
1787 	}
1788 
1789 	if( !bOk )
1790 		throw lang::IllegalArgumentException();
1791 
1792 	if( mpModel )
1793 		mpModel->SetChanged();
1794 
1795 	return true;
1796 }
1797 
1798 //----------------------------------------------------------------------
1799 
1800 bool SvxGraphicObject::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)
1801 {
1802 	switch( pProperty->nWID )
1803 	{
1804 	case OWN_ATTR_VALUE_FILLBITMAP:
1805 	{
1806 		sal_Bool bSwapped = static_cast< SdrGrafObj* >( mpObj.get() )->IsSwappedOut();
1807 		const Graphic& rGraphic = static_cast< SdrGrafObj*>( mpObj.get() )->GetGraphic();
1808 
1809 		if(rGraphic.GetType() != GRAPHIC_GDIMETAFILE)
1810 		{
1811 			// Objekt in eine Bitmap packen
1812 			Reference< ::com::sun::star::awt::XBitmap >  xBitmap( VCLUnoHelper::CreateBitmap(static_cast< SdrGrafObj*>( mpObj.get() )->GetGraphic().GetBitmapEx()) );
1813 			rValue <<= xBitmap;
1814 		}
1815 		else
1816 		{
1817 			SvMemoryStream aDestStrm( 65535, 65535 );
1818 
1819 			ConvertGDIMetaFileToWMF( rGraphic.GetGDIMetaFile(), aDestStrm, NULL, sal_False );
1820             const uno::Sequence<sal_Int8> aSeq(
1821                 static_cast< const sal_Int8* >(aDestStrm.GetData()),
1822                 aDestStrm.GetEndOfData());
1823 			rValue <<= aSeq;
1824 		}
1825 		if ( bSwapped )
1826 			static_cast< SdrGrafObj* >( mpObj.get() )->ForceSwapOut();
1827 		break;
1828 	}
1829 
1830 	case OWN_ATTR_GRAFURL:
1831 	{
1832 		if( static_cast< SdrGrafObj*>( mpObj.get() )->IsLinkedGraphic() )
1833 		{
1834 			rValue <<= OUString( static_cast< SdrGrafObj*>( mpObj.get() )->GetFileName() );
1835 		}
1836 		else
1837 		{
1838 			sal_Bool bSwapped = static_cast< SdrGrafObj* >( mpObj.get() )->IsSwappedOut();
1839 			const GraphicObject& rGrafObj = static_cast< SdrGrafObj*>( mpObj.get() )->GetGraphicObject(true);
1840 			OUString aURL( RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX));
1841 			aURL += OUString::createFromAscii( rGrafObj.GetUniqueID().GetBuffer() );
1842 			rValue <<= aURL;
1843 			if ( bSwapped )
1844 				static_cast< SdrGrafObj* >( mpObj.get() )->ForceSwapOut();
1845 		}
1846 		break;
1847 	}
1848 
1849 	case OWN_ATTR_REPLACEMENTGRAFURL:
1850 	{
1851 		const GraphicObject* pGrafObj = static_cast< SdrGrafObj* >(mpObj.get())->GetReplacementGraphicObject();
1852 
1853         if(pGrafObj)
1854         {
1855 			OUString aURL(RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX));
1856 			aURL += OUString::createFromAscii(pGrafObj->GetUniqueID().GetBuffer());
1857 			rValue <<= aURL;
1858         }
1859 
1860 		break;
1861 	}
1862 
1863     case OWN_ATTR_GRAFSTREAMURL:
1864 	{
1865 		const OUString	aStreamURL( ( (SdrGrafObj*) mpObj.get() )->GetGrafStreamURL() );
1866 		if( aStreamURL.getLength() )
1867 			rValue <<= aStreamURL;
1868 		break;
1869 	}
1870 
1871 	case OWN_ATTR_VALUE_GRAPHIC:
1872     {
1873 		sal_Bool bSwapped = static_cast< SdrGrafObj* >( mpObj.get() )->IsSwappedOut();
1874         Reference< graphic::XGraphic > xGraphic( static_cast< SdrGrafObj* >( mpObj.get() )->GetGraphic().GetXGraphic() );
1875 		rValue <<= xGraphic;
1876 		if ( bSwapped )
1877 			static_cast< SdrGrafObj* >( mpObj.get() )->ForceSwapOut();
1878 		break;
1879     }
1880 
1881 	case OWN_ATTR_GRAPHIC_STREAM:
1882 	{
1883 		rValue <<= static_cast< SdrGrafObj* >( mpObj.get() )->getInputStream();
1884 		break;
1885 	}
1886 	default:
1887         return SvxShapeText::getPropertyValueImpl(rName, pProperty,rValue);
1888 	}
1889 
1890 	return true;
1891 }
1892 
1893 ///////////////////////////////////////////////////////////////////////
1894 
1895 SvxShapeCaption::SvxShapeCaption( SdrObject* pObj ) throw()
1896 : SvxShapeText( pObj, aSvxMapProvider.GetMap(SVXMAP_CAPTION), aSvxMapProvider.GetPropertySet(SVXMAP_CAPTION, SdrObject::GetGlobalDrawObjectItemPool()) )
1897 {
1898 }
1899 
1900 SvxShapeCaption::~SvxShapeCaption() throw()
1901 {
1902 }
1903 
1904 /***********************************************************************
1905 * class SvxCustomShape                                                   *
1906 ***********************************************************************/
1907 
1908 SvxCustomShape::SvxCustomShape( SdrObject* pObj )  throw() :
1909 	SvxShapeText( pObj, aSvxMapProvider.GetMap( SVXMAP_CUSTOMSHAPE ), aSvxMapProvider.GetPropertySet(SVXMAP_CUSTOMSHAPE, SdrObject::GetGlobalDrawObjectItemPool()) )
1910 {
1911 }
1912 
1913 //----------------------------------------------------------------------
1914 SvxCustomShape::~SvxCustomShape() throw()
1915 {
1916 }
1917 
1918 //----------------------------------------------------------------------
1919 
1920 void SvxCustomShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
1921 {
1922 	SvxShapeText::Create( pNewObj, pNewPage );
1923 }
1924 
1925 //----------------------------------------------------------------------
1926 
1927 uno::Any SAL_CALL SvxCustomShape::queryInterface( const uno::Type & rType )
1928 	throw(uno::RuntimeException)
1929 {
1930     return SvxShapeText::queryInterface( rType );
1931 }
1932 
1933 uno::Any SAL_CALL SvxCustomShape::queryAggregation( const uno::Type & rType )
1934 	throw(uno::RuntimeException)
1935 {
1936 	::com::sun::star::uno::Any aReturn = SvxShapeText::queryAggregation( rType );
1937     if ( !aReturn.hasValue() )
1938 		aReturn = ::cppu::queryInterface(rType, static_cast<drawing::XEnhancedCustomShapeDefaulter*>(this) );
1939 	return aReturn;
1940 }
1941 
1942 void SAL_CALL SvxCustomShape::acquire() throw ( )
1943 {
1944 	SvxShapeText::acquire();
1945 }
1946 
1947 void SAL_CALL SvxCustomShape::release() throw ( )
1948 {
1949 	SvxShapeText::release();
1950 }
1951 
1952 //----------------------------------------------------------------------
1953 
1954 uno::Sequence< uno::Type > SAL_CALL SvxCustomShape::getTypes()
1955 	throw (uno::RuntimeException)
1956 {
1957 	return SvxShapeText::getTypes();
1958 }
1959 
1960 uno::Sequence< sal_Int8 > SAL_CALL SvxCustomShape::getImplementationId()
1961 	throw (uno::RuntimeException)
1962 {
1963 	static uno::Sequence< sal_Int8 > aId;
1964 	if( aId.getLength() == 0 )
1965 	{
1966 		aId.realloc( 16 );
1967 		rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
1968 	}
1969 	return aId;
1970 }
1971 
1972 // ::com::sun::star::drawing::XShape
1973 
1974 //----------------------------------------------------------------------
1975 OUString SAL_CALL SvxCustomShape::getShapeType()
1976 	throw( uno::RuntimeException )
1977 {
1978 	return SvxShape::getShapeType();
1979 }
1980 
1981 //------------------------------------------------------------------1----
1982 awt::Point SAL_CALL SvxCustomShape::getPosition() throw(uno::RuntimeException)
1983 {
1984 	OGuard aGuard( Application::GetSolarMutex() );
1985 	if ( mpModel && mpObj.is() )
1986 	{
1987 		SdrAShapeObjGeoData aCustomShapeGeoData;
1988 		((SdrObjCustomShape*)mpObj.get())->SaveGeoData( aCustomShapeGeoData );
1989 
1990 		sal_Bool bMirroredX = sal_False;
1991 		sal_Bool bMirroredY = sal_False;
1992 
1993 		if ( mpObj.is() )
1994 		{
1995 			bMirroredX = ( ((SdrObjCustomShape*)mpObj.get())->IsMirroredX() );
1996 			bMirroredY = ( ((SdrObjCustomShape*)mpObj.get())->IsMirroredY() );
1997 		}
1998 		// get aRect, this is the unrotated snaprect
1999 		Rectangle aRect(((SdrObjCustomShape*)mpObj.get())->GetLogicRect());
2000 		Rectangle aRectangle( aRect );
2001 
2002 		if ( bMirroredX || bMirroredY )
2003 		{	// we have to retrieve the unmirrored rect
2004 
2005 			GeoStat aNewGeo( aCustomShapeGeoData.aGeo );
2006 			if ( bMirroredX )
2007 			{
2008 				Polygon aPol( Rect2Poly( aRect, aNewGeo ) );
2009 				Rectangle aBoundRect( aPol.GetBoundRect() );
2010 
2011 				Point aRef1( ( aBoundRect.Left() + aBoundRect.Right() ) >> 1, aBoundRect.Top() );
2012 				Point aRef2( aRef1.X(), aRef1.Y() + 1000 );
2013 				sal_uInt16 i;
2014 				sal_uInt16 nPntAnz=aPol.GetSize();
2015 				for (i=0; i<nPntAnz; i++)
2016 				{
2017 					MirrorPoint(aPol[i],aRef1,aRef2);
2018 				}
2019 				// Polygon wenden und etwas schieben
2020 				Polygon aPol0(aPol);
2021 				aPol[0]=aPol0[1];
2022 				aPol[1]=aPol0[0];
2023 				aPol[2]=aPol0[3];
2024 				aPol[3]=aPol0[2];
2025 				aPol[4]=aPol0[1];
2026 				Poly2Rect(aPol,aRectangle,aNewGeo);
2027 			}
2028 			if ( bMirroredY )
2029 			{
2030 				Polygon aPol( Rect2Poly( aRectangle, aNewGeo ) );
2031 				Rectangle aBoundRect( aPol.GetBoundRect() );
2032 
2033 				Point aRef1( aBoundRect.Left(), ( aBoundRect.Top() + aBoundRect.Bottom() ) >> 1 );
2034 				Point aRef2( aRef1.X() + 1000, aRef1.Y() );
2035 				sal_uInt16 i;
2036 				sal_uInt16 nPntAnz=aPol.GetSize();
2037 				for (i=0; i<nPntAnz; i++)
2038 				{
2039 					MirrorPoint(aPol[i],aRef1,aRef2);
2040 				}
2041 				// Polygon wenden und etwas schieben
2042 				Polygon aPol0(aPol);
2043 				aPol[0]=aPol0[1];
2044 				aPol[1]=aPol0[0];
2045 				aPol[2]=aPol0[3];
2046 				aPol[3]=aPol0[2];
2047 				aPol[4]=aPol0[1];
2048 				Poly2Rect( aPol, aRectangle, aNewGeo );
2049 			}
2050 		}
2051 		Point aPt( aRectangle.TopLeft() );
2052 
2053 		if( mpModel->IsWriter() )
2054 			aPt -= mpObj->GetAnchorPos();
2055 
2056 		ForceMetricTo100th_mm(aPt);
2057 		return ::com::sun::star::awt::Point( aPt.X(), aPt.Y() );
2058 	}
2059 	else
2060 		return SvxShape::getPosition();
2061 }
2062 
2063 //----------------------------------------------------------------------
2064 void SAL_CALL SvxCustomShape::setPosition( const awt::Point& Position ) throw(uno::RuntimeException)
2065 {
2066 	SvxShapeText::setPosition(Position);
2067 }
2068 
2069 //----------------------------------------------------------------------
2070 
2071 awt::Size SAL_CALL SvxCustomShape::getSize() throw(uno::RuntimeException)
2072 {
2073 	return SvxShapeText::getSize();
2074 }
2075 
2076 //----------------------------------------------------------------------
2077 void SAL_CALL SvxCustomShape::setSize( const awt::Size& rSize )
2078 	throw(beans::PropertyVetoException, uno::RuntimeException)
2079 {
2080 	SvxShapeText::setSize( rSize );
2081 }
2082 
2083 //----------------------------------------------------------------------
2084 
2085 //----------------------------------------------------------------------
2086 void SAL_CALL SvxCustomShape::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
2087 	throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, com::sun::star::beans::PropertyVetoException, com::sun::star::lang::IllegalArgumentException)
2088 {
2089 	OGuard aGuard( Application::GetSolarMutex() );
2090     SdrObject* pObject = mpObj.get();
2091 
2092     sal_Bool bCustomShapeGeometry = pObject && aPropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "CustomShapeGeometry" ) );
2093 
2094 	sal_Bool bMirroredX = sal_False;
2095 	sal_Bool bMirroredY = sal_False;
2096 
2097 	if ( bCustomShapeGeometry )
2098 	{
2099 		bMirroredX = ( ((SdrObjCustomShape*)pObject)->IsMirroredX() );
2100 		bMirroredY = ( ((SdrObjCustomShape*)pObject)->IsMirroredY() );
2101 	}
2102 
2103 	SvxShape::setPropertyValue( aPropertyName, aValue );
2104 
2105 	if ( bCustomShapeGeometry )
2106 	{
2107 		((SdrObjCustomShape*)pObject)->MergeDefaultAttributes(0);
2108 		Rectangle aRect( pObject->GetSnapRect() );
2109 
2110 		// #i38892#
2111 		bool bNeedsMirrorX = ((SdrObjCustomShape*)pObject)->IsMirroredX() != bMirroredX;
2112 		bool bNeedsMirrorY = ((SdrObjCustomShape*)pObject)->IsMirroredY() != bMirroredY;
2113 
2114 		boost::scoped_ptr< SdrGluePointList > pListCopy;
2115 		if( bNeedsMirrorX || bNeedsMirrorY )
2116 		{
2117 			const SdrGluePointList* pList = pObject->GetGluePointList();
2118 			if( pList )
2119 				pListCopy.reset( new SdrGluePointList(*pList) );
2120 		}
2121 
2122         if ( bNeedsMirrorX )
2123 		{
2124 			Point aTop( ( aRect.Left() + aRect.Right() ) >> 1, aRect.Top() );
2125 			Point aBottom( aTop.X(), aTop.Y() + 1000 );
2126 			pObject->NbcMirror( aTop, aBottom );
2127 			// NbcMirroring is flipping the current mirror state,
2128 			// so we have to set the correct state again
2129    			((SdrObjCustomShape*)pObject)->SetMirroredX( bMirroredX ? sal_False : sal_True );
2130 		}
2131 		if ( bNeedsMirrorY )
2132 		{
2133 			Point aLeft( aRect.Left(), ( aRect.Top() + aRect.Bottom() ) >> 1 );
2134 			Point aRight( aLeft.X() + 1000, aLeft.Y() );
2135 			pObject->NbcMirror( aLeft, aRight );
2136 			// NbcMirroring is flipping the current mirror state,
2137 			// so we have to set the correct state again
2138    			((SdrObjCustomShape*)pObject)->SetMirroredY( bMirroredY ? sal_False : sal_True );
2139 		}
2140 
2141 		if( pListCopy )
2142 		{
2143 			SdrGluePointList* pNewList = const_cast< SdrGluePointList* >( pObject->GetGluePointList() );
2144 			if(pNewList)
2145 				*pNewList = *pListCopy;
2146 		}
2147 	}
2148 }
2149 
2150 bool SvxCustomShape::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)
2151 {
2152 	switch( pProperty->nWID )
2153 	{
2154 	case SDRATTR_ROTATEANGLE:
2155 	{
2156 		double fAngle = static_cast<SdrObjCustomShape*>(mpObj.get())->GetObjectRotation();
2157 		fAngle *= 100;
2158 		rValue <<= (sal_Int32)fAngle;
2159 		return true;
2160 	}
2161 	default:
2162         return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
2163 	}
2164 }
2165 //----------------------------------------------------------------------
2166 
2167 void SvxCustomShape::createCustomShapeDefaults( const rtl::OUString& rValueType ) throw (::com::sun::star::uno::RuntimeException)
2168 {
2169 	((SdrObjCustomShape*)mpObj.get())->MergeDefaultAttributes( &rValueType );
2170 }
2171