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