svx/source/svdraw/svdhdl.cxx

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