?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 3.6.0.4, tag libreoffice-3.6.0.4
[LibreOffice.git] / svx / source / svdraw / svdhdl.cxx
blob62c3aae7500bd5ce02e75a2358749b9ab592ec47
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*************************************************************************
3 *
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * Copyright 2000, 2010 Oracle and/or its affiliates.
7 *
8 * OpenOffice.org - a multi-platform office productivity suite
9 *
10 * This file is part of OpenOffice.org.
11 *
12 * OpenOffice.org is free software: you can redistribute it and/or modify
13 * it under the terms of the GNU Lesser General Public License version 3
14 * only, as published by the Free Software Foundation.
15 *
16 * OpenOffice.org is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License version 3 for more details
20 * (a copy is included in the LICENSE file that accompanied this code).
21 *
22 * You should have received a copy of the GNU Lesser General Public License
23 * version 3 along with OpenOffice.org. If not, see
24 * <http://www.openoffice.org/license.html>
25 * for a copy of the LGPLv3 License.
26 *
27 ************************************************************************/
28
29
30 #include <algorithm>
31
32 #include <svx/svdhdl.hxx>
33 #include <svx/svdpagv.hxx>
34 #include <svx/svdetc.hxx>
35 #include <svx/svdmrkv.hxx>
36 #include <vcl/window.hxx>
37
38 #include <vcl/virdev.hxx>
39 #include <tools/poly.hxx>
40 #include <vcl/bmpacc.hxx>
41
42 #include <svx/sxekitm.hxx>
43 #include "svx/svdstr.hrc"
44 #include "svx/svdglob.hxx"
45
46 #include <svx/svdmodel.hxx>
47 #include "gradtrns.hxx"
48 #include <svx/xflgrit.hxx>
49 #include <svx/svdundo.hxx>
50 #include <svx/dialmgr.hxx>
51 #include <svx/xflftrit.hxx>
52
53 // #105678#
54 #include <svx/svdopath.hxx>
55 #include <basegfx/vector/b2dvector.hxx>
56 #include <basegfx/polygon/b2dpolygon.hxx>
57 #include <svx/sdr/overlay/overlaymanager.hxx>
58 #include <svx/sdr/overlay/overlayanimatedbitmapex.hxx>
59 #include <svx/sdr/overlay/overlaybitmapex.hxx>
60 #include <svx/sdr/overlay/overlayline.hxx>
61 #include <svx/sdr/overlay/overlaytriangle.hxx>
62 #include <svx/sdr/overlay/overlayhatchrect.hxx>
63 #include <svx/sdrpagewindow.hxx>
64 #include <svx/sdrpaintwindow.hxx>
65 #include <vcl/svapp.hxx>
66 #include <svx/sdr/overlay/overlaypolypolygon.hxx>
67 #include <vcl/lazydelete.hxx>
68
69 ////////////////////////////////////////////////////////////////////////////////////////////////////
70 // #i15222#
71 // Due to the resource problems in Win95/98 with bitmap resources I
72 // will change this handle bitmap providing class. Old version was splitting
73 // and preparing all small handle bitmaps in device bitmap format, now this will
74 // be done on the fly. Thus, there is only one big bitmap in memory. With
75 // three source bitmaps, this will be 3 system bitmap resources instead of hundreds.
76 // The price for that needs to be evaluated. Maybe we will need another change here
77 // if this is too expensive.
78 class SdrHdlBitmapSet
79 {
80 // the bitmap holding all information
81 BitmapEx maMarkersBitmap;
82
83 // the cropped Bitmaps for reusage
84 ::std::vector< BitmapEx > maRealMarkers;
85
86 // helpers
87 BitmapEx& impGetOrCreateTargetBitmap(sal_uInt16 nIndex, const Rectangle& rRectangle);
88
89 public:
90 SdrHdlBitmapSet(sal_uInt16 nResId);
91 ~SdrHdlBitmapSet();
92
93 const BitmapEx& GetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd=0);
94 };
95
96 ////////////////////////////////////////////////////////////////////////////////////////////////////
97 #define KIND_COUNT (14)
98 #define INDEX_COUNT (6)
99 #define INDIVIDUAL_COUNT (4)
100
101 SdrHdlBitmapSet::SdrHdlBitmapSet(sal_uInt16 nResId)
102 : maMarkersBitmap(ResId(nResId, *ImpGetResMgr())),
103 // 14 kinds (BitmapMarkerKind) use index [0..5], 4 extra
104 maRealMarkers((KIND_COUNT * INDEX_COUNT) + INDIVIDUAL_COUNT)
105 {
106 }
107
108 SdrHdlBitmapSet::~SdrHdlBitmapSet()
109 {
110 }
111
112 BitmapEx& SdrHdlBitmapSet::impGetOrCreateTargetBitmap(sal_uInt16 nIndex, const Rectangle& rRectangle)
113 {
114 BitmapEx& rTargetBitmap = maRealMarkers[nIndex];
115
116 if(rTargetBitmap.IsEmpty())
117 {
118 rTargetBitmap = maMarkersBitmap;
119 rTargetBitmap.Crop(rRectangle);
120 }
121
122 return rTargetBitmap;
123 }
124
125 // change getting of bitmap to use the big resource bitmap
126 const BitmapEx& SdrHdlBitmapSet::GetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd)
127 {
128 // fill in size and source position in maMarkersBitmap
129 const sal_uInt16 nYPos(nInd * 11);
130
131 switch(eKindOfMarker)
132 {
133 default:
134 {
135 OSL_FAIL( "Unknown kind of marker." );
136 // no break here, return Rect_9x9 as default
137 }
138 case Rect_9x9:
139 {
140 return impGetOrCreateTargetBitmap((1 * INDEX_COUNT) + nInd, Rectangle(Point(7, nYPos), Size(9, 9)));
141 }
142
143 case Rect_7x7:
144 {
145 return impGetOrCreateTargetBitmap((0 * INDEX_COUNT) + nInd, Rectangle(Point(0, nYPos), Size(7, 7)));
146 }
147
148 case Rect_11x11:
149 {
150 return impGetOrCreateTargetBitmap((2 * INDEX_COUNT) + nInd, Rectangle(Point(16, nYPos), Size(11, 11)));
151 }
152
153 case Rect_13x13:
154 {
155 const sal_uInt16 nIndex((3 * INDEX_COUNT) + nInd);
156
157 switch(nInd)
158 {
159 case 0:
160 {
161 return impGetOrCreateTargetBitmap(nIndex, Rectangle(Point(72, 66), Size(13, 13)));
162 }
163 case 1:
164 {
165 return impGetOrCreateTargetBitmap(nIndex, Rectangle(Point(85, 66), Size(13, 13)));
166 }
167 case 2:
168 {
169 return impGetOrCreateTargetBitmap(nIndex, Rectangle(Point(72, 79), Size(13, 13)));
170 }
171 case 3:
172 {
173 return impGetOrCreateTargetBitmap(nIndex, Rectangle(Point(85, 79), Size(13, 13)));
174 }
175 case 4:
176 {
177 return impGetOrCreateTargetBitmap(nIndex, Rectangle(Point(98, 79), Size(13, 13)));
178 }
179 default: // case 5:
180 {
181 return impGetOrCreateTargetBitmap(nIndex, Rectangle(Point(98, 66), Size(13, 13)));
182 }
183 }
184 }
185
186 case Circ_7x7:
187 {
188 return impGetOrCreateTargetBitmap((4 * INDEX_COUNT) + nInd, Rectangle(Point(27, nYPos), Size(7, 7)));
189 }
190
191 case Circ_9x9:
192 case Customshape1:
193 {
194 return impGetOrCreateTargetBitmap((5 * INDEX_COUNT) + nInd, Rectangle(Point(34, nYPos), Size(9, 9)));
195 }
196
197 case Circ_11x11:
198 {
199 return impGetOrCreateTargetBitmap((6 * INDEX_COUNT) + nInd, Rectangle(Point(43, nYPos), Size(11, 11)));
200 }
201
202 case Elli_7x9:
203 {
204 return impGetOrCreateTargetBitmap((7 * INDEX_COUNT) + nInd, Rectangle(Point(54, nYPos), Size(7, 9)));
205 }
206
207 case Elli_9x11:
208 {
209 return impGetOrCreateTargetBitmap((8 * INDEX_COUNT) + nInd, Rectangle(Point(61, nYPos), Size(9, 11)));
210 }
211
212 case Elli_9x7:
213 {
214 return impGetOrCreateTargetBitmap((9 * INDEX_COUNT) + nInd, Rectangle(Point(70, nYPos), Size(9, 7)));
215 }
216
217 case Elli_11x9:
218 {
219 return impGetOrCreateTargetBitmap((10 * INDEX_COUNT) + nInd, Rectangle(Point(79, nYPos), Size(11, 9)));
220 }
221
222 case RectPlus_7x7:
223 {
224 return impGetOrCreateTargetBitmap((11 * INDEX_COUNT) + nInd, Rectangle(Point(90, nYPos), Size(7, 7)));
225 }
226
227 case RectPlus_9x9:
228 {
229 return impGetOrCreateTargetBitmap((12 * INDEX_COUNT) + nInd, Rectangle(Point(97, nYPos), Size(9, 9)));
230 }
231
232 case RectPlus_11x11:
233 {
234 return impGetOrCreateTargetBitmap((13 * INDEX_COUNT) + nInd, Rectangle(Point(106, nYPos), Size(11, 11)));
235 }
236
237 case Crosshair:
238 {
239 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 0, Rectangle(Point(0, 68), Size(15, 15)));
240 }
241
242 case Glue:
243 {
244 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 1, Rectangle(Point(15, 76), Size(9, 9)));
245 }
246
247 case Glue_Deselected:
248 {
249 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 1, Rectangle(Point(15, 67), Size(9, 9)));
250 }
251
252 case Anchor: // AnchorTR for SW
253 case AnchorTR:
254 {
255 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 2, Rectangle(Point(24, 67), Size(24, 24)));
256 }
257
258 // add AnchorPressed to be able to animate anchor control
259 case AnchorPressed:
260 case AnchorPressedTR:
261 {
262 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 3, Rectangle(Point(48, 67), Size(24, 24)));
263 }
264 }
265 }
266
267 ////////////////////////////////////////////////////////////////////////////////////////////////////
268
269 SdrHdl::SdrHdl():
270 pObj(NULL),
271 pPV(NULL),
272 pHdlList(NULL),
273 eKind(HDL_MOVE),
274 nDrehWink(0),
275 nObjHdlNum(0),
276 nPolyNum(0),
277 nPPntNum(0),
278 nSourceHdlNum(0),
279 bSelect(sal_False),
280 b1PixMore(sal_False),
281 bPlusHdl(sal_False),
282 mbMoveOutside(false),
283 mbMouseOver(false)
284 {
285 }
286
287 SdrHdl::SdrHdl(const Point& rPnt, SdrHdlKind eNewKind):
288 pObj(NULL),
289 pPV(NULL),
290 pHdlList(NULL),
291 aPos(rPnt),
292 eKind(eNewKind),
293 nDrehWink(0),
294 nObjHdlNum(0),
295 nPolyNum(0),
296 nPPntNum(0),
297 nSourceHdlNum(0),
298 bSelect(sal_False),
299 b1PixMore(sal_False),
300 bPlusHdl(sal_False),
301 mbMoveOutside(false),
302 mbMouseOver(false)
303 {
304 }
305
306 SdrHdl::~SdrHdl()
307 {
308 GetRidOfIAObject();
309 }
310
311 void SdrHdl::Set1PixMore(sal_Bool bJa)
312 {
313 if(b1PixMore != bJa)
314 {
315 b1PixMore = bJa;
316
317 // create new display
318 Touch();
319 }
320 }
321
322 void SdrHdl::SetMoveOutside( bool bMoveOutside )
323 {
324 if(mbMoveOutside != bMoveOutside)
325 {
326 mbMoveOutside = bMoveOutside;
327
328 // create new display
329 Touch();
330 }
331 }
332
333 void SdrHdl::SetDrehWink(long n)
334 {
335 if(nDrehWink != n)
336 {
337 nDrehWink = n;
338
339 // create new display
340 Touch();
341 }
342 }
343
344 void SdrHdl::SetPos(const Point& rPnt)
345 {
346 if(aPos != rPnt)
347 {
348 // remember new position
349 aPos = rPnt;
350
351 // create new display
352 Touch();
353 }
354 }
355
356 void SdrHdl::SetSelected(sal_Bool bJa)
357 {
358 if(bSelect != bJa)
359 {
360 // remember new value
361 bSelect = bJa;
362
363 // create new display
364 Touch();
365 }
366 }
367
368 void SdrHdl::SetHdlList(SdrHdlList* pList)
369 {
370 if(pHdlList != pList)
371 {
372 // rememver list
373 pHdlList = pList;
374
375 // now its possible to create graphic representation
376 Touch();
377 }
378 }
379
380 void SdrHdl::SetObj(SdrObject* pNewObj)
381 {
382 if(pObj != pNewObj)
383 {
384 // remember new object
385 pObj = pNewObj;
386
387 // graphic representation may have changed
388 Touch();
389 }
390 }
391
392 void SdrHdl::Touch()
393 {
394 // force update of graphic representation
395 CreateB2dIAObject();
396 }
397
398 void SdrHdl::GetRidOfIAObject()
399 {
400
401 // OVERLAYMANAGER
402 maOverlayGroup.clear();
403 }
404
405 void SdrHdl::CreateB2dIAObject()
406 {
407 // first throw away old one
408 GetRidOfIAObject();
409
410 if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden())
411 {
412 BitmapColorIndex eColIndex = LightGreen;
413 BitmapMarkerKind eKindOfMarker = Rect_7x7;
414
415 sal_Bool bRot = pHdlList->IsRotateShear();
416 if(pObj)
417 eColIndex = (bSelect) ? Cyan : LightCyan;
418 if(bRot)
419 {
420 // red rotation handles
421 if(pObj && bSelect)
422 eColIndex = Red;
423 else
424 eColIndex = LightRed;
425 }
426
427 switch(eKind)
428 {
429 case HDL_MOVE:
430 {
431 eKindOfMarker = (b1PixMore) ? Rect_9x9 : Rect_7x7;
432 break;
433 }
434 case HDL_UPLFT:
435 case HDL_UPRGT:
436 case HDL_LWLFT:
437 case HDL_LWRGT:
438 {
439 // corner handles
440 if(bRot)
441 {
442 eKindOfMarker = Circ_7x7;
443 }
444 else
445 {
446 eKindOfMarker = Rect_7x7;
447 }
448 break;
449 }
450 case HDL_UPPER:
451 case HDL_LOWER:
452 {
453 // Upper/Lower handles
454 if(bRot)
455 {
456 eKindOfMarker = Elli_9x7;
457 }
458 else
459 {
460 eKindOfMarker = Rect_7x7;
461 }
462 break;
463 }
464 case HDL_LEFT:
465 case HDL_RIGHT:
466 {
467 // Left/Right handles
468 if(bRot)
469 {
470 eKindOfMarker = Elli_7x9;
471 }
472 else
473 {
474 eKindOfMarker = Rect_7x7;
475 }
476 break;
477 }
478 case HDL_POLY:
479 {
480 if(bRot)
481 {
482 eKindOfMarker = (b1PixMore) ? Circ_9x9 : Circ_7x7;
483 }
484 else
485 {
486 eKindOfMarker = (b1PixMore) ? Rect_9x9 : Rect_7x7;
487 }
488 break;
489 }
490 case HDL_BWGT: // weight at poly
491 {
492 eKindOfMarker = Circ_7x7;
493 break;
494 }
495 case HDL_CIRC:
496 {
497 eKindOfMarker = Rect_11x11;
498 break;
499 }
500 case HDL_REF1:
501 case HDL_REF2:
502 {
503 eKindOfMarker = Crosshair;
504 break;
505 }
506 case HDL_GLUE:
507 {
508 eKindOfMarker = Glue;
509 break;
510 }
511 case HDL_GLUE_DESELECTED:
512 {
513 eKindOfMarker = Glue_Deselected;
514 break;
515 }
516 case HDL_ANCHOR:
517 {
518 eKindOfMarker = Anchor;
519 break;
520 }
521 case HDL_USER:
522 {
523 break;
524 }
525 // top right anchor for SW
526 case HDL_ANCHOR_TR:
527 {
528 eKindOfMarker = AnchorTR;
529 break;
530 }
531
532 // for SJ and the CustomShapeHandles:
533 case HDL_CUSTOMSHAPE1:
534 {
535 eKindOfMarker = Customshape1;
536 eColIndex = Yellow;
537 break;
538 }
539 default:
540 break;
541 }
542
543 SdrMarkView* pView = pHdlList->GetView();
544 SdrPageView* pPageView = pView->GetSdrPageView();
545
546 if(pPageView)
547 {
548 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
549 {
550 // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b];
551 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
552
553 if(rPageWindow.GetPaintWindow().OutputToWindow())
554 {
555 Point aMoveOutsideOffset(0, 0);
556
557 // add offset if necessary
558 if(pHdlList->IsMoveOutside() || mbMoveOutside)
559 {
560 OutputDevice& rOutDev = rPageWindow.GetPaintWindow().GetOutputDevice();
561 Size aOffset = rOutDev.PixelToLogic(Size(4, 4));
562
563 if(eKind == HDL_UPLFT || eKind == HDL_UPPER || eKind == HDL_UPRGT)
564 aMoveOutsideOffset.Y() -= aOffset.Width();
565 if(eKind == HDL_LWLFT || eKind == HDL_LOWER || eKind == HDL_LWRGT)
566 aMoveOutsideOffset.Y() += aOffset.Height();
567 if(eKind == HDL_UPLFT || eKind == HDL_LEFT || eKind == HDL_LWLFT)
568 aMoveOutsideOffset.X() -= aOffset.Width();
569 if(eKind == HDL_UPRGT || eKind == HDL_RIGHT || eKind == HDL_LWRGT)
570 aMoveOutsideOffset.X() += aOffset.Height();
571 }
572
573 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
574 if (xManager.is())
575 {
576 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
577 ::sdr::overlay::OverlayObject* pNewOverlayObject = CreateOverlayObject(
578 aPosition,
579 eColIndex,
580 eKindOfMarker,
581 aMoveOutsideOffset);
582
583 // OVERLAYMANAGER
584 if(pNewOverlayObject)
585 {
586 xManager->add(*pNewOverlayObject);
587 maOverlayGroup.append(*pNewOverlayObject);
588 }
589 }
590 }
591 }
592 }
593 }
594 }
595
596 BitmapMarkerKind SdrHdl::GetNextBigger(BitmapMarkerKind eKnd) const
597 {
598 BitmapMarkerKind eRetval(eKnd);
599
600 switch(eKnd)
601 {
602 case Rect_7x7: eRetval = Rect_9x9; break;
603 case Rect_9x9: eRetval = Rect_11x11; break;
604 case Rect_11x11: eRetval = Rect_13x13; break;
605
606 case Circ_7x7: eRetval = Circ_9x9; break;
607 case Circ_9x9: eRetval = Circ_11x11; break;
608
609 case Elli_7x9: eRetval = Elli_9x11; break;
610
611 case Elli_9x7: eRetval = Elli_11x9; break;
612
613 case RectPlus_7x7: eRetval = RectPlus_9x9; break;
614 case RectPlus_9x9: eRetval = RectPlus_11x11; break;
615
616 // let anchor blink with its pressed state
617 case Anchor: eRetval = AnchorPressed; break;
618
619 // same for AnchorTR
620 case AnchorTR: eRetval = AnchorPressedTR; break;
621 default:
622 break;
623 }
624
625 return eRetval;
626 }
627
628 BitmapEx SdrHdl::ImpGetBitmapEx( BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd)
629 {
630 static vcl::DeleteOnDeinit< SdrHdlBitmapSet > aModernSet(new SdrHdlBitmapSet(SIP_SA_MARKERS));
631 return aModernSet.get()->GetBitmapEx(eKindOfMarker, nInd);
632 }
633
634 ::sdr::overlay::OverlayObject* SdrHdl::CreateOverlayObject(
635 const basegfx::B2DPoint& rPos,
636 BitmapColorIndex eColIndex, BitmapMarkerKind eKindOfMarker, Point aMoveOutsideOffset)
637 {
638 ::sdr::overlay::OverlayObject* pRetval = 0L;
639
640 // support bigger sizes
641 sal_Bool bForceBiggerSize(sal_False);
642
643 if(pHdlList->GetHdlSize() > 3)
644 {
645 bForceBiggerSize = sal_True;
646 }
647
648 if(bForceBiggerSize)
649 {
650 eKindOfMarker = GetNextBigger(eKindOfMarker);
651 }
652
653 // This handle has the focus, visualize it
654 if(IsFocusHdl() && pHdlList && pHdlList->GetFocusHdl() == this)
655 {
656 // create animated handle
657 BitmapMarkerKind eNextBigger = GetNextBigger(eKindOfMarker);
658
659 if(eNextBigger == eKindOfMarker)
660 {
661 // this may happen for the not supported getting-bigger types.
662 // Choose an alternative here
663 switch(eKindOfMarker)
664 {
665 case Rect_13x13: eNextBigger = Rect_11x11; break;
666 case Circ_11x11: eNextBigger = Elli_11x9; break;
667 case Elli_9x11: eNextBigger = Elli_11x9; break;
668 case Elli_11x9: eNextBigger = Elli_9x11; break;
669 case RectPlus_11x11: eNextBigger = Rect_13x13; break;
670
671 case Crosshair:
672 eNextBigger = Glue;
673 break;
674
675 case Glue:
676 eNextBigger = Crosshair;
677 break;
678 case Glue_Deselected:
679 eNextBigger = Glue;
680 break;
681 default:
682 break;
683 }
684 }
685
686 // create animated handle
687 BitmapEx aBmpEx1 = ImpGetBitmapEx( eKindOfMarker, (sal_uInt16)eColIndex );
688 BitmapEx aBmpEx2 = ImpGetBitmapEx( eNextBigger, (sal_uInt16)eColIndex );
689
690 // #i53216# Use system cursor blink time. Use the unsigned value.
691 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
692 const sal_uInt32 nBlinkTime((sal_uInt32)rStyleSettings.GetCursorBlinkTime());
693
694 if(eKindOfMarker == Anchor || eKindOfMarker == AnchorPressed)
695 {
696 // when anchor is used take upper left as reference point inside the handle
697 pRetval = new ::sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime);
698 }
699 else if(eKindOfMarker == AnchorTR || eKindOfMarker == AnchorPressedTR)
700 {
701 // AnchorTR for SW, take top right as (0,0)
702 pRetval = new ::sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime,
703 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1), 0,
704 (sal_uInt16)(aBmpEx2.GetSizePixel().Width() - 1), 0);
705 }
706 else
707 {
708 // create centered handle as default
709 pRetval = new ::sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime,
710 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1) >> 1,
711 (sal_uInt16)(aBmpEx1.GetSizePixel().Height() - 1) >> 1,
712 (sal_uInt16)(aBmpEx2.GetSizePixel().Width() - 1) >> 1,
713 (sal_uInt16)(aBmpEx2.GetSizePixel().Height() - 1) >> 1);
714 }
715 }
716 else
717 {
718 // create normal handle: use ImpGetBitmapEx(...) now
719 BitmapEx aBmpEx = ImpGetBitmapEx(eKindOfMarker, (sal_uInt16)eColIndex);
720
721 if(eKindOfMarker == Anchor || eKindOfMarker == AnchorPressed)
722 {
723 // upper left as reference point inside the handle for AnchorPressed, too
724 pRetval = new ::sdr::overlay::OverlayBitmapEx(rPos, aBmpEx);
725 }
726 else if(eKindOfMarker == AnchorTR || eKindOfMarker == AnchorPressedTR)
727 {
728 // AnchorTR for SW, take top right as (0,0)
729 pRetval = new ::sdr::overlay::OverlayBitmapEx(rPos, aBmpEx,
730 (sal_uInt16)(aBmpEx.GetSizePixel().Width() - 1), 0);
731 }
732 else
733 {
734 sal_uInt16 nCenX((sal_uInt16)(aBmpEx.GetSizePixel().Width() - 1L) >> 1);
735 sal_uInt16 nCenY((sal_uInt16)(aBmpEx.GetSizePixel().Height() - 1L) >> 1);
736
737 if(aMoveOutsideOffset.X() > 0)
738 {
739 nCenX = 0;
740 }
741 else if(aMoveOutsideOffset.X() < 0)
742 {
743 nCenX = (sal_uInt16)(aBmpEx.GetSizePixel().Width() - 1);
744 }
745
746 if(aMoveOutsideOffset.Y() > 0)
747 {
748 nCenY = 0;
749 }
750 else if(aMoveOutsideOffset.Y() < 0)
751 {
752 nCenY = (sal_uInt16)(aBmpEx.GetSizePixel().Height() - 1);
753 }
754
755 // create centered handle as default
756 pRetval = new ::sdr::overlay::OverlayBitmapEx(rPos, aBmpEx, nCenX, nCenY);
757 }
758 }
759
760 return pRetval;
761 }
762
763 bool SdrHdl::IsHdlHit(const Point& rPnt) const
764 {
765 // OVERLAYMANAGER
766 basegfx::B2DPoint aPosition(rPnt.X(), rPnt.Y());
767 return maOverlayGroup.isHitLogic(aPosition);
768 }
769
770 Pointer SdrHdl::GetPointer() const
771 {
772 PointerStyle ePtr=POINTER_MOVE;
773 const sal_Bool bSize=eKind>=HDL_UPLFT && eKind<=HDL_LWRGT;
774 const sal_Bool bRot=pHdlList!=NULL && pHdlList->IsRotateShear();
775 const sal_Bool bDis=pHdlList!=NULL && pHdlList->IsDistortShear();
776 if (bSize && pHdlList!=NULL && (bRot || bDis)) {
777 switch (eKind) {
778 case HDL_UPLFT: case HDL_UPRGT:
779 case HDL_LWLFT: case HDL_LWRGT: ePtr=bRot ? POINTER_ROTATE : POINTER_REFHAND; break;
780 case HDL_LEFT : case HDL_RIGHT: ePtr=POINTER_VSHEAR; break;
781 case HDL_UPPER: case HDL_LOWER: ePtr=POINTER_HSHEAR; break;
782 default:
783 break;
784 }
785 } else {
786 // When resizing rotated rectangles, rotate the mouse cursor slightly, too
787 if (bSize && nDrehWink!=0) {
788 long nHdlWink=0;
789 switch (eKind) {
790 case HDL_LWRGT: nHdlWink=31500; break;
791 case HDL_LOWER: nHdlWink=27000; break;
792 case HDL_LWLFT: nHdlWink=22500; break;
793 case HDL_LEFT : nHdlWink=18000; break;
794 case HDL_UPLFT: nHdlWink=13500; break;
795 case HDL_UPPER: nHdlWink=9000; break;
796 case HDL_UPRGT: nHdlWink=4500; break;
797 case HDL_RIGHT: nHdlWink=0; break;
798 default:
799 break;
800 }
801 nHdlWink+=nDrehWink+2249; // a little bit more (for rounding)
802 while (nHdlWink<0) nHdlWink+=36000;
803 while (nHdlWink>=36000) nHdlWink-=36000;
804 nHdlWink/=4500;
805 switch ((sal_uInt8)nHdlWink) {
806 case 0: ePtr=POINTER_ESIZE; break;
807 case 1: ePtr=POINTER_NESIZE; break;
808 case 2: ePtr=POINTER_NSIZE; break;
809 case 3: ePtr=POINTER_NWSIZE; break;
810 case 4: ePtr=POINTER_WSIZE; break;
811 case 5: ePtr=POINTER_SWSIZE; break;
812 case 6: ePtr=POINTER_SSIZE; break;
813 case 7: ePtr=POINTER_SESIZE; break;
814 } // switch
815 } else {
816 switch (eKind) {
817 case HDL_UPLFT: ePtr=POINTER_NWSIZE; break;
818 case HDL_UPPER: ePtr=POINTER_NSIZE; break;
819 case HDL_UPRGT: ePtr=POINTER_NESIZE; break;
820 case HDL_LEFT : ePtr=POINTER_WSIZE; break;
821 case HDL_RIGHT: ePtr=POINTER_ESIZE; break;
822 case HDL_LWLFT: ePtr=POINTER_SWSIZE; break;
823 case HDL_LOWER: ePtr=POINTER_SSIZE; break;
824 case HDL_LWRGT: ePtr=POINTER_SESIZE; break;
825 case HDL_POLY : ePtr=POINTER_MOVEPOINT; break;
826 case HDL_CIRC : ePtr=POINTER_HAND; break;
827 case HDL_REF1 : ePtr=POINTER_REFHAND; break;
828 case HDL_REF2 : ePtr=POINTER_REFHAND; break;
829 case HDL_BWGT : ePtr=POINTER_MOVEBEZIERWEIGHT; break;
830 case HDL_GLUE : ePtr=POINTER_MOVEPOINT; break;
831 case HDL_GLUE_DESELECTED : ePtr=POINTER_MOVEPOINT; break;
832 case HDL_CUSTOMSHAPE1 : ePtr=POINTER_HAND; break;
833 default:
834 break;
835 }
836 }
837 }
838 return Pointer(ePtr);
839 }
840
841 sal_Bool SdrHdl::IsFocusHdl() const
842 {
843 switch(eKind)
844 {
845 case HDL_UPLFT:
846 case HDL_UPPER:
847 case HDL_UPRGT:
848 case HDL_LEFT:
849 case HDL_RIGHT:
850 case HDL_LWLFT:
851 case HDL_LOWER:
852 case HDL_LWRGT:
853 {
854 // if it's an activated TextEdit, it's moved to extended points
855 if(pHdlList && pHdlList->IsMoveOutside())
856 return sal_False;
857 else
858 return sal_True;
859 }
860
861 case HDL_MOVE: // handle to move object
862 case HDL_POLY: // selected point of polygon or curve
863 case HDL_BWGT: // weight at a curve
864 case HDL_CIRC: // angle of circle segments, corner radius of rectangles
865 case HDL_REF1: // reference point 1, e. g. center of rotation
866 case HDL_REF2: // reference point 2, e. g. endpoint of reflection axis
867 case HDL_GLUE: // glue point
868 case HDL_GLUE_DESELECTED: // deselected glue point, used to be a little blue cross
869
870 // for SJ and the CustomShapeHandles:
871 case HDL_CUSTOMSHAPE1:
872
873 case HDL_USER:
874 {
875 return sal_True;
876 }
877
878 default:
879 {
880 return sal_False;
881 }
882 }
883 }
884
885 void SdrHdl::onMouseEnter(const MouseEvent& /*rMEvt*/)
886 {
887 }
888
889 void SdrHdl::onMouseLeave()
890 {
891 }
892
893 ////////////////////////////////////////////////////////////////////////////////////////////////////
894 // class SdrHdlColor
895
896 SdrHdlColor::SdrHdlColor(const Point& rRef, Color aCol, const Size& rSize, sal_Bool bLum)
897 : SdrHdl(rRef, HDL_COLR),
898 aMarkerSize(rSize),
899 bUseLuminance(bLum)
900 {
901 if(IsUseLuminance())
902 aCol = GetLuminance(aCol);
903
904 // remember color
905 aMarkerColor = aCol;
906 }
907
908 SdrHdlColor::~SdrHdlColor()
909 {
910 }
911
912 void SdrHdlColor::CreateB2dIAObject()
913 {
914 // first throw away old one
915 GetRidOfIAObject();
916
917 if(pHdlList)
918 {
919 SdrMarkView* pView = pHdlList->GetView();
920
921 if(pView && !pView->areMarkHandlesHidden())
922 {
923 SdrPageView* pPageView = pView->GetSdrPageView();
924
925 if(pPageView)
926 {
927 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
928 {
929 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
930
931 if(rPageWindow.GetPaintWindow().OutputToWindow())
932 {
933 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
934 if (xManager.is())
935 {
936 Bitmap aBmpCol(CreateColorDropper(aMarkerColor));
937 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
938 ::sdr::overlay::OverlayObject* pNewOverlayObject = new
939 ::sdr::overlay::OverlayBitmapEx(
940 aPosition,
941 BitmapEx(aBmpCol),
942 (sal_uInt16)(aBmpCol.GetSizePixel().Width() - 1) >> 1,
943 (sal_uInt16)(aBmpCol.GetSizePixel().Height() - 1) >> 1
944 );
945 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
946
947 // OVERLAYMANAGER
948 if(pNewOverlayObject)
949 {
950 xManager->add(*pNewOverlayObject);
951 maOverlayGroup.append(*pNewOverlayObject);
952 }
953 }
954 }
955 }
956 }
957 }
958 }
959 }
960
961 Bitmap SdrHdlColor::CreateColorDropper(Color aCol)
962 {
963 // get the Bitmap
964 Bitmap aRetval(aMarkerSize, 24);
965 aRetval.Erase(aCol);
966
967 // get write access
968 BitmapWriteAccess* pWrite = aRetval.AcquireWriteAccess();
969 DBG_ASSERT(pWrite, "Got NO write access to a new Bitmap!");
970
971 if(pWrite)
972 {
973 // draw outer border
974 sal_Int32 nWidth = aMarkerSize.Width();
975 sal_Int32 nHeight = aMarkerSize.Height();
976
977 pWrite->SetLineColor(Color(COL_LIGHTGRAY));
978 pWrite->DrawLine(Point(0, 0), Point(0, nHeight - 1));
979 pWrite->DrawLine(Point(1, 0), Point(nWidth - 1, 0));
980 pWrite->SetLineColor(Color(COL_GRAY));
981 pWrite->DrawLine(Point(1, nHeight - 1), Point(nWidth - 1, nHeight - 1));
982 pWrite->DrawLine(Point(nWidth - 1, 1), Point(nWidth - 1, nHeight - 2));
983
984 // draw lighter UpperLeft
985 const Color aLightColor(
986 (sal_uInt8)(::std::min((sal_Int16)((sal_Int16)aCol.GetRed() + (sal_Int16)0x0040), (sal_Int16)0x00ff)),
987 (sal_uInt8)(::std::min((sal_Int16)((sal_Int16)aCol.GetGreen() + (sal_Int16)0x0040), (sal_Int16)0x00ff)),
988 (sal_uInt8)(::std::min((sal_Int16)((sal_Int16)aCol.GetBlue() + (sal_Int16)0x0040), (sal_Int16)0x00ff)));
989 pWrite->SetLineColor(aLightColor);
990 pWrite->DrawLine(Point(1, 1), Point(1, nHeight - 2));
991 pWrite->DrawLine(Point(2, 1), Point(nWidth - 2, 1));
992
993 // draw darker LowerRight
994 const Color aDarkColor(
995 (sal_uInt8)(::std::max((sal_Int16)((sal_Int16)aCol.GetRed() - (sal_Int16)0x0040), (sal_Int16)0x0000)),
996 (sal_uInt8)(::std::max((sal_Int16)((sal_Int16)aCol.GetGreen() - (sal_Int16)0x0040), (sal_Int16)0x0000)),
997 (sal_uInt8)(::std::max((sal_Int16)((sal_Int16)aCol.GetBlue() - (sal_Int16)0x0040), (sal_Int16)0x0000)));
998 pWrite->SetLineColor(aDarkColor);
999 pWrite->DrawLine(Point(2, nHeight - 2), Point(nWidth - 2, nHeight - 2));
1000 pWrite->DrawLine(Point(nWidth - 2, 2), Point(nWidth - 2, nHeight - 3));
1001
1002 // get rid of write access
1003 delete pWrite;
1004 }
1005
1006 return aRetval;
1007 }
1008
1009 Color SdrHdlColor::GetLuminance(const Color& rCol)
1010 {
1011 sal_uInt8 aLum = rCol.GetLuminance();
1012 Color aRetval(aLum, aLum, aLum);
1013 return aRetval;
1014 }
1015
1016 void SdrHdlColor::CallColorChangeLink()
1017 {
1018 aColorChangeHdl.Call(this);
1019 }
1020
1021 void SdrHdlColor::SetColor(Color aNew, sal_Bool bCallLink)
1022 {
1023 if(IsUseLuminance())
1024 aNew = GetLuminance(aNew);
1025
1026 if(aMarkerColor != aNew)
1027 {
1028 // remember new color
1029 aMarkerColor = aNew;
1030
1031 // create new display
1032 Touch();
1033
1034 // tell about change
1035 if(bCallLink)
1036 CallColorChangeLink();
1037 }
1038 }
1039
1040 void SdrHdlColor::SetSize(const Size& rNew)
1041 {
1042 if(rNew != aMarkerSize)
1043 {
1044 // remember new size
1045 aMarkerSize = rNew;
1046
1047 // create new display
1048 Touch();
1049 }
1050 }
1051
1052 ////////////////////////////////////////////////////////////////////////////////////////////////////
1053 // class SdrHdlGradient
1054
1055 SdrHdlGradient::SdrHdlGradient(const Point& rRef1, const Point& rRef2, sal_Bool bGrad)
1056 : SdrHdl(rRef1, bGrad ? HDL_GRAD : HDL_TRNS),
1057 pColHdl1(NULL),
1058 pColHdl2(NULL),
1059 a2ndPos(rRef2),
1060 bGradient(bGrad)
1061 {
1062 }
1063
1064 SdrHdlGradient::~SdrHdlGradient()
1065 {
1066 }
1067
1068 void SdrHdlGradient::Set2ndPos(const Point& rPnt)
1069 {
1070 if(a2ndPos != rPnt)
1071 {
1072 // remember new position
1073 a2ndPos = rPnt;
1074
1075 // create new display
1076 Touch();
1077 }
1078 }
1079
1080 void SdrHdlGradient::CreateB2dIAObject()
1081 {
1082 // first throw away old one
1083 GetRidOfIAObject();
1084
1085 if(pHdlList)
1086 {
1087 SdrMarkView* pView = pHdlList->GetView();
1088
1089 if(pView && !pView->areMarkHandlesHidden())
1090 {
1091 SdrPageView* pPageView = pView->GetSdrPageView();
1092
1093 if(pPageView)
1094 {
1095 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1096 {
1097 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1098
1099 if(rPageWindow.GetPaintWindow().OutputToWindow())
1100 {
1101 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1102 if (xManager.is())
1103 {
1104 // striped line in between
1105 basegfx::B2DVector aVec(a2ndPos.X() - aPos.X(), a2ndPos.Y() - aPos.Y());
1106 double fVecLen = aVec.getLength();
1107 double fLongPercentArrow = (1.0 - 0.05) * fVecLen;
1108 double fHalfArrowWidth = (0.05 * 0.5) * fVecLen;
1109 aVec.normalize();
1110 basegfx::B2DVector aPerpend(-aVec.getY(), aVec.getX());
1111 sal_Int32 nMidX = (sal_Int32)(aPos.X() + aVec.getX() * fLongPercentArrow);
1112 sal_Int32 nMidY = (sal_Int32)(aPos.Y() + aVec.getY() * fLongPercentArrow);
1113 Point aMidPoint(nMidX, nMidY);
1114
1115 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1116 basegfx::B2DPoint aMidPos(aMidPoint.X(), aMidPoint.Y());
1117
1118 ::sdr::overlay::OverlayObject* pNewOverlayObject = new
1119 ::sdr::overlay::OverlayLineStriped(
1120 aPosition, aMidPos
1121 );
1122 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1123
1124 pNewOverlayObject->setBaseColor(IsGradient() ? Color(COL_BLACK) : Color(COL_BLUE));
1125 xManager->add(*pNewOverlayObject);
1126 maOverlayGroup.append(*pNewOverlayObject);
1127
1128 // arrowhead
1129 Point aLeft(aMidPoint.X() + (sal_Int32)(aPerpend.getX() * fHalfArrowWidth),
1130 aMidPoint.Y() + (sal_Int32)(aPerpend.getY() * fHalfArrowWidth));
1131 Point aRight(aMidPoint.X() - (sal_Int32)(aPerpend.getX() * fHalfArrowWidth),
1132 aMidPoint.Y() - (sal_Int32)(aPerpend.getY() * fHalfArrowWidth));
1133
1134 basegfx::B2DPoint aPositionLeft(aLeft.X(), aLeft.Y());
1135 basegfx::B2DPoint aPositionRight(aRight.X(), aRight.Y());
1136 basegfx::B2DPoint aPosition2(a2ndPos.X(), a2ndPos.Y());
1137
1138 pNewOverlayObject = new
1139 ::sdr::overlay::OverlayTriangle(
1140 aPositionLeft,
1141 aPosition2,
1142 aPositionRight,
1143 IsGradient() ? Color(COL_BLACK) : Color(COL_BLUE)
1144 );
1145 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1146
1147 xManager->add(*pNewOverlayObject);
1148 maOverlayGroup.append(*pNewOverlayObject);
1149 }
1150 }
1151 }
1152 }
1153 }
1154 }
1155 }
1156
1157 IMPL_LINK(SdrHdlGradient, ColorChangeHdl, SdrHdl*, /*pHdl*/)
1158 {
1159 if(GetObj())
1160 FromIAOToItem(GetObj(), sal_True, sal_True);
1161 return 0;
1162 }
1163
1164 void SdrHdlGradient::FromIAOToItem(SdrObject* _pObj, sal_Bool bSetItemOnObject, sal_Bool bUndo)
1165 {
1166 // from IAO positions and colors to gradient
1167 const SfxItemSet& rSet = _pObj->GetMergedItemSet();
1168
1169 GradTransformer aGradTransformer;
1170 GradTransGradient aOldGradTransGradient;
1171 GradTransGradient aGradTransGradient;
1172 GradTransVector aGradTransVector;
1173
1174 String aString;
1175
1176 aGradTransVector.maPositionA = basegfx::B2DPoint(GetPos().X(), GetPos().Y());
1177 aGradTransVector.maPositionB = basegfx::B2DPoint(Get2ndPos().X(), Get2ndPos().Y());
1178 if(pColHdl1)
1179 aGradTransVector.aCol1 = pColHdl1->GetColor();
1180 if(pColHdl2)
1181 aGradTransVector.aCol2 = pColHdl2->GetColor();
1182
1183 if(IsGradient())
1184 aOldGradTransGradient.aGradient = ((XFillGradientItem&)rSet.Get(XATTR_FILLGRADIENT)).GetGradientValue();
1185 else
1186 aOldGradTransGradient.aGradient = ((XFillFloatTransparenceItem&)rSet.Get(XATTR_FILLFLOATTRANSPARENCE)).GetGradientValue();
1187
1188 // transform vector data to gradient
1189 aGradTransformer.VecToGrad(aGradTransVector, aGradTransGradient, aOldGradTransGradient, _pObj, bMoveSingleHandle, bMoveFirstHandle);
1190
1191 if(bSetItemOnObject)
1192 {
1193 SdrModel* pModel = _pObj->GetModel();
1194 SfxItemSet aNewSet(pModel->GetItemPool());
1195
1196 if(IsGradient())
1197 {
1198 aString = String();
1199 XFillGradientItem aNewGradItem(aString, aGradTransGradient.aGradient);
1200 aNewSet.Put(aNewGradItem);
1201 }
1202 else
1203 {
1204 aString = String();
1205 XFillFloatTransparenceItem aNewTransItem(aString, aGradTransGradient.aGradient);
1206 aNewSet.Put(aNewTransItem);
1207 }
1208
1209 if(bUndo && pModel->IsUndoEnabled())
1210 {
1211 pModel->BegUndo(SVX_RESSTR(IsGradient() ? SIP_XA_FILLGRADIENT : SIP_XA_FILLTRANSPARENCE));
1212 pModel->AddUndo(pModel->GetSdrUndoFactory().CreateUndoAttrObject(*_pObj));
1213 pModel->EndUndo();
1214 }
1215
1216 pObj->SetMergedItemSetAndBroadcast(aNewSet);
1217 }
1218
1219 // back transformation, set values on pIAOHandle
1220 aGradTransformer.GradToVec(aGradTransGradient, aGradTransVector, _pObj);
1221
1222 SetPos(Point(FRound(aGradTransVector.maPositionA.getX()), FRound(aGradTransVector.maPositionA.getY())));
1223 Set2ndPos(Point(FRound(aGradTransVector.maPositionB.getX()), FRound(aGradTransVector.maPositionB.getY())));
1224 if(pColHdl1)
1225 {
1226 pColHdl1->SetPos(Point(FRound(aGradTransVector.maPositionA.getX()), FRound(aGradTransVector.maPositionA.getY())));
1227 pColHdl1->SetColor(aGradTransVector.aCol1);
1228 }
1229 if(pColHdl2)
1230 {
1231 pColHdl2->SetPos(Point(FRound(aGradTransVector.maPositionB.getX()), FRound(aGradTransVector.maPositionB.getY())));
1232 pColHdl2->SetColor(aGradTransVector.aCol2);
1233 }
1234 }
1235
1236 ////////////////////////////////////////////////////////////////////////////////////////////////////
1237
1238 SdrHdlLine::~SdrHdlLine() {}
1239
1240 void SdrHdlLine::CreateB2dIAObject()
1241 {
1242 // first throw away old one
1243 GetRidOfIAObject();
1244
1245 if(pHdlList)
1246 {
1247 SdrMarkView* pView = pHdlList->GetView();
1248
1249 if(pView && !pView->areMarkHandlesHidden() && pHdl1 && pHdl2)
1250 {
1251 SdrPageView* pPageView = pView->GetSdrPageView();
1252
1253 if(pPageView)
1254 {
1255 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1256 {
1257 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1258
1259 if(rPageWindow.GetPaintWindow().OutputToWindow())
1260 {
1261 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1262 if (xManager.is())
1263 {
1264 basegfx::B2DPoint aPosition1(pHdl1->GetPos().X(), pHdl1->GetPos().Y());
1265 basegfx::B2DPoint aPosition2(pHdl2->GetPos().X(), pHdl2->GetPos().Y());
1266
1267 ::sdr::overlay::OverlayObject* pNewOverlayObject = new
1268 ::sdr::overlay::OverlayLineStriped(
1269 aPosition1,
1270 aPosition2
1271 );
1272 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1273
1274 // OVERLAYMANAGER
1275 if(pNewOverlayObject)
1276 {
1277 // color(?)
1278 pNewOverlayObject->setBaseColor(Color(COL_LIGHTRED));
1279
1280 xManager->add(*pNewOverlayObject);
1281 maOverlayGroup.append(*pNewOverlayObject);
1282 }
1283 }
1284 }
1285 }
1286 }
1287 }
1288 }
1289 }
1290
1291 Pointer SdrHdlLine::GetPointer() const
1292 {
1293 return Pointer(POINTER_REFHAND);
1294 }
1295
1296 ////////////////////////////////////////////////////////////////////////////////////////////////////
1297
1298 SdrHdlBezWgt::~SdrHdlBezWgt() {}
1299
1300 void SdrHdlBezWgt::CreateB2dIAObject()
1301 {
1302 // call parent
1303 SdrHdl::CreateB2dIAObject();
1304
1305 // create lines
1306 if(pHdlList)
1307 {
1308 SdrMarkView* pView = pHdlList->GetView();
1309
1310 if(pView && !pView->areMarkHandlesHidden())
1311 {
1312 SdrPageView* pPageView = pView->GetSdrPageView();
1313
1314 if(pPageView)
1315 {
1316 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1317 {
1318 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1319
1320 if(rPageWindow.GetPaintWindow().OutputToWindow())
1321 {
1322 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1323 if (xManager.is())
1324 {
1325 basegfx::B2DPoint aPosition1(pHdl1->GetPos().X(), pHdl1->GetPos().Y());
1326 basegfx::B2DPoint aPosition2(aPos.X(), aPos.Y());
1327
1328 if(!aPosition1.equal(aPosition2))
1329 {
1330 ::sdr::overlay::OverlayObject* pNewOverlayObject = new
1331 ::sdr::overlay::OverlayLineStriped(
1332 aPosition1,
1333 aPosition2
1334 );
1335 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1336
1337 // OVERLAYMANAGER
1338 if(pNewOverlayObject)
1339 {
1340 // line part is not hittable
1341 pNewOverlayObject->setHittable(sal_False);
1342
1343 // color(?)
1344 pNewOverlayObject->setBaseColor(Color(COL_LIGHTBLUE));
1345
1346 xManager->add(*pNewOverlayObject);
1347 maOverlayGroup.append(*pNewOverlayObject);
1348 }
1349 }
1350 }
1351 }
1352 }
1353 }
1354 }
1355 }
1356 }
1357
1358 ////////////////////////////////////////////////////////////////////////////////////////////////////
1359
1360 E3dVolumeMarker::E3dVolumeMarker(const basegfx::B2DPolyPolygon& rWireframePoly)
1361 {
1362 aWireframePoly = rWireframePoly;
1363 }
1364
1365 void E3dVolumeMarker::CreateB2dIAObject()
1366 {
1367 // create lines
1368 if(pHdlList)
1369 {
1370 SdrMarkView* pView = pHdlList->GetView();
1371
1372 if(pView && !pView->areMarkHandlesHidden())
1373 {
1374 SdrPageView* pPageView = pView->GetSdrPageView();
1375
1376 if(pPageView)
1377 {
1378 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1379 {
1380 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1381
1382 if(rPageWindow.GetPaintWindow().OutputToWindow())
1383 {
1384 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1385 if (xManager.is() && aWireframePoly.count())
1386 {
1387 ::sdr::overlay::OverlayObject* pNewOverlayObject = new
1388 ::sdr::overlay::OverlayPolyPolygonStriped(aWireframePoly);
1389 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1390
1391 // OVERLAYMANAGER
1392 if(pNewOverlayObject)
1393 {
1394 pNewOverlayObject->setBaseColor(Color(COL_BLACK));
1395
1396 xManager->add(*pNewOverlayObject);
1397 maOverlayGroup.append(*pNewOverlayObject);
1398 }
1399 }
1400 }
1401 }
1402 }
1403 }
1404 }
1405 }
1406
1407 ////////////////////////////////////////////////////////////////////////////////////////////////////
1408
1409 ImpEdgeHdl::~ImpEdgeHdl()
1410 {
1411 }
1412
1413 void ImpEdgeHdl::CreateB2dIAObject()
1414 {
1415 if(nObjHdlNum <= 1 && pObj)
1416 {
1417 // first throw away old one
1418 GetRidOfIAObject();
1419
1420 BitmapColorIndex eColIndex = LightCyan;
1421 BitmapMarkerKind eKindOfMarker = Rect_7x7;
1422
1423 if(pHdlList)
1424 {
1425 SdrMarkView* pView = pHdlList->GetView();
1426
1427 if(pView && !pView->areMarkHandlesHidden())
1428 {
1429 const SdrEdgeObj* pEdge = (SdrEdgeObj*)pObj;
1430
1431 if(pEdge->GetConnectedNode(nObjHdlNum == 0) != NULL)
1432 eColIndex = LightRed;
1433
1434 if(nPPntNum < 2)
1435 {
1436 // Handle with plus sign inside
1437 eKindOfMarker = Circ_7x7;
1438 }
1439
1440 SdrPageView* pPageView = pView->GetSdrPageView();
1441
1442 if(pPageView)
1443 {
1444 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1445 {
1446 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1447
1448 if(rPageWindow.GetPaintWindow().OutputToWindow())
1449 {
1450 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1451 if (xManager.is())
1452 {
1453 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1454
1455 ::sdr::overlay::OverlayObject* pNewOverlayObject = CreateOverlayObject(
1456 aPosition,
1457 eColIndex,
1458 eKindOfMarker);
1459
1460 // OVERLAYMANAGER
1461 if(pNewOverlayObject)
1462 {
1463 xManager->add(*pNewOverlayObject);
1464 maOverlayGroup.append(*pNewOverlayObject);
1465 }
1466 }
1467 }
1468 }
1469 }
1470 }
1471 }
1472 }
1473 else
1474 {
1475 // call parent
1476 SdrHdl::CreateB2dIAObject();
1477 }
1478 }
1479
1480 void ImpEdgeHdl::SetLineCode(SdrEdgeLineCode eCode)
1481 {
1482 if(eLineCode != eCode)
1483 {
1484 // remember new value
1485 eLineCode = eCode;
1486
1487 // create new display
1488 Touch();
1489 }
1490 }
1491
1492 Pointer ImpEdgeHdl::GetPointer() const
1493 {
1494 SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pObj);
1495 if (pEdge==NULL)
1496 return SdrHdl::GetPointer();
1497 if (nObjHdlNum<=1)
1498 return Pointer(POINTER_MOVEPOINT);
1499 if (IsHorzDrag())
1500 return Pointer(POINTER_ESIZE);
1501 else
1502 return Pointer(POINTER_SSIZE);
1503 }
1504
1505 sal_Bool ImpEdgeHdl::IsHorzDrag() const
1506 {
1507 SdrEdgeObj* pEdge=PTR_CAST(SdrEdgeObj,pObj);
1508 if (pEdge==NULL)
1509 return sal_False;
1510 if (nObjHdlNum<=1)
1511 return sal_False;
1512
1513 SdrEdgeKind eEdgeKind = ((SdrEdgeKindItem&)(pEdge->GetObjectItem(SDRATTR_EDGEKIND))).GetValue();
1514
1515 const SdrEdgeInfoRec& rInfo=pEdge->aEdgeInfo;
1516 if (eEdgeKind==SDREDGE_ORTHOLINES || eEdgeKind==SDREDGE_BEZIER)
1517 {
1518 return !rInfo.ImpIsHorzLine(eLineCode,*pEdge->pEdgeTrack);
1519 }
1520 else if (eEdgeKind==SDREDGE_THREELINES)
1521 {
1522 long nWink=nObjHdlNum==2 ? rInfo.nAngle1 : rInfo.nAngle2;
1523 if (nWink==0 || nWink==18000)
1524 return sal_True;
1525 else
1526 return sal_False;
1527 }
1528 return sal_False;
1529 }
1530
1531 ////////////////////////////////////////////////////////////////////////////////////////////////////
1532
1533 ImpMeasureHdl::~ImpMeasureHdl()
1534 {
1535 }
1536
1537 void ImpMeasureHdl::CreateB2dIAObject()
1538 {
1539 // first throw away old one
1540 GetRidOfIAObject();
1541
1542 if(pHdlList)
1543 {
1544 SdrMarkView* pView = pHdlList->GetView();
1545
1546 if(pView && !pView->areMarkHandlesHidden())
1547 {
1548 BitmapColorIndex eColIndex = LightCyan;
1549 BitmapMarkerKind eKindOfMarker = Rect_9x9;
1550
1551 if(nObjHdlNum > 1)
1552 {
1553 eKindOfMarker = Rect_7x7;
1554 }
1555
1556 if(bSelect)
1557 {
1558 eColIndex = Cyan;
1559 }
1560
1561 SdrPageView* pPageView = pView->GetSdrPageView();
1562
1563 if(pPageView)
1564 {
1565 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1566 {
1567 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1568
1569 if(rPageWindow.GetPaintWindow().OutputToWindow())
1570 {
1571 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1572 if (xManager.is())
1573 {
1574 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1575
1576 ::sdr::overlay::OverlayObject* pNewOverlayObject = CreateOverlayObject(
1577 aPosition,
1578 eColIndex,
1579 eKindOfMarker);
1580
1581 // OVERLAYMANAGER
1582 if(pNewOverlayObject)
1583 {
1584 xManager->add(*pNewOverlayObject);
1585 maOverlayGroup.append(*pNewOverlayObject);
1586 }
1587 }
1588 }
1589 }
1590 }
1591 }
1592 }
1593 }
1594
1595 Pointer ImpMeasureHdl::GetPointer() const
1596 {
1597 switch (nObjHdlNum)
1598 {
1599 case 0: case 1: return Pointer(POINTER_HAND);
1600 case 2: case 3: return Pointer(POINTER_MOVEPOINT);
1601 case 4: case 5: return SdrHdl::GetPointer(); // will then be rotated appropriately
1602 } // switch
1603 return Pointer(POINTER_NOTALLOWED);
1604 }
1605
1606 ////////////////////////////////////////////////////////////////////////////////////////////////////
1607
1608 ImpTextframeHdl::ImpTextframeHdl(const Rectangle& rRect) :
1609 SdrHdl(rRect.TopLeft(),HDL_MOVE),
1610 maRect(rRect)
1611 {
1612 }
1613
1614 void ImpTextframeHdl::CreateB2dIAObject()
1615 {
1616 // first throw away old one
1617 GetRidOfIAObject();
1618
1619 if(pHdlList)
1620 {
1621 SdrMarkView* pView = pHdlList->GetView();
1622
1623 if(pView && !pView->areMarkHandlesHidden())
1624 {
1625 SdrPageView* pPageView = pView->GetSdrPageView();
1626
1627 if(pPageView)
1628 {
1629 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
1630 {
1631 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1632
1633 if(rPageWindow.GetPaintWindow().OutputToWindow())
1634 {
1635 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1636 if (xManager.is())
1637 {
1638 const basegfx::B2DPoint aTopLeft(maRect.Left(), maRect.Top());
1639 const basegfx::B2DPoint aBottomRight(maRect.Right(), maRect.Bottom());
1640 const svtools::ColorConfig aColorConfig;
1641 const Color aHatchCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
1642
1643 ::sdr::overlay::OverlayHatchRect* pNewOverlayObject = new ::sdr::overlay::OverlayHatchRect(
1644 aTopLeft,
1645 aBottomRight,
1646 aHatchCol,
1647 3.0,
1648 3.0,
1649 45 * F_PI180,
1650 nDrehWink * -F_PI18000);
1651 pNewOverlayObject->setHittable(false);
1652
1653 // OVERLAYMANAGER
1654 if(pNewOverlayObject)
1655 {
1656 xManager->add(*pNewOverlayObject);
1657 maOverlayGroup.append(*pNewOverlayObject);
1658 }
1659 }
1660 }
1661 }
1662 }
1663 }
1664 }
1665 }
1666
1667 ////////////////////////////////////////////////////////////////////////////////////////////////////
1668
1669 class ImpSdrHdlListSorter: public ContainerSorter {
1670 public:
1671 ImpSdrHdlListSorter(Container& rNewCont): ContainerSorter(rNewCont) {}
1672 virtual ~ImpSdrHdlListSorter() {}
1673 virtual int Compare(const void* pElem1, const void* pElem2) const;
1674 };
1675
1676 int ImpSdrHdlListSorter::Compare(const void* pElem1, const void* pElem2) const
1677 {
1678 SdrHdlKind eKind1=((SdrHdl*)pElem1)->GetKind();
1679 SdrHdlKind eKind2=((SdrHdl*)pElem2)->GetKind();
1680 // Level 1: first normal handles, then Glue, then User, then Plus handles, then reference point handles
1681 unsigned n1=1;
1682 unsigned n2=1;
1683 if (eKind1!=eKind2)
1684 {
1685 if (eKind1==HDL_REF1 || eKind1==HDL_REF2 || eKind1==HDL_MIRX) n1=5;
1686 else if (eKind1==HDL_GLUE || eKind1==HDL_GLUE_DESELECTED) n1=2;
1687 else if (eKind1==HDL_USER) n1=3;
1688 else if (eKind1==HDL_SMARTTAG) n1=0;
1689 if (eKind2==HDL_REF1 || eKind2==HDL_REF2 || eKind2==HDL_MIRX) n2=5;
1690 else if (eKind2==HDL_GLUE || eKind2==HDL_GLUE_DESELECTED) n2=2;
1691 else if (eKind2==HDL_USER) n2=3;
1692 else if (eKind2==HDL_SMARTTAG) n2=0;
1693 }
1694 if (((SdrHdl*)pElem1)->IsPlusHdl()) n1=4;
1695 if (((SdrHdl*)pElem2)->IsPlusHdl()) n2=4;
1696 if (n1==n2)
1697 {
1698 // Level 2: PageView (Pointer)
1699 SdrPageView* pPV1=((SdrHdl*)pElem1)->GetPageView();
1700 SdrPageView* pPV2=((SdrHdl*)pElem2)->GetPageView();
1701 if (pPV1==pPV2)
1702 {
1703 // Level 3: Position (x+y)
1704 SdrObject* pObj1=((SdrHdl*)pElem1)->GetObj();
1705 SdrObject* pObj2=((SdrHdl*)pElem2)->GetObj();
1706 if (pObj1==pObj2)
1707 {
1708 sal_uInt32 nNum1=((SdrHdl*)pElem1)->GetObjHdlNum();
1709 sal_uInt32 nNum2=((SdrHdl*)pElem2)->GetObjHdlNum();
1710 if (nNum1==nNum2)
1711 {
1712 if (eKind1==eKind2)
1713 return (long)pElem1<(long)pElem2 ? -1 : 1; // Hack, to always get to the same sorting
1714 return (sal_uInt16)eKind1<(sal_uInt16)eKind2 ? -1 : 1;
1715 }
1716 else
1717 return nNum1<nNum2 ? -1 : 1;
1718 }
1719 else
1720 {
1721 return (long)pObj1<(long)pObj2 ? -1 : 1;
1722 }
1723 }
1724 else
1725 {
1726 return (long)pPV1<(long)pPV2 ? -1 : 1;
1727 }
1728 }
1729 else
1730 {
1731 return n1<n2 ? -1 : 1;
1732 }
1733 }
1734
1735 SdrMarkView* SdrHdlList::GetView() const
1736 {
1737 return pView;
1738 }
1739
1740 // Helper struct for re-sorting handles
1741 struct ImplHdlAndIndex
1742 {
1743 SdrHdl* mpHdl;
1744 sal_uInt32 mnIndex;
1745 };
1746
1747 // Helper method for sorting handles taking care of OrdNums, keeping order in
1748 // single objects and re-sorting polygon handles intuitively
1749 extern "C" int __LOADONCALLAPI ImplSortHdlFunc( const void* pVoid1, const void* pVoid2 )
1750 {
1751 const ImplHdlAndIndex* p1 = (ImplHdlAndIndex*)pVoid1;
1752 const ImplHdlAndIndex* p2 = (ImplHdlAndIndex*)pVoid2;
1753
1754 if(p1->mpHdl->GetObj() == p2->mpHdl->GetObj())
1755 {
1756 if(p1->mpHdl->GetObj() && p1->mpHdl->GetObj()->ISA(SdrPathObj))
1757 {
1758 // same object and a path object
1759 if((p1->mpHdl->GetKind() == HDL_POLY || p1->mpHdl->GetKind() == HDL_BWGT)
1760 && (p2->mpHdl->GetKind() == HDL_POLY || p2->mpHdl->GetKind() == HDL_BWGT))
1761 {
1762 // both handles are point or control handles
1763 if(p1->mpHdl->GetPolyNum() == p2->mpHdl->GetPolyNum())
1764 {
1765 if(p1->mpHdl->GetPointNum() < p2->mpHdl->GetPointNum())
1766 {
1767 return -1;
1768 }
1769 else
1770 {
1771 return 1;
1772 }
1773 }
1774 else if(p1->mpHdl->GetPolyNum() < p2->mpHdl->GetPolyNum())
1775 {
1776 return -1;
1777 }
1778 else
1779 {
1780 return 1;
1781 }
1782 }
1783 }
1784 }
1785 else
1786 {
1787 if(!p1->mpHdl->GetObj())
1788 {
1789 return -1;
1790 }
1791 else if(!p2->mpHdl->GetObj())
1792 {
1793 return 1;
1794 }
1795 else
1796 {
1797 // different objects, use OrdNum for sort
1798 const sal_uInt32 nOrdNum1 = p1->mpHdl->GetObj()->GetOrdNum();
1799 const sal_uInt32 nOrdNum2 = p2->mpHdl->GetObj()->GetOrdNum();
1800
1801 if(nOrdNum1 < nOrdNum2)
1802 {
1803 return -1;
1804 }
1805 else
1806 {
1807 return 1;
1808 }
1809 }
1810 }
1811
1812 // fallback to indices
1813 if(p1->mnIndex < p2->mnIndex)
1814 {
1815 return -1;
1816 }
1817 else
1818 {
1819 return 1;
1820 }
1821 }
1822
1823 ////////////////////////////////////////////////////////////////////////////////////////////////////
1824
1825 void SdrHdlList::TravelFocusHdl(sal_Bool bForward)
1826 {
1827 // security correction
1828 if(mnFocusIndex != CONTAINER_ENTRY_NOTFOUND && mnFocusIndex >= GetHdlCount())
1829 mnFocusIndex = CONTAINER_ENTRY_NOTFOUND;
1830
1831 if(aList.Count())
1832 {
1833 // take care of old handle
1834 const sal_uIntPtr nOldHdlNum(mnFocusIndex);
1835 SdrHdl* pOld = GetHdl(nOldHdlNum);
1836
1837 if(pOld)
1838 {
1839 // switch off old handle
1840 mnFocusIndex = CONTAINER_ENTRY_NOTFOUND;
1841 pOld->Touch();
1842 }
1843
1844 // allocate pointer array for sorted handle list
1845 ImplHdlAndIndex* pHdlAndIndex = new ImplHdlAndIndex[aList.Count()];
1846
1847 // build sorted handle list
1848 sal_uInt32 a;
1849 for( a = 0; a < aList.Count(); a++)
1850 {
1851 pHdlAndIndex[a].mpHdl = (SdrHdl*)aList.GetObject(a);
1852 pHdlAndIndex[a].mnIndex = a;
1853 }
1854
1855 qsort(pHdlAndIndex, aList.Count(), sizeof(ImplHdlAndIndex), ImplSortHdlFunc);
1856
1857 // look for old num in sorted array
1858 sal_uIntPtr nOldHdl(nOldHdlNum);
1859
1860 if(nOldHdlNum != CONTAINER_ENTRY_NOTFOUND)
1861 {
1862 for(a = 0; a < aList.Count(); a++)
1863 {
1864 if(pHdlAndIndex[a].mpHdl == pOld)
1865 {
1866 nOldHdl = a;
1867 break;
1868 }
1869 }
1870 }
1871
1872 // build new HdlNum
1873 sal_uIntPtr nNewHdl(nOldHdl);
1874
1875 // do the focus travel
1876 if(bForward)
1877 {
1878 if(nOldHdl != CONTAINER_ENTRY_NOTFOUND)
1879 {
1880 if(nOldHdl == aList.Count() - 1)
1881 {
1882 // end forward run
1883 nNewHdl = CONTAINER_ENTRY_NOTFOUND;
1884 }
1885 else
1886 {
1887 // simply the next handle
1888 nNewHdl++;
1889 }
1890 }
1891 else
1892 {
1893 // start forward run at first entry
1894 nNewHdl = 0;
1895 }
1896 }
1897 else
1898 {
1899 if(nOldHdl == CONTAINER_ENTRY_NOTFOUND)
1900 {
1901 // start backward run at last entry
1902 nNewHdl = aList.Count() - 1;
1903
1904 }
1905 else
1906 {
1907 if(nOldHdl == 0)
1908 {
1909 // end backward run
1910 nNewHdl = CONTAINER_ENTRY_NOTFOUND;
1911 }
1912 else
1913 {
1914 // simply the previous handle
1915 nNewHdl--;
1916 }
1917 }
1918 }
1919
1920 // build new HdlNum
1921 sal_uInt32 nNewHdlNum(nNewHdl);
1922
1923 // look for old num in sorted array
1924 if(nNewHdl != CONTAINER_ENTRY_NOTFOUND)
1925 {
1926 SdrHdl* pNew = pHdlAndIndex[nNewHdl].mpHdl;
1927
1928 for(a = 0; a < aList.Count(); a++)
1929 {
1930 if((SdrHdl*)aList.GetObject(a) == pNew)
1931 {
1932 nNewHdlNum = a;
1933 break;
1934 }
1935 }
1936 }
1937
1938 // take care of next handle
1939 if(nOldHdlNum != nNewHdlNum)
1940 {
1941 mnFocusIndex = nNewHdlNum;
1942 SdrHdl* pNew = GetHdl(mnFocusIndex);
1943
1944 if(pNew)
1945 {
1946 pNew->Touch();
1947 }
1948 }
1949
1950 // free memory again
1951 delete [] pHdlAndIndex;
1952 }
1953 }
1954
1955 SdrHdl* SdrHdlList::GetFocusHdl() const
1956 {
1957 if(mnFocusIndex != CONTAINER_ENTRY_NOTFOUND && mnFocusIndex < GetHdlCount())
1958 return GetHdl(mnFocusIndex);
1959 else
1960 return 0L;
1961 }
1962
1963 void SdrHdlList::SetFocusHdl(SdrHdl* pNew)
1964 {
1965 if(pNew)
1966 {
1967 SdrHdl* pActual = GetFocusHdl();
1968
1969 if(!pActual || pActual != pNew)
1970 {
1971 sal_uIntPtr nNewHdlNum = GetHdlNum(pNew);
1972
1973 if(nNewHdlNum != CONTAINER_ENTRY_NOTFOUND)
1974 {
1975 mnFocusIndex = nNewHdlNum;
1976
1977 if(pActual)
1978 {
1979 pActual->Touch();
1980 }
1981
1982 if(pNew)
1983 {
1984 pNew->Touch();
1985 }
1986
1987 }
1988 }
1989 }
1990 }
1991
1992 void SdrHdlList::ResetFocusHdl()
1993 {
1994 SdrHdl* pHdl = GetFocusHdl();
1995
1996 mnFocusIndex = CONTAINER_ENTRY_NOTFOUND;
1997
1998 if(pHdl)
1999 {
2000 pHdl->Touch();
2001 }
2002 }
2003
2004 ////////////////////////////////////////////////////////////////////////////////////////////////////
2005
2006 SdrHdlList::SdrHdlList(SdrMarkView* pV)
2007 : mnFocusIndex(CONTAINER_ENTRY_NOTFOUND),
2008 pView(pV),
2009 aList(1024,32,32)
2010 {
2011 nHdlSize = 3;
2012 bRotateShear = sal_False;
2013 bMoveOutside = sal_False;
2014 bDistortShear = sal_False;
2015 }
2016
2017 SdrHdlList::~SdrHdlList()
2018 {
2019 Clear();
2020 }
2021
2022 void SdrHdlList::SetHdlSize(sal_uInt16 nSiz)
2023 {
2024 if(nHdlSize != nSiz)
2025 {
2026 // remember new value
2027 nHdlSize = nSiz;
2028
2029 // propagate change to IAOs
2030 for(sal_uInt32 i=0; i<GetHdlCount(); i++)
2031 {
2032 SdrHdl* pHdl = GetHdl(i);
2033 pHdl->Touch();
2034 }
2035 }
2036 }
2037
2038 void SdrHdlList::SetMoveOutside(sal_Bool bOn)
2039 {
2040 if(bMoveOutside != bOn)
2041 {
2042 // remember new value
2043 bMoveOutside = bOn;
2044
2045 // propagate change to IAOs
2046 for(sal_uInt32 i=0; i<GetHdlCount(); i++)
2047 {
2048 SdrHdl* pHdl = GetHdl(i);
2049 pHdl->Touch();
2050 }
2051 }
2052 }
2053
2054 void SdrHdlList::SetRotateShear(sal_Bool bOn)
2055 {
2056 bRotateShear = bOn;
2057 }
2058
2059 void SdrHdlList::SetDistortShear(sal_Bool bOn)
2060 {
2061 bDistortShear = bOn;
2062 }
2063
2064 SdrHdl* SdrHdlList::RemoveHdl(sal_uIntPtr nNum)
2065 {
2066 SdrHdl* pRetval = (SdrHdl*)aList.Remove(nNum);
2067
2068 return pRetval;
2069 }
2070
2071 void SdrHdlList::RemoveAllByKind(SdrHdlKind eKind)
2072 {
2073 SdrHdl* p = static_cast<SdrHdl*>(aList.Last());
2074 while (p)
2075 {
2076 if (p->GetKind() == eKind)
2077 {
2078 // If removing an item doesn't invalidate the current position,
2079 // then perhaps it's safe to keep calling Prev here. But then I'm
2080 // too lazy to find out & this Container needs to be replaced by
2081 // STL anyways... :-P
2082 aList.Remove(p);
2083 delete p;
2084 p = static_cast<SdrHdl*>(aList.Last()); // start from the back again.
2085 }
2086 else
2087 p = static_cast<SdrHdl*>(aList.Prev());
2088 }
2089 }
2090
2091 void SdrHdlList::Clear()
2092 {
2093 for (sal_uIntPtr i=0; i<GetHdlCount(); i++)
2094 {
2095 SdrHdl* pHdl=GetHdl(i);
2096 delete pHdl;
2097 }
2098 aList.Clear();
2099
2100 bRotateShear=sal_False;
2101 bDistortShear=sal_False;
2102 }
2103
2104 void SdrHdlList::Sort()
2105 {
2106 // remember currently focused handle
2107 SdrHdl* pPrev = GetFocusHdl();
2108
2109 ImpSdrHdlListSorter aSort(aList);
2110 aSort.DoSort();
2111
2112 // get now and compare
2113 SdrHdl* pNow = GetFocusHdl();
2114
2115 if(pPrev != pNow)
2116 {
2117
2118 if(pPrev)
2119 {
2120 pPrev->Touch();
2121 }
2122
2123 if(pNow)
2124 {
2125 pNow->Touch();
2126 }
2127 }
2128 }
2129
2130 sal_uIntPtr SdrHdlList::GetHdlNum(const SdrHdl* pHdl) const
2131 {
2132 if (pHdl==NULL)
2133 return CONTAINER_ENTRY_NOTFOUND;
2134 sal_uIntPtr nPos=aList.GetPos(pHdl);
2135 return nPos;
2136 }
2137
2138 void SdrHdlList::AddHdl(SdrHdl* pHdl, sal_Bool bAtBegin)
2139 {
2140 if (pHdl!=NULL)
2141 {
2142 if (bAtBegin)
2143 {
2144 aList.Insert(pHdl,sal_uIntPtr(0));
2145 }
2146 else
2147 {
2148 aList.Insert(pHdl,CONTAINER_APPEND);
2149 }
2150 pHdl->SetHdlList(this);
2151 }
2152 }
2153
2154 SdrHdl* SdrHdlList::IsHdlListHit(const Point& rPnt, sal_Bool bBack, sal_Bool bNext, SdrHdl* pHdl0) const
2155 {
2156 SdrHdl* pRet=NULL;
2157 sal_uIntPtr nAnz=GetHdlCount();
2158 sal_uIntPtr nNum=bBack ? 0 : nAnz;
2159 while ((bBack ? nNum<nAnz : nNum>0) && pRet==NULL)
2160 {
2161 if (!bBack)
2162 nNum--;
2163 SdrHdl* pHdl=GetHdl(nNum);
2164 if (bNext)
2165 {
2166 if (pHdl==pHdl0)
2167 bNext=sal_False;
2168 }
2169 else
2170 {
2171 if (pHdl->IsHdlHit(rPnt))
2172 pRet=pHdl;
2173 }
2174 if (bBack)
2175 nNum++;
2176 }
2177 return pRet;
2178 }
2179
2180 SdrHdl* SdrHdlList::GetHdl(SdrHdlKind eKind1) const
2181 {
2182 SdrHdl* pRet=NULL;
2183 for (sal_uIntPtr i=0; i<GetHdlCount() && pRet==NULL; i++)
2184 {
2185 SdrHdl* pHdl=GetHdl(i);
2186 if (pHdl->GetKind()==eKind1)
2187 pRet=pHdl;
2188 }
2189 return pRet;
2190 }
2191
2192 // --------------------------------------------------------------------
2193 // SdrCropHdl
2194 // --------------------------------------------------------------------
2195
2196 SdrCropHdl::SdrCropHdl(const Point& rPnt, SdrHdlKind eNewKind)
2197 : SdrHdl( rPnt, eNewKind )
2198 {
2199 }
2200
2201 // --------------------------------------------------------------------
2202
2203 BitmapEx SdrCropHdl::GetHandlesBitmap()
2204 {
2205 static BitmapEx* pModernBitmap = 0;
2206 if( pModernBitmap == 0 )
2207 pModernBitmap = new BitmapEx(ResId(SIP_SA_CROP_MARKERS, *ImpGetResMgr()));
2208 return *pModernBitmap;
2209 }
2210
2211 // --------------------------------------------------------------------
2212
2213 BitmapEx SdrCropHdl::GetBitmapForHandle( const BitmapEx& rBitmap, int nSize )
2214 {
2215 int nPixelSize = 0, nX = 0, nY = 0, nOffset = 0;
2216
2217 if( nSize <= 3 )
2218 {
2219 nPixelSize = 13;
2220 nOffset = 0;
2221 }
2222 else if( nSize <=4 )
2223 {
2224 nPixelSize = 17;
2225 nOffset = 39;
2226 }
2227 else
2228 {
2229 nPixelSize = 21;
2230 nOffset = 90;
2231 }
2232
2233 switch( eKind )
2234 {
2235 case HDL_UPLFT: nX = 0; nY = 0; break;
2236 case HDL_UPPER: nX = 1; nY = 0; break;
2237 case HDL_UPRGT: nX = 2; nY = 0; break;
2238 case HDL_LEFT: nX = 0; nY = 1; break;
2239 case HDL_RIGHT: nX = 2; nY = 1; break;
2240 case HDL_LWLFT: nX = 0; nY = 2; break;
2241 case HDL_LOWER: nX = 1; nY = 2; break;
2242 case HDL_LWRGT: nX = 2; nY = 2; break;
2243 default: break;
2244 }
2245
2246 Rectangle aSourceRect( Point( nX * (nPixelSize) + nOffset, nY * (nPixelSize)), Size(nPixelSize, nPixelSize) );
2247
2248 BitmapEx aRetval(rBitmap);
2249 aRetval.Crop(aSourceRect);
2250 return aRetval;
2251 }
2252
2253 // --------------------------------------------------------------------
2254
2255 void SdrCropHdl::CreateB2dIAObject()
2256 {
2257 // first throw away old one
2258 GetRidOfIAObject();
2259
2260 SdrMarkView* pView = pHdlList ? pHdlList->GetView() : 0;
2261 SdrPageView* pPageView = pView ? pView->GetSdrPageView() : 0;
2262
2263 if( pPageView && !pView->areMarkHandlesHidden() )
2264 {
2265 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2266 int nHdlSize = pHdlList->GetHdlSize();
2267
2268 const BitmapEx aHandlesBitmap( GetHandlesBitmap() );
2269 BitmapEx aBmpEx1( GetBitmapForHandle( aHandlesBitmap, nHdlSize ) );
2270
2271 for(sal_uInt32 b(0L); b < pPageView->PageWindowCount(); b++)
2272 {
2273 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
2274
2275 if(rPageWindow.GetPaintWindow().OutputToWindow())
2276 {
2277 rtl::Reference< ::sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
2278 if (xManager.is())
2279 {
2280 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
2281
2282 ::sdr::overlay::OverlayObject* pOverlayObject = 0L;
2283
2284 // animate focused handles
2285 if(IsFocusHdl() && (pHdlList->GetFocusHdl() == this))
2286 {
2287 if( nHdlSize >= 2 )
2288 nHdlSize = 1;
2289
2290 BitmapEx aBmpEx2( GetBitmapForHandle( aHandlesBitmap, nHdlSize + 1 ) );
2291
2292 const sal_uInt32 nBlinkTime = sal::static_int_cast<sal_uInt32>(rStyleSettings.GetCursorBlinkTime());
2293
2294 pOverlayObject = new ::sdr::overlay::OverlayAnimatedBitmapEx(aPosition, aBmpEx1, aBmpEx2, nBlinkTime,
2295 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1) >> 1,
2296 (sal_uInt16)(aBmpEx1.GetSizePixel().Height() - 1) >> 1,
2297 (sal_uInt16)(aBmpEx2.GetSizePixel().Width() - 1) >> 1,
2298 (sal_uInt16)(aBmpEx2.GetSizePixel().Height() - 1) >> 1);
2299 }
2300 else
2301 {
2302 // create centered handle as default
2303 pOverlayObject = new ::sdr::overlay::OverlayBitmapEx(aPosition, aBmpEx1,
2304 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1) >> 1,
2305 (sal_uInt16)(aBmpEx1.GetSizePixel().Height() - 1) >> 1);
2306 }
2307
2308 // OVERLAYMANAGER
2309 if(pOverlayObject)
2310 {
2311 xManager->add(*pOverlayObject);
2312 maOverlayGroup.append(*pOverlayObject);
2313 }
2314 }
2315 }
2316 }
2317 }
2318 }
2319
2320 // --------------------------------------------------------------------
2321
2322 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE