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