| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _SVDHDL_HXX |
| #define _SVDHDL_HXX |
| |
| #include <tools/gen.hxx> |
| |
| #ifndef _POINTR_HXX //autogen |
| #include <vcl/pointr.hxx> |
| #endif |
| #include <tools/contnr.hxx> |
| |
| #ifndef _SOLAR_HRC |
| #include <svl/solar.hrc> |
| #endif |
| |
| #include <svx/xpoly.hxx> |
| #include <svx/svdoedge.hxx> |
| #include <svx/sdr/overlay/overlayobjectlist.hxx> |
| #include "svx/svxdllapi.h" |
| |
| #include <svx/xpoly.hxx> |
| #include <svx/svdoedge.hxx> |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <svx/sdgcpitm.hxx> |
| |
| class VirtualDevice; |
| class OutputDevice; |
| class Region; |
| class Window; |
| class SdrHdlList; |
| class SdrMarkView; |
| class SdrObject; |
| class SdrPageView; |
| class MouseEvent; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // Jedes Objekt muss in der Lage seine Handles zu erzeugen. Diese werden dann |
| // bei einer Selektion abgeholt, bei der View angemeldet und sichtbar gemacht. |
| // Wird ein Handle von der Maus beruehrt (IsHit()), so wird von der View der |
| // entsprechende Mauszeiger vom Handle abgeholt und der App auf Anfrage zum |
| // reinschalten uebergeben. |
| // Handles wie z.B. der Rotationsmittelpunkt oder die Spiegelachse werden von |
| // der View generiert, wenn vom Controller der entsprechende Transformations- |
| // Modus selektiert wird. |
| // HDL_MOVE...HDL_LWRGT muessen im enum immer zusammen stehen bleiben! |
| |
| enum SdrHdlKind |
| { |
| HDL_MOVE, // Handle zum Verschieben des Objekts |
| HDL_UPLFT, // Oben links |
| HDL_UPPER, // Oben |
| HDL_UPRGT, // Oben rechts |
| HDL_LEFT, // Links |
| HDL_RIGHT, // Rechts |
| HDL_LWLFT, // Unten links |
| HDL_LOWER, // Unten |
| HDL_LWRGT, // Unten rechts |
| HDL_POLY, // Punktselektion an Polygon oder Bezierkurve |
| HDL_BWGT, // Gewicht an einer Bezierkurve |
| HDL_CIRC, // Winkel an Kreissegmenten, Eckenradius am Rect |
| HDL_REF1, // Referenzpunkt 1, z.B. Rotationsmitte |
| HDL_REF2, // Referenzpunkt 2, z.B. Endpunkt der Spiegelachse |
| HDL_MIRX, // Die Spiegelachse selbst |
| HDL_GLUE, // GluePoint |
| HDL_ANCHOR, // anchor symbol (SD, SW) |
| HDL_TRNS, // interactive transparence |
| HDL_GRAD, // interactive gradient |
| HDL_COLR, // interactive color |
| HDL_USER, |
| HDL_ANCHOR_TR, // #101688# Anchor handle with (0,0) at top right for SW |
| |
| // for SJ and the CustomShapeHandles: |
| HDL_CUSTOMSHAPE1, |
| |
| HDL_SMARTTAG |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| enum BitmapColorIndex |
| { |
| LightGreen, |
| Cyan, |
| LightCyan, |
| Red, |
| LightRed, |
| Yellow |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| enum BitmapMarkerKind |
| { |
| Rect_7x7, |
| Rect_9x9, |
| Rect_11x11, |
| Rect_13x13, |
| Circ_7x7, |
| Circ_9x9, |
| Circ_11x11, |
| Elli_7x9, |
| Elli_9x11, |
| Elli_9x7, |
| Elli_11x9, |
| RectPlus_7x7, |
| RectPlus_9x9, |
| RectPlus_11x11, |
| Crosshair, |
| Glue, |
| Anchor, |
| |
| // #98388# add AnchorPressed to be able to aninate anchor control, too. |
| AnchorPressed, |
| |
| // #101688# AnchorTR for SW |
| AnchorTR, |
| AnchorPressedTR, |
| |
| // for SJ and the CustomShapeHandles: |
| Customshape_7x7, |
| Customshape_9x9, |
| Customshape_11x11 |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class SVX_DLLPUBLIC SdrHdl |
| { |
| friend class SdrMarkView; // fuer den Zugriff auf nObjHdlNum |
| friend class SdrHdlList; |
| |
| // #101928# |
| BitmapEx ImpGetBitmapEx(BitmapMarkerKind eKindOfMarker, sal_uInt16 nInd, sal_Bool bFine, sal_Bool bIsHighContrast); |
| |
| protected: |
| SdrObject* pObj; // Gehoert das Handle zu einem Objekt? |
| SdrPageView* pPV; // Gehoert das Handle zu einem Objekt in einer bestimmten PageView? |
| SdrHdlList* pHdlList; // Zum Feststelen der Handlegroesse |
| |
| // OVERLAYMANAGER |
| ::sdr::overlay::OverlayObjectList maOverlayGroup; |
| |
| Point aPos; |
| |
| SdrHdlKind eKind; |
| |
| long nDrehWink; // Handles bzw. Mauszeiger drehen |
| sal_uInt32 nObjHdlNum; // wird von der MarkView benoetigt |
| sal_uInt32 nPolyNum; // Polygonpunktes |
| sal_uInt32 nPPntNum; // Punktnummer des Polygons |
| sal_uInt32 nSourceHdlNum; // ist noch vollstaendig zu implementieren |
| |
| unsigned bSelect : 1; // Ein selektierter Polygonpunkt? |
| unsigned b1PixMore : 1; // True=Handle wird 1 Pixel groesser dargestellt |
| unsigned bPlusHdl : 1; // u.a. fuer Hld-Paint Optimierung bei MarkPoint/UnmarkPoint, ... |
| |
| bool mbMoveOutside; // forces this handle to be moved outside of the selection rectangle |
| |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| // cleanup marker if one exists |
| void GetRidOfIAObject(); |
| |
| private: |
| bool mbMouseOver; // is true if the mouse is over this handle |
| |
| protected: |
| ::sdr::overlay::OverlayObject* CreateOverlayObject( |
| const basegfx::B2DPoint& rPos, |
| BitmapColorIndex eColIndex, BitmapMarkerKind eKindOfMarker, Point aMoveOutsideOffset = Point()); |
| BitmapMarkerKind GetNextBigger(BitmapMarkerKind eKnd) const; |
| |
| public: |
| SdrHdl(); |
| SdrHdl(const Point& rPnt, SdrHdlKind eNewKind=HDL_MOVE); |
| virtual ~SdrHdl(); |
| |
| const ::sdr::overlay::OverlayObjectList& getOverlayObjectList() const { return maOverlayGroup; } |
| |
| void SetHdlList(SdrHdlList* pList); |
| SdrHdlKind GetKind() const { return eKind; } |
| void Touch(); |
| |
| const Point& GetPos() const { return aPos; } |
| void SetPos(const Point& rPnt); |
| |
| SdrPageView* GetPageView() const { return pPV; } |
| void SetPageView(SdrPageView* pNewPV) { pPV=pNewPV; } |
| |
| SdrObject* GetObj() const { return pObj; } |
| void SetObj(SdrObject* pNewObj); |
| |
| sal_Bool IsSelected() const { return bSelect; } |
| void SetSelected(sal_Bool bJa=sal_True); |
| |
| void Set1PixMore(sal_Bool bJa=sal_True); |
| void SetDrehWink(long n); |
| |
| sal_Bool IsCornerHdl() const { return eKind==HDL_UPLFT || eKind==HDL_UPRGT || eKind==HDL_LWLFT || eKind==HDL_LWRGT; } |
| sal_Bool IsVertexHdl() const { return eKind==HDL_UPPER || eKind==HDL_LOWER || eKind==HDL_LEFT || eKind==HDL_RIGHT; } |
| |
| void SetObjHdlNum(sal_uInt32 nNum) { nObjHdlNum=nNum; } |
| sal_uInt32 GetObjHdlNum() const { return nObjHdlNum; } |
| |
| void SetPolyNum(sal_uInt32 nNum) { nPolyNum=nNum; } |
| sal_uInt32 GetPolyNum() const { return nPolyNum; } |
| |
| void SetPointNum(sal_uInt32 nNum) { nPPntNum=nNum; } |
| sal_uInt32 GetPointNum() const { return nPPntNum; } |
| |
| void SetPlusHdl(sal_Bool bOn) { bPlusHdl=bOn; } |
| sal_Bool IsPlusHdl() const { return bPlusHdl; } |
| |
| void SetSourceHdlNum(sal_uInt32 nNum) { nSourceHdlNum=nNum; } |
| sal_uInt32 GetSourceHdlNum() const { return nSourceHdlNum; } |
| |
| virtual Pointer GetPointer() const; |
| bool IsHdlHit(const Point& rPnt) const; |
| |
| // #97016# II |
| virtual sal_Bool IsFocusHdl() const; |
| |
| void SetMoveOutside( bool bMoveOutside ); |
| |
| /** is called when the mouse enters the area of this handle. If the handle changes his |
| visualisation during mouse over it must override this method and call Touch(). */ |
| virtual void onMouseEnter(const MouseEvent& rMEvt); |
| |
| /** is called when the mouse leaves the area of this handle. If the handle changes his |
| visualisation during mouse over it must override this method and call Touch(). */ |
| virtual void onMouseLeave(); |
| |
| bool isMouseOver() const; |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #define SDR_HANDLE_COLOR_SIZE_NORMAL Size(13, 13) |
| #define SDR_HANDLE_COLOR_SIZE_SELECTED Size(17, 17) |
| |
| class SVX_DLLPUBLIC SdrHdlColor : public SdrHdl |
| { |
| private: |
| // size of colr markers |
| Size aMarkerSize; |
| |
| // color |
| Color aMarkerColor; |
| |
| // callback link when value changed |
| Link aColorChangeHdl; |
| |
| // use luminance values only |
| unsigned bUseLuminance : 1; |
| |
| // create marker for this kind |
| SVX_DLLPRIVATE virtual void CreateB2dIAObject(); |
| |
| // help functions |
| SVX_DLLPRIVATE Bitmap CreateColorDropper(Color aCol); |
| SVX_DLLPRIVATE Color GetLuminance(const Color& rCol); |
| SVX_DLLPRIVATE void CallColorChangeLink(); |
| |
| public: |
| SdrHdlColor(const Point& rRef, Color aCol = Color(COL_BLACK), const Size& rSize = Size(11, 11), sal_Bool bLum = sal_False); |
| virtual ~SdrHdlColor(); |
| |
| sal_Bool IsUseLuminance() const { return bUseLuminance; } |
| |
| Color GetColor() const { return aMarkerColor; } |
| void SetColor(Color aNew, sal_Bool bCallLink = sal_False); |
| |
| const Size& GetSize() const { return aMarkerSize; } |
| void SetSize(const Size& rNew); |
| |
| void SetColorChangeHdl(const Link& rLink) { aColorChangeHdl = rLink; } |
| const Link& GetColorChangeHdl() const { return aColorChangeHdl; } |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class SdrHdlGradient : public SdrHdl |
| { |
| private: |
| // pointer to used color handles |
| SdrHdlColor* pColHdl1; |
| SdrHdlColor* pColHdl2; |
| |
| // 2nd position |
| Point a2ndPos; |
| |
| // is this a gradient or a transparence |
| unsigned bGradient : 1; |
| |
| // select which handle to move |
| unsigned bMoveSingleHandle : 1; |
| unsigned bMoveFirstHandle : 1; |
| |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| public: |
| SdrHdlGradient(const Point& rRef1, const Point& rRef2, sal_Bool bGrad = sal_True); |
| virtual ~SdrHdlGradient(); |
| |
| sal_Bool IsGradient() const { return bGradient; } |
| |
| // set the associated color handles |
| void SetColorHandles(SdrHdlColor* pL1, SdrHdlColor* pL2) { pColHdl1 = pL1; pColHdl2 = pL2; } |
| SdrHdlColor* GetColorHdl1() const { return pColHdl1; } |
| SdrHdlColor* GetColorHdl2() const { return pColHdl2; } |
| |
| const Point& Get2ndPos() const { return a2ndPos; } |
| void Set2ndPos(const Point& rPnt); |
| |
| // the link called by the color handles |
| DECL_LINK(ColorChangeHdl, SdrHdl*); |
| |
| // transformation call, create gradient from this handle |
| void FromIAOToItem(SdrObject* pObj, sal_Bool bSetItemOnObject, sal_Bool bUndo); |
| |
| // selection flags for interaction |
| sal_Bool IsMoveSingleHandle() const { return bMoveSingleHandle; } |
| void SetMoveSingleHandle(sal_Bool bNew) { bMoveSingleHandle = bNew; } |
| sal_Bool IsMoveFirstHandle() const { return bMoveFirstHandle; } |
| void SetMoveFirstHandle(sal_Bool bNew) { bMoveFirstHandle = bNew; } |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // Spiegelachse |
| class SdrHdlLine: public SdrHdl |
| { |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| protected: |
| SdrHdl* pHdl1; |
| SdrHdl* pHdl2; |
| |
| public: |
| SdrHdlLine(SdrHdl& rHdl1, SdrHdl& rHdl2, SdrHdlKind eNewKind=HDL_MIRX) { eKind=eNewKind; pHdl1=&rHdl1; pHdl2=&rHdl2; } |
| virtual ~SdrHdlLine(); |
| |
| virtual Pointer GetPointer() const; |
| }; |
| |
| // Ein SdrHdlBezWgt hat Kenntnis von seinem "BasisHandle". Seine Draw-Methode |
| // zeichnet zusaetzlich eine Linie von seiner Position zur Position dieses |
| // BasisHandles. |
| class SdrHdlBezWgt: public SdrHdl |
| { |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| protected: |
| const SdrHdl* pHdl1; |
| |
| public: |
| // das ist kein Copy-Ctor!!! |
| SdrHdlBezWgt(const SdrHdl* pRefHdl1, SdrHdlKind eNewKind=HDL_BWGT) { eKind=eNewKind; pHdl1=pRefHdl1; } |
| virtual ~SdrHdlBezWgt(); |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class E3dVolumeMarker : public SdrHdl |
| { |
| basegfx::B2DPolyPolygon aWireframePoly; |
| |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| public: |
| E3dVolumeMarker(const basegfx::B2DPolyPolygon& rWireframePoly); |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class ImpEdgeHdl: public SdrHdl |
| { |
| SdrEdgeLineCode eLineCode; |
| |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| public: |
| ImpEdgeHdl(const Point& rPnt, SdrHdlKind eNewKind): SdrHdl(rPnt,eNewKind),eLineCode(MIDDLELINE) {} |
| virtual ~ImpEdgeHdl(); |
| |
| void SetLineCode(SdrEdgeLineCode eCode); |
| SdrEdgeLineCode GetLineCode() const { return eLineCode; } |
| sal_Bool IsHorzDrag() const; |
| virtual Pointer GetPointer() const; |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class ImpMeasureHdl: public SdrHdl |
| { |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| public: |
| ImpMeasureHdl(const Point& rPnt, SdrHdlKind eNewKind): SdrHdl(rPnt,eNewKind) {} |
| virtual ~ImpMeasureHdl(); |
| |
| virtual Pointer GetPointer() const; |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class ImpTextframeHdl: public SdrHdl |
| { |
| const Rectangle maRect; |
| |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| public: |
| explicit ImpTextframeHdl(const Rectangle& rRect); |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // #97016# II |
| class ImplHdlListData; |
| |
| class SVX_DLLPUBLIC SdrHdlList |
| { |
| protected: |
| sal_uIntPtr mnFocusIndex; |
| SdrMarkView* pView; |
| Container aList; |
| sal_uInt16 nHdlSize; |
| |
| unsigned bRotateShear : 1; |
| unsigned bDistortShear : 1; |
| unsigned bMoveOutside : 1; // Handles nach aussen ruecken (fuer TextEdit) |
| unsigned bFineHandles : 1; |
| |
| private: |
| SVX_DLLPRIVATE SdrHdlList(const SdrHdlList&): aList(1024,64,64) {} |
| SVX_DLLPRIVATE void operator=(const SdrHdlList&) {} |
| SVX_DLLPRIVATE sal_Bool operator==(const SdrHdlList&) const { return sal_False; } |
| SVX_DLLPRIVATE sal_Bool operator!=(const SdrHdlList&) const { return sal_False; } |
| |
| public: |
| SdrHdlList(SdrMarkView* pV); |
| ~SdrHdlList(); |
| void Clear(); |
| |
| // #97016# II |
| void TravelFocusHdl(sal_Bool bForward); |
| SdrHdl* GetFocusHdl() const; |
| void SetFocusHdl(SdrHdl* pNew); |
| void ResetFocusHdl(); |
| |
| // Access to View |
| SdrMarkView* GetView() const; |
| |
| // Sortierung: 1.Level Erst Refpunkt-Handles, dann normale Handles, dann Glue, dann User, dann Plushandles |
| // 2.Level PageView (Pointer) |
| // 3.Level Position (x+y) |
| void Sort(); |
| sal_uIntPtr GetHdlCount() const { return aList.Count(); } |
| SdrHdl* GetHdl(sal_uIntPtr nNum) const { return (SdrHdl*)(aList.GetObject(nNum)); } |
| sal_uIntPtr GetHdlNum(const SdrHdl* pHdl) const; |
| void SetHdlSize(sal_uInt16 nSiz); |
| sal_uInt16 GetHdlSize() const { return nHdlSize; } |
| void SetMoveOutside(sal_Bool bOn); |
| sal_Bool IsMoveOutside() const { return bMoveOutside; } |
| void SetRotateShear(sal_Bool bOn); |
| sal_Bool IsRotateShear() const { return bRotateShear; } |
| void SetDistortShear(sal_Bool bOn); |
| sal_Bool IsDistortShear() const { return bDistortShear; } |
| void SetFineHdl(sal_Bool bOn); |
| sal_Bool IsFineHdl() const { return bFineHandles; } |
| |
| // AddHdl uebernimmt das Handle in sein Eigentum. Es muss |
| // also auf dem Heap stehen, da Clear() ein delete macht. |
| void AddHdl(SdrHdl* pHdl, sal_Bool bAtBegin=sal_False); |
| SdrHdl* RemoveHdl(sal_uIntPtr nNum); |
| |
| // Zuletzt eingefuegte Handles werden am ehesten getroffen |
| // (wenn Handles uebereinander liegen). |
| SdrHdl* IsHdlListHit(const Point& rPnt, sal_Bool bBack=sal_False, sal_Bool bNext=sal_False, SdrHdl* pHdl0=NULL) const; |
| SdrHdl* GetHdl(SdrHdlKind eKind1) const; |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class SVX_DLLPUBLIC SdrCropHdl : public SdrHdl |
| { |
| private: |
| // evtl. shear and rotation, equal to the object's one to allow adaption of |
| // the visualization handles |
| double mfShearX; |
| double mfRotation; |
| |
| public: |
| SdrCropHdl( |
| const Point& rPnt, |
| SdrHdlKind eNewKind, |
| double fShearX, |
| double fRotation); |
| |
| protected: |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| |
| BitmapEx GetBitmapForHandle( const BitmapEx& rBitmap, int nSize ); |
| |
| static BitmapEx GetHandlesBitmap( bool bIsFineHdl, bool bIsHighContrast ); |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class SVX_DLLPUBLIC SdrCropViewHdl : public SdrHdl |
| { |
| private: |
| basegfx::B2DHomMatrix maObjectTransform; |
| Graphic maGraphic; |
| double mfCropLeft; |
| double mfCropTop; |
| double mfCropRight; |
| double mfCropBottom; |
| |
| public: |
| SdrCropViewHdl( |
| const basegfx::B2DHomMatrix& rObjectTransform, |
| const Graphic& rGraphic, |
| double fCropLeft, |
| double fCropTop, |
| double fCropRight, |
| double fCropBottom); |
| |
| protected: |
| // create marker for this kind |
| virtual void CreateB2dIAObject(); |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #endif //_SVDHDL_HXX |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // eof |