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