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