LCOV - code coverage report
Current view: top level - include/svx - svdhdl.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 47 0.0 %
Date: 2014-04-14 Functions: 0 51 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #ifndef INCLUDED_SVX_SVDHDL_HXX
      21             : #define INCLUDED_SVX_SVDHDL_HXX
      22             : 
      23             : #include <tools/gen.hxx>
      24             : 
      25             : #include <vcl/pointr.hxx>
      26             : 
      27             : #include <svl/solar.hrc>
      28             : 
      29             : #include <svx/xpoly.hxx>
      30             : #include <svx/svdoedge.hxx>
      31             : #include <basegfx/matrix/b2dhommatrix.hxx>
      32             : #include <svx/sdgcpitm.hxx>
      33             : #include <svx/sdr/overlay/overlayobjectlist.hxx>
      34             : #include <svx/svxdllapi.h>
      35             : 
      36             : class VirtualDevice;
      37             : class OutputDevice;
      38             : class Region;
      39             : class Window;
      40             : class SdrHdlList;
      41             : class SdrMarkView;
      42             : class SdrObject;
      43             : class SdrPageView;
      44             : class MouseEvent;
      45             : 
      46             : 
      47             : 
      48             : // Jedes Objekt muss in der Lage seine Handles zu erzeugen. Diese werden dann
      49             : // bei einer Selektion abgeholt, bei der View angemeldet und sichtbar gemacht.
      50             : // Wird ein Handle von der Maus beruehrt (IsHit()), so wird von der View der
      51             : // entsprechende Mauszeiger vom Handle abgeholt und der App auf Anfrage zum
      52             : // reinschalten uebergeben.
      53             : // Handles wie z.B. der Rotationsmittelpunkt oder die Spiegelachse werden von
      54             : // der View generiert, wenn vom Controller der entsprechende Transformations-
      55             : // Modus selektiert wird.
      56             : // HDL_MOVE...HDL_LWRGT muessen im enum immer zusammen stehen bleiben!
      57             : 
      58             : enum SdrHdlKind
      59             : {
      60             :     HDL_MOVE,       // Handle zum Verschieben des Objekts
      61             :     HDL_UPLFT,      // Oben links
      62             :     HDL_UPPER,      // Oben
      63             :     HDL_UPRGT,      // Oben rechts
      64             :     HDL_LEFT,       // Links
      65             :     HDL_RIGHT,      // Rechts
      66             :     HDL_LWLFT,      // Unten links
      67             :     HDL_LOWER,      // Unten
      68             :     HDL_LWRGT,      // Unten rechts
      69             :     HDL_POLY,       // Punktselektion an Polygon oder Bezierkurve
      70             :     HDL_BWGT,       // Gewicht an einer Bezierkurve
      71             :     HDL_CIRC,       // Winkel an Kreissegmenten, Eckenradius am Rect
      72             :     HDL_REF1,       // Referenzpunkt 1, z.B. Rotationsmitte
      73             :     HDL_REF2,       // Referenzpunkt 2, z.B. Endpunkt der Spiegelachse
      74             :     HDL_MIRX,       // Die Spiegelachse selbst
      75             :     HDL_GLUE,       // GluePoint
      76             :     HDL_GLUE_DESELECTED,       // GluePoint
      77             :     HDL_ANCHOR,     // anchor symbol (SD, SW)
      78             :     HDL_TRNS,       // interactive transparence
      79             :     HDL_GRAD,       // interactive gradient
      80             :     HDL_COLR,       // interactive color
      81             :     HDL_USER,
      82             :     HDL_ANCHOR_TR,  // #101688# Anchor handle with (0,0) at top right for SW
      83             : 
      84             :     // for SJ and the CustomShapeHandles:
      85             :     HDL_CUSTOMSHAPE1,
      86             : 
      87             :     HDL_SMARTTAG
      88             : };
      89             : 
      90             : 
      91             : 
      92             : enum BitmapColorIndex
      93             : {
      94             :     LightGreen,
      95             :     Cyan,
      96             :     LightCyan,
      97             :     Red,
      98             :     LightRed,
      99             :     Yellow
     100             : };
     101             : 
     102             : 
     103             : 
     104             : enum BitmapMarkerKind
     105             : {
     106             :     Rect_7x7,
     107             :     Rect_9x9,
     108             :     Rect_11x11,
     109             :     Rect_13x13,
     110             :     Circ_7x7,
     111             :     Circ_9x9,
     112             :     Circ_11x11,
     113             :     Elli_7x9,
     114             :     Elli_9x11,
     115             :     Elli_9x7,
     116             :     Elli_11x9,
     117             :     RectPlus_7x7,
     118             :     RectPlus_9x9,
     119             :     RectPlus_11x11,
     120             :     Crosshair,
     121             :     Glue,
     122             :     Glue_Deselected,
     123             :     Anchor,
     124             : 
     125             :     // #98388# add AnchorPressed to be able to aninate anchor control, too.
     126             :     AnchorPressed,
     127             : 
     128             :     // #101688# AnchorTR for SW
     129             :     AnchorTR,
     130             :     AnchorPressedTR,
     131             : 
     132             :     // for SJ and the CustomShapeHandles:
     133             :     Customshape_7x7,
     134             :     Customshape_9x9,
     135             :     Customshape_11x11
     136             : };
     137             : 
     138             : 
     139             : 
     140             : class SVX_DLLPUBLIC SdrHdl
     141             : {
     142             :     friend class                SdrMarkView; // fuer den Zugriff auf nObjHdlNum
     143             :     friend class                SdrHdlList;
     144             : 
     145             :     static BitmapEx ImpGetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd);
     146             : 
     147             : protected:
     148             :     SdrObject*                  pObj;      // Gehoert das Handle zu einem Objekt?
     149             :     SdrPageView*                pPV;       // Gehoert das Handle zu einem Objekt in einer bestimmten PageView?
     150             :     SdrHdlList*                 pHdlList;  // Zum Feststelen der Handlegroesse
     151             : 
     152             :     // OVERLAYMANAGER
     153             :     ::sdr::overlay::OverlayObjectList           maOverlayGroup;
     154             : 
     155             :     Point                       aPos;
     156             : 
     157             :     SdrHdlKind                  eKind;
     158             : 
     159             :     long                        nDrehWink; // Handles bzw. Mauszeiger drehen
     160             :     sal_uInt32                  nObjHdlNum; // wird von der MarkView benoetigt
     161             :     sal_uInt32                  nPolyNum;  // Polygonpunktes
     162             :     sal_uInt32                  nPPntNum;  // Punktnummer des Polygons
     163             :     sal_uInt32                  nSourceHdlNum; // ist noch vollstaendig zu implementieren
     164             : 
     165             :     bool                        bSelect : 1;   // Ein selektierter Polygonpunkt?
     166             :     bool                        b1PixMore : 1; // True=Handle wird 1 Pixel groesser dargestellt
     167             :     bool                        bPlusHdl : 1;  // u.a. fuer Hld-Paint Optimierung bei MarkPoint/UnmarkPoint, ...
     168             : 
     169             :     bool                        mbMoveOutside; // forces this handle to be moved outside of the selection rectangle
     170             : 
     171             :     // create marker for this kind
     172             :     virtual void CreateB2dIAObject();
     173             : 
     174             :     // cleanup marker if one exists
     175             :     void GetRidOfIAObject();
     176             : 
     177             : private:
     178             :     bool                        mbMouseOver;    // is true if the mouse is over this handle
     179             : 
     180             : protected:
     181             :     ::sdr::overlay::OverlayObject* CreateOverlayObject(
     182             :         const basegfx::B2DPoint& rPos,
     183             :         BitmapColorIndex eColIndex, BitmapMarkerKind eKindOfMarker, Point aMoveOutsideOffset = Point());
     184             :     BitmapMarkerKind GetNextBigger(BitmapMarkerKind eKnd) const;
     185             : 
     186             : public:
     187             :     SdrHdl();
     188             :     explicit SdrHdl(const Point& rPnt, SdrHdlKind eNewKind=HDL_MOVE);
     189             :     virtual ~SdrHdl();
     190             : 
     191           0 :     const ::sdr::overlay::OverlayObjectList& getOverlayObjectList() const { return maOverlayGroup; }
     192             : 
     193             :     void SetHdlList(SdrHdlList* pList);
     194           0 :     SdrHdlKind GetKind() const { return eKind; }
     195             :     void Touch();
     196             : 
     197           0 :     const Point& GetPos() const { return aPos; }
     198             :     void SetPos(const Point& rPnt);
     199             : 
     200           0 :     SdrPageView* GetPageView() const { return pPV; }
     201           0 :     void SetPageView(SdrPageView* pNewPV) { pPV=pNewPV; }
     202             : 
     203           0 :     SdrObject* GetObj() const { return pObj;  }
     204             :     void SetObj(SdrObject* pNewObj);
     205             : 
     206           0 :     bool IsSelected() const { return bSelect; }
     207             :     void SetSelected(bool bJa=true);
     208             : 
     209             :     void Set1PixMore(bool bJa=true);
     210             :     void SetDrehWink(long n);
     211             : 
     212           0 :     bool IsCornerHdl() const { return eKind==HDL_UPLFT || eKind==HDL_UPRGT || eKind==HDL_LWLFT || eKind==HDL_LWRGT; }
     213           0 :     bool IsVertexHdl() const { return eKind==HDL_UPPER || eKind==HDL_LOWER || eKind==HDL_LEFT  || eKind==HDL_RIGHT; }
     214             : 
     215           0 :     void SetObjHdlNum(sal_uInt32 nNum) { nObjHdlNum=nNum; }
     216           0 :     sal_uInt32 GetObjHdlNum() const { return nObjHdlNum; }
     217             : 
     218           0 :     void SetPolyNum(sal_uInt32 nNum) { nPolyNum=nNum; }
     219           0 :     sal_uInt32 GetPolyNum() const { return nPolyNum; }
     220             : 
     221           0 :     void SetPointNum(sal_uInt32 nNum) { nPPntNum=nNum; }
     222           0 :     sal_uInt32 GetPointNum() const { return nPPntNum; }
     223             : 
     224           0 :     void SetPlusHdl(bool bOn) { bPlusHdl=bOn; }
     225           0 :     bool IsPlusHdl() const { return bPlusHdl; }
     226             : 
     227           0 :     void SetSourceHdlNum(sal_uInt32 nNum) { nSourceHdlNum=nNum; }
     228           0 :     sal_uInt32 GetSourceHdlNum() const { return nSourceHdlNum; }
     229             : 
     230             :     virtual Pointer GetPointer() const;
     231             :     bool IsHdlHit(const Point& rPnt) const;
     232             : 
     233             :     // #97016# II
     234             :     virtual bool IsFocusHdl() const;
     235             : 
     236             :     void SetMoveOutside( bool bMoveOutside );
     237             : 
     238             :     /** is called when the mouse enters the area of this handle. If the handle changes his
     239             :         visualisation during mouse over it must override this method and call Touch(). */
     240             :     virtual void onMouseEnter(const MouseEvent& rMEvt);
     241             : 
     242             :     /** is called when the mouse leaves the area of this handle. If the handle changes his
     243             :         visualisation during mouse over it must override this method and call Touch(). */
     244             :     virtual void onMouseLeave();
     245             : 
     246           0 :     static BitmapEx createGluePointBitmap() { return ImpGetBitmapEx(Glue_Deselected, 0); }
     247             : };
     248             : 
     249             : 
     250             : 
     251             : #define SDR_HANDLE_COLOR_SIZE_NORMAL            Size(13, 13)
     252             : #define SDR_HANDLE_COLOR_SIZE_SELECTED          Size(17, 17)
     253             : 
     254             : class SVX_DLLPUBLIC SdrHdlColor : public SdrHdl
     255             : {
     256             : private:
     257             :     // size of colr markers
     258             :     Size                        aMarkerSize;
     259             : 
     260             :     // color
     261             :     Color                       aMarkerColor;
     262             : 
     263             :     // callback link when value changed
     264             :     Link                        aColorChangeHdl;
     265             : 
     266             :     // use luminance values only
     267             :     bool                        bUseLuminance : 1;
     268             : 
     269             :     // create marker for this kind
     270             :     SVX_DLLPRIVATE virtual void CreateB2dIAObject() SAL_OVERRIDE;
     271             : 
     272             :     // help functions
     273             :     SVX_DLLPRIVATE Bitmap CreateColorDropper(Color aCol);
     274             :     SVX_DLLPRIVATE Color GetLuminance(const Color& rCol);
     275             :     SVX_DLLPRIVATE void CallColorChangeLink();
     276             : 
     277             : public:
     278             :     explicit SdrHdlColor(const Point& rRef, Color aCol = Color(COL_BLACK), const Size& rSize = Size(11, 11), bool bLum = false);
     279             :     virtual ~SdrHdlColor();
     280             : 
     281           0 :     bool IsUseLuminance() const { return bUseLuminance; }
     282             : 
     283           0 :     Color GetColor() const { return aMarkerColor; }
     284             :     void SetColor(Color aNew, bool bCallLink = false);
     285             : 
     286             :     const Size& GetSize() const { return aMarkerSize; }
     287             :     void SetSize(const Size& rNew);
     288             : 
     289           0 :     void SetColorChangeHdl(const Link& rLink) { aColorChangeHdl = rLink; }
     290             :     const Link& GetColorChangeHdl() const { return aColorChangeHdl; }
     291             : };
     292             : 
     293             : 
     294             : 
     295             : class SdrHdlGradient : public SdrHdl
     296             : {
     297             : private:
     298             :     // pointer to used color handles
     299             :     SdrHdlColor*                pColHdl1;
     300             :     SdrHdlColor*                pColHdl2;
     301             : 
     302             :     // 2nd position
     303             :     Point                       a2ndPos;
     304             : 
     305             :     // is this a gradient or a transparence
     306             :     bool                        bGradient : 1;
     307             : 
     308             :     // select which handle to move
     309             :     bool                        bMoveSingleHandle : 1;
     310             :     bool                        bMoveFirstHandle : 1;
     311             : 
     312             :     // create marker for this kind
     313             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     314             : 
     315             : public:
     316             :     SdrHdlGradient(const Point& rRef1, const Point& rRef2, bool bGrad = true);
     317             :     virtual ~SdrHdlGradient();
     318             : 
     319           0 :     bool IsGradient() const { return bGradient; }
     320             : 
     321             :     // set the associated color handles
     322           0 :     void SetColorHandles(SdrHdlColor* pL1, SdrHdlColor* pL2) { pColHdl1 = pL1; pColHdl2 = pL2; }
     323           0 :     SdrHdlColor* GetColorHdl1() const { return pColHdl1; }
     324           0 :     SdrHdlColor* GetColorHdl2() const { return pColHdl2; }
     325             : 
     326           0 :     const Point& Get2ndPos() const { return a2ndPos; }
     327             :     void Set2ndPos(const Point& rPnt);
     328             : 
     329             :     // the link called by the color handles
     330             :     DECL_LINK(ColorChangeHdl, SdrHdl*);
     331             : 
     332             :     // transformation call, create gradient from this handle
     333             :     void FromIAOToItem(SdrObject* pObj, bool bSetItemOnObject, bool bUndo);
     334             : 
     335             :     // selection flags for interaction
     336           0 :     bool IsMoveSingleHandle() const { return bMoveSingleHandle; }
     337           0 :     void SetMoveSingleHandle(bool bNew) { bMoveSingleHandle = bNew; }
     338           0 :     bool IsMoveFirstHandle() const { return bMoveFirstHandle; }
     339           0 :     void SetMoveFirstHandle(bool bNew) { bMoveFirstHandle = bNew; }
     340             : };
     341             : 
     342             : 
     343             : 
     344             : // Spiegelachse
     345             : class SdrHdlLine: public SdrHdl
     346             : {
     347             :     // create marker for this kind
     348             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     349             : 
     350             : protected:
     351             :     SdrHdl*                     pHdl1;
     352             :     SdrHdl*                     pHdl2;
     353             : 
     354             : public:
     355           0 :     SdrHdlLine(SdrHdl& rHdl1, SdrHdl& rHdl2, SdrHdlKind eNewKind=HDL_MIRX) { eKind=eNewKind; pHdl1=&rHdl1; pHdl2=&rHdl2; }
     356             :     virtual ~SdrHdlLine();
     357             : 
     358             :     virtual Pointer GetPointer() const SAL_OVERRIDE;
     359             : };
     360             : 
     361             : // Ein SdrHdlBezWgt hat Kenntnis von seinem "BasisHandle". Seine Draw-Methode
     362             : // zeichnet zusaetzlich eine Linie von seiner Position zur Position dieses
     363             : // BasisHandles.
     364             : class SdrHdlBezWgt: public SdrHdl
     365             : {
     366             :     // create marker for this kind
     367             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     368             : 
     369             : protected:
     370             :     const SdrHdl* pHdl1;
     371             : 
     372             : public:
     373             :     // das ist kein Copy-Ctor!!!
     374           0 :     SdrHdlBezWgt(const SdrHdl* pRefHdl1, SdrHdlKind eNewKind=HDL_BWGT) { eKind=eNewKind; pHdl1=pRefHdl1; }
     375             :     virtual ~SdrHdlBezWgt();
     376             : };
     377             : 
     378             : 
     379             : 
     380           0 : class E3dVolumeMarker : public SdrHdl
     381             : {
     382             :     basegfx::B2DPolyPolygon             aWireframePoly;
     383             : 
     384             :     // create marker for this kind
     385             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     386             : 
     387             : public:
     388             :     explicit E3dVolumeMarker(const basegfx::B2DPolyPolygon& rWireframePoly);
     389             : };
     390             : 
     391             : 
     392             : 
     393             : class ImpEdgeHdl: public SdrHdl
     394             : {
     395             :     SdrEdgeLineCode eLineCode;
     396             : 
     397             :     // create marker for this kind
     398             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     399             : 
     400             : public:
     401           0 :     ImpEdgeHdl(const Point& rPnt, SdrHdlKind eNewKind): SdrHdl(rPnt,eNewKind),eLineCode(MIDDLELINE) {}
     402             :     virtual ~ImpEdgeHdl();
     403             : 
     404             :     void SetLineCode(SdrEdgeLineCode eCode);
     405           0 :     SdrEdgeLineCode GetLineCode() const     { return eLineCode; }
     406             :     bool IsHorzDrag() const;
     407             :     virtual Pointer GetPointer() const SAL_OVERRIDE;
     408             : };
     409             : 
     410             : 
     411             : 
     412             : class ImpMeasureHdl: public SdrHdl
     413             : {
     414             :     // create marker for this kind
     415             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     416             : 
     417             : public:
     418           0 :     ImpMeasureHdl(const Point& rPnt, SdrHdlKind eNewKind): SdrHdl(rPnt,eNewKind) {}
     419             :     virtual ~ImpMeasureHdl();
     420             : 
     421             :     virtual Pointer GetPointer() const SAL_OVERRIDE;
     422             : };
     423             : 
     424             : 
     425             : 
     426           0 : class ImpTextframeHdl: public SdrHdl
     427             : {
     428             :     const Rectangle maRect;
     429             : 
     430             :     // create marker for this kind
     431             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     432             : 
     433             : public:
     434             :     explicit ImpTextframeHdl(const Rectangle& rRect);
     435             : };
     436             : 
     437             : 
     438             : 
     439             : 
     440             : 
     441             : class SVX_DLLPUBLIC SdrHdlList
     442             : {
     443             : protected:
     444             :     sal_uIntPtr                 mnFocusIndex;
     445             :     SdrMarkView*                pView;
     446             :     std::deque<SdrHdl*>         aList;
     447             :     sal_uInt16                  nHdlSize;
     448             : 
     449             :     bool                        bRotateShear : 1;
     450             :     bool                        bDistortShear : 1;
     451             :     bool                        bMoveOutside : 1;      // Handles nach aussen ruecken (fuer TextEdit)
     452             : 
     453             : private:
     454             :     SVX_DLLPRIVATE SdrHdlList(const SdrHdlList&): aList()  {}
     455             :     SVX_DLLPRIVATE void operator=(const SdrHdlList&)                 {}
     456             :     SVX_DLLPRIVATE bool operator==(const SdrHdlList&) const      { return false; }
     457             :     SVX_DLLPRIVATE bool operator!=(const SdrHdlList&) const      { return false; }
     458             : 
     459             : public:
     460             :     explicit SdrHdlList(SdrMarkView* pV);
     461             :     ~SdrHdlList();
     462             :     void Clear();
     463             : 
     464             :     // #97016# II
     465             :     void TravelFocusHdl(bool bForward);
     466             :     SdrHdl* GetFocusHdl() const;
     467             :     void SetFocusHdl(SdrHdl* pNew);
     468             :     void ResetFocusHdl();
     469             : 
     470             :     // Access to View
     471             :     SdrMarkView* GetView() const;
     472             : 
     473             :     // Sortierung: 1.Level Erst Refpunkt-Handles, dann normale Handles, dann Glue, dann User, dann Plushandles
     474             :     //             2.Level PageView (Pointer)
     475             :     //             3.Level Position (x+y)
     476             :     void     Sort();
     477           0 :     sal_uIntPtr    GetHdlCount() const                       { return aList.size(); }
     478           0 :     SdrHdl*  GetHdl(sal_uIntPtr nNum) const                  { return nNum != CONTAINER_ENTRY_NOTFOUND ? aList[nNum] : NULL; }
     479             :     sal_uIntPtr    GetHdlNum(const SdrHdl* pHdl) const;
     480             :     void     SetHdlSize(sal_uInt16 nSiz);
     481           0 :     sal_uInt16   GetHdlSize() const                        { return nHdlSize; }
     482             :     void     SetMoveOutside(bool bOn);
     483           0 :     bool IsMoveOutside() const                     { return bMoveOutside; }
     484             :     void     SetRotateShear(bool bOn);
     485           0 :     bool IsRotateShear() const                     { return bRotateShear; }
     486             :     void     SetDistortShear(bool bOn);
     487           0 :     bool IsDistortShear() const                    { return bDistortShear; }
     488             : 
     489             :     // AddHdl uebernimmt das Handle in sein Eigentum. Es muss
     490             :     // also auf dem Heap stehen, da Clear() ein delete macht.
     491             :     void    AddHdl(SdrHdl* pHdl, bool bAtBegin=false);
     492             :     SdrHdl* RemoveHdl(sal_uIntPtr nNum);
     493             :     void RemoveAllByKind(SdrHdlKind eKind);
     494             : 
     495             :     // Zuletzt eingefuegte Handles werden am ehesten getroffen
     496             :     // (wenn Handles uebereinander liegen).
     497             :     SdrHdl* IsHdlListHit(const Point& rPnt, bool bBack=false, bool bNext=false, SdrHdl* pHdl0=NULL) const;
     498             :     SdrHdl* GetHdl(SdrHdlKind eKind1) const;
     499             : };
     500             : 
     501             : 
     502             : 
     503           0 : class SVX_DLLPUBLIC SdrCropHdl : public SdrHdl
     504             : {
     505             : private:
     506             :     // evtl. shear and rotation, equal to the object's one to allow adaption of
     507             :     // the visualization handles
     508             :     double          mfShearX;
     509             :     double          mfRotation;
     510             : 
     511             : public:
     512             :     SdrCropHdl(
     513             :         const Point& rPnt,
     514             :         SdrHdlKind eNewKind,
     515             :         double fShearX,
     516             :         double fRotation);
     517             : 
     518             : protected:
     519             :     // create marker for this kind
     520             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     521             : 
     522             :     BitmapEx GetBitmapForHandle( const BitmapEx& rBitmap, int nSize );
     523             : 
     524             :     static BitmapEx GetHandlesBitmap();
     525             : };
     526             : 
     527             : 
     528             : 
     529           0 : class SVX_DLLPUBLIC SdrCropViewHdl : public SdrHdl
     530             : {
     531             : private:
     532             :     basegfx::B2DHomMatrix       maObjectTransform;
     533             :     Graphic                     maGraphic;
     534             :     double                      mfCropLeft;
     535             :     double                      mfCropTop;
     536             :     double                      mfCropRight;
     537             :     double                      mfCropBottom;
     538             : 
     539             : public:
     540             :     SdrCropViewHdl(
     541             :         const basegfx::B2DHomMatrix& rObjectTransform,
     542             :         const Graphic& rGraphic,
     543             :         double fCropLeft,
     544             :         double fCropTop,
     545             :         double fCropRight,
     546             :         double fCropBottom);
     547             : 
     548             : protected:
     549             :     // create marker for this kind
     550             :     virtual void CreateB2dIAObject() SAL_OVERRIDE;
     551             : };
     552             : 
     553             : 
     554             : 
     555             : #endif // INCLUDED_SVX_SVDHDL_HXX
     556             : 
     557             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10