Line data Source code
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 :
21 : #include <dragmt3d.hxx>
22 : #include <tools/shl.hxx>
23 : #include <svx/svdpagv.hxx>
24 : #include <svx/dialmgr.hxx>
25 : #include <svx/svddrgmt.hxx>
26 : #include <svx/svdtrans.hxx>
27 : #include <svx/obj3d.hxx>
28 : #include <svx/polysc3d.hxx>
29 : #include <svx/e3dundo.hxx>
30 : #include <svx/dialogs.hrc>
31 : #include <svx/sdr/overlay/overlaypolypolygon.hxx>
32 : #include <svx/sdr/overlay/overlaymanager.hxx>
33 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
34 : #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
35 : #include <drawinglayer/geometry/viewinformation3d.hxx>
36 : #include <svx/e3dsceneupdater.hxx>
37 :
38 0 : TYPEINIT1(E3dDragMethod, SdrDragMethod);
39 :
40 0 : E3dDragMethod::E3dDragMethod (
41 : SdrDragView &_rView,
42 : const SdrMarkList& rMark,
43 : E3dDragConstraint eConstr,
44 : sal_Bool bFull)
45 : : SdrDragMethod(_rView),
46 : meConstraint(eConstr),
47 : mbMoveFull(bFull),
48 0 : mbMovedAtAll(sal_False)
49 : {
50 : // Create a unit for all the 3D objects present in the selection
51 0 : const long nCnt(rMark.GetMarkCount());
52 : static bool bDoInvalidate(false);
53 0 : long nObjs(0);
54 :
55 0 : if(mbMoveFull)
56 : {
57 : // for non-visible 3D objects fallback to wireframe interaction
58 0 : bool bInvisibleObjects(false);
59 :
60 0 : for(nObjs = 0;!bInvisibleObjects && nObjs < nCnt;nObjs++)
61 : {
62 0 : E3dObject* pE3dObj = dynamic_cast< E3dObject* >(rMark.GetMark(nObjs)->GetMarkedSdrObj());
63 :
64 0 : if(pE3dObj)
65 : {
66 0 : if(!pE3dObj->HasFillStyle() && !pE3dObj->HasLineStyle())
67 : {
68 0 : bInvisibleObjects = true;
69 : }
70 : }
71 : }
72 :
73 0 : if(bInvisibleObjects)
74 : {
75 0 : mbMoveFull = false;
76 : }
77 : }
78 :
79 0 : for(nObjs = 0;nObjs < nCnt;nObjs++)
80 : {
81 0 : E3dObject* pE3dObj = dynamic_cast< E3dObject* >(rMark.GetMark(nObjs)->GetMarkedSdrObj());
82 :
83 0 : if(pE3dObj)
84 : {
85 : // fill new interaction unit
86 0 : E3dDragMethodUnit aNewUnit;
87 0 : aNewUnit.mp3DObj = pE3dObj;
88 :
89 : // get transformations
90 0 : aNewUnit.maInitTransform = aNewUnit.maTransform = pE3dObj->GetTransform();
91 :
92 0 : if(pE3dObj->GetParentObj())
93 : {
94 : // get transform between object and world, normally scene transform
95 0 : aNewUnit.maInvDisplayTransform = aNewUnit.maDisplayTransform = pE3dObj->GetParentObj()->GetFullTransform();
96 0 : aNewUnit.maInvDisplayTransform.invert();
97 : }
98 :
99 : // Invalidate SnapRects of the objects involved, to force a
100 : // recalculation for setting the marker
101 0 : if(bDoInvalidate)
102 : {
103 0 : pE3dObj->SetRectsDirty();
104 : }
105 :
106 0 : if(!mbMoveFull)
107 : {
108 : // create wireframe visualisation for parent coordinate system
109 0 : aNewUnit.maWireframePoly.clear();
110 0 : aNewUnit.maWireframePoly = pE3dObj->CreateWireframe();
111 0 : aNewUnit.maWireframePoly.transform(aNewUnit.maTransform);
112 : }
113 :
114 : // Determine FullBound
115 0 : maFullBound.Union(pE3dObj->GetSnapRect());
116 :
117 : // Insert Unit
118 0 : maGrp.push_back(aNewUnit);
119 : }
120 : }
121 0 : }
122 :
123 0 : void E3dDragMethod::TakeSdrDragComment(XubString& /*rStr*/) const
124 : {
125 0 : }
126 :
127 : // Create the wireframe model for all actions
128 :
129 0 : bool E3dDragMethod::BeginSdrDrag()
130 : {
131 0 : if(E3DDRAG_CONSTR_Z == meConstraint)
132 : {
133 0 : const sal_uInt32 nCnt(maGrp.size());
134 0 : DragStat().Ref1() = maFullBound.Center();
135 :
136 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
137 : {
138 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
139 0 : rCandidate.mnStartAngle = GetAngle(DragStat().GetStart() - DragStat().GetRef1());
140 0 : rCandidate.mnLastAngle = 0;
141 : }
142 : }
143 : else
144 : {
145 0 : maLastPos = DragStat().GetStart();
146 : }
147 :
148 0 : if(!mbMoveFull)
149 : {
150 0 : Show();
151 : }
152 :
153 0 : return sal_True;
154 : }
155 :
156 0 : bool E3dDragMethod::EndSdrDrag(bool /*bCopy*/)
157 : {
158 0 : const sal_uInt32 nCnt(maGrp.size());
159 :
160 0 : if(!mbMoveFull)
161 : {
162 : // Hide wireframe
163 0 : Hide();
164 : }
165 :
166 : // Apply all transformations and create undo's
167 0 : if(mbMovedAtAll)
168 : {
169 0 : const bool bUndo = getSdrDragView().IsUndoEnabled();
170 0 : if( bUndo )
171 0 : getSdrDragView().BegUndo(SVX_RESSTR(RID_SVX_3D_UNDO_ROTATE));
172 0 : sal_uInt32 nOb(0);
173 :
174 0 : for(nOb=0;nOb<nCnt;nOb++)
175 : {
176 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
177 0 : E3DModifySceneSnapRectUpdater aUpdater(rCandidate.mp3DObj);
178 0 : rCandidate.mp3DObj->SetTransform(rCandidate.maTransform);
179 0 : if( bUndo )
180 : {
181 0 : getSdrDragView().AddUndo(new E3dRotateUndoAction(rCandidate.mp3DObj->GetModel(),
182 : rCandidate.mp3DObj, rCandidate.maInitTransform,
183 0 : rCandidate.maTransform));
184 : }
185 0 : }
186 0 : if( bUndo )
187 0 : getSdrDragView().EndUndo();
188 : }
189 :
190 0 : return sal_True;
191 : }
192 :
193 0 : void E3dDragMethod::CancelSdrDrag()
194 : {
195 0 : if(mbMoveFull)
196 : {
197 0 : if(mbMovedAtAll)
198 : {
199 0 : const sal_uInt32 nCnt(maGrp.size());
200 :
201 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
202 : {
203 : // Restore transformation
204 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
205 0 : E3DModifySceneSnapRectUpdater aUpdater(rCandidate.mp3DObj);
206 0 : rCandidate.mp3DObj->SetTransform(rCandidate.maInitTransform);
207 0 : }
208 : }
209 : }
210 : else
211 : {
212 : // Hide WireFrame
213 0 : Hide();
214 : }
215 0 : }
216 :
217 : // Common MoveSdrDrag()
218 :
219 0 : void E3dDragMethod::MoveSdrDrag(const Point& /*rPnt*/)
220 : {
221 0 : mbMovedAtAll = true;
222 0 : }
223 :
224 : // Draw the wire frame model
225 :
226 : // for migration from XOR to overlay
227 0 : void E3dDragMethod::CreateOverlayGeometry(::sdr::overlay::OverlayManager& rOverlayManager)
228 : {
229 0 : const sal_uInt32 nCnt(maGrp.size());
230 0 : basegfx::B2DPolyPolygon aResult;
231 :
232 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
233 : {
234 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
235 0 : SdrPageView* pPV = getSdrDragView().GetSdrPageView();
236 :
237 0 : if(pPV && pPV->HasMarkedObjPageView())
238 : {
239 0 : const basegfx::B3DPolyPolygon aCandidate(rCandidate.maWireframePoly);
240 0 : const sal_uInt32 nPlyCnt(aCandidate.count());
241 :
242 0 : if(nPlyCnt)
243 : {
244 0 : const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(rCandidate.mp3DObj->GetScene()->GetViewContact());
245 0 : const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
246 0 : const basegfx::B3DHomMatrix aWorldToView(aViewInfo3D.getDeviceToView() * aViewInfo3D.getProjection() * aViewInfo3D.getOrientation());
247 0 : const basegfx::B3DHomMatrix aTransform(aWorldToView * rCandidate.maDisplayTransform);
248 :
249 : // transform to relative scene coordinates
250 0 : basegfx::B2DPolyPolygon aPolyPolygon(basegfx::tools::createB2DPolyPolygonFromB3DPolyPolygon(aCandidate, aTransform));
251 :
252 : // transform to 2D view coordinates
253 0 : aPolyPolygon.transform(rVCScene.getObjectTransformation());
254 :
255 0 : aResult.append(aPolyPolygon);
256 0 : }
257 : }
258 : }
259 :
260 0 : if(aResult.count())
261 : {
262 0 : ::sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(aResult);
263 0 : rOverlayManager.add(*pNew);
264 0 : addToOverlayObjectList(*pNew);
265 0 : }
266 0 : }
267 :
268 : /*************************************************************************
269 :
270 : E3dDragRotate
271 :
272 : *************************************************************************/
273 :
274 0 : TYPEINIT1(E3dDragRotate, E3dDragMethod);
275 :
276 0 : E3dDragRotate::E3dDragRotate(SdrDragView &_rView,
277 : const SdrMarkList& rMark,
278 : E3dDragConstraint eConstr,
279 : sal_Bool bFull)
280 0 : : E3dDragMethod(_rView, rMark, eConstr, bFull)
281 : {
282 : // Get center of all selected objects in eye coordinates
283 0 : const sal_uInt32 nCnt(maGrp.size());
284 :
285 0 : if(nCnt)
286 : {
287 0 : const E3dScene *pScene = maGrp[0].mp3DObj->GetScene();
288 :
289 0 : if(pScene)
290 : {
291 0 : const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(pScene->GetViewContact());
292 0 : const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
293 :
294 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
295 : {
296 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
297 0 : basegfx::B3DPoint aObjCenter = rCandidate.mp3DObj->GetBoundVolume().getCenter();
298 0 : const basegfx::B3DHomMatrix aTransform(aViewInfo3D.getOrientation() * rCandidate.maDisplayTransform * rCandidate.maInitTransform);
299 :
300 0 : aObjCenter = aTransform * aObjCenter;
301 0 : maGlobalCenter += aObjCenter;
302 0 : }
303 :
304 : // Divide by the number
305 0 : if(nCnt > 1)
306 : {
307 0 : maGlobalCenter /= (double)nCnt;
308 : }
309 :
310 : // get rotate center and transform to 3D eye coordinates
311 0 : basegfx::B2DPoint aRotCenter2D(Ref1().X(), Ref1().Y());
312 :
313 : // from world to relative scene using inverse getObjectTransformation()
314 0 : basegfx::B2DHomMatrix aInverseObjectTransform(rVCScene.getObjectTransformation());
315 0 : aInverseObjectTransform.invert();
316 0 : aRotCenter2D = aInverseObjectTransform * aRotCenter2D;
317 :
318 : // from 3D view to 3D eye
319 0 : basegfx::B3DPoint aRotCenter3D(aRotCenter2D.getX(), aRotCenter2D.getY(), 0.0);
320 0 : basegfx::B3DHomMatrix aInverseViewToEye(aViewInfo3D.getDeviceToView() * aViewInfo3D.getProjection());
321 0 : aInverseViewToEye.invert();
322 0 : aRotCenter3D = aInverseViewToEye * aRotCenter3D;
323 :
324 : // Use X,Y of the RotCenter and depth of the common object centre
325 : // as rotation point in the space
326 0 : maGlobalCenter.setX(aRotCenter3D.getX());
327 0 : maGlobalCenter.setY(aRotCenter3D.getY());
328 : }
329 : }
330 0 : }
331 :
332 :
333 : //The object is moved, determine the angle
334 :
335 0 : void E3dDragRotate::MoveSdrDrag(const Point& rPnt)
336 : {
337 : // call parent
338 0 : E3dDragMethod::MoveSdrDrag(rPnt);
339 :
340 0 : if(DragStat().CheckMinMoved(rPnt))
341 : {
342 : // Get modifier
343 0 : sal_uInt16 nModifier = 0;
344 0 : if(getSdrDragView().ISA(E3dView))
345 : {
346 0 : const MouseEvent& rLastMouse = ((E3dView&)getSdrDragView()).GetMouseEvent();
347 0 : nModifier = rLastMouse.GetModifier();
348 : }
349 :
350 : // Rotate all objects
351 0 : const sal_uInt32 nCnt(maGrp.size());
352 :
353 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
354 : {
355 : // Determine rotation angle
356 : double fWAngle, fHAngle;
357 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
358 :
359 0 : if(E3DDRAG_CONSTR_Z == meConstraint)
360 : {
361 0 : fWAngle = NormAngle360(GetAngle(rPnt - DragStat().GetRef1()) -
362 0 : rCandidate.mnStartAngle) - rCandidate.mnLastAngle;
363 0 : rCandidate.mnLastAngle = (long)fWAngle + rCandidate.mnLastAngle;
364 0 : fWAngle /= 100.0;
365 0 : fHAngle = 0.0;
366 : }
367 : else
368 : {
369 0 : fWAngle = 90.0 * (double)(rPnt.X() - maLastPos.X())
370 0 : / (double)maFullBound.GetWidth();
371 0 : fHAngle = 90.0 * (double)(rPnt.Y() - maLastPos.Y())
372 0 : / (double)maFullBound.GetHeight();
373 : }
374 0 : long nSnap = 0;
375 :
376 0 : if(!getSdrDragView().IsRotateAllowed(sal_False))
377 0 : nSnap = 90;
378 :
379 0 : if(nSnap != 0)
380 : {
381 0 : fWAngle = (double)(((long) fWAngle + nSnap/2) / nSnap * nSnap);
382 0 : fHAngle = (double)(((long) fHAngle + nSnap/2) / nSnap * nSnap);
383 : }
384 :
385 : // to radians
386 0 : fWAngle *= F_PI180;
387 0 : fHAngle *= F_PI180;
388 :
389 : // Determine transformation
390 0 : basegfx::B3DHomMatrix aRotMat;
391 0 : if(E3DDRAG_CONSTR_Y & meConstraint)
392 : {
393 0 : if(nModifier & KEY_MOD2)
394 0 : aRotMat.rotate(0.0, 0.0, fWAngle);
395 : else
396 0 : aRotMat.rotate(0.0, fWAngle, 0.0);
397 : }
398 0 : else if(E3DDRAG_CONSTR_Z & meConstraint)
399 : {
400 0 : if(nModifier & KEY_MOD2)
401 0 : aRotMat.rotate(0.0, fWAngle, 0.0);
402 : else
403 0 : aRotMat.rotate(0.0, 0.0, fWAngle);
404 : }
405 0 : if(E3DDRAG_CONSTR_X & meConstraint)
406 : {
407 0 : aRotMat.rotate(fHAngle, 0.0, 0.0);
408 : }
409 :
410 : // Transformation in eye coordinates, there rotate then and back
411 0 : const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(rCandidate.mp3DObj->GetScene()->GetViewContact());
412 0 : const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
413 0 : basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
414 0 : aInverseOrientation.invert();
415 :
416 0 : basegfx::B3DHomMatrix aTransMat(rCandidate.maDisplayTransform);
417 0 : aTransMat *= aViewInfo3D.getOrientation();
418 0 : aTransMat.translate(-maGlobalCenter.getX(), -maGlobalCenter.getY(), -maGlobalCenter.getZ());
419 0 : aTransMat *= aRotMat;
420 0 : aTransMat.translate(maGlobalCenter.getX(), maGlobalCenter.getY(), maGlobalCenter.getZ());
421 0 : aTransMat *= aInverseOrientation;
422 0 : aTransMat *= rCandidate.maInvDisplayTransform;
423 :
424 : // ...and apply
425 0 : rCandidate.maTransform *= aTransMat;
426 :
427 0 : if(mbMoveFull)
428 : {
429 0 : E3DModifySceneSnapRectUpdater aUpdater(rCandidate.mp3DObj);
430 0 : rCandidate.mp3DObj->SetTransform(rCandidate.maTransform);
431 : }
432 : else
433 : {
434 0 : Hide();
435 0 : rCandidate.maWireframePoly.transform(aTransMat);
436 0 : Show();
437 : }
438 0 : }
439 0 : maLastPos = rPnt;
440 0 : DragStat().NextMove(rPnt);
441 : }
442 0 : }
443 :
444 0 : Pointer E3dDragRotate::GetSdrDragPointer() const
445 : {
446 0 : return Pointer(POINTER_ROTATE);
447 : }
448 :
449 : // E3dDragMove. This drag method is only required for translations inside
450 : // 3D scenes. If a 3D-scene itself moved, then this drag method will drag
451 : // not be used.
452 :
453 0 : TYPEINIT1(E3dDragMove, E3dDragMethod);
454 :
455 0 : E3dDragMove::E3dDragMove(SdrDragView &_rView,
456 : const SdrMarkList& rMark,
457 : SdrHdlKind eDrgHdl,
458 : E3dDragConstraint eConstr,
459 : sal_Bool bFull)
460 : : E3dDragMethod(_rView, rMark, eConstr, bFull),
461 0 : meWhatDragHdl(eDrgHdl)
462 : {
463 0 : switch(meWhatDragHdl)
464 : {
465 : case HDL_LEFT:
466 0 : maScaleFixPos = maFullBound.RightCenter();
467 0 : break;
468 : case HDL_RIGHT:
469 0 : maScaleFixPos = maFullBound.LeftCenter();
470 0 : break;
471 : case HDL_UPPER:
472 0 : maScaleFixPos = maFullBound.BottomCenter();
473 0 : break;
474 : case HDL_LOWER:
475 0 : maScaleFixPos = maFullBound.TopCenter();
476 0 : break;
477 : case HDL_UPLFT:
478 0 : maScaleFixPos = maFullBound.BottomRight();
479 0 : break;
480 : case HDL_UPRGT:
481 0 : maScaleFixPos = maFullBound.BottomLeft();
482 0 : break;
483 : case HDL_LWLFT:
484 0 : maScaleFixPos = maFullBound.TopRight();
485 0 : break;
486 : case HDL_LWRGT:
487 0 : maScaleFixPos = maFullBound.TopLeft();
488 0 : break;
489 : default:
490 : // Moving the object, HDL_MOVE
491 0 : break;
492 : }
493 :
494 : // Override when IsResizeAtCenter()
495 0 : if(getSdrDragView().IsResizeAtCenter())
496 : {
497 0 : meWhatDragHdl = HDL_USER;
498 0 : maScaleFixPos = maFullBound.Center();
499 : }
500 0 : }
501 :
502 : // The object is moved, determine the translations
503 :
504 0 : void E3dDragMove::MoveSdrDrag(const Point& rPnt)
505 : {
506 : // call parent
507 0 : E3dDragMethod::MoveSdrDrag(rPnt);
508 :
509 0 : if(DragStat().CheckMinMoved(rPnt))
510 : {
511 0 : if(HDL_MOVE == meWhatDragHdl)
512 : {
513 : // Translation
514 : // Determine the motion vector
515 0 : basegfx::B3DPoint aGlobalMoveHead((double)(rPnt.X() - maLastPos.X()), (double)(rPnt.Y() - maLastPos.Y()), 32768.0);
516 0 : basegfx::B3DPoint aGlobalMoveTail(0.0, 0.0, 32768.0);
517 0 : const sal_uInt32 nCnt(maGrp.size());
518 :
519 : // Get modifier
520 0 : sal_uInt16 nModifier(0);
521 :
522 0 : if(getSdrDragView().ISA(E3dView))
523 : {
524 0 : const MouseEvent& rLastMouse = ((E3dView&)getSdrDragView()).GetMouseEvent();
525 0 : nModifier = rLastMouse.GetModifier();
526 : }
527 :
528 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
529 : {
530 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
531 0 : const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(rCandidate.mp3DObj->GetScene()->GetViewContact());
532 0 : const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
533 :
534 : // move coor from 2d world to 3d Eye
535 0 : basegfx::B2DPoint aGlobalMoveHead2D((double)(rPnt.X() - maLastPos.X()), (double)(rPnt.Y() - maLastPos.Y()));
536 0 : basegfx::B2DPoint aGlobalMoveTail2D(0.0, 0.0);
537 0 : basegfx::B2DHomMatrix aInverseSceneTransform(rVCScene.getObjectTransformation());
538 :
539 0 : aInverseSceneTransform.invert();
540 0 : aGlobalMoveHead2D = aInverseSceneTransform * aGlobalMoveHead2D;
541 0 : aGlobalMoveTail2D = aInverseSceneTransform * aGlobalMoveTail2D;
542 :
543 0 : basegfx::B3DPoint aMoveHead3D(aGlobalMoveHead2D.getX(), aGlobalMoveHead2D.getY(), 0.5);
544 0 : basegfx::B3DPoint aMoveTail3D(aGlobalMoveTail2D.getX(), aGlobalMoveTail2D.getY(), 0.5);
545 0 : basegfx::B3DHomMatrix aInverseViewToEye(aViewInfo3D.getDeviceToView() * aViewInfo3D.getProjection());
546 0 : aInverseViewToEye.invert();
547 :
548 0 : aMoveHead3D = aInverseViewToEye * aMoveHead3D;
549 0 : aMoveTail3D = aInverseViewToEye * aMoveTail3D;
550 :
551 : // eventually switch movement from XY to XZ plane
552 0 : if(nModifier & KEY_MOD2)
553 : {
554 0 : double fZwi = aMoveHead3D.getY();
555 0 : aMoveHead3D.setY(aMoveHead3D.getZ());
556 0 : aMoveHead3D.setZ(fZwi);
557 :
558 0 : fZwi = aMoveTail3D.getY();
559 0 : aMoveTail3D.setY(aMoveTail3D.getZ());
560 0 : aMoveTail3D.setZ(fZwi);
561 : }
562 :
563 : // Motion vector from eye coordinates to parent coordinates
564 0 : basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
565 0 : aInverseOrientation.invert();
566 0 : basegfx::B3DHomMatrix aCompleteTrans(rCandidate.maInvDisplayTransform * aInverseOrientation);
567 :
568 0 : aMoveHead3D = aCompleteTrans * aMoveHead3D;
569 0 : aMoveTail3D = aCompleteTrans* aMoveTail3D;
570 :
571 : // build transformation
572 0 : basegfx::B3DHomMatrix aTransMat;
573 0 : basegfx::B3DPoint aTranslate(aMoveHead3D - aMoveTail3D);
574 0 : aTransMat.translate(aTranslate.getX(), aTranslate.getY(), aTranslate.getZ());
575 :
576 : // ...and apply
577 0 : rCandidate.maTransform *= aTransMat;
578 :
579 0 : if(mbMoveFull)
580 : {
581 0 : E3DModifySceneSnapRectUpdater aUpdater(rCandidate.mp3DObj);
582 0 : rCandidate.mp3DObj->SetTransform(rCandidate.maTransform);
583 : }
584 : else
585 : {
586 0 : Hide();
587 0 : rCandidate.maWireframePoly.transform(aTransMat);
588 0 : Show();
589 : }
590 0 : }
591 : }
592 : else
593 : {
594 : // Scaling
595 : // Determine scaling vector
596 0 : Point aStartPos = DragStat().GetStart();
597 0 : const sal_uInt32 nCnt(maGrp.size());
598 :
599 0 : for(sal_uInt32 nOb(0); nOb < nCnt; nOb++)
600 : {
601 0 : E3dDragMethodUnit& rCandidate = maGrp[nOb];
602 0 : const basegfx::B3DPoint aObjectCenter(rCandidate.mp3DObj->GetBoundVolume().getCenter());
603 :
604 : // transform from 2D world view to 3D eye
605 0 : const sdr::contact::ViewContactOfE3dScene& rVCScene = static_cast< sdr::contact::ViewContactOfE3dScene& >(rCandidate.mp3DObj->GetScene()->GetViewContact());
606 0 : const drawinglayer::geometry::ViewInformation3D aViewInfo3D(rVCScene.getViewInformation3D());
607 :
608 0 : basegfx::B2DPoint aGlobalScaleStart2D((double)(aStartPos.X()), (double)(aStartPos.Y()));
609 0 : basegfx::B2DPoint aGlobalScaleNext2D((double)(rPnt.X()), (double)(rPnt.Y()));
610 0 : basegfx::B2DPoint aGlobalScaleFixPos2D((double)(maScaleFixPos.X()), (double)(maScaleFixPos.Y()));
611 0 : basegfx::B2DHomMatrix aInverseSceneTransform(rVCScene.getObjectTransformation());
612 :
613 0 : aInverseSceneTransform.invert();
614 0 : aGlobalScaleStart2D = aInverseSceneTransform * aGlobalScaleStart2D;
615 0 : aGlobalScaleNext2D = aInverseSceneTransform * aGlobalScaleNext2D;
616 0 : aGlobalScaleFixPos2D = aInverseSceneTransform * aGlobalScaleFixPos2D;
617 :
618 0 : basegfx::B3DPoint aGlobalScaleStart3D(aGlobalScaleStart2D.getX(), aGlobalScaleStart2D.getY(), aObjectCenter.getZ());
619 0 : basegfx::B3DPoint aGlobalScaleNext3D(aGlobalScaleNext2D.getX(), aGlobalScaleNext2D.getY(), aObjectCenter.getZ());
620 0 : basegfx::B3DPoint aGlobalScaleFixPos3D(aGlobalScaleFixPos2D.getX(), aGlobalScaleFixPos2D.getY(), aObjectCenter.getZ());
621 0 : basegfx::B3DHomMatrix aInverseViewToEye(aViewInfo3D.getDeviceToView() * aViewInfo3D.getProjection());
622 :
623 0 : aInverseViewToEye.invert();
624 0 : basegfx::B3DPoint aScStart(aInverseViewToEye * aGlobalScaleStart3D);
625 0 : basegfx::B3DPoint aScNext(aInverseViewToEye * aGlobalScaleNext3D);
626 0 : basegfx::B3DPoint aScFixPos(aInverseViewToEye * aGlobalScaleFixPos3D);
627 :
628 : // constraints?
629 0 : switch(meWhatDragHdl)
630 : {
631 : case HDL_LEFT:
632 : case HDL_RIGHT:
633 : // to constrain on X -> Y equal
634 0 : aScNext.setY(aScFixPos.getY());
635 0 : break;
636 : case HDL_UPPER:
637 : case HDL_LOWER:
638 : // constrain to auf Y -> X equal
639 0 : aScNext.setX(aScFixPos.getX());
640 0 : break;
641 : default:
642 0 : break;
643 : }
644 :
645 : // get scale vector in eye coordinates
646 0 : basegfx::B3DPoint aScaleVec(aScStart - aScFixPos);
647 0 : aScaleVec.setZ(1.0);
648 :
649 0 : if(aScaleVec.getX() != 0.0)
650 : {
651 0 : aScaleVec.setX((aScNext.getX() - aScFixPos.getX()) / aScaleVec.getX());
652 : }
653 : else
654 : {
655 0 : aScaleVec.setX(1.0);
656 : }
657 :
658 0 : if(aScaleVec.getY() != 0.0)
659 : {
660 0 : aScaleVec.setY((aScNext.getY() - aScFixPos.getY()) / aScaleVec.getY());
661 : }
662 : else
663 : {
664 0 : aScaleVec.setY(1.0);
665 : }
666 :
667 : // SHIFT-key used?
668 0 : if(getSdrDragView().IsOrtho())
669 : {
670 0 : if(fabs(aScaleVec.getX()) > fabs(aScaleVec.getY()))
671 : {
672 : // X is biggest
673 0 : aScaleVec.setY(aScaleVec.getX());
674 : }
675 : else
676 : {
677 : // Y is biggest
678 0 : aScaleVec.setX(aScaleVec.getY());
679 : }
680 : }
681 :
682 : // build transformation
683 0 : basegfx::B3DHomMatrix aInverseOrientation(aViewInfo3D.getOrientation());
684 0 : aInverseOrientation.invert();
685 :
686 0 : basegfx::B3DHomMatrix aNewTrans = rCandidate.maInitTransform;
687 0 : aNewTrans *= rCandidate.maDisplayTransform;
688 0 : aNewTrans *= aViewInfo3D.getOrientation();
689 0 : aNewTrans.translate(-aScFixPos.getX(), -aScFixPos.getY(), -aScFixPos.getZ());
690 0 : aNewTrans.scale(aScaleVec.getX(), aScaleVec.getY(), aScaleVec.getZ());
691 0 : aNewTrans.translate(aScFixPos.getX(), aScFixPos.getY(), aScFixPos.getZ());
692 0 : aNewTrans *= aInverseOrientation;
693 0 : aNewTrans *= rCandidate.maInvDisplayTransform;
694 :
695 : // ...and apply
696 0 : rCandidate.maTransform = aNewTrans;
697 :
698 0 : if(mbMoveFull)
699 : {
700 0 : E3DModifySceneSnapRectUpdater aUpdater(rCandidate.mp3DObj);
701 0 : rCandidate.mp3DObj->SetTransform(rCandidate.maTransform);
702 : }
703 : else
704 : {
705 0 : Hide();
706 0 : rCandidate.maWireframePoly.clear();
707 0 : rCandidate.maWireframePoly = rCandidate.mp3DObj->CreateWireframe();
708 0 : rCandidate.maWireframePoly.transform(rCandidate.maTransform);
709 0 : Show();
710 : }
711 0 : }
712 : }
713 0 : maLastPos = rPnt;
714 0 : DragStat().NextMove(rPnt);
715 : }
716 0 : }
717 :
718 0 : Pointer E3dDragMove::GetSdrDragPointer() const
719 : {
720 0 : return Pointer(POINTER_MOVE);
721 : }
722 :
723 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
