svx/source/unodraw/unoshap3.cxx

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