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