Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <svx/svddrgv.hxx>
22 : #include <svx/svdview.hxx>
23 : #include "svx/xattr.hxx"
24 : #include <svx/xpoly.hxx>
25 : #include <svx/svdetc.hxx>
26 : #include <svx/svdtrans.hxx>
27 : #include <svx/svdundo.hxx>
28 : #include <svx/svdocapt.hxx>
29 : #include <svx/svdpagv.hxx>
30 : #include <svx/svdopath.hxx>
31 : #include <svx/svdoedge.hxx>
32 : #include "svx/svdstr.hrc"
33 : #include "svdglob.hxx"
34 : #include "svddrgm1.hxx"
35 : #include <svx/obj3d.hxx>
36 : #include <svx/svdoashp.hxx>
37 : #include <svx/sdrpaintwindow.hxx>
38 : #include <basegfx/polygon/b2dpolypolygontools.hxx>
39 : #include <basegfx/polygon/b2dpolygontools.hxx>
40 : #include <svx/polypolygoneditor.hxx>
41 : #include <basegfx/matrix/b2dhommatrix.hxx>
42 : #include <svx/sdr/overlay/overlaymanager.hxx>
43 :
44 : using namespace sdr;
45 :
46 :
47 :
48 : // DragView
49 :
50 :
51 :
52 9504 : void SdrDragView::ImpClearVars()
53 : {
54 9504 : mbFramDrag=false;
55 9504 : eDragMode=SDRDRAG_MOVE;
56 9504 : mbDragLimit=false;
57 9504 : mbMarkedHitMovesAlways=false;
58 9504 : meDragHdl=HDL_MOVE;
59 9504 : mpDragHdl=NULL;
60 9504 : mbDragHdl=false;
61 9504 : mbDragSpecial=false;
62 9504 : mpCurrentSdrDragMethod=NULL;
63 9504 : mbDragStripes=false;
64 9504 : mbMirrRefDragObj=true;
65 9504 : mbDragWithCopy=false;
66 9504 : mpInsPointUndo=NULL;
67 9504 : mbInsGluePoint=false;
68 9504 : mbInsObjPointMode=false;
69 9504 : mbInsGluePointMode=false;
70 9504 : mnDragXorPolyLimit=100;
71 9504 : mnDragXorPointLimit=500;
72 9504 : mbNoDragXorPolys=false;
73 9504 : mbAutoVertexCon=true;
74 9504 : mbAutoCornerCon=false;
75 9504 : mbRubberEdgeDragging=true;
76 9504 : mbDetailedEdgeDragging=true;
77 9504 : mnDetailedEdgeDraggingLimit=10;
78 9504 : mbResizeAtCenter=false;
79 9504 : mbCrookAtCenter=false;
80 9504 : mbMouseHideWhileDraggingPoints=false;
81 :
82 : // init using default
83 9504 : mbSolidDragging = getOptionsDrawinglayer().IsSolidDragCreate();
84 9504 : }
85 :
86 9504 : SdrDragView::SdrDragView(SdrModel* pModel1, OutputDevice* pOut)
87 9504 : : SdrExchangeView(pModel1,pOut)
88 : {
89 9504 : ImpClearVars();
90 9504 : }
91 :
92 9438 : SdrDragView::~SdrDragView()
93 : {
94 9438 : }
95 :
96 1894 : bool SdrDragView::IsAction() const
97 : {
98 1894 : return (mpCurrentSdrDragMethod || SdrExchangeView::IsAction());
99 : }
100 :
101 2 : void SdrDragView::MovAction(const Point& rPnt)
102 : {
103 2 : SdrExchangeView::MovAction(rPnt);
104 2 : if (mpCurrentSdrDragMethod)
105 : {
106 2 : MovDragObj(rPnt);
107 : }
108 2 : }
109 :
110 0 : void SdrDragView::EndAction()
111 : {
112 0 : if (mpCurrentSdrDragMethod)
113 : {
114 0 : EndDragObj(false);
115 : }
116 0 : SdrExchangeView::EndAction();
117 0 : }
118 :
119 0 : void SdrDragView::BckAction()
120 : {
121 0 : SdrExchangeView::BckAction();
122 0 : BrkDragObj();
123 0 : }
124 :
125 5984 : void SdrDragView::BrkAction()
126 : {
127 5984 : SdrExchangeView::BrkAction();
128 5984 : BrkDragObj();
129 5984 : }
130 :
131 9 : void SdrDragView::TakeActionRect(Rectangle& rRect) const
132 : {
133 9 : if (mpCurrentSdrDragMethod)
134 : {
135 9 : rRect=aDragStat.GetActionRect();
136 9 : if (rRect.IsEmpty())
137 : {
138 9 : SdrPageView* pPV = GetSdrPageView();
139 :
140 9 : if(pPV&& pPV->HasMarkedObjPageView())
141 : {
142 : // #i95646# is this used..?
143 9 : const basegfx::B2DRange aBoundRange(mpCurrentSdrDragMethod->getCurrentRange());
144 9 : if (aBoundRange.isEmpty())
145 : {
146 4 : rRect.SetEmpty();
147 : }
148 : else
149 : {
150 : rRect = Rectangle(
151 10 : basegfx::fround(aBoundRange.getMinX()), basegfx::fround(aBoundRange.getMinY()),
152 15 : basegfx::fround(aBoundRange.getMaxX()), basegfx::fround(aBoundRange.getMaxY()));
153 : }
154 : }
155 : }
156 9 : if (rRect.IsEmpty())
157 : {
158 4 : rRect=Rectangle(aDragStat.GetNow(),aDragStat.GetNow());
159 : }
160 : }
161 : else
162 : {
163 0 : SdrExchangeView::TakeActionRect(rRect);
164 : }
165 9 : }
166 :
167 1 : bool SdrDragView::TakeDragObjAnchorPos(Point& rPos, bool bTR ) const
168 : {
169 1 : Rectangle aR;
170 1 : TakeActionRect(aR);
171 1 : rPos = bTR ? aR.TopRight() : aR.TopLeft();
172 4 : if (GetMarkedObjectCount()==1 && IsDragObj() && // only on single selection
173 4 : !IsDraggingPoints() && !IsDraggingGluePoints() && // not when moving points
174 1 : !mpCurrentSdrDragMethod->ISA(SdrDragMovHdl)) // not when moving handles
175 : {
176 1 : SdrObject* pObj=GetMarkedObjectByIndex(0);
177 1 : if (pObj->ISA(SdrCaptionObj))
178 : {
179 0 : Point aPt(static_cast<SdrCaptionObj*>(pObj)->GetTailPos());
180 0 : bool bTail=meDragHdl==HDL_POLY; // drag tail
181 0 : bool bOwn=mpCurrentSdrDragMethod->ISA(SdrDragObjOwn); // specific to object
182 0 : if (!bTail)
183 : { // for bTail, TakeActionRect already does the right thing
184 0 : if (bOwn)
185 : { // bOwn may be MoveTextFrame, ResizeTextFrame, but may not (any more) be DragTail
186 0 : rPos=aPt;
187 : }
188 : else
189 : {
190 : // drag the whole Object (Move, Resize, ...)
191 0 : const basegfx::B2DPoint aTransformed(mpCurrentSdrDragMethod->getCurrentTransformation() * basegfx::B2DPoint(aPt.X(), aPt.Y()));
192 0 : rPos.X() = basegfx::fround(aTransformed.getX());
193 0 : rPos.Y() = basegfx::fround(aTransformed.getY());
194 : }
195 : }
196 : }
197 1 : return true;
198 : }
199 0 : return false;
200 : }
201 :
202 :
203 :
204 1 : bool SdrDragView::TakeDragLimit(SdrDragMode /*eMode*/, Rectangle& /*rRect*/) const
205 : {
206 1 : return false;
207 : }
208 :
209 2 : bool SdrDragView::BegDragObj(const Point& rPnt, OutputDevice* pOut, SdrHdl* pHdl, short nMinMov, SdrDragMethod* pForcedMeth)
210 : {
211 2 : BrkAction();
212 :
213 2 : bool bRet=false;
214 : {
215 2 : SetDragWithCopy(false);
216 : //TODO: aAni.Reset();
217 2 : mpCurrentSdrDragMethod=NULL;
218 2 : mbDragSpecial=false;
219 2 : mbDragLimit=false;
220 2 : SdrDragMode eTmpMode=eDragMode;
221 2 : if (eTmpMode==SDRDRAG_MOVE && pHdl!=NULL && pHdl->GetKind()!=HDL_MOVE) {
222 2 : eTmpMode=SDRDRAG_RESIZE;
223 : }
224 2 : mbDragLimit=TakeDragLimit(eTmpMode,maDragLimit);
225 2 : mbFramDrag=ImpIsFrameHandles();
226 6 : if (!mbFramDrag &&
227 4 : (pMarkedObj==NULL || !pMarkedObj->hasSpecialDrag()) &&
228 0 : (pHdl==NULL || pHdl->GetObj()==NULL)) {
229 0 : mbFramDrag=true;
230 : }
231 :
232 2 : Point aPnt(rPnt);
233 2 : if(pHdl == NULL
234 2 : || pHdl->GetKind() == HDL_MOVE
235 2 : || pHdl->GetKind() == HDL_MIRX
236 2 : || pHdl->GetKind() == HDL_TRNS
237 4 : || pHdl->GetKind() == HDL_GRAD)
238 : {
239 0 : aDragStat.Reset(aPnt);
240 : }
241 : else
242 : {
243 2 : aDragStat.Reset(pHdl->GetPos());
244 : }
245 :
246 2 : aDragStat.SetView(static_cast<SdrView*>(this));
247 2 : aDragStat.SetPageView(pMarkedPV); // <<-- DragPV has to go here!!!
248 2 : aDragStat.SetMinMove(ImpGetMinMovLogic(nMinMov,pOut));
249 2 : aDragStat.SetHdl(pHdl);
250 2 : aDragStat.NextPoint();
251 2 : pDragWin=pOut;
252 2 : mpDragHdl=pHdl;
253 2 : meDragHdl= pHdl==NULL ? HDL_MOVE : pHdl->GetKind();
254 2 : mbDragHdl=meDragHdl==HDL_REF1 || meDragHdl==HDL_REF2 || meDragHdl==HDL_MIRX;
255 :
256 : // Expand test for HDL_ANCHOR_TR
257 2 : bool bNotDraggable = (HDL_ANCHOR == meDragHdl || HDL_ANCHOR_TR == meDragHdl);
258 :
259 2 : if(pHdl && (pHdl->GetKind() == HDL_SMARTTAG) && pForcedMeth )
260 : {
261 : // just use the forced method for smart tags
262 : }
263 2 : else if(mbDragHdl)
264 : {
265 0 : mpCurrentSdrDragMethod = new SdrDragMovHdl(*this);
266 : }
267 2 : else if(!bNotDraggable)
268 : {
269 2 : switch (eDragMode)
270 : {
271 : case SDRDRAG_ROTATE: case SDRDRAG_SHEAR: case SDRDRAG_DISTORT:
272 : {
273 0 : switch (meDragHdl)
274 : {
275 : case HDL_LEFT: case HDL_RIGHT:
276 : case HDL_UPPER: case HDL_LOWER:
277 : {
278 : // are 3D objects selected?
279 0 : bool b3DObjSelected = false;
280 0 : for(size_t a=0; !b3DObjSelected && a<GetMarkedObjectCount(); ++a)
281 : {
282 0 : SdrObject* pObj = GetMarkedObjectByIndex(a);
283 0 : if(pObj && pObj->ISA(E3dObject))
284 0 : b3DObjSelected = true;
285 : }
286 : // If yes, allow shear even when !IsShearAllowed,
287 : // because 3D objects are limited rotations
288 0 : if (!b3DObjSelected && !IsShearAllowed())
289 0 : return false;
290 0 : mpCurrentSdrDragMethod = new SdrDragShear(*this,eDragMode==SDRDRAG_ROTATE);
291 0 : } break;
292 : case HDL_UPLFT: case HDL_UPRGT:
293 : case HDL_LWLFT: case HDL_LWRGT:
294 : {
295 0 : if (eDragMode==SDRDRAG_SHEAR || eDragMode==SDRDRAG_DISTORT)
296 : {
297 0 : if (!IsDistortAllowed(true) && !IsDistortAllowed(false)) return false;
298 0 : mpCurrentSdrDragMethod = new SdrDragDistort(*this);
299 : }
300 : else
301 : {
302 0 : if (!IsRotateAllowed(true)) return false;
303 0 : mpCurrentSdrDragMethod = new SdrDragRotate(*this);
304 : }
305 0 : } break;
306 : default:
307 : {
308 0 : if (IsMarkedHitMovesAlways() && meDragHdl==HDL_MOVE)
309 : { // HDL_MOVE is true, even if Obj is hit directly
310 0 : if (!IsMoveAllowed()) return false;
311 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
312 : }
313 : else
314 : {
315 0 : if (!IsRotateAllowed(true)) return false;
316 0 : mpCurrentSdrDragMethod = new SdrDragRotate(*this);
317 : }
318 : }
319 : }
320 0 : } break;
321 : case SDRDRAG_MIRROR:
322 : {
323 0 : if (meDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
324 : {
325 0 : if (!IsMoveAllowed()) return false;
326 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
327 : }
328 : else
329 : {
330 0 : if (!IsMirrorAllowed(true,true)) return false;
331 0 : mpCurrentSdrDragMethod = new SdrDragMirror(*this);
332 : }
333 0 : } break;
334 :
335 : case SDRDRAG_CROP:
336 : {
337 0 : if (meDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
338 : {
339 0 : if (!IsMoveAllowed())
340 0 : return false;
341 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
342 : }
343 : else
344 : {
345 0 : if (!IsCropAllowed())
346 0 : return false;
347 0 : mpCurrentSdrDragMethod = new SdrDragCrop(*this);
348 : }
349 : }
350 0 : break;
351 :
352 : case SDRDRAG_TRANSPARENCE:
353 : {
354 0 : if(meDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
355 : {
356 0 : if(!IsMoveAllowed())
357 0 : return false;
358 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
359 : }
360 : else
361 : {
362 0 : if(!IsTransparenceAllowed())
363 0 : return false;
364 :
365 0 : mpCurrentSdrDragMethod = new SdrDragGradient(*this, false);
366 : }
367 0 : break;
368 : }
369 : case SDRDRAG_GRADIENT:
370 : {
371 0 : if(meDragHdl == HDL_MOVE && IsMarkedHitMovesAlways())
372 : {
373 0 : if(!IsMoveAllowed())
374 0 : return false;
375 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
376 : }
377 : else
378 : {
379 0 : if(!IsGradientAllowed())
380 0 : return false;
381 :
382 0 : mpCurrentSdrDragMethod = new SdrDragGradient(*this);
383 : }
384 0 : break;
385 : }
386 :
387 : case SDRDRAG_CROOK :
388 : {
389 0 : if (meDragHdl==HDL_MOVE && IsMarkedHitMovesAlways())
390 : {
391 0 : if (!IsMoveAllowed()) return false;
392 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
393 : }
394 : else
395 : {
396 0 : if (!IsCrookAllowed(true) && !IsCrookAllowed(false)) return false;
397 0 : mpCurrentSdrDragMethod = new SdrDragCrook(*this);
398 : }
399 0 : } break;
400 :
401 : default:
402 : {
403 : // SDRDRAG_MOVE
404 2 : if((meDragHdl == HDL_MOVE) && !IsMoveAllowed())
405 : {
406 0 : return false;
407 : }
408 2 : else if(meDragHdl == HDL_GLUE)
409 : {
410 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
411 : }
412 : else
413 : {
414 2 : if(mbFramDrag)
415 : {
416 0 : if(meDragHdl == HDL_MOVE)
417 : {
418 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
419 : }
420 : else
421 : {
422 0 : if(!IsResizeAllowed(true))
423 : {
424 0 : return false;
425 : }
426 :
427 0 : bool bSingleTextObjMark = false; // SJ: #i100490#
428 0 : if ( GetMarkedObjectCount() == 1 )
429 : {
430 0 : pMarkedObj=GetMarkedObjectByIndex(0);
431 0 : if ( pMarkedObj &&
432 0 : pMarkedObj->ISA( SdrTextObj ) &&
433 0 : static_cast<SdrTextObj*>(pMarkedObj)->IsTextFrame() )
434 0 : bSingleTextObjMark = true;
435 : }
436 0 : if ( bSingleTextObjMark )
437 0 : mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
438 : else
439 0 : mpCurrentSdrDragMethod = new SdrDragResize(*this);
440 : }
441 : }
442 : else
443 : {
444 2 : if(HDL_MOVE == meDragHdl)
445 : {
446 0 : const bool bCustomShapeSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrObjCustomShape));
447 :
448 0 : if(bCustomShapeSelected)
449 : {
450 0 : mpCurrentSdrDragMethod = new SdrDragMove( *this );
451 : }
452 : }
453 2 : else if(HDL_POLY == meDragHdl)
454 : {
455 0 : const bool bConnectorSelected(1 == GetMarkedObjectCount() && GetMarkedObjectByIndex(0)->ISA(SdrEdgeObj));
456 :
457 0 : if(bConnectorSelected)
458 : {
459 : // #i97784#
460 : // fallback to old behaviour for connectors (see
461 : // text in task description for more details)
462 : }
463 0 : else if(!IsMoveAllowed() || !IsResizeAllowed())
464 : {
465 : // #i77187#
466 : // do not allow move of polygon points if object is move or size protected
467 0 : return false;
468 : }
469 : }
470 :
471 2 : if(!mpCurrentSdrDragMethod)
472 : {
473 : // fallback to DragSpecial if no interaction defined
474 2 : mbDragSpecial = true;
475 2 : mpCurrentSdrDragMethod = new SdrDragObjOwn(*this);
476 : }
477 : }
478 : }
479 : }
480 : }
481 : }
482 2 : if (pForcedMeth!=NULL)
483 : {
484 0 : delete mpCurrentSdrDragMethod;
485 0 : mpCurrentSdrDragMethod = pForcedMeth;
486 : }
487 2 : aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
488 2 : if (mpCurrentSdrDragMethod)
489 : {
490 2 : bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
491 2 : if (!bRet)
492 : {
493 0 : if (pHdl==NULL && IS_TYPE(SdrDragObjOwn,mpCurrentSdrDragMethod))
494 : {
495 : // Obj may not Move SpecialDrag, so try with MoveFrameDrag
496 0 : delete mpCurrentSdrDragMethod;
497 0 : mpCurrentSdrDragMethod = 0;
498 0 : mbDragSpecial=false;
499 :
500 0 : if (!IsMoveAllowed())
501 0 : return false;
502 :
503 0 : mbFramDrag=true;
504 0 : mpCurrentSdrDragMethod = new SdrDragMove(*this);
505 0 : aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
506 0 : bRet = mpCurrentSdrDragMethod->BeginSdrDrag();
507 : }
508 : }
509 2 : if (!bRet)
510 : {
511 0 : delete mpCurrentSdrDragMethod;
512 0 : mpCurrentSdrDragMethod = 0;
513 0 : aDragStat.SetDragMethod(mpCurrentSdrDragMethod);
514 : }
515 : }
516 : }
517 :
518 2 : return bRet;
519 : }
520 :
521 3 : void SdrDragView::MovDragObj(const Point& rPnt)
522 : {
523 3 : if (mpCurrentSdrDragMethod)
524 : {
525 3 : Point aPnt(rPnt);
526 3 : ImpLimitToWorkArea(aPnt);
527 3 : mpCurrentSdrDragMethod->MoveSdrDrag(aPnt); // this call already makes a Hide()/Show combination
528 : }
529 3 : }
530 :
531 2 : bool SdrDragView::EndDragObj(bool bCopy)
532 : {
533 2 : bool bRet(false);
534 :
535 : // #i73341# If inserting GluePoint, do not insist on last points being different
536 2 : if(mpCurrentSdrDragMethod && aDragStat.IsMinMoved() && (IsInsertGluePoint() || aDragStat.GetNow() != aDragStat.GetPrev()))
537 : {
538 2 : sal_uIntPtr nHdlAnzMerk=0;
539 :
540 2 : if (bEliminatePolyPoints)
541 : { // IBM Special
542 0 : nHdlAnzMerk=GetMarkablePointCount();
543 : }
544 :
545 2 : const bool bUndo = IsUndoEnabled();
546 2 : if (IsInsertGluePoint() && bUndo)
547 : {
548 0 : BegUndo(maInsPointUndoStr);
549 0 : AddUndo(mpInsPointUndo);
550 : }
551 :
552 2 : bRet = mpCurrentSdrDragMethod->EndSdrDrag(bCopy);
553 :
554 2 : if( IsInsertGluePoint() && bUndo)
555 0 : EndUndo();
556 :
557 2 : delete mpCurrentSdrDragMethod;
558 2 : mpCurrentSdrDragMethod = 0;
559 :
560 2 : if (bEliminatePolyPoints)
561 : { // IBM Special
562 0 : if (nHdlAnzMerk!=GetMarkablePointCount())
563 : {
564 0 : UnmarkAllPoints();
565 : }
566 : }
567 :
568 2 : if (bInsPolyPoint)
569 : {
570 0 : SetMarkHandles();
571 0 : bInsPolyPoint=false;
572 0 : if( bUndo )
573 : {
574 0 : BegUndo(maInsPointUndoStr);
575 0 : AddUndo(mpInsPointUndo);
576 0 : EndUndo();
577 : }
578 : }
579 :
580 2 : meDragHdl=HDL_MOVE;
581 2 : mpDragHdl=NULL;
582 :
583 2 : if (!bSomeObjChgdFlag)
584 : {
585 : // Obj did not broadcast (e. g. Writer FlyFrames)
586 0 : if(!mbDragHdl)
587 : {
588 0 : AdjustMarkHdl();
589 : }
590 : }
591 : }
592 : else
593 : {
594 0 : BrkDragObj();
595 : }
596 :
597 2 : bInsPolyPoint=false;
598 2 : SetInsertGluePoint(false);
599 :
600 2 : return bRet;
601 : }
602 :
603 5984 : void SdrDragView::BrkDragObj()
604 : {
605 5984 : if (mpCurrentSdrDragMethod)
606 : {
607 0 : mpCurrentSdrDragMethod->CancelSdrDrag();
608 :
609 0 : delete mpCurrentSdrDragMethod;
610 0 : mpCurrentSdrDragMethod = 0;
611 :
612 0 : if (bInsPolyPoint)
613 : {
614 0 : mpInsPointUndo->Undo(); // delete inserted point again
615 0 : delete mpInsPointUndo;
616 0 : mpInsPointUndo=NULL;
617 0 : SetMarkHandles();
618 0 : bInsPolyPoint=false;
619 : }
620 :
621 0 : if (IsInsertGluePoint())
622 : {
623 0 : mpInsPointUndo->Undo(); // delete inserted glue point again
624 0 : delete mpInsPointUndo;
625 0 : mpInsPointUndo=NULL;
626 0 : SetInsertGluePoint(false);
627 : }
628 :
629 0 : meDragHdl=HDL_MOVE;
630 0 : mpDragHdl=NULL;
631 : }
632 5984 : }
633 :
634 0 : bool SdrDragView::IsInsObjPointPossible() const
635 : {
636 0 : return pMarkedObj!=NULL && pMarkedObj->IsPolyObj();
637 : }
638 :
639 0 : bool SdrDragView::ImpBegInsObjPoint(bool bIdxZwang, sal_uInt32 nIdx, const Point& rPnt, bool bNewObj, OutputDevice* pOut)
640 : {
641 0 : bool bRet(false);
642 :
643 0 : if(pMarkedObj && pMarkedObj->ISA(SdrPathObj))
644 : {
645 0 : SdrPathObj* pMarkedPath = static_cast<SdrPathObj*>(pMarkedObj);
646 0 : BrkAction();
647 0 : mpInsPointUndo = dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pMarkedObj) );
648 : DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
649 :
650 0 : OUString aStr(ImpGetResStr(STR_DragInsertPoint));
651 :
652 0 : maInsPointUndoStr = aStr.replaceFirst("%1", pMarkedObj->TakeObjNameSingul() );
653 :
654 0 : Point aPt(rPnt);
655 :
656 0 : if(bNewObj)
657 0 : aPt = GetSnapPos(aPt,pMarkedPV);
658 :
659 0 : bool bClosed0 = pMarkedPath->IsClosedObj();
660 :
661 0 : if(bIdxZwang)
662 : {
663 0 : mnInsPointNum = pMarkedPath->NbcInsPoint(nIdx, aPt, bNewObj, true);
664 : }
665 : else
666 : {
667 0 : mnInsPointNum = pMarkedPath->NbcInsPointOld(aPt, bNewObj, true);
668 : }
669 :
670 0 : if(bClosed0 != pMarkedPath->IsClosedObj())
671 : {
672 : // Obj was closed implicitly
673 : // object changed
674 0 : pMarkedPath->SetChanged();
675 0 : pMarkedPath->BroadcastObjectChange();
676 : }
677 :
678 0 : if(0xffffffff != mnInsPointNum)
679 : {
680 0 : bInsPolyPoint = true;
681 0 : UnmarkAllPoints();
682 0 : AdjustMarkHdl();
683 :
684 0 : bRet = BegDragObj(rPnt, pOut, maHdlList.GetHdl(mnInsPointNum), 0);
685 :
686 0 : if (bRet)
687 : {
688 0 : aDragStat.SetMinMoved();
689 0 : MovDragObj(rPnt);
690 : }
691 : }
692 : else
693 : {
694 0 : delete mpInsPointUndo;
695 0 : mpInsPointUndo = NULL;
696 0 : }
697 : }
698 :
699 0 : return bRet;
700 : }
701 :
702 0 : bool SdrDragView::EndInsObjPoint(SdrCreateCmd eCmd)
703 : {
704 0 : if(IsInsObjPoint())
705 : {
706 0 : sal_uInt32 nNextPnt(mnInsPointNum);
707 0 : Point aPnt(aDragStat.GetNow());
708 0 : bool bOk=EndDragObj(false);
709 0 : if (bOk && eCmd!=SDRCREATE_FORCEEND)
710 : {
711 : // Ret=True means: Action is over.
712 0 : bOk=!(ImpBegInsObjPoint(true, nNextPnt, aPnt, eCmd == SDRCREATE_NEXTOBJECT, pDragWin));
713 : }
714 :
715 0 : return bOk;
716 0 : } else return false;
717 : }
718 :
719 0 : bool SdrDragView::IsInsGluePointPossible() const
720 : {
721 0 : bool bRet=false;
722 0 : if (IsInsGluePointMode() && AreObjectsMarked())
723 : {
724 0 : if (GetMarkedObjectCount()==1)
725 : {
726 : // return sal_False, if only 1 object which is a connector.
727 0 : const SdrObject* pObj=GetMarkedObjectByIndex(0);
728 0 : if (!HAS_BASE(SdrEdgeObj,pObj))
729 : {
730 0 : bRet=true;
731 : }
732 : }
733 : else
734 : {
735 0 : bRet=true;
736 : }
737 : }
738 0 : return bRet;
739 : }
740 :
741 0 : bool SdrDragView::BegInsGluePoint(const Point& rPnt)
742 : {
743 0 : bool bRet=false;
744 : SdrObject* pObj;
745 : SdrPageView* pPV;
746 0 : if (PickMarkedObj(rPnt,pObj,pPV,SdrSearchOptions::PASS2BOUND))
747 : {
748 0 : BrkAction();
749 0 : UnmarkAllGluePoints();
750 0 : mpInsPointUndo= dynamic_cast< SdrUndoGeoObj* >( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj) );
751 : DBG_ASSERT( mpInsPointUndo, "svx::SdrDragView::BegInsObjPoint(), could not create correct undo object!" );
752 0 : OUString aStr(ImpGetResStr(STR_DragInsertGluePoint));
753 :
754 0 : maInsPointUndoStr = aStr.replaceFirst("%1", pObj->TakeObjNameSingul() );
755 :
756 0 : SdrGluePointList* pGPL=pObj->ForceGluePointList();
757 0 : if (pGPL!=NULL)
758 : {
759 0 : sal_uInt16 nGlueIdx=pGPL->Insert(SdrGluePoint());
760 0 : SdrGluePoint& rGP=(*pGPL)[nGlueIdx];
761 0 : sal_uInt16 nGlueId=rGP.GetId();
762 0 : rGP.SetAbsolutePos(rPnt,*pObj);
763 :
764 0 : SdrHdl* pHdl=NULL;
765 0 : if (MarkGluePoint(pObj,nGlueId,pPV))
766 : {
767 0 : pHdl=GetGluePointHdl(pObj,nGlueId);
768 : }
769 0 : if (pHdl!=NULL && pHdl->GetKind()==HDL_GLUE && pHdl->GetObj()==pObj && pHdl->GetObjHdlNum()==nGlueId)
770 : {
771 0 : SetInsertGluePoint(true);
772 0 : bRet=BegDragObj(rPnt,NULL,pHdl,0);
773 0 : if (bRet)
774 : {
775 0 : aDragStat.SetMinMoved();
776 0 : MovDragObj(rPnt);
777 : }
778 : else
779 : {
780 0 : SetInsertGluePoint(false);
781 0 : delete mpInsPointUndo;
782 0 : mpInsPointUndo=NULL;
783 : }
784 : }
785 : else
786 : {
787 : OSL_FAIL("BegInsGluePoint(): GluePoint handle not found.");
788 : }
789 : }
790 : else
791 : {
792 : // no glue points possible for this object (e. g. Edge)
793 0 : SetInsertGluePoint(false);
794 0 : delete mpInsPointUndo;
795 0 : mpInsPointUndo=NULL;
796 0 : }
797 : }
798 :
799 0 : return bRet;
800 : }
801 :
802 2 : void SdrDragView::ShowDragObj()
803 : {
804 2 : if(mpCurrentSdrDragMethod && !aDragStat.IsShown())
805 : {
806 4 : for(sal_uInt32 a(0); a < PaintWindowCount(); a++)
807 : {
808 2 : SdrPaintWindow* pCandidate = GetPaintWindow(a);
809 2 : rtl::Reference<sdr::overlay::OverlayManager> xOverlayManager = pCandidate->GetOverlayManager();
810 :
811 2 : if (xOverlayManager.is())
812 : {
813 2 : mpCurrentSdrDragMethod->CreateOverlayGeometry(*xOverlayManager);
814 :
815 : // #i101679# Force changed overlay to be shown
816 2 : xOverlayManager->flush();
817 : }
818 2 : }
819 :
820 2 : aDragStat.SetShown(true);
821 : }
822 2 : }
823 :
824 4 : void SdrDragView::HideDragObj()
825 : {
826 4 : if(mpCurrentSdrDragMethod && aDragStat.IsShown())
827 : {
828 2 : mpCurrentSdrDragMethod->destroyOverlayGeometry();
829 2 : aDragStat.SetShown(false);
830 : }
831 4 : }
832 :
833 :
834 :
835 1788 : void SdrDragView::SetNoDragXorPolys(bool bOn)
836 : {
837 1788 : if (IsNoDragXorPolys()!=bOn)
838 : {
839 17 : const bool bDragging(mpCurrentSdrDragMethod);
840 17 : const bool bShown(bDragging && aDragStat.IsShown());
841 :
842 17 : if(bShown)
843 : {
844 0 : HideDragObj();
845 : }
846 :
847 17 : mbNoDragXorPolys = bOn;
848 :
849 17 : if(bDragging)
850 : {
851 : // force recreation of drag content
852 0 : mpCurrentSdrDragMethod->resetSdrDragEntries();
853 : }
854 :
855 17 : if(bShown)
856 : {
857 0 : ShowDragObj();
858 : }
859 : }
860 1788 : }
861 :
862 4616 : void SdrDragView::SetDragStripes(bool bOn)
863 : {
864 4616 : if (mpCurrentSdrDragMethod && aDragStat.IsShown())
865 : {
866 0 : HideDragObj();
867 0 : mbDragStripes=bOn;
868 0 : ShowDragObj();
869 : }
870 : else
871 : {
872 4616 : mbDragStripes=bOn;
873 : }
874 4616 : }
875 :
876 0 : bool SdrDragView::IsOrthoDesired() const
877 : {
878 0 : if(mpCurrentSdrDragMethod && (IS_TYPE(SdrDragObjOwn, mpCurrentSdrDragMethod) || IS_TYPE(SdrDragResize, mpCurrentSdrDragMethod)))
879 : {
880 0 : return bOrthoDesiredOnMarked;
881 : }
882 :
883 0 : return false;
884 : }
885 :
886 51281 : void SdrDragView::SetMarkHandles()
887 : {
888 51281 : if( mpDragHdl )
889 0 : mpDragHdl = 0;
890 :
891 51281 : SdrExchangeView::SetMarkHandles();
892 51281 : }
893 :
894 1008 : void SdrDragView::SetSolidDragging(bool bOn)
895 : {
896 1008 : if((bool)mbSolidDragging != bOn)
897 : {
898 0 : mbSolidDragging = bOn;
899 : }
900 1008 : }
901 :
902 1865 : bool SdrDragView::IsSolidDragging() const
903 : {
904 : // allow each user to disable by having a local setting, but using AND for
905 : // checking allowance
906 1865 : return mbSolidDragging && getOptionsDrawinglayer().IsSolidDragCreate();
907 435 : }
908 :
909 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
