Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 633 insertions, 0 deletions

diff --git a/svx/source/svdraw/svdsnpv.cxx b/svx/source/svdraw/svdsnpv.cxx
new file mode 100644
index 0000000000..bcef8b3c3e
--- /dev/null
+++ b/svx/source/svdraw/svdsnpv.cxx
@@ -0,0 +1,633 @@
+/* -*- 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 .
+ */
+
+
+#include <svx/svdsnpv.hxx>
+#include <math.h>
+
+#include <svx/svdobj.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svditer.hxx>
+#include <svx/sdr/overlay/overlayobjectlist.hxx>
+#include <sdr/overlay/overlaycrosshair.hxx>
+#include <sdr/overlay/overlayhelpline.hxx>
+#include <svx/sdr/overlay/overlaymanager.hxx>
+#include <svx/sdrpaintwindow.hxx>
+#include <tools/debug.hxx>
+#include <vcl/ptrstyle.hxx>
+
+
+class ImplPageOriginOverlay
+{
+    // The OverlayObjects
+    sdr::overlay::OverlayObjectList               maObjects;
+
+    // The current position in logical coordinates
+    basegfx::B2DPoint                               maPosition;
+
+public:
+    ImplPageOriginOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos);
+
+    // The OverlayObjects are cleared using the destructor of OverlayObjectList.
+    // That destructor calls clear() at the list which removes all objects from the
+    // OverlayManager and deletes them.
+
+    void SetPosition(const basegfx::B2DPoint& rNewPosition);
+};
+
+ImplPageOriginOverlay::ImplPageOriginOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos)
+:   maPosition(rStartPos)
+{
+    for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++)
+    {
+        SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
+        const rtl::Reference< sdr::overlay::OverlayManager >& xTargetOverlay = pCandidate->GetOverlayManager();
+
+        if (xTargetOverlay.is())
+        {
+            std::unique_ptr<sdr::overlay::OverlayCrosshairStriped> aNew(new sdr::overlay::OverlayCrosshairStriped(
+                maPosition));
+            xTargetOverlay->add(*aNew);
+            maObjects.append(std::move(aNew));
+        }
+    }
+}
+
+void ImplPageOriginOverlay::SetPosition(const basegfx::B2DPoint& rNewPosition)
+{
+    if(rNewPosition == maPosition)
+        return;
+
+    // apply to OverlayObjects
+    for(sal_uInt32 a(0); a < maObjects.count(); a++)
+    {
+        sdr::overlay::OverlayCrosshairStriped* pCandidate =
+            static_cast< sdr::overlay::OverlayCrosshairStriped* >(&maObjects.getOverlayObject(a));
+
+        if(pCandidate)
+        {
+            pCandidate->setBasePosition(rNewPosition);
+        }
+    }
+
+    // remember new position
+    maPosition = rNewPosition;
+}
+
+
+class ImplHelpLineOverlay
+{
+    // The OverlayObjects
+    sdr::overlay::OverlayObjectList               maObjects;
+
+    // The current position in logical coordinates
+    basegfx::B2DPoint                               maPosition;
+
+    // HelpLine specific stuff
+    SdrPageView*                                    mpPageView;
+    sal_uInt16                                      mnHelpLineNumber;
+    SdrHelpLineKind                                 meHelpLineKind;
+
+public:
+    ImplHelpLineOverlay(const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos,
+        SdrPageView* pPageView, sal_uInt16 nHelpLineNumber, SdrHelpLineKind eKind);
+
+    // The OverlayObjects are cleared using the destructor of OverlayObjectList.
+    // That destructor calls clear() at the list which removes all objects from the
+    // OverlayManager and deletes them.
+
+    void SetPosition(const basegfx::B2DPoint& rNewPosition);
+
+    // access to HelpLine specific stuff
+    SdrPageView* GetPageView() const { return mpPageView; }
+    sal_uInt16 GetHelpLineNumber() const { return mnHelpLineNumber; }
+    SdrHelpLineKind GetHelpLineKind() const { return meHelpLineKind; }
+};
+
+ImplHelpLineOverlay::ImplHelpLineOverlay(
+    const SdrPaintView& rView, const basegfx::B2DPoint& rStartPos,
+    SdrPageView* pPageView, sal_uInt16 nHelpLineNumber, SdrHelpLineKind eKind)
+:   maPosition(rStartPos),
+    mpPageView(pPageView),
+    mnHelpLineNumber(nHelpLineNumber),
+    meHelpLineKind(eKind)
+{
+    for(sal_uInt32 a(0); a < rView.PaintWindowCount(); a++)
+    {
+        SdrPaintWindow* pCandidate = rView.GetPaintWindow(a);
+        const rtl::Reference< sdr::overlay::OverlayManager >& xTargetOverlay = pCandidate->GetOverlayManager();
+
+        if (xTargetOverlay.is())
+        {
+            std::unique_ptr<sdr::overlay::OverlayHelplineStriped> aNew(new sdr::overlay::OverlayHelplineStriped(
+                maPosition, meHelpLineKind));
+            xTargetOverlay->add(*aNew);
+            maObjects.append(std::move(aNew));
+        }
+    }
+}
+
+void ImplHelpLineOverlay::SetPosition(const basegfx::B2DPoint& rNewPosition)
+{
+    if(rNewPosition == maPosition)
+        return;
+
+    // apply to OverlayObjects
+    for(sal_uInt32 a(0); a < maObjects.count(); a++)
+    {
+        sdr::overlay::OverlayHelplineStriped* pCandidate =
+            static_cast< sdr::overlay::OverlayHelplineStriped* >(&maObjects.getOverlayObject(a));
+
+        if(pCandidate)
+        {
+            pCandidate->setBasePosition(rNewPosition);
+        }
+    }
+
+    // remember new position
+    maPosition = rNewPosition;
+}
+
+SdrSnapView::SdrSnapView(
+    SdrModel& rSdrModel,
+    OutputDevice* pOut)
+:   SdrPaintView(rSdrModel, pOut)
+    ,mpPageOriginOverlay(nullptr)
+    ,mpHelpLineOverlay(nullptr)
+    ,nMagnSizPix(4)
+    ,nSnapAngle(1500)
+    ,nEliminatePolyPointLimitAngle(0)
+    ,eCrookMode(SdrCrookMode::Rotate)
+    ,bSnapEnab(true)
+    ,bGridSnap(true)
+    ,bBordSnap(true)
+    ,bHlplSnap(true)
+    ,bOFrmSnap(true)
+    ,bOPntSnap(false)
+    ,bOConSnap(true)
+    ,bMoveSnapOnlyTopLeft(false)
+    ,bOrtho(false)
+    ,bBigOrtho(true)
+    ,bAngleSnapEnab(false)
+    ,bMoveOnlyDragging(false)
+    ,bSlantButShear(false)
+    ,bCrookNoContortion(false)
+    ,bEliminatePolyPoints(false)
+{
+}
+
+SdrSnapView::~SdrSnapView()
+{
+    BrkSetPageOrg();
+    BrkDragHelpLine();
+}
+
+
+bool SdrSnapView::IsAction() const
+{
+    return IsSetPageOrg() || IsDragHelpLine() || SdrPaintView::IsAction();
+}
+
+void SdrSnapView::MovAction(const Point& rPnt)
+{
+    SdrPaintView::MovAction(rPnt);
+    if (IsSetPageOrg()) {
+        MovSetPageOrg(rPnt);
+    }
+    if (IsDragHelpLine()) {
+        MovDragHelpLine(rPnt);
+    }
+}
+
+void SdrSnapView::EndAction()
+{
+    if (IsSetPageOrg()) {
+        EndSetPageOrg();
+    }
+    if (IsDragHelpLine()) {
+        EndDragHelpLine();
+    }
+    SdrPaintView::EndAction();
+}
+
+void SdrSnapView::BckAction()
+{
+    BrkSetPageOrg();
+    BrkDragHelpLine();
+    SdrPaintView::BckAction();
+}
+
+void SdrSnapView::BrkAction()
+{
+    BrkSetPageOrg();
+    BrkDragHelpLine();
+    SdrPaintView::BrkAction();
+}
+
+void SdrSnapView::TakeActionRect(tools::Rectangle& rRect) const
+{
+    if (IsSetPageOrg() || IsDragHelpLine()) {
+        rRect=tools::Rectangle(maDragStat.GetNow(),maDragStat.GetNow());
+    } else {
+        SdrPaintView::TakeActionRect(rRect);
+    }
+}
+
+
+Point SdrSnapView::GetSnapPos(const Point& rPnt, const SdrPageView* pPV) const
+{
+    Point aPt(rPnt);
+    SnapPos(aPt,pPV);
+    return aPt;
+}
+
+#define NOT_SNAPPED 0x7FFFFFFF
+SdrSnap SdrSnapView::SnapPos(Point& rPnt, const SdrPageView* pPV) const
+{
+    if (!bSnapEnab) return SdrSnap::NOTSNAPPED;
+    tools::Long x=rPnt.X();
+    tools::Long y=rPnt.Y();
+    if (pPV==nullptr) {
+        pPV=GetSdrPageView();
+        if (pPV==nullptr) return SdrSnap::NOTSNAPPED;
+    }
+
+    tools::Long dx=NOT_SNAPPED;
+    tools::Long dy=NOT_SNAPPED;
+    tools::Long dx1,dy1;
+    tools::Long mx=aMagnSiz.Width();
+    tools::Long my=aMagnSiz.Height();
+    if (mbHlplVisible && bHlplSnap && !IsDragHelpLine())
+    {
+        const SdrHelpLineList& rHLL=pPV->GetHelpLines();
+        sal_uInt16 nCount=rHLL.GetCount();
+        for (sal_uInt16 i=nCount; i>0;) {
+            i--;
+            const SdrHelpLine& rHL=rHLL[i];
+            const Point& rPos=rHL.GetPos();
+            switch (rHL.GetKind()) {
+                case SdrHelpLineKind::Vertical: {
+                    tools::Long a=x-rPos.X();
+                    if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)<std::abs(dx)) dx=dx1; }
+                } break;
+                case SdrHelpLineKind::Horizontal: {
+                    tools::Long b=y-rPos.Y();
+                    if (std::abs(b)<=my) { dy1=-b; if (std::abs(dy1)<std::abs(dy)) dy=dy1; }
+                } break;
+                case SdrHelpLineKind::Point: {
+                    tools::Long a=x-rPos.X();
+                    tools::Long b=y-rPos.Y();
+                    if (std::abs(a)<=mx && std::abs(b)<=my) {
+                        dx1=-a; dy1=-b;
+                        if (std::abs(dx1)<std::abs(dx) && std::abs(dy1)<std::abs(dy)) { dx=dx1; dy=dy1; }
+                    }
+                } break;
+            } // switch
+        }
+    }
+    if (mbBordVisible && bBordSnap) {
+        SdrPage* pPage=pPV->GetPage();
+        tools::Long xs=pPage->GetWidth();
+        tools::Long ys=pPage->GetHeight();
+        tools::Long lft=pPage->GetLeftBorder();
+        tools::Long rgt=pPage->GetRightBorder();
+        tools::Long upp=pPage->GetUpperBorder();
+        tools::Long lwr=pPage->GetLowerBorder();
+        tools::Long a;
+        a=x- lft    ; if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)<std::abs(dx)) dx=dx1; } // left margin
+        a=x-(xs-rgt); if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)<std::abs(dx)) dx=dx1; } // right margin
+        a=x         ; if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)<std::abs(dx)) dx=dx1; } // left edge of paper
+        a=x- xs     ; if (std::abs(a)<=mx) { dx1=-a; if (std::abs(dx1)<std::abs(dx)) dx=dx1; } // right edge of paper
+        a=y- upp    ; if (std::abs(a)<=my) { dy1=-a; if (std::abs(dy1)<std::abs(dy)) dy=dy1; } // left margin
+        a=y-(ys-lwr); if (std::abs(a)<=my) { dy1=-a; if (std::abs(dy1)<std::abs(dy)) dy=dy1; } // right margin
+        a=y         ; if (std::abs(a)<=my) { dy1=-a; if (std::abs(dy1)<std::abs(dy)) dy=dy1; } // left edge of paper
+        a=y- ys     ; if (std::abs(a)<=my) { dy1=-a; if (std::abs(dy1)<std::abs(dy)) dy=dy1; } // right edge of paper
+    }
+    if (bOFrmSnap || bOPntSnap) {
+        sal_uInt32 nMaxPointSnapCount=200;
+        sal_uInt32 nMaxFrameSnapCount=200;
+
+        // go back to SdrIterMode::DeepNoGroups runthrough for snap to object comparisons
+        SdrObjListIter aIter(pPV->GetPage(),SdrIterMode::DeepNoGroups,true);
+
+        while (aIter.IsMore() && (nMaxPointSnapCount>0 || nMaxFrameSnapCount>0)) {
+            SdrObject* pO=aIter.Next();
+            tools::Rectangle aRect(pO->GetCurrentBoundRect());
+            aRect.AdjustLeft( -mx );
+            aRect.AdjustRight(mx );
+            aRect.AdjustTop( -my );
+            aRect.AdjustBottom(my );
+            if (aRect.Contains(rPnt)) {
+                if (bOPntSnap && nMaxPointSnapCount>0)
+                {
+                    sal_uInt32 nCount(pO->GetSnapPointCount());
+                    for (sal_uInt32 i(0); i < nCount && nMaxPointSnapCount > 0; i++)
+                    {
+                        Point aP(pO->GetSnapPoint(i));
+                        dx1=x-aP.X();
+                        dy1=y-aP.Y();
+                        if (std::abs(dx1)<=mx && std::abs(dy1)<=my && std::abs(dx1)<std::abs(dx) && std::abs(dy1)<std::abs(dy)) {
+                            dx=-dx1;
+                            dy=-dy1;
+                        }
+                        nMaxPointSnapCount--;
+                    }
+                }
+                if (bOFrmSnap && nMaxFrameSnapCount>0) {
+                    tools::Rectangle aLog(pO->GetSnapRect());
+                    tools::Rectangle aR1(aLog);
+                    aR1.AdjustLeft( -mx );
+                    aR1.AdjustRight(mx );
+                    aR1.AdjustTop( -my );
+                    aR1.AdjustBottom(my );
+                    if (aR1.Contains(rPnt)) {
+                        if (std::abs(x-aLog.Left  ())<=mx) { dx1=-(x-aLog.Left  ()); if (std::abs(dx1)<std::abs(dx)) dx=dx1; }
+                        if (std::abs(x-aLog.Right ())<=mx) { dx1=-(x-aLog.Right ()); if (std::abs(dx1)<std::abs(dx)) dx=dx1; }
+                        if (std::abs(y-aLog.Top   ())<=my) { dy1=-(y-aLog.Top   ()); if (std::abs(dy1)<std::abs(dy)) dy=dy1; }
+                        if (std::abs(y-aLog.Bottom())<=my) { dy1=-(y-aLog.Bottom()); if (std::abs(dy1)<std::abs(dy)) dy=dy1; }
+                    }
+                    nMaxFrameSnapCount--;
+                }
+            }
+        }
+    }
+    if(bGridSnap)
+    {
+        double fSnapWidth(aSnapWdtX);
+        if(dx == NOT_SNAPPED && fSnapWidth != 0.0)
+        {
+            double fx = static_cast<double>(x);
+
+            // round instead of trunc
+            if(fx - static_cast<double>(pPV->GetPageOrigin().X()) >= 0.0)
+                fx += fSnapWidth / 2.0;
+            else
+                fx -= fSnapWidth / 2.0;
+
+            x = static_cast<tools::Long>((fx - static_cast<double>(pPV->GetPageOrigin().X())) / fSnapWidth);
+            x = static_cast<tools::Long>(static_cast<double>(x) * fSnapWidth + static_cast<double>(pPV->GetPageOrigin().X()));
+            dx = 0;
+        }
+        fSnapWidth = double(aSnapWdtY);
+        if(dy == NOT_SNAPPED && fSnapWidth)
+        {
+            double fy = static_cast<double>(y);
+
+            // round instead of trunc
+            if(fy - static_cast<double>(pPV->GetPageOrigin().Y()) >= 0.0)
+                fy += fSnapWidth / 2.0;
+            else
+                fy -= fSnapWidth / 2.0;
+
+            y = static_cast<tools::Long>((fy - static_cast<double>(pPV->GetPageOrigin().Y())) / fSnapWidth);
+            y = static_cast<tools::Long>(static_cast<double>(y) * fSnapWidth + static_cast<double>(pPV->GetPageOrigin().Y()));
+            dy = 0;
+        }
+    }
+    SdrSnap bRet=SdrSnap::NOTSNAPPED;
+    if (dx==NOT_SNAPPED) dx=0; else bRet|=SdrSnap::XSNAPPED;
+    if (dy==NOT_SNAPPED) dy=0; else bRet|=SdrSnap::YSNAPPED;
+    rPnt.setX(x+dx );
+    rPnt.setY(y+dy );
+    return bRet;
+}
+
+void SdrSnapView::CheckSnap(const Point& rPt, tools::Long& nBestXSnap, tools::Long& nBestYSnap, bool& bXSnapped, bool& bYSnapped) const
+{
+    Point aPt(rPt);
+    SdrSnap nRet=SnapPos(aPt,nullptr);
+    aPt-=rPt;
+    if (nRet & SdrSnap::XSNAPPED) {
+        if (bXSnapped) {
+            if (std::abs(aPt.X())<std::abs(nBestXSnap)) {
+                nBestXSnap=aPt.X();
+            }
+        } else {
+            nBestXSnap=aPt.X();
+            bXSnapped=true;
+        }
+    }
+    if (nRet & SdrSnap::YSNAPPED) {
+        if (bYSnapped) {
+            if (std::abs(aPt.Y())<std::abs(nBestYSnap)) {
+                nBestYSnap=aPt.Y();
+            }
+        } else {
+            nBestYSnap=aPt.Y();
+            bYSnapped=true;
+        }
+    }
+}
+
+
+void SdrSnapView::BegSetPageOrg(const Point& rPnt)
+{
+    BrkAction();
+
+    DBG_ASSERT(nullptr == mpPageOriginOverlay, "SdrSnapView::BegSetPageOrg: There exists an ImplPageOriginOverlay (!)");
+    basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y());
+    mpPageOriginOverlay = new ImplPageOriginOverlay(*this, aStartPos);
+    maDragStat.Reset(GetSnapPos(rPnt,nullptr));
+}
+
+void SdrSnapView::MovSetPageOrg(const Point& rPnt)
+{
+    if(IsSetPageOrg())
+    {
+        maDragStat.NextMove(GetSnapPos(rPnt,nullptr));
+        DBG_ASSERT(mpPageOriginOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
+        basegfx::B2DPoint aNewPos(maDragStat.GetNow().X(), maDragStat.GetNow().Y());
+        mpPageOriginOverlay->SetPosition(aNewPos);
+    }
+}
+
+void SdrSnapView::EndSetPageOrg()
+{
+    if(!IsSetPageOrg())
+        return;
+
+    SdrPageView* pPV = GetSdrPageView();
+
+    if(pPV)
+    {
+        Point aPnt(maDragStat.GetNow());
+        pPV->SetPageOrigin(aPnt);
+    }
+
+    // cleanup
+    BrkSetPageOrg();
+}
+
+void SdrSnapView::BrkSetPageOrg()
+{
+    if(IsSetPageOrg())
+    {
+        DBG_ASSERT(mpPageOriginOverlay, "SdrSnapView::MovSetPageOrg: no ImplPageOriginOverlay (!)");
+        delete mpPageOriginOverlay;
+        mpPageOriginOverlay = nullptr;
+    }
+}
+
+
+bool SdrSnapView::PickHelpLine(const Point& rPnt, short nTol, const OutputDevice& rOut, sal_uInt16& rnHelpLineNum, SdrPageView*& rpPV) const
+{
+    rpPV=nullptr;
+    nTol=ImpGetHitTolLogic(nTol,&rOut);
+    SdrPageView* pPV = GetSdrPageView();
+
+    if(pPV)
+    {
+        Point aPnt(rPnt);
+        sal_uInt16 nIndex=pPV->GetHelpLines().HitTest(aPnt,sal_uInt16(nTol),rOut);
+        if (nIndex!=SDRHELPLINE_NOTFOUND) {
+            rpPV=pPV;
+            rnHelpLineNum=nIndex;
+            return true;
+        }
+    }
+    return false;
+}
+
+// start HelpLine drag for new HelpLine
+bool SdrSnapView::BegDragHelpLine(sal_uInt16 nHelpLineNum, SdrPageView* pPV)
+{
+    bool bRet(false);
+
+    BrkAction();
+
+    if(pPV && nHelpLineNum < pPV->GetHelpLines().GetCount())
+    {
+        const SdrHelpLineList& rHelpLines = pPV->GetHelpLines();
+        const SdrHelpLine& rHelpLine = rHelpLines[nHelpLineNum];
+        Point aHelpLinePos = rHelpLine.GetPos();
+        basegfx::B2DPoint aStartPos(aHelpLinePos.X(), aHelpLinePos.Y());
+
+        DBG_ASSERT(nullptr == mpHelpLineOverlay, "SdrSnapView::BegDragHelpLine: There exists an ImplHelpLineOverlay (!)");
+        mpHelpLineOverlay = new ImplHelpLineOverlay(*this, aStartPos, pPV, nHelpLineNum, rHelpLine.GetKind());
+
+        maDragStat.Reset(GetSnapPos(aHelpLinePos, pPV));
+        maDragStat.SetMinMove(ImpGetMinMovLogic(-3, nullptr));
+
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+// start HelpLine drag with existing HelpLine
+void SdrSnapView::BegDragHelpLine(const Point& rPnt, SdrHelpLineKind eNewKind)
+{
+    BrkAction();
+
+    if(GetSdrPageView())
+    {
+        DBG_ASSERT(nullptr == mpHelpLineOverlay, "SdrSnapView::BegDragHelpLine: There exists an ImplHelpLineOverlay (!)");
+        basegfx::B2DPoint aStartPos(rPnt.X(), rPnt.Y());
+        mpHelpLineOverlay = new ImplHelpLineOverlay(*this, aStartPos, nullptr, 0, eNewKind);
+        maDragStat.Reset(GetSnapPos(rPnt, nullptr));
+    }
+}
+
+PointerStyle SdrSnapView::GetDraggedHelpLinePointer() const
+{
+    if(IsDragHelpLine())
+    {
+        switch(mpHelpLineOverlay->GetHelpLineKind())
+        {
+            case SdrHelpLineKind::Vertical  : return PointerStyle::ESize;
+            case SdrHelpLineKind::Horizontal: return PointerStyle::SSize;
+            default                    : return PointerStyle::Move;
+        }
+    }
+
+    return PointerStyle::Move;
+}
+
+void SdrSnapView::MovDragHelpLine(const Point& rPnt)
+{
+    if(IsDragHelpLine() && maDragStat.CheckMinMoved(rPnt))
+    {
+        Point aPnt(GetSnapPos(rPnt, nullptr));
+
+        if(aPnt != maDragStat.GetNow())
+        {
+            maDragStat.NextMove(aPnt);
+            DBG_ASSERT(mpHelpLineOverlay, "SdrSnapView::MovDragHelpLine: no ImplHelpLineOverlay (!)");
+            basegfx::B2DPoint aNewPos(maDragStat.GetNow().X(), maDragStat.GetNow().Y());
+            mpHelpLineOverlay->SetPosition(aNewPos);
+        }
+    }
+}
+
+bool SdrSnapView::EndDragHelpLine()
+{
+    bool bRet(false);
+
+    if(IsDragHelpLine())
+    {
+        if(maDragStat.IsMinMoved())
+        {
+            SdrPageView* pPageView = mpHelpLineOverlay->GetPageView();
+
+            if(pPageView)
+            {
+                // moved existing one
+                Point aPnt(maDragStat.GetNow());
+                const SdrHelpLineList& rHelpLines = pPageView->GetHelpLines();
+                SdrHelpLine aChangedHelpLine = rHelpLines[mpHelpLineOverlay->GetHelpLineNumber()];
+                aChangedHelpLine.SetPos(aPnt);
+                pPageView->SetHelpLine(mpHelpLineOverlay->GetHelpLineNumber(), aChangedHelpLine);
+
+                bRet = true;
+            }
+            else
+            {
+                // create new one
+                pPageView = GetSdrPageView();
+
+                if(pPageView)
+                {
+                    Point aPnt(maDragStat.GetNow());
+                    SdrHelpLine aNewHelpLine(mpHelpLineOverlay->GetHelpLineKind(), aPnt);
+                    pPageView->InsertHelpLine(aNewHelpLine);
+
+                    bRet = true;
+                }
+            }
+        }
+
+        // cleanup
+        BrkDragHelpLine();
+    }
+
+    return bRet;
+}
+
+void SdrSnapView::BrkDragHelpLine()
+{
+    if(IsDragHelpLine())
+    {
+        DBG_ASSERT(mpHelpLineOverlay, "SdrSnapView::EndDragHelpLine: no ImplHelpLineOverlay (!)");
+        delete mpHelpLineOverlay;
+        mpHelpLineOverlay = nullptr;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */