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