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/drawing/HomogenMatrix.hpp> 29 #include <com/sun/star/drawing/Position3D.hpp> 30 #include <com/sun/star/drawing/Direction3D.hpp> 31 #include <com/sun/star/drawing/DoubleSequence.hpp> 32 #include <com/sun/star/drawing/CameraGeometry.hpp> 33 #include <vcl/svapp.hxx> 34 #include <vos/mutex.hxx> 35 #include <comphelper/serviceinfohelper.hxx> 36 37 #include <rtl/uuid.h> 38 #include <rtl/memory.h> 39 #include <svx/svdpool.hxx> 40 #include <svx/unoshape.hxx> 41 #include <svx/unopage.hxx> 42 #include <editeng/unoprnms.hxx> 43 #include <svx/polysc3d.hxx> 44 #include "svx/globl3d.hxx" 45 #include <svx/cube3d.hxx> 46 #include <svx/sphere3d.hxx> 47 #include <svx/lathe3d.hxx> 48 #include <svx/extrud3d.hxx> 49 #include <svx/polygn3d.hxx> 50 #include "svx/unoshprp.hxx" 51 #include "svx/svdmodel.hxx" 52 #include <basegfx/polygon/b3dpolygon.hxx> 53 #include <basegfx/polygon/b3dpolygontools.hxx> 54 #include <com/sun/star/drawing/PolyPolygonShape3D.hpp> 55 #include <basegfx/polygon/b2dpolypolygontools.hxx> 56 57 using ::rtl::OUString; 58 using namespace ::vos; 59 using namespace ::cppu; 60 using namespace ::com::sun::star; 61 using namespace ::com::sun::star::uno; 62 using namespace ::com::sun::star::lang; 63 using namespace ::com::sun::star::container; 64 65 #define INTERFACE_TYPE( xint ) \ 66 ::getCppuType((const Reference< xint >*)0) 67 68 #define QUERYINT( xint ) \ 69 if( rType == ::getCppuType((const Reference< xint >*)0) ) \ 70 aAny <<= Reference< xint >(this) 71 72 /*********************************************************************** 73 * class Svx3DSceneObject * 74 ***********************************************************************/ 75 76 //---------------------------------------------------------------------- 77 Svx3DSceneObject::Svx3DSceneObject( SdrObject* pObj, SvxDrawPage* pDrawPage ) throw() 78 : SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_3DSCENEOBJECT), aSvxMapProvider.GetPropertySet(SVXMAP_3DSCENEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) ) 79 , mxPage( pDrawPage ) 80 { 81 } 82 83 //---------------------------------------------------------------------- 84 Svx3DSceneObject::~Svx3DSceneObject() throw() 85 { 86 } 87 88 //---------------------------------------------------------------------- 89 void Svx3DSceneObject::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage ) 90 { 91 SvxShape::Create( pNewObj, pNewPage ); 92 mxPage = pNewPage; 93 } 94 95 //---------------------------------------------------------------------- 96 uno::Any SAL_CALL Svx3DSceneObject::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 97 { 98 uno::Any aAny; 99 100 QUERYINT( drawing::XShapes ); 101 else QUERYINT( container::XIndexAccess ); 102 else QUERYINT( container::XElementAccess ); 103 else 104 return SvxShape::queryAggregation( rType ); 105 106 return aAny; 107 } 108 109 uno::Any SAL_CALL Svx3DSceneObject::queryInterface( const uno::Type & rType ) throw( uno::RuntimeException ) 110 { 111 return SvxShape::queryInterface( rType ); 112 } 113 114 void SAL_CALL Svx3DSceneObject::acquire() throw ( ) 115 { 116 SvxShape::acquire(); 117 } 118 119 void SAL_CALL Svx3DSceneObject::release() throw ( ) 120 { 121 SvxShape::release(); 122 } 123 124 // XTypeProvider 125 126 uno::Sequence< uno::Type > SAL_CALL Svx3DSceneObject::getTypes() 127 throw (uno::RuntimeException) 128 { 129 130 return SvxShape::getTypes(); 131 } 132 133 uno::Sequence< sal_Int8 > SAL_CALL Svx3DSceneObject::getImplementationId() 134 throw (uno::RuntimeException) 135 { 136 static uno::Sequence< sal_Int8 > aId; 137 if( aId.getLength() == 0 ) 138 { 139 aId.realloc( 16 ); 140 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True ); 141 } 142 return aId; 143 } 144 145 //---------------------------------------------------------------------- 146 void SAL_CALL Svx3DSceneObject::add( const Reference< drawing::XShape >& xShape ) 147 throw( uno::RuntimeException) 148 { 149 OGuard aGuard( Application::GetSolarMutex() ); 150 151 SvxShape* pShape = SvxShape::getImplementation( xShape ); 152 153 if(!mpObj.is() || !mxPage.is() || pShape == NULL || NULL != pShape->GetSdrObject() ) 154 throw uno::RuntimeException(); 155 156 SdrObject* pSdrShape = mxPage->_CreateSdrObject( xShape ); 157 if( pSdrShape->ISA(E3dObject) ) 158 { 159 mpObj->GetSubList()->NbcInsertObject( pSdrShape ); 160 161 if(pShape) 162 pShape->Create( pSdrShape, mxPage.get() ); 163 } 164 else 165 { 166 SdrObject::Free( pSdrShape ); 167 throw uno::RuntimeException(); 168 } 169 170 if( mpModel ) 171 mpModel->SetChanged(); 172 } 173 174 //---------------------------------------------------------------------- 175 void SAL_CALL Svx3DSceneObject::remove( const Reference< drawing::XShape >& xShape ) 176 throw( uno::RuntimeException ) 177 { 178 OGuard aGuard( Application::GetSolarMutex() ); 179 180 SvxShape* pShape = SvxShape::getImplementation( xShape ); 181 182 if(!mpObj.is() || pShape == NULL) 183 throw uno::RuntimeException(); 184 185 SdrObject* pSdrShape = pShape->GetSdrObject(); 186 if(pSdrShape == NULL || pSdrShape->GetObjList()->GetOwnerObj() != mpObj.get()) 187 { 188 throw uno::RuntimeException(); 189 } 190 else 191 { 192 SdrObjList& rList = *pSdrShape->GetObjList(); 193 194 const sal_uInt32 nObjCount = rList.GetObjCount(); 195 sal_uInt32 nObjNum = 0; 196 while( nObjNum < nObjCount ) 197 { 198 if(rList.GetObj( nObjNum ) == pSdrShape ) 199 break; 200 nObjNum++; 201 } 202 203 if( nObjNum < nObjCount ) 204 { 205 SdrObject* pObject = rList.NbcRemoveObject( nObjNum ); 206 SdrObject::Free( pObject ); 207 } 208 else 209 { 210 DBG_ASSERT( 0, "Fatality! SdrObject is not belonging to its SdrObjList! [CL]" ); 211 } 212 } 213 } 214 215 //---------------------------------------------------------------------- 216 sal_Int32 SAL_CALL Svx3DSceneObject::getCount() 217 throw( uno::RuntimeException ) 218 { 219 OGuard aGuard( Application::GetSolarMutex() ); 220 221 sal_Int32 nRetval = 0; 222 223 if(mpObj.is() && mpObj->ISA(E3dPolyScene) && mpObj->GetSubList()) 224 nRetval = mpObj->GetSubList()->GetObjCount(); 225 return nRetval; 226 } 227 228 //---------------------------------------------------------------------- 229 230 uno::Any SAL_CALL Svx3DSceneObject::getByIndex( sal_Int32 Index ) 231 throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException) 232 { 233 OGuard aGuard( Application::GetSolarMutex() ); 234 235 if( !mpObj.is() || mpObj->GetSubList() == NULL ) 236 throw uno::RuntimeException(); 237 238 if( mpObj->GetSubList()->GetObjCount() <= (sal_uInt32)Index ) 239 throw lang::IndexOutOfBoundsException(); 240 241 SdrObject* pDestObj = mpObj->GetSubList()->GetObj( Index ); 242 if(pDestObj == NULL) 243 throw lang::IndexOutOfBoundsException(); 244 245 Reference< drawing::XShape > xShape( pDestObj->getUnoShape(), uno::UNO_QUERY ); 246 uno::Any aAny; 247 aAny <<= xShape; 248 return aAny; 249 } 250 251 //---------------------------------------------------------------------- 252 // ::com::sun::star::container::XElementAccess 253 254 uno::Type SAL_CALL Svx3DSceneObject::getElementType() 255 throw( uno::RuntimeException ) 256 { 257 return ::getCppuType(( const Reference< drawing::XShape>*)0); 258 } 259 260 //---------------------------------------------------------------------- 261 sal_Bool SAL_CALL Svx3DSceneObject::hasElements() 262 throw( uno::RuntimeException ) 263 { 264 OGuard aGuard( Application::GetSolarMutex() ); 265 266 return mpObj.is() && mpObj->GetSubList() && (mpObj->GetSubList()->GetObjCount() > 0); 267 } 268 269 //---------------------------------------------------------------------- 270 271 static bool ConvertHomogenMatrixToObject( E3dObject* pObject, const Any& rValue ) 272 { 273 drawing::HomogenMatrix m; 274 if( rValue >>= m ) 275 { 276 basegfx::B3DHomMatrix aMat; 277 aMat.set(0, 0, m.Line1.Column1); 278 aMat.set(0, 1, m.Line1.Column2); 279 aMat.set(0, 2, m.Line1.Column3); 280 aMat.set(0, 3, m.Line1.Column4); 281 aMat.set(1, 0, m.Line2.Column1); 282 aMat.set(1, 1, m.Line2.Column2); 283 aMat.set(1, 2, m.Line2.Column3); 284 aMat.set(1, 3, m.Line2.Column4); 285 aMat.set(2, 0, m.Line3.Column1); 286 aMat.set(2, 1, m.Line3.Column2); 287 aMat.set(2, 2, m.Line3.Column3); 288 aMat.set(2, 3, m.Line3.Column4); 289 aMat.set(3, 0, m.Line4.Column1); 290 aMat.set(3, 1, m.Line4.Column2); 291 aMat.set(3, 2, m.Line4.Column3); 292 aMat.set(3, 3, m.Line4.Column4); 293 pObject->SetTransform(aMat); 294 return true; 295 } 296 return false; 297 } 298 299 static void ConvertObjectToHomogenMatric( E3dObject* pObject, Any& rValue ) 300 { 301 drawing::HomogenMatrix aHomMat; 302 const basegfx::B3DHomMatrix& rMat = pObject->GetTransform(); 303 aHomMat.Line1.Column1 = rMat.get(0, 0); 304 aHomMat.Line1.Column2 = rMat.get(0, 1); 305 aHomMat.Line1.Column3 = rMat.get(0, 2); 306 aHomMat.Line1.Column4 = rMat.get(0, 3); 307 aHomMat.Line2.Column1 = rMat.get(1, 0); 308 aHomMat.Line2.Column2 = rMat.get(1, 1); 309 aHomMat.Line2.Column3 = rMat.get(1, 2); 310 aHomMat.Line2.Column4 = rMat.get(1, 3); 311 aHomMat.Line3.Column1 = rMat.get(2, 0); 312 aHomMat.Line3.Column2 = rMat.get(2, 1); 313 aHomMat.Line3.Column3 = rMat.get(2, 2); 314 aHomMat.Line3.Column4 = rMat.get(2, 3); 315 aHomMat.Line4.Column1 = rMat.get(3, 0); 316 aHomMat.Line4.Column2 = rMat.get(3, 1); 317 aHomMat.Line4.Column3 = rMat.get(3, 2); 318 aHomMat.Line4.Column4 = rMat.get(3, 3); 319 rValue <<= aHomMat; 320 } 321 322 //---------------------------------------------------------------------- 323 #include <svx/svditer.hxx> 324 325 struct ImpRememberTransAndRect 326 { 327 basegfx::B3DHomMatrix maMat; 328 Rectangle maRect; 329 }; 330 331 bool Svx3DSceneObject::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) 332 { 333 switch( pProperty->nWID ) 334 { 335 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 336 { 337 // Transformationsmatrix in das Objekt packen 338 if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( mpObj.get() ), rValue ) ) 339 return true; 340 break; 341 } 342 case OWN_ATTR_3D_VALUE_CAMERA_GEOMETRY: 343 { 344 // set CameraGeometry at scene 345 E3dScene* pScene = static_cast< E3dScene* >( mpObj.get() ); 346 drawing::CameraGeometry aCamGeo; 347 348 if(rValue >>= aCamGeo) 349 { 350 basegfx::B3DPoint aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ); 351 basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ); 352 basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ); 353 354 // rescue scene transformation 355 ImpRememberTransAndRect aSceneTAR; 356 aSceneTAR.maMat = pScene->GetTransform(); 357 aSceneTAR.maRect = pScene->GetSnapRect(); 358 359 // rescue object transformations 360 SdrObjListIter aIter(*pScene->GetSubList(), IM_DEEPWITHGROUPS); 361 List aObjTrans; 362 while(aIter.IsMore()) 363 { 364 E3dObject* p3DObj = (E3dObject*)aIter.Next(); 365 basegfx::B3DHomMatrix* pNew = new basegfx::B3DHomMatrix; 366 *pNew = p3DObj->GetTransform(); 367 aObjTrans.Insert(pNew, LIST_APPEND); 368 } 369 370 // reset object transformations 371 aIter.Reset(); 372 while(aIter.IsMore()) 373 { 374 E3dObject* p3DObj = (E3dObject*)aIter.Next(); 375 p3DObj->NbcSetTransform(basegfx::B3DHomMatrix()); 376 } 377 378 // reset scene transformation and make a complete recalc 379 pScene->NbcSetTransform(basegfx::B3DHomMatrix()); 380 381 // fill old camera from new parameters 382 Camera3D aCam(pScene->GetCamera()); 383 const basegfx::B3DRange& rVolume = pScene->GetBoundVolume(); 384 double fW = rVolume.getWidth(); 385 double fH = rVolume.getHeight(); 386 387 const SfxItemSet& rSceneSet = pScene->GetMergedItemSet(); 388 double fCamPosZ = 389 (double)((const SfxUInt32Item&)rSceneSet.Get(SDRATTR_3DSCENE_DISTANCE)).GetValue(); 390 double fCamFocal = 391 (double)((const SfxUInt32Item&)rSceneSet.Get(SDRATTR_3DSCENE_FOCAL_LENGTH)).GetValue(); 392 393 aCam.SetAutoAdjustProjection(sal_False); 394 aCam.SetViewWindow(- fW / 2, - fH / 2, fW, fH); 395 basegfx::B3DPoint aLookAt; 396 basegfx::B3DPoint aCamPos(0.0, 0.0, fCamPosZ); 397 aCam.SetPosAndLookAt(aCamPos, aLookAt); 398 aCam.SetFocalLength(fCamFocal / 100.0); 399 aCam.SetDefaults(basegfx::B3DPoint(0.0, 0.0, fCamPosZ), aLookAt, fCamFocal / 100.0); 400 aCam.SetDeviceWindow(Rectangle(0, 0, (long)fW, (long)fH)); 401 402 // set at scene 403 pScene->SetCamera(aCam); 404 405 // #91047# use imported VRP, VPN and VUP (if used) 406 sal_Bool bVRPUsed(!aVRP.equal(basegfx::B3DPoint(0.0, 0.0, 1.0))); 407 sal_Bool bVPNUsed(!aVPN.equal(basegfx::B3DVector(0.0, 0.0, 1.0))); 408 sal_Bool bVUPUsed(!aVUP.equal(basegfx::B3DVector(0.0, 1.0, 0.0))); 409 410 if(bVRPUsed || bVPNUsed || bVUPUsed) 411 { 412 pScene->GetCameraSet().SetViewportValues(aVRP, aVPN, aVUP); 413 } 414 415 // set object transformations again at objects 416 aIter.Reset(); 417 sal_uInt32 nIndex(0L); 418 while(aIter.IsMore()) 419 { 420 E3dObject* p3DObj = (E3dObject*)aIter.Next(); 421 basegfx::B3DHomMatrix* pMat = (basegfx::B3DHomMatrix*)aObjTrans.GetObject(nIndex++); 422 p3DObj->NbcSetTransform(*pMat); 423 delete pMat; 424 } 425 426 // set scene transformation again at scene 427 pScene->NbcSetTransform(aSceneTAR.maMat); 428 pScene->NbcSetSnapRect(aSceneTAR.maRect); 429 430 return true; 431 } 432 break; 433 } 434 default: 435 return SvxShape::setPropertyValueImpl(rName, pProperty, rValue); 436 } 437 438 throw IllegalArgumentException(); 439 } 440 441 //---------------------------------------------------------------------- 442 443 bool Svx3DSceneObject::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) 444 { 445 switch( pProperty->nWID ) 446 { 447 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 448 { 449 // Objekt in eine homogene 4x4 Matrix packen 450 ConvertObjectToHomogenMatric( static_cast< E3dObject* >( mpObj.get() ), rValue ); 451 break; 452 } 453 case OWN_ATTR_3D_VALUE_CAMERA_GEOMETRY: 454 { 455 // get CameraGeometry from scene 456 E3dScene* pScene = static_cast< E3dScene* >( mpObj.get() ); 457 drawing::CameraGeometry aCamGeo; 458 459 // fill Vectors from scene camera 460 B3dCamera& aCameraSet = pScene->GetCameraSet(); 461 basegfx::B3DPoint aVRP(aCameraSet.GetVRP()); 462 basegfx::B3DVector aVPN(aCameraSet.GetVPN()); 463 basegfx::B3DVector aVUP(aCameraSet.GetVUV()); 464 465 // transfer to structure 466 aCamGeo.vrp.PositionX = aVRP.getX(); 467 aCamGeo.vrp.PositionY = aVRP.getY(); 468 aCamGeo.vrp.PositionZ = aVRP.getZ(); 469 aCamGeo.vpn.DirectionX = aVPN.getX(); 470 aCamGeo.vpn.DirectionY = aVPN.getY(); 471 aCamGeo.vpn.DirectionZ = aVPN.getZ(); 472 aCamGeo.vup.DirectionX = aVUP.getX(); 473 aCamGeo.vup.DirectionY = aVUP.getY(); 474 aCamGeo.vup.DirectionZ = aVUP.getZ(); 475 476 rValue <<= aCamGeo; 477 break; 478 } 479 default: 480 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); 481 } 482 483 return true; 484 } 485 486 // ::com::sun::star::lang::XServiceInfo 487 uno::Sequence< OUString > SAL_CALL Svx3DSceneObject::getSupportedServiceNames() 488 throw(uno::RuntimeException) 489 { 490 uno::Sequence< OUString > aSeq( SvxShape::getSupportedServiceNames() ); 491 comphelper::ServiceInfoHelper::addToSequence( aSeq, 1, "com.sun.star.drawing.Shape3DScene" ); 492 return aSeq; 493 } 494 495 /*********************************************************************** 496 * * 497 ***********************************************************************/ 498 499 //---------------------------------------------------------------------- 500 Svx3DCubeObject::Svx3DCubeObject( SdrObject* pObj ) throw() 501 : SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_3DCUBEOBJEKT), aSvxMapProvider.GetPropertySet(SVXMAP_3DCUBEOBJEKT, SdrObject::GetGlobalDrawObjectItemPool()) ) 502 { 503 } 504 505 //---------------------------------------------------------------------- 506 Svx3DCubeObject::~Svx3DCubeObject() throw() 507 { 508 } 509 510 //---------------------------------------------------------------------- 511 bool Svx3DCubeObject::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) 512 { 513 OGuard aGuard( Application::GetSolarMutex() ); 514 515 switch( pProperty->nWID ) 516 { 517 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 518 { 519 // Transformationsmatrix in das Objekt packen 520 if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( mpObj.get() ), rValue ) ) 521 return true; 522 break; 523 } 524 case OWN_ATTR_3D_VALUE_POSITION: 525 { 526 // Position in das Objekt packen 527 drawing::Position3D aUnoPos; 528 if( rValue >>= aUnoPos ) 529 { 530 basegfx::B3DPoint aPos(aUnoPos.PositionX, aUnoPos.PositionY, aUnoPos.PositionZ); 531 static_cast< E3dCubeObj* >( mpObj.get() )->SetCubePos(aPos); 532 return true; 533 } 534 break; 535 } 536 case OWN_ATTR_3D_VALUE_SIZE: 537 { 538 // Groesse in das Objekt packen 539 drawing::Direction3D aDirection; 540 if( rValue >>= aDirection ) 541 { 542 basegfx::B3DVector aSize(aDirection.DirectionX, aDirection.DirectionY, aDirection.DirectionZ); 543 static_cast< E3dCubeObj* >( mpObj.get() )->SetCubeSize(aSize); 544 return true; 545 } 546 break; 547 } 548 case OWN_ATTR_3D_VALUE_POS_IS_CENTER: 549 { 550 sal_Bool bNew = sal_False; 551 // sal_Bool bPosIsCenter in das Objekt packen 552 if( rValue >>= bNew ) 553 { 554 static_cast< E3dCubeObj* >( mpObj.get() )->SetPosIsCenter(bNew); 555 return true; 556 } 557 break; 558 } 559 default: 560 return SvxShape::setPropertyValueImpl( rName, pProperty, rValue ); 561 } 562 563 throw IllegalArgumentException(); 564 } 565 566 //---------------------------------------------------------------------- 567 568 bool Svx3DCubeObject::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) 569 { 570 switch( pProperty->nWID ) 571 { 572 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 573 { 574 // Transformation in eine homogene Matrix packen 575 ConvertObjectToHomogenMatric( static_cast< E3dObject* >( mpObj.get() ), rValue ); 576 break; 577 } 578 case OWN_ATTR_3D_VALUE_POSITION: 579 { 580 // Position packen 581 const basegfx::B3DPoint& rPos = ((E3dCubeObj*)mpObj.get())->GetCubePos(); 582 drawing::Position3D aPos; 583 584 aPos.PositionX = rPos.getX(); 585 aPos.PositionY = rPos.getY(); 586 aPos.PositionZ = rPos.getZ(); 587 588 rValue <<= aPos; 589 break; 590 } 591 case OWN_ATTR_3D_VALUE_SIZE: 592 { 593 // Groesse packen 594 const basegfx::B3DVector& rSize = static_cast<E3dCubeObj*>(mpObj.get())->GetCubeSize(); 595 drawing::Direction3D aDir; 596 597 aDir.DirectionX = rSize.getX(); 598 aDir.DirectionY = rSize.getY(); 599 aDir.DirectionZ = rSize.getZ(); 600 601 rValue <<= aDir; 602 break; 603 } 604 case OWN_ATTR_3D_VALUE_POS_IS_CENTER: 605 { 606 rValue <<= static_cast<E3dCubeObj*>(mpObj.get())->GetPosIsCenter(); 607 break; 608 } 609 default: 610 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); 611 } 612 613 return true; 614 } 615 616 // ::com::sun::star::lang::XServiceInfo 617 uno::Sequence< OUString > SAL_CALL Svx3DCubeObject::getSupportedServiceNames() 618 throw(uno::RuntimeException) 619 { 620 uno::Sequence< OUString > aSeq( SvxShape::getSupportedServiceNames() ); 621 comphelper::ServiceInfoHelper::addToSequence( aSeq, 2, "com.sun.star.drawing.Shape3D", 622 "com.sun.star.drawing.Shape3DCube"); 623 return aSeq; 624 } 625 626 /*********************************************************************** 627 * * 628 ***********************************************************************/ 629 630 //---------------------------------------------------------------------- 631 Svx3DSphereObject::Svx3DSphereObject( SdrObject* pObj ) throw() 632 : SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_3DSPHEREOBJECT), aSvxMapProvider.GetPropertySet(SVXMAP_3DSPHEREOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) ) 633 { 634 } 635 636 //---------------------------------------------------------------------- 637 Svx3DSphereObject::~Svx3DSphereObject() throw() 638 { 639 } 640 641 //---------------------------------------------------------------------- 642 643 bool Svx3DSphereObject::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) 644 { 645 switch( pProperty->nWID ) 646 { 647 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 648 { 649 // Transformationsmatrix in das Objekt packen 650 if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( mpObj.get() ), rValue ) ) 651 return true; 652 break; 653 } 654 655 case OWN_ATTR_3D_VALUE_POSITION: 656 { 657 // Position in das Objekt packen 658 drawing::Position3D aUnoPos; 659 if( rValue >>= aUnoPos ) 660 { 661 basegfx::B3DPoint aPos(aUnoPos.PositionX, aUnoPos.PositionY, aUnoPos.PositionZ); 662 static_cast<E3dSphereObj*>(mpObj.get())->SetCenter(aPos); 663 return true; 664 } 665 break; 666 } 667 668 case OWN_ATTR_3D_VALUE_SIZE: 669 { 670 // Groesse in das Objekt packen 671 drawing::Direction3D aDir; 672 if( rValue >>= aDir ) 673 { 674 basegfx::B3DVector aPos(aDir.DirectionX, aDir.DirectionY, aDir.DirectionZ); 675 static_cast<E3dSphereObj*>(mpObj.get())->SetSize(aPos); 676 return true; 677 } 678 break; 679 } 680 default: 681 return SvxShape::setPropertyValueImpl( rName, pProperty, rValue ); 682 } 683 684 throw IllegalArgumentException(); 685 } 686 687 //---------------------------------------------------------------------- 688 689 bool Svx3DSphereObject::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) 690 { 691 switch( pProperty->nWID ) 692 { 693 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 694 { 695 // Transformation in eine homogene Matrix packen 696 ConvertObjectToHomogenMatric( static_cast< E3dObject* >( mpObj.get() ), rValue ); 697 break; 698 } 699 case OWN_ATTR_3D_VALUE_POSITION: 700 { 701 // Position packen 702 const basegfx::B3DPoint& rPos = ((E3dSphereObj*)mpObj.get())->Center(); 703 drawing::Position3D aPos; 704 705 aPos.PositionX = rPos.getX(); 706 aPos.PositionY = rPos.getY(); 707 aPos.PositionZ = rPos.getZ(); 708 709 rValue <<= aPos; 710 break; 711 } 712 case OWN_ATTR_3D_VALUE_SIZE: 713 { 714 // Groesse packen 715 const basegfx::B3DVector& rSize = ((E3dSphereObj*)mpObj.get())->Size(); 716 drawing::Direction3D aDir; 717 718 aDir.DirectionX = rSize.getX(); 719 aDir.DirectionY = rSize.getY(); 720 aDir.DirectionZ = rSize.getZ(); 721 722 rValue <<= aDir; 723 break; 724 } 725 default: 726 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); 727 } 728 729 return true; 730 } 731 732 // ::com::sun::star::lang::XServiceInfo 733 uno::Sequence< OUString > SAL_CALL Svx3DSphereObject::getSupportedServiceNames() 734 throw(uno::RuntimeException) 735 { 736 uno::Sequence< OUString > aSeq( SvxShape::getSupportedServiceNames() ); 737 comphelper::ServiceInfoHelper::addToSequence( aSeq, 2, "com.sun.star.drawing.Shape3D", 738 "com.sun.star.drawing.Shape3DSphere"); 739 return aSeq; 740 } 741 742 /*********************************************************************** 743 * * 744 ***********************************************************************/ 745 746 //---------------------------------------------------------------------- 747 Svx3DLatheObject::Svx3DLatheObject( SdrObject* pObj ) throw() 748 : SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_3DLATHEOBJECT), aSvxMapProvider.GetPropertySet(SVXMAP_3DLATHEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) ) 749 { 750 } 751 752 //---------------------------------------------------------------------- 753 Svx3DLatheObject::~Svx3DLatheObject() throw() 754 { 755 } 756 757 bool PolyPolygonShape3D_to_B3dPolyPolygon( 758 const Any& rValue, 759 basegfx::B3DPolyPolygon& rResultPolygon, 760 bool bCorrectPolygon) 761 { 762 drawing::PolyPolygonShape3D aSourcePolyPolygon; 763 if( !(rValue >>= aSourcePolyPolygon) ) 764 return false; 765 766 sal_Int32 nOuterSequenceCount = aSourcePolyPolygon.SequenceX.getLength(); 767 if(nOuterSequenceCount != aSourcePolyPolygon.SequenceY.getLength() || nOuterSequenceCount != aSourcePolyPolygon.SequenceZ.getLength()) 768 return false; 769 770 drawing::DoubleSequence* pInnerSequenceX = aSourcePolyPolygon.SequenceX.getArray(); 771 drawing::DoubleSequence* pInnerSequenceY = aSourcePolyPolygon.SequenceY.getArray(); 772 drawing::DoubleSequence* pInnerSequenceZ = aSourcePolyPolygon.SequenceZ.getArray(); 773 for(sal_Int32 a(0L);a<nOuterSequenceCount;a++) 774 { 775 sal_Int32 nInnerSequenceCount = pInnerSequenceX->getLength(); 776 if(nInnerSequenceCount != pInnerSequenceY->getLength() || nInnerSequenceCount != pInnerSequenceZ->getLength()) 777 { 778 return false; 779 } 780 basegfx::B3DPolygon aNewPolygon; 781 double* pArrayX = pInnerSequenceX->getArray(); 782 double* pArrayY = pInnerSequenceY->getArray(); 783 double* pArrayZ = pInnerSequenceZ->getArray(); 784 for(sal_Int32 b(0L);b<nInnerSequenceCount;b++) 785 { 786 aNewPolygon.append(basegfx::B3DPoint(*pArrayX++,*pArrayY++,*pArrayZ++)); 787 } 788 pInnerSequenceX++; 789 pInnerSequenceY++; 790 pInnerSequenceZ++; 791 792 // #i101520# correction is needed for imported polygons of old format, 793 // see callers 794 if(bCorrectPolygon) 795 { 796 basegfx::tools::checkClosed(aNewPolygon); 797 } 798 799 rResultPolygon.append(aNewPolygon); 800 } 801 return true; 802 } 803 804 static void B3dPolyPolygon_to_PolyPolygonShape3D( const basegfx::B3DPolyPolygon& rSourcePolyPolygon, Any& rValue ) 805 { 806 drawing::PolyPolygonShape3D aRetval; 807 aRetval.SequenceX.realloc(rSourcePolyPolygon.count()); 808 aRetval.SequenceY.realloc(rSourcePolyPolygon.count()); 809 aRetval.SequenceZ.realloc(rSourcePolyPolygon.count()); 810 drawing::DoubleSequence* pOuterSequenceX = aRetval.SequenceX.getArray(); 811 drawing::DoubleSequence* pOuterSequenceY = aRetval.SequenceY.getArray(); 812 drawing::DoubleSequence* pOuterSequenceZ = aRetval.SequenceZ.getArray(); 813 for(sal_uInt32 a(0L);a<rSourcePolyPolygon.count();a++) 814 { 815 const basegfx::B3DPolygon aPoly(rSourcePolyPolygon.getB3DPolygon(a)); 816 sal_Int32 nPointCount(aPoly.count()); 817 if(aPoly.isClosed()) nPointCount++; 818 pOuterSequenceX->realloc(nPointCount); 819 pOuterSequenceY->realloc(nPointCount); 820 pOuterSequenceZ->realloc(nPointCount); 821 double* pInnerSequenceX = pOuterSequenceX->getArray(); 822 double* pInnerSequenceY = pOuterSequenceY->getArray(); 823 double* pInnerSequenceZ = pOuterSequenceZ->getArray(); 824 for(sal_uInt32 b(0L);b<aPoly.count();b++) 825 { 826 const basegfx::B3DPoint aPoint(aPoly.getB3DPoint(b)); 827 *pInnerSequenceX++ = aPoint.getX(); 828 *pInnerSequenceY++ = aPoint.getY(); 829 *pInnerSequenceZ++ = aPoint.getZ(); 830 } 831 if(aPoly.isClosed()) 832 { 833 const basegfx::B3DPoint aPoint(aPoly.getB3DPoint(0L)); 834 *pInnerSequenceX++ = aPoint.getX(); 835 *pInnerSequenceY++ = aPoint.getY(); 836 *pInnerSequenceZ++ = aPoint.getZ(); 837 } 838 pOuterSequenceX++; 839 pOuterSequenceY++; 840 pOuterSequenceZ++; 841 } 842 rValue <<= aRetval; 843 } 844 845 //---------------------------------------------------------------------- 846 847 bool Svx3DLatheObject::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) 848 { 849 switch( pProperty->nWID ) 850 { 851 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 852 { 853 // Transformationsmatrix in das Objekt packen 854 if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( mpObj.get() ), rValue ) ) 855 return true; 856 break; 857 } 858 case OWN_ATTR_3D_VALUE_POLYPOLYGON3D: 859 { 860 // Polygondefinition in das Objekt packen 861 basegfx::B3DPolyPolygon aNewB3DPolyPolygon; 862 863 // #i101520# Probably imported 864 if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, true ) ) 865 { 866 // #105127# SetPolyPoly3D sets the Svx3DVerticalSegmentsItem to the number 867 // of points of the polygon. Thus, value gets lost. To avoid this, rescue 868 // item here and re-set after setting the polygon. 869 const sal_uInt32 nPrevVerticalSegs(static_cast<E3dLatheObj*>(mpObj.get())->GetVerticalSegments()); 870 871 // Polygon setzen 872 const basegfx::B3DHomMatrix aIdentity; 873 const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(aNewB3DPolyPolygon, aIdentity)); 874 static_cast<E3dLatheObj*>(mpObj.get())->SetPolyPoly2D(aB2DPolyPolygon); 875 const sal_uInt32 nPostVerticalSegs(static_cast<E3dLatheObj*>(mpObj.get())->GetVerticalSegments()); 876 877 if(nPrevVerticalSegs != nPostVerticalSegs) 878 { 879 // restore the vertical segment count 880 static_cast<E3dLatheObj*>(mpObj.get())->SetMergedItem(Svx3DVerticalSegmentsItem(nPrevVerticalSegs)); 881 } 882 return true; 883 } 884 break; 885 } 886 default: 887 return SvxShape::setPropertyValueImpl( rName, pProperty, rValue ); 888 } 889 890 throw IllegalArgumentException(); 891 } 892 893 //---------------------------------------------------------------------- 894 bool Svx3DLatheObject::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) 895 { 896 switch( pProperty->nWID ) 897 { 898 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 899 { 900 // Transformation in eine homogene Matrix packen 901 drawing::HomogenMatrix aHomMat; 902 basegfx::B3DHomMatrix aMat = static_cast<E3dObject*>(mpObj.get())->GetTransform(); 903 904 // pack evtl. transformed matrix to output 905 aHomMat.Line1.Column1 = aMat.get(0, 0); 906 aHomMat.Line1.Column2 = aMat.get(0, 1); 907 aHomMat.Line1.Column3 = aMat.get(0, 2); 908 aHomMat.Line1.Column4 = aMat.get(0, 3); 909 aHomMat.Line2.Column1 = aMat.get(1, 0); 910 aHomMat.Line2.Column2 = aMat.get(1, 1); 911 aHomMat.Line2.Column3 = aMat.get(1, 2); 912 aHomMat.Line2.Column4 = aMat.get(1, 3); 913 aHomMat.Line3.Column1 = aMat.get(2, 0); 914 aHomMat.Line3.Column2 = aMat.get(2, 1); 915 aHomMat.Line3.Column3 = aMat.get(2, 2); 916 aHomMat.Line3.Column4 = aMat.get(2, 3); 917 aHomMat.Line4.Column1 = aMat.get(3, 0); 918 aHomMat.Line4.Column2 = aMat.get(3, 1); 919 aHomMat.Line4.Column3 = aMat.get(3, 2); 920 aHomMat.Line4.Column4 = aMat.get(3, 3); 921 922 rValue <<= aHomMat; 923 break; 924 } 925 case OWN_ATTR_3D_VALUE_POLYPOLYGON3D: 926 { 927 const basegfx::B2DPolyPolygon& rPolyPoly = static_cast<E3dLatheObj*>(mpObj.get())->GetPolyPoly2D(); 928 const basegfx::B3DPolyPolygon aB3DPolyPolygon(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPoly)); 929 930 B3dPolyPolygon_to_PolyPolygonShape3D(aB3DPolyPolygon, rValue); 931 break; 932 } 933 default: 934 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); 935 } 936 937 return true; 938 } 939 940 // ::com::sun::star::lang::XServiceInfo 941 uno::Sequence< OUString > SAL_CALL Svx3DLatheObject::getSupportedServiceNames() 942 throw(uno::RuntimeException) 943 { 944 uno::Sequence< OUString > aSeq( SvxShape::getSupportedServiceNames() ); 945 comphelper::ServiceInfoHelper::addToSequence( aSeq, 2, "com.sun.star.drawing.Shape3D", 946 "com.sun.star.drawing.Shape3DLathe"); 947 return aSeq; 948 } 949 950 /*********************************************************************** 951 * * 952 ***********************************************************************/ 953 954 Svx3DExtrudeObject::Svx3DExtrudeObject( SdrObject* pObj ) throw() 955 : SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_3DEXTRUDEOBJECT), aSvxMapProvider.GetPropertySet(SVXMAP_3DEXTRUDEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) ) 956 { 957 } 958 959 //---------------------------------------------------------------------- 960 Svx3DExtrudeObject::~Svx3DExtrudeObject() throw() 961 { 962 } 963 964 //---------------------------------------------------------------------- 965 966 bool Svx3DExtrudeObject::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) 967 { 968 switch( pProperty->nWID ) 969 { 970 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 971 { 972 // Transformationsmatrix in das Objekt packen 973 if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( mpObj.get() ), rValue ) ) 974 return true; 975 break; 976 } 977 978 case OWN_ATTR_3D_VALUE_POLYPOLYGON3D: 979 { 980 // Polygondefinition in das Objekt packen 981 basegfx::B3DPolyPolygon aNewB3DPolyPolygon; 982 983 // #i101520# Probably imported 984 if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, true ) ) 985 { 986 // Polygon setzen 987 const basegfx::B3DHomMatrix aIdentity; 988 const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(aNewB3DPolyPolygon, aIdentity)); 989 static_cast<E3dExtrudeObj*>(mpObj.get())->SetExtrudePolygon(aB2DPolyPolygon); 990 return true; 991 } 992 break; 993 } 994 default: 995 return SvxShape::setPropertyValueImpl( rName, pProperty, rValue ); 996 } 997 998 throw IllegalArgumentException(); 999 } 1000 1001 //---------------------------------------------------------------------- 1002 1003 bool Svx3DExtrudeObject::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) 1004 { 1005 switch( pProperty->nWID ) 1006 { 1007 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 1008 { 1009 // Transformation in eine homogene Matrix packen 1010 drawing::HomogenMatrix aHomMat; 1011 basegfx::B3DHomMatrix aMat = ((E3dObject*)mpObj.get())->GetTransform(); 1012 1013 // pack evtl. transformed matrix to output 1014 aHomMat.Line1.Column1 = aMat.get(0, 0); 1015 aHomMat.Line1.Column2 = aMat.get(0, 1); 1016 aHomMat.Line1.Column3 = aMat.get(0, 2); 1017 aHomMat.Line1.Column4 = aMat.get(0, 3); 1018 aHomMat.Line2.Column1 = aMat.get(1, 0); 1019 aHomMat.Line2.Column2 = aMat.get(1, 1); 1020 aHomMat.Line2.Column3 = aMat.get(1, 2); 1021 aHomMat.Line2.Column4 = aMat.get(1, 3); 1022 aHomMat.Line3.Column1 = aMat.get(2, 0); 1023 aHomMat.Line3.Column2 = aMat.get(2, 1); 1024 aHomMat.Line3.Column3 = aMat.get(2, 2); 1025 aHomMat.Line3.Column4 = aMat.get(2, 3); 1026 aHomMat.Line4.Column1 = aMat.get(3, 0); 1027 aHomMat.Line4.Column2 = aMat.get(3, 1); 1028 aHomMat.Line4.Column3 = aMat.get(3, 2); 1029 aHomMat.Line4.Column4 = aMat.get(3, 3); 1030 1031 rValue <<= aHomMat; 1032 break; 1033 } 1034 1035 case OWN_ATTR_3D_VALUE_POLYPOLYGON3D: 1036 { 1037 // Polygondefinition packen 1038 const basegfx::B2DPolyPolygon& rPolyPoly = static_cast<E3dExtrudeObj*>(mpObj.get())->GetExtrudePolygon(); 1039 const basegfx::B3DPolyPolygon aB3DPolyPolygon(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPoly)); 1040 1041 B3dPolyPolygon_to_PolyPolygonShape3D(aB3DPolyPolygon, rValue); 1042 break; 1043 } 1044 default: 1045 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); 1046 } 1047 1048 return true; 1049 } 1050 1051 // ::com::sun::star::lang::XServiceInfo 1052 uno::Sequence< OUString > SAL_CALL Svx3DExtrudeObject::getSupportedServiceNames() 1053 throw(uno::RuntimeException) 1054 { 1055 uno::Sequence< OUString > aSeq( SvxShape::getSupportedServiceNames() ); 1056 comphelper::ServiceInfoHelper::addToSequence( aSeq, 2, "com.sun.star.drawing.Shape3D", 1057 "com.sun.star.drawing.Shape3DExtrude"); 1058 return aSeq; 1059 } 1060 1061 /*********************************************************************** 1062 * * 1063 ***********************************************************************/ 1064 1065 //---------------------------------------------------------------------- 1066 Svx3DPolygonObject::Svx3DPolygonObject( SdrObject* pObj ) throw() 1067 : SvxShape( pObj, aSvxMapProvider.GetMap(SVXMAP_3DPOLYGONOBJECT), aSvxMapProvider.GetPropertySet(SVXMAP_3DPOLYGONOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) ) 1068 { 1069 } 1070 1071 //---------------------------------------------------------------------- 1072 Svx3DPolygonObject::~Svx3DPolygonObject() throw() 1073 { 1074 } 1075 1076 //---------------------------------------------------------------------- 1077 bool Svx3DPolygonObject::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) 1078 { 1079 switch( pProperty->nWID ) 1080 { 1081 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 1082 { 1083 // Transformationsmatrix in das Objekt packen 1084 if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( mpObj.get() ), rValue ) ) 1085 return true; 1086 break; 1087 } 1088 1089 case OWN_ATTR_3D_VALUE_POLYPOLYGON3D: 1090 { 1091 // Polygondefinition in das Objekt packen 1092 basegfx::B3DPolyPolygon aNewB3DPolyPolygon; 1093 1094 // #i101520# Direct API data (e.g. from chart) 1095 if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, false ) ) 1096 { 1097 // Polygon setzen 1098 static_cast<E3dPolygonObj*>(mpObj.get())->SetPolyPolygon3D(aNewB3DPolyPolygon); 1099 return true; 1100 } 1101 break; 1102 } 1103 case OWN_ATTR_3D_VALUE_NORMALSPOLYGON3D: 1104 { 1105 // Normalendefinition in das Objekt packen 1106 basegfx::B3DPolyPolygon aNewB3DPolyPolygon; 1107 1108 // #i101520# Direct API data (e.g. from chart) 1109 if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, false ) ) 1110 { 1111 // Polygon setzen 1112 static_cast<E3dPolygonObj*>(mpObj.get())->SetPolyNormals3D(aNewB3DPolyPolygon); 1113 return true; 1114 } 1115 break; 1116 } 1117 case OWN_ATTR_3D_VALUE_TEXTUREPOLYGON3D: 1118 { 1119 // Texturdefinition in das Objekt packen 1120 basegfx::B3DPolyPolygon aNewB3DPolyPolygon; 1121 1122 // #i101520# Direct API data (e.g. from chart) 1123 if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, false ) ) 1124 { 1125 // Polygon setzen 1126 const basegfx::B3DHomMatrix aIdentity; 1127 const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(aNewB3DPolyPolygon, aIdentity)); 1128 static_cast<E3dPolygonObj*>(mpObj.get())->SetPolyTexture2D(aB2DPolyPolygon); 1129 return true; 1130 } 1131 break; 1132 } 1133 case OWN_ATTR_3D_VALUE_LINEONLY: 1134 { 1135 sal_Bool bNew = sal_False; 1136 if( rValue >>= bNew ) 1137 { 1138 static_cast<E3dPolygonObj*>(mpObj.get())->SetLineOnly(bNew); 1139 return true; 1140 } 1141 break; 1142 } 1143 default: 1144 return SvxShape::setPropertyValueImpl( rName, pProperty, rValue ); 1145 } 1146 1147 throw IllegalArgumentException(); 1148 } 1149 1150 //---------------------------------------------------------------------- 1151 bool Svx3DPolygonObject::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) 1152 { 1153 switch( pProperty->nWID ) 1154 { 1155 case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX: 1156 { 1157 ConvertObjectToHomogenMatric( static_cast< E3dObject* >( mpObj.get() ), rValue ); 1158 break; 1159 } 1160 1161 case OWN_ATTR_3D_VALUE_POLYPOLYGON3D: 1162 { 1163 B3dPolyPolygon_to_PolyPolygonShape3D(static_cast<E3dPolygonObj*>(mpObj.get())->GetPolyPolygon3D(),rValue); 1164 break; 1165 } 1166 1167 case OWN_ATTR_3D_VALUE_NORMALSPOLYGON3D: 1168 { 1169 B3dPolyPolygon_to_PolyPolygonShape3D(static_cast<E3dPolygonObj*>(mpObj.get())->GetPolyNormals3D(),rValue); 1170 break; 1171 } 1172 1173 case OWN_ATTR_3D_VALUE_TEXTUREPOLYGON3D: 1174 { 1175 // Texturdefinition packen 1176 const basegfx::B2DPolyPolygon& rPolyPoly = static_cast<E3dPolygonObj*>(mpObj.get())->GetPolyTexture2D(); 1177 const basegfx::B3DPolyPolygon aB3DPolyPolygon(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPoly)); 1178 1179 B3dPolyPolygon_to_PolyPolygonShape3D(aB3DPolyPolygon,rValue); 1180 break; 1181 } 1182 1183 case OWN_ATTR_3D_VALUE_LINEONLY: 1184 { 1185 rValue <<= (sal_Bool)static_cast<E3dPolygonObj*>(mpObj.get())->GetLineOnly(); 1186 break; 1187 } 1188 1189 default: 1190 return SvxShape::getPropertyValueImpl( rName, pProperty, rValue ); 1191 } 1192 1193 return true; 1194 } 1195 1196 // ::com::sun::star::lang::XServiceInfo 1197 uno::Sequence< OUString > SAL_CALL Svx3DPolygonObject::getSupportedServiceNames() 1198 throw(uno::RuntimeException) 1199 { 1200 Sequence< OUString > aSeq( SvxShape::getSupportedServiceNames() ); 1201 comphelper::ServiceInfoHelper::addToSequence( aSeq, 2, "com.sun.star.drawing.Shape3D", 1202 "com.sun.star.drawing.Shape3DPolygon"); 1203 return aSeq; 1204 } 1205 1206 // eof 1207