summaryrefslogtreecommitdiffstats
path: root/include/svx/svdmrkv.hxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--include/svx/svdmrkv.hxx457
1 files changed, 457 insertions, 0 deletions
diff --git a/include/svx/svdmrkv.hxx b/include/svx/svdmrkv.hxx
new file mode 100644
index 000000000..49d39f06f
--- /dev/null
+++ b/include/svx/svdmrkv.hxx
@@ -0,0 +1,457 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * 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 .
+ */
+
+#ifndef INCLUDED_SVX_SVDMRKV_HXX
+#define INCLUDED_SVX_SVDMRKV_HXX
+
+#include <svx/svdmark.hxx>
+#include <svx/svdhdl.hxx>
+#include <svx/svdsnpv.hxx>
+#include <svx/svdtypes.hxx>
+#include <svx/svxdllapi.h>
+#include <o3tl/typed_flags_set.hxx>
+
+class SfxViewShell;
+
+// The following is not yet implemented, or just partially:
+enum class SdrSearchOptions
+{
+ NONE = 0x0000,
+ DEEP = 0x0001, /* recursive into group objects */
+ ALSOONMASTER = 0x0002, /* MasterPages are also scanned */
+ WHOLEPAGE = 0x0004, /* Not just the ObjList of PageView */
+ TESTMARKABLE = 0x0008, /* just markable objects/points/handles/... */
+ TESTMACRO = 0x0010, /* Just objects with macro */
+ TESTTEXTEDIT = 0x0020, /* Just TextEdit-enabled objects */
+ MARKED = 0x0040, /* Just marked objects/points/... */
+ PASS2BOUND = 0x0080, /* In case of empty search results, then 2nd. try with BoundRectHit */
+ BEFOREMARK = 0x0100, /* if one marked one found, ignore all behind that */
+
+ IMPISMASTER = 0x0200, /* MasterPage is being searched right now */
+ PICKMARKABLE = TESTMARKABLE,
+ PICKTEXTEDIT = DEEP | TESTMARKABLE | TESTTEXTEDIT,
+ PICKMACRO = DEEP | ALSOONMASTER | WHOLEPAGE | TESTMACRO,
+};
+namespace o3tl
+{
+ template<> struct typed_flags<SdrSearchOptions> : is_typed_flags<SdrSearchOptions, 0x03ff> {};
+}
+
+enum class SdrHitKind
+{
+ NONE, // No hit
+ Object, // Hit
+ Handle, // Marking handle
+ HelpLine, // Reference line
+ Gluepoint, // Glue point
+ TextEdit, // Open OutlinerView was hit
+ TextEditObj, // Object for SdrBeginTextEdit (Textbereich)
+ UrlField, // Field in TextObj was hit (while it is currently not edited)
+ Macro, // Object for BegMacroObj
+ MarkedObject, // Marked object (e.g. for dragging)
+ UnmarkedObject, // non-marked Object (e.g. for marking)
+ Cell // hit on a cell inside a table shape (outside of the cells text area)
+};
+
+enum class SdrViewEditMode {
+ Edit, // Also known as arrow or pointer mode
+ Create, // Tool for object creation
+ GluePointEdit // Glue point editing mode
+};
+
+/** options for ImpGetDescriptionString() */
+enum class ImpGetDescriptionOptions
+{
+ NONE = 0,
+ POINTS = 1,
+ GLUEPOINTS = 2,
+};
+
+class ImplMarkingOverlay;
+
+class SVXCORE_DLLPUBLIC SdrMarkView : public SdrSnapView
+{
+ friend class SdrPageView;
+
+ // #114409#-3 Migrate selections
+ ImplMarkingOverlay* mpMarkObjOverlay;
+ ImplMarkingOverlay* mpMarkPointsOverlay;
+ ImplMarkingOverlay* mpMarkGluePointsOverlay;
+
+protected:
+ SdrObject* mpMarkedObj; // If not just one object ( i.e. More than one object ) is marked.
+ SdrPageView* mpMarkedPV; // If all marked obects are situated on the same PageView.
+
+ Point maRef1; // Persistent - Rotation center / axis of reflection
+ Point maRef2; // Persistent
+ SdrHdlList maHdlList;
+ sdr::ViewSelection maSdrViewSelection;
+
+ tools::Rectangle maMarkedObjRect;
+ tools::Rectangle maMarkedPointsRect;
+ tools::Rectangle maMarkedGluePointsRect;
+
+ sal_uInt16 mnFrameHandlesLimit;
+
+ SdrDragMode meDragMode; // Persistent
+ SdrViewEditMode meEditMode; // Persistent
+ SdrViewEditMode meEditMode0; // Persistent
+
+ bool mbDesignMode : 1; // DesignMode for SdrUnoObj
+ bool mbForceFrameHandles : 1; // Persistent - FrameDrag also for single objects
+ bool mbPlusHdlAlways : 1; // Persistent
+ bool mbInsPolyPoint : 1; // at this time InsPolyPointDragging
+ bool mbMarkedObjRectDirty : 1;
+ bool mbMrkPntDirty : 1;
+ bool mbMarkedPointsRectsDirty : 1;
+
+ // flag to completely disable handles at the view
+ bool mbMarkHandlesHidden : 1;
+
+ // Helper to get a possible GridOffset from SdrObject
+ bool getPossibleGridOffsetForSdrObject(
+ basegfx::B2DVector& rOffset,
+ const SdrObject* pObj,
+ const SdrPageView* pPV) const;
+
+ // Helper to get a possible GridOffset from Position
+ bool getPossibleGridOffsetForPosition(
+ basegfx::B2DVector& rOffset,
+ const basegfx::B2DPoint& rPoint,
+ const SdrPageView* pPV) const;
+
+private:
+ SVX_DLLPRIVATE void ImpClearVars();
+ SVX_DLLPRIVATE void ImpSetPointsRects() const;
+ void UndirtyMrkPnt() const;
+
+ void SetMarkHandlesForLOKit(tools::Rectangle const & rRect, SfxViewShell* pOtherShell);
+
+protected:
+ virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override;
+ virtual void ModelHasChanged() override; // Is called by the PaintView
+ virtual void SetMarkHandles(SfxViewShell* pOtherShell); // maHdlList - fill (List of handles)
+ void SetMarkRects(); // Rects at the PageViews
+ void CheckMarked(); // Scan MarkList after Del and Lock Layer ...
+ void AddDragModeHdl(SdrDragMode eMode);
+ virtual bool MouseMove(const MouseEvent& rMEvt, OutputDevice* pWin) override;
+ virtual bool RequestHelp(const HelpEvent& rHEvt) override;
+
+ // add custom handles (used by other apps, e.g. AnchorPos)
+ virtual void AddCustomHdl();
+
+ void ForceRefToMarked();
+ void ForceUndirtyMrkPnt() const { if (mbMrkPntDirty) UndirtyMrkPnt(); }
+
+ virtual SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObject* pObj, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay) const;
+ SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList const * pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay, SdrObject*& rpRootObj) const;
+ SdrObject* CheckSingleSdrObjectHit(const Point& rPnt, sal_uInt16 nTol, SdrObjList const * pOL, SdrPageView* pPV, SdrSearchOptions nOptions, const SdrLayerIDSet* pMVisLay, SdrObject*& rpRootObj,const SdrMarkList * pMarkList) const;
+ bool ImpIsFrameHandles() const;
+ OUString ImpGetDescriptionString(const char* pStrCacheID, ImpGetDescriptionOptions nOpt=ImpGetDescriptionOptions::NONE) const;
+
+ // Generates a string including degrees symbol, from an angel specification in 1/100deg
+ bool ImpMarkPoint(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark);
+ virtual bool MarkPoints(const tools::Rectangle* pRect, bool bUnmark);
+ bool MarkGluePoints(const tools::Rectangle* pRect, bool bUnmark);
+
+ void SetMoveOutside(bool bOn);
+ bool MarkableObjectsExceed( int n ) const;
+
+protected:
+ // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView
+ SdrMarkView(
+ SdrModel& rSdrModel,
+ OutputDevice* pOut);
+
+ virtual ~SdrMarkView() override;
+
+public:
+ virtual bool IsAction() const override;
+ virtual void MovAction(const Point& rPnt) override;
+ virtual void EndAction() override;
+ virtual void BckAction() override;
+ virtual void BrkAction() override;
+ virtual void TakeActionRect(tools::Rectangle& rRect) const override;
+
+ virtual void ClearPageView() override;
+ virtual void HideSdrPage() override;
+ bool IsObjMarkable(SdrObject const * pObj, SdrPageView const * pPV) const;
+
+ // Returns sal_True if objects, points or glue points are selected by drawing a frame
+ // (as long as the frame is drawn).
+ bool IsMarking() const { return IsMarkObj() || IsMarkPoints() || IsMarkGluePoints(); }
+
+ // Marking objects by drawing of a selection frame
+ void BegMarkObj(const Point& rPnt, bool bUnmark = false);
+ void MovMarkObj(const Point& rPnt);
+ bool EndMarkObj();
+ void BrkMarkObj();
+ bool IsMarkObj() const { return (nullptr != mpMarkObjOverlay); }
+
+ // DragModes: SDRDRAG_CREATE,SdrDragMode::Move,SdrDragMode::Resize,SdrDragMode::Rotate,SdrDragMode::Mirror,SdrDragMode::Shear,SdrDragMode::Crook
+ // Move==Resize
+ // The interface might maybe be changed in the future because of Ortho-Drag
+ void SetDragMode(SdrDragMode eMode);
+ SdrDragMode GetDragMode() const { return meDragMode; }
+ void SetFrameHandles(bool bOn);
+ bool IsFrameHandles() const { return mbForceFrameHandles; }
+
+ // returns true if number of markable objects is greater than 1
+ bool HasMultipleMarkableObjects() const { return MarkableObjectsExceed(1); };
+
+ void SetEditMode(SdrViewEditMode eMode);
+ SdrViewEditMode GetEditMode() const { return meEditMode; }
+
+ void SetEditMode(bool bOn) { SetEditMode(bOn?SdrViewEditMode::Edit:SdrViewEditMode::Create); }
+ bool IsEditMode() const { return meEditMode==SdrViewEditMode::Edit; }
+ void SetCreateMode(bool bOn) { SetEditMode(bOn?SdrViewEditMode::Create:SdrViewEditMode::Edit); }
+ bool IsCreateMode() const { return meEditMode==SdrViewEditMode::Create; }
+ void SetGluePointEditMode(bool bOn) { SetEditMode(bOn?SdrViewEditMode::GluePointEdit:meEditMode0); }
+ bool IsGluePointEditMode() const { return meEditMode==SdrViewEditMode::GluePointEdit; }
+
+ void SetDesignMode(bool bOn = true);
+ bool IsDesignMode() const { return mbDesignMode; }
+
+ void SetFrameDragSingles(bool bOn=true) { SetFrameHandles(bOn); }
+ bool IsFrameDragSingles() const { return IsFrameHandles(); }
+
+ bool HasMarkableObj() const { return MarkableObjectsExceed(0); };
+
+
+// migrate selections
+
+protected:
+ // all available changing methods
+ SdrMarkList& GetMarkedObjectListWriteAccess() { return maSdrViewSelection.GetMarkedObjectListWriteAccess(); }
+
+public:
+ // all available const methods for read access to selection
+ const SdrMarkList& GetMarkedObjectList() const { return maSdrViewSelection.GetMarkedObjectList(); }
+ // returns SAL_MAX_SIZE if not found
+ size_t TryToFindMarkedObject(const SdrObject* pObj) const { return GetMarkedObjectList().FindObject(pObj); }
+ SdrPageView* GetSdrPageViewOfMarkedByIndex(size_t nNum) const { return GetMarkedObjectList().GetMark(nNum)->GetPageView(); }
+ SdrMark* GetSdrMarkByIndex(size_t nNum) const { return GetMarkedObjectList().GetMark(nNum); }
+ SdrObject* GetMarkedObjectByIndex(size_t nNum) const { return GetMarkedObjectList().GetMark(nNum)->GetMarkedSdrObj(); }
+ size_t GetMarkedObjectCount() const { return GetMarkedObjectList().GetMarkCount(); }
+ void SortMarkedObjects() const { GetMarkedObjectList().ForceSort(); }
+ bool AreObjectsMarked() const { return 0 != GetMarkedObjectList().GetMarkCount(); }
+ OUString const & GetDescriptionOfMarkedObjects() const { return GetMarkedObjectList().GetMarkDescription(); }
+ OUString const & GetDescriptionOfMarkedPoints() const { return GetMarkedObjectList().GetPointMarkDescription(); }
+ OUString const & GetDescriptionOfMarkedGluePoints() const { return GetMarkedObjectList().GetGluePointMarkDescription(); }
+
+ // Get a list of all those links which are connected to marked nodes,
+ // but which are not marked themselves.
+ const SdrMarkList& GetEdgesOfMarkedNodes() const { return maSdrViewSelection.GetEdgesOfMarkedNodes(); }
+ const SdrMarkList& GetMarkedEdgesOfMarkedNodes() const { return maSdrViewSelection.GetMarkedEdgesOfMarkedNodes(); }
+ const std::vector<SdrObject*>& GetTransitiveHullOfMarkedObjects() const { return maSdrViewSelection.GetAllMarkedObjects(); }
+
+
+ // mechanism to complete disable handles at the view. Handles will be hidden and deleted
+ // when set, no new ones created, no interaction allowed. Handles will be recreated and shown
+ // when reset. Default is false.
+ void hideMarkHandles();
+ void showMarkHandles();
+ bool areMarkHandlesHidden() const { return mbMarkHandlesHidden; }
+
+ bool IsMarkedHit(const Point& rPnt, short nTol=-2) const { return IsMarkedObjHit(rPnt,nTol); }
+ bool IsMarkedObjHit(const Point& rPnt, short nTol=-2) const;
+
+ SdrHdl* PickHandle(const Point& rPnt) const;
+
+ // Pick: Supported options for nOptions are:
+ // SdrSearchOptions::DEEP SdrSearchOptions::ALSOONMASTER SdrSearchOptions::TESTMARKABLE SdrSearchOptions::TESTTEXTEDIT
+ // SdrSearchOptions::MARKED
+ // SdrSearchOptions::WHOLEPAGE
+ SdrObject* PickObj(const Point& rPnt, short nTol, SdrPageView*& rpPV, SdrSearchOptions nOptions, SdrObject** ppRootObj, bool* pbHitPassDirect=nullptr) const;
+ SdrObject* PickObj(const Point& rPnt, short nTol, SdrPageView*& rpPV, SdrSearchOptions nOptions=SdrSearchOptions::NONE) const;
+ bool MarkObj(const Point& rPnt, short nTol=-2, bool bToggle=false, bool bDeep=false);
+
+ // Pick: Supported options for nOptions are SdrSearchOptions::PASS2BOUND
+ bool PickMarkedObj(const Point& rPnt, SdrObject*& rpObj, SdrPageView*& rpPV, SdrSearchOptions nOptions) const;
+
+ // Selects the most upper of the marked objects (O1) and scans from there
+ // towards bottom direction, selecting the first non-marked object (O2).
+ // In case of success the marking of O1 is deleted, a marking is created at
+ // O2 and TRUE is returned. With the parameter bPrev=sal_True the scan
+ // direction is turned to the other direction.
+ bool MarkNextObj(bool bPrev=false);
+
+ // Selects the most upper of the marked objects which is hit by rPnt/nTol
+ // and scans from there to bottom direction, selecting the first non-marked
+ // object (O2). In case of success the marking of O1 is deleted, a marking
+ // is created at O2 and sal_True is returned. With the parameter
+ // bPrev=sal_True the scan direction is turned to the other direction.
+ bool MarkNextObj(const Point& rPnt, short nTol, bool bPrev);
+
+ // Mark all objects within a rectangular area
+ // Just objects are marked which are inclosed completely
+ void MarkObj(const tools::Rectangle& rRect, bool bUnmark);
+ void MarkObj(SdrObject* pObj, SdrPageView* pPV, bool bUnmark=false, bool bImpNoSetMarkHdl=false);
+ void MarkAllObj(SdrPageView* pPV=nullptr); // pPage=NULL => all displayed pages
+ void UnmarkAllObj(SdrPageView const * pPV=nullptr); // pPage=NULL => all displayed pages
+
+ // This function is time-consuming intensive, as the MarkList has to be scanned.
+ bool IsObjMarked(SdrObject const * pObj) const;
+ void UnMarkAll(SdrPageView const * pPV=nullptr) { UnmarkAllObj(pPV); }
+
+ // Request/set the size of the marking handles. Declaration in Pixel.
+ // The value is meant to be the edge length ( link length ).
+ // Pair values are round up to impair values: 3->3, 4->5, 5->5, 6->7, 7->7, ...
+ // Default value is 7, minimum value is 3 Pixels.
+ sal_uInt16 GetMarkHdlSizePixel() const;
+ void SetMarkHdlSizePixel(sal_uInt16 nSiz);
+
+ virtual bool HasMarkablePoints() const;
+ virtual sal_Int32 GetMarkablePointCount() const;
+ virtual bool HasMarkedPoints() const;
+
+ // There might be points which can't be marked:
+ bool IsPointMarkable(const SdrHdl& rHdl) const;
+ virtual bool MarkPoint(SdrHdl& rHdl, bool bUnmark=false);
+
+ /** should only be used from outside svx for special ui elements */
+ bool MarkPointHelper(SdrHdl* pHdl, SdrMark* pMark, bool bUnmark);
+
+ bool UnmarkPoint(SdrHdl& rHdl) { return MarkPoint(rHdl,true); }
+ bool IsPointMarked(const SdrHdl& rHdl) const { ForceUndirtyMrkPnt(); return rHdl.IsSelected(); }
+ bool MarkAllPoints() { return MarkPoints(nullptr,false); }
+ bool UnmarkAllPoints() { return MarkPoints(nullptr,true); }
+
+ // Selects the first marked point (P1) which is hit by rPnt
+ // and from there it searches the first non-marked point(P2).
+ // In case of success the marking of
+ // P1 is deleted, a mark is set at P2.
+ void MarkNextPoint();
+
+ // Search for the number of the suitable handle. In case of empty search result,
+ // SAL_MAX_SIZE is returned.
+ size_t GetHdlNum(SdrHdl const * pHdl) const { return maHdlList.GetHdlNum(pHdl); }
+ SdrHdl* GetHdl(size_t nHdlNum) const { return maHdlList.GetHdl(nHdlNum); }
+ const SdrHdlList& GetHdlList() const { return maHdlList; }
+
+ // Draw a selection frame for marking of points.
+ // This routine will just be started in case that HasMarkablePoints() returns sal_True.
+ bool BegMarkPoints(const Point& rPnt, bool bUnmark = false);
+ void MovMarkPoints(const Point& rPnt);
+ bool EndMarkPoints();
+ void BrkMarkPoints();
+ bool IsMarkPoints() const { return (nullptr != mpMarkPointsOverlay); }
+
+ // Select that additional handles are displayed permanently.
+ void SetPlusHandlesAlwaysVisible(bool bOn);
+ bool IsPlusHandlesAlwaysVisible() const { return mbPlusHdlAlways; }
+
+ bool HasMarkableGluePoints() const;
+ bool HasMarkedGluePoints() const;
+
+ // A gluepoint is clearly identified by the SdrObject
+ // (to which it belongs) as well as by a sal_uInt16 nId (as each SdrObject may consist of
+ // several glue points. Here at the View there is an additional
+ // SdrPageView, which should be defined correctly always.
+ // Alternatively a gluepoint may be characterized by a SdrHdl.
+ // In this case the SdrHdl instance consists of all required information.
+ // And in this case, the glue point are always is marked by enforcement
+ // (Handlers are just situated at marked gluepoints )
+ // Attention: With each change of the glue point status the handle list is re-calculated.
+ // All previously saved SdrHdl* became invalid by this, the same with the point IDs!
+ bool PickGluePoint(const Point& rPnt, SdrObject*& rpObj, sal_uInt16& rnId, SdrPageView*& rpPV) const;
+ bool MarkGluePoint(const SdrObject* pObj, sal_uInt16 nId, bool bUnmark);
+ void UnmarkGluePoint(const SdrObject* pObj, sal_uInt16 nId) { MarkGluePoint(pObj,nId,true); }
+ bool IsGluePointMarked(const SdrObject* pObj, sal_uInt16 nId) const;
+
+ // Get the Hdl (handle) of a marked GluePoint. Non-marked
+ // GluePoints don`t have handles
+ SdrHdl* GetGluePointHdl(const SdrObject* pObj, sal_uInt16 nId) const;
+
+ // Mark all points within this rectangular (View coordinates)
+ bool MarkAllGluePoints() { return MarkGluePoints(nullptr,false); }
+ bool UnmarkAllGluePoints() { return MarkGluePoints(nullptr,true); }
+
+ // Selects the first marked point (P1) which is hit by rPnt
+ // and from there it searches the first non-marked point(P2).
+ // In case of success the marking of
+ // P1 is deleted, a mark is set at P2.
+ void MarkNextGluePoint();
+
+ // Draw a selection frame for glue point marking.
+ // This routine will just be started in case that HasMarkablePoints() returns sal_True.
+ // The GlueEditMode sal_True is disregarded.
+ // bool BegMarkGluePoints(const Point& rPnt, OutputDevice* pOut);
+ bool BegMarkGluePoints(const Point& rPnt, bool bUnmark = false);
+ void MovMarkGluePoints(const Point& rPnt);
+ void EndMarkGluePoints();
+ void BrkMarkGluePoints();
+ bool IsMarkGluePoints() const { return (nullptr != mpMarkGluePointsOverlay); }
+
+ // bRestraintPaint=sal_False causes the handles not to be drawn immediately.
+ // AdjustMarkHdl is just called in case of changes; usually this causes an Invalidate
+ // At the end of a redraw the handles are drawn automatically.
+ // The purpose is to avoid unnecessary flickering. -> This does not yet work, that's why sal_True!
+ void AdjustMarkHdl(SfxViewShell* pOtherShell = nullptr); //HMHBOOL bRestraintPaint=sal_True);
+
+ const tools::Rectangle& GetMarkedObjRect() const; // SnapRects of Objects, without line width
+ tools::Rectangle GetMarkedObjBoundRect() const; // incl. line width, overlapping rags, ...
+ const tools::Rectangle& GetMarkedPointsRect() const; // Enclosing rectangle of all marked points
+ const tools::Rectangle& GetMarkedGluePointsRect() const; // Enclosing rectangle of all marked glue points
+ const tools::Rectangle& GetAllMarkedRect() const { return GetMarkedObjRect(); }
+ tools::Rectangle GetAllMarkedBoundRect() const { return GetMarkedObjBoundRect(); }
+
+ // Will be always called, if the list of marked objects might be changed.
+ // If you override this method, be sure that you call the
+ // methods of the base class!
+ virtual void MarkListHasChanged();
+
+ // Entering (Editing) of a maybe marked object group. If there are several
+ // object groups marked, the most upper group is selected. After that
+ // all member objects of the group are directly accessible. All other
+ // objects may not be processed in the meantime (until the next
+ // LeaveGroup()). With markings which overlaps pages, every page is processed
+ // separately. The method returns sal_True, if at least one group was entered.
+ void EnterMarkedGroup();
+
+ // Rotation center point and start point of the axis of reflection, respectively
+ const Point& GetRef1() const { return maRef1; }
+ void SetRef1(const Point& rPt);
+
+ // End point of the axis of reflection
+ const Point& GetRef2() const { return maRef2; }
+ void SetRef2(const Point& rPt);
+ /// Get access to the view shell owning this draw view, if any.
+ virtual SfxViewShell* GetSfxViewShell() const;
+};
+
+
+// - Hit tolerances:
+// It has to be declared in logical coordinates. So please translate the
+// wanted pixel value with PixelToLogic in Logical values.
+// Taking as example a logical value of 100:
+// - For a horizontal hairline (Object with height 0), the generated data is +/-100, i.e.
+// a vertical area of 200 logical units is sensitive.
+// - For a polygon, a rectangular of the size (200,200) is generated and a
+// touch test between Poly and this Rect is processed.
+// - Obects which respond SdrObject::HasEdit()==TRUE ( e.g. a text frame ),
+// are specially treated: An additional sensitive area with a width of
+// 2*Tol (200 units for this example) is created around the object.
+// When an object is directly hit, the Edit method is called.
+// In opposite, a hit in the surrounding sensitive area enables Dragging.
+
+
+#endif // INCLUDED_SVX_SVDMRKV_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */