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