?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / svx / source / svdraw / svddrgmt.cxx
blob5c582541e278e1a568e2ce75ab610dbbac808a9f
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: svddrgmt.cxx,v $
10 * $Revision: 1.21.6.2 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svx.hxx"
33
34 #include "svddrgm1.hxx"
35 #include <math.h>
36
37 #ifndef _MATH_H
38 #define _MATH_H
39 #endif
40 #include <tools/bigint.hxx>
41 #include <vcl/svapp.hxx>
42
43 #include "xattr.hxx"
44 #include <svx/xpoly.hxx>
45 #include <svx/svdetc.hxx>
46 #include <svx/svdtrans.hxx>
47 #include <svx/svdundo.hxx>
48 #include <svx/svdmark.hxx>
49 #include <svx/svdocapt.hxx>
50 #include <svx/svdpagv.hxx>
51 #include "svdstr.hrc" // Namen aus der Resource
52 #include "svdglob.hxx" // StringCache
53 #include <svx/svddrgv.hxx>
54 #include <svx/svdundo.hxx>
55 #include <svx/svdograf.hxx>
56 #include <svx/dialogs.hrc>
57 #include <svx/dialmgr.hxx>
58 #include <svx/sdgcpitm.hxx>
59 #include <basegfx/polygon/b2dpolygon.hxx>
60 #include <basegfx/polygon/b2dpolygontools.hxx>
61 #include <svx/sdr/overlay/overlaypolypolygon.hxx>
62 #include <svx/sdr/overlay/overlaymanager.hxx>
63 #include <svx/sdr/overlay/overlayrollingrectangle.hxx>
64 #include <svx/sdrpagewindow.hxx>
65 #include <sdrpaintwindow.hxx>
66 #include <basegfx/matrix/b2dhommatrix.hxx>
67 #include <basegfx/polygon/b2dpolypolygontools.hxx>
68 #include <svx/sdr/contact/viewobjectcontact.hxx>
69 #include <svx/sdr/contact/viewcontact.hxx>
70 #include <svx/sdr/contact/displayinfo.hxx>
71 #include <svx/sdr/overlay/overlayprimitive2dsequenceobject.hxx>
72 #include <drawinglayer/primitive2d/unifiedalphaprimitive2d.hxx>
73 #include <svx/sdr/contact/objectcontact.hxx>
74 #include "svditer.hxx"
75 #include <svx/svdopath.hxx>
76 #include <svx/polypolygoneditor.hxx>
77 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
78 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
79 #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
80 #include <svx/sdr/primitive2d/sdrattributecreator.hxx>
81 #include <drawinglayer/attribute/sdrattribute.hxx>
82 #include <svx/sdr/primitive2d/sdrdecompositiontools.hxx>
83 #include <svx/svdoole2.hxx>
84 #include <svx/svdovirt.hxx>
85 #include <svx/svdouno.hxx>
86 #include <svx/sdr/primitive2d/sdrprimitivetools.hxx>
87
88 ////////////////////////////////////////////////////////////////////////////////////////////////////
89
90 SdrDragEntry::SdrDragEntry()
91 : mbAddToTransparent(false)
92 {
93 }
94
95 SdrDragEntry::~SdrDragEntry()
96 {
97 }
98
99 ////////////////////////////////////////////////////////////////////////////////////////////////////
100
101 SdrDragEntryPolyPolygon::SdrDragEntryPolyPolygon(const basegfx::B2DPolyPolygon& rOriginalPolyPolygon)
102 : SdrDragEntry(),
103 maOriginalPolyPolygon(rOriginalPolyPolygon)
104 {
105 }
106
107 SdrDragEntryPolyPolygon::~SdrDragEntryPolyPolygon()
108 {
109 }
110
111 drawinglayer::primitive2d::Primitive2DSequence SdrDragEntryPolyPolygon::createPrimitive2DSequenceInCurrentState(SdrDragMethod& rDragMethod)
112 {
113 drawinglayer::primitive2d::Primitive2DSequence aRetval;
114
115 if(maOriginalPolyPolygon.count())
116 {
117 basegfx::B2DPolyPolygon aCopy(maOriginalPolyPolygon);
118 const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
119
120 rDragMethod.applyCurrentTransformationToPolyPolygon(aCopy);
121 basegfx::BColor aColA(aSvtOptionsDrawinglayer.GetStripeColorA().getBColor());
122 basegfx::BColor aColB(aSvtOptionsDrawinglayer.GetStripeColorB().getBColor());
123 const double fStripeLength(aSvtOptionsDrawinglayer.GetStripeLength());
124
125 if(Application::GetSettings().GetStyleSettings().GetHighContrastMode())
126 {
127 aColA = aColB = Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor();
128 aColB.invert();
129 }
130
131 drawinglayer::primitive2d::Primitive2DReference aPolyPolygonMarkerPrimitive2D(
132 new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(aCopy, aColA, aColB, fStripeLength));
133
134 aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aPolyPolygonMarkerPrimitive2D, 1);
135 }
136
137 return aRetval;
138 }
139
140 ////////////////////////////////////////////////////////////////////////////////////////////////////
141
142 SdrDragEntrySdrObject::SdrDragEntrySdrObject(const SdrObject& rOriginal, sdr::contact::ObjectContact& rObjectContact, bool bModify)
143 : SdrDragEntry(),
144 maOriginal(rOriginal),
145 mpClone(0),
146 mrObjectContact(rObjectContact),
147 mbModify(bModify)
148 {
149 // add SdrObject parts to transparent overlay stuff
150 setAddToTransparent(true);
151 }
152
153 SdrDragEntrySdrObject::~SdrDragEntrySdrObject()
154 {
155 if(mpClone)
156 {
157 SdrObject::Free(mpClone);
158 }
159 }
160
161 drawinglayer::primitive2d::Primitive2DSequence SdrDragEntrySdrObject::createPrimitive2DSequenceInCurrentState(SdrDragMethod& rDragMethod)
162 {
163 // for the moment, i need to re-create the clone in all cases. I need to figure
164 // out when clone and original have the same class, so that i can use operator=
165 // in those cases
166
167 // // copy all other needed stuff
168 // basegfx::B2DHomMatrix aMatrix;
169 // basegfx::B2DPolyPolygon aPolyPolygon;
170 // pOleObject->TRGetBaseGeometry(aMatrix, aPolyPolygon);
171 // pClone->TRSetBaseGeometry(aMatrix, aPolyPolygon);
172
173 const SdrObject* pSource = &maOriginal;
174
175 if(mpClone)
176 {
177 SdrObject::Free(mpClone);
178 mpClone = 0;
179 }
180
181 if(mbModify)
182 {
183 if(!mpClone)
184 {
185 mpClone = maOriginal.getFullDragClone();
186 }
187
188 // apply original transformation, implemented at the DragMethods
189 rDragMethod.applyCurrentTransformationToSdrObject(*mpClone);
190
191 // choose source for geometry data
192 pSource = mpClone;
193 }
194
195 // get VOC and Primitive2DSequence
196 sdr::contact::ViewContact& rVC = pSource->GetViewContact();
197 sdr::contact::ViewObjectContact& rVOC = rVC.GetViewObjectContact(mrObjectContact);
198 sdr::contact::DisplayInfo aDisplayInfo;
199
200 // Do not use the last ViewPort set at the OC from the last ProcessDisplay(),
201 // here we want the complete primitive sequence without visibility clippings
202 mrObjectContact.resetViewPort();
203
204 return rVOC.getPrimitive2DSequenceHierarchy(aDisplayInfo);
205 }
206
207 ////////////////////////////////////////////////////////////////////////////////////////////////////
208
209 SdrDragEntryPointGlueDrag::SdrDragEntryPointGlueDrag(const std::vector< basegfx::B2DPoint >& rPositions, bool bIsPointDrag)
210 : maPositions(rPositions),
211 mbIsPointDrag(bIsPointDrag)
212 {
213 // add SdrObject parts to transparent overlay stuff
214 setAddToTransparent(true);
215 }
216
217 SdrDragEntryPointGlueDrag::~SdrDragEntryPointGlueDrag()
218 {
219 }
220
221 drawinglayer::primitive2d::Primitive2DSequence SdrDragEntryPointGlueDrag::createPrimitive2DSequenceInCurrentState(SdrDragMethod& rDragMethod)
222 {
223 drawinglayer::primitive2d::Primitive2DSequence aRetval;
224
225 if(maPositions.size())
226 {
227 basegfx::B2DPolygon aPolygon;
228 sal_uInt32 a(0);
229
230 for(a = 0; a < maPositions.size(); a++)
231 {
232 aPolygon.append(maPositions[a]);
233 }
234
235 basegfx::B2DPolyPolygon aPolyPolygon(aPolygon);
236
237 rDragMethod.applyCurrentTransformationToPolyPolygon(aPolyPolygon);
238
239 const basegfx::B2DPolygon aTransformed(aPolyPolygon.getB2DPolygon(0));
240 std::vector< basegfx::B2DPoint > aTransformedPositions;
241
242 aTransformedPositions.reserve(aTransformed.count());
243
244 for(a = 0; a < aTransformed.count(); a++)
245 {
246 aTransformedPositions.push_back(aTransformed.getB2DPoint(a));
247 }
248
249 if(mbIsPointDrag)
250 {
251 const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
252 basegfx::BColor aColor(aSvtOptionsDrawinglayer.GetStripeColorA().getBColor());
253
254 if(Application::GetSettings().GetStyleSettings().GetHighContrastMode())
255 {
256 aColor = Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor();
257 }
258
259 drawinglayer::primitive2d::Primitive2DReference aMarkerArrayPrimitive2D(
260 new drawinglayer::primitive2d::MarkerArrayPrimitive2D(aTransformedPositions,
261 drawinglayer::primitive2d::createDefaultCross_3x3(aColor)));
262
263 aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aMarkerArrayPrimitive2D, 1);
264 }
265 else
266 {
267 const basegfx::BColor aBackPen(1.0, 1.0, 1.0);
268 const basegfx::BColor aRGBFrontColor(0.0, 0.0, 1.0); // COL_LIGHTBLUE
269 drawinglayer::primitive2d::Primitive2DReference aMarkerArrayPrimitive2D(
270 new drawinglayer::primitive2d::MarkerArrayPrimitive2D(aTransformedPositions,
271 drawinglayer::primitive2d::createDefaultGluepoint_7x7(aBackPen, aRGBFrontColor)));
272
273 aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aMarkerArrayPrimitive2D, 1);
274 }
275 }
276
277 return aRetval;
278 }
279
280 ////////////////////////////////////////////////////////////////////////////////////////////////////
281
282 TYPEINIT0(SdrDragMethod);
283
284 void SdrDragMethod::resetSdrDragEntries()
285 {
286 // clear entries; creation is on demand
287 clearSdrDragEntries();
288 }
289
290 basegfx::B2DRange SdrDragMethod::getCurrentRange() const
291 {
292 return getB2DRangeFromOverlayObjectList();
293 }
294
295 void SdrDragMethod::createSdrDragEntries()
296 {
297 if(getSdrDragView().GetSdrPageView() && getSdrDragView().GetSdrPageView()->HasMarkedObjPageView())
298 {
299 if(getSdrDragView().IsDraggingPoints())
300 {
301 createSdrDragEntries_PointDrag();
302 }
303 else if(getSdrDragView().IsDraggingGluePoints())
304 {
305 createSdrDragEntries_GlueDrag();
306 }
307 else
308 {
309 if(getSolidDraggingActive())
310 {
311 createSdrDragEntries_SolidDrag();
312 }
313 else
314 {
315 createSdrDragEntries_PolygonDrag();
316 }
317 }
318 }
319 }
320
321 void SdrDragMethod::createSdrDragEntries_SolidDrag()
322 {
323 const sal_uInt32 nMarkAnz(getSdrDragView().GetMarkedObjectCount());
324 SdrPageView* pPV = getSdrDragView().GetSdrPageView();
325
326 if(pPV)
327 {
328 for(sal_uInt32 a(0); a < nMarkAnz; a++)
329 {
330 SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(a);
331
332 if(pM->GetPageView() == pPV)
333 {
334 const SdrObject* pObject = pM->GetMarkedSdrObj();
335
336 if(pObject)
337 {
338 if(pPV->PageWindowCount())
339 {
340 sdr::contact::ObjectContact& rOC = pPV->GetPageWindow(0)->GetObjectContact();
341 SdrObjListIter aIter(*pObject);
342
343 while(aIter.IsMore())
344 {
345 SdrObject* pCandidate = aIter.Next();
346
347 if(pCandidate)
348 {
349 const bool bSuppressFullDrag(!pCandidate->supportsFullDrag());
350 bool bAddWireframe(bSuppressFullDrag);
351
352 if(!bAddWireframe && !pCandidate->HasLineStyle())
353 {
354 // add wireframe for objects without outline
355 bAddWireframe = true;
356 }
357
358 if(!bSuppressFullDrag)
359 {
360 // add full obejct drag; Clone() at the object has to work
361 // for this
362 addSdrDragEntry(new SdrDragEntrySdrObject(*pCandidate, rOC, true));
363 }
364
365 if(bAddWireframe)
366 {
367 // when dragging a 50% transparent copy of a filled or not filled object without
368 // outline, this is normally hard to see. Add extra wireframe in that case. This
369 // works nice e.g. with thext frames etc.
370 addSdrDragEntry(new SdrDragEntryPolyPolygon(pCandidate->TakeXorPoly()));
371 }
372 }
373 }
374 }
375 }
376 }
377 }
378 }
379 }
380
381 void SdrDragMethod::createSdrDragEntries_PolygonDrag()
382 {
383 const sal_uInt32 nMarkAnz(getSdrDragView().GetMarkedObjectCount());
384 bool bNoPolygons(getSdrDragView().IsNoDragXorPolys() || nMarkAnz > getSdrDragView().GetDragXorPolyLimit());
385 basegfx::B2DPolyPolygon aResult;
386 sal_uInt32 nPointCount(0);
387
388 for(sal_uInt32 a(0); !bNoPolygons && a < nMarkAnz; a++)
389 {
390 SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(a);
391
392 if(pM->GetPageView() == getSdrDragView().GetSdrPageView())
393 {
394 const basegfx::B2DPolyPolygon aNewPolyPolygon(pM->GetMarkedSdrObj()->TakeXorPoly());
395
396 for(sal_uInt32 b(0); b < aNewPolyPolygon.count(); b++)
397 {
398 nPointCount += aNewPolyPolygon.getB2DPolygon(b).count();
399 }
400
401 if(nPointCount > getSdrDragView().GetDragXorPointLimit())
402 {
403 bNoPolygons = true;
404 }
405
406 if(!bNoPolygons)
407 {
408 aResult.append(aNewPolyPolygon);
409 }
410 }
411 }
412
413 if(bNoPolygons)
414 {
415 const Rectangle aR(getSdrDragView().GetSdrPageView()->MarkSnap());
416 const basegfx::B2DRange aNewRectangle(aR.Left(), aR.Top(), aR.Right(), aR.Bottom());
417 basegfx::B2DPolygon aNewPolygon(basegfx::tools::createPolygonFromRect(aNewRectangle));
418
419 aResult = basegfx::B2DPolyPolygon(basegfx::tools::expandToCurve(aNewPolygon));
420 }
421
422 if(aResult.count())
423 {
424 addSdrDragEntry(new SdrDragEntryPolyPolygon(aResult));
425 }
426 }
427
428 void SdrDragMethod::createSdrDragEntries_PointDrag()
429 {
430 const sal_uInt32 nMarkAnz(getSdrDragView().GetMarkedObjectCount());
431 std::vector< basegfx::B2DPoint > aPositions;
432
433 for(sal_uInt32 nm(0); nm < nMarkAnz; nm++)
434 {
435 SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(nm);
436
437 if(pM->GetPageView() == getSdrDragView().GetSdrPageView())
438 {
439 const SdrUShortCont* pPts = pM->GetMarkedPoints();
440
441 if(pPts && pPts->GetCount())
442 {
443 const SdrObject* pObj = pM->GetMarkedSdrObj();
444 const SdrPathObj* pPath = dynamic_cast< const SdrPathObj* >(pObj);
445
446 if(pPath)
447 {
448 const basegfx::B2DPolyPolygon aPathXPP = pPath->GetPathPoly();
449
450 if(aPathXPP.count())
451 {
452 const sal_uInt32 nPtAnz(pPts->GetCount());
453
454 for(sal_uInt32 nPtNum(0); nPtNum < nPtAnz; nPtNum++)
455 {
456 sal_uInt32 nPolyNum, nPointNum;
457 const sal_uInt16 nObjPt(pPts->GetObject(nPtNum));
458
459 if(sdr::PolyPolygonEditor::GetRelativePolyPoint(aPathXPP, nObjPt, nPolyNum, nPointNum))
460 {
461 aPositions.push_back(aPathXPP.getB2DPolygon(nPolyNum).getB2DPoint(nPointNum));
462 }
463 }
464 }
465 }
466 }
467 }
468 }
469
470 if(aPositions.size())
471 {
472 addSdrDragEntry(new SdrDragEntryPointGlueDrag(aPositions, true));
473 }
474 }
475
476 void SdrDragMethod::createSdrDragEntries_GlueDrag()
477 {
478 const sal_uInt32 nMarkAnz(getSdrDragView().GetMarkedObjectCount());
479 std::vector< basegfx::B2DPoint > aPositions;
480
481 for(sal_uInt32 nm(0); nm < nMarkAnz; nm++)
482 {
483 SdrMark* pM = getSdrDragView().GetSdrMarkByIndex(nm);
484
485 if(pM->GetPageView() == getSdrDragView().GetSdrPageView())
486 {
487 const SdrUShortCont* pPts = pM->GetMarkedGluePoints();
488
489 if(pPts && pPts->GetCount())
490 {
491 const SdrObject* pObj = pM->GetMarkedSdrObj();
492 const SdrGluePointList* pGPL = pObj->GetGluePointList();
493
494 if(pGPL)
495 {
496 const sal_uInt32 nPtAnz(pPts->GetCount());
497
498 for(sal_uInt32 nPtNum(0); nPtNum < nPtAnz; nPtNum++)
499 {
500 const sal_uInt16 nObjPt(pPts->GetObject(nPtNum));
501 const sal_uInt16 nGlueNum(pGPL->FindGluePoint(nObjPt));
502
503 if(SDRGLUEPOINT_NOTFOUND != nGlueNum)
504 {
505 const Point aPoint((*pGPL)[nGlueNum].GetAbsolutePos(*pObj));
506 aPositions.push_back(basegfx::B2DPoint(aPoint.X(), aPoint.Y()));
507 }
508 }
509 }
510 }
511 }
512 }
513
514 if(aPositions.size())
515 {
516 addSdrDragEntry(new SdrDragEntryPointGlueDrag(aPositions, false));
517 }
518 }
519
520 void SdrDragMethod::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, XubString& rStr, sal_uInt16 nVal) const
521 {
522 sal_uInt16 nOpt=0;
523 if (IsDraggingPoints()) {
524 nOpt=IMPSDR_POINTSDESCRIPTION;
525 } else if (IsDraggingGluePoints()) {
526 nOpt=IMPSDR_GLUEPOINTSDESCRIPTION;
527 }
528 getSdrDragView().ImpTakeDescriptionStr(nStrCacheID,rStr,nVal,nOpt);
529 }
530
531 SdrObject* SdrDragMethod::GetDragObj() const
532 {
533 SdrObject* pObj=NULL;
534 if (getSdrDragView().pDragHdl!=NULL) pObj=getSdrDragView().pDragHdl->GetObj();
535 if (pObj==NULL) pObj=getSdrDragView().pMarkedObj;
536 return pObj;
537 }
538
539 SdrPageView* SdrDragMethod::GetDragPV() const
540 {
541 SdrPageView* pPV=NULL;
542 if (getSdrDragView().pDragHdl!=NULL) pPV=getSdrDragView().pDragHdl->GetPageView();
543 if (pPV==NULL) pPV=getSdrDragView().pMarkedPV;
544 return pPV;
545 }
546
547 void SdrDragMethod::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
548 {
549 // the original applies the transformation using TRGetBaseGeometry/TRSetBaseGeometry.
550 // Later this should be the only needed one for linear transforms (not for SdrDragCrook and
551 // SdrDragDistort, those are NOT linear). Currently, this can not yet be used since the
552 // special handling of rotate/mirror due to the not-being-able to handle it in the old
553 // drawinglayer stuff. Text would currently not correctly be mirrored in the preview.
554 basegfx::B2DHomMatrix aObjectTransform;
555 basegfx::B2DPolyPolygon aObjectPolyPolygon;
556 bool bPolyUsed(rTarget.TRGetBaseGeometry(aObjectTransform, aObjectPolyPolygon));
557
558 // apply transform to object transform
559 aObjectTransform *= getCurrentTransformation();
560
561 if(bPolyUsed)
562 {
563 // do something special since the object size is in the polygon
564 // break up matrix to get the scale
565 basegfx::B2DTuple aScale;
566 basegfx::B2DTuple aTranslate;
567 double fRotate, fShearX;
568 aObjectTransform.decompose(aScale, aTranslate, fRotate, fShearX);
569
570 // get polygon's pos and size
571 const basegfx::B2DRange aPolyRange(aObjectPolyPolygon.getB2DRange());
572
573 // get the scaling factors (do not mirror, this is in the object transformation)
574 const double fScaleX(fabs(aScale.getX()) / (basegfx::fTools::equalZero(aPolyRange.getWidth()) ? 1.0 : aPolyRange.getWidth()));
575 const double fScaleY(fabs(aScale.getY()) / (basegfx::fTools::equalZero(aPolyRange.getHeight()) ? 1.0 : aPolyRange.getHeight()));
576
577 // prepare transform matrix for polygon
578 basegfx::B2DHomMatrix aPolyTransform;
579
580 aPolyTransform.translate(-aPolyRange.getMinX(), -aPolyRange.getMinY());
581 aPolyTransform.scale(fScaleX, fScaleY);
582
583 // normally the poly should be moved back, but the translation is in the object
584 // transformation and thus does not need to be done
585 // aPolyTransform.translate(-aPolyRange.getMinX(), -aPolyRange.getMinY());
586
587 // transform the polygon
588 aObjectPolyPolygon.transform(aPolyTransform);
589 }
590
591 rTarget.TRSetBaseGeometry(getCurrentTransformation() * aObjectTransform, aObjectPolyPolygon);
592 }
593
594 void SdrDragMethod::applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget)
595 {
596 // original uses CurrentTransformation
597 rTarget.transform(getCurrentTransformation());
598 }
599
600 SdrDragMethod::SdrDragMethod(SdrDragView& rNewView)
601 : maSdrDragEntries(),
602 maOverlayObjectList(),
603 mrSdrDragView(rNewView),
604 mbMoveOnly(false),
605 mbSolidDraggingActive(getSdrDragView().IsSolidDragging())
606 {
607 if(mbSolidDraggingActive && Application::GetSettings().GetStyleSettings().GetHighContrastMode())
608 {
609 // fallback to wireframe when high contrast is used
610 mbSolidDraggingActive = false;
611 }
612 }
613
614 SdrDragMethod::~SdrDragMethod()
615 {
616 clearSdrDragEntries();
617 }
618
619 void SdrDragMethod::Show()
620 {
621 getSdrDragView().ShowDragObj();
622 }
623
624 void SdrDragMethod::Hide()
625 {
626 getSdrDragView().HideDragObj();
627 }
628
629 basegfx::B2DHomMatrix SdrDragMethod::getCurrentTransformation()
630 {
631 return basegfx::B2DHomMatrix();
632 }
633
634 void SdrDragMethod::CancelSdrDrag()
635 {
636 Hide();
637 }
638
639 void SdrDragMethod::CreateOverlayGeometry(sdr::overlay::OverlayManager& rOverlayManager)
640 {
641 // create SdrDragEntries on demand
642 if(!maSdrDragEntries.size())
643 {
644 createSdrDragEntries();
645 }
646
647 // if there are entries, derive OverlayObjects fromthe entries, including
648 // modification from current interactive state
649 if(maSdrDragEntries.size())
650 {
651 drawinglayer::primitive2d::Primitive2DSequence aResult;
652 drawinglayer::primitive2d::Primitive2DSequence aResultTransparent;
653
654 for(sal_uInt32 a(0); a < maSdrDragEntries.size(); a++)
655 {
656 SdrDragEntry* pCandidate = maSdrDragEntries[a];
657
658 if(pCandidate)
659 {
660 const drawinglayer::primitive2d::Primitive2DSequence aCandidateResult(pCandidate->createPrimitive2DSequenceInCurrentState(*this));
661
662 if(aCandidateResult.hasElements())
663 {
664 if(pCandidate->getAddToTransparent())
665 {
666 drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(aResultTransparent, aCandidateResult);
667 }
668 else
669 {
670 drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(aResult, aCandidateResult);
671 }
672 }
673 }
674 }
675
676 if(DoAddConnectorOverlays())
677 {
678 const drawinglayer::primitive2d::Primitive2DSequence aConnectorOverlays(AddConnectorOverlays());
679
680 if(aConnectorOverlays.hasElements())
681 {
682 // add connector overlays to transparent part
683 drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(aResultTransparent, aConnectorOverlays);
684 }
685 }
686
687 if(aResult.hasElements())
688 {
689 sdr::overlay::OverlayObject* pNewOverlayObject = new sdr::overlay::OverlayPrimitive2DSequenceObject(aResult);
690 rOverlayManager.add(*pNewOverlayObject);
691 addToOverlayObjectList(*pNewOverlayObject);
692 }
693
694 if(aResultTransparent.hasElements())
695 {
696 drawinglayer::primitive2d::Primitive2DReference aUnifiedAlphaPrimitive2D(new drawinglayer::primitive2d::UnifiedAlphaPrimitive2D(aResultTransparent, 0.5));
697 aResultTransparent = drawinglayer::primitive2d::Primitive2DSequence(&aUnifiedAlphaPrimitive2D, 1);
698
699 sdr::overlay::OverlayObject* pNewOverlayObject = new sdr::overlay::OverlayPrimitive2DSequenceObject(aResultTransparent);
700 rOverlayManager.add(*pNewOverlayObject);
701 addToOverlayObjectList(*pNewOverlayObject);
702 }
703 }
704
705 // evtl add DragStripes (help lines cross the page when dragging)
706 if(getSdrDragView().IsDragStripes())
707 {
708 Rectangle aActionRectangle;
709 getSdrDragView().TakeActionRect(aActionRectangle);
710
711 const basegfx::B2DPoint aTopLeft(aActionRectangle.Left(), aActionRectangle.Top());
712 const basegfx::B2DPoint aBottomRight(aActionRectangle.Right(), aActionRectangle.Bottom());
713 sdr::overlay::OverlayRollingRectangleStriped* pNew = new sdr::overlay::OverlayRollingRectangleStriped(
714 aTopLeft, aBottomRight, true, false);
715
716 rOverlayManager.add(*pNew);
717 addToOverlayObjectList(*pNew);
718 }
719 }
720
721 void SdrDragMethod::destroyOverlayGeometry()
722 {
723 clearOverlayObjectList();
724 }
725
726 bool SdrDragMethod::DoAddConnectorOverlays()
727 {
728 // these conditions are translated from SdrDragView::ImpDrawEdgeXor
729 const SdrMarkList& rMarkedNodes = getSdrDragView().GetEdgesOfMarkedNodes();
730
731 if(!rMarkedNodes.GetMarkCount())
732 {
733 return false;
734 }
735
736 if(!getSdrDragView().IsRubberEdgeDragging() && !getSdrDragView().IsDetailedEdgeDragging())
737 {
738 return false;
739 }
740
741 if(getSdrDragView().IsDraggingPoints() || getSdrDragView().IsDraggingGluePoints())
742 {
743 return false;
744 }
745
746 if(!getMoveOnly() && !(
747 IS_TYPE(SdrDragMove, this) || IS_TYPE(SdrDragResize, this) ||
748 IS_TYPE(SdrDragRotate,this) || IS_TYPE(SdrDragMirror,this)))
749 {
750 return false;
751 }
752
753 const bool bDetail(getSdrDragView().IsDetailedEdgeDragging() && getMoveOnly());
754
755 if(!bDetail && !getSdrDragView().IsRubberEdgeDragging())
756 {
757 return false;
758 }
759
760 // one more migrated from SdrEdgeObj::NspToggleEdgeXor
761 if(IS_TYPE(SdrDragObjOwn, this) || IS_TYPE(SdrDragMovHdl, this))
762 {
763 return false;
764 }
765
766 return true;
767 }
768
769 drawinglayer::primitive2d::Primitive2DSequence SdrDragMethod::AddConnectorOverlays()
770 {
771 drawinglayer::primitive2d::Primitive2DSequence aRetval;
772 const bool bDetail(getSdrDragView().IsDetailedEdgeDragging() && getMoveOnly());
773 const SdrMarkList& rMarkedNodes = getSdrDragView().GetEdgesOfMarkedNodes();
774
775 for(sal_uInt16 a(0); a < rMarkedNodes.GetMarkCount(); a++)
776 {
777 SdrMark* pEM = rMarkedNodes.GetMark(a);
778
779 if(pEM && pEM->GetMarkedSdrObj())
780 {
781 SdrEdgeObj* pEdge = dynamic_cast< SdrEdgeObj* >(pEM->GetMarkedSdrObj());
782
783 if(pEdge)
784 {
785 const basegfx::B2DPolygon aEdgePolygon(pEdge->ImplAddConnectorOverlay(*this, pEM->IsCon1(), pEM->IsCon2(), bDetail));
786
787 if(aEdgePolygon.count())
788 {
789 // this polygon is a temporary calculated connector path, so it is not possible to fetch
790 // the needed primitives directly from the pEdge object which does not get changed. If full
791 // drag is on, use the SdrObjects ItemSet to create a adequate representation
792 if(getSolidDraggingActive())
793 {
794 const SfxItemSet& rItemSet = pEdge->GetMergedItemSet();
795 drawinglayer::attribute::SdrLineAttribute* pLine = drawinglayer::primitive2d::createNewSdrLineAttribute(rItemSet);
796 drawinglayer::attribute::SdrLineStartEndAttribute* pLineStartEnd = 0;
797
798 if(pLine && !pLine->isVisible())
799 {
800 delete pLine;
801 pLine = 0;
802 }
803
804 if(pLine)
805 {
806 pLineStartEnd = drawinglayer::primitive2d::createNewSdrLineStartEndAttribute(rItemSet, pLine->getWidth());
807
808 if(pLineStartEnd && !pLineStartEnd->isVisible())
809 {
810 delete pLineStartEnd;
811 pLineStartEnd = 0;
812 }
813
814 drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
815 aRetval, drawinglayer::primitive2d::createPolygonLinePrimitive(
816 aEdgePolygon, basegfx::B2DHomMatrix(), *pLine, pLineStartEnd));
817
818 if(pLineStartEnd)
819 {
820 delete pLineStartEnd;
821 }
822
823 delete pLine;
824 }
825 }
826 else
827 {
828 const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
829 basegfx::BColor aColA(aSvtOptionsDrawinglayer.GetStripeColorA().getBColor());
830 basegfx::BColor aColB(aSvtOptionsDrawinglayer.GetStripeColorB().getBColor());
831 const double fStripeLength(aSvtOptionsDrawinglayer.GetStripeLength());
832
833 if(Application::GetSettings().GetStyleSettings().GetHighContrastMode())
834 {
835 aColA = aColB = Application::GetSettings().GetStyleSettings().GetHighlightColor().getBColor();
836 aColB.invert();
837 }
838
839 drawinglayer::primitive2d::Primitive2DReference aPolyPolygonMarkerPrimitive2D(
840 new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(
841 basegfx::B2DPolyPolygon(aEdgePolygon), aColA, aColB, fStripeLength));
842 drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aPolyPolygonMarkerPrimitive2D);
843 }
844 }
845 }
846 }
847 }
848
849 return aRetval;
850 }
851
852 ////////////////////////////////////////////////////////////////////////////////////////////////////
853
854 TYPEINIT1(SdrDragMovHdl,SdrDragMethod);
855
856 SdrDragMovHdl::SdrDragMovHdl(SdrDragView& rNewView)
857 : SdrDragMethod(rNewView),
858 bMirrObjShown(false)
859 {
860 }
861
862 void SdrDragMovHdl::createSdrDragEntries()
863 {
864 // SdrDragMovHdl does not use the default drags,
865 // but creates nothing
866 }
867
868 void SdrDragMovHdl::TakeSdrDragComment(XubString& rStr) const
869 {
870 rStr=ImpGetResStr(STR_DragMethMovHdl);
871 if (getSdrDragView().IsDragWithCopy()) rStr+=ImpGetResStr(STR_EditWithCopy);
872 }
873
874 bool SdrDragMovHdl::BeginSdrDrag()
875 {
876 DragStat().Ref1()=GetDragHdl()->GetPos();
877 DragStat().SetShown(!DragStat().IsShown());
878 SdrHdlKind eKind=GetDragHdl()->GetKind();
879 SdrHdl* pH1=GetHdlList().GetHdl(HDL_REF1);
880 SdrHdl* pH2=GetHdlList().GetHdl(HDL_REF2);
881
882 if (eKind==HDL_MIRX)
883 {
884 if (pH1==NULL || pH2==NULL)
885 {
886 DBG_ERROR("SdrDragMovHdl::BeginSdrDrag(): Verschieben der Spiegelachse: Referenzhandles nicht gefunden");
887 return false;
888 }
889
890 DragStat().SetActionRect(Rectangle(pH1->GetPos(),pH2->GetPos()));
891 }
892 else
893 {
894 Point aPt(GetDragHdl()->GetPos());
895 DragStat().SetActionRect(Rectangle(aPt,aPt));
896 }
897
898 return true;
899 }
900
901 void SdrDragMovHdl::MoveSdrDrag(const Point& rNoSnapPnt)
902 {
903 Point aPnt(rNoSnapPnt);
904
905 if (DragStat().CheckMinMoved(rNoSnapPnt))
906 {
907 if (GetDragHdl()->GetKind()==HDL_MIRX)
908 {
909 SdrHdl* pH1=GetHdlList().GetHdl(HDL_REF1);
910 SdrHdl* pH2=GetHdlList().GetHdl(HDL_REF2);
911
912 if (pH1==NULL || pH2==NULL)
913 return;
914
915 if (!DragStat().IsNoSnap())
916 {
917 long nBestXSnap=0;
918 long nBestYSnap=0;
919 bool bXSnapped=false;
920 bool bYSnapped=false;
921 Point aDif(aPnt-DragStat().GetStart());
922 getSdrDragView().CheckSnap(Ref1()+aDif,NULL,nBestXSnap,nBestYSnap,bXSnapped,bYSnapped);
923 getSdrDragView().CheckSnap(Ref2()+aDif,NULL,nBestXSnap,nBestYSnap,bXSnapped,bYSnapped);
924 aPnt.X()+=nBestXSnap;
925 aPnt.Y()+=nBestYSnap;
926 }
927
928 if (aPnt!=DragStat().GetNow())
929 {
930 Hide();
931 DragStat().NextMove(aPnt);
932 Point aDif(DragStat().GetNow()-DragStat().GetStart());
933 pH1->SetPos(Ref1()+aDif);
934 pH2->SetPos(Ref2()+aDif);
935
936 SdrHdl* pHM = GetHdlList().GetHdl(HDL_MIRX);
937
938 if(pHM)
939 pHM->Touch();
940
941 Show();
942 DragStat().SetActionRect(Rectangle(pH1->GetPos(),pH2->GetPos()));
943 }
944 }
945 else
946 {
947 if (!DragStat().IsNoSnap()) SnapPos(aPnt);
948 long nSA=0;
949
950 if (getSdrDragView().IsAngleSnapEnabled())
951 nSA=getSdrDragView().GetSnapAngle();
952
953 if (getSdrDragView().IsMirrorAllowed(true,true))
954 { // eingeschraenkt
955 if (!getSdrDragView().IsMirrorAllowed(false,false)) nSA=4500;
956 if (!getSdrDragView().IsMirrorAllowed(true,false)) nSA=9000;
957 }
958
959 if (getSdrDragView().IsOrtho() && nSA!=9000)
960 nSA=4500;
961
962 if (nSA!=0)
963 { // Winkelfang
964 SdrHdlKind eRef=HDL_REF1;
965
966 if (GetDragHdl()->GetKind()==HDL_REF1)
967 eRef=HDL_REF2;
968
969 SdrHdl* pH=GetHdlList().GetHdl(eRef);
970
971 if (pH!=NULL)
972 {
973 Point aRef(pH->GetPos());
974 long nWink=NormAngle360(GetAngle(aPnt-aRef));
975 long nNeuWink=nWink;
976 nNeuWink+=nSA/2;
977 nNeuWink/=nSA;
978 nNeuWink*=nSA;
979 nNeuWink=NormAngle360(nNeuWink);
980 double a=(nNeuWink-nWink)*nPi180;
981 double nSin=sin(a);
982 double nCos=cos(a);
983 RotatePoint(aPnt,aRef,nSin,nCos);
984
985 // Bei bestimmten Werten Rundungsfehler ausschliessen:
986 if (nSA==9000)
987 {
988 if (nNeuWink==0 || nNeuWink==18000) aPnt.Y()=aRef.Y();
989 if (nNeuWink==9000 || nNeuWink==27000) aPnt.X()=aRef.X();
990 }
991
992 if (nSA==4500)
993 OrthoDistance8(aRef,aPnt,true);
994 }
995 }
996
997 if (aPnt!=DragStat().GetNow())
998 {
999 Hide();
1000 DragStat().NextMove(aPnt);
1001 GetDragHdl()->SetPos(DragStat().GetNow());
1002 SdrHdl* pHM = GetHdlList().GetHdl(HDL_MIRX);
1003
1004 if(pHM)
1005 pHM->Touch();
1006
1007 Show();
1008 DragStat().SetActionRect(Rectangle(aPnt,aPnt));
1009 }
1010 }
1011 }
1012 }
1013
1014 bool SdrDragMovHdl::EndSdrDrag(bool /*bCopy*/)
1015 {
1016 switch (GetDragHdl()->GetKind())
1017 {
1018 case HDL_REF1:
1019 Ref1()=DragStat().GetNow();
1020 break;
1021
1022 case HDL_REF2:
1023 Ref2()=DragStat().GetNow();
1024 break;
1025
1026 case HDL_MIRX:
1027 Ref1()+=DragStat().GetNow()-DragStat().GetStart();
1028 Ref2()+=DragStat().GetNow()-DragStat().GetStart();
1029 break;
1030
1031 default: break;
1032 }
1033
1034 return true;
1035 }
1036
1037 void SdrDragMovHdl::CancelSdrDrag()
1038 {
1039 Hide();
1040 GetDragHdl()->SetPos(DragStat().GetRef1());
1041 SdrHdl* pHM = GetHdlList().GetHdl(HDL_MIRX);
1042
1043 if(pHM)
1044 pHM->Touch();
1045 }
1046
1047 Pointer SdrDragMovHdl::GetSdrDragPointer() const
1048 {
1049 const SdrHdl* pHdl = GetDragHdl();
1050
1051 if (pHdl!=NULL)
1052 {
1053 return pHdl->GetPointer();
1054 }
1055
1056 return Pointer(POINTER_REFHAND);
1057 }
1058
1059 ////////////////////////////////////////////////////////////////////////////////////////////////////
1060
1061 TYPEINIT1(SdrDragObjOwn,SdrDragMethod);
1062
1063 SdrDragObjOwn::SdrDragObjOwn(SdrDragView& rNewView)
1064 : SdrDragMethod(rNewView),
1065 mpClone(0)
1066 {
1067 const SdrObject* pObj = GetDragObj();
1068
1069 if(pObj)
1070 {
1071 // suppress full drag for some object types
1072 setSolidDraggingActive(pObj->supportsFullDrag());
1073 }
1074 }
1075
1076 SdrDragObjOwn::~SdrDragObjOwn()
1077 {
1078 if(mpClone)
1079 {
1080 SdrObject::Free(mpClone);
1081 }
1082 }
1083
1084 void SdrDragObjOwn::createSdrDragEntries()
1085 {
1086 if(mpClone)
1087 {
1088 basegfx::B2DPolyPolygon aDragPolyPolygon;
1089 bool bAddWireframe(true);
1090
1091 if(getSolidDraggingActive())
1092 {
1093 SdrPageView* pPV = getSdrDragView().GetSdrPageView();
1094
1095 if(pPV && pPV->PageWindowCount())
1096 {
1097 sdr::contact::ObjectContact& rOC = pPV->GetPageWindow(0)->GetObjectContact();
1098 addSdrDragEntry(new SdrDragEntrySdrObject(*mpClone, rOC, false));
1099
1100 // potentially no wireframe needed, full drag works
1101 bAddWireframe = false;
1102 }
1103 }
1104
1105 if(!bAddWireframe)
1106 {
1107 // check for extra conditions for wireframe, e.g. no border at
1108 // objects
1109 if(!mpClone->HasLineStyle())
1110 {
1111 bAddWireframe = true;
1112 }
1113 }
1114
1115 if(bAddWireframe)
1116 {
1117 // use wireframe poly when full drag is off or did not work
1118 aDragPolyPolygon = mpClone->TakeXorPoly();
1119 }
1120
1121 // add evtl. extra DragPolyPolygon
1122 const basegfx::B2DPolyPolygon aSpecialDragPolyPolygon(mpClone->getSpecialDragPoly(DragStat()));
1123
1124 if(aSpecialDragPolyPolygon.count())
1125 {
1126 aDragPolyPolygon.append(aSpecialDragPolyPolygon);
1127 }
1128
1129 if(aDragPolyPolygon.count())
1130 {
1131 addSdrDragEntry(new SdrDragEntryPolyPolygon(aDragPolyPolygon));
1132 }
1133 }
1134 }
1135
1136 void SdrDragObjOwn::TakeSdrDragComment(XubString& rStr) const
1137 {
1138 const SdrObject* pObj = GetDragObj();
1139
1140 if(pObj)
1141 {
1142 rStr = pObj->getSpecialDragComment(DragStat());
1143 }
1144 }
1145
1146 bool SdrDragObjOwn::BeginSdrDrag()
1147 {
1148 if(!mpClone)
1149 {
1150 const SdrObject* pObj = GetDragObj();
1151
1152 if(pObj && !pObj->IsResizeProtect())
1153 {
1154 if(pObj->beginSpecialDrag(DragStat()))
1155 {
1156 // create nitial clone to have a start visualisation
1157 mpClone = pObj->getFullDragClone();
1158 mpClone->applySpecialDrag(DragStat());
1159
1160 return true;
1161 }
1162 }
1163 }
1164
1165 return false;
1166 }
1167
1168 void SdrDragObjOwn::MoveSdrDrag(const Point& rNoSnapPnt)
1169 {
1170 const SdrObject* pObj = GetDragObj();
1171
1172 if(pObj)
1173 {
1174 Point aPnt(rNoSnapPnt);
1175 SdrPageView* pPV = GetDragPV();
1176
1177 if(pPV)
1178 {
1179 if(!DragStat().IsNoSnap())
1180 {
1181 SnapPos(aPnt);
1182 }
1183
1184 if(getSdrDragView().IsOrtho())
1185 {
1186 if (DragStat().IsOrtho8Possible())
1187 {
1188 OrthoDistance8(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho());
1189 }
1190 else if (DragStat().IsOrtho4Possible())
1191 {
1192 OrthoDistance4(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho());
1193 }
1194 }
1195
1196 if(DragStat().CheckMinMoved(rNoSnapPnt))
1197 {
1198 if(aPnt != DragStat().GetNow())
1199 {
1200 Hide();
1201 DragStat().NextMove(aPnt);
1202
1203 // since SdrDragObjOwn currently supports no transformation of
1204 // existing SdrDragEntries but only their recreation, a recreation
1205 // after every move is needed in this mode. Delete existing
1206 // SdrDragEntries here to force their recreation in the following Show().
1207 clearSdrDragEntries();
1208
1209 // delete current clone (after the last reference to it is deleted above)
1210 if(mpClone)
1211 {
1212 SdrObject::Free(mpClone);
1213 mpClone = 0;
1214 }
1215
1216 // create a new clone and modify to current drag state
1217 if(!mpClone)
1218 {
1219 mpClone = pObj->getFullDragClone();
1220 mpClone->applySpecialDrag(DragStat());
1221 }
1222
1223 Show();
1224 }
1225 }
1226 }
1227 }
1228 }
1229
1230 bool SdrDragObjOwn::EndSdrDrag(bool /*bCopy*/)
1231 {
1232 Hide();
1233 SdrUndoAction* pUndo = NULL;
1234 SdrUndoAction* pUndo2 = NULL;
1235 std::vector< SdrUndoAction* > vConnectorUndoActions;
1236 bool bRet = false;
1237 SdrObject* pObj = GetDragObj();
1238
1239 if(pObj)
1240 {
1241 const bool bUndo = getSdrDragView().IsUndoEnabled();
1242
1243 if( bUndo )
1244 {
1245 if(!getSdrDragView().IsInsObjPoint() && pObj->IsInserted() )
1246 {
1247 if (DragStat().IsEndDragChangesAttributes())
1248 {
1249 pUndo=getSdrDragView().GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pObj);
1250
1251 if (DragStat().IsEndDragChangesGeoAndAttributes())
1252 {
1253 vConnectorUndoActions = getSdrDragView().CreateConnectorUndo( *pObj );
1254 pUndo2 = getSdrDragView().GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj);
1255 }
1256 }
1257 else
1258 {
1259 vConnectorUndoActions = getSdrDragView().CreateConnectorUndo( *pObj );
1260 pUndo= getSdrDragView().GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj);
1261 }
1262 }
1263
1264 if( pUndo )
1265 {
1266 getSdrDragView().BegUndo( pUndo->GetComment() );
1267 }
1268 else
1269 {
1270 getSdrDragView().BegUndo();
1271 }
1272 }
1273
1274 // evtl. use opertator= for setting changed object data (do not change selection in
1275 // view, this will destroy the interactor). This is possible since a clone is now
1276 // directly modified by the modifiers. Only SdrTableObj is adding own UNDOs
1277 // in it's SdrTableObj::endSpecialDrag, so currently not possible. OTOH it uses
1278 // a CreateUndoGeoObject() so maybe setting SetEndDragChangesAttributes is okay. I
1279 // will test this now
1280 Rectangle aBoundRect0;
1281
1282 if(pObj->GetUserCall())
1283 {
1284 aBoundRect0 = pObj->GetLastBoundRect();
1285 }
1286
1287 bRet = pObj->applySpecialDrag(DragStat());
1288
1289 if(bRet)
1290 {
1291 pObj->SetChanged();
1292 pObj->BroadcastObjectChange();
1293 pObj->SendUserCall( SDRUSERCALL_RESIZE, aBoundRect0 );
1294 }
1295
1296 if(bRet)
1297 {
1298 if( bUndo )
1299 {
1300 getSdrDragView().AddUndoActions( vConnectorUndoActions );
1301
1302 if ( pUndo )
1303 {
1304 getSdrDragView().AddUndo(pUndo);
1305 }
1306
1307 if ( pUndo2 )
1308 {
1309 getSdrDragView().AddUndo(pUndo2);
1310 }
1311 }
1312 }
1313 else
1314 {
1315 if( bUndo )
1316 {
1317 std::vector< SdrUndoAction* >::iterator vConnectorUndoIter( vConnectorUndoActions.begin() );
1318
1319 while( vConnectorUndoIter != vConnectorUndoActions.end() )
1320 {
1321 delete *vConnectorUndoIter++;
1322 }
1323
1324 delete pUndo;
1325 delete pUndo2;
1326 }
1327 }
1328
1329 if( bUndo )
1330 getSdrDragView().EndUndo();
1331 }
1332
1333 return bRet;
1334 }
1335
1336 Pointer SdrDragObjOwn::GetSdrDragPointer() const
1337 {
1338 const SdrHdl* pHdl=GetDragHdl();
1339
1340 if (pHdl)
1341 {
1342 return pHdl->GetPointer();
1343 }
1344
1345 return Pointer(POINTER_MOVE);
1346 }
1347
1348 ////////////////////////////////////////////////////////////////////////////////////////////////////
1349
1350 TYPEINIT1(SdrDragMove,SdrDragMethod);
1351
1352 void SdrDragMove::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
1353 {
1354 rTarget.Move(Size(DragStat().GetDX(), DragStat().GetDY()));
1355 }
1356
1357 SdrDragMove::SdrDragMove(SdrDragView& rNewView)
1358 : SdrDragMethod(rNewView)
1359 {
1360 setMoveOnly(true);
1361 }
1362
1363 void SdrDragMove::TakeSdrDragComment(XubString& rStr) const
1364 {
1365 XubString aStr;
1366
1367 ImpTakeDescriptionStr(STR_DragMethMove, rStr);
1368 rStr.AppendAscii(" (x=");
1369 getSdrDragView().GetModel()->TakeMetricStr(DragStat().GetDX(), aStr);
1370 rStr += aStr;
1371 rStr.AppendAscii(" y=");
1372 getSdrDragView().GetModel()->TakeMetricStr(DragStat().GetDY(), aStr);
1373 rStr += aStr;
1374 rStr += sal_Unicode(')');
1375
1376 if(getSdrDragView().IsDragWithCopy())
1377 {
1378 if(!getSdrDragView().IsInsObjPoint() && !getSdrDragView().IsInsGluePoint())
1379 {
1380 rStr += ImpGetResStr(STR_EditWithCopy);
1381 }
1382 }
1383 }
1384
1385 bool SdrDragMove::BeginSdrDrag()
1386 {
1387 DragStat().SetActionRect(GetMarkedRect());
1388 Show();
1389
1390 return true;
1391 }
1392
1393 basegfx::B2DHomMatrix SdrDragMove::getCurrentTransformation()
1394 {
1395 basegfx::B2DHomMatrix aRetval;
1396
1397 aRetval.translate(DragStat().GetDX(), DragStat().GetDY());
1398
1399 return aRetval;
1400 }
1401
1402 void SdrDragMove::ImpCheckSnap(const Point& rPt)
1403 {
1404 Point aPt(rPt);
1405 sal_uInt16 nRet=SnapPos(aPt);
1406 aPt-=rPt;
1407
1408 if ((nRet & SDRSNAP_XSNAPPED) !=0)
1409 {
1410 if (bXSnapped)
1411 {
1412 if (Abs(aPt.X())<Abs(nBestXSnap))
1413 {
1414 nBestXSnap=aPt.X();
1415 }
1416 }
1417 else
1418 {
1419 nBestXSnap=aPt.X();
1420 bXSnapped=true;
1421 }
1422 }
1423
1424 if ((nRet & SDRSNAP_YSNAPPED) !=0)
1425 {
1426 if (bYSnapped)
1427 {
1428 if (Abs(aPt.Y())<Abs(nBestYSnap))
1429 {
1430 nBestYSnap=aPt.Y();
1431 }
1432 }
1433 else
1434 {
1435 nBestYSnap=aPt.Y();
1436 bYSnapped=true;
1437 }
1438 }
1439 }
1440
1441 void SdrDragMove::MoveSdrDrag(const Point& rNoSnapPnt_)
1442 {
1443 nBestXSnap=0;
1444 nBestYSnap=0;
1445 bXSnapped=false;
1446 bYSnapped=false;
1447 Point aNoSnapPnt(rNoSnapPnt_);
1448 const Rectangle& aSR=GetMarkedRect();
1449 long nMovedx=aNoSnapPnt.X()-DragStat().GetStart().X();
1450 long nMovedy=aNoSnapPnt.Y()-DragStat().GetStart().Y();
1451 Point aLO(aSR.TopLeft()); aLO.X()+=nMovedx; aLO.Y()+=nMovedy;
1452 Point aRU(aSR.BottomRight()); aRU.X()+=nMovedx; aRU.Y()+=nMovedy;
1453 Point aLU(aLO.X(),aRU.Y());
1454 Point aRO(aRU.X(),aLO.Y());
1455 ImpCheckSnap(aLO);
1456
1457 if (!getSdrDragView().IsMoveSnapOnlyTopLeft())
1458 {
1459 ImpCheckSnap(aRO);
1460 ImpCheckSnap(aLU);
1461 ImpCheckSnap(aRU);
1462 }
1463
1464 Point aPnt(aNoSnapPnt.X()+nBestXSnap,aNoSnapPnt.Y()+nBestYSnap);
1465 bool bOrtho=getSdrDragView().IsOrtho();
1466
1467 if (bOrtho)
1468 OrthoDistance8(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho());
1469
1470 if (DragStat().CheckMinMoved(aNoSnapPnt))
1471 {
1472 Point aPt1(aPnt);
1473 Rectangle aLR(getSdrDragView().GetWorkArea());
1474 bool bWorkArea=!aLR.IsEmpty();
1475 bool bDragLimit=IsDragLimit();
1476
1477 if (bDragLimit || bWorkArea)
1478 {
1479 Rectangle aSR2(GetMarkedRect());
1480 Point aD(aPt1-DragStat().GetStart());
1481
1482 if (bDragLimit)
1483 {
1484 Rectangle aR2(GetDragLimitRect());
1485
1486 if (bWorkArea)
1487 aLR.Intersection(aR2);
1488 else
1489 aLR=aR2;
1490 }
1491
1492 if (aSR2.Left()>aLR.Left() || aSR2.Right()<aLR.Right())
1493 { // ist ueberhaupt Platz zum verschieben?
1494 aSR2.Move(aD.X(),0);
1495
1496 if (aSR2.Left()<aLR.Left())
1497 {
1498 aPt1.X()-=aSR2.Left()-aLR.Left();
1499 }
1500 else if (aSR2.Right()>aLR.Right())
1501 {
1502 aPt1.X()-=aSR2.Right()-aLR.Right();
1503 }
1504 }
1505 else
1506 aPt1.X()=DragStat().GetStart().X(); // kein Platz zum verschieben
1507
1508 if (aSR2.Top()>aLR.Top() || aSR2.Bottom()<aLR.Bottom())
1509 { // ist ueberhaupt Platz zum verschieben?
1510 aSR2.Move(0,aD.Y());
1511
1512 if (aSR2.Top()<aLR.Top())
1513 {
1514 aPt1.Y()-=aSR2.Top()-aLR.Top();
1515 }
1516 else if (aSR2.Bottom()>aLR.Bottom())
1517 {
1518 aPt1.Y()-=aSR2.Bottom()-aLR.Bottom();
1519 }
1520 }
1521 else
1522 aPt1.Y()=DragStat().GetStart().Y(); // kein Platz zum verschieben
1523 }
1524
1525 if (getSdrDragView().IsDraggingGluePoints())
1526 { // Klebepunkte aufs BoundRect des Obj limitieren
1527 aPt1-=DragStat().GetStart();
1528 const SdrMarkList& rML=GetMarkedObjectList();
1529 ULONG nMarkAnz=rML.GetMarkCount();
1530
1531 for (ULONG nMarkNum=0; nMarkNum<nMarkAnz; nMarkNum++)
1532 {
1533 const SdrMark* pM=rML.GetMark(nMarkNum);
1534 const SdrUShortCont* pPts=pM->GetMarkedGluePoints();
1535 ULONG nPtAnz=pPts==NULL ? 0 : pPts->GetCount();
1536
1537 if (nPtAnz!=0)
1538 {
1539 const SdrObject* pObj=pM->GetMarkedSdrObj();
1540 const SdrGluePointList* pGPL=pObj->GetGluePointList();
1541 Rectangle aBound(pObj->GetCurrentBoundRect());
1542
1543 for (ULONG nPtNum=0; nPtNum<nPtAnz; nPtNum++)
1544 {
1545 sal_uInt16 nId=pPts->GetObject(nPtNum);
1546 sal_uInt16 nGlueNum=pGPL->FindGluePoint(nId);
1547
1548 if (nGlueNum!=SDRGLUEPOINT_NOTFOUND)
1549 {
1550 Point aPt((*pGPL)[nGlueNum].GetAbsolutePos(*pObj));
1551 aPt+=aPt1; // soviel soll verschoben werden
1552 if (aPt.X()<aBound.Left() ) aPt1.X()-=aPt.X()-aBound.Left() ;
1553 if (aPt.X()>aBound.Right() ) aPt1.X()-=aPt.X()-aBound.Right() ;
1554 if (aPt.Y()<aBound.Top() ) aPt1.Y()-=aPt.Y()-aBound.Top() ;
1555 if (aPt.Y()>aBound.Bottom()) aPt1.Y()-=aPt.Y()-aBound.Bottom();
1556 }
1557 }
1558 }
1559 }
1560
1561 aPt1+=DragStat().GetStart();
1562 }
1563
1564 if (bOrtho)
1565 OrthoDistance8(DragStat().GetStart(),aPt1,false);
1566
1567 if (aPt1!=DragStat().GetNow())
1568 {
1569 Hide();
1570 DragStat().NextMove(aPt1);
1571 Rectangle aAction(GetMarkedRect());
1572 aAction.Move(DragStat().GetDX(),DragStat().GetDY());
1573 DragStat().SetActionRect(aAction);
1574 Show();
1575 }
1576 }
1577 }
1578
1579 bool SdrDragMove::EndSdrDrag(bool bCopy)
1580 {
1581 Hide();
1582
1583 if (getSdrDragView().IsInsObjPoint() || getSdrDragView().IsInsGluePoint())
1584 bCopy=false;
1585
1586 if (IsDraggingPoints())
1587 {
1588 getSdrDragView().MoveMarkedPoints(Size(DragStat().GetDX(),DragStat().GetDY()),bCopy);
1589 }
1590 else if (IsDraggingGluePoints())
1591 {
1592 getSdrDragView().MoveMarkedGluePoints(Size(DragStat().GetDX(),DragStat().GetDY()),bCopy);
1593 }
1594 else
1595 {
1596 getSdrDragView().MoveMarkedObj(Size(DragStat().GetDX(),DragStat().GetDY()),bCopy);
1597 }
1598
1599 return true;
1600 }
1601
1602 Pointer SdrDragMove::GetSdrDragPointer() const
1603 {
1604 if (IsDraggingPoints() || IsDraggingGluePoints())
1605 {
1606 return Pointer(POINTER_MOVEPOINT);
1607 }
1608 else
1609 {
1610 return Pointer(POINTER_MOVE);
1611 }
1612 }
1613
1614 ////////////////////////////////////////////////////////////////////////////////////////////////////
1615
1616 TYPEINIT1(SdrDragResize,SdrDragMethod);
1617
1618 SdrDragResize::SdrDragResize(SdrDragView& rNewView)
1619 : SdrDragMethod(rNewView),
1620 aXFact(1,1),
1621 aYFact(1,1)
1622 {
1623 }
1624
1625 void SdrDragResize::TakeSdrDragComment(XubString& rStr) const
1626 {
1627 ImpTakeDescriptionStr(STR_DragMethResize, rStr);
1628 bool bEqual(aXFact == aYFact);
1629 Fraction aFact1(1,1);
1630 Point aStart(DragStat().GetStart());
1631 Point aRef(DragStat().GetRef1());
1632 INT32 nXDiv(aStart.X() - aRef.X());
1633
1634 if(!nXDiv)
1635 nXDiv = 1;
1636
1637 INT32 nYDiv(aStart.Y() - aRef.Y());
1638
1639 if(!nYDiv)
1640 nYDiv = 1;
1641
1642 bool bX(aXFact != aFact1 && Abs(nXDiv) > 1);
1643 bool bY(aYFact != aFact1 && Abs(nYDiv) > 1);
1644
1645 if(bX || bY)
1646 {
1647 XubString aStr;
1648
1649 rStr.AppendAscii(" (");
1650
1651 if(bX)
1652 {
1653 if(!bEqual)
1654 rStr.AppendAscii("x=");
1655
1656 getSdrDragView().GetModel()->TakePercentStr(aXFact, aStr);
1657 rStr += aStr;
1658 }
1659
1660 if(bY && !bEqual)
1661 {
1662 if(bX)
1663 rStr += sal_Unicode(' ');
1664
1665 rStr.AppendAscii("y=");
1666 getSdrDragView().GetModel()->TakePercentStr(aYFact, aStr);
1667 rStr += aStr;
1668 }
1669
1670 rStr += sal_Unicode(')');
1671 }
1672
1673 if(getSdrDragView().IsDragWithCopy())
1674 rStr += ImpGetResStr(STR_EditWithCopy);
1675 }
1676
1677 bool SdrDragResize::BeginSdrDrag()
1678 {
1679 SdrHdlKind eRefHdl=HDL_MOVE;
1680 SdrHdl* pRefHdl=NULL;
1681
1682 switch (GetDragHdlKind())
1683 {
1684 case HDL_UPLFT: eRefHdl=HDL_LWRGT; break;
1685 case HDL_UPPER: eRefHdl=HDL_LOWER; DragStat().SetHorFixed(true); break;
1686 case HDL_UPRGT: eRefHdl=HDL_LWLFT; break;
1687 case HDL_LEFT : eRefHdl=HDL_RIGHT; DragStat().SetVerFixed(true); break;
1688 case HDL_RIGHT: eRefHdl=HDL_LEFT ; DragStat().SetVerFixed(true); break;
1689 case HDL_LWLFT: eRefHdl=HDL_UPRGT; break;
1690 case HDL_LOWER: eRefHdl=HDL_UPPER; DragStat().SetHorFixed(true); break;
1691 case HDL_LWRGT: eRefHdl=HDL_UPLFT; break;
1692 default: break;
1693 }
1694
1695 if (eRefHdl!=HDL_MOVE)
1696 pRefHdl=GetHdlList().GetHdl(eRefHdl);
1697
1698 if (pRefHdl!=NULL && !getSdrDragView().IsResizeAtCenter())
1699 {
1700 DragStat().Ref1()=pRefHdl->GetPos();
1701 }
1702 else
1703 {
1704 SdrHdl* pRef1=GetHdlList().GetHdl(HDL_UPLFT);
1705 SdrHdl* pRef2=GetHdlList().GetHdl(HDL_LWRGT);
1706
1707 if (pRef1!=NULL && pRef2!=NULL)
1708 {
1709 DragStat().Ref1()=Rectangle(pRef1->GetPos(),pRef2->GetPos()).Center();
1710 }
1711 else
1712 {
1713 DragStat().Ref1()=GetMarkedRect().Center();
1714 }
1715 }
1716
1717 Show();
1718
1719 return true;
1720 }
1721
1722 basegfx::B2DHomMatrix SdrDragResize::getCurrentTransformation()
1723 {
1724 basegfx::B2DHomMatrix aRetval;
1725
1726 aRetval.translate(-DragStat().Ref1().X(), -DragStat().Ref1().Y());
1727 aRetval.scale(aXFact, aYFact);
1728 aRetval.translate(DragStat().Ref1().X(), DragStat().Ref1().Y());
1729
1730 return aRetval;
1731 }
1732
1733 void SdrDragResize::MoveSdrDrag(const Point& rNoSnapPnt)
1734 {
1735 Point aPnt(GetSnapPos(rNoSnapPnt));
1736 Point aStart(DragStat().GetStart());
1737 Point aRef(DragStat().GetRef1());
1738 Fraction aMaxFact(0x7FFFFFFF,1);
1739 Rectangle aLR(getSdrDragView().GetWorkArea());
1740 bool bWorkArea=!aLR.IsEmpty();
1741 bool bDragLimit=IsDragLimit();
1742
1743 if (bDragLimit || bWorkArea)
1744 {
1745 Rectangle aSR(GetMarkedRect());
1746
1747 if (bDragLimit)
1748 {
1749 Rectangle aR2(GetDragLimitRect());
1750
1751 if (bWorkArea)
1752 aLR.Intersection(aR2);
1753 else
1754 aLR=aR2;
1755 }
1756
1757 if (aPnt.X()<aLR.Left())
1758 aPnt.X()=aLR.Left();
1759 else if (aPnt.X()>aLR.Right())
1760 aPnt.X()=aLR.Right();
1761
1762 if (aPnt.Y()<aLR.Top())
1763 aPnt.Y()=aLR.Top();
1764 else if (aPnt.Y()>aLR.Bottom())
1765 aPnt.Y()=aLR.Bottom();
1766
1767 if (aRef.X()>aSR.Left())
1768 {
1769 Fraction aMax(aRef.X()-aLR.Left(),aRef.X()-aSR.Left());
1770
1771 if (aMax<aMaxFact)
1772 aMaxFact=aMax;
1773 }
1774
1775 if (aRef.X()<aSR.Right())
1776 {
1777 Fraction aMax(aLR.Right()-aRef.X(),aSR.Right()-aRef.X());
1778
1779 if (aMax<aMaxFact)
1780 aMaxFact=aMax;
1781 }
1782
1783 if (aRef.Y()>aSR.Top())
1784 {
1785 Fraction aMax(aRef.Y()-aLR.Top(),aRef.Y()-aSR.Top());
1786
1787 if (aMax<aMaxFact)
1788 aMaxFact=aMax;
1789 }
1790
1791 if (aRef.Y()<aSR.Bottom())
1792 {
1793 Fraction aMax(aLR.Bottom()-aRef.Y(),aSR.Bottom()-aRef.Y());
1794
1795 if (aMax<aMaxFact)
1796 aMaxFact=aMax;
1797 }
1798 }
1799
1800 long nXDiv=aStart.X()-aRef.X(); if (nXDiv==0) nXDiv=1;
1801 long nYDiv=aStart.Y()-aRef.Y(); if (nYDiv==0) nYDiv=1;
1802 long nXMul=aPnt.X()-aRef.X();
1803 long nYMul=aPnt.Y()-aRef.Y();
1804
1805 if (nXDiv<0)
1806 {
1807 nXDiv=-nXDiv;
1808 nXMul=-nXMul;
1809 }
1810
1811 if (nYDiv<0)
1812 {
1813 nYDiv=-nYDiv;
1814 nYMul=-nYMul;
1815 }
1816
1817 bool bXNeg=nXMul<0; if (bXNeg) nXMul=-nXMul;
1818 bool bYNeg=nYMul<0; if (bYNeg) nYMul=-nYMul;
1819 bool bOrtho=getSdrDragView().IsOrtho() || !getSdrDragView().IsResizeAllowed(false);
1820
1821 if (!DragStat().IsHorFixed() && !DragStat().IsVerFixed())
1822 {
1823 if (Abs(nXDiv)<=1 || Abs(nYDiv)<=1)
1824 bOrtho=false;
1825
1826 if (bOrtho)
1827 {
1828 if ((Fraction(nXMul,nXDiv)>Fraction(nYMul,nYDiv)) !=getSdrDragView().IsBigOrtho())
1829 {
1830 nXMul=nYMul;
1831 nXDiv=nYDiv;
1832 }
1833 else
1834 {
1835 nYMul=nXMul;
1836 nYDiv=nXDiv;
1837 }
1838 }
1839 }
1840 else
1841 {
1842 if (bOrtho)
1843 {
1844 if (DragStat().IsHorFixed())
1845 {
1846 bXNeg=false;
1847 nXMul=nYMul;
1848 nXDiv=nYDiv;
1849 }
1850
1851 if (DragStat().IsVerFixed())
1852 {
1853 bYNeg=false;
1854 nYMul=nXMul;
1855 nYDiv=nXDiv;
1856 }
1857 }
1858 else
1859 {
1860 if (DragStat().IsHorFixed())
1861 {
1862 bXNeg=false;
1863 nXMul=1;
1864 nXDiv=1;
1865 }
1866
1867 if (DragStat().IsVerFixed())
1868 {
1869 bYNeg=false;
1870 nYMul=1;
1871 nYDiv=1;
1872 }
1873 }
1874 }
1875
1876 Fraction aNeuXFact(nXMul,nXDiv);
1877 Fraction aNeuYFact(nYMul,nYDiv);
1878
1879 if (bOrtho)
1880 {
1881 if (aNeuXFact>aMaxFact)
1882 {
1883 aNeuXFact=aMaxFact;
1884 aNeuYFact=aMaxFact;
1885 }
1886
1887 if (aNeuYFact>aMaxFact)
1888 {
1889 aNeuXFact=aMaxFact;
1890 aNeuYFact=aMaxFact;
1891 }
1892 }
1893
1894 if (bXNeg)
1895 aNeuXFact=Fraction(-aNeuXFact.GetNumerator(),aNeuXFact.GetDenominator());
1896
1897 if (bYNeg)
1898 aNeuYFact=Fraction(-aNeuYFact.GetNumerator(),aNeuYFact.GetDenominator());
1899
1900 if (DragStat().CheckMinMoved(aPnt))
1901 {
1902 if ((!DragStat().IsHorFixed() && aPnt.X()!=DragStat().GetNow().X()) ||
1903 (!DragStat().IsVerFixed() && aPnt.Y()!=DragStat().GetNow().Y()))
1904 {
1905 Hide();
1906 DragStat().NextMove(aPnt);
1907 aXFact=aNeuXFact;
1908 aYFact=aNeuYFact;
1909 Show();
1910 }
1911 }
1912 }
1913
1914 void SdrDragResize::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
1915 {
1916 rTarget.Resize(DragStat().Ref1(),aXFact,aYFact);
1917 }
1918
1919 bool SdrDragResize::EndSdrDrag(bool bCopy)
1920 {
1921 Hide();
1922
1923 if (IsDraggingPoints())
1924 {
1925 getSdrDragView().ResizeMarkedPoints(DragStat().Ref1(),aXFact,aYFact,bCopy);
1926 }
1927 else if (IsDraggingGluePoints())
1928 {
1929 getSdrDragView().ResizeMarkedGluePoints(DragStat().Ref1(),aXFact,aYFact,bCopy);
1930 }
1931 else
1932 {
1933 getSdrDragView().ResizeMarkedObj(DragStat().Ref1(),aXFact,aYFact,bCopy);
1934 }
1935
1936 return true;
1937 }
1938
1939 Pointer SdrDragResize::GetSdrDragPointer() const
1940 {
1941 const SdrHdl* pHdl=GetDragHdl();
1942
1943 if (pHdl!=NULL)
1944 {
1945 return pHdl->GetPointer();
1946 }
1947
1948 return Pointer(POINTER_MOVE);
1949 }
1950
1951 ////////////////////////////////////////////////////////////////////////////////////////////////////
1952
1953 TYPEINIT1(SdrDragRotate,SdrDragMethod);
1954
1955 void SdrDragRotate::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
1956 {
1957 rTarget.Rotate(DragStat().GetRef1(), nWink, sin(nWink*nPi180), cos(nWink*nPi180));
1958 }
1959
1960 SdrDragRotate::SdrDragRotate(SdrDragView& rNewView)
1961 : SdrDragMethod(rNewView),
1962 nSin(0.0),
1963 nCos(1.0),
1964 nWink0(0),
1965 nWink(0),
1966 bRight(false)
1967 {
1968 }
1969
1970 void SdrDragRotate::TakeSdrDragComment(XubString& rStr) const
1971 {
1972 ImpTakeDescriptionStr(STR_DragMethRotate, rStr);
1973 rStr.AppendAscii(" (");
1974 XubString aStr;
1975 INT32 nTmpWink(NormAngle360(nWink));
1976
1977 if(bRight && nWink)
1978 {
1979 nTmpWink -= 36000;
1980 }
1981
1982 getSdrDragView().GetModel()->TakeWinkStr(nTmpWink, aStr);
1983 rStr += aStr;
1984 rStr += sal_Unicode(')');
1985
1986 if(getSdrDragView().IsDragWithCopy())
1987 rStr += ImpGetResStr(STR_EditWithCopy);
1988 }
1989
1990 bool SdrDragRotate::BeginSdrDrag()
1991 {
1992 SdrHdl* pH=GetHdlList().GetHdl(HDL_REF1);
1993
1994 if (pH!=NULL)
1995 {
1996 Show();
1997 DragStat().Ref1()=pH->GetPos();
1998 nWink0=GetAngle(DragStat().GetStart()-DragStat().GetRef1());
1999 return true;
2000 }
2001 else
2002 {
2003 DBG_ERROR("SdrDragRotate::BeginSdrDrag(): Kein Referenzpunkt-Handle gefunden");
2004 return false;
2005 }
2006 }
2007
2008 basegfx::B2DHomMatrix SdrDragRotate::getCurrentTransformation()
2009 {
2010 basegfx::B2DHomMatrix aRetval;
2011
2012 aRetval.translate(-DragStat().GetRef1().X(), -DragStat().GetRef1().Y());
2013 aRetval.rotate(-atan2(nSin, nCos));
2014 aRetval.translate(DragStat().GetRef1().X(), DragStat().GetRef1().Y());
2015
2016 return aRetval;
2017 }
2018
2019 void SdrDragRotate::MoveSdrDrag(const Point& rPnt_)
2020 {
2021 Point aPnt(rPnt_);
2022 if (DragStat().CheckMinMoved(aPnt))
2023 {
2024 long nNeuWink=NormAngle360(GetAngle(aPnt-DragStat().GetRef1())-nWink0);
2025 long nSA=0;
2026
2027 if (getSdrDragView().IsAngleSnapEnabled())
2028 nSA=getSdrDragView().GetSnapAngle();
2029
2030 if (!getSdrDragView().IsRotateAllowed(false))
2031 nSA=9000;
2032
2033 if (nSA!=0)
2034 { // Winkelfang
2035 nNeuWink+=nSA/2;
2036 nNeuWink/=nSA;
2037 nNeuWink*=nSA;
2038 }
2039
2040 nNeuWink=NormAngle180(nNeuWink);
2041
2042 if (nWink!=nNeuWink)
2043 {
2044 sal_uInt16 nSekt0=GetAngleSector(nWink);
2045 sal_uInt16 nSekt1=GetAngleSector(nNeuWink);
2046
2047 if (nSekt0==0 && nSekt1==3)
2048 bRight=true;
2049
2050 if (nSekt0==3 && nSekt1==0)
2051 bRight=false;
2052
2053 nWink=nNeuWink;
2054 double a=nWink*nPi180;
2055 double nSin1=sin(a); // schonmal berechnen, damit mgl. wenig Zeit
2056 double nCos1=cos(a); // zwischen Hide() und Show() vergeht
2057 Hide();
2058 nSin=nSin1;
2059 nCos=nCos1;
2060 DragStat().NextMove(aPnt);
2061 Show();
2062 }
2063 }
2064 }
2065
2066 bool SdrDragRotate::EndSdrDrag(bool bCopy)
2067 {
2068 Hide();
2069
2070 if (nWink!=0)
2071 {
2072 if (IsDraggingPoints())
2073 {
2074 getSdrDragView().RotateMarkedPoints(DragStat().GetRef1(),nWink,bCopy);
2075 }
2076 else if (IsDraggingGluePoints())
2077 {
2078 getSdrDragView().RotateMarkedGluePoints(DragStat().GetRef1(),nWink,bCopy);
2079 }
2080 else
2081 {
2082 getSdrDragView().RotateMarkedObj(DragStat().GetRef1(),nWink,bCopy);
2083 }
2084 }
2085 return true;
2086 }
2087
2088 Pointer SdrDragRotate::GetSdrDragPointer() const
2089 {
2090 return Pointer(POINTER_ROTATE);
2091 }
2092
2093 ////////////////////////////////////////////////////////////////////////////////////////////////////
2094
2095 TYPEINIT1(SdrDragShear,SdrDragMethod);
2096
2097 SdrDragShear::SdrDragShear(SdrDragView& rNewView, bool bSlant1)
2098 : SdrDragMethod(rNewView),
2099 aFact(1,1),
2100 nWink0(0),
2101 nWink(0),
2102 nTan(0.0),
2103 bVertical(false),
2104 bResize(false),
2105 bUpSideDown(false),
2106 bSlant(bSlant1)
2107 {
2108 }
2109
2110 void SdrDragShear::TakeSdrDragComment(XubString& rStr) const
2111 {
2112 ImpTakeDescriptionStr(STR_DragMethShear, rStr);
2113 rStr.AppendAscii(" (");
2114
2115 INT32 nTmpWink(nWink);
2116
2117 if(bUpSideDown)
2118 nTmpWink += 18000;
2119
2120 nTmpWink = NormAngle180(nTmpWink);
2121
2122 XubString aStr;
2123
2124 getSdrDragView().GetModel()->TakeWinkStr(nTmpWink, aStr);
2125 rStr += aStr;
2126 rStr += sal_Unicode(')');
2127
2128 if(getSdrDragView().IsDragWithCopy())
2129 rStr += ImpGetResStr(STR_EditWithCopy);
2130 }
2131
2132 bool SdrDragShear::BeginSdrDrag()
2133 {
2134 SdrHdlKind eRefHdl=HDL_MOVE;
2135 SdrHdl* pRefHdl=NULL;
2136
2137 switch (GetDragHdlKind())
2138 {
2139 case HDL_UPPER: eRefHdl=HDL_LOWER; break;
2140 case HDL_LOWER: eRefHdl=HDL_UPPER; break;
2141 case HDL_LEFT : eRefHdl=HDL_RIGHT; bVertical=true; break;
2142 case HDL_RIGHT: eRefHdl=HDL_LEFT ; bVertical=true; break;
2143 default: break;
2144 }
2145
2146 if (eRefHdl!=HDL_MOVE)
2147 pRefHdl=GetHdlList().GetHdl(eRefHdl);
2148
2149 if (pRefHdl!=NULL)
2150 {
2151 DragStat().Ref1()=pRefHdl->GetPos();
2152 nWink0=GetAngle(DragStat().GetStart()-DragStat().GetRef1());
2153 }
2154 else
2155 {
2156 DBG_ERROR("SdrDragShear::BeginSdrDrag(): Kein Referenzpunkt-Handle fuer Shear gefunden");
2157 return false;
2158 }
2159
2160 Show();
2161 return true;
2162 }
2163
2164 basegfx::B2DHomMatrix SdrDragShear::getCurrentTransformation()
2165 {
2166 basegfx::B2DHomMatrix aRetval;
2167
2168 aRetval.translate(-DragStat().GetRef1().X(), -DragStat().GetRef1().Y());
2169
2170 if (bResize)
2171 {
2172 if (bVertical)
2173 {
2174 aRetval.scale(aFact, 1.0);
2175 aRetval.shearY(-nTan);
2176 }
2177 else
2178 {
2179 aRetval.scale(1.0, aFact);
2180 aRetval.shearX(-nTan);
2181 }
2182 }
2183
2184 aRetval.translate(DragStat().GetRef1().X(), DragStat().GetRef1().Y());
2185
2186 return aRetval;
2187 }
2188
2189 void SdrDragShear::MoveSdrDrag(const Point& rPnt)
2190 {
2191 if (DragStat().CheckMinMoved(rPnt))
2192 {
2193 bResize=!getSdrDragView().IsOrtho();
2194 long nSA=0;
2195
2196 if (getSdrDragView().IsAngleSnapEnabled())
2197 nSA=getSdrDragView().GetSnapAngle();
2198
2199 Point aP0(DragStat().GetStart());
2200 Point aPnt(rPnt);
2201 Fraction aNeuFact(1,1);
2202
2203 // Wenn kein Winkelfang, dann ggf. Rasterfang (ausser bei Slant)
2204 if (nSA==0 && !bSlant)
2205 aPnt=GetSnapPos(aPnt);
2206
2207 if (!bSlant && !bResize)
2208 { // Shear ohne Resize
2209 if (bVertical)
2210 aPnt.X()=aP0.X();
2211 else
2212 aPnt.Y()=aP0.Y();
2213 }
2214
2215 Point aRef(DragStat().GetRef1());
2216 Point aDif(aPnt-aRef);
2217
2218 long nNeuWink=0;
2219
2220 if (bSlant)
2221 {
2222 nNeuWink=NormAngle180(-(GetAngle(aDif)-nWink0));
2223
2224 if (bVertical)
2225 nNeuWink=NormAngle180(-nNeuWink);
2226 }
2227 else
2228 {
2229 if (bVertical)
2230 nNeuWink=NormAngle180(GetAngle(aDif));
2231 else
2232 nNeuWink=NormAngle180(-(GetAngle(aDif)-9000));
2233
2234 if (nNeuWink<-9000 || nNeuWink>9000)
2235 nNeuWink=NormAngle180(nNeuWink+18000);
2236
2237 if (bResize)
2238 {
2239 Point aPt2(aPnt);
2240
2241 if (nSA!=0)
2242 aPt2=GetSnapPos(aPnt); // den also in jedem Falle fangen
2243
2244 if (bVertical)
2245 {
2246 aNeuFact=Fraction(aPt2.X()-aRef.X(),aP0.X()-aRef.X());
2247 }
2248 else
2249 {
2250 aNeuFact=Fraction(aPt2.Y()-aRef.Y(),aP0.Y()-aRef.Y());
2251 }
2252 }
2253 }
2254
2255 bool bNeg=nNeuWink<0;
2256
2257 if (bNeg)
2258 nNeuWink=-nNeuWink;
2259
2260 if (nSA!=0)
2261 { // Winkelfang
2262 nNeuWink+=nSA/2;
2263 nNeuWink/=nSA;
2264 nNeuWink*=nSA;
2265 }
2266
2267 nNeuWink=NormAngle360(nNeuWink);
2268 bUpSideDown=nNeuWink>9000 && nNeuWink<27000;
2269
2270 if (bSlant)
2271 { // Resize fuer Slant berechnen
2272 // Mit Winkelfang jedoch ohne 89deg Begrenzung
2273 long nTmpWink=nNeuWink;
2274 if (bUpSideDown) nNeuWink-=18000;
2275 if (bNeg) nTmpWink=-nTmpWink;
2276 bResize=true;
2277 double nCos=cos(nTmpWink*nPi180);
2278 aNeuFact=nCos;
2279 Kuerzen(aFact,10); // 3 Dezimalstellen sollten reichen
2280 }
2281
2282 if (nNeuWink>8900)
2283 nNeuWink=8900;
2284
2285 if (bNeg)
2286 nNeuWink=-nNeuWink;
2287
2288 if (nWink!=nNeuWink || aFact!=aNeuFact)
2289 {
2290 nWink=nNeuWink;
2291 aFact=aNeuFact;
2292 double a=nWink*nPi180;
2293 double nTan1=0.0;
2294 nTan1=tan(a); // schonmal berechnen, damit mgl. wenig Zeit zwischen Hide() und Show() vergeht
2295 Hide();
2296 nTan=nTan1;
2297 DragStat().NextMove(rPnt);
2298 Show();
2299 }
2300 }
2301 }
2302
2303 void SdrDragShear::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
2304 {
2305 if (bResize)
2306 {
2307 if (bVertical)
2308 {
2309 rTarget.Resize(DragStat().GetRef1(),aFact,Fraction(1,1));
2310 }
2311 else
2312 {
2313 rTarget.Resize(DragStat().GetRef1(),Fraction(1,1),aFact);
2314 }
2315 }
2316
2317 if (nWink!=0)
2318 {
2319 rTarget.Shear(DragStat().GetRef1(),nWink,tan(nWink*nPi180),bVertical);
2320 }
2321 }
2322
2323 bool SdrDragShear::EndSdrDrag(bool bCopy)
2324 {
2325 Hide();
2326
2327 if (bResize && aFact==Fraction(1,1))
2328 bResize=false;
2329
2330 if (nWink!=0 || bResize)
2331 {
2332 if (nWink!=0 && bResize)
2333 {
2334 XubString aStr;
2335 ImpTakeDescriptionStr(STR_EditShear,aStr);
2336
2337 if (bCopy)
2338 aStr+=ImpGetResStr(STR_EditWithCopy);
2339
2340 getSdrDragView().BegUndo(aStr);
2341 }
2342
2343 if (bResize)
2344 {
2345 if (bVertical)
2346 {
2347 getSdrDragView().ResizeMarkedObj(DragStat().GetRef1(),aFact,Fraction(1,1),bCopy);
2348 }
2349 else
2350 {
2351 getSdrDragView().ResizeMarkedObj(DragStat().GetRef1(),Fraction(1,1),aFact,bCopy);
2352 }
2353
2354 bCopy=false;
2355 }
2356
2357 if (nWink!=0)
2358 {
2359 getSdrDragView().ShearMarkedObj(DragStat().GetRef1(),nWink,bVertical,bCopy);
2360 }
2361
2362 if (nWink!=0 && bResize)
2363 getSdrDragView().EndUndo();
2364
2365 return true;
2366 }
2367
2368 return false;
2369 }
2370
2371 Pointer SdrDragShear::GetSdrDragPointer() const
2372 {
2373 if (bVertical)
2374 return Pointer(POINTER_VSHEAR);
2375 else
2376 return Pointer(POINTER_HSHEAR);
2377 }
2378
2379 ////////////////////////////////////////////////////////////////////////////////////////////////////
2380
2381 TYPEINIT1(SdrDragMirror,SdrDragMethod);
2382
2383 void SdrDragMirror::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
2384 {
2385 if(bMirrored)
2386 {
2387 rTarget.Mirror(DragStat().GetRef1(), DragStat().GetRef2());
2388 }
2389 }
2390
2391 SdrDragMirror::SdrDragMirror(SdrDragView& rNewView)
2392 : SdrDragMethod(rNewView),
2393 nWink(0),
2394 bMirrored(false),
2395 bSide0(false)
2396 {
2397 }
2398
2399 bool SdrDragMirror::ImpCheckSide(const Point& rPnt) const
2400 {
2401 long nWink1=GetAngle(rPnt-DragStat().GetRef1());
2402 nWink1-=nWink;
2403 nWink1=NormAngle360(nWink1);
2404
2405 return nWink1<18000;
2406 }
2407
2408 void SdrDragMirror::TakeSdrDragComment(XubString& rStr) const
2409 {
2410 if (aDif.X()==0)
2411 ImpTakeDescriptionStr(STR_DragMethMirrorHori,rStr);
2412 else if (aDif.Y()==0)
2413 ImpTakeDescriptionStr(STR_DragMethMirrorVert,rStr);
2414 else if (Abs(aDif.X())==Abs(aDif.Y()))
2415 ImpTakeDescriptionStr(STR_DragMethMirrorDiag,rStr);
2416 else
2417 ImpTakeDescriptionStr(STR_DragMethMirrorFree,rStr);
2418
2419 if (getSdrDragView().IsDragWithCopy())
2420 rStr+=ImpGetResStr(STR_EditWithCopy);
2421 }
2422
2423 bool SdrDragMirror::BeginSdrDrag()
2424 {
2425 SdrHdl* pH1=GetHdlList().GetHdl(HDL_REF1);
2426 SdrHdl* pH2=GetHdlList().GetHdl(HDL_REF2);
2427
2428 if (pH1!=NULL && pH2!=NULL)
2429 {
2430 DragStat().Ref1()=pH1->GetPos();
2431 DragStat().Ref2()=pH2->GetPos();
2432 Ref1()=pH1->GetPos();
2433 Ref2()=pH2->GetPos();
2434 aDif=pH2->GetPos()-pH1->GetPos();
2435 bool b90=(aDif.X()==0) || aDif.Y()==0;
2436 bool b45=b90 || (Abs(aDif.X())==Abs(aDif.Y()));
2437 nWink=NormAngle360(GetAngle(aDif));
2438
2439 if (!getSdrDragView().IsMirrorAllowed(false,false) && !b45)
2440 return false; // freier Achsenwinkel nicht erlaubt
2441
2442 if (!getSdrDragView().IsMirrorAllowed(true,false) && !b90)
2443 return false; // 45deg auch nicht erlaubt
2444
2445 bSide0=ImpCheckSide(DragStat().GetStart());
2446 Show();
2447 return true;
2448 }
2449 else
2450 {
2451 DBG_ERROR("SdrDragMirror::BeginSdrDrag(): Spiegelachse nicht gefunden");
2452 return false;
2453 }
2454 }
2455
2456 basegfx::B2DHomMatrix SdrDragMirror::getCurrentTransformation()
2457 {
2458 basegfx::B2DHomMatrix aRetval;
2459
2460 if (bMirrored)
2461 {
2462 const double fDeltaX(DragStat().GetRef2().X() - DragStat().GetRef1().X());
2463 const double fDeltaY(DragStat().GetRef2().Y() - DragStat().GetRef1().Y());
2464 const double fRotation(atan2(fDeltaY, fDeltaX));
2465
2466 aRetval.translate(-DragStat().GetRef1().X(), -DragStat().GetRef1().Y());
2467 aRetval.rotate(-fRotation);
2468 aRetval.scale(1.0, -1.0);
2469 aRetval.rotate(fRotation);
2470 aRetval.translate(DragStat().GetRef1().X(), DragStat().GetRef1().Y());
2471 }
2472
2473 return aRetval;
2474 }
2475
2476 void SdrDragMirror::MoveSdrDrag(const Point& rPnt)
2477 {
2478 if (DragStat().CheckMinMoved(rPnt))
2479 {
2480 bool bNeuSide=ImpCheckSide(rPnt);
2481 bool bNeuMirr=bSide0!=bNeuSide;
2482
2483 if (bMirrored!=bNeuMirr)
2484 {
2485 Hide();
2486 bMirrored=bNeuMirr;
2487 DragStat().NextMove(rPnt);
2488 Show();
2489 }
2490 }
2491 }
2492
2493 bool SdrDragMirror::EndSdrDrag(bool bCopy)
2494 {
2495 Hide();
2496
2497 if (bMirrored)
2498 {
2499 getSdrDragView().MirrorMarkedObj(DragStat().GetRef1(),DragStat().GetRef2(),bCopy);
2500 }
2501
2502 return true;
2503 }
2504
2505 Pointer SdrDragMirror::GetSdrDragPointer() const
2506 {
2507 return Pointer(POINTER_MIRROR);
2508 }
2509
2510 ////////////////////////////////////////////////////////////////////////////////////////////////////
2511
2512 TYPEINIT1(SdrDragGradient, SdrDragMethod);
2513
2514 SdrDragGradient::SdrDragGradient(SdrDragView& rNewView, bool bGrad)
2515 : SdrDragMethod(rNewView),
2516 pIAOHandle(NULL),
2517 bIsGradient(bGrad)
2518 {
2519 }
2520
2521 void SdrDragGradient::TakeSdrDragComment(XubString& rStr) const
2522 {
2523 if(IsGradient())
2524 ImpTakeDescriptionStr(STR_DragMethGradient, rStr);
2525 else
2526 ImpTakeDescriptionStr(STR_DragMethTransparence, rStr);
2527 }
2528
2529 bool SdrDragGradient::BeginSdrDrag()
2530 {
2531 bool bRetval(false);
2532
2533 pIAOHandle = (SdrHdlGradient*)GetHdlList().GetHdl(IsGradient() ? HDL_GRAD : HDL_TRNS);
2534
2535 if(pIAOHandle)
2536 {
2537 // save old values
2538 DragStat().Ref1() = pIAOHandle->GetPos();
2539 DragStat().Ref2() = pIAOHandle->Get2ndPos();
2540
2541 // what was hit?
2542 bool bHit(false);
2543 SdrHdlColor* pColHdl = pIAOHandle->GetColorHdl1();
2544
2545 // init handling flags
2546 pIAOHandle->SetMoveSingleHandle(false);
2547 pIAOHandle->SetMoveFirstHandle(false);
2548
2549 // test first color handle
2550 if(pColHdl)
2551 {
2552 basegfx::B2DPoint aPosition(DragStat().GetStart().X(), DragStat().GetStart().Y());
2553
2554 if(pColHdl->getOverlayObjectList().isHitLogic(aPosition))
2555 {
2556 bHit = true;
2557 pIAOHandle->SetMoveSingleHandle(true);
2558 pIAOHandle->SetMoveFirstHandle(true);
2559 }
2560 }
2561
2562 // test second color handle
2563 pColHdl = pIAOHandle->GetColorHdl2();
2564
2565 if(!bHit && pColHdl)
2566 {
2567 basegfx::B2DPoint aPosition(DragStat().GetStart().X(), DragStat().GetStart().Y());
2568
2569 if(pColHdl->getOverlayObjectList().isHitLogic(aPosition))
2570 {
2571 bHit = true;
2572 pIAOHandle->SetMoveSingleHandle(true);
2573 }
2574 }
2575
2576 // test gradient handle itself
2577 if(!bHit)
2578 {
2579 basegfx::B2DPoint aPosition(DragStat().GetStart().X(), DragStat().GetStart().Y());
2580
2581 if(pIAOHandle->getOverlayObjectList().isHitLogic(aPosition))
2582 {
2583 bHit = true;
2584 }
2585 }
2586
2587 // everything up and running :o}
2588 bRetval = bHit;
2589 }
2590 else
2591 {
2592 DBG_ERROR("SdrDragGradient::BeginSdrDrag(): IAOGradient nicht gefunden");
2593 }
2594
2595 return bRetval;
2596 }
2597
2598 void SdrDragGradient::MoveSdrDrag(const Point& rPnt)
2599 {
2600 if(pIAOHandle && DragStat().CheckMinMoved(rPnt))
2601 {
2602 DragStat().NextMove(rPnt);
2603
2604 // Do the Move here!!! DragStat().GetStart()
2605 Point aMoveDiff = rPnt - DragStat().GetStart();
2606
2607 if(pIAOHandle->IsMoveSingleHandle())
2608 {
2609 if(pIAOHandle->IsMoveFirstHandle())
2610 {
2611 pIAOHandle->SetPos(DragStat().Ref1() + aMoveDiff);
2612 if(pIAOHandle->GetColorHdl1())
2613 pIAOHandle->GetColorHdl1()->SetPos(DragStat().Ref1() + aMoveDiff);
2614 }
2615 else
2616 {
2617 pIAOHandle->Set2ndPos(DragStat().Ref2() + aMoveDiff);
2618 if(pIAOHandle->GetColorHdl2())
2619 pIAOHandle->GetColorHdl2()->SetPos(DragStat().Ref2() + aMoveDiff);
2620 }
2621 }
2622 else
2623 {
2624 pIAOHandle->SetPos(DragStat().Ref1() + aMoveDiff);
2625 pIAOHandle->Set2ndPos(DragStat().Ref2() + aMoveDiff);
2626
2627 if(pIAOHandle->GetColorHdl1())
2628 pIAOHandle->GetColorHdl1()->SetPos(DragStat().Ref1() + aMoveDiff);
2629
2630 if(pIAOHandle->GetColorHdl2())
2631 pIAOHandle->GetColorHdl2()->SetPos(DragStat().Ref2() + aMoveDiff);
2632 }
2633
2634 // new state
2635 pIAOHandle->FromIAOToItem(getSdrDragView().GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(), false, false);
2636 }
2637 }
2638
2639 bool SdrDragGradient::EndSdrDrag(bool /*bCopy*/)
2640 {
2641 // here the result is clear, do something with the values
2642 Ref1() = pIAOHandle->GetPos();
2643 Ref2() = pIAOHandle->Get2ndPos();
2644
2645 // new state
2646 pIAOHandle->FromIAOToItem(getSdrDragView().GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(), true, true);
2647
2648 return true;
2649 }
2650
2651 void SdrDragGradient::CancelSdrDrag()
2652 {
2653 // restore old values
2654 pIAOHandle->SetPos(DragStat().Ref1());
2655 pIAOHandle->Set2ndPos(DragStat().Ref2());
2656
2657 if(pIAOHandle->GetColorHdl1())
2658 pIAOHandle->GetColorHdl1()->SetPos(DragStat().Ref1());
2659
2660 if(pIAOHandle->GetColorHdl2())
2661 pIAOHandle->GetColorHdl2()->SetPos(DragStat().Ref2());
2662
2663 // new state
2664 pIAOHandle->FromIAOToItem(getSdrDragView().GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(), true, false);
2665 }
2666
2667 Pointer SdrDragGradient::GetSdrDragPointer() const
2668 {
2669 return Pointer(POINTER_REFHAND);
2670 }
2671
2672 ////////////////////////////////////////////////////////////////////////////////////////////////////
2673
2674 TYPEINIT1(SdrDragCrook,SdrDragMethod);
2675
2676 SdrDragCrook::SdrDragCrook(SdrDragView& rNewView)
2677 : SdrDragMethod(rNewView),
2678 aFact(1,1),
2679 bContortionAllowed(false),
2680 bNoContortionAllowed(false),
2681 bContortion(false),
2682 bResizeAllowed(false),
2683 bResize(false),
2684 bRotateAllowed(false),
2685 bRotate(false),
2686 bVertical(false),
2687 bValid(false),
2688 bLft(false),
2689 bRgt(false),
2690 bUpr(false),
2691 bLwr(false),
2692 bAtCenter(false),
2693 nWink(0),
2694 nMarkSize(0),
2695 eMode(SDRCROOK_ROTATE)
2696 {
2697 }
2698
2699 void SdrDragCrook::TakeSdrDragComment(XubString& rStr) const
2700 {
2701 ImpTakeDescriptionStr(!bContortion ? STR_DragMethCrook : STR_DragMethCrookContortion, rStr);
2702
2703 if(bValid)
2704 {
2705 rStr.AppendAscii(" (");
2706
2707 XubString aStr;
2708 INT32 nVal(nWink);
2709
2710 if(bAtCenter)
2711 nVal *= 2;
2712
2713 nVal = Abs(nVal);
2714 getSdrDragView().GetModel()->TakeWinkStr(nVal, aStr);
2715 rStr += aStr;
2716 rStr += sal_Unicode(')');
2717 }
2718
2719 if(getSdrDragView().IsDragWithCopy())
2720 rStr += ImpGetResStr(STR_EditWithCopy);
2721 }
2722
2723 // #96920# These defines parametrise the created raster
2724 // for interactions
2725 #define DRAG_CROOK_RASTER_MINIMUM (4)
2726 #define DRAG_CROOK_RASTER_MAXIMUM (15)
2727 #define DRAG_CROOK_RASTER_DISTANCE (30)
2728
2729 basegfx::B2DPolyPolygon impCreateDragRaster(SdrPageView& rPageView, const Rectangle& rMarkRect)
2730 {
2731 basegfx::B2DPolyPolygon aRetval;
2732
2733 if(rPageView.PageWindowCount())
2734 {
2735 OutputDevice& rOut = (rPageView.GetPageWindow(0)->GetPaintWindow().GetOutputDevice());
2736 Rectangle aPixelSize = rOut.LogicToPixel(rMarkRect);
2737 sal_uInt32 nHorDiv(aPixelSize.GetWidth() / DRAG_CROOK_RASTER_DISTANCE);
2738 sal_uInt32 nVerDiv(aPixelSize.GetHeight() / DRAG_CROOK_RASTER_DISTANCE);
2739
2740 if(nHorDiv > DRAG_CROOK_RASTER_MAXIMUM)
2741 nHorDiv = DRAG_CROOK_RASTER_MAXIMUM;
2742 if(nHorDiv < DRAG_CROOK_RASTER_MINIMUM)
2743 nHorDiv = DRAG_CROOK_RASTER_MINIMUM;
2744
2745 if(nVerDiv > DRAG_CROOK_RASTER_MAXIMUM)
2746 nVerDiv = DRAG_CROOK_RASTER_MAXIMUM;
2747 if(nVerDiv < DRAG_CROOK_RASTER_MINIMUM)
2748 nVerDiv = DRAG_CROOK_RASTER_MINIMUM;
2749
2750 const double fXLen(rMarkRect.GetWidth() / (double)nHorDiv);
2751 const double fYLen(rMarkRect.GetHeight() / (double)nVerDiv);
2752 double fYPos(rMarkRect.Top());
2753 sal_uInt32 a, b;
2754
2755 for(a = 0; a <= nVerDiv; a++)
2756 {
2757 // hor lines
2758 for(b = 0; b < nHorDiv; b++)
2759 {
2760 basegfx::B2DPolygon aHorLineSegment;
2761
2762 const double fNewX(rMarkRect.Left() + (b * fXLen));
2763 aHorLineSegment.append(basegfx::B2DPoint(fNewX, fYPos));
2764 aHorLineSegment.appendBezierSegment(
2765 basegfx::B2DPoint(fNewX + (fXLen * (1.0 / 3.0)), fYPos),
2766 basegfx::B2DPoint(fNewX + (fXLen * (2.0 / 3.0)), fYPos),
2767 basegfx::B2DPoint(fNewX + fXLen, fYPos));
2768 aRetval.append(aHorLineSegment);
2769 }
2770
2771 // increments
2772 fYPos += fYLen;
2773 }
2774
2775 double fXPos(rMarkRect.Left());
2776
2777 for(a = 0; a <= nHorDiv; a++)
2778 {
2779 // ver lines
2780 for(b = 0; b < nVerDiv; b++)
2781 {
2782 basegfx::B2DPolygon aVerLineSegment;
2783
2784 const double fNewY(rMarkRect.Top() + (b * fYLen));
2785 aVerLineSegment.append(basegfx::B2DPoint(fXPos, fNewY));
2786 aVerLineSegment.appendBezierSegment(
2787 basegfx::B2DPoint(fXPos, fNewY + (fYLen * (1.0 / 3.0))),
2788 basegfx::B2DPoint(fXPos, fNewY + (fYLen * (2.0 / 3.0))),
2789 basegfx::B2DPoint(fXPos, fNewY + fYLen));
2790 aRetval.append(aVerLineSegment);
2791 }
2792
2793 // increments
2794 fXPos += fXLen;
2795 }
2796 }
2797
2798 return aRetval;
2799 }
2800
2801 void SdrDragCrook::createSdrDragEntries()
2802 {
2803 // Add extended frame raster first, so it will be behind objects
2804 if(getSdrDragView().GetSdrPageView())
2805 {
2806 const basegfx::B2DPolyPolygon aDragRaster(impCreateDragRaster(*getSdrDragView().GetSdrPageView(), GetMarkedRect()));
2807
2808 if(aDragRaster.count())
2809 {
2810 addSdrDragEntry(new SdrDragEntryPolyPolygon(aDragRaster));
2811 }
2812 }
2813
2814 // call parent
2815 SdrDragMethod::createSdrDragEntries();
2816 }
2817
2818 bool SdrDragCrook::BeginSdrDrag()
2819 {
2820 bContortionAllowed=getSdrDragView().IsCrookAllowed(false);
2821 bNoContortionAllowed=getSdrDragView().IsCrookAllowed(true);
2822 bResizeAllowed=getSdrDragView().IsResizeAllowed(false);
2823 bRotateAllowed=getSdrDragView().IsRotateAllowed(false);
2824
2825 if (bContortionAllowed || bNoContortionAllowed)
2826 {
2827 bVertical=(GetDragHdlKind()==HDL_LOWER || GetDragHdlKind()==HDL_UPPER);
2828 aMarkRect=GetMarkedRect();
2829 aMarkCenter=aMarkRect.Center();
2830 nMarkSize=bVertical ? (aMarkRect.GetHeight()-1) : (aMarkRect.GetWidth()-1);
2831 aCenter=aMarkCenter;
2832 aStart=DragStat().GetStart();
2833 Show();
2834 return true;
2835 }
2836 else
2837 {
2838 return false;
2839 }
2840 }
2841
2842 void SdrDragCrook::_MovAllPoints(basegfx::B2DPolyPolygon& rTarget)
2843 {
2844 SdrPageView* pPV = getSdrDragView().GetSdrPageView();
2845
2846 if(pPV)
2847 {
2848 XPolyPolygon aTempPolyPoly(rTarget);
2849
2850 if (pPV->HasMarkedObjPageView())
2851 {
2852 sal_uInt16 nPolyAnz=aTempPolyPoly.Count();
2853
2854 if (!bContortion && !getSdrDragView().IsNoDragXorPolys())
2855 {
2856 sal_uInt16 n1st=0,nLast=0;
2857 Point aC(aCenter);
2858
2859 while (n1st<nPolyAnz)
2860 {
2861 nLast=n1st;
2862 while (nLast<nPolyAnz && aTempPolyPoly[nLast].GetPointCount()!=0) nLast++;
2863 Rectangle aBound(aTempPolyPoly[n1st].GetBoundRect());
2864 sal_uInt16 i;
2865
2866 for (i=n1st+1; i<nLast; i++)
2867 {
2868 aBound.Union(aTempPolyPoly[n1st].GetBoundRect());
2869 }
2870
2871 Point aCtr0(aBound.Center());
2872 Point aCtr1(aCtr0);
2873
2874 if (bResize)
2875 {
2876 Fraction aFact1(1,1);
2877
2878 if (bVertical)
2879 {
2880 ResizePoint(aCtr1,aC,aFact1,aFact);
2881 }
2882 else
2883 {
2884 ResizePoint(aCtr1,aC,aFact,aFact1);
2885 }
2886 }
2887
2888 bool bRotOk=false;
2889 double nSin=0,nCos=0;
2890
2891 if (aRad.X()!=0 && aRad.Y()!=0)
2892 {
2893 bRotOk=bRotate;
2894
2895 switch (eMode)
2896 {
2897 case SDRCROOK_ROTATE : CrookRotateXPoint (aCtr1,NULL,NULL,aC,aRad,nSin,nCos,bVertical); break;
2898 case SDRCROOK_SLANT : CrookSlantXPoint (aCtr1,NULL,NULL,aC,aRad,nSin,nCos,bVertical); break;
2899 case SDRCROOK_STRETCH: CrookStretchXPoint(aCtr1,NULL,NULL,aC,aRad,nSin,nCos,bVertical,aMarkRect); break;
2900 } // switch
2901 }
2902
2903 aCtr1-=aCtr0;
2904
2905 for (i=n1st; i<nLast; i++)
2906 {
2907 if (bRotOk)
2908 {
2909 RotateXPoly(aTempPolyPoly[i],aCtr0,nSin,nCos);
2910 }
2911
2912 aTempPolyPoly[i].Move(aCtr1.X(),aCtr1.Y());
2913 }
2914
2915 n1st=nLast+1;
2916 }
2917 }
2918 else
2919 {
2920 sal_uInt16 i,j;
2921
2922 for (j=0; j<nPolyAnz; j++)
2923 {
2924 XPolygon& aPol=aTempPolyPoly[j];
2925 sal_uInt16 nPtAnz=aPol.GetPointCount();
2926 i=0;
2927
2928 while (i<nPtAnz)
2929 {
2930 Point* pPnt=&aPol[i];
2931 Point* pC1=NULL;
2932 Point* pC2=NULL;
2933
2934 if (i+1<nPtAnz && aPol.IsControl(i))
2935 { // Kontrollpunkt links
2936 pC1=pPnt;
2937 i++;
2938 pPnt=&aPol[i];
2939 }
2940
2941 i++;
2942
2943 if (i<nPtAnz && aPol.IsControl(i))
2944 { // Kontrollpunkt rechts
2945 pC2=&aPol[i];
2946 i++;
2947 }
2948
2949 _MovCrookPoint(*pPnt,pC1,pC2);
2950 }
2951 }
2952 }
2953 }
2954
2955 rTarget = aTempPolyPoly.getB2DPolyPolygon();
2956 }
2957 }
2958
2959 void SdrDragCrook::_MovCrookPoint(Point& rPnt, Point* pC1, Point* pC2)
2960 {
2961 bool bVert=bVertical;
2962 bool bC1=pC1!=NULL;
2963 bool bC2=pC2!=NULL;
2964 Point aC(aCenter);
2965
2966 if (bResize)
2967 {
2968 Fraction aFact1(1,1);
2969
2970 if (bVert)
2971 {
2972 ResizePoint(rPnt,aC,aFact1,aFact);
2973
2974 if (bC1)
2975 ResizePoint(*pC1,aC,aFact1,aFact);
2976
2977 if (bC2)
2978 ResizePoint(*pC2,aC,aFact1,aFact);
2979 }
2980 else
2981 {
2982 ResizePoint(rPnt,aC,aFact,aFact1);
2983
2984 if (bC1)
2985 ResizePoint(*pC1,aC,aFact,aFact1);
2986
2987 if (bC2)
2988 ResizePoint(*pC2,aC,aFact,aFact1);
2989 }
2990 }
2991
2992 if (aRad.X()!=0 && aRad.Y()!=0)
2993 {
2994 double nSin,nCos;
2995
2996 switch (eMode)
2997 {
2998 case SDRCROOK_ROTATE : CrookRotateXPoint (rPnt,pC1,pC2,aC,aRad,nSin,nCos,bVert); break;
2999 case SDRCROOK_SLANT : CrookSlantXPoint (rPnt,pC1,pC2,aC,aRad,nSin,nCos,bVert); break;
3000 case SDRCROOK_STRETCH: CrookStretchXPoint(rPnt,pC1,pC2,aC,aRad,nSin,nCos,bVert,aMarkRect); break;
3001 } // switch
3002 }
3003 }
3004
3005 void SdrDragCrook::MoveSdrDrag(const Point& rPnt)
3006 {
3007 if (DragStat().CheckMinMoved(rPnt))
3008 {
3009 Point aPnt(rPnt);
3010 bool bNeuMoveOnly=getSdrDragView().IsMoveOnlyDragging();
3011 bAtCenter=false;
3012 SdrCrookMode eNeuMode=getSdrDragView().GetCrookMode();
3013 bool bNeuContortion=!bNeuMoveOnly && ((bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed);
3014 bResize=!getSdrDragView().IsOrtho() && bResizeAllowed && !bNeuMoveOnly;
3015 bool bNeuRotate=bRotateAllowed && !bNeuContortion && !bNeuMoveOnly && eNeuMode==SDRCROOK_ROTATE;
3016 long nSA=0;
3017
3018 if (nSA==0)
3019 aPnt=GetSnapPos(aPnt);
3020
3021 Point aNeuCenter(aMarkCenter.X(),aStart.Y());
3022
3023 if (bVertical)
3024 {
3025 aNeuCenter.X()=aStart.X();
3026 aNeuCenter.Y()=aMarkCenter.Y();
3027 }
3028
3029 if (!getSdrDragView().IsCrookAtCenter())
3030 {
3031 switch (GetDragHdlKind())
3032 {
3033 case HDL_UPLFT: aNeuCenter.X()=aMarkRect.Right(); bLft=true; break;
3034 case HDL_UPPER: aNeuCenter.Y()=aMarkRect.Bottom(); bUpr=true; break;
3035 case HDL_UPRGT: aNeuCenter.X()=aMarkRect.Left(); bRgt=true; break;
3036 case HDL_LEFT : aNeuCenter.X()=aMarkRect.Right(); bLft=true; break;
3037 case HDL_RIGHT: aNeuCenter.X()=aMarkRect.Left(); bRgt=true; break;
3038 case HDL_LWLFT: aNeuCenter.X()=aMarkRect.Right(); bLft=true; break;
3039 case HDL_LOWER: aNeuCenter.Y()=aMarkRect.Top(); bLwr=true; break;
3040 case HDL_LWRGT: aNeuCenter.X()=aMarkRect.Left(); bRgt=true; break;
3041 default: bAtCenter=true;
3042 }
3043 }
3044 else
3045 bAtCenter=true;
3046
3047 Fraction aNeuFact(1,1);
3048 long dx1=aPnt.X()-aNeuCenter.X();
3049 long dy1=aPnt.Y()-aNeuCenter.Y();
3050 bValid=bVertical ? dx1!=0 : dy1!=0;
3051
3052 if (bValid)
3053 {
3054 if (bVertical)
3055 bValid=Abs(dx1)*100>Abs(dy1);
3056 else
3057 bValid=Abs(dy1)*100>Abs(dx1);
3058 }
3059
3060 long nNeuRad=0;
3061 nWink=0;
3062
3063 if (bValid)
3064 {
3065 double a=0; // Steigung des Radius
3066 long nPntWink=0;
3067
3068 if (bVertical)
3069 {
3070 a=((double)dy1)/((double)dx1); // Steigung des Radius
3071 nNeuRad=((long)(dy1*a)+dx1) /2;
3072 aNeuCenter.X()+=nNeuRad;
3073 nPntWink=GetAngle(aPnt-aNeuCenter);
3074 }
3075 else
3076 {
3077 a=((double)dx1)/((double)dy1); // Steigung des Radius
3078 nNeuRad=((long)(dx1*a)+dy1) /2;
3079 aNeuCenter.Y()+=nNeuRad;
3080 nPntWink=GetAngle(aPnt-aNeuCenter)-9000;
3081 }
3082
3083 if (!bAtCenter)
3084 {
3085 if (nNeuRad<0)
3086 {
3087 if (bRgt) nPntWink+=18000;
3088 if (bLft) nPntWink=18000-nPntWink;
3089 if (bLwr) nPntWink=-nPntWink;
3090 }
3091 else
3092 {
3093 if (bRgt) nPntWink=-nPntWink;
3094 if (bUpr) nPntWink=18000-nPntWink;
3095 if (bLwr) nPntWink+=18000;
3096 }
3097
3098 nPntWink=NormAngle360(nPntWink);
3099 }
3100 else
3101 {
3102 if (nNeuRad<0) nPntWink+=18000;
3103 if (bVertical) nPntWink=18000-nPntWink;
3104 nPntWink=NormAngle180(nPntWink);
3105 nPntWink=Abs(nPntWink);
3106 }
3107
3108 double nUmfang=2*Abs(nNeuRad)*nPi;
3109
3110 if (bResize)
3111 {
3112 if (nSA!=0)
3113 { // Winkelfang
3114 long nWink0=nPntWink;
3115 nPntWink+=nSA/2;
3116 nPntWink/=nSA;
3117 nPntWink*=nSA;
3118 BigInt a2(nNeuRad);
3119 a2*=BigInt(nWink);
3120 a2/=BigInt(nWink0);
3121 nNeuRad=long(a2);
3122
3123 if (bVertical)
3124 aNeuCenter.X()=aStart.X()+nNeuRad;
3125 else
3126 aNeuCenter.Y()=aStart.Y()+nNeuRad;
3127 }
3128
3129 long nMul=(long)(nUmfang*NormAngle360(nPntWink)/36000);
3130
3131 if (bAtCenter)
3132 nMul*=2;
3133
3134 aNeuFact=Fraction(nMul,nMarkSize);
3135 nWink=nPntWink;
3136 }
3137 else
3138 {
3139 nWink=(long)((nMarkSize*360/nUmfang)*100)/2;
3140
3141 if (nWink==0)
3142 bValid=false;
3143
3144 if (bValid && nSA!=0)
3145 { // Winkelfang
3146 long nWink0=nWink;
3147 nWink+=nSA/2;
3148 nWink/=nSA;
3149 nWink*=nSA;
3150 BigInt a2(nNeuRad);
3151 a2*=BigInt(nWink);
3152 a2/=BigInt(nWink0);
3153 nNeuRad=long(a2);
3154
3155 if (bVertical)
3156 aNeuCenter.X()=aStart.X()+nNeuRad;
3157 else
3158 aNeuCenter.Y()=aStart.Y()+nNeuRad;
3159 }
3160 }
3161 }
3162
3163 if (nWink==0 || nNeuRad==0)
3164 bValid=false;
3165
3166 if (!bValid)
3167 nNeuRad=0;
3168
3169 if (!bValid && bResize)
3170 {
3171 long nMul=bVertical ? dy1 : dx1;
3172
3173 if (bLft || bUpr)
3174 nMul=-nMul;
3175
3176 long nDiv=nMarkSize;
3177
3178 if (bAtCenter)
3179 {
3180 nMul*=2;
3181 nMul=Abs(nMul);
3182 }
3183
3184 aNeuFact=Fraction(nMul,nDiv);
3185 }
3186
3187 if (aNeuCenter!=aCenter || bNeuContortion!=bContortion || aNeuFact!=aFact ||
3188 bNeuMoveOnly != getMoveOnly() || bNeuRotate!=bRotate || eNeuMode!=eMode)
3189 {
3190 Hide();
3191 setMoveOnly(bNeuMoveOnly);
3192 bRotate=bNeuRotate;
3193 eMode=eNeuMode;
3194 bContortion=bNeuContortion;
3195 aCenter=aNeuCenter;
3196 aFact=aNeuFact;
3197 aRad=Point(nNeuRad,nNeuRad);
3198 bResize=aFact!=Fraction(1,1) && aFact.GetDenominator()!=0 && aFact.IsValid();
3199 DragStat().NextMove(aPnt);
3200 Show();
3201 }
3202 }
3203 }
3204
3205 void SdrDragCrook::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
3206 {
3207 const bool bDoResize(aFact!=Fraction(1,1));
3208 const bool bDoCrook(aCenter!=aMarkCenter && aRad.X()!=0 && aRad.Y()!=0);
3209
3210 if (bDoCrook || bDoResize)
3211 {
3212 if (bDoResize)
3213 {
3214 Fraction aFact1(1,1);
3215
3216 if (bContortion)
3217 {
3218 if (bVertical)
3219 {
3220 rTarget.Resize(aCenter,aFact1,aFact);
3221 }
3222 else
3223 {
3224 rTarget.Resize(aCenter,aFact,aFact1);
3225 }
3226 }
3227 else
3228 {
3229 Point aCtr0(rTarget.GetSnapRect().Center());
3230 Point aCtr1(aCtr0);
3231
3232 if (bVertical)
3233 {
3234 ResizePoint(aCtr1,aCenter,aFact1,aFact);
3235 }
3236 else
3237 {
3238 ResizePoint(aCtr1,aCenter,aFact,aFact1);
3239 }
3240
3241 Size aSiz(aCtr1.X()-aCtr0.X(),aCtr1.Y()-aCtr0.Y());
3242
3243 rTarget.Move(aSiz);
3244 }
3245 }
3246
3247 if (bDoCrook)
3248 {
3249 const Rectangle aLocalMarkRect(getSdrDragView().GetMarkedObjRect());
3250 const bool bLocalRotate(!bContortion && eMode == SDRCROOK_ROTATE && getSdrDragView().IsRotateAllowed(false));
3251
3252 getSdrDragView().ImpCrookObj(&rTarget,aCenter,aRad,eMode,bVertical,!bContortion,bLocalRotate,aLocalMarkRect);
3253 }
3254 }
3255 }
3256
3257 void SdrDragCrook::applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget)
3258 {
3259 // use helper derived from old stuff
3260 _MovAllPoints(rTarget);
3261 }
3262
3263 bool SdrDragCrook::EndSdrDrag(bool bCopy)
3264 {
3265 Hide();
3266
3267 if (bResize && aFact==Fraction(1,1))
3268 bResize=false;
3269
3270 const bool bUndo = getSdrDragView().IsUndoEnabled();
3271
3272 bool bDoCrook=aCenter!=aMarkCenter && aRad.X()!=0 && aRad.Y()!=0;
3273
3274 if (bDoCrook || bResize)
3275 {
3276 if (bResize && bUndo)
3277 {
3278 XubString aStr;
3279 ImpTakeDescriptionStr(!bContortion?STR_EditCrook:STR_EditCrookContortion,aStr);
3280
3281 if (bCopy)
3282 aStr+=ImpGetResStr(STR_EditWithCopy);
3283
3284 getSdrDragView().BegUndo(aStr);
3285 }
3286
3287 if (bResize)
3288 {
3289 Fraction aFact1(1,1);
3290
3291 if (bContortion)
3292 {
3293 if (bVertical)
3294 getSdrDragView().ResizeMarkedObj(aCenter,aFact1,aFact,bCopy);
3295 else
3296 getSdrDragView().ResizeMarkedObj(aCenter,aFact,aFact1,bCopy);
3297 }
3298 else
3299 {
3300 if (bCopy)
3301 getSdrDragView().CopyMarkedObj();
3302
3303 ULONG nMarkAnz=getSdrDragView().GetMarkedObjectList().GetMarkCount();
3304
3305 for (ULONG nm=0; nm<nMarkAnz; nm++)
3306 {
3307 SdrMark* pM=getSdrDragView().GetMarkedObjectList().GetMark(nm);
3308 SdrObject* pO=pM->GetMarkedSdrObj();
3309 Point aCtr0(pO->GetSnapRect().Center());
3310 Point aCtr1(aCtr0);
3311
3312 if (bVertical)
3313 ResizePoint(aCtr1,aCenter,aFact1,aFact);
3314 else
3315 ResizePoint(aCtr1,aCenter,aFact,aFact1);
3316
3317 Size aSiz(aCtr1.X()-aCtr0.X(),aCtr1.Y()-aCtr0.Y());
3318 if( bUndo )
3319 AddUndo(getSdrDragView().GetModel()->GetSdrUndoFactory().CreateUndoMoveObject(*pO,aSiz));
3320 pO->Move(aSiz);
3321 }
3322 }
3323
3324 bCopy=false;
3325 }
3326
3327 if (bDoCrook)
3328 {
3329 getSdrDragView().CrookMarkedObj(aCenter,aRad,eMode,bVertical,!bContortion,bCopy);
3330 getSdrDragView().SetLastCrookCenter(aCenter);
3331 }
3332
3333 if (bResize && bUndo)
3334 getSdrDragView().EndUndo();
3335
3336 return true;
3337 }
3338
3339 return false;
3340 }
3341
3342 Pointer SdrDragCrook::GetSdrDragPointer() const
3343 {
3344 return Pointer(POINTER_CROOK);
3345 }
3346
3347 ////////////////////////////////////////////////////////////////////////////////////////////////////
3348
3349 TYPEINIT1(SdrDragDistort,SdrDragMethod);
3350
3351 SdrDragDistort::SdrDragDistort(SdrDragView& rNewView)
3352 : SdrDragMethod(rNewView),
3353 nPolyPt(0),
3354 bContortionAllowed(false),
3355 bNoContortionAllowed(false),
3356 bContortion(false)
3357 {
3358 }
3359
3360 void SdrDragDistort::TakeSdrDragComment(XubString& rStr) const
3361 {
3362 ImpTakeDescriptionStr(STR_DragMethDistort, rStr);
3363
3364 XubString aStr;
3365
3366 rStr.AppendAscii(" (x=");
3367 getSdrDragView().GetModel()->TakeMetricStr(DragStat().GetDX(), aStr);
3368 rStr += aStr;
3369 rStr.AppendAscii(" y=");
3370 getSdrDragView().GetModel()->TakeMetricStr(DragStat().GetDY(), aStr);
3371 rStr += aStr;
3372 rStr += sal_Unicode(')');
3373
3374 if(getSdrDragView().IsDragWithCopy())
3375 rStr += ImpGetResStr(STR_EditWithCopy);
3376 }
3377
3378 void SdrDragDistort::createSdrDragEntries()
3379 {
3380 // Add extended frame raster first, so it will be behind objects
3381 if(getSdrDragView().GetSdrPageView())
3382 {
3383 const basegfx::B2DPolyPolygon aDragRaster(impCreateDragRaster(*getSdrDragView().GetSdrPageView(), GetMarkedRect()));
3384
3385 if(aDragRaster.count())
3386 {
3387 addSdrDragEntry(new SdrDragEntryPolyPolygon(aDragRaster));
3388 }
3389 }
3390
3391 // call parent
3392 SdrDragMethod::createSdrDragEntries();
3393 }
3394
3395 bool SdrDragDistort::BeginSdrDrag()
3396 {
3397 bContortionAllowed=getSdrDragView().IsDistortAllowed(false);
3398 bNoContortionAllowed=getSdrDragView().IsDistortAllowed(true);
3399
3400 if (bContortionAllowed || bNoContortionAllowed)
3401 {
3402 SdrHdlKind eKind=GetDragHdlKind();
3403 nPolyPt=0xFFFF;
3404
3405 if (eKind==HDL_UPLFT) nPolyPt=0;
3406 if (eKind==HDL_UPRGT) nPolyPt=1;
3407 if (eKind==HDL_LWRGT) nPolyPt=2;
3408 if (eKind==HDL_LWLFT) nPolyPt=3;
3409 if (nPolyPt>3) return false;
3410
3411 aMarkRect=GetMarkedRect();
3412 aDistortedRect=XPolygon(aMarkRect);
3413 Show();
3414 return true;
3415 }
3416 else
3417 {
3418 return false;
3419 }
3420 }
3421
3422 void SdrDragDistort::_MovAllPoints(basegfx::B2DPolyPolygon& rTarget)
3423 {
3424 if (bContortion)
3425 {
3426 SdrPageView* pPV = getSdrDragView().GetSdrPageView();
3427
3428 if(pPV)
3429 {
3430 if (pPV->HasMarkedObjPageView())
3431 {
3432 basegfx::B2DPolyPolygon aDragPolygon(rTarget);
3433 const basegfx::B2DRange aOriginalRange(aMarkRect.Left(), aMarkRect.Top(), aMarkRect.Right(), aMarkRect.Bottom());
3434 const basegfx::B2DPoint aTopLeft(aDistortedRect[0].X(), aDistortedRect[0].Y());
3435 const basegfx::B2DPoint aTopRight(aDistortedRect[1].X(), aDistortedRect[1].Y());
3436 const basegfx::B2DPoint aBottomLeft(aDistortedRect[3].X(), aDistortedRect[3].Y());
3437 const basegfx::B2DPoint aBottomRight(aDistortedRect[2].X(), aDistortedRect[2].Y());
3438
3439 aDragPolygon = basegfx::tools::distort(aDragPolygon, aOriginalRange, aTopLeft, aTopRight, aBottomLeft, aBottomRight);
3440 rTarget = aDragPolygon;
3441 }
3442 }
3443 }
3444 }
3445
3446 void SdrDragDistort::MoveSdrDrag(const Point& rPnt)
3447 {
3448 if (DragStat().CheckMinMoved(rPnt))
3449 {
3450 Point aPnt(GetSnapPos(rPnt));
3451
3452 if (getSdrDragView().IsOrtho())
3453 OrthoDistance8(DragStat().GetStart(),aPnt,getSdrDragView().IsBigOrtho());
3454
3455 bool bNeuContortion=(bContortionAllowed && !getSdrDragView().IsCrookNoContortion()) || !bNoContortionAllowed;
3456
3457 if (bNeuContortion!=bContortion || aDistortedRect[nPolyPt]!=aPnt)
3458 {
3459 Hide();
3460 aDistortedRect[nPolyPt]=aPnt;
3461 bContortion=bNeuContortion;
3462 DragStat().NextMove(aPnt);
3463 Show();
3464 }
3465 }
3466 }
3467
3468 bool SdrDragDistort::EndSdrDrag(bool bCopy)
3469 {
3470 Hide();
3471 bool bDoDistort=DragStat().GetDX()!=0 || DragStat().GetDY()!=0;
3472
3473 if (bDoDistort)
3474 {
3475 getSdrDragView().DistortMarkedObj(aMarkRect,aDistortedRect,!bContortion,bCopy);
3476 return true;
3477 }
3478
3479 return false;
3480 }
3481
3482 Pointer SdrDragDistort::GetSdrDragPointer() const
3483 {
3484 return Pointer(POINTER_REFHAND);
3485 }
3486
3487 void SdrDragDistort::applyCurrentTransformationToSdrObject(SdrObject& rTarget)
3488 {
3489 const bool bDoDistort(DragStat().GetDX()!=0 || DragStat().GetDY()!=0);
3490
3491 if (bDoDistort)
3492 {
3493 getSdrDragView().ImpDistortObj(&rTarget, aMarkRect, aDistortedRect, !bContortion);
3494 }
3495 }
3496
3497 void SdrDragDistort::applyCurrentTransformationToPolyPolygon(basegfx::B2DPolyPolygon& rTarget)
3498 {
3499 // use helper derived from old stuff
3500 _MovAllPoints(rTarget);
3501 }
3502
3503 ////////////////////////////////////////////////////////////////////////////////////////////////////
3504
3505 TYPEINIT1(SdrDragCrop,SdrDragResize);
3506
3507 SdrDragCrop::SdrDragCrop(SdrDragView& rNewView)
3508 : SdrDragResize(rNewView)
3509 {
3510 // switch off solid dragging for crop; it just makes no sense since showing
3511 // a 50% transparent object above the original will not be visible
3512 setSolidDraggingActive(false);
3513 }
3514
3515 void SdrDragCrop::TakeSdrDragComment(XubString& rStr) const
3516 {
3517 ImpTakeDescriptionStr(STR_DragMethCrop, rStr);
3518
3519 XubString aStr;
3520
3521 rStr.AppendAscii(" (x=");
3522 getSdrDragView().GetModel()->TakeMetricStr(DragStat().GetDX(), aStr);
3523 rStr += aStr;
3524 rStr.AppendAscii(" y=");
3525 getSdrDragView().GetModel()->TakeMetricStr(DragStat().GetDY(), aStr);
3526 rStr += aStr;
3527 rStr += sal_Unicode(')');
3528
3529 if(getSdrDragView().IsDragWithCopy())
3530 rStr += ImpGetResStr(STR_EditWithCopy);
3531 }
3532
3533 bool SdrDragCrop::EndSdrDrag(bool bCopy)
3534 {
3535 Hide();
3536
3537 if( DragStat().GetDX()==0 && DragStat().GetDY()==0 )
3538 return false;
3539
3540 const SdrMarkList& rMarkList = getSdrDragView().GetMarkedObjectList();
3541
3542 if( rMarkList.GetMarkCount() != 1 )
3543 return false;
3544
3545 SdrGrafObj* pObj = dynamic_cast<SdrGrafObj*>( rMarkList.GetMark( 0 )->GetMarkedSdrObj() );
3546
3547 if( !pObj || (pObj->GetGraphicType() == GRAPHIC_NONE) || (pObj->GetGraphicType() == GRAPHIC_DEFAULT) )
3548 return false;
3549
3550 const GraphicObject& rGraphicObject = pObj->GetGraphicObject();
3551 const MapMode aMapMode100thmm(MAP_100TH_MM);
3552 Size aGraphicSize(rGraphicObject.GetPrefSize());
3553
3554 if( MAP_PIXEL == rGraphicObject.GetPrefMapMode().GetMapUnit() )
3555 aGraphicSize = Application::GetDefaultDevice()->PixelToLogic( aGraphicSize, aMapMode100thmm );
3556 else
3557 aGraphicSize = Application::GetDefaultDevice()->LogicToLogic( aGraphicSize, rGraphicObject.GetPrefMapMode(), aMapMode100thmm);
3558
3559 if( aGraphicSize.nA == 0 || aGraphicSize.nB == 0 )
3560 return false;
3561
3562 const SdrGrafCropItem& rOldCrop = (const SdrGrafCropItem&)pObj->GetMergedItem(SDRATTR_GRAFCROP);
3563
3564 const bool bUndo = getSdrDragView().IsUndoEnabled();
3565
3566 if( bUndo )
3567 {
3568 String aUndoStr;
3569 ImpTakeDescriptionStr(STR_DragMethCrop, aUndoStr);
3570
3571 getSdrDragView().BegUndo( aUndoStr );
3572 getSdrDragView().AddUndo( getSdrDragView().GetModel()->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
3573 }
3574
3575 Rectangle aOldRect( pObj->GetLogicRect() );
3576 getSdrDragView().ResizeMarkedObj(DragStat().Ref1(),aXFact,aYFact,bCopy);
3577 Rectangle aNewRect( pObj->GetLogicRect() );
3578
3579 double fScaleX = ( aGraphicSize.Width() - rOldCrop.GetLeft() - rOldCrop.GetRight() ) / (double)aOldRect.GetWidth();
3580 double fScaleY = ( aGraphicSize.Height() - rOldCrop.GetTop() - rOldCrop.GetBottom() ) / (double)aOldRect.GetHeight();
3581
3582 sal_Int32 nDiffLeft = aNewRect.nLeft - aOldRect.nLeft;
3583 sal_Int32 nDiffTop = aNewRect.nTop - aOldRect.nTop;
3584 sal_Int32 nDiffRight = aNewRect.nRight - aOldRect.nRight;
3585 sal_Int32 nDiffBottom = aNewRect.nBottom - aOldRect.nBottom;
3586
3587 sal_Int32 nLeftCrop = static_cast<sal_Int32>( rOldCrop.GetLeft() + nDiffLeft * fScaleX );
3588 sal_Int32 nTopCrop = static_cast<sal_Int32>( rOldCrop.GetTop() + nDiffTop * fScaleY );
3589 sal_Int32 nRightCrop = static_cast<sal_Int32>( rOldCrop.GetRight() - nDiffRight * fScaleX );
3590 sal_Int32 nBottomCrop = static_cast<sal_Int32>( rOldCrop.GetBottom() - nDiffBottom * fScaleY );
3591
3592 SfxItemPool& rPool = getSdrDragView().GetModel()->GetItemPool();
3593 SfxItemSet aSet( rPool, SDRATTR_GRAFCROP, SDRATTR_GRAFCROP );
3594 aSet.Put( SdrGrafCropItem( nLeftCrop, nTopCrop, nRightCrop, nBottomCrop ) );
3595 getSdrDragView().SetAttributes( aSet, false );
3596
3597 if( bUndo )
3598 getSdrDragView().EndUndo();
3599
3600 return true;
3601 }
3602
3603 Pointer SdrDragCrop::GetSdrDragPointer() const
3604 {
3605 return Pointer(POINTER_CROP);
3606 }
3607
3608 ////////////////////////////////////////////////////////////////////////////////////////////////////
3609 // eof
vba interoperability for OOo