svx/source/unodraw/unoshap3.cxx

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