1f6e50924SAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3f6e50924SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4f6e50924SAndrew Rist * or more contributor license agreements. See the NOTICE file
5f6e50924SAndrew Rist * distributed with this work for additional information
6f6e50924SAndrew Rist * regarding copyright ownership. The ASF licenses this file
7f6e50924SAndrew Rist * to you under the Apache License, Version 2.0 (the
8f6e50924SAndrew Rist * "License"); you may not use this file except in compliance
9f6e50924SAndrew Rist * with the License. You may obtain a copy of the License at
10f6e50924SAndrew Rist *
11f6e50924SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12f6e50924SAndrew Rist *
13f6e50924SAndrew Rist * Unless required by applicable law or agreed to in writing,
14f6e50924SAndrew Rist * software distributed under the License is distributed on an
15f6e50924SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16f6e50924SAndrew Rist * KIND, either express or implied. See the License for the
17f6e50924SAndrew Rist * specific language governing permissions and limitations
18f6e50924SAndrew Rist * under the License.
19f6e50924SAndrew Rist *
20f6e50924SAndrew Rist *************************************************************/
21f6e50924SAndrew Rist
22f6e50924SAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_svx.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include "svx/svdstr.hrc"
28cdf0e10cSrcweir #include "svx/svdglob.hxx"
29cdf0e10cSrcweir #include "svx/svditer.hxx"
30cdf0e10cSrcweir
31cdf0e10cSrcweir #if defined( UNX ) || defined( ICC )
32cdf0e10cSrcweir #include <stdlib.h>
33cdf0e10cSrcweir #endif
34cdf0e10cSrcweir #include "svx/globl3d.hxx"
35cdf0e10cSrcweir #include <svx/svdpage.hxx>
36cdf0e10cSrcweir #include <svl/style.hxx>
37cdf0e10cSrcweir #include <svx/scene3d.hxx>
38cdf0e10cSrcweir #include <svx/e3dundo.hxx>
39cdf0e10cSrcweir #include <svx/svdtrans.hxx>
40cdf0e10cSrcweir #include <svx/svxids.hrc>
41cdf0e10cSrcweir #include <editeng/colritem.hxx>
42cdf0e10cSrcweir #include <svx/e3ditem.hxx>
43cdf0e10cSrcweir #include <svx/xlntrit.hxx>
44cdf0e10cSrcweir #include <svx/xfltrit.hxx>
45cdf0e10cSrcweir #include <svx/svx3ditems.hxx>
46cdf0e10cSrcweir #include <svl/whiter.hxx>
47cdf0e10cSrcweir #include <svx/xflftrit.hxx>
48cdf0e10cSrcweir #include <svx/sdr/properties/e3dsceneproperties.hxx>
49cdf0e10cSrcweir #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
50cdf0e10cSrcweir #include <svx/svddrag.hxx>
51cdf0e10cSrcweir #include <helperminimaldepth3d.hxx>
52cdf0e10cSrcweir #include <algorithm>
53cdf0e10cSrcweir #include <drawinglayer/geometry/viewinformation3d.hxx>
54cdf0e10cSrcweir #include <basegfx/polygon/b2dpolypolygontools.hxx>
55cdf0e10cSrcweir #include <svx/e3dsceneupdater.hxx>
56*28cc6868SArmin Le Grand #include <svx/svdmodel.hxx>
57cdf0e10cSrcweir
58cdf0e10cSrcweir #define ITEMVALUE(ItemSet,Id,Cast) ((const Cast&)(ItemSet).Get(Id)).GetValue()
59cdf0e10cSrcweir
60cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////
61cdf0e10cSrcweir // #110988#
62cdf0e10cSrcweir
63cdf0e10cSrcweir class ImpRemap3DDepth
64cdf0e10cSrcweir {
65cdf0e10cSrcweir sal_uInt32 mnOrdNum;
66cdf0e10cSrcweir double mfMinimalDepth;
67cdf0e10cSrcweir
68cdf0e10cSrcweir // bitfield
69cdf0e10cSrcweir unsigned mbIsScene : 1;
70cdf0e10cSrcweir
71cdf0e10cSrcweir public:
72cdf0e10cSrcweir ImpRemap3DDepth(sal_uInt32 nOrdNum, double fMinimalDepth);
73cdf0e10cSrcweir ImpRemap3DDepth(sal_uInt32 nOrdNum);
74cdf0e10cSrcweir ~ImpRemap3DDepth();
75cdf0e10cSrcweir
76cdf0e10cSrcweir // for ::std::sort
77cdf0e10cSrcweir bool operator<(const ImpRemap3DDepth& rComp) const;
78cdf0e10cSrcweir
GetOrdNum() const79cdf0e10cSrcweir sal_uInt32 GetOrdNum() const { return mnOrdNum; }
IsScene() const80cdf0e10cSrcweir sal_Bool IsScene() const { return mbIsScene; }
81cdf0e10cSrcweir };
82cdf0e10cSrcweir
ImpRemap3DDepth(sal_uInt32 nOrdNum,double fMinimalDepth)83cdf0e10cSrcweir ImpRemap3DDepth::ImpRemap3DDepth(sal_uInt32 nOrdNum, double fMinimalDepth)
84cdf0e10cSrcweir : mnOrdNum(nOrdNum),
85cdf0e10cSrcweir mfMinimalDepth(fMinimalDepth),
86cdf0e10cSrcweir mbIsScene(sal_False)
87cdf0e10cSrcweir {
88cdf0e10cSrcweir }
89cdf0e10cSrcweir
ImpRemap3DDepth(sal_uInt32 nOrdNum)90cdf0e10cSrcweir ImpRemap3DDepth::ImpRemap3DDepth(sal_uInt32 nOrdNum)
91cdf0e10cSrcweir : mnOrdNum(nOrdNum),
92cdf0e10cSrcweir mbIsScene(sal_True)
93cdf0e10cSrcweir {
94cdf0e10cSrcweir }
95cdf0e10cSrcweir
~ImpRemap3DDepth()96cdf0e10cSrcweir ImpRemap3DDepth::~ImpRemap3DDepth()
97cdf0e10cSrcweir {
98cdf0e10cSrcweir }
99cdf0e10cSrcweir
operator <(const ImpRemap3DDepth & rComp) const100cdf0e10cSrcweir bool ImpRemap3DDepth::operator<(const ImpRemap3DDepth& rComp) const
101cdf0e10cSrcweir {
102cdf0e10cSrcweir if(IsScene())
103cdf0e10cSrcweir {
104cdf0e10cSrcweir return sal_False;
105cdf0e10cSrcweir }
106cdf0e10cSrcweir else
107cdf0e10cSrcweir {
108cdf0e10cSrcweir if(rComp.IsScene())
109cdf0e10cSrcweir {
110cdf0e10cSrcweir return sal_True;
111cdf0e10cSrcweir }
112cdf0e10cSrcweir else
113cdf0e10cSrcweir {
114cdf0e10cSrcweir return mfMinimalDepth < rComp.mfMinimalDepth;
115cdf0e10cSrcweir }
116cdf0e10cSrcweir }
117cdf0e10cSrcweir }
118cdf0e10cSrcweir
119cdf0e10cSrcweir // typedefs for a vector of ImpRemap3DDepths
120cdf0e10cSrcweir typedef ::std::vector< ImpRemap3DDepth > ImpRemap3DDepthVector;
121cdf0e10cSrcweir
122cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////
123cdf0e10cSrcweir // #110988#
124cdf0e10cSrcweir
125cdf0e10cSrcweir class Imp3DDepthRemapper
126cdf0e10cSrcweir {
127cdf0e10cSrcweir ImpRemap3DDepthVector maVector;
128cdf0e10cSrcweir
129cdf0e10cSrcweir public:
130cdf0e10cSrcweir Imp3DDepthRemapper(E3dScene& rScene);
131cdf0e10cSrcweir ~Imp3DDepthRemapper();
132cdf0e10cSrcweir
133cdf0e10cSrcweir sal_uInt32 RemapOrdNum(sal_uInt32 nOrdNum) const;
134cdf0e10cSrcweir };
135cdf0e10cSrcweir
Imp3DDepthRemapper(E3dScene & rScene)136cdf0e10cSrcweir Imp3DDepthRemapper::Imp3DDepthRemapper(E3dScene& rScene)
137cdf0e10cSrcweir {
138cdf0e10cSrcweir // only called when rScene.GetSubList() and nObjCount > 1L
139cdf0e10cSrcweir SdrObjList* pList = rScene.GetSubList();
140cdf0e10cSrcweir const sal_uInt32 nObjCount(pList->GetObjCount());
141cdf0e10cSrcweir
142cdf0e10cSrcweir for(sal_uInt32 a(0L); a < nObjCount; a++)
143cdf0e10cSrcweir {
144cdf0e10cSrcweir SdrObject* pCandidate = pList->GetObj(a);
145cdf0e10cSrcweir
146cdf0e10cSrcweir if(pCandidate)
147cdf0e10cSrcweir {
148cdf0e10cSrcweir if(pCandidate->ISA(E3dCompoundObject))
149cdf0e10cSrcweir {
150cdf0e10cSrcweir // single 3d object, calc depth
151cdf0e10cSrcweir const double fMinimalDepth(getMinimalDepthInViewCoordinates(static_cast< const E3dCompoundObject& >(*pCandidate)));
152cdf0e10cSrcweir ImpRemap3DDepth aEntry(a, fMinimalDepth);
153cdf0e10cSrcweir maVector.push_back(aEntry);
154cdf0e10cSrcweir }
155cdf0e10cSrcweir else
156cdf0e10cSrcweir {
157cdf0e10cSrcweir // scene, use standard entry for scene
158cdf0e10cSrcweir ImpRemap3DDepth aEntry(a);
159cdf0e10cSrcweir maVector.push_back(aEntry);
160cdf0e10cSrcweir }
161cdf0e10cSrcweir }
162cdf0e10cSrcweir }
163cdf0e10cSrcweir
164cdf0e10cSrcweir // now, we need to sort the maVector by it's members minimal depth. The
165cdf0e10cSrcweir // smaller, the nearer to the viewer.
166cdf0e10cSrcweir ::std::sort(maVector.begin(), maVector.end());
167cdf0e10cSrcweir }
168cdf0e10cSrcweir
~Imp3DDepthRemapper()169cdf0e10cSrcweir Imp3DDepthRemapper::~Imp3DDepthRemapper()
170cdf0e10cSrcweir {
171cdf0e10cSrcweir }
172cdf0e10cSrcweir
RemapOrdNum(sal_uInt32 nOrdNum) const173cdf0e10cSrcweir sal_uInt32 Imp3DDepthRemapper::RemapOrdNum(sal_uInt32 nOrdNum) const
174cdf0e10cSrcweir {
175cdf0e10cSrcweir if(nOrdNum < maVector.size())
176cdf0e10cSrcweir {
177cdf0e10cSrcweir nOrdNum = maVector[(maVector.size() - 1) - nOrdNum].GetOrdNum();
178cdf0e10cSrcweir }
179cdf0e10cSrcweir
180cdf0e10cSrcweir return nOrdNum;
181cdf0e10cSrcweir }
182cdf0e10cSrcweir
183cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////
184cdf0e10cSrcweir // BaseProperties section
185cdf0e10cSrcweir
CreateObjectSpecificProperties()186cdf0e10cSrcweir sdr::properties::BaseProperties* E3dScene::CreateObjectSpecificProperties()
187cdf0e10cSrcweir {
188cdf0e10cSrcweir return new sdr::properties::E3dSceneProperties(*this);
189cdf0e10cSrcweir }
190cdf0e10cSrcweir
191cdf0e10cSrcweir //////////////////////////////////////////////////////////////////////////////
192cdf0e10cSrcweir // #110094# DrawContact section
193cdf0e10cSrcweir
CreateObjectSpecificViewContact()194cdf0e10cSrcweir sdr::contact::ViewContact* E3dScene::CreateObjectSpecificViewContact()
195cdf0e10cSrcweir {
196cdf0e10cSrcweir return new sdr::contact::ViewContactOfE3dScene(*this);
197cdf0e10cSrcweir }
198cdf0e10cSrcweir
199cdf0e10cSrcweir ////////////////////////////////////////////////////////////////////////////////////////////////////
200cdf0e10cSrcweir
201cdf0e10cSrcweir TYPEINIT1(E3dScene, E3dObject);
202cdf0e10cSrcweir
203cdf0e10cSrcweir /*************************************************************************
204cdf0e10cSrcweir |*
205cdf0e10cSrcweir |* E3dScene-Konstruktor
206cdf0e10cSrcweir |*
207cdf0e10cSrcweir \************************************************************************/
208cdf0e10cSrcweir
E3dScene()209cdf0e10cSrcweir E3dScene::E3dScene()
210cdf0e10cSrcweir : E3dObject(),
211cdf0e10cSrcweir aCamera(basegfx::B3DPoint(0.0, 0.0, 4.0), basegfx::B3DPoint()),
212cdf0e10cSrcweir mp3DDepthRemapper(0L),
213cdf0e10cSrcweir bDrawOnlySelected(false)
214cdf0e10cSrcweir {
215cdf0e10cSrcweir // Defaults setzen
216cdf0e10cSrcweir E3dDefaultAttributes aDefault;
217cdf0e10cSrcweir SetDefaultAttributes(aDefault);
218cdf0e10cSrcweir }
219cdf0e10cSrcweir
E3dScene(E3dDefaultAttributes & rDefault)220cdf0e10cSrcweir E3dScene::E3dScene(E3dDefaultAttributes& rDefault)
221cdf0e10cSrcweir : E3dObject(),
222cdf0e10cSrcweir aCamera(basegfx::B3DPoint(0.0, 0.0, 4.0), basegfx::B3DPoint()),
223cdf0e10cSrcweir mp3DDepthRemapper(0L),
224cdf0e10cSrcweir bDrawOnlySelected(false)
225cdf0e10cSrcweir {
226cdf0e10cSrcweir // Defaults setzen
227cdf0e10cSrcweir SetDefaultAttributes(rDefault);
228cdf0e10cSrcweir }
229cdf0e10cSrcweir
SetDefaultAttributes(E3dDefaultAttributes &)230cdf0e10cSrcweir void E3dScene::SetDefaultAttributes(E3dDefaultAttributes& /*rDefault*/)
231cdf0e10cSrcweir {
232cdf0e10cSrcweir // Fuer OS/2 die FP-Exceptions abschalten
233cdf0e10cSrcweir #if defined(OS2)
234cdf0e10cSrcweir #define SC_FPEXCEPTIONS_ON() _control87( MCW_EM, 0 )
235cdf0e10cSrcweir #define SC_FPEXCEPTIONS_OFF() _control87( MCW_EM, MCW_EM )
236cdf0e10cSrcweir SC_FPEXCEPTIONS_OFF();
237cdf0e10cSrcweir #endif
238cdf0e10cSrcweir
239cdf0e10cSrcweir // Fuer WIN95/NT die FP-Exceptions abschalten
240cdf0e10cSrcweir #if defined(WNT)
241cdf0e10cSrcweir #define SC_FPEXCEPTIONS_ON() _control87( _MCW_EM, 0 )
242cdf0e10cSrcweir #define SC_FPEXCEPTIONS_OFF() _control87( _MCW_EM, _MCW_EM )
243cdf0e10cSrcweir SC_FPEXCEPTIONS_OFF();
244cdf0e10cSrcweir #endif
245cdf0e10cSrcweir
246cdf0e10cSrcweir // Defaults setzen
247cdf0e10cSrcweir aCamera.SetViewWindow(-2, -2, 4, 4);
248cdf0e10cSrcweir aCameraSet.SetDeviceRectangle(-2, 2, -2, 2);
249cdf0e10cSrcweir aCamera.SetDeviceWindow(Rectangle(0, 0, 10, 10));
250cdf0e10cSrcweir Rectangle aRect(0, 0, 10, 10);
251cdf0e10cSrcweir aCameraSet.SetViewportRectangle(aRect);
252cdf0e10cSrcweir
253cdf0e10cSrcweir // set defaults for Camera from ItemPool
254cdf0e10cSrcweir aCamera.SetProjection(GetPerspective());
255cdf0e10cSrcweir basegfx::B3DPoint aActualPosition(aCamera.GetPosition());
256cdf0e10cSrcweir double fNew = GetDistance();
257cdf0e10cSrcweir
258cdf0e10cSrcweir if(fabs(fNew - aActualPosition.getZ()) > 1.0)
259cdf0e10cSrcweir {
260cdf0e10cSrcweir aCamera.SetPosition( basegfx::B3DPoint( aActualPosition.getX(), aActualPosition.getY(), fNew) );
261cdf0e10cSrcweir }
262cdf0e10cSrcweir
263cdf0e10cSrcweir fNew = GetFocalLength() / 100.0;
264cdf0e10cSrcweir aCamera.SetFocalLength(fNew);
265cdf0e10cSrcweir }
266cdf0e10cSrcweir
267cdf0e10cSrcweir /*************************************************************************
268cdf0e10cSrcweir |*
269cdf0e10cSrcweir |* Destruktor
270cdf0e10cSrcweir |*
271cdf0e10cSrcweir \************************************************************************/
272cdf0e10cSrcweir
~E3dScene()273cdf0e10cSrcweir E3dScene::~E3dScene()
274cdf0e10cSrcweir {
275cdf0e10cSrcweir // #110988#
276cdf0e10cSrcweir ImpCleanup3DDepthMapper();
277cdf0e10cSrcweir }
278cdf0e10cSrcweir
TakeXorPoly() const279cdf0e10cSrcweir basegfx::B2DPolyPolygon E3dScene::TakeXorPoly() const
280cdf0e10cSrcweir {
281cdf0e10cSrcweir const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(GetViewContact());
282cdf0e10cSrcweir const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
283cdf0e10cSrcweir const basegfx::B3DPolyPolygon aCubePolyPolygon(CreateWireframe());
284cdf0e10cSrcweir
285cdf0e10cSrcweir basegfx::B2DPolyPolygon aRetval(basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(aCubePolyPolygon,
286cdf0e10cSrcweir aViewInfo3D.getObjectToView()));
287cdf0e10cSrcweir aRetval.transform(rVCScene.getObjectTransformation());
288cdf0e10cSrcweir
289cdf0e10cSrcweir return aRetval;
290cdf0e10cSrcweir }
291cdf0e10cSrcweir
292cdf0e10cSrcweir // #110988#
ImpCleanup3DDepthMapper()293cdf0e10cSrcweir void E3dScene::ImpCleanup3DDepthMapper()
294cdf0e10cSrcweir {
295cdf0e10cSrcweir if(mp3DDepthRemapper)
296cdf0e10cSrcweir {
297cdf0e10cSrcweir delete mp3DDepthRemapper;
298cdf0e10cSrcweir mp3DDepthRemapper = 0L;
299cdf0e10cSrcweir }
300cdf0e10cSrcweir }
301cdf0e10cSrcweir
302cdf0e10cSrcweir // #110988#
RemapOrdNum(sal_uInt32 nNewOrdNum) const303cdf0e10cSrcweir sal_uInt32 E3dScene::RemapOrdNum(sal_uInt32 nNewOrdNum) const
304cdf0e10cSrcweir {
305cdf0e10cSrcweir if(!mp3DDepthRemapper)
306cdf0e10cSrcweir {
307cdf0e10cSrcweir const sal_uInt32 nObjCount(GetSubList() ? GetSubList()->GetObjCount() : 0L);
308cdf0e10cSrcweir
309cdf0e10cSrcweir if(nObjCount > 1L)
310cdf0e10cSrcweir {
311cdf0e10cSrcweir ((E3dScene*)this)->mp3DDepthRemapper = new Imp3DDepthRemapper((E3dScene&)(*this));
312cdf0e10cSrcweir }
313cdf0e10cSrcweir }
314cdf0e10cSrcweir
315cdf0e10cSrcweir if(mp3DDepthRemapper)
316cdf0e10cSrcweir {
317cdf0e10cSrcweir return mp3DDepthRemapper->RemapOrdNum(nNewOrdNum);
318cdf0e10cSrcweir }
319cdf0e10cSrcweir
320cdf0e10cSrcweir return nNewOrdNum;
321cdf0e10cSrcweir }
322cdf0e10cSrcweir
323cdf0e10cSrcweir /*************************************************************************
324cdf0e10cSrcweir |*
325cdf0e10cSrcweir |* Identifier zurueckgeben
326cdf0e10cSrcweir |*
327cdf0e10cSrcweir \************************************************************************/
328cdf0e10cSrcweir
GetObjIdentifier() const329cdf0e10cSrcweir sal_uInt16 E3dScene::GetObjIdentifier() const
330cdf0e10cSrcweir {
331cdf0e10cSrcweir return E3D_SCENE_ID;
332cdf0e10cSrcweir }
333cdf0e10cSrcweir
SetBoundRectDirty()334cdf0e10cSrcweir void E3dScene::SetBoundRectDirty()
335cdf0e10cSrcweir {
336cdf0e10cSrcweir E3dScene* pScene = GetScene();
337cdf0e10cSrcweir
338cdf0e10cSrcweir if(pScene == this)
339cdf0e10cSrcweir {
340cdf0e10cSrcweir // avoid resetting aOutRect which in case of a 3D scene used as 2d object
341cdf0e10cSrcweir // is model data,not re-creatable view data
342cdf0e10cSrcweir }
343cdf0e10cSrcweir else
344cdf0e10cSrcweir {
345cdf0e10cSrcweir // if not the outmost scene it is used as group in 3d, call parent
346cdf0e10cSrcweir E3dObject::SetBoundRectDirty();
347cdf0e10cSrcweir }
348cdf0e10cSrcweir }
349cdf0e10cSrcweir
350cdf0e10cSrcweir /*************************************************************************
351cdf0e10cSrcweir |*
352cdf0e10cSrcweir |* SetSnapRect
353cdf0e10cSrcweir |*
354cdf0e10cSrcweir \************************************************************************/
355cdf0e10cSrcweir
NbcSetSnapRect(const Rectangle & rRect)356cdf0e10cSrcweir void E3dScene::NbcSetSnapRect(const Rectangle& rRect)
357cdf0e10cSrcweir {
358cdf0e10cSrcweir SetRectsDirty();
359cdf0e10cSrcweir E3dObject::NbcSetSnapRect(rRect);
360cdf0e10cSrcweir aCamera.SetDeviceWindow(rRect);
361cdf0e10cSrcweir aCameraSet.SetViewportRectangle((Rectangle&)rRect);
362cdf0e10cSrcweir
363cdf0e10cSrcweir // #110988#
364cdf0e10cSrcweir ImpCleanup3DDepthMapper();
365cdf0e10cSrcweir }
366cdf0e10cSrcweir
367cdf0e10cSrcweir /*************************************************************************
368cdf0e10cSrcweir |*
369cdf0e10cSrcweir |* Objekt verschieben
370cdf0e10cSrcweir |*
371cdf0e10cSrcweir \************************************************************************/
372cdf0e10cSrcweir
NbcMove(const Size & rSize)373cdf0e10cSrcweir void E3dScene::NbcMove(const Size& rSize)
374cdf0e10cSrcweir {
375cdf0e10cSrcweir Rectangle aNewSnapRect = GetSnapRect();
376cdf0e10cSrcweir MoveRect(aNewSnapRect, rSize);
377cdf0e10cSrcweir NbcSetSnapRect(aNewSnapRect);
378cdf0e10cSrcweir }
379cdf0e10cSrcweir
380cdf0e10cSrcweir /*************************************************************************
381cdf0e10cSrcweir |*
382cdf0e10cSrcweir |* Objekt Resizen
383cdf0e10cSrcweir |*
384cdf0e10cSrcweir \************************************************************************/
385cdf0e10cSrcweir
NbcResize(const Point & rRef,const Fraction & rXFact,const Fraction & rYFact)386cdf0e10cSrcweir void E3dScene::NbcResize(const Point& rRef, const Fraction& rXFact,
387cdf0e10cSrcweir const Fraction& rYFact)
388cdf0e10cSrcweir {
389cdf0e10cSrcweir Rectangle aNewSnapRect = GetSnapRect();
390cdf0e10cSrcweir ResizeRect(aNewSnapRect, rRef, rXFact, rYFact);
391cdf0e10cSrcweir NbcSetSnapRect(aNewSnapRect);
392cdf0e10cSrcweir }
393cdf0e10cSrcweir
394cdf0e10cSrcweir /*************************************************************************
395cdf0e10cSrcweir |*
396cdf0e10cSrcweir |* Neue Kamera setzen, und dabei die Szene und ggf. das BoundVolume
397cdf0e10cSrcweir |* als geaendert markieren
398cdf0e10cSrcweir |*
399cdf0e10cSrcweir \************************************************************************/
400cdf0e10cSrcweir
SetCamera(const Camera3D & rNewCamera)401cdf0e10cSrcweir void E3dScene::SetCamera(const Camera3D& rNewCamera)
402cdf0e10cSrcweir {
403cdf0e10cSrcweir // Alte Kamera setzen
404cdf0e10cSrcweir aCamera = rNewCamera;
405cdf0e10cSrcweir ((sdr::properties::E3dSceneProperties&)GetProperties()).SetSceneItemsFromCamera();
406cdf0e10cSrcweir
407cdf0e10cSrcweir SetRectsDirty();
408cdf0e10cSrcweir
409cdf0e10cSrcweir // Neue Kamera aus alter fuellen
410cdf0e10cSrcweir Camera3D& rCam = (Camera3D&)GetCamera();
411cdf0e10cSrcweir
412cdf0e10cSrcweir // Ratio abschalten
413cdf0e10cSrcweir if(rCam.GetAspectMapping() == AS_NO_MAPPING)
414cdf0e10cSrcweir GetCameraSet().SetRatio(0.0);
415cdf0e10cSrcweir
416cdf0e10cSrcweir // Abbildungsgeometrie setzen
417cdf0e10cSrcweir basegfx::B3DPoint aVRP(rCam.GetViewPoint());
418cdf0e10cSrcweir basegfx::B3DVector aVPN(aVRP - rCam.GetVRP());
419cdf0e10cSrcweir basegfx::B3DVector aVUV(rCam.GetVUV());
420cdf0e10cSrcweir
421cdf0e10cSrcweir // #91047# use SetViewportValues() to set VRP, VPN and VUV as vectors, too.
422cdf0e10cSrcweir // Else these values would not be exported/imported correctly.
423cdf0e10cSrcweir GetCameraSet().SetViewportValues(aVRP, aVPN, aVUV);
424cdf0e10cSrcweir
425cdf0e10cSrcweir // Perspektive setzen
426cdf0e10cSrcweir GetCameraSet().SetPerspective(rCam.GetProjection() == PR_PERSPECTIVE);
427cdf0e10cSrcweir GetCameraSet().SetViewportRectangle((Rectangle&)rCam.GetDeviceWindow());
428cdf0e10cSrcweir
429cdf0e10cSrcweir // #110988#
430cdf0e10cSrcweir ImpCleanup3DDepthMapper();
431cdf0e10cSrcweir }
432cdf0e10cSrcweir
433cdf0e10cSrcweir /*************************************************************************
434cdf0e10cSrcweir |*
435cdf0e10cSrcweir |* 3D-Objekt einfuegen
436cdf0e10cSrcweir |*
437cdf0e10cSrcweir \************************************************************************/
438cdf0e10cSrcweir
NewObjectInserted(const E3dObject * p3DObj)439cdf0e10cSrcweir void E3dScene::NewObjectInserted(const E3dObject* p3DObj)
440cdf0e10cSrcweir {
441cdf0e10cSrcweir E3dObject::NewObjectInserted(p3DObj);
442cdf0e10cSrcweir
443cdf0e10cSrcweir if ( p3DObj == this )
444cdf0e10cSrcweir return;
445cdf0e10cSrcweir
446cdf0e10cSrcweir // #110988#
447cdf0e10cSrcweir ImpCleanup3DDepthMapper();
448cdf0e10cSrcweir }
449cdf0e10cSrcweir
450cdf0e10cSrcweir /*************************************************************************
451cdf0e10cSrcweir |*
452cdf0e10cSrcweir |* Parent ueber Aenderung eines Childs informieren
453cdf0e10cSrcweir |*
454cdf0e10cSrcweir \************************************************************************/
455cdf0e10cSrcweir
StructureChanged()456cdf0e10cSrcweir void E3dScene::StructureChanged()
457cdf0e10cSrcweir {
458cdf0e10cSrcweir E3dObject::StructureChanged();
459*28cc6868SArmin Le Grand
460*28cc6868SArmin Le Grand if(!GetModel() || !GetModel()->isLocked())
461*28cc6868SArmin Le Grand {
462*28cc6868SArmin Le Grand // #123539# optimization for 3D chart object generation: do not reset
463*28cc6868SArmin Le Grand // already calculated scene projection data every time an object gets
464*28cc6868SArmin Le Grand // initialized
465*28cc6868SArmin Le Grand SetRectsDirty();
466*28cc6868SArmin Le Grand }
467cdf0e10cSrcweir
468cdf0e10cSrcweir // #110988#
469cdf0e10cSrcweir ImpCleanup3DDepthMapper();
470cdf0e10cSrcweir }
471cdf0e10cSrcweir
472cdf0e10cSrcweir /*************************************************************************
473cdf0e10cSrcweir |*
474cdf0e10cSrcweir |* Uebergeordnetes Szenenobjekt bestimmen
475cdf0e10cSrcweir |*
476cdf0e10cSrcweir \************************************************************************/
477cdf0e10cSrcweir
GetScene() const478cdf0e10cSrcweir E3dScene* E3dScene::GetScene() const
479cdf0e10cSrcweir {
480cdf0e10cSrcweir if(GetParentObj())
481cdf0e10cSrcweir return GetParentObj()->GetScene();
482cdf0e10cSrcweir else
483cdf0e10cSrcweir return (E3dScene*)this;
484cdf0e10cSrcweir }
485cdf0e10cSrcweir
removeAllNonSelectedObjects()486cdf0e10cSrcweir void E3dScene::removeAllNonSelectedObjects()
487cdf0e10cSrcweir {
488cdf0e10cSrcweir E3DModifySceneSnapRectUpdater aUpdater(this);
489cdf0e10cSrcweir
490cdf0e10cSrcweir for(sal_uInt32 a(0); a < maSubList.GetObjCount(); a++)
491cdf0e10cSrcweir {
492cdf0e10cSrcweir SdrObject* pObj = maSubList.GetObj(a);
493cdf0e10cSrcweir
494cdf0e10cSrcweir if(pObj)
495cdf0e10cSrcweir {
496cdf0e10cSrcweir bool bRemoveObject(false);
497cdf0e10cSrcweir
498cdf0e10cSrcweir if(pObj->ISA(E3dScene))
499cdf0e10cSrcweir {
500cdf0e10cSrcweir E3dScene* pScene = (E3dScene*)pObj;
501cdf0e10cSrcweir
502cdf0e10cSrcweir // iterate over this sub-scene
503cdf0e10cSrcweir pScene->removeAllNonSelectedObjects();
504cdf0e10cSrcweir
505cdf0e10cSrcweir // check object count. Empty scenes can be deleted
506cdf0e10cSrcweir const sal_uInt32 nObjCount(pScene->GetSubList() ? pScene->GetSubList()->GetObjCount() : 0);
507cdf0e10cSrcweir
508cdf0e10cSrcweir if(!nObjCount)
509cdf0e10cSrcweir {
510cdf0e10cSrcweir // all objects removed, scene can be removed, too
511cdf0e10cSrcweir bRemoveObject = true;
512cdf0e10cSrcweir }
513cdf0e10cSrcweir }
514cdf0e10cSrcweir else if(pObj->ISA(E3dCompoundObject))
515cdf0e10cSrcweir {
516cdf0e10cSrcweir E3dCompoundObject* pCompound = (E3dCompoundObject*)pObj;
517cdf0e10cSrcweir
518cdf0e10cSrcweir if(!pCompound->GetSelected())
519cdf0e10cSrcweir {
520cdf0e10cSrcweir bRemoveObject = true;
521cdf0e10cSrcweir }
522cdf0e10cSrcweir }
523cdf0e10cSrcweir
524cdf0e10cSrcweir if(bRemoveObject)
525cdf0e10cSrcweir {
526cdf0e10cSrcweir maSubList.NbcRemoveObject(pObj->GetOrdNum());
527cdf0e10cSrcweir a--;
528cdf0e10cSrcweir SdrObject::Free(pObj);
529cdf0e10cSrcweir }
530cdf0e10cSrcweir }
531cdf0e10cSrcweir }
532cdf0e10cSrcweir }
533cdf0e10cSrcweir
534cdf0e10cSrcweir /*************************************************************************
535cdf0e10cSrcweir |*
536cdf0e10cSrcweir |* Zuweisungsoperator
537cdf0e10cSrcweir |*
538cdf0e10cSrcweir \************************************************************************/
539cdf0e10cSrcweir
operator =(const SdrObject & rObj)540cdf0e10cSrcweir void E3dScene::operator=(const SdrObject& rObj)
541cdf0e10cSrcweir {
542cdf0e10cSrcweir E3dObject::operator=(rObj);
543cdf0e10cSrcweir
544cdf0e10cSrcweir const E3dScene& r3DObj = (const E3dScene&) rObj;
545cdf0e10cSrcweir aCamera = r3DObj.aCamera;
546cdf0e10cSrcweir
547cdf0e10cSrcweir // neu ab 377:
548cdf0e10cSrcweir aCameraSet = r3DObj.aCameraSet;
549cdf0e10cSrcweir ((sdr::properties::E3dSceneProperties&)GetProperties()).SetSceneItemsFromCamera();
550cdf0e10cSrcweir
551cdf0e10cSrcweir // SetSnapRect(r3DObj.GetSnapRect());
552cdf0e10cSrcweir InvalidateBoundVolume();
553cdf0e10cSrcweir RebuildLists();
554cdf0e10cSrcweir SetRectsDirty();
555cdf0e10cSrcweir
556cdf0e10cSrcweir // #110988#
557cdf0e10cSrcweir ImpCleanup3DDepthMapper();
558cdf0e10cSrcweir
559cdf0e10cSrcweir // #i101941#
560cdf0e10cSrcweir // After a Scene as model object is cloned, the used
561cdf0e10cSrcweir // ViewContactOfE3dScene is created and partially used
562cdf0e10cSrcweir // to calculate Bound/SnapRects, but - since quite some
563cdf0e10cSrcweir // values are buffered at the VC - not really well
564cdf0e10cSrcweir // initialized. It would be possible to always watch for
565cdf0e10cSrcweir // preconditions of buffered data, but this would be expensive
566cdf0e10cSrcweir // and would create a lot of short living data structures.
567cdf0e10cSrcweir // It is currently better to flush that data, e.g. by using
568cdf0e10cSrcweir // ActionChanged at the VC which will for this class
569cdf0e10cSrcweir // flush that cached data and initalize it's valid reconstruction
570cdf0e10cSrcweir GetViewContact().ActionChanged();
571cdf0e10cSrcweir }
572cdf0e10cSrcweir
573cdf0e10cSrcweir /*************************************************************************
574cdf0e10cSrcweir |*
575cdf0e10cSrcweir |* Licht- und Labelobjektlisten neu aufbauen (nach Laden, Zuweisung)
576cdf0e10cSrcweir |*
577cdf0e10cSrcweir \************************************************************************/
578cdf0e10cSrcweir
RebuildLists()579cdf0e10cSrcweir void E3dScene::RebuildLists()
580cdf0e10cSrcweir {
581cdf0e10cSrcweir // zuerst loeschen
582cdf0e10cSrcweir SdrLayerID nCurrLayerID = GetLayer();
583cdf0e10cSrcweir
584cdf0e10cSrcweir SdrObjListIter a3DIterator(maSubList, IM_FLAT);
585cdf0e10cSrcweir
586cdf0e10cSrcweir // dann alle Objekte in der Szene pruefen
587cdf0e10cSrcweir while ( a3DIterator.IsMore() )
588cdf0e10cSrcweir {
589cdf0e10cSrcweir E3dObject* p3DObj = (E3dObject*) a3DIterator.Next();
590cdf0e10cSrcweir p3DObj->NbcSetLayer(nCurrLayerID);
591cdf0e10cSrcweir NewObjectInserted(p3DObj);
592cdf0e10cSrcweir }
593cdf0e10cSrcweir }
594cdf0e10cSrcweir
595cdf0e10cSrcweir /*************************************************************************
596cdf0e10cSrcweir |*
597cdf0e10cSrcweir |* erstelle neues GeoData-Objekt
598cdf0e10cSrcweir |*
599cdf0e10cSrcweir \************************************************************************/
600cdf0e10cSrcweir
NewGeoData() const601cdf0e10cSrcweir SdrObjGeoData *E3dScene::NewGeoData() const
602cdf0e10cSrcweir {
603cdf0e10cSrcweir return new E3DSceneGeoData;
604cdf0e10cSrcweir }
605cdf0e10cSrcweir
606cdf0e10cSrcweir /*************************************************************************
607cdf0e10cSrcweir |*
608cdf0e10cSrcweir |* uebergebe aktuelle werte an das GeoData-Objekt
609cdf0e10cSrcweir |*
610cdf0e10cSrcweir \************************************************************************/
611cdf0e10cSrcweir
SaveGeoData(SdrObjGeoData & rGeo) const612cdf0e10cSrcweir void E3dScene::SaveGeoData(SdrObjGeoData& rGeo) const
613cdf0e10cSrcweir {
614cdf0e10cSrcweir E3dObject::SaveGeoData (rGeo);
615cdf0e10cSrcweir
616cdf0e10cSrcweir ((E3DSceneGeoData &) rGeo).aCamera = aCamera;
617cdf0e10cSrcweir }
618cdf0e10cSrcweir
619cdf0e10cSrcweir /*************************************************************************
620cdf0e10cSrcweir |*
621cdf0e10cSrcweir |* uebernehme werte aus dem GeoData-Objekt
622cdf0e10cSrcweir |*
623cdf0e10cSrcweir \************************************************************************/
624cdf0e10cSrcweir
RestGeoData(const SdrObjGeoData & rGeo)625cdf0e10cSrcweir void E3dScene::RestGeoData(const SdrObjGeoData& rGeo)
626cdf0e10cSrcweir {
627cdf0e10cSrcweir // #i94832# removed E3DModifySceneSnapRectUpdater here.
628cdf0e10cSrcweir // It should not be needed, is already part of E3dObject::RestGeoData
629cdf0e10cSrcweir E3dObject::RestGeoData (rGeo);
630cdf0e10cSrcweir SetCamera (((E3DSceneGeoData &) rGeo).aCamera);
631cdf0e10cSrcweir }
632cdf0e10cSrcweir
633cdf0e10cSrcweir /*************************************************************************
634cdf0e10cSrcweir |*
635cdf0e10cSrcweir |* Am StyleSheet wurde etwas geaendert, also Scene aendern
636cdf0e10cSrcweir |*
637cdf0e10cSrcweir \************************************************************************/
638cdf0e10cSrcweir
Notify(SfxBroadcaster & rBC,const SfxHint & rHint)639cdf0e10cSrcweir void E3dScene::Notify(SfxBroadcaster &rBC, const SfxHint &rHint)
640cdf0e10cSrcweir {
641cdf0e10cSrcweir SetRectsDirty();
642cdf0e10cSrcweir E3dObject::Notify(rBC, rHint);
643cdf0e10cSrcweir }
644cdf0e10cSrcweir
645cdf0e10cSrcweir /*************************************************************************
646cdf0e10cSrcweir |*
647cdf0e10cSrcweir \************************************************************************/
648cdf0e10cSrcweir
RotateScene(const Point & rRef,long,double sn,double cs)649cdf0e10cSrcweir void E3dScene::RotateScene (const Point& rRef, long /*nWink*/, double sn, double cs)
650cdf0e10cSrcweir {
651cdf0e10cSrcweir Point UpperLeft, LowerRight, Center, NewCenter;
652cdf0e10cSrcweir
653cdf0e10cSrcweir UpperLeft = aOutRect.TopLeft();
654cdf0e10cSrcweir LowerRight = aOutRect.BottomRight();
655cdf0e10cSrcweir
656cdf0e10cSrcweir long dxOutRectHalf = labs(UpperLeft.X() - LowerRight.X());
657cdf0e10cSrcweir dxOutRectHalf /= 2;
658cdf0e10cSrcweir long dyOutRectHalf = labs(UpperLeft.Y() - LowerRight.Y());
659cdf0e10cSrcweir dyOutRectHalf /= 2;
660cdf0e10cSrcweir
661cdf0e10cSrcweir Rectangle RectQuelle(aOutRect), RectZiel(aOutRect);
662cdf0e10cSrcweir
663cdf0e10cSrcweir // Nur der Mittelpunkt wird bewegt. Die Ecken werden von NbcMove bewegt.
664cdf0e10cSrcweir // Fuer das Drehen wird von mir ein kartesisches Koordinatensystem verwendet in dem der Drehpunkt
665cdf0e10cSrcweir // der Nullpunkt ist und die Y- Achse nach oben ansteigt, die X-Achse nach rechts.
666cdf0e10cSrcweir // Dies muss bei den Y-Werten beachtet werden. (Auf dem Blatt zeigt die Y-Achse nach unten
667cdf0e10cSrcweir Center.X() = (UpperLeft.X() + dxOutRectHalf) - rRef.X();
668cdf0e10cSrcweir Center.Y() = -((UpperLeft.Y() + dyOutRectHalf) - rRef.Y());
669cdf0e10cSrcweir // Ein paar Spezialfaelle zuerst abhandeln (n*90 Grad n ganzzahlig)
670cdf0e10cSrcweir if (sn==1.0 && cs==0.0) { // 90deg
671cdf0e10cSrcweir NewCenter.X() = -Center.Y();
672cdf0e10cSrcweir NewCenter.Y() = -Center.X();
673cdf0e10cSrcweir } else if (sn==0.0 && cs==-1.0) { // 180deg
674cdf0e10cSrcweir NewCenter.X() = -Center.X();
675cdf0e10cSrcweir NewCenter.Y() = -Center.Y();
676cdf0e10cSrcweir } else if (sn==-1.0 && cs==0.0) { // 270deg
677cdf0e10cSrcweir NewCenter.X() = Center.Y();
678cdf0e10cSrcweir NewCenter.Y() = -Center.X();
679cdf0e10cSrcweir }
680cdf0e10cSrcweir else // Hier wird um einen beliebigen Winkel in mathematisch positiver Richtung gedreht!
681cdf0e10cSrcweir { // xneu = x * cos(alpha) - y * sin(alpha)
682cdf0e10cSrcweir // yneu = x * sin(alpha) + y * cos(alpha)
683cdf0e10cSrcweir // Unten Rechts wird nicht gedreht: die Seiten von RectQuelle muessen parallel
684cdf0e10cSrcweir // zu den Koordinatenachsen bleiben.
685cdf0e10cSrcweir NewCenter.X() = (long) (Center.X() * cs - Center.Y() * sn);
686cdf0e10cSrcweir NewCenter.Y() = (long) (Center.X() * sn + Center.Y() * cs);
687cdf0e10cSrcweir }
688cdf0e10cSrcweir
689cdf0e10cSrcweir Size Differenz;
690cdf0e10cSrcweir Point DiffPoint = (NewCenter - Center);
691cdf0e10cSrcweir Differenz.Width() = DiffPoint.X();
692cdf0e10cSrcweir Differenz.Height() = -DiffPoint.Y(); // Man beachte dass die Y-Achse nach unten positiv gezaehlt wird.
693cdf0e10cSrcweir NbcMove (Differenz); // fuehrt die eigentliche Koordinatentransformation durch.
694cdf0e10cSrcweir }
695cdf0e10cSrcweir
696cdf0e10cSrcweir /*************************************************************************
697cdf0e10cSrcweir |*
698cdf0e10cSrcweir |* Get the name of the object (singular)
699cdf0e10cSrcweir |*
700cdf0e10cSrcweir \************************************************************************/
701cdf0e10cSrcweir
TakeObjNameSingul(XubString & rName) const702cdf0e10cSrcweir void E3dScene::TakeObjNameSingul(XubString& rName) const
703cdf0e10cSrcweir {
704cdf0e10cSrcweir rName=ImpGetResStr(STR_ObjNameSingulScene3d);
705cdf0e10cSrcweir
706cdf0e10cSrcweir String aName( GetName() );
707cdf0e10cSrcweir if(aName.Len())
708cdf0e10cSrcweir {
709cdf0e10cSrcweir rName += sal_Unicode(' ');
710cdf0e10cSrcweir rName += sal_Unicode('\'');
711cdf0e10cSrcweir rName += aName;
712cdf0e10cSrcweir rName += sal_Unicode('\'');
713cdf0e10cSrcweir }
714cdf0e10cSrcweir }
715cdf0e10cSrcweir
716cdf0e10cSrcweir /*************************************************************************
717cdf0e10cSrcweir |*
718cdf0e10cSrcweir |* Get the name of the object (plural)
719cdf0e10cSrcweir |*
720cdf0e10cSrcweir \************************************************************************/
721cdf0e10cSrcweir
TakeObjNamePlural(XubString & rName) const722cdf0e10cSrcweir void E3dScene::TakeObjNamePlural(XubString& rName) const
723cdf0e10cSrcweir {
724cdf0e10cSrcweir rName=ImpGetResStr(STR_ObjNamePluralScene3d);
725cdf0e10cSrcweir }
726cdf0e10cSrcweir
727cdf0e10cSrcweir /*************************************************************************
728cdf0e10cSrcweir |*
729cdf0e10cSrcweir |* Die NbcRotate-Routine ueberlaedt die des SdrObject. Die Idee ist die Scene
730cdf0e10cSrcweir |* drehen zu koennen und relativ zur Lage der Scene dann auch die Objekte
731cdf0e10cSrcweir |* in der Scene
732cdf0e10cSrcweir |*
733cdf0e10cSrcweir \************************************************************************/
734cdf0e10cSrcweir
NbcSetTransform(const basegfx::B3DHomMatrix & rMatrix)735cdf0e10cSrcweir void E3dScene::NbcSetTransform(const basegfx::B3DHomMatrix& rMatrix)
736cdf0e10cSrcweir {
737cdf0e10cSrcweir if(maTransformation != rMatrix)
738cdf0e10cSrcweir {
739cdf0e10cSrcweir // call parent
740cdf0e10cSrcweir E3dObject::NbcSetTransform(rMatrix);
741cdf0e10cSrcweir }
742cdf0e10cSrcweir }
743cdf0e10cSrcweir
SetTransform(const basegfx::B3DHomMatrix & rMatrix)744cdf0e10cSrcweir void E3dScene::SetTransform(const basegfx::B3DHomMatrix& rMatrix)
745cdf0e10cSrcweir {
746cdf0e10cSrcweir if(rMatrix != maTransformation)
747cdf0e10cSrcweir {
748cdf0e10cSrcweir // call parent
749cdf0e10cSrcweir E3dObject::SetTransform(rMatrix);
750cdf0e10cSrcweir }
751cdf0e10cSrcweir }
752cdf0e10cSrcweir
NbcRotate(const Point & rRef,long nWink,double sn,double cs)753cdf0e10cSrcweir void E3dScene::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
754cdf0e10cSrcweir {
755cdf0e10cSrcweir // Also derzeit sind die Klebepunkte relativ zum aOutRect der Szene definiert. Vor dem Drehen
756cdf0e10cSrcweir // werden die Klebepunkte relativ zur Seite definiert. Sie nehmen an der Drehung der Szene noch nicht Teil
757cdf0e10cSrcweir // dafuer gibt es den
758cdf0e10cSrcweir SetGlueReallyAbsolute(sal_True);
759cdf0e10cSrcweir
760cdf0e10cSrcweir // So dass war die Szene, ab jetzt kommen die Objekte in der Szene
761cdf0e10cSrcweir // 3D-Objekte gibt es nur ein einziges das kann zwar mehrere Flaechen haben aber die Flaechen
762cdf0e10cSrcweir // muessen ja nicht zusammenhaengend sein
763cdf0e10cSrcweir // es ermoeglicht den Zugriff auf Kindobjekte
764cdf0e10cSrcweir // Ich gehe also die gesamte Liste durch und rotiere um die Z-Achse die durch den
765cdf0e10cSrcweir // Mittelpunkt von aOutRect geht (Satz von Steiner), also RotateZ
766cdf0e10cSrcweir
767cdf0e10cSrcweir RotateScene (rRef, nWink, sn, cs); // Rotiert die Szene
768cdf0e10cSrcweir double fWinkelInRad = nWink/100 * F_PI180;
769cdf0e10cSrcweir
770cdf0e10cSrcweir basegfx::B3DHomMatrix aRotation;
771cdf0e10cSrcweir aRotation.rotate(0.0, 0.0, fWinkelInRad);
772cdf0e10cSrcweir NbcSetTransform(aRotation * GetTransform());
773cdf0e10cSrcweir
774cdf0e10cSrcweir SetRectsDirty(); // Veranlasst eine Neuberechnung aller BoundRects
775cdf0e10cSrcweir NbcRotateGluePoints(rRef,nWink,sn,cs); // Rotiert die Klebepunkte (die haben noch Koordinaten relativ
776cdf0e10cSrcweir // zum Urpsung des Blattes
777cdf0e10cSrcweir SetGlueReallyAbsolute(sal_False); // ab jetzt sind sie wieder relativ zum BoundRect (also dem aOutRect definiert)
778cdf0e10cSrcweir SetRectsDirty();
779cdf0e10cSrcweir }
780cdf0e10cSrcweir
781cdf0e10cSrcweir /*************************************************************************
782cdf0e10cSrcweir |*
783cdf0e10cSrcweir |* SnapRect berechnen
784cdf0e10cSrcweir |*
785cdf0e10cSrcweir \************************************************************************/
786cdf0e10cSrcweir
RecalcSnapRect()787cdf0e10cSrcweir void E3dScene::RecalcSnapRect()
788cdf0e10cSrcweir {
789cdf0e10cSrcweir E3dScene* pScene = GetScene();
790cdf0e10cSrcweir
791cdf0e10cSrcweir if(pScene == this)
792cdf0e10cSrcweir {
793cdf0e10cSrcweir // Szene wird als 2D-Objekt benutzt, nimm SnapRect aus der
794cdf0e10cSrcweir // 2D Bildschrimdarstellung
795cdf0e10cSrcweir Camera3D& rCam = (Camera3D&)pScene->GetCamera();
796cdf0e10cSrcweir maSnapRect = rCam.GetDeviceWindow();
797cdf0e10cSrcweir }
798cdf0e10cSrcweir else
799cdf0e10cSrcweir {
800cdf0e10cSrcweir // Szene ist selbst Mitglied einer anderen Szene, hole das
801cdf0e10cSrcweir // SnapRect als zusammengesetztes Objekt
802cdf0e10cSrcweir E3dObject::RecalcSnapRect();
803cdf0e10cSrcweir }
804cdf0e10cSrcweir }
805cdf0e10cSrcweir
806cdf0e10cSrcweir /*************************************************************************
807cdf0e10cSrcweir |*
808cdf0e10cSrcweir |* Aufbrechen
809cdf0e10cSrcweir |*
810cdf0e10cSrcweir \************************************************************************/
811cdf0e10cSrcweir
IsBreakObjPossible()812cdf0e10cSrcweir sal_Bool E3dScene::IsBreakObjPossible()
813cdf0e10cSrcweir {
814cdf0e10cSrcweir // Szene ist aufzubrechen, wenn alle Mitglieder aufzubrechen sind
815cdf0e10cSrcweir SdrObjListIter a3DIterator(maSubList, IM_DEEPWITHGROUPS);
816cdf0e10cSrcweir
817cdf0e10cSrcweir while ( a3DIterator.IsMore() )
818cdf0e10cSrcweir {
819cdf0e10cSrcweir E3dObject* pObj = (E3dObject*) a3DIterator.Next();
820cdf0e10cSrcweir DBG_ASSERT(pObj->ISA(E3dObject), "AW: In Szenen sind nur 3D-Objekte erlaubt!");
821cdf0e10cSrcweir if(!pObj->IsBreakObjPossible())
822cdf0e10cSrcweir return sal_False;
823cdf0e10cSrcweir }
824cdf0e10cSrcweir
825cdf0e10cSrcweir return sal_True;
826cdf0e10cSrcweir }
827cdf0e10cSrcweir
GetShadowPlaneDirection() const828cdf0e10cSrcweir basegfx::B3DVector E3dScene::GetShadowPlaneDirection() const
829cdf0e10cSrcweir {
830cdf0e10cSrcweir double fWink = (double)GetShadowSlant() * F_PI180;
831cdf0e10cSrcweir basegfx::B3DVector aShadowPlaneDir(0.0, sin(fWink), cos(fWink));
832cdf0e10cSrcweir aShadowPlaneDir.normalize();
833cdf0e10cSrcweir return aShadowPlaneDir;
834cdf0e10cSrcweir }
835cdf0e10cSrcweir
SetShadowPlaneDirection(const basegfx::B3DVector & rVec)836cdf0e10cSrcweir void E3dScene::SetShadowPlaneDirection(const basegfx::B3DVector& rVec)
837cdf0e10cSrcweir {
838cdf0e10cSrcweir sal_uInt16 nSceneShadowSlant = (sal_uInt16)((atan2(rVec.getY(), rVec.getZ()) / F_PI180) + 0.5);
839cdf0e10cSrcweir GetProperties().SetObjectItemDirect(Svx3DShadowSlantItem(nSceneShadowSlant));
840cdf0e10cSrcweir }
841cdf0e10cSrcweir
TakeCreatePoly(const SdrDragStat &) const842cdf0e10cSrcweir basegfx::B2DPolyPolygon E3dScene::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const
843cdf0e10cSrcweir {
844cdf0e10cSrcweir return TakeXorPoly();
845cdf0e10cSrcweir }
846cdf0e10cSrcweir
BegCreate(SdrDragStat & rStat)847cdf0e10cSrcweir FASTBOOL E3dScene::BegCreate(SdrDragStat& rStat)
848cdf0e10cSrcweir {
849cdf0e10cSrcweir rStat.SetOrtho4Possible();
850cdf0e10cSrcweir Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
851cdf0e10cSrcweir aRect1.Justify();
852cdf0e10cSrcweir rStat.SetActionRect(aRect1);
853cdf0e10cSrcweir NbcSetSnapRect(aRect1);
854cdf0e10cSrcweir return sal_True;
855cdf0e10cSrcweir }
856cdf0e10cSrcweir
MovCreate(SdrDragStat & rStat)857cdf0e10cSrcweir FASTBOOL E3dScene::MovCreate(SdrDragStat& rStat)
858cdf0e10cSrcweir {
859cdf0e10cSrcweir Rectangle aRect1;
860cdf0e10cSrcweir rStat.TakeCreateRect(aRect1);
861cdf0e10cSrcweir aRect1.Justify();
862cdf0e10cSrcweir rStat.SetActionRect(aRect1);
863cdf0e10cSrcweir NbcSetSnapRect(aRect1);
864cdf0e10cSrcweir SetBoundRectDirty();
865cdf0e10cSrcweir bSnapRectDirty=sal_True;
866cdf0e10cSrcweir return sal_True;
867cdf0e10cSrcweir }
868cdf0e10cSrcweir
EndCreate(SdrDragStat & rStat,SdrCreateCmd eCmd)869cdf0e10cSrcweir FASTBOOL E3dScene::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
870cdf0e10cSrcweir {
871cdf0e10cSrcweir Rectangle aRect1;
872cdf0e10cSrcweir rStat.TakeCreateRect(aRect1);
873cdf0e10cSrcweir aRect1.Justify();
874cdf0e10cSrcweir NbcSetSnapRect(aRect1);
875cdf0e10cSrcweir SetRectsDirty();
876cdf0e10cSrcweir return (eCmd==SDRCREATE_FORCEEND || rStat.GetPointAnz()>=2);
877cdf0e10cSrcweir }
878cdf0e10cSrcweir
BckCreate(SdrDragStat &)879cdf0e10cSrcweir FASTBOOL E3dScene::BckCreate(SdrDragStat& /*rStat*/)
880cdf0e10cSrcweir {
881cdf0e10cSrcweir return sal_False;
882cdf0e10cSrcweir }
883cdf0e10cSrcweir
BrkCreate(SdrDragStat &)884cdf0e10cSrcweir void E3dScene::BrkCreate(SdrDragStat& /*rStat*/)
885cdf0e10cSrcweir {
886cdf0e10cSrcweir }
887cdf0e10cSrcweir
888cdf0e10cSrcweir // eof
889