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