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