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