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/helper/vclunohelper.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