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