?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adjust includes
[LibreOffice.git] / svx / source / svdraw / svdhdl.cxx
blobef9634ad08009590c1b984b465547f9f2c29a7e3
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 <algorithm>
22 #include <cassert>
23
24 #include <svx/svdhdl.hxx>
25 #include <svx/svdpagv.hxx>
26 #include <svx/svdetc.hxx>
27 #include <svx/svdmrkv.hxx>
28 #include <vcl/window.hxx>
29 #include <vcl/settings.hxx>
30 #include <vcl/virdev.hxx>
31 #include <tools/poly.hxx>
32 #include <vcl/bitmapaccess.hxx>
33
34 #include <svx/sxekitm.hxx>
35 #include <svx/strings.hrc>
36 #include <svdglob.hxx>
37
38 #include <svx/svdmodel.hxx>
39 #include "gradtrns.hxx"
40 #include <svx/xflgrit.hxx>
41 #include <svx/svdundo.hxx>
42 #include <svx/dialmgr.hxx>
43 #include <svx/xflftrit.hxx>
44
45 #include <svx/svdopath.hxx>
46 #include <basegfx/vector/b2dvector.hxx>
47 #include <basegfx/polygon/b2dpolygon.hxx>
48 #include <svx/sdr/overlay/overlaymanager.hxx>
49 #include <svx/sdr/overlay/overlayanimatedbitmapex.hxx>
50 #include <svx/sdr/overlay/overlaybitmapex.hxx>
51 #include <sdr/overlay/overlayline.hxx>
52 #include <svx/sdr/overlay/overlaytriangle.hxx>
53 #include <sdr/overlay/overlayhandle.hxx>
54 #include <sdr/overlay/overlayrectangle.hxx>
55 #include <svx/sdrpagewindow.hxx>
56 #include <svx/sdrpaintwindow.hxx>
57 #include <vcl/svapp.hxx>
58 #include <svx/sdr/overlay/overlaypolypolygon.hxx>
59 #include <vcl/lazydelete.hxx>
60 #include <vcl/BitmapTools.hxx>
61
62 #include <basegfx/polygon/b2dpolygontools.hxx>
63 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
64 #include <svx/sdr/overlay/overlayprimitive2dsequenceobject.hxx>
65 #include <drawinglayer/primitive2d/graphicprimitive2d.hxx>
66 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
67 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
68 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
69 #include <memory>
70 #include <bitmaps.hlst>
71
72 // #i15222#
73 // Due to the resource problems in Win95/98 with bitmap resources I
74 // will change this handle bitmap providing class. Old version was splitting
75 // and preparing all small handle bitmaps in device bitmap format, now this will
76 // be done on the fly. Thus, there is only one big bitmap in memory. With
77 // three source bitmaps, this will be 3 system bitmap resources instead of hundreds.
78 // The price for that needs to be evaluated. Maybe we will need another change here
79 // if this is too expensive.
80 class SdrHdlBitmapSet
81 {
82 // the bitmap holding all information
83 BitmapEx maMarkersBitmap;
84
85 // the cropped Bitmaps for reusage
86 ::std::vector< BitmapEx > maRealMarkers;
87
88 // helpers
89 BitmapEx& impGetOrCreateTargetBitmap(sal_uInt16 nIndex, const tools::Rectangle& rRectangle);
90
91 public:
92 explicit SdrHdlBitmapSet();
93
94 const BitmapEx& GetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd);
95 };
96
97
98 #define KIND_COUNT (14)
99 #define INDEX_COUNT (6)
100 #define INDIVIDUAL_COUNT (5)
101
102 SdrHdlBitmapSet::SdrHdlBitmapSet()
103 : maMarkersBitmap(SIP_SA_MARKERS),
104 // 15 kinds (BitmapMarkerKind) use index [0..5] + 5 extra
105 maRealMarkers((KIND_COUNT * INDEX_COUNT) + INDIVIDUAL_COUNT)
106 {
107 }
108
109 BitmapEx& SdrHdlBitmapSet::impGetOrCreateTargetBitmap(sal_uInt16 nIndex, const tools::Rectangle& rRectangle)
110 {
111 BitmapEx& rTargetBitmap = maRealMarkers[nIndex];
112
113 if(rTargetBitmap.IsEmpty())
114 {
115 rTargetBitmap = maMarkersBitmap;
116 rTargetBitmap.Crop(rRectangle);
117 }
118
119 return rTargetBitmap;
120 }
121
122 // change getting of bitmap to use the big resource bitmap
123 const BitmapEx& SdrHdlBitmapSet::GetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd)
124 {
125 // fill in size and source position in maMarkersBitmap
126 const sal_uInt16 nYPos(nInd * 11);
127
128 switch(eKindOfMarker)
129 {
130 default:
131 {
132 OSL_FAIL( "Unknown kind of marker." );
133 SAL_FALLTHROUGH; // return Rect_9x9 as default
134 }
135 case BitmapMarkerKind::Rect_9x9:
136 {
137 return impGetOrCreateTargetBitmap((1 * INDEX_COUNT) + nInd, tools::Rectangle(Point(7, nYPos), Size(9, 9)));
138 }
139
140 case BitmapMarkerKind::Rect_7x7:
141 {
142 return impGetOrCreateTargetBitmap((0 * INDEX_COUNT) + nInd, tools::Rectangle(Point(0, nYPos), Size(7, 7)));
143 }
144
145 case BitmapMarkerKind::Rect_11x11:
146 {
147 return impGetOrCreateTargetBitmap((2 * INDEX_COUNT) + nInd, tools::Rectangle(Point(16, nYPos), Size(11, 11)));
148 }
149
150 case BitmapMarkerKind::Rect_13x13:
151 {
152 const sal_uInt16 nIndex((3 * INDEX_COUNT) + nInd);
153
154 switch(nInd)
155 {
156 case 0:
157 {
158 return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(72, 66), Size(13, 13)));
159 }
160 case 1:
161 {
162 return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(85, 66), Size(13, 13)));
163 }
164 case 2:
165 {
166 return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(72, 79), Size(13, 13)));
167 }
168 case 3:
169 {
170 return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(85, 79), Size(13, 13)));
171 }
172 case 4:
173 {
174 return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(98, 79), Size(13, 13)));
175 }
176 default: // case 5:
177 {
178 return impGetOrCreateTargetBitmap(nIndex, tools::Rectangle(Point(98, 66), Size(13, 13)));
179 }
180 }
181 }
182
183 case BitmapMarkerKind::Circ_7x7:
184 case BitmapMarkerKind::Customshape_7x7:
185 {
186 return impGetOrCreateTargetBitmap((4 * INDEX_COUNT) + nInd, tools::Rectangle(Point(27, nYPos), Size(7, 7)));
187 }
188
189 case BitmapMarkerKind::Circ_9x9:
190 case BitmapMarkerKind::Customshape_9x9:
191 {
192 return impGetOrCreateTargetBitmap((5 * INDEX_COUNT) + nInd, tools::Rectangle(Point(34, nYPos), Size(9, 9)));
193 }
194
195 case BitmapMarkerKind::Circ_11x11:
196 case BitmapMarkerKind::Customshape_11x11:
197 {
198 return impGetOrCreateTargetBitmap((6 * INDEX_COUNT) + nInd, tools::Rectangle(Point(43, nYPos), Size(11, 11)));
199 }
200
201 case BitmapMarkerKind::Elli_7x9:
202 {
203 return impGetOrCreateTargetBitmap((7 * INDEX_COUNT) + nInd, tools::Rectangle(Point(54, nYPos), Size(7, 9)));
204 }
205
206 case BitmapMarkerKind::Elli_9x11:
207 {
208 return impGetOrCreateTargetBitmap((8 * INDEX_COUNT) + nInd, tools::Rectangle(Point(61, nYPos), Size(9, 11)));
209 }
210
211 case BitmapMarkerKind::Elli_9x7:
212 {
213 return impGetOrCreateTargetBitmap((9 * INDEX_COUNT) + nInd, tools::Rectangle(Point(70, nYPos), Size(9, 7)));
214 }
215
216 case BitmapMarkerKind::Elli_11x9:
217 {
218 return impGetOrCreateTargetBitmap((10 * INDEX_COUNT) + nInd, tools::Rectangle(Point(79, nYPos), Size(11, 9)));
219 }
220
221 case BitmapMarkerKind::RectPlus_7x7:
222 {
223 return impGetOrCreateTargetBitmap((11 * INDEX_COUNT) + nInd, tools::Rectangle(Point(90, nYPos), Size(7, 7)));
224 }
225
226 case BitmapMarkerKind::RectPlus_9x9:
227 {
228 return impGetOrCreateTargetBitmap((12 * INDEX_COUNT) + nInd, tools::Rectangle(Point(97, nYPos), Size(9, 9)));
229 }
230
231 case BitmapMarkerKind::RectPlus_11x11:
232 {
233 return impGetOrCreateTargetBitmap((13 * INDEX_COUNT) + nInd, tools::Rectangle(Point(106, nYPos), Size(11, 11)));
234 }
235
236 case BitmapMarkerKind::Crosshair:
237 {
238 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 0, tools::Rectangle(Point(0, 68), Size(15, 15)));
239 }
240
241 case BitmapMarkerKind::Glue:
242 {
243 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 1, tools::Rectangle(Point(15, 76), Size(9, 9)));
244 }
245
246 case BitmapMarkerKind::Glue_Deselected:
247 {
248 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 2, tools::Rectangle(Point(15, 67), Size(9, 9)));
249 }
250
251 case BitmapMarkerKind::Anchor: // AnchorTR for SW
252 case BitmapMarkerKind::AnchorTR:
253 {
254 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 3, tools::Rectangle(Point(24, 67), Size(24, 24)));
255 }
256
257 // add AnchorPressed to be able to animate anchor control
258 case BitmapMarkerKind::AnchorPressed:
259 case BitmapMarkerKind::AnchorPressedTR:
260 {
261 return impGetOrCreateTargetBitmap((KIND_COUNT * INDEX_COUNT) + 4, tools::Rectangle(Point(48, 67), Size(24, 24)));
262 }
263 }
264 }
265
266
267 SdrHdl::SdrHdl():
268 pObj(nullptr),
269 pPV(nullptr),
270 pHdlList(nullptr),
271 eKind(SdrHdlKind::Move),
272 nRotationAngle(0),
273 nObjHdlNum(0),
274 nPolyNum(0),
275 nPPntNum(0),
276 nSourceHdlNum(0),
277 bSelect(false),
278 b1PixMore(false),
279 bPlusHdl(false),
280 mbMoveOutside(false),
281 mbMouseOver(false)
282 {
283 }
284
285 SdrHdl::SdrHdl(const Point& rPnt, SdrHdlKind eNewKind):
286 pObj(nullptr),
287 pPV(nullptr),
288 pHdlList(nullptr),
289 aPos(rPnt),
290 eKind(eNewKind),
291 nRotationAngle(0),
292 nObjHdlNum(0),
293 nPolyNum(0),
294 nPPntNum(0),
295 nSourceHdlNum(0),
296 bSelect(false),
297 b1PixMore(false),
298 bPlusHdl(false),
299 mbMoveOutside(false),
300 mbMouseOver(false)
301 {
302 }
303
304 SdrHdl::~SdrHdl()
305 {
306 GetRidOfIAObject();
307 }
308
309 void SdrHdl::Set1PixMore(bool bJa)
310 {
311 if(b1PixMore != bJa)
312 {
313 b1PixMore = bJa;
314
315 // create new display
316 Touch();
317 }
318 }
319
320 void SdrHdl::SetMoveOutside( bool bMoveOutside )
321 {
322 if(mbMoveOutside != bMoveOutside)
323 {
324 mbMoveOutside = bMoveOutside;
325
326 // create new display
327 Touch();
328 }
329 }
330
331 void SdrHdl::SetRotationAngle(long n)
332 {
333 if(nRotationAngle != n)
334 {
335 nRotationAngle = n;
336
337 // create new display
338 Touch();
339 }
340 }
341
342 void SdrHdl::SetPos(const Point& rPnt)
343 {
344 if(aPos != rPnt)
345 {
346 // remember new position
347 aPos = rPnt;
348
349 // create new display
350 Touch();
351 }
352 }
353
354 void SdrHdl::SetSelected(bool bJa)
355 {
356 if(bSelect != bJa)
357 {
358 // remember new value
359 bSelect = bJa;
360
361 // create new display
362 Touch();
363 }
364 }
365
366 void SdrHdl::SetHdlList(SdrHdlList* pList)
367 {
368 if(pHdlList != pList)
369 {
370 // remember list
371 pHdlList = pList;
372
373 // now its possible to create graphic representation
374 Touch();
375 }
376 }
377
378 void SdrHdl::SetObj(SdrObject* pNewObj)
379 {
380 if(pObj != pNewObj)
381 {
382 // remember new object
383 pObj = pNewObj;
384
385 // graphic representation may have changed
386 Touch();
387 }
388 }
389
390 void SdrHdl::Touch()
391 {
392 // force update of graphic representation
393 CreateB2dIAObject();
394 }
395
396 void SdrHdl::GetRidOfIAObject()
397 {
398
399 // OVERLAYMANAGER
400 maOverlayGroup.clear();
401 }
402
403 void SdrHdl::CreateB2dIAObject()
404 {
405 // first throw away old one
406 GetRidOfIAObject();
407
408 if(pHdlList && pHdlList->GetView() && !pHdlList->GetView()->areMarkHandlesHidden())
409 {
410 BitmapColorIndex eColIndex = BitmapColorIndex::LightGreen;
411 BitmapMarkerKind eKindOfMarker = BitmapMarkerKind::Rect_7x7;
412
413 bool bRot = pHdlList->IsRotateShear();
414 if(pObj)
415 eColIndex = bSelect ? BitmapColorIndex::Cyan : BitmapColorIndex::LightCyan;
416 if(bRot)
417 {
418 // red rotation handles
419 if(pObj && bSelect)
420 eColIndex = BitmapColorIndex::Red;
421 else
422 eColIndex = BitmapColorIndex::LightRed;
423 }
424
425 switch(eKind)
426 {
427 case SdrHdlKind::Move:
428 {
429 eKindOfMarker = (b1PixMore) ? BitmapMarkerKind::Rect_9x9 : BitmapMarkerKind::Rect_7x7;
430 break;
431 }
432 case SdrHdlKind::UpperLeft:
433 case SdrHdlKind::UpperRight:
434 case SdrHdlKind::LowerLeft:
435 case SdrHdlKind::LowerRight:
436 {
437 // corner handles
438 if(bRot)
439 {
440 eKindOfMarker = BitmapMarkerKind::Circ_7x7;
441 }
442 else
443 {
444 eKindOfMarker = BitmapMarkerKind::Rect_7x7;
445 }
446 break;
447 }
448 case SdrHdlKind::Upper:
449 case SdrHdlKind::Lower:
450 {
451 // Upper/Lower handles
452 if(bRot)
453 {
454 eKindOfMarker = BitmapMarkerKind::Elli_9x7;
455 }
456 else
457 {
458 eKindOfMarker = BitmapMarkerKind::Rect_7x7;
459 }
460 break;
461 }
462 case SdrHdlKind::Left:
463 case SdrHdlKind::Right:
464 {
465 // Left/Right handles
466 if(bRot)
467 {
468 eKindOfMarker = BitmapMarkerKind::Elli_7x9;
469 }
470 else
471 {
472 eKindOfMarker = BitmapMarkerKind::Rect_7x7;
473 }
474 break;
475 }
476 case SdrHdlKind::Poly:
477 {
478 if(bRot)
479 {
480 eKindOfMarker = b1PixMore ? BitmapMarkerKind::Circ_9x9 : BitmapMarkerKind::Circ_7x7;
481 }
482 else
483 {
484 eKindOfMarker = b1PixMore ? BitmapMarkerKind::Rect_9x9 : BitmapMarkerKind::Rect_7x7;
485 }
486 break;
487 }
488 case SdrHdlKind::BezierWeight: // weight at poly
489 {
490 eKindOfMarker = BitmapMarkerKind::Circ_7x7;
491 break;
492 }
493 case SdrHdlKind::Circle:
494 {
495 eKindOfMarker = BitmapMarkerKind::Rect_11x11;
496 break;
497 }
498 case SdrHdlKind::Ref1:
499 case SdrHdlKind::Ref2:
500 {
501 eKindOfMarker = BitmapMarkerKind::Crosshair;
502 break;
503 }
504 case SdrHdlKind::Glue:
505 {
506 eKindOfMarker = BitmapMarkerKind::Glue;
507 break;
508 }
509 case SdrHdlKind::Anchor:
510 {
511 eKindOfMarker = BitmapMarkerKind::Anchor;
512 break;
513 }
514 case SdrHdlKind::User:
515 {
516 break;
517 }
518 // top right anchor for SW
519 case SdrHdlKind::Anchor_TR:
520 {
521 eKindOfMarker = BitmapMarkerKind::AnchorTR;
522 break;
523 }
524
525 // for SJ and the CustomShapeHandles:
526 case SdrHdlKind::CustomShape1:
527 {
528 eKindOfMarker = b1PixMore ? BitmapMarkerKind::Customshape_9x9 : BitmapMarkerKind::Customshape_7x7;
529 eColIndex = BitmapColorIndex::Yellow;
530 break;
531 }
532 default:
533 break;
534 }
535
536 SdrMarkView* pView = pHdlList->GetView();
537 SdrPageView* pPageView = pView->GetSdrPageView();
538
539 if(pPageView)
540 {
541 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
542 {
543 // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b];
544 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
545
546 if(rPageWindow.GetPaintWindow().OutputToWindow())
547 {
548 Point aMoveOutsideOffset(0, 0);
549 OutputDevice& rOutDev = rPageWindow.GetPaintWindow().GetOutputDevice();
550
551 // add offset if necessary
552 if(pHdlList->IsMoveOutside() || mbMoveOutside)
553 {
554 Size aOffset = rOutDev.PixelToLogic(Size(4, 4));
555
556 if(eKind == SdrHdlKind::UpperLeft || eKind == SdrHdlKind::Upper || eKind == SdrHdlKind::UpperRight)
557 aMoveOutsideOffset.Y() -= aOffset.Width();
558 if(eKind == SdrHdlKind::LowerLeft || eKind == SdrHdlKind::Lower || eKind == SdrHdlKind::LowerRight)
559 aMoveOutsideOffset.Y() += aOffset.Height();
560 if(eKind == SdrHdlKind::UpperLeft || eKind == SdrHdlKind::Left || eKind == SdrHdlKind::LowerLeft)
561 aMoveOutsideOffset.X() -= aOffset.Width();
562 if(eKind == SdrHdlKind::UpperRight || eKind == SdrHdlKind::Right || eKind == SdrHdlKind::LowerRight)
563 aMoveOutsideOffset.X() += aOffset.Height();
564 }
565
566 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
567 if (xManager.is())
568 {
569 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
570 sdr::overlay::OverlayObject* pNewOverlayObject = nullptr;
571 if (getenv ("SVX_DRAW_HANDLES") && (eKindOfMarker == BitmapMarkerKind::Rect_7x7 || eKindOfMarker == BitmapMarkerKind::Rect_9x9 || eKindOfMarker == BitmapMarkerKind::Rect_11x11))
572 {
573 double fSize = 7.0;
574 switch (eKindOfMarker)
575 {
576 case BitmapMarkerKind::Rect_9x9:
577 fSize = 9.0;
578 break;
579 case BitmapMarkerKind::Rect_11x11:
580 fSize = 11.0;
581 break;
582 default:
583 break;
584 }
585 float fScalingFactor = rOutDev.GetDPIScaleFactor();
586 basegfx::B2DSize aB2DSize(fSize * fScalingFactor, fSize * fScalingFactor);
587
588 Color aHandleStrokeColor(COL_BLACK);
589 Color aHandleFillColor(COL_LIGHTGREEN);
590 switch (eColIndex)
591 {
592 case BitmapColorIndex::Cyan:
593 aHandleFillColor = Color(COL_CYAN);
594 break;
595 case BitmapColorIndex::LightCyan:
596 aHandleFillColor = Color(COL_LIGHTCYAN);
597 break;
598 case BitmapColorIndex::Red:
599 aHandleFillColor = Color(COL_RED);
600 break;
601 case BitmapColorIndex::LightRed:
602 aHandleFillColor = Color(COL_LIGHTRED);
603 break;
604 case BitmapColorIndex::Yellow:
605 aHandleFillColor = Color(COL_YELLOW);
606 break;
607 default:
608 break;
609 }
610 pNewOverlayObject = new sdr::overlay::OverlayHandle(aPosition, aB2DSize, aHandleStrokeColor, aHandleFillColor);
611 }
612 else
613 {
614 pNewOverlayObject = CreateOverlayObject(
615 aPosition, eColIndex, eKindOfMarker,
616 aMoveOutsideOffset);
617 }
618 // OVERLAYMANAGER
619 if (pNewOverlayObject)
620 {
621 xManager->add(*pNewOverlayObject);
622 maOverlayGroup.append(pNewOverlayObject);
623 }
624 }
625 }
626 }
627 }
628 }
629 }
630
631 BitmapMarkerKind SdrHdl::GetNextBigger(BitmapMarkerKind eKnd)
632 {
633 BitmapMarkerKind eRetval(eKnd);
634
635 switch(eKnd)
636 {
637 case BitmapMarkerKind::Rect_7x7: eRetval = BitmapMarkerKind::Rect_9x9; break;
638 case BitmapMarkerKind::Rect_9x9: eRetval = BitmapMarkerKind::Rect_11x11; break;
639 case BitmapMarkerKind::Rect_11x11: eRetval = BitmapMarkerKind::Rect_13x13; break;
640
641 case BitmapMarkerKind::Circ_7x7: eRetval = BitmapMarkerKind::Circ_9x9; break;
642 case BitmapMarkerKind::Circ_9x9: eRetval = BitmapMarkerKind::Circ_11x11; break;
643
644 case BitmapMarkerKind::Customshape_7x7: eRetval = BitmapMarkerKind::Customshape_9x9; break;
645 case BitmapMarkerKind::Customshape_9x9: eRetval = BitmapMarkerKind::Customshape_11x11; break;
646 //case BitmapMarkerKind::Customshape_11x11: eRetval = ; break;
647
648 case BitmapMarkerKind::Elli_7x9: eRetval = BitmapMarkerKind::Elli_9x11; break;
649
650 case BitmapMarkerKind::Elli_9x7: eRetval = BitmapMarkerKind::Elli_11x9; break;
651
652 case BitmapMarkerKind::RectPlus_7x7: eRetval = BitmapMarkerKind::RectPlus_9x9; break;
653 case BitmapMarkerKind::RectPlus_9x9: eRetval = BitmapMarkerKind::RectPlus_11x11; break;
654
655 // let anchor blink with its pressed state
656 case BitmapMarkerKind::Anchor: eRetval = BitmapMarkerKind::AnchorPressed; break;
657
658 // same for AnchorTR
659 case BitmapMarkerKind::AnchorTR: eRetval = BitmapMarkerKind::AnchorPressedTR; break;
660 default:
661 break;
662 }
663
664 return eRetval;
665 }
666
667 namespace
668 {
669
670 OUString appendMarkerName(BitmapMarkerKind eKindOfMarker)
671 {
672 switch(eKindOfMarker)
673 {
674 case BitmapMarkerKind::Rect_7x7:
675 return OUString("rect7");
676 case BitmapMarkerKind::Rect_9x9:
677 return OUString("rect9");
678 case BitmapMarkerKind::Rect_11x11:
679 return OUString("rect11");
680 case BitmapMarkerKind::Rect_13x13:
681 return OUString("rect13");
682 case BitmapMarkerKind::Circ_7x7:
683 case BitmapMarkerKind::Customshape_7x7:
684 return OUString("circ7");
685 case BitmapMarkerKind::Circ_9x9:
686 case BitmapMarkerKind::Customshape_9x9:
687 return OUString("circ9");
688 case BitmapMarkerKind::Circ_11x11:
689 case BitmapMarkerKind::Customshape_11x11:
690 return OUString("circ11");
691 case BitmapMarkerKind::Elli_7x9:
692 return OUString("elli7x9");
693 case BitmapMarkerKind::Elli_9x11:
694 return OUString("elli9x11");
695 case BitmapMarkerKind::Elli_9x7:
696 return OUString("elli9x7");
697 case BitmapMarkerKind::Elli_11x9:
698 return OUString("elli11x9");
699 case BitmapMarkerKind::RectPlus_7x7:
700 return OUString("rectplus7");
701 case BitmapMarkerKind::RectPlus_9x9:
702 return OUString("rectplus9");
703 case BitmapMarkerKind::RectPlus_11x11:
704 return OUString("rectplus11");
705 case BitmapMarkerKind::Crosshair:
706 return OUString("cross");
707 case BitmapMarkerKind::Anchor:
708 case BitmapMarkerKind::AnchorTR:
709 return OUString("anchor");
710 case BitmapMarkerKind::AnchorPressed:
711 case BitmapMarkerKind::AnchorPressedTR:
712 return OUString("anchor-pressed");
713 case BitmapMarkerKind::Glue:
714 return OUString("glue-selected");
715 case BitmapMarkerKind::Glue_Deselected:
716 return OUString("glue-unselected");
717 default:
718 break;
719 }
720 return OUString();
721 }
722
723 OUString appendMarkerColor(BitmapColorIndex eIndex)
724 {
725 switch(eIndex)
726 {
727 case BitmapColorIndex::LightGreen:
728 return OUString("1");
729 case BitmapColorIndex::Cyan:
730 return OUString("2");
731 case BitmapColorIndex::LightCyan:
732 return OUString("3");
733 case BitmapColorIndex::Red:
734 return OUString("4");
735 case BitmapColorIndex::LightRed:
736 return OUString("5");
737 case BitmapColorIndex::Yellow:
738 return OUString("6");
739 default:
740 break;
741 }
742 return OUString();
743 }
744
745 BitmapEx ImpGetBitmapEx(BitmapMarkerKind eKindOfMarker, BitmapColorIndex eIndex)
746 {
747 // use this code path only when we use HiDPI (for now)
748 if (Application::GetDefaultDevice()->GetDPIScalePercentage() > 100)
749 {
750 OUString sMarkerPrefix("svx/res/marker-");
751
752 OUString sMarkerName = appendMarkerName(eKindOfMarker);
753 if (!sMarkerName.isEmpty())
754 {
755 BitmapEx aBitmapEx;
756
757 if (eKindOfMarker == BitmapMarkerKind::Crosshair
758 || eKindOfMarker == BitmapMarkerKind::Anchor
759 || eKindOfMarker == BitmapMarkerKind::AnchorTR
760 || eKindOfMarker == BitmapMarkerKind::AnchorPressed
761 || eKindOfMarker == BitmapMarkerKind::AnchorPressedTR
762 || eKindOfMarker == BitmapMarkerKind::Glue
763 || eKindOfMarker == BitmapMarkerKind::Glue_Deselected)
764 {
765 aBitmapEx = vcl::bitmap::loadFromName(sMarkerPrefix + sMarkerName + ".png");
766 }
767 else
768 {
769 aBitmapEx = vcl::bitmap::loadFromName(sMarkerPrefix + sMarkerName + "-" + appendMarkerColor(eIndex) + ".png");
770 }
771
772 if (!aBitmapEx.IsEmpty())
773 return aBitmapEx;
774 }
775 }
776
777 // if we can't load the marker..
778
779 static vcl::DeleteOnDeinit< SdrHdlBitmapSet > aModernSet(new SdrHdlBitmapSet);
780 return aModernSet.get()->GetBitmapEx(eKindOfMarker, sal_uInt16(eIndex));
781 }
782
783 } // end anonymous namespace
784
785 sdr::overlay::OverlayObject* SdrHdl::CreateOverlayObject(
786 const basegfx::B2DPoint& rPos,
787 BitmapColorIndex eColIndex, BitmapMarkerKind eKindOfMarker, Point aMoveOutsideOffset)
788 {
789 sdr::overlay::OverlayObject* pRetval = nullptr;
790
791 // support bigger sizes
792 bool bForceBiggerSize(false);
793
794 if(pHdlList->GetHdlSize() > 3)
795 {
796 switch(eKindOfMarker)
797 {
798 case BitmapMarkerKind::Anchor:
799 case BitmapMarkerKind::AnchorPressed:
800 case BitmapMarkerKind::AnchorTR:
801 case BitmapMarkerKind::AnchorPressedTR:
802 {
803 // #i121463# For anchor, do not simply make bigger because of HdlSize,
804 // do it dependent of IsSelected() which Writer can set in drag mode
805 if(IsSelected())
806 {
807 bForceBiggerSize = true;
808 }
809 break;
810 }
811 default:
812 {
813 bForceBiggerSize = true;
814 break;
815 }
816 }
817 }
818
819 if(bForceBiggerSize)
820 {
821 eKindOfMarker = GetNextBigger(eKindOfMarker);
822 }
823
824 // This handle has the focus, visualize it
825 if(IsFocusHdl() && pHdlList && pHdlList->GetFocusHdl() == this)
826 {
827 // create animated handle
828 BitmapMarkerKind eNextBigger = GetNextBigger(eKindOfMarker);
829
830 if(eNextBigger == eKindOfMarker)
831 {
832 // this may happen for the not supported getting-bigger types.
833 // Choose an alternative here
834 switch(eKindOfMarker)
835 {
836 case BitmapMarkerKind::Rect_13x13: eNextBigger = BitmapMarkerKind::Rect_11x11; break;
837 case BitmapMarkerKind::Circ_11x11: eNextBigger = BitmapMarkerKind::Elli_11x9; break;
838 case BitmapMarkerKind::Elli_9x11: eNextBigger = BitmapMarkerKind::Elli_11x9; break;
839 case BitmapMarkerKind::Elli_11x9: eNextBigger = BitmapMarkerKind::Elli_9x11; break;
840 case BitmapMarkerKind::RectPlus_11x11: eNextBigger = BitmapMarkerKind::Rect_13x13; break;
841
842 case BitmapMarkerKind::Crosshair:
843 eNextBigger = BitmapMarkerKind::Glue;
844 break;
845
846 case BitmapMarkerKind::Glue:
847 eNextBigger = BitmapMarkerKind::Crosshair;
848 break;
849 case BitmapMarkerKind::Glue_Deselected:
850 eNextBigger = BitmapMarkerKind::Glue;
851 break;
852 default:
853 break;
854 }
855 }
856
857 // create animated handle
858 BitmapEx aBmpEx1 = ImpGetBitmapEx(eKindOfMarker, eColIndex);
859 BitmapEx aBmpEx2 = ImpGetBitmapEx(eNextBigger, eColIndex);
860
861 // #i53216# Use system cursor blink time. Use the unsigned value.
862 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
863 const sal_uInt64 nBlinkTime(rStyleSettings.GetCursorBlinkTime());
864
865 if(eKindOfMarker == BitmapMarkerKind::Anchor || eKindOfMarker == BitmapMarkerKind::AnchorPressed)
866 {
867 // when anchor is used take upper left as reference point inside the handle
868 pRetval = new sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime);
869 }
870 else if(eKindOfMarker == BitmapMarkerKind::AnchorTR || eKindOfMarker == BitmapMarkerKind::AnchorPressedTR)
871 {
872 // AnchorTR for SW, take top right as (0,0)
873 pRetval = new sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime,
874 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1), 0,
875 (sal_uInt16)(aBmpEx2.GetSizePixel().Width() - 1), 0);
876 }
877 else
878 {
879 // create centered handle as default
880 pRetval = new sdr::overlay::OverlayAnimatedBitmapEx(rPos, aBmpEx1, aBmpEx2, nBlinkTime,
881 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1) >> 1,
882 (sal_uInt16)(aBmpEx1.GetSizePixel().Height() - 1) >> 1,
883 (sal_uInt16)(aBmpEx2.GetSizePixel().Width() - 1) >> 1,
884 (sal_uInt16)(aBmpEx2.GetSizePixel().Height() - 1) >> 1);
885 }
886 }
887 else
888 {
889 // create normal handle: use ImpGetBitmapEx(...) now
890 BitmapEx aBmpEx = ImpGetBitmapEx(eKindOfMarker, eColIndex);
891
892 // When the image with handles is not found, the bitmap returned is
893 // empty. This is a problem when we use LibreOffice as a library
894 // (through LOKit - for example on Android) even when we don't show
895 // the handles, because the hit test would always return false.
896 //
897 // This HACK replaces the empty bitmap with a black 13x13 bitmap handle
898 // so that the hit test works for this case.
899 if (aBmpEx.IsEmpty())
900 {
901 aBmpEx = BitmapEx(Bitmap(Size(13, 13), 24));
902 aBmpEx.Erase(COL_BLACK);
903 }
904
905 if(eKindOfMarker == BitmapMarkerKind::Anchor || eKindOfMarker == BitmapMarkerKind::AnchorPressed)
906 {
907 // upper left as reference point inside the handle for AnchorPressed, too
908 pRetval = new sdr::overlay::OverlayBitmapEx(rPos, aBmpEx);
909 }
910 else if(eKindOfMarker == BitmapMarkerKind::AnchorTR || eKindOfMarker == BitmapMarkerKind::AnchorPressedTR)
911 {
912 // AnchorTR for SW, take top right as (0,0)
913 pRetval = new sdr::overlay::OverlayBitmapEx(rPos, aBmpEx,
914 (sal_uInt16)(aBmpEx.GetSizePixel().Width() - 1), 0);
915 }
916 else
917 {
918 sal_uInt16 nCenX((sal_uInt16)(aBmpEx.GetSizePixel().Width() - 1) >> 1);
919 sal_uInt16 nCenY((sal_uInt16)(aBmpEx.GetSizePixel().Height() - 1) >> 1);
920
921 if(aMoveOutsideOffset.X() > 0)
922 {
923 nCenX = 0;
924 }
925 else if(aMoveOutsideOffset.X() < 0)
926 {
927 nCenX = (sal_uInt16)(aBmpEx.GetSizePixel().Width() - 1);
928 }
929
930 if(aMoveOutsideOffset.Y() > 0)
931 {
932 nCenY = 0;
933 }
934 else if(aMoveOutsideOffset.Y() < 0)
935 {
936 nCenY = (sal_uInt16)(aBmpEx.GetSizePixel().Height() - 1);
937 }
938
939 // create centered handle as default
940 pRetval = new sdr::overlay::OverlayBitmapEx(rPos, aBmpEx, nCenX, nCenY);
941 }
942 }
943
944 return pRetval;
945 }
946
947 bool SdrHdl::IsHdlHit(const Point& rPnt) const
948 {
949 // OVERLAYMANAGER
950 basegfx::B2DPoint aPosition(rPnt.X(), rPnt.Y());
951 return maOverlayGroup.isHitLogic(aPosition);
952 }
953
954 Pointer SdrHdl::GetPointer() const
955 {
956 PointerStyle ePtr=PointerStyle::Move;
957 const bool bSize=eKind>=SdrHdlKind::UpperLeft && eKind<=SdrHdlKind::LowerRight;
958 const bool bRot=pHdlList!=nullptr && pHdlList->IsRotateShear();
959 const bool bDis=pHdlList!=nullptr && pHdlList->IsDistortShear();
960 if (bSize && pHdlList!=nullptr && (bRot || bDis)) {
961 switch (eKind) {
962 case SdrHdlKind::UpperLeft: case SdrHdlKind::UpperRight:
963 case SdrHdlKind::LowerLeft: case SdrHdlKind::LowerRight: ePtr=bRot ? PointerStyle::Rotate : PointerStyle::RefHand; break;
964 case SdrHdlKind::Left : case SdrHdlKind::Right: ePtr=PointerStyle::VShear; break;
965 case SdrHdlKind::Upper: case SdrHdlKind::Lower: ePtr=PointerStyle::HShear; break;
966 default:
967 break;
968 }
969 } else {
970 // When resizing rotated rectangles, rotate the mouse cursor slightly, too
971 if (bSize && nRotationAngle!=0) {
972 long nHdlAngle=0;
973 switch (eKind) {
974 case SdrHdlKind::LowerRight: nHdlAngle=31500; break;
975 case SdrHdlKind::Lower: nHdlAngle=27000; break;
976 case SdrHdlKind::LowerLeft: nHdlAngle=22500; break;
977 case SdrHdlKind::Left : nHdlAngle=18000; break;
978 case SdrHdlKind::UpperLeft: nHdlAngle=13500; break;
979 case SdrHdlKind::Upper: nHdlAngle=9000; break;
980 case SdrHdlKind::UpperRight: nHdlAngle=4500; break;
981 case SdrHdlKind::Right: nHdlAngle=0; break;
982 default:
983 break;
984 }
985 nHdlAngle+=nRotationAngle+2249; // a little bit more (for rounding)
986 while (nHdlAngle<0) nHdlAngle+=36000;
987 while (nHdlAngle>=36000) nHdlAngle-=36000;
988 nHdlAngle/=4500;
989 switch ((sal_uInt8)nHdlAngle) {
990 case 0: ePtr=PointerStyle::ESize; break;
991 case 1: ePtr=PointerStyle::NESize; break;
992 case 2: ePtr=PointerStyle::NSize; break;
993 case 3: ePtr=PointerStyle::NWSize; break;
994 case 4: ePtr=PointerStyle::WSize; break;
995 case 5: ePtr=PointerStyle::SWSize; break;
996 case 6: ePtr=PointerStyle::SSize; break;
997 case 7: ePtr=PointerStyle::SESize; break;
998 } // switch
999 } else {
1000 switch (eKind) {
1001 case SdrHdlKind::UpperLeft: ePtr=PointerStyle::NWSize; break;
1002 case SdrHdlKind::Upper: ePtr=PointerStyle::NSize; break;
1003 case SdrHdlKind::UpperRight: ePtr=PointerStyle::NESize; break;
1004 case SdrHdlKind::Left : ePtr=PointerStyle::WSize; break;
1005 case SdrHdlKind::Right: ePtr=PointerStyle::ESize; break;
1006 case SdrHdlKind::LowerLeft: ePtr=PointerStyle::SWSize; break;
1007 case SdrHdlKind::Lower: ePtr=PointerStyle::SSize; break;
1008 case SdrHdlKind::LowerRight: ePtr=PointerStyle::SESize; break;
1009 case SdrHdlKind::Poly : ePtr=PointerStyle::MovePoint; break;
1010 case SdrHdlKind::Circle : ePtr=PointerStyle::Hand; break;
1011 case SdrHdlKind::Ref1 : ePtr=PointerStyle::RefHand; break;
1012 case SdrHdlKind::Ref2 : ePtr=PointerStyle::RefHand; break;
1013 case SdrHdlKind::BezierWeight : ePtr=PointerStyle::MoveBezierWeight; break;
1014 case SdrHdlKind::Glue : ePtr=PointerStyle::MovePoint; break;
1015 case SdrHdlKind::CustomShape1 : ePtr=PointerStyle::Hand; break;
1016 default:
1017 break;
1018 }
1019 }
1020 }
1021 return Pointer(ePtr);
1022 }
1023
1024 bool SdrHdl::IsFocusHdl() const
1025 {
1026 switch(eKind)
1027 {
1028 case SdrHdlKind::UpperLeft:
1029 case SdrHdlKind::Upper:
1030 case SdrHdlKind::UpperRight:
1031 case SdrHdlKind::Left:
1032 case SdrHdlKind::Right:
1033 case SdrHdlKind::LowerLeft:
1034 case SdrHdlKind::Lower:
1035 case SdrHdlKind::LowerRight:
1036 {
1037 // if it's an activated TextEdit, it's moved to extended points
1038 return !pHdlList || !pHdlList->IsMoveOutside();
1039 }
1040
1041 case SdrHdlKind::Move: // handle to move object
1042 case SdrHdlKind::Poly: // selected point of polygon or curve
1043 case SdrHdlKind::BezierWeight: // weight at a curve
1044 case SdrHdlKind::Circle: // angle of circle segments, corner radius of rectangles
1045 case SdrHdlKind::Ref1: // reference point 1, e. g. center of rotation
1046 case SdrHdlKind::Ref2: // reference point 2, e. g. endpoint of reflection axis
1047 case SdrHdlKind::Glue: // glue point
1048
1049 // for SJ and the CustomShapeHandles:
1050 case SdrHdlKind::CustomShape1:
1051
1052 case SdrHdlKind::User:
1053 {
1054 return true;
1055 }
1056
1057 default:
1058 {
1059 return false;
1060 }
1061 }
1062 }
1063
1064 void SdrHdl::onMouseEnter(const MouseEvent& /*rMEvt*/)
1065 {
1066 }
1067
1068 void SdrHdl::onMouseLeave()
1069 {
1070 }
1071
1072 BitmapEx SdrHdl::createGluePointBitmap()
1073 {
1074 return ImpGetBitmapEx(BitmapMarkerKind::Glue_Deselected, BitmapColorIndex::LightGreen);
1075 }
1076
1077 SdrHdlColor::SdrHdlColor(const Point& rRef, Color aCol, const Size& rSize, bool bLum)
1078 : SdrHdl(rRef, SdrHdlKind::Color),
1079 aMarkerSize(rSize),
1080 bUseLuminance(bLum)
1081 {
1082 if(IsUseLuminance())
1083 aCol = GetLuminance(aCol);
1084
1085 // remember color
1086 aMarkerColor = aCol;
1087 }
1088
1089 SdrHdlColor::~SdrHdlColor()
1090 {
1091 }
1092
1093 void SdrHdlColor::CreateB2dIAObject()
1094 {
1095 // first throw away old one
1096 GetRidOfIAObject();
1097
1098 if(pHdlList)
1099 {
1100 SdrMarkView* pView = pHdlList->GetView();
1101
1102 if(pView && !pView->areMarkHandlesHidden())
1103 {
1104 SdrPageView* pPageView = pView->GetSdrPageView();
1105
1106 if(pPageView)
1107 {
1108 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1109 {
1110 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1111
1112 if(rPageWindow.GetPaintWindow().OutputToWindow())
1113 {
1114 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1115 if (xManager.is())
1116 {
1117 Bitmap aBmpCol(CreateColorDropper(aMarkerColor));
1118 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1119 sdr::overlay::OverlayObject* pNewOverlayObject = new
1120 sdr::overlay::OverlayBitmapEx(
1121 aPosition,
1122 BitmapEx(aBmpCol),
1123 (sal_uInt16)(aBmpCol.GetSizePixel().Width() - 1) >> 1,
1124 (sal_uInt16)(aBmpCol.GetSizePixel().Height() - 1) >> 1
1125 );
1126
1127 // OVERLAYMANAGER
1128 xManager->add(*pNewOverlayObject);
1129 maOverlayGroup.append(pNewOverlayObject);
1130 }
1131 }
1132 }
1133 }
1134 }
1135 }
1136 }
1137
1138 Bitmap SdrHdlColor::CreateColorDropper(Color aCol)
1139 {
1140 // get the Bitmap
1141 Bitmap aRetval(aMarkerSize, 24);
1142 aRetval.Erase(aCol);
1143
1144 // get write access
1145 std::unique_ptr<BitmapWriteAccess> pWrite(aRetval.AcquireWriteAccess());
1146 DBG_ASSERT(pWrite, "Got NO write access to a new Bitmap!");
1147
1148 if(pWrite)
1149 {
1150 // draw outer border
1151 sal_Int32 nWidth = aMarkerSize.Width();
1152 sal_Int32 nHeight = aMarkerSize.Height();
1153
1154 pWrite->SetLineColor(Color(COL_LIGHTGRAY));
1155 pWrite->DrawLine(Point(0, 0), Point(0, nHeight - 1));
1156 pWrite->DrawLine(Point(1, 0), Point(nWidth - 1, 0));
1157 pWrite->SetLineColor(Color(COL_GRAY));
1158 pWrite->DrawLine(Point(1, nHeight - 1), Point(nWidth - 1, nHeight - 1));
1159 pWrite->DrawLine(Point(nWidth - 1, 1), Point(nWidth - 1, nHeight - 2));
1160
1161 // draw lighter UpperLeft
1162 const Color aLightColor(
1163 (sal_uInt8)(::std::min((sal_Int16)((sal_Int16)aCol.GetRed() + (sal_Int16)0x0040), (sal_Int16)0x00ff)),
1164 (sal_uInt8)(::std::min((sal_Int16)((sal_Int16)aCol.GetGreen() + (sal_Int16)0x0040), (sal_Int16)0x00ff)),
1165 (sal_uInt8)(::std::min((sal_Int16)((sal_Int16)aCol.GetBlue() + (sal_Int16)0x0040), (sal_Int16)0x00ff)));
1166 pWrite->SetLineColor(aLightColor);
1167 pWrite->DrawLine(Point(1, 1), Point(1, nHeight - 2));
1168 pWrite->DrawLine(Point(2, 1), Point(nWidth - 2, 1));
1169
1170 // draw darker LowerRight
1171 const Color aDarkColor(
1172 (sal_uInt8)(::std::max((sal_Int16)((sal_Int16)aCol.GetRed() - (sal_Int16)0x0040), (sal_Int16)0x0000)),
1173 (sal_uInt8)(::std::max((sal_Int16)((sal_Int16)aCol.GetGreen() - (sal_Int16)0x0040), (sal_Int16)0x0000)),
1174 (sal_uInt8)(::std::max((sal_Int16)((sal_Int16)aCol.GetBlue() - (sal_Int16)0x0040), (sal_Int16)0x0000)));
1175 pWrite->SetLineColor(aDarkColor);
1176 pWrite->DrawLine(Point(2, nHeight - 2), Point(nWidth - 2, nHeight - 2));
1177 pWrite->DrawLine(Point(nWidth - 2, 2), Point(nWidth - 2, nHeight - 3));
1178 }
1179
1180 return aRetval;
1181 }
1182
1183 Color SdrHdlColor::GetLuminance(const Color& rCol)
1184 {
1185 sal_uInt8 aLum = rCol.GetLuminance();
1186 Color aRetval(aLum, aLum, aLum);
1187 return aRetval;
1188 }
1189
1190 void SdrHdlColor::SetColor(Color aNew, bool bCallLink)
1191 {
1192 if(IsUseLuminance())
1193 aNew = GetLuminance(aNew);
1194
1195 if(aMarkerColor != aNew)
1196 {
1197 // remember new color
1198 aMarkerColor = aNew;
1199
1200 // create new display
1201 Touch();
1202
1203 // tell about change
1204 if(bCallLink)
1205 aColorChangeHdl.Call(this);
1206 }
1207 }
1208
1209 void SdrHdlColor::SetSize(const Size& rNew)
1210 {
1211 if(rNew != aMarkerSize)
1212 {
1213 // remember new size
1214 aMarkerSize = rNew;
1215
1216 // create new display
1217 Touch();
1218 }
1219 }
1220
1221 SdrHdlGradient::SdrHdlGradient(const Point& rRef1, const Point& rRef2, bool bGrad)
1222 : SdrHdl(rRef1, bGrad ? SdrHdlKind::Gradient : SdrHdlKind::Transparence)
1223 , pColHdl1(nullptr)
1224 , pColHdl2(nullptr)
1225 , a2ndPos(rRef2)
1226 , bGradient(bGrad)
1227 , bMoveSingleHandle(false)
1228 , bMoveFirstHandle(false)
1229 {
1230 }
1231
1232 SdrHdlGradient::~SdrHdlGradient()
1233 {
1234 }
1235
1236 void SdrHdlGradient::Set2ndPos(const Point& rPnt)
1237 {
1238 if(a2ndPos != rPnt)
1239 {
1240 // remember new position
1241 a2ndPos = rPnt;
1242
1243 // create new display
1244 Touch();
1245 }
1246 }
1247
1248 void SdrHdlGradient::CreateB2dIAObject()
1249 {
1250 // first throw away old one
1251 GetRidOfIAObject();
1252
1253 if(pHdlList)
1254 {
1255 SdrMarkView* pView = pHdlList->GetView();
1256
1257 if(pView && !pView->areMarkHandlesHidden())
1258 {
1259 SdrPageView* pPageView = pView->GetSdrPageView();
1260
1261 if(pPageView)
1262 {
1263 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1264 {
1265 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1266
1267 if(rPageWindow.GetPaintWindow().OutputToWindow())
1268 {
1269 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1270 if (xManager.is())
1271 {
1272 // striped line in between
1273 basegfx::B2DVector aVec(a2ndPos.X() - aPos.X(), a2ndPos.Y() - aPos.Y());
1274 double fVecLen = aVec.getLength();
1275 double fLongPercentArrow = (1.0 - 0.05) * fVecLen;
1276 double fHalfArrowWidth = (0.05 * 0.5) * fVecLen;
1277 aVec.normalize();
1278 basegfx::B2DVector aPerpend(-aVec.getY(), aVec.getX());
1279 sal_Int32 nMidX = (sal_Int32)(aPos.X() + aVec.getX() * fLongPercentArrow);
1280 sal_Int32 nMidY = (sal_Int32)(aPos.Y() + aVec.getY() * fLongPercentArrow);
1281 Point aMidPoint(nMidX, nMidY);
1282
1283 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1284 basegfx::B2DPoint aMidPos(aMidPoint.X(), aMidPoint.Y());
1285
1286 sdr::overlay::OverlayObject* pNewOverlayObject = new
1287 sdr::overlay::OverlayLineStriped(
1288 aPosition, aMidPos
1289 );
1290 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1291
1292 pNewOverlayObject->setBaseColor(IsGradient() ? Color(COL_BLACK) : Color(COL_BLUE));
1293 xManager->add(*pNewOverlayObject);
1294 maOverlayGroup.append(pNewOverlayObject);
1295
1296 // arrowhead
1297 Point aLeft(aMidPoint.X() + (sal_Int32)(aPerpend.getX() * fHalfArrowWidth),
1298 aMidPoint.Y() + (sal_Int32)(aPerpend.getY() * fHalfArrowWidth));
1299 Point aRight(aMidPoint.X() - (sal_Int32)(aPerpend.getX() * fHalfArrowWidth),
1300 aMidPoint.Y() - (sal_Int32)(aPerpend.getY() * fHalfArrowWidth));
1301
1302 basegfx::B2DPoint aPositionLeft(aLeft.X(), aLeft.Y());
1303 basegfx::B2DPoint aPositionRight(aRight.X(), aRight.Y());
1304 basegfx::B2DPoint aPosition2(a2ndPos.X(), a2ndPos.Y());
1305
1306 pNewOverlayObject = new
1307 sdr::overlay::OverlayTriangle(
1308 aPositionLeft,
1309 aPosition2,
1310 aPositionRight,
1311 IsGradient() ? Color(COL_BLACK) : Color(COL_BLUE)
1312 );
1313 DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
1314
1315 xManager->add(*pNewOverlayObject);
1316 maOverlayGroup.append(pNewOverlayObject);
1317 }
1318 }
1319 }
1320 }
1321 }
1322 }
1323 }
1324
1325 IMPL_LINK_NOARG(SdrHdlGradient, ColorChangeHdl, SdrHdlColor*, void)
1326 {
1327 if(GetObj())
1328 FromIAOToItem(GetObj(), true, true);
1329 }
1330
1331 void SdrHdlGradient::FromIAOToItem(SdrObject* _pObj, bool bSetItemOnObject, bool bUndo)
1332 {
1333 // from IAO positions and colors to gradient
1334 const SfxItemSet& rSet = _pObj->GetMergedItemSet();
1335
1336 GradTransformer aGradTransformer;
1337 GradTransGradient aOldGradTransGradient;
1338 GradTransGradient aGradTransGradient;
1339 GradTransVector aGradTransVector;
1340
1341 OUString aString;
1342
1343 aGradTransVector.maPositionA = basegfx::B2DPoint(GetPos().X(), GetPos().Y());
1344 aGradTransVector.maPositionB = basegfx::B2DPoint(Get2ndPos().X(), Get2ndPos().Y());
1345 if(pColHdl1)
1346 aGradTransVector.aCol1 = pColHdl1->GetColor();
1347 if(pColHdl2)
1348 aGradTransVector.aCol2 = pColHdl2->GetColor();
1349
1350 if(IsGradient())
1351 aOldGradTransGradient.aGradient = rSet.Get(XATTR_FILLGRADIENT).GetGradientValue();
1352 else
1353 aOldGradTransGradient.aGradient = rSet.Get(XATTR_FILLFLOATTRANSPARENCE).GetGradientValue();
1354
1355 // transform vector data to gradient
1356 GradTransformer::VecToGrad(aGradTransVector, aGradTransGradient, aOldGradTransGradient, _pObj, bMoveSingleHandle, bMoveFirstHandle);
1357
1358 if(bSetItemOnObject)
1359 {
1360 SdrModel* pModel = _pObj->GetModel();
1361 SfxItemSet aNewSet(pModel->GetItemPool());
1362
1363 if(IsGradient())
1364 {
1365 aString.clear();
1366 XFillGradientItem aNewGradItem(aString, aGradTransGradient.aGradient);
1367 aNewSet.Put(aNewGradItem);
1368 }
1369 else
1370 {
1371 aString.clear();
1372 XFillFloatTransparenceItem aNewTransItem(aString, aGradTransGradient.aGradient);
1373 aNewSet.Put(aNewTransItem);
1374 }
1375
1376 if(bUndo && pModel->IsUndoEnabled())
1377 {
1378 pModel->BegUndo(SvxResId(IsGradient() ? SIP_XA_FILLGRADIENT : SIP_XA_FILLTRANSPARENCE));
1379 pModel->AddUndo(pModel->GetSdrUndoFactory().CreateUndoAttrObject(*_pObj));
1380 pModel->EndUndo();
1381 }
1382
1383 pObj->SetMergedItemSetAndBroadcast(aNewSet);
1384 }
1385
1386 // back transformation, set values on pIAOHandle
1387 GradTransformer::GradToVec(aGradTransGradient, aGradTransVector, _pObj);
1388
1389 SetPos(Point(FRound(aGradTransVector.maPositionA.getX()), FRound(aGradTransVector.maPositionA.getY())));
1390 Set2ndPos(Point(FRound(aGradTransVector.maPositionB.getX()), FRound(aGradTransVector.maPositionB.getY())));
1391 if(pColHdl1)
1392 {
1393 pColHdl1->SetPos(Point(FRound(aGradTransVector.maPositionA.getX()), FRound(aGradTransVector.maPositionA.getY())));
1394 pColHdl1->SetColor(aGradTransVector.aCol1);
1395 }
1396 if(pColHdl2)
1397 {
1398 pColHdl2->SetPos(Point(FRound(aGradTransVector.maPositionB.getX()), FRound(aGradTransVector.maPositionB.getY())));
1399 pColHdl2->SetColor(aGradTransVector.aCol2);
1400 }
1401 }
1402
1403
1404 SdrHdlLine::~SdrHdlLine() {}
1405
1406 void SdrHdlLine::CreateB2dIAObject()
1407 {
1408 // first throw away old one
1409 GetRidOfIAObject();
1410
1411 if(pHdlList)
1412 {
1413 SdrMarkView* pView = pHdlList->GetView();
1414
1415 if(pView && !pView->areMarkHandlesHidden() && pHdl1 && pHdl2)
1416 {
1417 SdrPageView* pPageView = pView->GetSdrPageView();
1418
1419 if(pPageView)
1420 {
1421 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1422 {
1423 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1424
1425 if(rPageWindow.GetPaintWindow().OutputToWindow())
1426 {
1427 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1428 if (xManager.is())
1429 {
1430 basegfx::B2DPoint aPosition1(pHdl1->GetPos().X(), pHdl1->GetPos().Y());
1431 basegfx::B2DPoint aPosition2(pHdl2->GetPos().X(), pHdl2->GetPos().Y());
1432
1433 sdr::overlay::OverlayObject* pNewOverlayObject = new
1434 sdr::overlay::OverlayLineStriped(
1435 aPosition1,
1436 aPosition2
1437 );
1438
1439 // OVERLAYMANAGER
1440 // color(?)
1441 pNewOverlayObject->setBaseColor(Color(COL_LIGHTRED));
1442
1443 xManager->add(*pNewOverlayObject);
1444 maOverlayGroup.append(pNewOverlayObject);
1445 }
1446 }
1447 }
1448 }
1449 }
1450 }
1451 }
1452
1453 Pointer SdrHdlLine::GetPointer() const
1454 {
1455 return Pointer(PointerStyle::RefHand);
1456 }
1457
1458
1459 SdrHdlBezWgt::~SdrHdlBezWgt() {}
1460
1461 void SdrHdlBezWgt::CreateB2dIAObject()
1462 {
1463 // call parent
1464 SdrHdl::CreateB2dIAObject();
1465
1466 // create lines
1467 if(pHdlList)
1468 {
1469 SdrMarkView* pView = pHdlList->GetView();
1470
1471 if(pView && !pView->areMarkHandlesHidden())
1472 {
1473 SdrPageView* pPageView = pView->GetSdrPageView();
1474
1475 if(pPageView)
1476 {
1477 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1478 {
1479 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1480
1481 if(rPageWindow.GetPaintWindow().OutputToWindow())
1482 {
1483 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1484 if (xManager.is())
1485 {
1486 basegfx::B2DPoint aPosition1(pHdl1->GetPos().X(), pHdl1->GetPos().Y());
1487 basegfx::B2DPoint aPosition2(aPos.X(), aPos.Y());
1488
1489 if(!aPosition1.equal(aPosition2))
1490 {
1491 sdr::overlay::OverlayObject* pNewOverlayObject = new
1492 sdr::overlay::OverlayLineStriped(
1493 aPosition1,
1494 aPosition2
1495 );
1496 // OVERLAYMANAGER
1497 // line part is not hittable
1498 pNewOverlayObject->setHittable(false);
1499
1500 // color(?)
1501 pNewOverlayObject->setBaseColor(Color(COL_LIGHTBLUE));
1502
1503 xManager->add(*pNewOverlayObject);
1504 maOverlayGroup.append(pNewOverlayObject);
1505 }
1506 }
1507 }
1508 }
1509 }
1510 }
1511 }
1512 }
1513
1514
1515 E3dVolumeMarker::E3dVolumeMarker(const basegfx::B2DPolyPolygon& rWireframePoly)
1516 {
1517 aWireframePoly = rWireframePoly;
1518 }
1519
1520 void E3dVolumeMarker::CreateB2dIAObject()
1521 {
1522 // create lines
1523 if(pHdlList)
1524 {
1525 SdrMarkView* pView = pHdlList->GetView();
1526
1527 if(pView && !pView->areMarkHandlesHidden())
1528 {
1529 SdrPageView* pPageView = pView->GetSdrPageView();
1530
1531 if(pPageView)
1532 {
1533 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1534 {
1535 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1536
1537 if(rPageWindow.GetPaintWindow().OutputToWindow())
1538 {
1539 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1540 if (xManager.is() && aWireframePoly.count())
1541 {
1542 sdr::overlay::OverlayObject* pNewOverlayObject = new
1543 sdr::overlay::OverlayPolyPolygonStripedAndFilled(
1544 aWireframePoly);
1545
1546 // OVERLAYMANAGER
1547 pNewOverlayObject->setBaseColor(Color(COL_BLACK));
1548
1549 xManager->add(*pNewOverlayObject);
1550 maOverlayGroup.append(pNewOverlayObject);
1551 }
1552 }
1553 }
1554 }
1555 }
1556 }
1557 }
1558
1559
1560 ImpEdgeHdl::~ImpEdgeHdl()
1561 {
1562 }
1563
1564 void ImpEdgeHdl::CreateB2dIAObject()
1565 {
1566 if(nObjHdlNum <= 1 && pObj)
1567 {
1568 // first throw away old one
1569 GetRidOfIAObject();
1570
1571 BitmapColorIndex eColIndex = BitmapColorIndex::LightCyan;
1572 BitmapMarkerKind eKindOfMarker = BitmapMarkerKind::Rect_7x7;
1573
1574 if(pHdlList)
1575 {
1576 SdrMarkView* pView = pHdlList->GetView();
1577
1578 if(pView && !pView->areMarkHandlesHidden())
1579 {
1580 const SdrEdgeObj* pEdge = static_cast<SdrEdgeObj*>(pObj);
1581
1582 if(pEdge->GetConnectedNode(nObjHdlNum == 0) != nullptr)
1583 eColIndex = BitmapColorIndex::LightRed;
1584
1585 if(nPPntNum < 2)
1586 {
1587 // Handle with plus sign inside
1588 eKindOfMarker = BitmapMarkerKind::Circ_7x7;
1589 }
1590
1591 SdrPageView* pPageView = pView->GetSdrPageView();
1592
1593 if(pPageView)
1594 {
1595 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1596 {
1597 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1598
1599 if(rPageWindow.GetPaintWindow().OutputToWindow())
1600 {
1601 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1602 if (xManager.is())
1603 {
1604 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1605 sdr::overlay::OverlayObject* pNewOverlayObject = CreateOverlayObject(
1606 aPosition,
1607 eColIndex,
1608 eKindOfMarker);
1609
1610 // OVERLAYMANAGER
1611 if (pNewOverlayObject)
1612 {
1613 xManager->add(*pNewOverlayObject);
1614 maOverlayGroup.append(pNewOverlayObject);
1615 }
1616 }
1617 }
1618 }
1619 }
1620 }
1621 }
1622 }
1623 else
1624 {
1625 // call parent
1626 SdrHdl::CreateB2dIAObject();
1627 }
1628 }
1629
1630 void ImpEdgeHdl::SetLineCode(SdrEdgeLineCode eCode)
1631 {
1632 if(eLineCode != eCode)
1633 {
1634 // remember new value
1635 eLineCode = eCode;
1636
1637 // create new display
1638 Touch();
1639 }
1640 }
1641
1642 Pointer ImpEdgeHdl::GetPointer() const
1643 {
1644 SdrEdgeObj* pEdge=dynamic_cast<SdrEdgeObj*>( pObj );
1645 if (pEdge==nullptr)
1646 return SdrHdl::GetPointer();
1647 if (nObjHdlNum<=1)
1648 return Pointer(PointerStyle::MovePoint);
1649 if (IsHorzDrag())
1650 return Pointer(PointerStyle::ESize);
1651 else
1652 return Pointer(PointerStyle::SSize);
1653 }
1654
1655 bool ImpEdgeHdl::IsHorzDrag() const
1656 {
1657 SdrEdgeObj* pEdge=dynamic_cast<SdrEdgeObj*>( pObj );
1658 if (pEdge==nullptr)
1659 return false;
1660 if (nObjHdlNum<=1)
1661 return false;
1662
1663 SdrEdgeKind eEdgeKind = static_cast<const SdrEdgeKindItem&>(pEdge->GetObjectItem(SDRATTR_EDGEKIND)).GetValue();
1664
1665 const SdrEdgeInfoRec& rInfo=pEdge->aEdgeInfo;
1666 if (eEdgeKind==SdrEdgeKind::OrthoLines || eEdgeKind==SdrEdgeKind::Bezier)
1667 {
1668 return !rInfo.ImpIsHorzLine(eLineCode,*pEdge->pEdgeTrack);
1669 }
1670 else if (eEdgeKind==SdrEdgeKind::ThreeLines)
1671 {
1672 long nAngle=nObjHdlNum==2 ? rInfo.nAngle1 : rInfo.nAngle2;
1673 return nAngle==0 || nAngle==18000;
1674 }
1675 return false;
1676 }
1677
1678
1679 ImpMeasureHdl::~ImpMeasureHdl()
1680 {
1681 }
1682
1683 void ImpMeasureHdl::CreateB2dIAObject()
1684 {
1685 // first throw away old one
1686 GetRidOfIAObject();
1687
1688 if(pHdlList)
1689 {
1690 SdrMarkView* pView = pHdlList->GetView();
1691
1692 if(pView && !pView->areMarkHandlesHidden())
1693 {
1694 BitmapColorIndex eColIndex = BitmapColorIndex::LightCyan;
1695 BitmapMarkerKind eKindOfMarker = BitmapMarkerKind::Rect_9x9;
1696
1697 if(nObjHdlNum > 1)
1698 {
1699 eKindOfMarker = BitmapMarkerKind::Rect_7x7;
1700 }
1701
1702 if(bSelect)
1703 {
1704 eColIndex = BitmapColorIndex::Cyan;
1705 }
1706
1707 SdrPageView* pPageView = pView->GetSdrPageView();
1708
1709 if(pPageView)
1710 {
1711 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1712 {
1713 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1714
1715 if(rPageWindow.GetPaintWindow().OutputToWindow())
1716 {
1717 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1718 if (xManager.is())
1719 {
1720 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
1721 sdr::overlay::OverlayObject* pNewOverlayObject = CreateOverlayObject(
1722 aPosition,
1723 eColIndex,
1724 eKindOfMarker);
1725
1726 // OVERLAYMANAGER
1727 if (pNewOverlayObject)
1728 {
1729 xManager->add(*pNewOverlayObject);
1730 maOverlayGroup.append(pNewOverlayObject);
1731 }
1732 }
1733 }
1734 }
1735 }
1736 }
1737 }
1738 }
1739
1740 Pointer ImpMeasureHdl::GetPointer() const
1741 {
1742 switch (nObjHdlNum)
1743 {
1744 case 0: case 1: return Pointer(PointerStyle::Hand);
1745 case 2: case 3: return Pointer(PointerStyle::MovePoint);
1746 case 4: case 5: return SdrHdl::GetPointer(); // will then be rotated appropriately
1747 } // switch
1748 return Pointer(PointerStyle::NotAllowed);
1749 }
1750
1751
1752 ImpTextframeHdl::ImpTextframeHdl(const tools::Rectangle& rRect) :
1753 SdrHdl(rRect.TopLeft(),SdrHdlKind::Move),
1754 maRect(rRect)
1755 {
1756 }
1757
1758 void ImpTextframeHdl::CreateB2dIAObject()
1759 {
1760 // first throw away old one
1761 GetRidOfIAObject();
1762
1763 if(pHdlList)
1764 {
1765 SdrMarkView* pView = pHdlList->GetView();
1766
1767 if(pView && !pView->areMarkHandlesHidden())
1768 {
1769 SdrPageView* pPageView = pView->GetSdrPageView();
1770
1771 if(pPageView)
1772 {
1773 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
1774 {
1775 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
1776
1777 if(rPageWindow.GetPaintWindow().OutputToWindow())
1778 {
1779 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
1780 if (xManager.is())
1781 {
1782 const basegfx::B2DPoint aTopLeft(maRect.Left(), maRect.Top());
1783 const basegfx::B2DPoint aBottomRight(maRect.Right(), maRect.Bottom());
1784 const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
1785 const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor());
1786 const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
1787
1788 sdr::overlay::OverlayRectangle* pNewOverlayObject = new sdr::overlay::OverlayRectangle(
1789 aTopLeft,
1790 aBottomRight,
1791 aHilightColor,
1792 fTransparence,
1793 3.0,
1794 3.0,
1795 nRotationAngle * -F_PI18000,
1796 true); // allow animation; the Handle is not shown at text edit time
1797
1798 // OVERLAYMANAGER
1799 pNewOverlayObject->setHittable(false);
1800 xManager->add(*pNewOverlayObject);
1801 maOverlayGroup.append(pNewOverlayObject);
1802 }
1803 }
1804 }
1805 }
1806 }
1807 }
1808 }
1809
1810
1811 static bool ImpSdrHdlListSorter(SdrHdl* const& lhs, SdrHdl* const& rhs)
1812 {
1813 SdrHdlKind eKind1=lhs->GetKind();
1814 SdrHdlKind eKind2=rhs->GetKind();
1815 // Level 1: first normal handles, then Glue, then User, then Plus handles, then reference point handles
1816 unsigned n1=1;
1817 unsigned n2=1;
1818 if (eKind1!=eKind2)
1819 {
1820 if (eKind1==SdrHdlKind::Ref1 || eKind1==SdrHdlKind::Ref2 || eKind1==SdrHdlKind::MirrorAxis) n1=5;
1821 else if (eKind1==SdrHdlKind::Glue) n1=2;
1822 else if (eKind1==SdrHdlKind::User) n1=3;
1823 else if (eKind1==SdrHdlKind::SmartTag) n1=0;
1824 if (eKind2==SdrHdlKind::Ref1 || eKind2==SdrHdlKind::Ref2 || eKind2==SdrHdlKind::MirrorAxis) n2=5;
1825 else if (eKind2==SdrHdlKind::Glue) n2=2;
1826 else if (eKind2==SdrHdlKind::User) n2=3;
1827 else if (eKind2==SdrHdlKind::SmartTag) n2=0;
1828 }
1829 if (lhs->IsPlusHdl()) n1=4;
1830 if (rhs->IsPlusHdl()) n2=4;
1831 if (n1==n2)
1832 {
1833 // Level 2: PageView (Pointer)
1834 SdrPageView* pPV1=lhs->GetPageView();
1835 SdrPageView* pPV2=rhs->GetPageView();
1836 if (pPV1==pPV2)
1837 {
1838 // Level 3: Position (x+y)
1839 SdrObject* pObj1=lhs->GetObj();
1840 SdrObject* pObj2=rhs->GetObj();
1841 if (pObj1==pObj2)
1842 {
1843 sal_uInt32 nNum1=lhs->GetObjHdlNum();
1844 sal_uInt32 nNum2=rhs->GetObjHdlNum();
1845 if (nNum1==nNum2)
1846 {
1847 if (eKind1==eKind2)
1848 return lhs<rhs; // Hack, to always get to the same sorting
1849 return (sal_uInt16)eKind1<(sal_uInt16)eKind2;
1850 }
1851 else
1852 return nNum1<nNum2;
1853 }
1854 else
1855 {
1856 return pObj1<pObj2;
1857 }
1858 }
1859 else
1860 {
1861 return pPV1<pPV2;
1862 }
1863 }
1864 else
1865 {
1866 return n1<n2;
1867 }
1868 }
1869
1870
1871 // Helper struct for re-sorting handles
1872 struct ImplHdlAndIndex
1873 {
1874 SdrHdl* mpHdl;
1875 sal_uInt32 mnIndex;
1876 };
1877
1878 // Helper method for sorting handles taking care of OrdNums, keeping order in
1879 // single objects and re-sorting polygon handles intuitively
1880 extern "C" int ImplSortHdlFunc( const void* pVoid1, const void* pVoid2 )
1881 {
1882 const ImplHdlAndIndex* p1 = static_cast<ImplHdlAndIndex const *>(pVoid1);
1883 const ImplHdlAndIndex* p2 = static_cast<ImplHdlAndIndex const *>(pVoid2);
1884
1885 if(p1->mpHdl->GetObj() == p2->mpHdl->GetObj())
1886 {
1887 if(p1->mpHdl->GetObj() && dynamic_cast<const SdrPathObj*>(p1->mpHdl->GetObj()) != nullptr)
1888 {
1889 // same object and a path object
1890 if((p1->mpHdl->GetKind() == SdrHdlKind::Poly || p1->mpHdl->GetKind() == SdrHdlKind::BezierWeight)
1891 && (p2->mpHdl->GetKind() == SdrHdlKind::Poly || p2->mpHdl->GetKind() == SdrHdlKind::BezierWeight))
1892 {
1893 // both handles are point or control handles
1894 if(p1->mpHdl->GetPolyNum() == p2->mpHdl->GetPolyNum())
1895 {
1896 if(p1->mpHdl->GetPointNum() < p2->mpHdl->GetPointNum())
1897 {
1898 return -1;
1899 }
1900 else
1901 {
1902 return 1;
1903 }
1904 }
1905 else if(p1->mpHdl->GetPolyNum() < p2->mpHdl->GetPolyNum())
1906 {
1907 return -1;
1908 }
1909 else
1910 {
1911 return 1;
1912 }
1913 }
1914 }
1915 }
1916 else
1917 {
1918 if(!p1->mpHdl->GetObj())
1919 {
1920 return -1;
1921 }
1922 else if(!p2->mpHdl->GetObj())
1923 {
1924 return 1;
1925 }
1926 else
1927 {
1928 // different objects, use OrdNum for sort
1929 const sal_uInt32 nOrdNum1 = p1->mpHdl->GetObj()->GetOrdNum();
1930 const sal_uInt32 nOrdNum2 = p2->mpHdl->GetObj()->GetOrdNum();
1931
1932 if(nOrdNum1 < nOrdNum2)
1933 {
1934 return -1;
1935 }
1936 else
1937 {
1938 return 1;
1939 }
1940 }
1941 }
1942
1943 // fallback to indices
1944 if(p1->mnIndex < p2->mnIndex)
1945 {
1946 return -1;
1947 }
1948 else
1949 {
1950 return 1;
1951 }
1952 }
1953
1954
1955 void SdrHdlList::TravelFocusHdl(bool bForward)
1956 {
1957 // security correction
1958 if (mnFocusIndex >= GetHdlCount())
1959 mnFocusIndex = SAL_MAX_SIZE;
1960
1961 if(aList.empty())
1962 return;
1963
1964 // take care of old handle
1965 const size_t nOldHdlNum(mnFocusIndex);
1966 SdrHdl* pOld = GetHdl(nOldHdlNum);
1967
1968 if(pOld)
1969 {
1970 // switch off old handle
1971 mnFocusIndex = SAL_MAX_SIZE;
1972 pOld->Touch();
1973 }
1974
1975 // allocate pointer array for sorted handle list
1976 std::unique_ptr<ImplHdlAndIndex[]> pHdlAndIndex(new ImplHdlAndIndex[aList.size()]);
1977
1978 // build sorted handle list
1979 for( size_t a = 0; a < aList.size(); ++a)
1980 {
1981 pHdlAndIndex[a].mpHdl = aList[a];
1982 pHdlAndIndex[a].mnIndex = a;
1983 }
1984
1985 qsort(pHdlAndIndex.get(), aList.size(), sizeof(ImplHdlAndIndex), ImplSortHdlFunc);
1986
1987 // look for old num in sorted array
1988 size_t nOldHdl(nOldHdlNum);
1989
1990 if(nOldHdlNum != SAL_MAX_SIZE)
1991 {
1992 for(size_t a = 0; a < aList.size(); ++a)
1993 {
1994 if(pHdlAndIndex[a].mpHdl == pOld)
1995 {
1996 nOldHdl = a;
1997 break;
1998 }
1999 }
2000 }
2001
2002 // build new HdlNum
2003 size_t nNewHdl(nOldHdl);
2004
2005 // do the focus travel
2006 if(bForward)
2007 {
2008 if(nOldHdl != SAL_MAX_SIZE)
2009 {
2010 if(nOldHdl == aList.size() - 1)
2011 {
2012 // end forward run
2013 nNewHdl = SAL_MAX_SIZE;
2014 }
2015 else
2016 {
2017 // simply the next handle
2018 nNewHdl++;
2019 }
2020 }
2021 else
2022 {
2023 // start forward run at first entry
2024 nNewHdl = 0;
2025 }
2026 }
2027 else
2028 {
2029 if(nOldHdl == SAL_MAX_SIZE)
2030 {
2031 // start backward run at last entry
2032 nNewHdl = aList.size() - 1;
2033
2034 }
2035 else
2036 {
2037 if(nOldHdl == 0)
2038 {
2039 // end backward run
2040 nNewHdl = SAL_MAX_SIZE;
2041 }
2042 else
2043 {
2044 // simply the previous handle
2045 nNewHdl--;
2046 }
2047 }
2048 }
2049
2050 // build new HdlNum
2051 sal_uIntPtr nNewHdlNum(nNewHdl);
2052
2053 // look for old num in sorted array
2054 if(nNewHdl != SAL_MAX_SIZE)
2055 {
2056 SdrHdl* pNew = pHdlAndIndex[nNewHdl].mpHdl;
2057
2058 for(size_t a = 0; a < aList.size(); ++a)
2059 {
2060 if(aList[a] == pNew)
2061 {
2062 nNewHdlNum = a;
2063 break;
2064 }
2065 }
2066 }
2067
2068 // take care of next handle
2069 if(nOldHdlNum != nNewHdlNum)
2070 {
2071 mnFocusIndex = nNewHdlNum;
2072 SdrHdl* pNew = GetHdl(mnFocusIndex);
2073
2074 if(pNew)
2075 {
2076 pNew->Touch();
2077 }
2078 }
2079 }
2080
2081 SdrHdl* SdrHdlList::GetFocusHdl() const
2082 {
2083 if(mnFocusIndex < GetHdlCount())
2084 return GetHdl(mnFocusIndex);
2085 else
2086 return nullptr;
2087 }
2088
2089 void SdrHdlList::SetFocusHdl(SdrHdl* pNew)
2090 {
2091 if(pNew)
2092 {
2093 SdrHdl* pActual = GetFocusHdl();
2094
2095 if(!pActual || pActual != pNew)
2096 {
2097 const size_t nNewHdlNum = GetHdlNum(pNew);
2098
2099 if(nNewHdlNum != SAL_MAX_SIZE)
2100 {
2101 mnFocusIndex = nNewHdlNum;
2102
2103 if(pActual)
2104 {
2105 pActual->Touch();
2106 }
2107
2108 if(pNew)
2109 {
2110 pNew->Touch();
2111 }
2112
2113 }
2114 }
2115 }
2116 }
2117
2118 void SdrHdlList::ResetFocusHdl()
2119 {
2120 SdrHdl* pHdl = GetFocusHdl();
2121
2122 mnFocusIndex = SAL_MAX_SIZE;
2123
2124 if(pHdl)
2125 {
2126 pHdl->Touch();
2127 }
2128 }
2129
2130
2131 SdrHdlList::SdrHdlList(SdrMarkView* pV)
2132 : mnFocusIndex(SAL_MAX_SIZE),
2133 pView(pV),
2134 aList()
2135 {
2136 nHdlSize = 3;
2137 bRotateShear = false;
2138 bMoveOutside = false;
2139 bDistortShear = false;
2140 }
2141
2142 SdrHdlList::~SdrHdlList()
2143 {
2144 Clear();
2145 }
2146
2147 void SdrHdlList::SetHdlSize(sal_uInt16 nSiz)
2148 {
2149 if(nHdlSize != nSiz)
2150 {
2151 // remember new value
2152 nHdlSize = nSiz;
2153
2154 // propagate change to IAOs
2155 for(size_t i=0; i<GetHdlCount(); ++i)
2156 {
2157 SdrHdl* pHdl = GetHdl(i);
2158 pHdl->Touch();
2159 }
2160 }
2161 }
2162
2163 void SdrHdlList::SetMoveOutside(bool bOn)
2164 {
2165 if(bMoveOutside != bOn)
2166 {
2167 // remember new value
2168 bMoveOutside = bOn;
2169
2170 // propagate change to IAOs
2171 for(size_t i=0; i<GetHdlCount(); ++i)
2172 {
2173 SdrHdl* pHdl = GetHdl(i);
2174 pHdl->Touch();
2175 }
2176 }
2177 }
2178
2179 void SdrHdlList::SetRotateShear(bool bOn)
2180 {
2181 bRotateShear = bOn;
2182 }
2183
2184 void SdrHdlList::SetDistortShear(bool bOn)
2185 {
2186 bDistortShear = bOn;
2187 }
2188
2189 SdrHdl* SdrHdlList::RemoveHdl(size_t nNum)
2190 {
2191 SdrHdl* pRetval = aList[nNum];
2192 aList.erase(aList.begin() + nNum);
2193
2194 return pRetval;
2195 }
2196
2197 void SdrHdlList::RemoveAllByKind(SdrHdlKind eKind)
2198 {
2199 for(std::deque<SdrHdl*>::iterator it = aList.begin(); it != aList.end(); )
2200 {
2201 SdrHdl* p = *it;
2202 if (p->GetKind() == eKind)
2203 {
2204 it = aList.erase( it );
2205 delete p;
2206 }
2207 else
2208 ++it;
2209 }
2210 }
2211
2212 void SdrHdlList::Clear()
2213 {
2214 for (size_t i=0; i<GetHdlCount(); ++i)
2215 {
2216 SdrHdl* pHdl=GetHdl(i);
2217 delete pHdl;
2218 }
2219 aList.clear();
2220
2221 bRotateShear=false;
2222 bDistortShear=false;
2223 }
2224
2225 void SdrHdlList::Sort()
2226 {
2227 // remember currently focused handle
2228 SdrHdl* pPrev = GetFocusHdl();
2229
2230 std::sort( aList.begin(), aList.end(), ImpSdrHdlListSorter );
2231
2232 // get now and compare
2233 SdrHdl* pNow = GetFocusHdl();
2234
2235 if(pPrev != pNow)
2236 {
2237
2238 if(pPrev)
2239 {
2240 pPrev->Touch();
2241 }
2242
2243 if(pNow)
2244 {
2245 pNow->Touch();
2246 }
2247 }
2248 }
2249
2250 size_t SdrHdlList::GetHdlNum(const SdrHdl* pHdl) const
2251 {
2252 if (pHdl==nullptr)
2253 return SAL_MAX_SIZE;
2254 std::deque<SdrHdl*>::const_iterator it = std::find( aList.begin(), aList.end(), pHdl);
2255 if( it == aList.end() )
2256 return SAL_MAX_SIZE;
2257 return it - aList.begin();
2258 }
2259
2260 void SdrHdlList::AddHdl(SdrHdl* pHdl)
2261 {
2262 if (pHdl!=nullptr)
2263 {
2264 aList.push_back(pHdl);
2265 pHdl->SetHdlList(this);
2266 }
2267 }
2268
2269 SdrHdl* SdrHdlList::IsHdlListHit(const Point& rPnt) const
2270 {
2271 SdrHdl* pRet=nullptr;
2272 const size_t nCount=GetHdlCount();
2273 size_t nNum=nCount;
2274 while (nNum>0 && pRet==nullptr)
2275 {
2276 nNum--;
2277 SdrHdl* pHdl=GetHdl(nNum);
2278 if (pHdl->IsHdlHit(rPnt))
2279 pRet=pHdl;
2280 }
2281 return pRet;
2282 }
2283
2284 SdrHdl* SdrHdlList::GetHdl(SdrHdlKind eKind1) const
2285 {
2286 SdrHdl* pRet=nullptr;
2287 for (size_t i=0; i<GetHdlCount() && pRet==nullptr; ++i)
2288 {
2289 SdrHdl* pHdl=GetHdl(i);
2290 if (pHdl->GetKind()==eKind1)
2291 pRet=pHdl;
2292 }
2293 return pRet;
2294 }
2295
2296 SdrCropHdl::SdrCropHdl(
2297 const Point& rPnt,
2298 SdrHdlKind eNewKind,
2299 double fShearX,
2300 double fRotation)
2301 : SdrHdl(rPnt, eNewKind),
2302 mfShearX(fShearX),
2303 mfRotation(fRotation)
2304 {
2305 }
2306
2307
2308 BitmapEx SdrCropHdl::GetBitmapForHandle( const BitmapEx& rBitmap, int nSize )
2309 {
2310 int nPixelSize = 0, nX = 0, nY = 0, nOffset = 0;
2311
2312 if( nSize <= 3 )
2313 {
2314 nPixelSize = 13;
2315 nOffset = 0;
2316 }
2317 else if( nSize <=4 )
2318 {
2319 nPixelSize = 17;
2320 nOffset = 39;
2321 }
2322 else
2323 {
2324 nPixelSize = 21;
2325 nOffset = 90;
2326 }
2327
2328 switch( eKind )
2329 {
2330 case SdrHdlKind::UpperLeft: nX = 0; nY = 0; break;
2331 case SdrHdlKind::Upper: nX = 1; nY = 0; break;
2332 case SdrHdlKind::UpperRight: nX = 2; nY = 0; break;
2333 case SdrHdlKind::Left: nX = 0; nY = 1; break;
2334 case SdrHdlKind::Right: nX = 2; nY = 1; break;
2335 case SdrHdlKind::LowerLeft: nX = 0; nY = 2; break;
2336 case SdrHdlKind::Lower: nX = 1; nY = 2; break;
2337 case SdrHdlKind::LowerRight: nX = 2; nY = 2; break;
2338 default: break;
2339 }
2340
2341 tools::Rectangle aSourceRect( Point( nX * nPixelSize + nOffset, nY * nPixelSize), Size(nPixelSize, nPixelSize) );
2342
2343 BitmapEx aRetval(rBitmap);
2344 aRetval.Crop(aSourceRect);
2345 return aRetval;
2346 }
2347
2348
2349 void SdrCropHdl::CreateB2dIAObject()
2350 {
2351 // first throw away old one
2352 GetRidOfIAObject();
2353
2354 SdrMarkView* pView = pHdlList ? pHdlList->GetView() : nullptr;
2355 SdrPageView* pPageView = pView ? pView->GetSdrPageView() : nullptr;
2356
2357 if( pPageView && !pView->areMarkHandlesHidden() )
2358 {
2359 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2360 int nHdlSize = pHdlList->GetHdlSize();
2361
2362 const BitmapEx aHandlesBitmap(SIP_SA_CROP_MARKERS);
2363 BitmapEx aBmpEx1( GetBitmapForHandle( aHandlesBitmap, nHdlSize ) );
2364
2365 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
2366 {
2367 const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);
2368
2369 if(rPageWindow.GetPaintWindow().OutputToWindow())
2370 {
2371 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
2372 if (xManager.is())
2373 {
2374 basegfx::B2DPoint aPosition(aPos.X(), aPos.Y());
2375
2376 sdr::overlay::OverlayObject* pOverlayObject = nullptr;
2377
2378 // animate focused handles
2379 if(IsFocusHdl() && (pHdlList->GetFocusHdl() == this))
2380 {
2381 if( nHdlSize >= 2 )
2382 nHdlSize = 1;
2383
2384 BitmapEx aBmpEx2( GetBitmapForHandle( aHandlesBitmap, nHdlSize + 1 ) );
2385
2386 const sal_uInt64 nBlinkTime = rStyleSettings.GetCursorBlinkTime();
2387
2388 pOverlayObject = new sdr::overlay::OverlayAnimatedBitmapEx(
2389 aPosition,
2390 aBmpEx1,
2391 aBmpEx2,
2392 nBlinkTime,
2393 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1) >> 1,
2394 (sal_uInt16)(aBmpEx1.GetSizePixel().Height() - 1) >> 1,
2395 (sal_uInt16)(aBmpEx2.GetSizePixel().Width() - 1) >> 1,
2396 (sal_uInt16)(aBmpEx2.GetSizePixel().Height() - 1) >> 1,
2397 mfShearX,
2398 mfRotation);
2399 }
2400 else
2401 {
2402 // create centered handle as default
2403 pOverlayObject = new sdr::overlay::OverlayBitmapEx(
2404 aPosition,
2405 aBmpEx1,
2406 (sal_uInt16)(aBmpEx1.GetSizePixel().Width() - 1) >> 1,
2407 (sal_uInt16)(aBmpEx1.GetSizePixel().Height() - 1) >> 1,
2408 0.0,
2409 mfShearX,
2410 mfRotation);
2411 }
2412
2413 // OVERLAYMANAGER
2414 if(pOverlayObject)
2415 {
2416 xManager->add(*pOverlayObject);
2417 maOverlayGroup.append(pOverlayObject);
2418 }
2419 }
2420 }
2421 }
2422 }
2423 }
2424
2425
2426 // with the correction of crop handling I could get rid of the extra mirroring flag, adapted stuff
2427 // accordingly
2428
2429 SdrCropViewHdl::SdrCropViewHdl(
2430 const basegfx::B2DHomMatrix& rObjectTransform,
2431 const Graphic& rGraphic,
2432 double fCropLeft,
2433 double fCropTop,
2434 double fCropRight,
2435 double fCropBottom)
2436 : SdrHdl(Point(), SdrHdlKind::User),
2437 maObjectTransform(rObjectTransform),
2438 maGraphic(rGraphic),
2439 mfCropLeft(fCropLeft),
2440 mfCropTop(fCropTop),
2441 mfCropRight(fCropRight),
2442 mfCropBottom(fCropBottom)
2443 {
2444 }
2445
2446 namespace {
2447
2448 void translateRotationToMirroring(basegfx::B2DVector & scale, double * rotate) {
2449 assert(rotate != nullptr);
2450
2451 // detect 180 degree rotation, this is the same as mirrored in X and Y,
2452 // thus change to mirroring. Prefer mirroring here. Use the equal call
2453 // with getSmallValue here, the original which uses rtl::math::approxEqual
2454 // is too correct here. Maybe this changes with enhanced precision in aw080
2455 // to the better so that this can be reduced to the more precise call again
2456 if(basegfx::fTools::equal(fabs(*rotate), F_PI, 0.000000001))
2457 {
2458 scale.setX(scale.getX() * -1.0);
2459 scale.setY(scale.getY() * -1.0);
2460 *rotate = 0.0;
2461 }
2462 }
2463
2464 }
2465
2466 void SdrCropViewHdl::CreateB2dIAObject()
2467 {
2468 GetRidOfIAObject();
2469 SdrMarkView* pView = pHdlList ? pHdlList->GetView() : nullptr;
2470 SdrPageView* pPageView = pView ? pView->GetSdrPageView() : nullptr;
2471
2472 if(!pPageView || pView->areMarkHandlesHidden())
2473 {
2474 return;
2475 }
2476
2477 // decompose to have current translate and scale
2478 basegfx::B2DVector aScale, aTranslate;
2479 double fRotate, fShearX;
2480
2481 maObjectTransform.decompose(aScale, aTranslate, fRotate, fShearX);
2482
2483 if(aScale.equalZero())
2484 {
2485 return;
2486 }
2487
2488 translateRotationToMirroring(aScale, &fRotate);
2489
2490 // remember mirroring, reset at Scale and adapt crop values for usage;
2491 // mirroring can stay in the object transformation, so do not have to
2492 // cope with it here (except later for the CroppedImage transformation,
2493 // see below)
2494 const bool bMirroredX(aScale.getX() < 0.0);
2495 const bool bMirroredY(aScale.getY() < 0.0);
2496 double fCropLeft(mfCropLeft);
2497 double fCropTop(mfCropTop);
2498 double fCropRight(mfCropRight);
2499 double fCropBottom(mfCropBottom);
2500
2501 if(bMirroredX)
2502 {
2503 aScale.setX(-aScale.getX());
2504 }
2505
2506 if(bMirroredY)
2507 {
2508 aScale.setY(-aScale.getY());
2509 }
2510
2511 // create target translate and scale
2512 const basegfx::B2DVector aTargetScale(
2513 aScale.getX() + fCropRight + fCropLeft,
2514 aScale.getY() + fCropBottom + fCropTop);
2515 const basegfx::B2DVector aTargetTranslate(
2516 aTranslate.getX() - fCropLeft,
2517 aTranslate.getY() - fCropTop);
2518
2519 // create ranges to make comparisons
2520 const basegfx::B2DRange aCurrentForCompare(
2521 aTranslate.getX(), aTranslate.getY(),
2522 aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY());
2523 basegfx::B2DRange aCropped(
2524 aTargetTranslate.getX(), aTargetTranslate.getY(),
2525 aTargetTranslate.getX() + aTargetScale.getX(), aTargetTranslate.getY() + aTargetScale.getY());
2526
2527 if(aCropped.isEmpty())
2528 {
2529 // nothing to return since cropped content is completely empty
2530 return;
2531 }
2532
2533 if(aCurrentForCompare.equal(aCropped))
2534 {
2535 // no crop at all
2536 return;
2537 }
2538
2539 // back-transform to have values in unit coordinates
2540 basegfx::B2DHomMatrix aBackToUnit;
2541 aBackToUnit.translate(-aTranslate.getX(), -aTranslate.getY());
2542 aBackToUnit.scale(
2543 basegfx::fTools::equalZero(aScale.getX()) ? 1.0 : 1.0 / aScale.getX(),
2544 basegfx::fTools::equalZero(aScale.getY()) ? 1.0 : 1.0 / aScale.getY());
2545
2546 // transform cropped back to unit coordinates
2547 aCropped.transform(aBackToUnit);
2548
2549 // prepare crop PolyPolygon
2550 basegfx::B2DPolygon aGraphicOutlinePolygon(
2551 basegfx::utils::createPolygonFromRect(
2552 aCropped));
2553 basegfx::B2DPolyPolygon aCropPolyPolygon(aGraphicOutlinePolygon);
2554
2555 // current range is unit range
2556 basegfx::B2DRange aOverlap(0.0, 0.0, 1.0, 1.0);
2557
2558 aOverlap.intersect(aCropped);
2559
2560 if(!aOverlap.isEmpty())
2561 {
2562 aCropPolyPolygon.append(
2563 basegfx::utils::createPolygonFromRect(
2564 aOverlap));
2565 }
2566
2567 // transform to object coordinates to prepare for clip
2568 aCropPolyPolygon.transform(maObjectTransform);
2569 aGraphicOutlinePolygon.transform(maObjectTransform);
2570
2571 // create cropped transformation
2572 basegfx::B2DHomMatrix aCroppedTransform;
2573
2574 aCroppedTransform.scale(
2575 aCropped.getWidth(),
2576 aCropped.getHeight());
2577 aCroppedTransform.translate(
2578 aCropped.getMinX(),
2579 aCropped.getMinY());
2580 aCroppedTransform = maObjectTransform * aCroppedTransform;
2581
2582 // prepare graphic primitive (transformed)
2583 const drawinglayer::primitive2d::Primitive2DReference aGraphic(
2584 new drawinglayer::primitive2d::GraphicPrimitive2D(
2585 aCroppedTransform,
2586 maGraphic));
2587
2588 // prepare outline polygon for whole graphic
2589 const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
2590 const basegfx::BColor aHilightColor(aSvtOptionsDrawinglayer.getHilightColor().getBColor());
2591 const drawinglayer::primitive2d::Primitive2DReference aGraphicOutline(
2592 new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
2593 aGraphicOutlinePolygon,
2594 aHilightColor));
2595
2596 // combine these
2597 drawinglayer::primitive2d::Primitive2DContainer aCombination(2);
2598 aCombination[0] = aGraphic;
2599 aCombination[1] = aGraphicOutline;
2600
2601 // embed to MaskPrimitive2D
2602 const drawinglayer::primitive2d::Primitive2DReference aMaskedGraphic(
2603 new drawinglayer::primitive2d::MaskPrimitive2D(
2604 aCropPolyPolygon,
2605 aCombination));
2606
2607 // embed to UnifiedTransparencePrimitive2D
2608 const drawinglayer::primitive2d::Primitive2DReference aTransparenceMaskedGraphic(
2609 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
2610 drawinglayer::primitive2d::Primitive2DContainer { aMaskedGraphic },
2611 0.8));
2612
2613 const drawinglayer::primitive2d::Primitive2DContainer aSequence { aTransparenceMaskedGraphic };
2614
2615 for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)
2616 {
2617 // const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b];
2618 const SdrPageWindow& rPageWindow = *(pPageView->GetPageWindow(b));
2619
2620 if(rPageWindow.GetPaintWindow().OutputToWindow())
2621 {
2622 rtl::Reference< sdr::overlay::OverlayManager > xManager = rPageWindow.GetOverlayManager();
2623 if(xManager.is())
2624 {
2625 sdr::overlay::OverlayObject* pNew = new sdr::overlay::OverlayPrimitive2DSequenceObject(aSequence);
2626
2627 // only informative object, no hit
2628 pNew->setHittable(false);
2629
2630 xManager->add(*pNew);
2631 maOverlayGroup.append(pNew);
2632 }
2633 }
2634 }
2635 }
2636
2637 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE