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