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/svdmrkv.hxx>
22 : #include <svx/svdetc.hxx>
23 : #include <svx/svdoedge.hxx>
24 : #include "svdglob.hxx"
25 : #include <svx/svdview.hxx>
26 : #include <svx/svdpagv.hxx>
27 : #include <svx/svdpage.hxx>
28 : #include "svddrgm1.hxx"
29 :
30 : #ifdef DBG_UTIL
31 : #include <svdibrow.hxx>
32 : #endif
33 :
34 : #include <svx/svdoole2.hxx>
35 : #include <svx/xgrad.hxx>
36 : #include <svx/xflgrit.hxx>
37 : #include "gradtrns.hxx"
38 : #include <svx/xflftrit.hxx>
39 : #include <svx/dialmgr.hxx>
40 : #include "svx/svdstr.hrc"
41 : #include <svx/svdundo.hxx>
42 : #include <svx/svdopath.hxx>
43 : #include <svx/scene3d.hxx>
44 : #include <svx/svdovirt.hxx>
45 : #include <sdr/overlay/overlayrollingrectangle.hxx>
46 : #include <svx/sdr/overlay/overlaymanager.hxx>
47 : #include <svx/sdrpaintwindow.hxx>
48 : #include <svx/sdrpagewindow.hxx>
49 : #include <svx/sdrhittesthelper.hxx>
50 : #include <svx/svdocapt.hxx>
51 : #include <svx/svdograf.hxx>
52 :
53 : #include <editeng/editdata.hxx>
54 : #include <LibreOfficeKit/LibreOfficeKitEnums.h>
55 :
56 : using namespace com::sun::star;
57 :
58 : // Migrate Marking of Objects, Points and GluePoints
59 :
60 : class ImplMarkingOverlay
61 : {
62 : // The OverlayObjects
63 : sdr::overlay::OverlayObjectList maObjects;
64 :
65 : // The remembered second position in logical coordinates
66 : basegfx::B2DPoint maSecondPosition;
67 :
68 : // bitfield
69 : // A flag to remember if the action is for unmarking.
70 : bool mbUnmarking : 1;
71 :
72 : public:
73 : ImplMarkingOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, bool bUnmarking = false);
74 : ~ImplMarkingOverlay();
75 :
76 : void SetSecondPosition(const basegfx::B2DPoint& rNewPosition);
77 0 : bool IsUnmarking() const { return mbUnmarking; }
78 : };
79 :
80 0 : ImplMarkingOverlay::ImplMarkingOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos, bool bUnmarking)
81 : : maSecondPosition(rStartPos),
82 0 : mbUnmarking(bUnmarking)
83 : {
84 0 : for(sal_uInt32 a(0L); a < rView.PaintWindowCount(); a++)
85 : {
86 0 : SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
87 0 : rtl::Reference< sdr::overlay::OverlayManager > xTargetOverlay = pCandidate->GetOverlayManager();
88 :
89 0 : if (xTargetOverlay.is())
90 : {
91 : sdr::overlay::OverlayRollingRectangleStriped* pNew = new sdr::overlay::OverlayRollingRectangleStriped(
92 0 : rStartPos, rStartPos, false);
93 0 : xTargetOverlay->add(*pNew);
94 0 : maObjects.append(*pNew);
95 : }
96 0 : }
97 0 : }
98 :
99 0 : ImplMarkingOverlay::~ImplMarkingOverlay()
100 : {
101 : // The OverlayObjects are cleared using the destructor of OverlayObjectList.
102 : // That destructor calls clear() at the list which removes all objects from the
103 : // OverlayManager and deletes them.
104 0 : }
105 :
106 0 : void ImplMarkingOverlay::SetSecondPosition(const basegfx::B2DPoint& rNewPosition)
107 : {
108 0 : if(rNewPosition != maSecondPosition)
109 : {
110 : // apply to OverlayObjects
111 0 : for(sal_uInt32 a(0L); a < maObjects.count(); a++)
112 : {
113 0 : sdr::overlay::OverlayRollingRectangleStriped& rCandidate = static_cast< sdr::overlay::OverlayRollingRectangleStriped&>(maObjects.getOverlayObject(a));
114 0 : rCandidate.setSecondPosition(rNewPosition);
115 : }
116 :
117 : // remember new position
118 0 : maSecondPosition = rNewPosition;
119 : }
120 0 : }
121 :
122 :
123 :
124 : // MarkView
125 :
126 :
127 :
128 9504 : void SdrMarkView::ImpClearVars()
129 : {
130 9504 : eDragMode=SDRDRAG_MOVE;
131 9504 : bRefHdlShownOnly=false;
132 9504 : eEditMode=SDREDITMODE_EDIT;
133 9504 : eEditMode0=SDREDITMODE_EDIT;
134 9504 : bDesignMode=false;
135 9504 : pMarkedObj=NULL;
136 9504 : pMarkedPV=NULL;
137 9504 : bForceFrameHandles=false;
138 9504 : bPlusHdlAlways=false;
139 9504 : nFrameHandlesLimit=50;
140 9504 : bInsPolyPoint=false;
141 9504 : mnInsPointNum = 0L;
142 9504 : bMarkedObjRectDirty=false;
143 9504 : bMarkedPointsRectsDirty=false;
144 9504 : mbMarkHandlesHidden = false;
145 9504 : bMrkPntDirty=false;
146 9504 : bMarkHdlWhenTextEdit=false;
147 9504 : bMarkableObjCountDirty=false; // not yet implemented
148 9504 : nMarkableObjCount=0; // not yet implemented
149 :
150 : // Migrate selections
151 9504 : BrkMarkObj();
152 9504 : BrkMarkPoints();
153 9504 : BrkMarkGluePoints();
154 9504 : }
155 :
156 9504 : SdrMarkView::SdrMarkView(SdrModel* pModel1, OutputDevice* pOut)
157 : : SdrSnapView(pModel1,pOut),
158 : mpMarkObjOverlay(0L),
159 : mpMarkPointsOverlay(0L),
160 : mpMarkGluePointsOverlay(0L),
161 : maHdlList(this),
162 9504 : mpSdrViewSelection(new sdr::ViewSelection())
163 : {
164 9504 : ImpClearVars();
165 9504 : StartListening(*pModel1);
166 9504 : }
167 :
168 18876 : SdrMarkView::~SdrMarkView()
169 : {
170 : // Migrate selections
171 9438 : BrkMarkObj();
172 9438 : BrkMarkPoints();
173 9438 : BrkMarkGluePoints();
174 9438 : delete mpSdrViewSelection;
175 9438 : }
176 :
177 342865 : void SdrMarkView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
178 : {
179 342865 : const SdrHint* pSdrHint = dynamic_cast<const SdrHint*>(&rHint);
180 342865 : if (pSdrHint)
181 : {
182 333794 : SdrHintKind eKind=pSdrHint->GetKind();
183 :
184 333794 : if (eKind==HINT_OBJCHG || eKind==HINT_OBJINSERTED || eKind==HINT_OBJREMOVED)
185 : {
186 288694 : bMarkedObjRectDirty=true;
187 288694 : bMarkedPointsRectsDirty=true;
188 : }
189 : }
190 342865 : SdrSnapView::Notify(rBC,rHint);
191 342865 : }
192 :
193 3699 : void SdrMarkView::ModelHasChanged()
194 : {
195 3699 : SdrPaintView::ModelHasChanged();
196 3699 : GetMarkedObjectListWriteAccess().SetNameDirty();
197 3699 : bMarkedObjRectDirty=true;
198 3699 : bMarkedPointsRectsDirty=true;
199 : // Example: Obj is selected and maMarkedObjectList is sorted.
200 : // In another View 2, the ObjOrder is changed (e. g. MovToTop())
201 : // Then we need to re-sort MarkList.
202 3699 : GetMarkedObjectListWriteAccess().SetUnsorted();
203 3699 : SortMarkedObjects();
204 3699 : bMrkPntDirty=true;
205 3699 : UndirtyMrkPnt();
206 3699 : SdrView* pV=static_cast<SdrView*>(this);
207 3699 : if (pV!=NULL && !pV->IsDragObj() && !pV->IsInsObjPoint()) {
208 3699 : AdjustMarkHdl();
209 : }
210 3699 : }
211 :
212 :
213 :
214 1876 : bool SdrMarkView::IsAction() const
215 : {
216 1876 : return SdrSnapView::IsAction() || IsMarkObj() || IsMarkPoints() || IsMarkGluePoints();
217 : }
218 :
219 2 : void SdrMarkView::MovAction(const Point& rPnt)
220 : {
221 2 : SdrSnapView::MovAction(rPnt);
222 :
223 2 : if(IsMarkObj())
224 : {
225 0 : MovMarkObj(rPnt);
226 : }
227 2 : else if(IsMarkPoints())
228 : {
229 0 : MovMarkPoints(rPnt);
230 : }
231 2 : else if(IsMarkGluePoints())
232 : {
233 0 : MovMarkGluePoints(rPnt);
234 : }
235 2 : }
236 :
237 0 : void SdrMarkView::EndAction()
238 : {
239 0 : if(IsMarkObj())
240 : {
241 0 : EndMarkObj();
242 : }
243 0 : else if(IsMarkPoints())
244 : {
245 0 : EndMarkPoints();
246 : }
247 0 : else if(IsMarkGluePoints())
248 : {
249 0 : EndMarkGluePoints();
250 : }
251 :
252 0 : SdrSnapView::EndAction();
253 0 : }
254 :
255 0 : void SdrMarkView::BckAction()
256 : {
257 0 : SdrSnapView::BckAction();
258 0 : BrkMarkObj();
259 0 : BrkMarkPoints();
260 0 : BrkMarkGluePoints();
261 0 : }
262 :
263 5984 : void SdrMarkView::BrkAction()
264 : {
265 5984 : SdrSnapView::BrkAction();
266 5984 : BrkMarkObj();
267 5984 : BrkMarkPoints();
268 5984 : BrkMarkGluePoints();
269 5984 : }
270 :
271 0 : void SdrMarkView::TakeActionRect(Rectangle& rRect) const
272 : {
273 0 : if(IsMarkObj() || IsMarkPoints() || IsMarkGluePoints())
274 : {
275 0 : rRect = Rectangle(aDragStat.GetStart(), aDragStat.GetNow());
276 : }
277 : else
278 : {
279 0 : SdrSnapView::TakeActionRect(rRect);
280 : }
281 0 : }
282 :
283 :
284 :
285 0 : void SdrMarkView::ClearPageView()
286 : {
287 0 : UnmarkAllObj();
288 0 : SdrSnapView::ClearPageView();
289 0 : }
290 :
291 5243 : void SdrMarkView::HideSdrPage()
292 : {
293 5243 : bool bMrkChg(false);
294 :
295 5243 : SdrPageView* pPageView = GetSdrPageView();
296 5243 : if (pPageView)
297 : {
298 : // break all creation actions when hiding page (#75081#)
299 5029 : BrkAction();
300 :
301 : // Discard all selections on this page
302 5029 : bMrkChg = GetMarkedObjectListWriteAccess().DeletePageView(*pPageView);
303 : }
304 :
305 5243 : SdrSnapView::HideSdrPage();
306 :
307 5243 : if(bMrkChg)
308 : {
309 54 : MarkListHasChanged();
310 54 : AdjustMarkHdl();
311 : }
312 5243 : }
313 :
314 :
315 :
316 0 : bool SdrMarkView::BegMarkObj(const Point& rPnt, bool bUnmark)
317 : {
318 0 : BrkAction();
319 :
320 : DBG_ASSERT(0L == mpMarkObjOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkObjOverlay (!)");
321 0 : basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y());
322 0 : mpMarkObjOverlay = new ImplMarkingOverlay(*this, aStartPos, bUnmark);
323 :
324 0 : aDragStat.Reset(rPnt);
325 0 : aDragStat.NextPoint();
326 0 : aDragStat.SetMinMove(nMinMovLog);
327 :
328 0 : return true;
329 : }
330 :
331 0 : void SdrMarkView::MovMarkObj(const Point& rPnt)
332 : {
333 0 : if(IsMarkObj() && aDragStat.CheckMinMoved(rPnt))
334 : {
335 0 : aDragStat.NextMove(rPnt);
336 : DBG_ASSERT(mpMarkObjOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
337 0 : basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y());
338 0 : mpMarkObjOverlay->SetSecondPosition(aNewPos);
339 : }
340 0 : }
341 :
342 0 : bool SdrMarkView::EndMarkObj()
343 : {
344 0 : bool bRetval(false);
345 :
346 0 : if(IsMarkObj())
347 : {
348 0 : if(aDragStat.IsMinMoved())
349 : {
350 0 : Rectangle aRect(aDragStat.GetStart(), aDragStat.GetNow());
351 0 : aRect.Justify();
352 0 : MarkObj(aRect, mpMarkObjOverlay->IsUnmarking());
353 0 : bRetval = true;
354 : }
355 :
356 : // cleanup
357 0 : BrkMarkObj();
358 : }
359 :
360 0 : return bRetval;
361 : }
362 :
363 24926 : void SdrMarkView::BrkMarkObj()
364 : {
365 24926 : if(IsMarkObj())
366 : {
367 : DBG_ASSERT(mpMarkObjOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
368 0 : delete mpMarkObjOverlay;
369 0 : mpMarkObjOverlay = 0L;
370 : }
371 24926 : }
372 :
373 :
374 :
375 0 : bool SdrMarkView::BegMarkPoints(const Point& rPnt, bool bUnmark)
376 : {
377 0 : if(HasMarkablePoints())
378 : {
379 0 : BrkAction();
380 :
381 : DBG_ASSERT(0L == mpMarkPointsOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkPointsOverlay (!)");
382 0 : basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y());
383 0 : mpMarkPointsOverlay = new ImplMarkingOverlay(*this, aStartPos, bUnmark);
384 :
385 0 : aDragStat.Reset(rPnt);
386 0 : aDragStat.NextPoint();
387 0 : aDragStat.SetMinMove(nMinMovLog);
388 :
389 0 : return true;
390 : }
391 :
392 0 : return false;
393 : }
394 :
395 0 : void SdrMarkView::MovMarkPoints(const Point& rPnt)
396 : {
397 0 : if(IsMarkPoints() && aDragStat.CheckMinMoved(rPnt))
398 : {
399 0 : aDragStat.NextMove(rPnt);
400 :
401 : DBG_ASSERT(mpMarkPointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
402 0 : basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y());
403 0 : mpMarkPointsOverlay->SetSecondPosition(aNewPos);
404 : }
405 0 : }
406 :
407 0 : bool SdrMarkView::EndMarkPoints()
408 : {
409 0 : bool bRetval(false);
410 :
411 0 : if(IsMarkPoints())
412 : {
413 0 : if(aDragStat.IsMinMoved())
414 : {
415 0 : Rectangle aRect(aDragStat.GetStart(), aDragStat.GetNow());
416 0 : aRect.Justify();
417 0 : MarkPoints(aRect, mpMarkPointsOverlay->IsUnmarking());
418 :
419 0 : bRetval = true;
420 : }
421 :
422 : // cleanup
423 0 : BrkMarkPoints();
424 : }
425 :
426 0 : return bRetval;
427 : }
428 :
429 24926 : void SdrMarkView::BrkMarkPoints()
430 : {
431 24926 : if(IsMarkPoints())
432 : {
433 : DBG_ASSERT(mpMarkPointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
434 0 : delete mpMarkPointsOverlay;
435 0 : mpMarkPointsOverlay = 0L;
436 : }
437 24926 : }
438 :
439 :
440 :
441 0 : bool SdrMarkView::BegMarkGluePoints(const Point& rPnt, bool bUnmark)
442 : {
443 0 : if(HasMarkableGluePoints())
444 : {
445 0 : BrkAction();
446 :
447 : DBG_ASSERT(0L == mpMarkGluePointsOverlay, "SdrMarkView::BegMarkObj: There exists a mpMarkGluePointsOverlay (!)");
448 :
449 0 : basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y());
450 0 : mpMarkGluePointsOverlay = new ImplMarkingOverlay(*this, aStartPos, bUnmark);
451 0 : aDragStat.Reset(rPnt);
452 0 : aDragStat.NextPoint();
453 0 : aDragStat.SetMinMove(nMinMovLog);
454 :
455 0 : return true;
456 : }
457 :
458 0 : return false;
459 : }
460 :
461 0 : void SdrMarkView::MovMarkGluePoints(const Point& rPnt)
462 : {
463 0 : if(IsMarkGluePoints() && aDragStat.CheckMinMoved(rPnt))
464 : {
465 0 : aDragStat.NextMove(rPnt);
466 :
467 : DBG_ASSERT(mpMarkGluePointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
468 0 : basegfx::B2DPoint aNewPos(rPnt.X(), rPnt.Y());
469 0 : mpMarkGluePointsOverlay->SetSecondPosition(aNewPos);
470 : }
471 0 : }
472 :
473 0 : bool SdrMarkView::EndMarkGluePoints()
474 : {
475 0 : bool bRetval(false);
476 :
477 0 : if(IsMarkGluePoints())
478 : {
479 0 : if(aDragStat.IsMinMoved())
480 : {
481 0 : Rectangle aRect(aDragStat.GetStart(),aDragStat.GetNow());
482 0 : aRect.Justify();
483 0 : MarkGluePoints(&aRect, mpMarkGluePointsOverlay->IsUnmarking());
484 :
485 0 : bRetval = true;
486 : }
487 :
488 : // cleanup
489 0 : BrkMarkGluePoints();
490 : }
491 :
492 0 : return bRetval;
493 : }
494 :
495 24926 : void SdrMarkView::BrkMarkGluePoints()
496 : {
497 24926 : if(IsMarkGluePoints())
498 : {
499 : DBG_ASSERT(mpMarkGluePointsOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
500 0 : delete mpMarkGluePointsOverlay;
501 0 : mpMarkGluePointsOverlay = 0L;
502 : }
503 24926 : }
504 :
505 0 : sal_uIntPtr SdrMarkView::GetMarkableObjCount() const
506 : {
507 0 : sal_uIntPtr nCount=0;
508 0 : SdrPageView* pPV = GetSdrPageView();
509 :
510 0 : if(pPV)
511 : {
512 0 : SdrObjList* pOL=pPV->GetObjList();
513 0 : const size_t nObjCount = pOL->GetObjCount();
514 0 : for (size_t nObjNum=0; nObjNum<nObjCount; ++nObjNum) {
515 0 : SdrObject* pObj=pOL->GetObj(nObjNum);
516 0 : if (IsObjMarkable(pObj,pPV)) {
517 0 : nCount++;
518 : }
519 : }
520 : }
521 0 : return nCount;
522 : }
523 :
524 0 : bool SdrMarkView::HasMarkableObj() const
525 : {
526 0 : SdrPageView* pPV = GetSdrPageView();
527 0 : if(pPV)
528 : {
529 0 : SdrObjList* pOL=pPV->GetObjList();
530 0 : const size_t nObjCount = pOL->GetObjCount();
531 0 : for (size_t nObjNum = 0; nObjNum<nObjCount; ++nObjNum) {
532 0 : SdrObject* pObj=pOL->GetObj(nObjNum);
533 0 : if (IsObjMarkable(pObj,pPV)) {
534 0 : return true;
535 : }
536 : }
537 : }
538 0 : return false;
539 : }
540 :
541 15263 : void SdrMarkView::hideMarkHandles()
542 : {
543 15263 : if(!mbMarkHandlesHidden)
544 : {
545 15263 : mbMarkHandlesHidden = true;
546 15263 : AdjustMarkHdl();
547 : }
548 15263 : }
549 :
550 17669 : void SdrMarkView::showMarkHandles()
551 : {
552 17669 : if(mbMarkHandlesHidden)
553 : {
554 14996 : mbMarkHandlesHidden = false;
555 14996 : AdjustMarkHdl();
556 : }
557 17669 : }
558 :
559 47653 : bool SdrMarkView::ImpIsFrameHandles() const
560 : {
561 47653 : const size_t nMarkCount=GetMarkedObjectCount();
562 47653 : bool bFrmHdl=nMarkCount>static_cast<size_t>(nFrameHandlesLimit) || bForceFrameHandles;
563 47653 : bool bStdDrag=eDragMode==SDRDRAG_MOVE;
564 47653 : if (nMarkCount==1 && bStdDrag && bFrmHdl)
565 : {
566 109 : const SdrObject* pObj=GetMarkedObjectByIndex(0);
567 109 : if (pObj->GetObjInventor()==SdrInventor)
568 : {
569 107 : sal_uInt16 nIdent=pObj->GetObjIdentifier();
570 107 : if (nIdent==OBJ_LINE || nIdent==OBJ_EDGE || nIdent==OBJ_CAPTION || nIdent==OBJ_MEASURE || nIdent==OBJ_CUSTOMSHAPE || nIdent==OBJ_TABLE )
571 : {
572 40 : bFrmHdl=false;
573 : }
574 : }
575 : }
576 47653 : if (!bStdDrag && !bFrmHdl) {
577 : // all other drag modes only with FrameHandles
578 0 : bFrmHdl=true;
579 0 : if (eDragMode==SDRDRAG_ROTATE) {
580 : // when rotating, use ObjOwn drag, if there's at least 1 PolyObj
581 0 : for (size_t nMarkNum=0; nMarkNum<nMarkCount && bFrmHdl; ++nMarkNum) {
582 0 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
583 0 : const SdrObject* pObj=pM->GetMarkedSdrObj();
584 0 : bFrmHdl=!pObj->IsPolyObj();
585 : }
586 : }
587 : }
588 47653 : if (!bFrmHdl) {
589 : // FrameHandles, if at least 1 Obj can't do SpecialDrag
590 8056 : for (size_t nMarkNum=0; nMarkNum<nMarkCount && !bFrmHdl; ++nMarkNum) {
591 607 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
592 607 : const SdrObject* pObj=pM->GetMarkedSdrObj();
593 607 : bFrmHdl=!pObj->hasSpecialDrag();
594 : }
595 : }
596 :
597 : // no FrameHdl for crop
598 47653 : if(bFrmHdl && SDRDRAG_CROP == eDragMode)
599 : {
600 0 : bFrmHdl = false;
601 : }
602 :
603 47653 : return bFrmHdl;
604 : }
605 :
606 51281 : void SdrMarkView::SetMarkHandles()
607 : {
608 : // remember old focus handle values to search for it again
609 51281 : const SdrHdl* pSaveOldFocusHdl = maHdlList.GetFocusHdl();
610 51281 : bool bSaveOldFocus(false);
611 51281 : sal_uInt32 nSavePolyNum(0L), nSavePointNum(0L);
612 51281 : SdrHdlKind eSaveKind(HDL_MOVE);
613 51281 : SdrObject* pSaveObj = NULL;
614 :
615 51281 : if(pSaveOldFocusHdl
616 0 : && pSaveOldFocusHdl->GetObj()
617 0 : && pSaveOldFocusHdl->GetObj()->ISA(SdrPathObj)
618 51281 : && (pSaveOldFocusHdl->GetKind() == HDL_POLY || pSaveOldFocusHdl->GetKind() == HDL_BWGT))
619 : {
620 0 : bSaveOldFocus = true;
621 0 : nSavePolyNum = pSaveOldFocusHdl->GetPolyNum();
622 0 : nSavePointNum = pSaveOldFocusHdl->GetPointNum();
623 0 : pSaveObj = pSaveOldFocusHdl->GetObj();
624 0 : eSaveKind = pSaveOldFocusHdl->GetKind();
625 : }
626 :
627 : // delete/clear all handles. This will always be done, even with areMarkHandlesHidden()
628 51281 : maHdlList.Clear();
629 51281 : maHdlList.SetRotateShear(eDragMode==SDRDRAG_ROTATE);
630 51281 : maHdlList.SetDistortShear(eDragMode==SDRDRAG_SHEAR);
631 51281 : pMarkedObj=NULL;
632 51281 : pMarkedPV=NULL;
633 :
634 : // are handles enabled at all? Create only then
635 51281 : if(!areMarkHandlesHidden())
636 : {
637 35477 : const size_t nMarkCount=GetMarkedObjectCount();
638 35477 : bool bStdDrag=eDragMode==SDRDRAG_MOVE;
639 35477 : bool bSingleTextObjMark=false;
640 :
641 35477 : if (nMarkCount==1)
642 : {
643 120 : pMarkedObj=GetMarkedObjectByIndex(0);
644 : bSingleTextObjMark =
645 120 : pMarkedObj &&
646 187 : pMarkedObj->ISA(SdrTextObj) &&
647 187 : static_cast<SdrTextObj*>(pMarkedObj)->IsTextFrame();
648 : }
649 :
650 35477 : bool bFrmHdl=ImpIsFrameHandles();
651 :
652 35477 : if (nMarkCount>0)
653 : {
654 240 : pMarkedPV=GetSdrPageViewOfMarkedByIndex(0);
655 :
656 751 : for (size_t nMarkNum=0; nMarkNum<nMarkCount && (pMarkedPV!=NULL || !bFrmHdl); ++nMarkNum)
657 : {
658 511 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
659 :
660 511 : if (pMarkedPV!=pM->GetPageView())
661 : {
662 0 : pMarkedPV=NULL;
663 : }
664 : }
665 : }
666 :
667 : // apply calc offset to marked object rect
668 : // ( necessary for handles to be displayed in
669 : // correct position )
670 35477 : Point aGridOff = GetGridOffset();
671 :
672 : // There can be multiple mark views, but we're only interested in the one that has a window associated.
673 35477 : const bool bTiledRendering = GetModel()->isTiledRendering() && GetFirstOutputDevice() && GetFirstOutputDevice()->GetOutDevType() == OUTDEV_WINDOW;
674 :
675 : // check if text edit or ole is active and handles need to be suppressed. This may be the case
676 : // when a single object is selected
677 : // Using a strict return statement is okay here; no handles means *no* handles.
678 35477 : if(pMarkedObj)
679 : {
680 : // formally #i33755#: If TextEdit is active the EditEngine will directly paint
681 : // to the window, so suppress Overlay and handles completely; a text frame for
682 : // the active text edit will be painted by the repaitnt mechanism in
683 : // SdrObjEditView::ImpPaintOutlinerView in this case. This needs to be reworked
684 : // in the future
685 : // Also formally #122142#: Pretty much the same for SdrCaptionObj's in calc.
686 120 : if(static_cast<SdrView*>(this)->IsTextEdit())
687 : {
688 6 : const SdrTextObj* pSdrTextObj = dynamic_cast< const SdrTextObj* >(pMarkedObj);
689 :
690 6 : if(pSdrTextObj && pSdrTextObj->IsInEditMode())
691 : {
692 6 : if (bTiledRendering)
693 : // Suppress handles -> empty graphic selection.
694 6 : GetModel()->libreOfficeKitCallback(LOK_CALLBACK_GRAPHIC_SELECTION, "EMPTY");
695 12 : return;
696 : }
697 : }
698 :
699 : // formally #i118524#: if inplace activated OLE is selected, suppress handles
700 114 : const SdrOle2Obj* pSdrOle2Obj = dynamic_cast< const SdrOle2Obj* >(pMarkedObj);
701 :
702 114 : if(pSdrOle2Obj && (pSdrOle2Obj->isInplaceActive() || pSdrOle2Obj->isUiActive()))
703 : {
704 0 : return;
705 : }
706 :
707 114 : if (bTiledRendering && pMarkedObj->GetObjIdentifier() == OBJ_TABLE)
708 : {
709 0 : rtl::Reference<sdr::SelectionController> xController = static_cast<SdrView*>(this)->getSelectionController();
710 0 : if (xController.is() && xController->hasSelectedCells())
711 : {
712 : // The table shape has selected cells, which provide text selection already -> no graphic selection.
713 0 : GetModel()->libreOfficeKitCallback(LOK_CALLBACK_GRAPHIC_SELECTION, "EMPTY");
714 0 : return;
715 0 : }
716 : }
717 : }
718 :
719 35471 : Rectangle aRect(GetMarkedObjRect());
720 :
721 35471 : if (bTiledRendering)
722 : {
723 104 : Rectangle aSelection(aRect);
724 104 : OString sSelection;
725 104 : if (aSelection.IsEmpty())
726 89 : sSelection = "EMPTY";
727 : else
728 : {
729 : // In case the map mode is in 100th MM, then need to convert the coordinates over to twips for LOK.
730 15 : if (pMarkedPV)
731 : {
732 15 : if (OutputDevice* pOutputDevice = pMarkedPV->GetView().GetFirstOutputDevice())
733 : {
734 15 : if (pOutputDevice->GetMapMode().GetMapUnit() == MAP_100TH_MM)
735 8 : aSelection = OutputDevice::LogicToLogic(aSelection, MAP_100TH_MM, MAP_TWIP);
736 : }
737 : }
738 :
739 15 : sSelection = aSelection.toString();
740 :
741 : // hide the text selection too
742 15 : GetModel()->libreOfficeKitCallback(LOK_CALLBACK_TEXT_SELECTION, "");
743 : }
744 104 : GetModel()->libreOfficeKitCallback(LOK_CALLBACK_GRAPHIC_SELECTION, sSelection.getStr());
745 : }
746 :
747 35471 : if (bFrmHdl)
748 : {
749 33021 : if(!aRect.IsEmpty())
750 : { // otherwise nothing is found
751 133 : if( bSingleTextObjMark )
752 : {
753 6 : const size_t nSiz0=maHdlList.GetHdlCount();
754 6 : pMarkedObj->AddToHdlList(maHdlList);
755 6 : const size_t nSiz1=maHdlList.GetHdlCount();
756 66 : for (size_t i=nSiz0; i<nSiz1; ++i)
757 : {
758 60 : SdrHdl* pHdl=maHdlList.GetHdl(i);
759 60 : pHdl->SetObj(pMarkedObj);
760 60 : pHdl->SetPos( pHdl->GetPos() + aGridOff );
761 60 : pHdl->SetPageView(pMarkedPV);
762 60 : pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0));
763 : }
764 : }
765 : else
766 : {
767 127 : bool bWdt0=aRect.Left()==aRect.Right();
768 127 : bool bHgt0=aRect.Top()==aRect.Bottom();
769 127 : if (bWdt0 && bHgt0)
770 : {
771 0 : maHdlList.AddHdl(new SdrHdl(aRect.TopLeft(),HDL_UPLFT));
772 : }
773 127 : else if (!bStdDrag && (bWdt0 || bHgt0))
774 : {
775 0 : maHdlList.AddHdl(new SdrHdl(aRect.TopLeft() ,HDL_UPLFT));
776 0 : maHdlList.AddHdl(new SdrHdl(aRect.BottomRight(),HDL_LWRGT));
777 : }
778 : else
779 : {
780 127 : if (!bWdt0 && !bHgt0) maHdlList.AddHdl(new SdrHdl(aRect.TopLeft() ,HDL_UPLFT));
781 127 : if ( !bHgt0) maHdlList.AddHdl(new SdrHdl(aRect.TopCenter() ,HDL_UPPER));
782 127 : if (!bWdt0 && !bHgt0) maHdlList.AddHdl(new SdrHdl(aRect.TopRight() ,HDL_UPRGT));
783 127 : if (!bWdt0 ) maHdlList.AddHdl(new SdrHdl(aRect.LeftCenter() ,HDL_LEFT ));
784 127 : if (!bWdt0 ) maHdlList.AddHdl(new SdrHdl(aRect.RightCenter() ,HDL_RIGHT));
785 127 : if (!bWdt0 && !bHgt0) maHdlList.AddHdl(new SdrHdl(aRect.BottomLeft() ,HDL_LWLFT));
786 127 : if ( !bHgt0) maHdlList.AddHdl(new SdrHdl(aRect.BottomCenter(),HDL_LOWER));
787 127 : if (!bWdt0 && !bHgt0) maHdlList.AddHdl(new SdrHdl(aRect.BottomRight() ,HDL_LWRGT));
788 : }
789 : }
790 : }
791 : }
792 : else
793 : {
794 2450 : bool bDone(false);
795 :
796 : // moved crop handling to non-frame part and the handle creation to SdrGrafObj
797 2450 : if(1 == nMarkCount && pMarkedObj && SDRDRAG_CROP == eDragMode)
798 : {
799 : // Default addCropHandles from SdrObject does nothing. When pMarkedObj is SdrGrafObj, previous
800 : // behaviour occurs (code in svx/source/svdraw/svdograf.cxx). When pMarkedObj is SwVirtFlyDrawObj
801 : // writer takes the responsibility of adding handles (code in sw/source/core/draw/dflyobj.cxx)
802 0 : pMarkedObj->addCropHandles(maHdlList);
803 0 : bDone = true;
804 : }
805 :
806 2450 : if(!bDone)
807 : {
808 2639 : for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum)
809 : {
810 189 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
811 189 : SdrObject* pObj=pM->GetMarkedSdrObj();
812 189 : SdrPageView* pPV=pM->GetPageView();
813 189 : const size_t nSiz0=maHdlList.GetHdlCount();
814 189 : pObj->AddToHdlList(maHdlList);
815 189 : const size_t nSiz1=maHdlList.GetHdlCount();
816 189 : bool bPoly=pObj->IsPolyObj();
817 189 : const SdrUShortCont* pMrkPnts=pM->GetMarkedPoints();
818 1170 : for (size_t i=nSiz0; i<nSiz1; ++i)
819 : {
820 981 : SdrHdl* pHdl=maHdlList.GetHdl(i);
821 981 : pHdl->SetPos( pHdl->GetPos() + aGridOff );
822 981 : pHdl->SetObj(pObj);
823 981 : pHdl->SetPageView(pPV);
824 981 : pHdl->SetObjHdlNum(sal_uInt16(i-nSiz0));
825 :
826 981 : if (bPoly)
827 : {
828 : bool bSelected=pMrkPnts!=NULL
829 701 : && pMrkPnts->find( sal_uInt16(i-nSiz0) ) != pMrkPnts->end();
830 701 : pHdl->SetSelected(bSelected);
831 701 : if (bPlusHdlAlways || bSelected)
832 : {
833 0 : sal_uInt32 nPlusAnz=pObj->GetPlusHdlCount(*pHdl);
834 0 : for (sal_uInt32 nPlusNum=0; nPlusNum<nPlusAnz; nPlusNum++)
835 : {
836 0 : SdrHdl* pPlusHdl=pObj->GetPlusHdl(*pHdl,nPlusNum);
837 0 : if (pPlusHdl!=NULL)
838 : {
839 0 : pPlusHdl->SetObj(pObj);
840 0 : pPlusHdl->SetPageView(pPV);
841 0 : pPlusHdl->SetPlusHdl(true);
842 0 : maHdlList.AddHdl(pPlusHdl);
843 : }
844 : }
845 : }
846 : }
847 : }
848 : }
849 : }
850 : }
851 :
852 : // GluePoint handles
853 35976 : for (size_t nMarkNum=0; nMarkNum<nMarkCount; ++nMarkNum)
854 : {
855 505 : const SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
856 505 : SdrObject* pObj=pM->GetMarkedSdrObj();
857 505 : SdrPageView* pPV=pM->GetPageView();
858 505 : const SdrUShortCont* pMrkGlue=pM->GetMarkedGluePoints();
859 505 : if (pMrkGlue!=NULL)
860 : {
861 0 : const SdrGluePointList* pGPL=pObj->GetGluePointList();
862 0 : if (pGPL!=NULL)
863 : {
864 0 : for(SdrUShortCont::const_iterator it = pMrkGlue->begin(); it != pMrkGlue->end(); ++it)
865 : {
866 0 : sal_uInt16 nId=*it;
867 : //nNum changed to nNumGP because already used in for loop
868 0 : sal_uInt16 nNumGP=pGPL->FindGluePoint(nId);
869 0 : if (nNumGP!=SDRGLUEPOINT_NOTFOUND)
870 : {
871 0 : const SdrGluePoint& rGP=(*pGPL)[nNumGP];
872 0 : Point aPos(rGP.GetAbsolutePos(*pObj));
873 0 : SdrHdl* pGlueHdl=new SdrHdl(aPos,HDL_GLUE);
874 0 : pGlueHdl->SetObj(pObj);
875 0 : pGlueHdl->SetPageView(pPV);
876 0 : pGlueHdl->SetObjHdlNum(nId);
877 0 : maHdlList.AddHdl(pGlueHdl);
878 : }
879 : }
880 : }
881 : }
882 : }
883 :
884 : // rotation point/axis of reflection
885 35471 : AddDragModeHdl(eDragMode);
886 :
887 : // sort handles
888 35471 : maHdlList.Sort();
889 :
890 : // add custom handles (used by other apps, e.g. AnchorPos)
891 35471 : AddCustomHdl();
892 :
893 : // try to restore focus handle index from remembered values
894 35471 : if(bSaveOldFocus)
895 : {
896 0 : for(size_t a = 0; a < maHdlList.GetHdlCount(); ++a)
897 : {
898 0 : SdrHdl* pCandidate = maHdlList.GetHdl(a);
899 :
900 0 : if(pCandidate->GetObj()
901 0 : && pCandidate->GetObj() == pSaveObj
902 0 : && pCandidate->GetKind() == eSaveKind
903 0 : && pCandidate->GetPolyNum() == nSavePolyNum
904 0 : && pCandidate->GetPointNum() == nSavePointNum)
905 : {
906 0 : maHdlList.SetFocusHdl(pCandidate);
907 0 : break;
908 : }
909 : }
910 : }
911 : }
912 : }
913 :
914 2553 : void SdrMarkView::AddCustomHdl()
915 : {
916 : // add custom handles (used by other apps, e.g. AnchorPos)
917 2553 : }
918 :
919 1407 : void SdrMarkView::SetDragMode(SdrDragMode eMode)
920 : {
921 1407 : SdrDragMode eMode0=eDragMode;
922 1407 : eDragMode=eMode;
923 1407 : if (eDragMode==SDRDRAG_RESIZE) eDragMode=SDRDRAG_MOVE;
924 1407 : if (eDragMode!=eMode0) {
925 0 : ForceRefToMarked();
926 0 : SetMarkHandles();
927 : {
928 0 : if (AreObjectsMarked()) MarkListHasChanged();
929 : }
930 : }
931 1407 : }
932 :
933 35471 : void SdrMarkView::AddDragModeHdl(SdrDragMode eMode)
934 : {
935 35471 : switch(eMode)
936 : {
937 : case SDRDRAG_ROTATE:
938 : {
939 : // add rotation center
940 0 : SdrHdl* pHdl = new SdrHdl(aRef1, HDL_REF1);
941 :
942 0 : maHdlList.AddHdl(pHdl);
943 :
944 0 : break;
945 : }
946 : case SDRDRAG_MIRROR:
947 : {
948 : // add axis of reflection
949 0 : SdrHdl* pHdl3 = new SdrHdl(aRef2, HDL_REF2);
950 0 : SdrHdl* pHdl2 = new SdrHdl(aRef1, HDL_REF1);
951 0 : SdrHdl* pHdl1 = new SdrHdlLine(*pHdl2, *pHdl3, HDL_MIRX);
952 :
953 0 : pHdl1->SetObjHdlNum(1); // for sorting
954 0 : pHdl2->SetObjHdlNum(2); // for sorting
955 0 : pHdl3->SetObjHdlNum(3); // for sorting
956 :
957 0 : maHdlList.AddHdl(pHdl1); // line comes first, so it is the last in HitTest
958 0 : maHdlList.AddHdl(pHdl2);
959 0 : maHdlList.AddHdl(pHdl3);
960 :
961 0 : break;
962 : }
963 : case SDRDRAG_TRANSPARENCE:
964 : {
965 : // add interactive transparency handle
966 0 : const size_t nMarkCount = GetMarkedObjectCount();
967 0 : if(nMarkCount == 1)
968 : {
969 0 : SdrObject* pObj = GetMarkedObjectByIndex(0);
970 0 : SdrModel* pModel = GetModel();
971 0 : const SfxItemSet& rSet = pObj->GetMergedItemSet();
972 :
973 0 : if(SfxItemState::SET != rSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, false))
974 : {
975 : // add this item, it's not yet there
976 : XFillFloatTransparenceItem aNewItem(
977 0 : static_cast<const XFillFloatTransparenceItem&>(rSet.Get(XATTR_FILLFLOATTRANSPARENCE)));
978 0 : XGradient aGrad = aNewItem.GetGradientValue();
979 :
980 0 : aNewItem.SetEnabled(true);
981 0 : aGrad.SetStartIntens(100);
982 0 : aGrad.SetEndIntens(100);
983 0 : aNewItem.SetGradientValue(aGrad);
984 :
985 : // add undo to allow user to take back this step
986 0 : if( pModel->IsUndoEnabled() )
987 : {
988 0 : pModel->BegUndo(SVX_RESSTR(SIP_XA_FILLTRANSPARENCE));
989 0 : pModel->AddUndo(pModel->GetSdrUndoFactory().CreateUndoAttrObject(*pObj));
990 0 : pModel->EndUndo();
991 : }
992 :
993 0 : SfxItemSet aNewSet(pModel->GetItemPool());
994 0 : aNewSet.Put(aNewItem);
995 0 : pObj->SetMergedItemSetAndBroadcast(aNewSet);
996 : }
997 :
998 : // set values and transform to vector set
999 0 : GradTransformer aGradTransformer;
1000 0 : GradTransVector aGradTransVector;
1001 0 : GradTransGradient aGradTransGradient;
1002 :
1003 0 : aGradTransGradient.aGradient = static_cast<const XFillFloatTransparenceItem&>(rSet.Get(XATTR_FILLFLOATTRANSPARENCE)).GetGradientValue();
1004 0 : GradTransformer::GradToVec(aGradTransGradient, aGradTransVector, pObj);
1005 :
1006 : // build handles
1007 0 : const Point aTmpPos1(basegfx::fround(aGradTransVector.maPositionA.getX()), basegfx::fround(aGradTransVector.maPositionA.getY()));
1008 0 : const Point aTmpPos2(basegfx::fround(aGradTransVector.maPositionB.getX()), basegfx::fround(aGradTransVector.maPositionB.getY()));
1009 0 : SdrHdlColor* pColHdl1 = new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, SDR_HANDLE_COLOR_SIZE_NORMAL, true);
1010 0 : SdrHdlColor* pColHdl2 = new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, SDR_HANDLE_COLOR_SIZE_NORMAL, true);
1011 0 : SdrHdlGradient* pGradHdl = new SdrHdlGradient(aTmpPos1, aTmpPos2, false);
1012 : DBG_ASSERT(pColHdl1 && pColHdl2 && pGradHdl, "Could not get all necessary handles!");
1013 :
1014 : // link them
1015 0 : pGradHdl->SetColorHandles(pColHdl1, pColHdl2);
1016 0 : pGradHdl->SetObj(pObj);
1017 0 : pColHdl1->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl));
1018 0 : pColHdl2->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl));
1019 :
1020 : // insert them
1021 0 : maHdlList.AddHdl(pColHdl1);
1022 0 : maHdlList.AddHdl(pColHdl2);
1023 0 : maHdlList.AddHdl(pGradHdl);
1024 : }
1025 0 : break;
1026 : }
1027 : case SDRDRAG_GRADIENT:
1028 : {
1029 : // add interactive gradient handle
1030 0 : const size_t nMarkCount = GetMarkedObjectCount();
1031 0 : if(nMarkCount == 1)
1032 : {
1033 0 : SdrObject* pObj = GetMarkedObjectByIndex(0);
1034 0 : const SfxItemSet& rSet = pObj->GetMergedItemSet();
1035 0 : drawing::FillStyle eFillStyle = static_cast<const XFillStyleItem&>(rSet.Get(XATTR_FILLSTYLE)).GetValue();
1036 :
1037 0 : if(eFillStyle == drawing::FillStyle_GRADIENT)
1038 : {
1039 : // set values and transform to vector set
1040 0 : GradTransformer aGradTransformer;
1041 0 : GradTransVector aGradTransVector;
1042 0 : GradTransGradient aGradTransGradient;
1043 0 : Size aHdlSize(15, 15);
1044 :
1045 0 : aGradTransGradient.aGradient = static_cast<const XFillGradientItem&>(rSet.Get(XATTR_FILLGRADIENT)).GetGradientValue();
1046 0 : GradTransformer::GradToVec(aGradTransGradient, aGradTransVector, pObj);
1047 :
1048 : // build handles
1049 0 : const Point aTmpPos1(basegfx::fround(aGradTransVector.maPositionA.getX()), basegfx::fround(aGradTransVector.maPositionA.getY()));
1050 0 : const Point aTmpPos2(basegfx::fround(aGradTransVector.maPositionB.getX()), basegfx::fround(aGradTransVector.maPositionB.getY()));
1051 0 : SdrHdlColor* pColHdl1 = new SdrHdlColor(aTmpPos1, aGradTransVector.aCol1, aHdlSize, false);
1052 0 : SdrHdlColor* pColHdl2 = new SdrHdlColor(aTmpPos2, aGradTransVector.aCol2, aHdlSize, false);
1053 0 : SdrHdlGradient* pGradHdl = new SdrHdlGradient(aTmpPos1, aTmpPos2, true);
1054 : DBG_ASSERT(pColHdl1 && pColHdl2 && pGradHdl, "Could not get all necessary handles!");
1055 :
1056 : // link them
1057 0 : pGradHdl->SetColorHandles(pColHdl1, pColHdl2);
1058 0 : pGradHdl->SetObj(pObj);
1059 0 : pColHdl1->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl));
1060 0 : pColHdl2->SetColorChangeHdl(LINK(pGradHdl, SdrHdlGradient, ColorChangeHdl));
1061 :
1062 : // insert them
1063 0 : maHdlList.AddHdl(pColHdl1);
1064 0 : maHdlList.AddHdl(pColHdl2);
1065 0 : maHdlList.AddHdl(pGradHdl);
1066 : }
1067 : }
1068 0 : break;
1069 : }
1070 : case SDRDRAG_CROP:
1071 : {
1072 : // TODO
1073 0 : break;
1074 : }
1075 35471 : default: break;
1076 : }
1077 35471 : }
1078 :
1079 : /** handle mouse over effects for handles */
1080 4 : bool SdrMarkView::MouseMove(const MouseEvent& rMEvt, vcl::Window* pWin)
1081 : {
1082 4 : if(maHdlList.GetHdlCount())
1083 : {
1084 4 : SdrHdl* pMouseOverHdl = 0;
1085 4 : if( !rMEvt.IsLeaveWindow() && pWin )
1086 : {
1087 4 : Point aMDPos( pWin->PixelToLogic( rMEvt.GetPosPixel() ) );
1088 4 : pMouseOverHdl = PickHandle(aMDPos);
1089 : }
1090 :
1091 : // notify last mouse over handle that he lost the mouse
1092 4 : const size_t nHdlCount = maHdlList.GetHdlCount();
1093 :
1094 33 : for(size_t nHdl = 0; nHdl < nHdlCount; ++nHdl)
1095 : {
1096 31 : SdrHdl* pCurrentHdl = GetHdl(nHdl);
1097 31 : if( pCurrentHdl->mbMouseOver )
1098 : {
1099 2 : if( pCurrentHdl != pMouseOverHdl )
1100 : {
1101 2 : pCurrentHdl->mbMouseOver = false;
1102 2 : pCurrentHdl->onMouseLeave();
1103 : }
1104 2 : break;
1105 : }
1106 : }
1107 :
1108 : // notify current mouse over handle
1109 4 : if( pMouseOverHdl )
1110 : {
1111 2 : pMouseOverHdl->mbMouseOver = true;
1112 2 : pMouseOverHdl->onMouseEnter(rMEvt);
1113 : }
1114 : }
1115 4 : return SdrSnapView::MouseMove(rMEvt, pWin);
1116 : }
1117 :
1118 0 : void SdrMarkView::ForceRefToMarked()
1119 : {
1120 0 : switch(eDragMode)
1121 : {
1122 : case SDRDRAG_ROTATE:
1123 : {
1124 0 : Rectangle aR(GetMarkedObjRect());
1125 0 : aRef1 = aR.Center();
1126 :
1127 0 : break;
1128 : }
1129 :
1130 : case SDRDRAG_MIRROR:
1131 : {
1132 : // first calculate the length of the axis of reflection
1133 0 : long nOutMin=0;
1134 0 : long nOutMax=0;
1135 0 : long nMinLen=0;
1136 0 : long nObjDst=0;
1137 0 : long nOutHgt=0;
1138 0 : OutputDevice* pOut=GetFirstOutputDevice();
1139 0 : if (pOut!=NULL) {
1140 : // minimum length: 50 pixels
1141 0 : nMinLen=pOut->PixelToLogic(Size(0,50)).Height();
1142 : // 20 pixels distance to the Obj for the reference point
1143 0 : nObjDst=pOut->PixelToLogic(Size(0,20)).Height();
1144 : // MinY/MaxY
1145 : // margin = minimum length = 10 pixels
1146 0 : long nDst=pOut->PixelToLogic(Size(0,10)).Height();
1147 0 : nOutMin=-pOut->GetMapMode().GetOrigin().Y();
1148 0 : nOutMax=pOut->GetOutputSize().Height()-1+nOutMin;
1149 0 : nOutMin+=nDst;
1150 0 : nOutMax-=nDst;
1151 : // absolute minimum length, however, is 10 pixels
1152 0 : if (nOutMax-nOutMin<nDst) {
1153 0 : nOutMin+=nOutMax+1;
1154 0 : nOutMin/=2;
1155 0 : nOutMin-=(nDst+1)/2;
1156 0 : nOutMax=nOutMin+nDst;
1157 : }
1158 0 : nOutHgt=nOutMax-nOutMin;
1159 : // otherwise minimum length = 1/4 OutHgt
1160 0 : long nTemp=nOutHgt/4;
1161 0 : if (nTemp>nMinLen) nMinLen=nTemp;
1162 : }
1163 :
1164 0 : Rectangle aR(GetMarkedObjBoundRect());
1165 0 : Point aCenter(aR.Center());
1166 0 : long nMarkHgt=aR.GetHeight()-1;
1167 0 : long nHgt=nMarkHgt+nObjDst*2; // 20 pixels overlapping above and below
1168 0 : if (nHgt<nMinLen) nHgt=nMinLen; // minimum length 50 pixels or 1/4 OutHgt, respectively
1169 :
1170 0 : long nY1=aCenter.Y()-(nHgt+1)/2;
1171 0 : long nY2=nY1+nHgt;
1172 :
1173 0 : if (pOut!=NULL && nMinLen>nOutHgt) nMinLen=nOutHgt; // TODO: maybe shorten this a little
1174 :
1175 0 : if (pOut!=NULL) { // now move completely into the visible area
1176 0 : if (nY1<nOutMin) {
1177 0 : nY1=nOutMin;
1178 0 : if (nY2<nY1+nMinLen) nY2=nY1+nMinLen;
1179 : }
1180 0 : if (nY2>nOutMax) {
1181 0 : nY2=nOutMax;
1182 0 : if (nY1>nY2-nMinLen) nY1=nY2-nMinLen;
1183 : }
1184 : }
1185 :
1186 0 : aRef1.X()=aCenter.X();
1187 0 : aRef1.Y()=nY1;
1188 0 : aRef2.X()=aCenter.X();
1189 0 : aRef2.Y()=nY2;
1190 :
1191 0 : break;
1192 : }
1193 :
1194 : case SDRDRAG_TRANSPARENCE:
1195 : case SDRDRAG_GRADIENT:
1196 : case SDRDRAG_CROP:
1197 : {
1198 0 : Rectangle aRect(GetMarkedObjBoundRect());
1199 0 : aRef1 = aRect.TopLeft();
1200 0 : aRef2 = aRect.BottomRight();
1201 0 : break;
1202 : }
1203 0 : default: break;
1204 : }
1205 0 : }
1206 :
1207 0 : void SdrMarkView::SetRef1(const Point& rPt)
1208 : {
1209 0 : if(eDragMode == SDRDRAG_ROTATE || eDragMode == SDRDRAG_MIRROR)
1210 : {
1211 0 : aRef1 = rPt;
1212 0 : SdrHdl* pH = maHdlList.GetHdl(HDL_REF1);
1213 0 : if(pH)
1214 0 : pH->SetPos(rPt);
1215 : }
1216 0 : }
1217 :
1218 0 : void SdrMarkView::SetRef2(const Point& rPt)
1219 : {
1220 0 : if(eDragMode == SDRDRAG_MIRROR)
1221 : {
1222 0 : aRef2 = rPt;
1223 0 : SdrHdl* pH = maHdlList.GetHdl(HDL_REF2);
1224 0 : if(pH)
1225 0 : pH->SetPos(rPt);
1226 : }
1227 0 : }
1228 :
1229 53426 : void SdrMarkView::CheckMarked()
1230 : {
1231 107631 : for (size_t nm=GetMarkedObjectCount(); nm>0;) {
1232 779 : --nm;
1233 779 : SdrMark* pM=GetSdrMarkByIndex(nm);
1234 779 : SdrObject* pObj=pM->GetMarkedSdrObj();
1235 779 : SdrPageView* pPV=pM->GetPageView();
1236 779 : SdrLayerID nLay=pObj->GetLayer();
1237 779 : bool bRaus=!pObj->IsInserted(); // Obj deleted?
1238 779 : if (!pObj->Is3DObj()) {
1239 779 : bRaus=bRaus || pObj->GetPage()!=pPV->GetPage(); // Obj suddenly in different Page or Group
1240 : }
1241 1558 : bRaus=bRaus || pPV->GetLockedLayers().IsSet(nLay) || // Layer locked?
1242 1558 : !pPV->GetVisibleLayers().IsSet(nLay); // Layer invisible?
1243 :
1244 779 : if( !bRaus )
1245 779 : bRaus = !pObj->IsVisible(); // invisible objects can not be selected
1246 :
1247 779 : if (!bRaus) {
1248 : // Grouped objects can now be selected.
1249 : // After EnterGroup the higher-level objects,
1250 : // have to be deselected, though.
1251 779 : const SdrObjList* pOOL=pObj->GetObjList();
1252 779 : const SdrObjList* pVOL=pPV->GetObjList();
1253 1564 : while (pOOL!=NULL && pOOL!=pVOL) {
1254 6 : pOOL=pOOL->GetUpList();
1255 : }
1256 779 : bRaus=pOOL!=pVOL;
1257 : }
1258 :
1259 779 : if (bRaus)
1260 : {
1261 0 : GetMarkedObjectListWriteAccess().DeleteMark(nm);
1262 : }
1263 : else
1264 : {
1265 779 : if (!IsGluePointEditMode()) { // selected glue points only in GlueEditMode
1266 779 : SdrUShortCont* pPts=pM->GetMarkedGluePoints();
1267 779 : if (pPts!=NULL) {
1268 0 : pPts->clear();
1269 : }
1270 : }
1271 : }
1272 : }
1273 :
1274 : // at least reset the remembered BoundRect to prevent handle
1275 : // generation if bForceFrameHandles is TRUE.
1276 53426 : bMarkedObjRectDirty = true;
1277 53426 : }
1278 :
1279 51281 : void SdrMarkView::SetMarkRects()
1280 : {
1281 51281 : SdrPageView* pPV = GetSdrPageView();
1282 :
1283 51281 : if(pPV)
1284 : {
1285 45114 : pPV->SetHasMarkedObj(GetSnapRectFromMarkedObjects(pPV, pPV->MarkSnap()));
1286 45114 : GetBoundRectFromMarkedObjects(pPV, pPV->MarkBound());
1287 : }
1288 51281 : }
1289 :
1290 4889 : void SdrMarkView::SetFrameHandles(bool bOn)
1291 : {
1292 4889 : if (bOn!=bForceFrameHandles) {
1293 3825 : bool bOld=ImpIsFrameHandles();
1294 3825 : bForceFrameHandles=bOn;
1295 3825 : bool bNew=ImpIsFrameHandles();
1296 3825 : if (bNew!=bOld) {
1297 3825 : AdjustMarkHdl();
1298 3825 : MarkListHasChanged();
1299 : }
1300 : }
1301 4889 : }
1302 :
1303 353 : void SdrMarkView::SetEditMode(SdrViewEditMode eMode)
1304 : {
1305 353 : if (eMode!=eEditMode) {
1306 6 : bool bGlue0=eEditMode==SDREDITMODE_GLUEPOINTEDIT;
1307 6 : bool bEdge0=static_cast<SdrCreateView*>(this)->IsEdgeTool();
1308 6 : eEditMode0=eEditMode;
1309 6 : eEditMode=eMode;
1310 6 : bool bGlue1=eEditMode==SDREDITMODE_GLUEPOINTEDIT;
1311 6 : bool bEdge1=static_cast<SdrCreateView*>(this)->IsEdgeTool();
1312 : // avoid flickering when switching between GlueEdit and EdgeTool
1313 6 : if (bGlue1 && !bGlue0) ImpSetGlueVisible2(bGlue1);
1314 6 : if (bEdge1!=bEdge0) ImpSetGlueVisible3(bEdge1);
1315 6 : if (!bGlue1 && bGlue0) ImpSetGlueVisible2(bGlue1);
1316 6 : if (bGlue0 && !bGlue1) UnmarkAllGluePoints();
1317 : }
1318 353 : }
1319 :
1320 :
1321 :
1322 672 : bool SdrMarkView::IsObjMarkable(SdrObject* pObj, SdrPageView* pPV) const
1323 : {
1324 672 : if (pObj)
1325 : {
1326 1351 : if (pObj->IsMarkProtect() ||
1327 961 : (!bDesignMode && pObj->IsUnoObj()))
1328 : {
1329 : // object not selectable or
1330 : // SdrUnoObj not in DesignMode
1331 7 : return false;
1332 : }
1333 : }
1334 665 : return pPV==NULL || pPV->IsObjMarkable(pObj);
1335 : }
1336 :
1337 1 : bool SdrMarkView::IsMarkedObjHit(const Point& rPnt, short nTol) const
1338 : {
1339 1 : bool bRet=false;
1340 1 : nTol=ImpGetHitTolLogic(nTol,NULL);
1341 1 : Point aPt(rPnt);
1342 1 : for (size_t nm=0; nm<GetMarkedObjectCount() && !bRet; ++nm) {
1343 0 : SdrMark* pM=GetSdrMarkByIndex(nm);
1344 0 : bRet = 0 != CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pM->GetPageView(),SdrSearchOptions::NONE,0);
1345 : }
1346 1 : return bRet;
1347 : }
1348 :
1349 2909 : SdrHdl* SdrMarkView::PickHandle(const Point& rPnt, SdrSearchOptions nOptions, SdrHdl* pHdl0) const
1350 : {
1351 2909 : if (bSomeObjChgdFlag) { // recalculate handles, if necessary
1352 1066 : FlushComeBackTimer();
1353 : }
1354 2909 : bool bBack(nOptions & SdrSearchOptions::BACKWARD);
1355 2909 : bool bNext(nOptions & SdrSearchOptions::NEXT);
1356 2909 : Point aPt(rPnt);
1357 2909 : return maHdlList.IsHdlListHit(aPt,bBack,bNext,pHdl0);
1358 : }
1359 :
1360 3 : bool SdrMarkView::MarkObj(const Point& rPnt, short nTol, bool bToggle, bool bDeep)
1361 : {
1362 : SdrObject* pObj;
1363 : SdrPageView* pPV;
1364 3 : nTol=ImpGetHitTolLogic(nTol,NULL);
1365 3 : SdrSearchOptions nOptions=SdrSearchOptions::PICKMARKABLE;
1366 3 : if (bDeep) nOptions=nOptions|SdrSearchOptions::DEEP;
1367 3 : bool bRet=PickObj(rPnt,(sal_uInt16)nTol,pObj,pPV,nOptions);
1368 3 : if (bRet) {
1369 2 : bool bUnmark=bToggle && IsObjMarked(pObj);
1370 2 : MarkObj(pObj,pPV,bUnmark);
1371 : }
1372 3 : return bRet;
1373 : }
1374 :
1375 1 : bool SdrMarkView::MarkNextObj(bool bPrev)
1376 : {
1377 1 : SdrPageView* pPageView = GetSdrPageView();
1378 :
1379 1 : if(!pPageView)
1380 : {
1381 0 : return false;
1382 : }
1383 :
1384 1 : SortMarkedObjects();
1385 1 : const size_t nMarkCount=GetMarkedObjectCount();
1386 1 : size_t nChgMarkNum = SAL_MAX_SIZE; // number of the MarkEntry we want to replace
1387 1 : size_t nSearchObjNum = bPrev ? 0 : SAL_MAX_SIZE;
1388 1 : if (nMarkCount!=0) {
1389 0 : nChgMarkNum=bPrev ? 0 : nMarkCount-1;
1390 0 : SdrMark* pM=GetSdrMarkByIndex(nChgMarkNum);
1391 : OSL_ASSERT(pM!=NULL);
1392 0 : if (pM->GetMarkedSdrObj() != NULL)
1393 0 : nSearchObjNum = pM->GetMarkedSdrObj()->GetNavigationPosition();
1394 : }
1395 :
1396 1 : SdrObject* pMarkObj=NULL;
1397 1 : SdrObjList* pSearchObjList=pPageView->GetObjList();
1398 1 : const size_t nObjCount = pSearchObjList->GetObjCount();
1399 1 : if (nObjCount!=0) {
1400 1 : if (nSearchObjNum>nObjCount) nSearchObjNum=nObjCount;
1401 3 : while (pMarkObj==NULL && ((!bPrev && nSearchObjNum>0) || (bPrev && nSearchObjNum<nObjCount)))
1402 : {
1403 1 : if (!bPrev)
1404 1 : nSearchObjNum--;
1405 1 : SdrObject* pSearchObj = pSearchObjList->GetObjectForNavigationPosition(nSearchObjNum);
1406 1 : if (IsObjMarkable(pSearchObj,pPageView))
1407 : {
1408 1 : if (TryToFindMarkedObject(pSearchObj)==SAL_MAX_SIZE)
1409 : {
1410 1 : pMarkObj=pSearchObj;
1411 : }
1412 : }
1413 1 : if (bPrev) nSearchObjNum++;
1414 : }
1415 : }
1416 :
1417 1 : if(!pMarkObj)
1418 : {
1419 0 : return false;
1420 : }
1421 :
1422 1 : if (nChgMarkNum!=SAL_MAX_SIZE)
1423 : {
1424 0 : GetMarkedObjectListWriteAccess().DeleteMark(nChgMarkNum);
1425 : }
1426 1 : MarkObj(pMarkObj,pPageView); // also calls MarkListHasChanged(), AdjustMarkHdl()
1427 1 : return true;
1428 : }
1429 :
1430 0 : bool SdrMarkView::MarkNextObj(const Point& rPnt, short nTol, bool bPrev)
1431 : {
1432 0 : SortMarkedObjects();
1433 0 : nTol=ImpGetHitTolLogic(nTol,NULL);
1434 0 : Point aPt(rPnt);
1435 0 : SdrMark* pTopMarkHit=NULL;
1436 0 : SdrMark* pBtmMarkHit=NULL;
1437 0 : size_t nTopMarkHit=0;
1438 0 : size_t nBtmMarkHit=0;
1439 : // find topmost of the selected objects that is hit by rPnt
1440 0 : const size_t nMarkCount=GetMarkedObjectCount();
1441 0 : for (size_t nm=nMarkCount; nm>0 && pTopMarkHit==NULL;) {
1442 0 : --nm;
1443 0 : SdrMark* pM=GetSdrMarkByIndex(nm);
1444 0 : if(CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pM->GetPageView(),SdrSearchOptions::NONE,0))
1445 : {
1446 0 : pTopMarkHit=pM;
1447 0 : nTopMarkHit=nm;
1448 : }
1449 : }
1450 : // nothing found, in this case, just select an object
1451 0 : if (pTopMarkHit==NULL) return MarkObj(rPnt,sal_uInt16(nTol),false);
1452 :
1453 0 : SdrObject* pTopObjHit=pTopMarkHit->GetMarkedSdrObj();
1454 0 : SdrObjList* pObjList=pTopObjHit->GetObjList();
1455 0 : SdrPageView* pPV=pTopMarkHit->GetPageView();
1456 : // find lowermost of the selected objects that is hit by rPnt
1457 : // and is placed on the same PageView as pTopMarkHit
1458 0 : for (size_t nm=0; nm<nMarkCount && pBtmMarkHit==NULL; ++nm) {
1459 0 : SdrMark* pM=GetSdrMarkByIndex(nm);
1460 0 : SdrPageView* pPV2=pM->GetPageView();
1461 0 : if (pPV2==pPV && CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pM->GetMarkedSdrObj(),pPV2,SdrSearchOptions::NONE,0))
1462 : {
1463 0 : pBtmMarkHit=pM;
1464 0 : nBtmMarkHit=nm;
1465 : }
1466 : }
1467 0 : if (pBtmMarkHit==NULL) { pBtmMarkHit=pTopMarkHit; nBtmMarkHit=nTopMarkHit; }
1468 0 : SdrObject* pBtmObjHit=pBtmMarkHit->GetMarkedSdrObj();
1469 0 : const size_t nObjCount = pObjList->GetObjCount();
1470 :
1471 0 : size_t nSearchBeg = 0;
1472 0 : E3dScene* pScene = NULL;
1473 0 : SdrObject* pObjHit = (bPrev) ? pBtmObjHit : pTopObjHit;
1474 0 : bool bRemap = pObjHit->ISA(E3dCompoundObject)
1475 0 : && static_cast<E3dCompoundObject*>(pObjHit)->IsAOrdNumRemapCandidate(pScene);
1476 :
1477 0 : if(bPrev)
1478 : {
1479 0 : sal_uInt32 nOrdNumBtm(pBtmObjHit->GetOrdNum());
1480 :
1481 0 : if(bRemap)
1482 : {
1483 0 : nOrdNumBtm = pScene->RemapOrdNum(nOrdNumBtm);
1484 : }
1485 :
1486 0 : nSearchBeg = nOrdNumBtm + 1;
1487 : }
1488 : else
1489 : {
1490 0 : sal_uInt32 nOrdNumTop(pTopObjHit->GetOrdNum());
1491 :
1492 0 : if(bRemap)
1493 : {
1494 0 : nOrdNumTop = pScene->RemapOrdNum(nOrdNumTop);
1495 : }
1496 :
1497 0 : nSearchBeg = nOrdNumTop;
1498 : }
1499 :
1500 0 : size_t no=nSearchBeg;
1501 0 : SdrObject* pFndObj=NULL;
1502 0 : while (pFndObj==NULL && ((!bPrev && no>0) || (bPrev && no<nObjCount))) {
1503 0 : if (!bPrev) no--;
1504 : SdrObject* pObj;
1505 :
1506 0 : if(bRemap)
1507 : {
1508 0 : pObj = pObjList->GetObj(pScene->RemapOrdNum(no));
1509 : }
1510 : else
1511 : {
1512 0 : pObj = pObjList->GetObj(no);
1513 : }
1514 :
1515 0 : if (CheckSingleSdrObjectHit(aPt,sal_uInt16(nTol),pObj,pPV,SdrSearchOptions::TESTMARKABLE,0))
1516 : {
1517 0 : if (TryToFindMarkedObject(pObj)==SAL_MAX_SIZE) {
1518 0 : pFndObj=pObj;
1519 : } else {
1520 : // TODO: for performance reasons set on to Top or Btm, if necessary
1521 : }
1522 : }
1523 0 : if (bPrev) no++;
1524 : }
1525 0 : if (pFndObj!=NULL)
1526 : {
1527 0 : GetMarkedObjectListWriteAccess().DeleteMark(bPrev?nBtmMarkHit:nTopMarkHit);
1528 0 : GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pFndObj,pPV));
1529 0 : MarkListHasChanged();
1530 0 : AdjustMarkHdl();
1531 : }
1532 0 : return pFndObj!=NULL;
1533 : }
1534 :
1535 0 : bool SdrMarkView::MarkObj(const Rectangle& rRect, bool bUnmark)
1536 : {
1537 0 : bool bFnd=false;
1538 0 : Rectangle aR(rRect);
1539 : SdrObjList* pObjList;
1540 0 : BrkAction();
1541 0 : SdrPageView* pPV = GetSdrPageView();
1542 :
1543 0 : if(pPV)
1544 : {
1545 0 : pObjList=pPV->GetObjList();
1546 0 : Rectangle aFrm1(aR);
1547 0 : const size_t nObjCount = pObjList->GetObjCount();
1548 0 : for (size_t nO=0; nO<nObjCount; ++nO) {
1549 0 : SdrObject* pObj=pObjList->GetObj(nO);
1550 0 : Rectangle aRect(pObj->GetCurrentBoundRect());
1551 0 : if (aFrm1.IsInside(aRect)) {
1552 0 : if (!bUnmark) {
1553 0 : if (IsObjMarkable(pObj,pPV))
1554 : {
1555 0 : GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pObj,pPV));
1556 0 : bFnd=true;
1557 : }
1558 : } else {
1559 0 : const size_t nPos=TryToFindMarkedObject(pObj);
1560 0 : if (nPos!=SAL_MAX_SIZE)
1561 : {
1562 0 : GetMarkedObjectListWriteAccess().DeleteMark(nPos);
1563 0 : bFnd=true;
1564 : }
1565 : }
1566 : }
1567 : }
1568 : }
1569 0 : if (bFnd) {
1570 0 : SortMarkedObjects();
1571 0 : MarkListHasChanged();
1572 0 : AdjustMarkHdl();
1573 : }
1574 0 : return bFnd;
1575 : }
1576 :
1577 537 : void SdrMarkView::MarkObj(SdrObject* pObj, SdrPageView* pPV, bool bUnmark, bool bImpNoSetMarkHdl)
1578 : {
1579 537 : if (pObj!=NULL && pPV!=NULL && IsObjMarkable(pObj, pPV)) {
1580 535 : BrkAction();
1581 535 : if (!bUnmark)
1582 : {
1583 524 : GetMarkedObjectListWriteAccess().InsertEntry(SdrMark(pObj,pPV));
1584 : }
1585 : else
1586 : {
1587 11 : const size_t nPos=TryToFindMarkedObject(pObj);
1588 11 : if (nPos!=SAL_MAX_SIZE)
1589 : {
1590 0 : GetMarkedObjectListWriteAccess().DeleteMark(nPos);
1591 : }
1592 : }
1593 535 : if (!bImpNoSetMarkHdl) {
1594 458 : MarkListHasChanged();
1595 458 : AdjustMarkHdl();
1596 : }
1597 : }
1598 537 : }
1599 :
1600 4 : bool SdrMarkView::IsObjMarked(SdrObject* pObj) const
1601 : {
1602 4 : return TryToFindMarkedObject(pObj)!=SAL_MAX_SIZE;
1603 : }
1604 :
1605 8860 : sal_uInt16 SdrMarkView::GetMarkHdlSizePixel() const
1606 : {
1607 8860 : return maHdlList.GetHdlSize()*2+1;
1608 : }
1609 :
1610 4924 : void SdrMarkView::SetMarkHdlSizePixel(sal_uInt16 nSiz)
1611 : {
1612 4924 : if (nSiz<3) nSiz=3;
1613 4924 : nSiz/=2;
1614 4924 : if (nSiz!=maHdlList.GetHdlSize()) {
1615 3607 : maHdlList.SetHdlSize(nSiz);
1616 : }
1617 4924 : }
1618 :
1619 4703 : SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, SdrSearchOptions nOptions, const SetOfByte* pMVisLay) const
1620 : {
1621 4703 : if(((nOptions & SdrSearchOptions::IMPISMASTER) && pObj->IsNotVisibleAsMaster()) || (!pObj->IsVisible()))
1622 : {
1623 424 : return NULL;
1624 : }
1625 :
1626 4279 : const bool bCheckIfMarkable(nOptions & SdrSearchOptions::TESTMARKABLE);
1627 4279 : const bool bDeep(nOptions & SdrSearchOptions::DEEP);
1628 4279 : const bool bOLE(pObj->ISA(SdrOle2Obj));
1629 4279 : const bool bTXT(pObj->ISA(SdrTextObj) && static_cast<SdrTextObj*>(pObj)->IsTextFrame());
1630 4279 : SdrObject* pRet=NULL;
1631 4279 : Rectangle aRect(pObj->GetCurrentBoundRect());
1632 : // hack for calc grid sync
1633 4279 : aRect += pObj->GetGridOffset();
1634 4279 : sal_uInt16 nTol2(nTol);
1635 :
1636 : // double tolerance for OLE, text frames and objects in
1637 : // active text edit
1638 4279 : if(bOLE || bTXT || pObj==static_cast<const SdrObjEditView*>(this)->GetTextEditObject())
1639 : {
1640 1195 : nTol2*=2;
1641 : }
1642 :
1643 4279 : aRect.Left ()-=nTol2; // add 1 tolerance for all objects
1644 4279 : aRect.Top ()-=nTol2;
1645 4279 : aRect.Right ()+=nTol2;
1646 4279 : aRect.Bottom()+=nTol2;
1647 :
1648 4279 : if (aRect.IsInside(rPnt))
1649 : {
1650 141 : if ((!bCheckIfMarkable || IsObjMarkable(pObj,pPV)))
1651 : {
1652 80 : SdrObjList* pOL=pObj->GetSubList();
1653 :
1654 80 : if (pOL!=NULL && pOL->GetObjCount()!=0)
1655 : {
1656 : SdrObject* pTmpObj;
1657 : // adjustment hit point for virtual objects
1658 3 : Point aPnt( rPnt );
1659 :
1660 3 : if ( pObj->ISA(SdrVirtObj) )
1661 : {
1662 0 : Point aOffset = static_cast<SdrVirtObj*>(pObj)->GetOffset();
1663 0 : aPnt.Move( -aOffset.X(), -aOffset.Y() );
1664 : }
1665 :
1666 3 : pRet=CheckSingleSdrObjectHit(aPnt,nTol,pOL,pPV,nOptions,pMVisLay,pTmpObj);
1667 : }
1668 : else
1669 : {
1670 77 : if(!pMVisLay || pMVisLay->IsSet(pObj->GetLayer()))
1671 : {
1672 77 : pRet = SdrObjectPrimitiveHit(*pObj, rPnt, nTol2, *pPV, &pPV->GetVisibleLayers(), false);
1673 : }
1674 : }
1675 : }
1676 : }
1677 :
1678 4279 : if (!bDeep && pRet!=NULL)
1679 : {
1680 24 : pRet=pObj;
1681 : }
1682 :
1683 4279 : return pRet;
1684 : }
1685 :
1686 3 : SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList* pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SetOfByte* pMVisLay, SdrObject*& rpRootObj) const
1687 : {
1688 3 : return (*this).CheckSingleSdrObjectHit(rPnt,nTol,pOL,pPV,nOptions,pMVisLay,rpRootObj,NULL);
1689 : }
1690 3579 : SdrObject* SdrMarkView::CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList* pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SetOfByte* pMVisLay, SdrObject*& rpRootObj,const SdrMarkList * pMarkList) const
1691 : {
1692 3579 : bool bBack(nOptions & SdrSearchOptions::BACKWARD);
1693 3579 : bool bBefMrk(nOptions & SdrSearchOptions::BEFOREMARK);
1694 3579 : SdrObject* pRet=NULL;
1695 3579 : rpRootObj=NULL;
1696 3579 : if (pOL!=NULL)
1697 : {
1698 3579 : bool bRemap(pOL->GetOwnerObj() && pOL->GetOwnerObj()->ISA(E3dScene));
1699 3579 : E3dScene* pRemapScene = (bRemap ? static_cast<E3dScene*>(pOL->GetOwnerObj()) : 0L);
1700 :
1701 3579 : const size_t nObjCount=pOL->GetObjCount();
1702 3579 : size_t nObjNum=bBack ? 0 : nObjCount;
1703 11857 : while (pRet==NULL && (bBack ? nObjNum<nObjCount : nObjNum>0)) {
1704 4699 : if (!bBack) nObjNum--;
1705 : SdrObject* pObj;
1706 :
1707 4699 : if(bRemap)
1708 : {
1709 0 : pObj = pOL->GetObj(pRemapScene->RemapOrdNum(nObjNum));
1710 : }
1711 : else
1712 : {
1713 4699 : pObj = pOL->GetObj(nObjNum);
1714 : }
1715 4699 : if (bBefMrk)
1716 : {
1717 0 : if ((pMarkList)!=NULL)
1718 : {
1719 0 : if ((*pMarkList).FindObject(pObj)!=SAL_MAX_SIZE)
1720 : {
1721 0 : return NULL;
1722 : }
1723 : }
1724 : }
1725 4699 : pRet=CheckSingleSdrObjectHit(rPnt,nTol,pObj,pPV,nOptions,pMVisLay);
1726 4699 : if (pRet!=NULL) rpRootObj=pObj;
1727 4699 : if (bBack) nObjNum++;
1728 : }
1729 : }
1730 3579 : return pRet;
1731 : }
1732 :
1733 2563 : bool SdrMarkView::PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions) const
1734 : {
1735 2563 : return PickObj(rPnt,nTol,rpObj,rpPV,nOptions,NULL,NULL);
1736 : }
1737 :
1738 3261 : bool SdrMarkView::PickObj(const Point& rPnt, short nTol, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions, SdrObject** ppRootObj, bool* pbHitPassDirect) const
1739 : { // TODO: lacks a Pass2,Pass3
1740 3261 : SortMarkedObjects();
1741 3261 : if (ppRootObj!=NULL) *ppRootObj=NULL;
1742 3261 : if (pbHitPassDirect!=NULL) *pbHitPassDirect=true;
1743 3261 : rpObj=NULL;
1744 3261 : rpPV=NULL;
1745 3261 : bool bWholePage(nOptions & SdrSearchOptions::WHOLEPAGE);
1746 3261 : bool bMarked(nOptions & SdrSearchOptions::MARKED);
1747 3261 : bool bMasters=!bMarked && bool(nOptions & SdrSearchOptions::ALSOONMASTER);
1748 3261 : bool bBack(nOptions & SdrSearchOptions::BACKWARD);
1749 : #if OSL_DEBUG_LEVEL > 0
1750 : bool bNext(nOptions & SdrSearchOptions::NEXT); (void)bNext; // n.i.
1751 : bool bBoundCheckOn2ndPass(nOptions & SdrSearchOptions::PASS2BOUND); (void)bBoundCheckOn2ndPass;// n.i.
1752 : bool bCheckNearestOn3rdPass(nOptions & SdrSearchOptions::PASS3NEAREST); (void)bCheckNearestOn3rdPass;// n.i.
1753 : #endif
1754 3261 : if (nTol<0) nTol=ImpGetHitTolLogic(nTol,NULL);
1755 3261 : Point aPt(rPnt);
1756 3261 : SdrObject* pObj=NULL;
1757 3261 : SdrObject* pHitObj=NULL;
1758 3261 : SdrPageView* pPV=NULL;
1759 3261 : if (!bBack && static_cast<const SdrObjEditView*>(this)->IsTextEditFrameHit(rPnt)) {
1760 0 : pObj=static_cast<const SdrObjEditView*>(this)->GetTextEditObject();
1761 0 : pHitObj=pObj;
1762 0 : pPV=static_cast<const SdrObjEditView*>(this)->GetTextEditPageView();
1763 : }
1764 3261 : if (bMarked) {
1765 349 : const size_t nMrkAnz=GetMarkedObjectCount();
1766 349 : size_t nMrkNum=bBack ? 0 : nMrkAnz;
1767 702 : while (pHitObj==NULL && (bBack ? nMrkNum<nMrkAnz : nMrkNum>0)) {
1768 4 : if (!bBack) nMrkNum--;
1769 4 : SdrMark* pM=GetSdrMarkByIndex(nMrkNum);
1770 4 : pObj=pM->GetMarkedSdrObj();
1771 4 : pPV=pM->GetPageView();
1772 4 : pHitObj=CheckSingleSdrObjectHit(aPt,nTol,pObj,pPV,nOptions,NULL);
1773 4 : if (bBack) nMrkNum++;
1774 : }
1775 : }
1776 : else
1777 : {
1778 2912 : pPV = GetSdrPageView();
1779 :
1780 2912 : if(pPV)
1781 : {
1782 2912 : SdrPage* pPage=pPV->GetPage();
1783 2912 : sal_uInt16 nPgAnz=1;
1784 :
1785 2912 : if(bMasters && pPage->TRG_HasMasterPage())
1786 : {
1787 671 : nPgAnz++;
1788 : }
1789 :
1790 2912 : bool bExtraPassForWholePage=bWholePage && pPage!=pPV->GetObjList();
1791 2912 : if (bExtraPassForWholePage) nPgAnz++; // First search in AktObjList, then on the entire page
1792 2912 : sal_uInt16 nPgNum=bBack ? 0 : nPgAnz;
1793 9400 : while (pHitObj==NULL && (bBack ? nPgNum<nPgAnz : nPgNum>0)) {
1794 3576 : SdrSearchOptions nTmpOptions=nOptions;
1795 3576 : if (!bBack) nPgNum--;
1796 3576 : const SetOfByte* pMVisLay=NULL;
1797 3576 : SdrObjList* pObjList=NULL;
1798 3576 : if (pbHitPassDirect!=NULL) *pbHitPassDirect = true;
1799 3576 : if (nPgNum>=nPgAnz-1 || (bExtraPassForWholePage && nPgNum>=nPgAnz-2))
1800 : {
1801 2912 : pObjList=pPV->GetObjList();
1802 5824 : if (bExtraPassForWholePage && nPgNum==nPgAnz-2) {
1803 0 : pObjList=pPage;
1804 0 : if (pbHitPassDirect!=NULL) *pbHitPassDirect = false;
1805 : }
1806 : }
1807 : else
1808 : {
1809 : // otherwise MasterPage
1810 664 : SdrPage& rMasterPage = pPage->TRG_GetMasterPage();
1811 664 : pMVisLay = &pPage->TRG_GetMasterPageVisibleLayers();
1812 664 : pObjList = &rMasterPage;
1813 :
1814 664 : if (pbHitPassDirect!=NULL) *pbHitPassDirect = false;
1815 664 : nTmpOptions=nTmpOptions | SdrSearchOptions::IMPISMASTER;
1816 : }
1817 3576 : pHitObj=CheckSingleSdrObjectHit(aPt,nTol,pObjList,pPV,nTmpOptions,pMVisLay,pObj,&(GetMarkedObjectList()));
1818 3576 : if (bBack) nPgNum++;
1819 : }
1820 : }
1821 : }
1822 3261 : if (pHitObj!=NULL) {
1823 28 : if (ppRootObj!=NULL) *ppRootObj=pObj;
1824 28 : if (nOptions & SdrSearchOptions::DEEP) pObj=pHitObj;
1825 28 : if (nOptions & SdrSearchOptions::TESTTEXTEDIT) {
1826 0 : if (!pObj->HasTextEdit() || pPV->GetLockedLayers().IsSet(pObj->GetLayer())) {
1827 0 : pObj=NULL;
1828 : }
1829 : }
1830 28 : if (pObj!=NULL && (nOptions & SdrSearchOptions::TESTMACRO)) {
1831 1 : SdrObjMacroHitRec aHitRec;
1832 1 : aHitRec.aPos=aPt;
1833 1 : aHitRec.aDownPos=aPt;
1834 1 : aHitRec.nTol=nTol;
1835 1 : aHitRec.pVisiLayer=&pPV->GetVisibleLayers();
1836 1 : aHitRec.pPageView=pPV;
1837 1 : if (!pObj->HasMacro() || !pObj->IsMacroHit(aHitRec)) pObj=NULL;
1838 : }
1839 28 : if (pObj!=NULL && (nOptions & SdrSearchOptions::WITHTEXT) && pObj->GetOutlinerParaObject()==NULL) pObj=NULL;
1840 28 : if (pObj!=NULL && (nOptions & SdrSearchOptions::TESTTEXTAREA) && pPV)
1841 : {
1842 0 : if(!SdrObjectPrimitiveHit(*pObj, aPt, 0, *pPV, 0, true))
1843 : {
1844 0 : pObj = 0;
1845 : }
1846 : }
1847 28 : if (pObj!=NULL) {
1848 27 : rpObj=pObj;
1849 27 : rpPV=pPV;
1850 : }
1851 : }
1852 3261 : return rpObj!=NULL;
1853 : }
1854 :
1855 0 : bool SdrMarkView::PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions) const
1856 : {
1857 0 : SortMarkedObjects();
1858 0 : bool bBoundCheckOn2ndPass(nOptions & SdrSearchOptions::PASS2BOUND);
1859 0 : bool bCheckNearestOn3rdPass(nOptions & SdrSearchOptions::PASS3NEAREST);
1860 0 : rpObj=NULL;
1861 0 : rpPV=NULL;
1862 0 : Point aPt(rPnt);
1863 0 : sal_uInt16 nTol=(sal_uInt16)nHitTolLog;
1864 0 : bool bFnd=false;
1865 0 : const size_t nMarkCount=GetMarkedObjectCount();
1866 0 : for (size_t nMarkNum=nMarkCount; nMarkNum>0 && !bFnd;) {
1867 0 : --nMarkNum;
1868 0 : SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
1869 0 : SdrPageView* pPV=pM->GetPageView();
1870 0 : SdrObject* pObj=pM->GetMarkedSdrObj();
1871 0 : bFnd = 0 != CheckSingleSdrObjectHit(aPt,nTol,pObj,pPV,SdrSearchOptions::TESTMARKABLE,0);
1872 0 : if (bFnd) {
1873 0 : rpObj=pObj;
1874 0 : rpPV=pPV;
1875 : }
1876 : }
1877 0 : if ((bBoundCheckOn2ndPass || bCheckNearestOn3rdPass) && !bFnd) {
1878 0 : SdrObject* pBestObj=NULL;
1879 0 : SdrPageView* pBestPV=NULL;
1880 0 : sal_uIntPtr nBestDist=ULONG_MAX;
1881 0 : for (size_t nMarkNum=nMarkCount; nMarkNum>0 && !bFnd;) {
1882 0 : --nMarkNum;
1883 0 : SdrMark* pM=GetSdrMarkByIndex(nMarkNum);
1884 0 : SdrPageView* pPV=pM->GetPageView();
1885 0 : SdrObject* pObj=pM->GetMarkedSdrObj();
1886 0 : Rectangle aRect(pObj->GetCurrentBoundRect());
1887 0 : aRect.Left ()-=nTol;
1888 0 : aRect.Top ()-=nTol;
1889 0 : aRect.Right ()+=nTol;
1890 0 : aRect.Bottom()+=nTol;
1891 0 : if (aRect.IsInside(aPt)) {
1892 0 : bFnd=true;
1893 0 : rpObj=pObj;
1894 0 : rpPV=pPV;
1895 0 : } else if (bCheckNearestOn3rdPass) {
1896 0 : sal_uIntPtr nDist=0;
1897 0 : if (aPt.X()<aRect.Left()) nDist+=aRect.Left()-aPt.X();
1898 0 : if (aPt.X()>aRect.Right()) nDist+=aPt.X()-aRect.Right();
1899 0 : if (aPt.Y()<aRect.Top()) nDist+=aRect.Top()-aPt.Y();
1900 0 : if (aPt.Y()>aRect.Bottom()) nDist+=aPt.Y()-aRect.Bottom();
1901 0 : if (nDist<nBestDist) {
1902 0 : pBestObj=pObj;
1903 0 : pBestPV=pPV;
1904 : }
1905 : }
1906 : }
1907 0 : if (bCheckNearestOn3rdPass && !bFnd) {
1908 0 : rpObj=pBestObj;
1909 0 : rpPV=pBestPV;
1910 0 : bFnd=pBestObj!=NULL;
1911 : }
1912 : }
1913 0 : return bFnd;
1914 : }
1915 :
1916 :
1917 3122 : void SdrMarkView::UnmarkAllObj(SdrPageView* pPV)
1918 : {
1919 3122 : if (GetMarkedObjectCount()!=0) {
1920 279 : BrkAction();
1921 279 : if (pPV!=NULL)
1922 : {
1923 8 : GetMarkedObjectListWriteAccess().DeletePageView(*pPV);
1924 : }
1925 : else
1926 : {
1927 271 : GetMarkedObjectListWriteAccess().Clear();
1928 : }
1929 279 : pMarkedObj=NULL;
1930 279 : pMarkedPV=NULL;
1931 279 : MarkListHasChanged();
1932 279 : AdjustMarkHdl();
1933 : }
1934 3122 : }
1935 :
1936 0 : void SdrMarkView::MarkAllObj(SdrPageView* _pPV)
1937 : {
1938 0 : BrkAction();
1939 :
1940 0 : if(!_pPV)
1941 : {
1942 0 : _pPV = GetSdrPageView();
1943 : }
1944 :
1945 : // #i69171# _pPV may still be NULL if there is no SDrPageView (!), e.g. when inserting
1946 : // other files
1947 0 : if(_pPV)
1948 : {
1949 0 : const bool bMarkChg(GetMarkedObjectListWriteAccess().InsertPageView(*_pPV));
1950 :
1951 0 : if(bMarkChg)
1952 : {
1953 0 : MarkListHasChanged();
1954 : }
1955 : }
1956 :
1957 0 : if(GetMarkedObjectCount())
1958 : {
1959 0 : AdjustMarkHdl();
1960 : }
1961 0 : }
1962 :
1963 51281 : void SdrMarkView::AdjustMarkHdl()
1964 : {
1965 51281 : CheckMarked();
1966 51281 : SetMarkRects();
1967 51281 : SetMarkHandles();
1968 51281 : }
1969 :
1970 264 : Rectangle SdrMarkView::GetMarkedObjBoundRect() const
1971 : {
1972 264 : Rectangle aRect;
1973 528 : for (size_t nm=0; nm<GetMarkedObjectCount(); ++nm) {
1974 264 : SdrMark* pM=GetSdrMarkByIndex(nm);
1975 264 : SdrObject* pO=pM->GetMarkedSdrObj();
1976 264 : Rectangle aR1(pO->GetCurrentBoundRect());
1977 : // Ensure marked area includes the calc offset
1978 : // ( if applicable ) to sync to grid
1979 264 : aR1 += pO->GetGridOffset();
1980 264 : if (aRect.IsEmpty()) aRect=aR1;
1981 0 : else aRect.Union(aR1);
1982 : }
1983 264 : return aRect;
1984 : }
1985 :
1986 35478 : Point SdrMarkView::GetGridOffset() const
1987 : {
1988 35478 : Point aOffset;
1989 : // calculate the area occupied by the union of each marked object
1990 : // ( synced to grid ) and compare to the same unsynced area to calculate
1991 : // the offset. Hopefully that's the sensible thing to do
1992 35478 : const Rectangle& aGroupSyncedRect = GetMarkedObjRect();
1993 35478 : aOffset = aGroupSyncedRect.TopLeft() - aMarkedObjRectNoOffset.TopLeft();
1994 35478 : return aOffset;
1995 : }
1996 :
1997 71064 : const Rectangle& SdrMarkView::GetMarkedObjRect() const
1998 : {
1999 71064 : if (bMarkedObjRectDirty) {
2000 35491 : const_cast<SdrMarkView*>(this)->bMarkedObjRectDirty=false;
2001 35491 : Rectangle aRect;
2002 35491 : Rectangle aRect2;
2003 36015 : for (size_t nm=0; nm<GetMarkedObjectCount(); ++nm) {
2004 524 : SdrMark* pM=GetSdrMarkByIndex(nm);
2005 524 : SdrObject* pO=pM->GetMarkedSdrObj();
2006 524 : Rectangle aR1(pO->GetSnapRect());
2007 : // apply calc offset to marked object rect
2008 : // ( necessary for handles to be displayed in
2009 : // correct position )
2010 524 : if (aRect2.IsEmpty()) aRect2=aR1;
2011 273 : else aRect2.Union( aR1 );
2012 524 : aR1 += pO->GetGridOffset();
2013 524 : if (aRect.IsEmpty()) aRect=aR1;
2014 273 : else aRect.Union(aR1);
2015 : }
2016 35491 : const_cast<SdrMarkView*>(this)->aMarkedObjRect=aRect;
2017 35491 : const_cast<SdrMarkView*>(this)->aMarkedObjRectNoOffset=aRect2;
2018 : }
2019 71064 : return aMarkedObjRect;
2020 : }
2021 :
2022 :
2023 :
2024 1 : void SdrMarkView::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr, sal_uInt16 nVal, ImpTakeDescriptionOptions nOpt) const
2025 : {
2026 1 : rStr = ImpGetResStr(nStrCacheID);
2027 1 : sal_Int32 nPos = rStr.indexOf("%1");
2028 :
2029 1 : if(nPos != -1)
2030 : {
2031 1 : if(nOpt == ImpTakeDescriptionOptions::POINTS)
2032 : {
2033 0 : rStr = rStr.replaceAt(nPos, 2, GetDescriptionOfMarkedPoints());
2034 : }
2035 1 : else if(nOpt == ImpTakeDescriptionOptions::GLUEPOINTS)
2036 : {
2037 0 : rStr = rStr.replaceAt(nPos, 2, GetDescriptionOfMarkedGluePoints());
2038 : }
2039 : else
2040 : {
2041 1 : rStr = rStr.replaceAt(nPos, 2, GetDescriptionOfMarkedObjects());
2042 : }
2043 : }
2044 :
2045 1 : rStr = rStr.replaceFirst("%2", OUString::number( nVal ));
2046 1 : }
2047 :
2048 :
2049 :
2050 0 : bool SdrMarkView::EnterMarkedGroup()
2051 : {
2052 0 : bool bRet=false;
2053 : // We enter only the first group found (in only one PageView), because
2054 : // PageView::EnterGroup calls an AdjustMarkHdl.
2055 : // TODO: I'll have to prevent that via a flag.
2056 0 : SdrPageView* pPV = GetSdrPageView();
2057 :
2058 0 : if(pPV)
2059 : {
2060 0 : bool bEnter=false;
2061 0 : for (size_t nm = GetMarkedObjectCount(); nm > 0 && !bEnter;)
2062 : {
2063 0 : --nm;
2064 0 : SdrMark* pM=GetSdrMarkByIndex(nm);
2065 0 : if (pM->GetPageView()==pPV) {
2066 0 : SdrObject* pObj=pM->GetMarkedSdrObj();
2067 0 : if (pObj->IsGroupObject()) {
2068 0 : if (pPV->EnterGroup(pObj)) {
2069 0 : bRet=true;
2070 0 : bEnter=true;
2071 : }
2072 : }
2073 : }
2074 : }
2075 : }
2076 0 : return bRet;
2077 : }
2078 :
2079 :
2080 :
2081 4661 : void SdrMarkView::MarkListHasChanged()
2082 : {
2083 4661 : GetMarkedObjectListWriteAccess().SetNameDirty();
2084 4661 : SetEdgesOfMarkedNodesDirty();
2085 :
2086 4661 : bMarkedObjRectDirty=true;
2087 4661 : bMarkedPointsRectsDirty=true;
2088 : #ifdef DBG_UTIL
2089 : if (pItemBrowser!=nullptr) pItemBrowser->SetDirty();
2090 : #endif
2091 4661 : bool bOneEdgeMarked=false;
2092 4661 : if (GetMarkedObjectCount()==1) {
2093 366 : const SdrObject* pObj=GetMarkedObjectByIndex(0);
2094 366 : if (pObj->GetObjInventor()==SdrInventor) {
2095 365 : sal_uInt16 nIdent=pObj->GetObjIdentifier();
2096 365 : bOneEdgeMarked=nIdent==OBJ_EDGE;
2097 : }
2098 : }
2099 4661 : ImpSetGlueVisible4(bOneEdgeMarked);
2100 4661 : }
2101 :
2102 :
2103 :
2104 0 : void SdrMarkView::SetMoveOutside(bool bOn)
2105 : {
2106 0 : maHdlList.SetMoveOutside(bOn);
2107 0 : }
2108 :
2109 10021 : void SdrMarkView::SetDesignMode( bool _bOn )
2110 : {
2111 10021 : if ( bDesignMode != _bOn )
2112 : {
2113 8999 : bDesignMode = _bOn;
2114 8999 : SdrPageView* pPageView = GetSdrPageView();
2115 8999 : if ( pPageView )
2116 23 : pPageView->SetDesignMode( _bOn );
2117 : }
2118 10456 : }
2119 :
2120 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
