/* -*- 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 <o3tl/unit_conversion.hxx>

#include <tools/bigint.hxx>

#include <tools/helpers.hxx>

#include <svx/svdopath.hxx>

#include <math.h>

#include <svx/xpoly.hxx>

#include <svx/svdtrans.hxx>

#include <svx/svddrag.hxx>

#include <svx/svdmodel.hxx>

#include <svx/svdhdl.hxx>

#include <svx/svdview.hxx>

#include <svx/dialmgr.hxx>

#include <svx/strings.hrc>

#include <svx/polypolygoneditor.hxx>

#include <sdr/contact/viewcontactofsdrpathobj.hxx>

#include <basegfx/matrix/b2dhommatrix.hxx>

#include <basegfx/point/b2dpoint.hxx>

#include <basegfx/polygon/b2dpolypolygontools.hxx>

#include <basegfx/range/b2drange.hxx>

#include <basegfx/curve/b2dcubicbezier.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <sdr/attribute/sdrtextattribute.hxx>

#include <sdr/primitive2d/sdrattributecreator.hxx>

#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include <sdr/attribute/sdrformtextattribute.hxx>

#include <utility>

#include <vcl/ptrstyle.hxx>

#include <memory>

#include <sal/log.hxx>

#include <osl/diagnose.h>

using namespace sdr;

static sal_uInt16 GetPrevPnt(sal_uInt16 nPnt, sal_uInt16 nPntMax, bool bClosed)

{

    if (nPnt>0) {

        nPnt--;

    } else {

        nPnt=nPntMax;

        if (bClosed) nPnt--;

    }

    return nPnt;

}

static sal_uInt16 GetNextPnt(sal_uInt16 nPnt, sal_uInt16 nPntMax, bool bClosed)

{

    nPnt++;

    if (nPnt>nPntMax || (bClosed && nPnt>=nPntMax)) nPnt=0;

    return nPnt;

}

namespace {

struct ImpSdrPathDragData  : public SdrDragStatUserData

{

    XPolygon                    aXP;            // section of the original polygon

    bool                        bValid;         // FALSE = too few points

    bool                        bClosed;        // closed object?

    sal_uInt16                  nPoly;          // number of the polygon in the PolyPolygon

    sal_uInt16                  nPnt;           // number of point in the above polygon

    sal_uInt16                  nPointCount;    // number of points of the polygon

    bool                        bBegPnt;        // dragged point is first point of a Polyline

    bool                        bEndPnt;        // dragged point is finishing point of a Polyline

    sal_uInt16                  nPrevPnt;       // index of previous point

    sal_uInt16                  nNextPnt;       // index of next point

    bool                        bPrevIsBegPnt;  // previous point is first point of a Polyline

    bool                        bNextIsEndPnt;  // next point is first point of a Polyline

    sal_uInt16                  nPrevPrevPnt;   // index of point before previous point

    sal_uInt16                  nNextNextPnt;   // index of point after next point

    bool                        bControl;       // point is a control point

    bool                        bIsNextControl; // point is a control point after a support point

    bool                        bPrevIsControl; // if nPnt is a support point: a control point comes before

    bool                        bNextIsControl; // if nPnt is a support point: a control point comes after

    sal_uInt16                  nPrevPrevPnt0;

    sal_uInt16                  nPrevPnt0;

    sal_uInt16                  nPnt0;

    sal_uInt16                  nNextPnt0;

    sal_uInt16                  nNextNextPnt0;

    bool                        bEliminate;     // delete point? (is set by MovDrag)

    bool                        mbMultiPointDrag;

    const XPolyPolygon          maOrig;

    XPolyPolygon                maMove;

    std::vector<SdrHdl*>        maHandles;

public:

    ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl, bool bMuPoDr, const SdrDragStat& rDrag);

    void ResetPoly(const SdrPathObj& rPO);

    bool IsMultiPointDrag() const { return mbMultiPointDrag; }

};

}

ImpSdrPathDragData::ImpSdrPathDragData(const SdrPathObj& rPO, const SdrHdl& rHdl, bool bMuPoDr, const SdrDragStat& rDrag)

    : aXP(5)

    , bValid(false)

    , bClosed(false)

    , nPoly(0)

    , nPnt(0)

    , nPointCount(0)

    , bBegPnt(false)

    , bEndPnt(false)

    , nPrevPnt(0)

    , nNextPnt(0)

    , bPrevIsBegPnt(false)

    , bNextIsEndPnt(false)

    , nPrevPrevPnt(0)

    , nNextNextPnt(0)

    , bControl(false)

    , bIsNextControl(false)

    , bPrevIsControl(false)

    , bNextIsControl(false)

    , nPrevPrevPnt0(0)

    , nPrevPnt0(0)

    , nPnt0(0)

    , nNextPnt0(0)

    , nNextNextPnt0(0)

    , bEliminate(false)

    , mbMultiPointDrag(bMuPoDr)

    , maOrig(rPO.GetPathPoly())

    , maHandles(0)

{

    if(mbMultiPointDrag)

    {

        const SdrMarkView& rMarkView = *rDrag.GetView();

        const SdrHdlList& rHdlList = rMarkView.GetHdlList();

        const size_t nHdlCount = rHdlList.GetHdlCount();

        const SdrObject* pInteractionObject(nHdlCount && rHdlList.GetHdl(0) ? rHdlList.GetHdl(0)->GetObj() : nullptr);

        for(size_t a = 0; a < nHdlCount; ++a)

        {

            SdrHdl* pTestHdl = rHdlList.GetHdl(a);

            if(pTestHdl && pTestHdl->IsSelected() && pTestHdl->GetObj() == pInteractionObject)

            {

                maHandles.push_back(pTestHdl);

            }

        }

        maMove = maOrig;

        bValid = true;

    }

    else

    {

        sal_uInt16 nPntMax = 0; // maximum index

        bValid=false;

        bClosed=rPO.IsClosed();          // closed object?

        nPoly=static_cast<sal_uInt16>(rHdl.GetPolyNum());            // number of the polygon in the PolyPolygon

        nPnt=static_cast<sal_uInt16>(rHdl.GetPointNum());            // number of points in the above polygon

        const XPolygon aTmpXP(rPO.GetPathPoly().getB2DPolygon(nPoly));

        nPointCount=aTmpXP.GetPointCount();        // number of point of the polygon

        if (nPointCount==0 || (bClosed && nPointCount==1)) return; // minimum of 1 points for Lines, minimum of 2 points for Polygon

        nPntMax=nPointCount-1;                  // maximum index

        bBegPnt=!bClosed && nPnt==0;        // dragged point is first point of a Polyline

        bEndPnt=!bClosed && nPnt==nPntMax;  // dragged point is finishing point of a Polyline

        if (bClosed && nPointCount<=3) {        // if polygon is only a line

            bBegPnt=(nPointCount<3) || nPnt==0;

            bEndPnt=(nPointCount<3) || nPnt==nPntMax-1;

        }

        nPrevPnt=nPnt;                      // index of previous point

        nNextPnt=nPnt;                      // index of next point

        if (!bBegPnt) nPrevPnt=GetPrevPnt(nPnt,nPntMax,bClosed);

        if (!bEndPnt) nNextPnt=GetNextPnt(nPnt,nPntMax,bClosed);

        bPrevIsBegPnt=bBegPnt || (!bClosed && nPrevPnt==0);

        bNextIsEndPnt=bEndPnt || (!bClosed && nNextPnt==nPntMax);

        nPrevPrevPnt=nPnt;                  // index of point before previous point

        nNextNextPnt=nPnt;                  // index of point after next point

        if (!bPrevIsBegPnt) nPrevPrevPnt=GetPrevPnt(nPrevPnt,nPntMax,bClosed);

        if (!bNextIsEndPnt) nNextNextPnt=GetNextPnt(nNextPnt,nPntMax,bClosed);

        bControl=rHdl.IsPlusHdl();          // point is a control point

        bIsNextControl=false;               // point is a control point after a support point

        bPrevIsControl=false;               // if nPnt is a support point: a control point comes before

        bNextIsControl=false;               // if nPnt is a support point: a control point comes after

        if (bControl) {

            bIsNextControl=!aTmpXP.IsControl(nPrevPnt);

        } else {

            bPrevIsControl=!bBegPnt && !bPrevIsBegPnt && aTmpXP.GetFlags(nPrevPnt)==PolyFlags::Control;

            bNextIsControl=!bEndPnt && !bNextIsEndPnt && aTmpXP.GetFlags(nNextPnt)==PolyFlags::Control;

        }

        nPrevPrevPnt0=nPrevPrevPnt;

        nPrevPnt0    =nPrevPnt;

        nPnt0        =nPnt;

        nNextPnt0    =nNextPnt;

        nNextNextPnt0=nNextNextPnt;

        nPrevPrevPnt=0;

        nPrevPnt=1;

        nPnt=2;

        nNextPnt=3;

        nNextNextPnt=4;

        bEliminate=false;

        ResetPoly(rPO);

        bValid=true;

    }

}

void ImpSdrPathDragData::ResetPoly(const SdrPathObj& rPO)

{

    const XPolygon aTmpXP(rPO.GetPathPoly().getB2DPolygon(nPoly));

    aXP[0]=aTmpXP[nPrevPrevPnt0];  aXP.SetFlags(0,aTmpXP.GetFlags(nPrevPrevPnt0));

    aXP[1]=aTmpXP[nPrevPnt0];      aXP.SetFlags(1,aTmpXP.GetFlags(nPrevPnt0));

    aXP[2]=aTmpXP[nPnt0];          aXP.SetFlags(2,aTmpXP.GetFlags(nPnt0));

    aXP[3]=aTmpXP[nNextPnt0];      aXP.SetFlags(3,aTmpXP.GetFlags(nNextPnt0));

    aXP[4]=aTmpXP[nNextNextPnt0];  aXP.SetFlags(4,aTmpXP.GetFlags(nNextNextPnt0));

}

namespace {

struct ImpPathCreateUser  : public SdrDragStatUserData

{

    Point                   aBezControl0;

    Point                   aBezStart;

    Point                   aBezCtrl1;

    Point                   aBezCtrl2;

    Point                   aBezEnd;

    Point                   aCircStart;

    Point                   aCircEnd;

    Point                   aCircCenter;

    Point                   aLineStart;

    Point                   aLineEnd;

    Point                   aRectP1;

    Point                   aRectP2;

    Point                   aRectP3;

    tools::Long                    nCircRadius;

    Degree100               nCircStAngle;

    Degree100               nCircRelAngle;

    bool                    bBezier;

    bool                    bBezHasCtrl0;

    bool                    bCircle;

    bool                    bAngleSnap;

    bool                    bLine;

    bool                    bLine90;

    bool                    bRect;

    bool                    bMixedCreate;

    sal_uInt16                  nBezierStartPoint;

    SdrObjKind              eStartKind;

    SdrObjKind              eCurrentKind;

public:

    ImpPathCreateUser(): nCircRadius(0),nCircStAngle(0),nCircRelAngle(0),

        bBezier(false),bBezHasCtrl0(false),bCircle(false),bAngleSnap(false),bLine(false),bLine90(false),bRect(false),

        bMixedCreate(false),nBezierStartPoint(0),eStartKind(SdrObjKind::NONE),eCurrentKind(SdrObjKind::NONE) { }

    void ResetFormFlags() { bBezier=false; bCircle=false; bLine=false; bRect=false; }

    bool IsFormFlag() const { return bBezier || bCircle || bLine || bRect; }

    XPolygon GetFormPoly() const;

    void CalcBezier(const Point& rP1, const Point& rP2, const Point& rDir, bool bMouseDown);

    XPolygon GetBezierPoly() const;

    void CalcCircle(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView);

    XPolygon GetCirclePoly() const;

    void CalcLine(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView);

    static Point    CalcLine(const Point& rCsr, tools::Long nDirX, tools::Long nDirY, SdrView const * pView);

    XPolygon GetLinePoly() const;

    void CalcRect(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView);

    XPolygon GetRectPoly() const;

};

}

XPolygon ImpPathCreateUser::GetFormPoly() const

{

    if (bBezier) return GetBezierPoly();

    if (bCircle) return GetCirclePoly();

    if (bLine)   return GetLinePoly();

    if (bRect)   return GetRectPoly();

    return XPolygon();

}

void ImpPathCreateUser::CalcBezier(const Point& rP1, const Point& rP2, const Point& rDir, bool bMouseDown)

{

    aBezStart=rP1;

    aBezCtrl1=rP1+rDir;

    aBezCtrl2=rP2;

    // #i21479#

    // Also copy the end point when no end point is set yet

    if (!bMouseDown || (0 == aBezEnd.X() && 0 == aBezEnd.Y())) aBezEnd=rP2;

    bBezier=true;

}

XPolygon ImpPathCreateUser::GetBezierPoly() const

{

    XPolygon aXP(4);

    aXP[0]=aBezStart; aXP.SetFlags(0,PolyFlags::Smooth);

    aXP[1]=aBezCtrl1; aXP.SetFlags(1,PolyFlags::Control);

    aXP[2]=aBezCtrl2; aXP.SetFlags(2,PolyFlags::Control);

    aXP[3]=aBezEnd;

    return aXP;

}

void ImpPathCreateUser::CalcCircle(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView)

{

    Degree100 nTangAngle=GetAngle(rDir);

    aCircStart=rP1;

    aCircEnd=rP2;

    aCircCenter=rP1;

    tools::Long dx=rP2.X()-rP1.X();

    tools::Long dy=rP2.Y()-rP1.Y();

    Degree100 dAngle=GetAngle(Point(dx,dy))-nTangAngle;

    dAngle=NormAngle36000(dAngle);

    Degree100 nTmpAngle=NormAngle36000(9000_deg100-dAngle);

    bool bRet=nTmpAngle!=9000_deg100 && nTmpAngle!=27000_deg100;

    tools::Long nRad=0;

    if (bRet) {

        double cs = cos(toRadians(nTmpAngle));

        double nR=static_cast<double>(GetLen(Point(dx,dy)))/cs/2;

        nRad = std::abs(basegfx::fround<tools::Long>(nR));

    }

    if (dAngle<18000_deg100) {

        nCircStAngle=NormAngle36000(nTangAngle-9000_deg100);

        nCircRelAngle=NormAngle36000(2_deg100*dAngle);

        aCircCenter.AdjustX(basegfx::fround<tools::Long>(nRad * cos(toRadians(nTangAngle + 9000_deg100))));

        aCircCenter.AdjustY(basegfx::fround<tools::Long>(nRad * -sin(toRadians(nTangAngle + 9000_deg100))));

    } else {

        nCircStAngle=NormAngle36000(nTangAngle+9000_deg100);

        nCircRelAngle=-NormAngle36000(36000_deg100-2_deg100*dAngle);

        aCircCenter.AdjustX(basegfx::fround<tools::Long>(nRad * cos(toRadians(nTangAngle - 9000_deg100))));

        aCircCenter.AdjustY(basegfx::fround<tools::Long>(nRad * -sin(toRadians(nTangAngle - 9000_deg100))));

    }

    bAngleSnap=pView!=nullptr && pView->IsAngleSnapEnabled();

    if (bAngleSnap) {

        Degree100 nSA=pView->GetSnapAngle();

        if (nSA) { // angle snapping

            bool bNeg=nCircRelAngle<0_deg100;

            if (bNeg) nCircRelAngle=-nCircRelAngle;

            nCircRelAngle+=nSA/2_deg100;

            nCircRelAngle/=nSA;

            nCircRelAngle*=nSA;

            nCircRelAngle=NormAngle36000(nCircRelAngle);

            if (bNeg) nCircRelAngle=-nCircRelAngle;

        }

    }

    nCircRadius=nRad;

    if (nRad==0 || abs(nCircRelAngle).get()<5) bRet=false;

    bCircle=bRet;

}

XPolygon ImpPathCreateUser::GetCirclePoly() const

{

    if (nCircRelAngle>=0_deg100) {

        XPolygon aXP(aCircCenter,nCircRadius,nCircRadius,

                     nCircStAngle, nCircStAngle+nCircRelAngle,false);

        aXP[0]=aCircStart; aXP.SetFlags(0,PolyFlags::Smooth);

        if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd;

        return aXP;

    } else {

        XPolygon aXP(aCircCenter,nCircRadius,nCircRadius,

                     NormAngle36000(nCircStAngle+nCircRelAngle), nCircStAngle,false);

        sal_uInt16 nCount=aXP.GetPointCount();

        for (sal_uInt16 nNum=nCount/2; nNum>0;) {

            nNum--; // reverse XPoly's order of points

            sal_uInt16 n2=nCount-nNum-1;

            Point aPt(aXP[nNum]);

            aXP[nNum]=aXP[n2];

            aXP[n2]=aPt;

        }

        aXP[0]=aCircStart; aXP.SetFlags(0,PolyFlags::Smooth);

        if (!bAngleSnap) aXP[aXP.GetPointCount()-1]=aCircEnd;

        return aXP;

    }

}

Point ImpPathCreateUser::CalcLine(const Point& aCsr, tools::Long nDirX, tools::Long nDirY, SdrView const * pView)

{

    tools::Long x=aCsr.X();

    tools::Long y=aCsr.Y();

    bool bHLin=nDirY==0;

    bool bVLin=nDirX==0;

    if (bHLin) y=0;

    else if (bVLin) x=0;

    else {

        tools::Long x2=BigMulDiv(y,nDirX,nDirY);

        tools::Long y2=BigMulDiv(x,nDirY,nDirX);

        tools::Long l1=std::abs(x2)+std::abs(y);

        tools::Long l2=std::abs(x)+std::abs(y2);

        if ((l1<=l2) != (pView!=nullptr && pView->IsBigOrtho())) {

            x = x2;

        } else {

            y = y2;

        }

    }

    return Point(x,y);

}

void ImpPathCreateUser::CalcLine(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView)

{

    aLineStart=rP1;

    aLineEnd=rP2;

    bLine90=false;

    if (rP1==rP2 || (rDir.X()==0 && rDir.Y()==0)) { bLine=false; return; }

    Point aTmpPt(rP2-rP1);

    tools::Long nDirX=rDir.X();

    tools::Long nDirY=rDir.Y();

    Point aP1(CalcLine(aTmpPt, nDirX, nDirY,pView)); aP1-=aTmpPt; tools::Long nQ1=std::abs(aP1.X())+std::abs(aP1.Y());

    Point aP2(CalcLine(aTmpPt, nDirY,-nDirX,pView)); aP2-=aTmpPt; tools::Long nQ2=std::abs(aP2.X())+std::abs(aP2.Y());

    if (pView!=nullptr && pView->IsOrtho()) nQ1=0; // Ortho turns off at right angle

    bLine90=nQ1>2*nQ2;

    if (!bLine90) { // smooth transition

        aLineEnd+=aP1;

    } else {          // rectangular transition

        aLineEnd+=aP2;

    }

    bLine=true;

}

XPolygon ImpPathCreateUser::GetLinePoly() const

{

    XPolygon aXP(2);

    aXP[0]=aLineStart; if (!bLine90) aXP.SetFlags(0,PolyFlags::Smooth);

    aXP[1]=aLineEnd;

    return aXP;

}

void ImpPathCreateUser::CalcRect(const Point& rP1, const Point& rP2, const Point& rDir, SdrView const * pView)

{

    aRectP1=rP1;

    aRectP2=rP1;

    aRectP3=rP2;

    if (rP1==rP2 || (rDir.X()==0 && rDir.Y()==0)) { bRect=false; return; }

    Point aTmpPt(rP2-rP1);

    tools::Long nDirX=rDir.X();

    tools::Long nDirY=rDir.Y();

    tools::Long x=aTmpPt.X();

    tools::Long y=aTmpPt.Y();

    bool bHLin=nDirY==0;

    bool bVLin=nDirX==0;

    if (bHLin) y=0;

    else if (bVLin) x=0;

    else {

        y=BigMulDiv(x,nDirY,nDirX);

        tools::Long nHypLen=aTmpPt.Y()-y;

        Degree100 nTangAngle=-GetAngle(rDir);

        // sin=g/h, g=h*sin

        double a = toRadians(nTangAngle);

        double sn=sin(a);

        double cs=cos(a);

        double nGKathLen=nHypLen*sn;

        y += basegfx::fround<tools::Long>(nGKathLen * sn);

        x += basegfx::fround<tools::Long>(nGKathLen * cs);

    }

    aRectP2.AdjustX(x );

    aRectP2.AdjustY(y );

    if (pView!=nullptr && pView->IsOrtho()) {

        tools::Long dx1=aRectP2.X()-aRectP1.X(); tools::Long dx1a=std::abs(dx1);

        tools::Long dy1=aRectP2.Y()-aRectP1.Y(); tools::Long dy1a=std::abs(dy1);

        tools::Long dx2=aRectP3.X()-aRectP2.X(); tools::Long dx2a=std::abs(dx2);

        tools::Long dy2=aRectP3.Y()-aRectP2.Y(); tools::Long dy2a=std::abs(dy2);

        bool b1MoreThan2=dx1a+dy1a>dx2a+dy2a;

        if (b1MoreThan2 != pView->IsBigOrtho()) {

            tools::Long xtemp=dy2a-dx1a; if (dx1<0) xtemp=-xtemp;

            tools::Long ytemp=dx2a-dy1a; if (dy1<0) ytemp=-ytemp;

            aRectP2.AdjustX(xtemp );

            aRectP2.AdjustY(ytemp );

            aRectP3.AdjustX(xtemp );

            aRectP3.AdjustY(ytemp );

        } else {

            tools::Long xtemp=dy1a-dx2a; if (dx2<0) xtemp=-xtemp;

            tools::Long ytemp=dx1a-dy2a; if (dy2<0) ytemp=-ytemp;

            aRectP3.AdjustX(xtemp );

            aRectP3.AdjustY(ytemp );

        }

    }

    bRect=true;

}

XPolygon ImpPathCreateUser::GetRectPoly() const

{

    XPolygon aXP(3);

    aXP[0]=aRectP1; aXP.SetFlags(0,PolyFlags::Smooth);

    aXP[1]=aRectP2;

    if (aRectP3!=aRectP2) aXP[2]=aRectP3;

    return aXP;

}

class ImpPathForDragAndCreate

{

    SdrPathObj&                 mrSdrPathObject;

    XPolyPolygon                aPathPolygon;

    SdrObjKind                  meObjectKind;

    std::unique_ptr<ImpSdrPathDragData>

                                mpSdrPathDragData;

    bool                        mbCreating;

public:

    explicit ImpPathForDragAndCreate(SdrPathObj& rSdrPathObject);

    // drag stuff

    bool beginPathDrag( SdrDragStat const & rDrag )  const;

    bool movePathDrag( SdrDragStat& rDrag ) const;

    bool endPathDrag( SdrDragStat const & rDrag );

    OUString getSpecialDragComment(const SdrDragStat& rDrag) const;

    basegfx::B2DPolyPolygon getSpecialDragPoly(const SdrDragStat& rDrag) const;

    // create stuff

    void BegCreate(SdrDragStat& rStat);

    bool MovCreate(SdrDragStat& rStat);

    bool EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd);

    bool BckCreate(SdrDragStat const & rStat);

    void BrkCreate(SdrDragStat& rStat);

    PointerStyle GetCreatePointer() const;

    // helping stuff

    static bool IsClosed(SdrObjKind eKind) { return eKind==SdrObjKind::Polygon || eKind==SdrObjKind::PathPoly || eKind==SdrObjKind::PathFill || eKind==SdrObjKind::FreehandFill; }

    static bool IsFreeHand(SdrObjKind eKind) { return eKind==SdrObjKind::FreehandLine || eKind==SdrObjKind::FreehandFill; }

    static bool IsBezier(SdrObjKind eKind) { return eKind==SdrObjKind::PathLine || eKind==SdrObjKind::PathFill; }

    bool IsCreating() const { return mbCreating; }

    // get the polygon

    basegfx::B2DPolyPolygon TakeObjectPolyPolygon(const SdrDragStat& rDrag) const;

    static basegfx::B2DPolyPolygon TakeDragPolyPolygon(const SdrDragStat& rDrag);

    basegfx::B2DPolyPolygon getModifiedPolyPolygon() const { return  aPathPolygon.getB2DPolyPolygon(); }

};

ImpPathForDragAndCreate::ImpPathForDragAndCreate(SdrPathObj& rSdrPathObject)

:   mrSdrPathObject(rSdrPathObject),

    aPathPolygon(rSdrPathObject.GetPathPoly()),

    meObjectKind(mrSdrPathObject.meKind),

    mbCreating(false)

{

}

bool ImpPathForDragAndCreate::beginPathDrag( SdrDragStat const & rDrag )  const

{

    const SdrHdl* pHdl=rDrag.GetHdl();

    if(!pHdl)

        return false;

    bool bMultiPointDrag(true);

    if(aPathPolygon[static_cast<sal_uInt16>(pHdl->GetPolyNum())].IsControl(static_cast<sal_uInt16>(pHdl->GetPointNum())))

        bMultiPointDrag = false;

    if(bMultiPointDrag)

    {

        const SdrMarkView& rMarkView = *rDrag.GetView();

        const SdrHdlList& rHdlList = rMarkView.GetHdlList();

        const size_t nHdlCount = rHdlList.GetHdlCount();

        const SdrObject* pInteractionObject(nHdlCount && rHdlList.GetHdl(0) ? rHdlList.GetHdl(0)->GetObj() : nullptr);

        sal_uInt32 nSelectedPoints(0);

        for(size_t a = 0; a < nHdlCount; ++a)

        {

            SdrHdl* pTestHdl = rHdlList.GetHdl(a);

            if(pTestHdl && pTestHdl->IsSelected() && pTestHdl->GetObj() == pInteractionObject)

            {

                nSelectedPoints++;

            }

        }

        if(nSelectedPoints <= 1)

            bMultiPointDrag = false;

    }

    const_cast<ImpPathForDragAndCreate*>(this)->mpSdrPathDragData.reset( new ImpSdrPathDragData(mrSdrPathObject,*pHdl,bMultiPointDrag,rDrag) );

    if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)

    {

        OSL_FAIL("ImpPathForDragAndCreate::BegDrag(): ImpSdrPathDragData is invalid.");

        const_cast<ImpPathForDragAndCreate*>(this)->mpSdrPathDragData.reset();

        return false;

    }

    return true;

}

bool ImpPathForDragAndCreate::movePathDrag( SdrDragStat& rDrag ) const

{

    if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)

    {

        OSL_FAIL("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData is invalid.");

        return false;

    }

    if(mpSdrPathDragData->IsMultiPointDrag())

    {

        Point aDelta(rDrag.GetNow() - rDrag.GetStart());

        if(aDelta.X() || aDelta.Y())

        {

            for(SdrHdl* pHandle : mpSdrPathDragData->maHandles)

            {

                const sal_uInt16 nPolyIndex(static_cast<sal_uInt16>(pHandle->GetPolyNum()));

                const sal_uInt16 nPointIndex(static_cast<sal_uInt16>(pHandle->GetPointNum()));

                const XPolygon& rOrig = mpSdrPathDragData->maOrig[nPolyIndex];

                XPolygon& rMove = mpSdrPathDragData->maMove[nPolyIndex];

                const sal_uInt16 nPointCount(rOrig.GetPointCount());

                bool bClosed(rOrig[0] == rOrig[nPointCount-1]);

                // move point itself

                rMove[nPointIndex] = rOrig[nPointIndex] + aDelta;

                // when point is first and poly closed, move close point, too.

                if(nPointCount > 0 && !nPointIndex && bClosed)

                {

                    rMove[nPointCount - 1] = rOrig[nPointCount - 1] + aDelta;

                    // when moving the last point it may be necessary to move the

                    // control point in front of this one, too.

                    if(nPointCount > 1 && rOrig.IsControl(nPointCount - 2))

                        rMove[nPointCount - 2] = rOrig[nPointCount - 2] + aDelta;

                }

                // is a control point before this?

                if(nPointIndex > 0 && rOrig.IsControl(nPointIndex - 1))

                {

                    // Yes, move it, too

                    rMove[nPointIndex - 1] = rOrig[nPointIndex - 1] + aDelta;

                }

                // is a control point after this?

                if(nPointIndex + 1 < nPointCount && rOrig.IsControl(nPointIndex + 1))

                {

                    // Yes, move it, too

                    rMove[nPointIndex + 1] = rOrig[nPointIndex + 1] + aDelta;

                }

            }

        }

    }

    else

    {

        mpSdrPathDragData->ResetPoly(mrSdrPathObject);

        // copy certain data locally to use less code and have faster access times

        bool bClosed           =mpSdrPathDragData->bClosed       ; // closed object?

        sal_uInt16   nPnt          =mpSdrPathDragData->nPnt          ; // number of point in the above polygon

        bool bBegPnt           =mpSdrPathDragData->bBegPnt       ; // dragged point is first point of a Polyline

        bool bEndPnt           =mpSdrPathDragData->bEndPnt       ; // dragged point is last point of a Polyline

        sal_uInt16   nPrevPnt      =mpSdrPathDragData->nPrevPnt      ; // index of previous point

        sal_uInt16   nNextPnt      =mpSdrPathDragData->nNextPnt      ; // index of next point

        bool bPrevIsBegPnt     =mpSdrPathDragData->bPrevIsBegPnt ; // previous point is first point of a Polyline

        bool bNextIsEndPnt     =mpSdrPathDragData->bNextIsEndPnt ; // next point is last point of a Polyline

        sal_uInt16   nPrevPrevPnt  =mpSdrPathDragData->nPrevPrevPnt  ; // index of the point before the previous point

        sal_uInt16   nNextNextPnt  =mpSdrPathDragData->nNextNextPnt  ; // index if the point after the next point

        bool bControl          =mpSdrPathDragData->bControl      ; // point is a control point

        bool bIsNextControl    =mpSdrPathDragData->bIsNextControl; // point is a control point after a support point

        bool bPrevIsControl    =mpSdrPathDragData->bPrevIsControl; // if nPnt is a support point: there's a control point before

        bool bNextIsControl    =mpSdrPathDragData->bNextIsControl; // if nPnt is a support point: there's a control point after

        // Ortho for lines/polygons: keep angle

        if (!bControl && rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho()) {

            bool bBigOrtho=rDrag.GetView()->IsBigOrtho();

            Point  aPos(rDrag.GetNow());      // current position

            Point  aPnt(mpSdrPathDragData->aXP[nPnt]);      // the dragged point

            sal_uInt16 nPnt1=0xFFFF,nPnt2=0xFFFF; // its neighboring points

            Point  aNewPos1,aNewPos2;         // new alternative for aPos

            bool bPnt1 = false, bPnt2 = false; // are these valid alternatives?

            if (!bClosed && mpSdrPathDragData->nPointCount>=2) { // minimum of 2 points for lines

                if (!bBegPnt) nPnt1=nPrevPnt;

                if (!bEndPnt) nPnt2=nNextPnt;

            }

            if (bClosed && mpSdrPathDragData->nPointCount>=3) { // minimum of 3 points for polygon

                nPnt1=nPrevPnt;

                nPnt2=nNextPnt;

            }

            if (nPnt1!=0xFFFF && !bPrevIsControl) {

                Point aPnt1=mpSdrPathDragData->aXP[nPnt1];

                tools::Long ndx0=aPnt.X()-aPnt1.X();

                tools::Long ndy0=aPnt.Y()-aPnt1.Y();

                bool bHLin=ndy0==0;

                bool bVLin=ndx0==0;

                if (!bHLin || !bVLin) {

                    tools::Long ndx=aPos.X()-aPnt1.X();

                    tools::Long ndy=aPos.Y()-aPnt1.Y();

                    bPnt1=true;

                    double nXFact=0; if (!bVLin) nXFact=static_cast<double>(ndx)/static_cast<double>(ndx0);

                    double nYFact=0; if (!bHLin) nYFact=static_cast<double>(ndy)/static_cast<double>(ndy0);

                    bool bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho);

                    bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho);

                    if (bHor) ndy=tools::Long(ndy0*nXFact);

                    if (bVer) ndx=tools::Long(ndx0*nYFact);

                    aNewPos1=aPnt1;

                    aNewPos1.AdjustX(ndx );

                    aNewPos1.AdjustY(ndy );

                }

            }

            if (nPnt2!=0xFFFF && !bNextIsControl) {

                Point aPnt2=mpSdrPathDragData->aXP[nPnt2];

                tools::Long ndx0=aPnt.X()-aPnt2.X();

                tools::Long ndy0=aPnt.Y()-aPnt2.Y();

                bool bHLin=ndy0==0;

                bool bVLin=ndx0==0;

                if (!bHLin || !bVLin) {

                    tools::Long ndx=aPos.X()-aPnt2.X();

                    tools::Long ndy=aPos.Y()-aPnt2.Y();

                    bPnt2=true;

                    double nXFact=0; if (!bVLin) nXFact=static_cast<double>(ndx)/static_cast<double>(ndx0);

                    double nYFact=0; if (!bHLin) nYFact=static_cast<double>(ndy)/static_cast<double>(ndy0);

                    bool bHor=bHLin || (!bVLin && (nXFact>nYFact) ==bBigOrtho);

                    bool bVer=bVLin || (!bHLin && (nXFact<=nYFact)==bBigOrtho);

                    if (bHor) ndy=tools::Long(ndy0*nXFact);

                    if (bVer) ndx=tools::Long(ndx0*nYFact);

                    aNewPos2=aPnt2;

                    aNewPos2.AdjustX(ndx );

                    aNewPos2.AdjustY(ndy );

                }

            }

            if (bPnt1 && bPnt2) { // both alternatives exist (and compete)

                BigInt nX1(aNewPos1.X()-aPos.X()); nX1*=nX1;

                BigInt nY1(aNewPos1.Y()-aPos.Y()); nY1*=nY1;

                BigInt nX2(aNewPos2.X()-aPos.X()); nX2*=nX2;

                BigInt nY2(aNewPos2.Y()-aPos.Y()); nY2*=nY2;

                nX1+=nY1; // correction distance to square

                nX2+=nY2; // correction distance to square

                // let the alternative that allows fewer correction win

                if (nX1<nX2) bPnt2=false; else bPnt1=false;

            }

            if (bPnt1) rDrag.SetNow(aNewPos1);

            if (bPnt2) rDrag.SetNow(aNewPos2);

        }

        rDrag.SetActionRect(tools::Rectangle(rDrag.GetNow(),rDrag.GetNow()));

        // specially for IBM: Eliminate points if both adjoining lines form near 180 degrees angle anyway

        if (!bControl && rDrag.GetView()!=nullptr && rDrag.GetView()->IsEliminatePolyPoints() &&

            !bBegPnt && !bEndPnt && !bPrevIsControl && !bNextIsControl)

        {

            Point aPt(mpSdrPathDragData->aXP[nNextPnt]);

            aPt-=rDrag.GetNow();

            Degree100 nAngle1=GetAngle(aPt);

            aPt=rDrag.GetNow();

            aPt-=mpSdrPathDragData->aXP[nPrevPnt];

            Degree100 nAngle2=GetAngle(aPt);

            Degree100 nDiff=nAngle1-nAngle2;

            nDiff=abs(nDiff);

            mpSdrPathDragData->bEliminate=nDiff<=rDrag.GetView()->GetEliminatePolyPointLimitAngle();

            if (mpSdrPathDragData->bEliminate) { // adapt position, Smooth is true for the ends

                aPt=mpSdrPathDragData->aXP[nNextPnt];

                aPt+=mpSdrPathDragData->aXP[nPrevPnt];

                aPt/=2;

                rDrag.SetNow(aPt);

            }

        }

        // we dragged by this distance

        Point aDiff(rDrag.GetNow()); aDiff-=mpSdrPathDragData->aXP[nPnt];

        /* There are 8 possible cases:

              X      1. A control point neither on the left nor on the right.

           o--X--o   2. There are control points on the left and the right, we are dragging a support point.

           o--X      3. There is a control point on the left, we are dragging a support point.

              X--o   4. There is a control point on the right, we are dragging a support point.

           x--O--o   5. There are control points on the left and the right, we are dragging the left one.

           x--O      6. There is a control point on the left, we are dragging it.

           o--O--x   7. There are control points on the left and the right, we are dragging the right one.

              O--x   8. There is a control point on the right, we are dragging it.

           Note: modifying a line (not a curve!) might create a curve on the other end of the line

           if Smooth is set there (with control points aligned to line).

        */

        mpSdrPathDragData->aXP[nPnt]+=aDiff;

        // now check symmetric plus handles

        if (bControl) { // cases 5,6,7,8

            sal_uInt16   nSt; // the associated support point

            sal_uInt16   nFix;  // the opposing control point

            if (bIsNextControl) { // if the next one is a control point, the on before has to be a support point

                nSt=nPrevPnt;

                nFix=nPrevPrevPnt;

            } else {

                nSt=nNextPnt;

                nFix=nNextNextPnt;

            }

            if (mpSdrPathDragData->aXP.IsSmooth(nSt)) {

                mpSdrPathDragData->aXP.CalcSmoothJoin(nSt,nPnt,nFix);

            }

        }

        if (!bControl) { // Cases 1,2,3,4. In case 1, nothing happens; in cases 3 and 4, there is more following below.

            // move both control points

            if (bPrevIsControl) mpSdrPathDragData->aXP[nPrevPnt]+=aDiff;

            if (bNextIsControl) mpSdrPathDragData->aXP[nNextPnt]+=aDiff;

            // align control point to line, if appropriate

            if (mpSdrPathDragData->aXP.IsSmooth(nPnt)) {

                if (bPrevIsControl && !bNextIsControl && !bEndPnt) { // case 3

                    mpSdrPathDragData->aXP.CalcSmoothJoin(nPnt,nNextPnt,nPrevPnt);

                }

                if (bNextIsControl && !bPrevIsControl && !bBegPnt) { // case 4

                    mpSdrPathDragData->aXP.CalcSmoothJoin(nPnt,nPrevPnt,nNextPnt);

                }

            }

            // Now check the other ends of the line (nPnt+-1). If there is a

            // curve (IsControl(nPnt+-2)) with SmoothJoin (nPnt+-1), the

            // associated control point (nPnt+-2) has to be adapted.

            if (!bBegPnt && !bPrevIsControl && !bPrevIsBegPnt && mpSdrPathDragData->aXP.IsSmooth(nPrevPnt)) {

                if (mpSdrPathDragData->aXP.IsControl(nPrevPrevPnt)) {

                    mpSdrPathDragData->aXP.CalcSmoothJoin(nPrevPnt,nPnt,nPrevPrevPnt);

                }

            }

            if (!bEndPnt && !bNextIsControl && !bNextIsEndPnt && mpSdrPathDragData->aXP.IsSmooth(nNextPnt)) {

                if (mpSdrPathDragData->aXP.IsControl(nNextNextPnt)) {

                    mpSdrPathDragData->aXP.CalcSmoothJoin(nNextPnt,nPnt,nNextNextPnt);

                }

            }

        }

    }

    return true;

}

bool ImpPathForDragAndCreate::endPathDrag(SdrDragStat const & rDrag)

{

    Point aLinePt1;

    Point aLinePt2;

    bool bLineGlueMirror(SdrObjKind::Line == meObjectKind);

    if (bLineGlueMirror) {

        XPolygon& rXP=aPathPolygon[0];

        aLinePt1=rXP[0];

        aLinePt2=rXP[1];

    }

    if(!mpSdrPathDragData || !mpSdrPathDragData->bValid)

    {

        OSL_FAIL("ImpPathForDragAndCreate::MovDrag(): ImpSdrPathDragData is invalid.");

        return false;

    }

    if(mpSdrPathDragData->IsMultiPointDrag())

    {

        aPathPolygon = mpSdrPathDragData->maMove;

    }

    else

    {

        const SdrHdl* pHdl=rDrag.GetHdl();

        // reference the polygon

        XPolygon& rXP=aPathPolygon[static_cast<sal_uInt16>(pHdl->GetPolyNum())];

        // the 5 points that might have changed

        if (!mpSdrPathDragData->bPrevIsBegPnt) rXP[mpSdrPathDragData->nPrevPrevPnt0]=mpSdrPathDragData->aXP[mpSdrPathDragData->nPrevPrevPnt];

        if (!mpSdrPathDragData->bNextIsEndPnt) rXP[mpSdrPathDragData->nNextNextPnt0]=mpSdrPathDragData->aXP[mpSdrPathDragData->nNextNextPnt];

        if (!mpSdrPathDragData->bBegPnt)       rXP[mpSdrPathDragData->nPrevPnt0]    =mpSdrPathDragData->aXP[mpSdrPathDragData->nPrevPnt];

        if (!mpSdrPathDragData->bEndPnt)       rXP[mpSdrPathDragData->nNextPnt0]    =mpSdrPathDragData->aXP[mpSdrPathDragData->nNextPnt];

        rXP[mpSdrPathDragData->nPnt0]        =mpSdrPathDragData->aXP[mpSdrPathDragData->nPnt];

        // for closed objects: last point has to be equal to first point

        if (mpSdrPathDragData->bClosed) rXP[rXP.GetPointCount()-1]=rXP[0];

        if (mpSdrPathDragData->bEliminate)

        {

            basegfx::B2DPolyPolygon aTempPolyPolygon(aPathPolygon.getB2DPolyPolygon());

            sal_uInt32 nPoly,nPnt;

            if(PolyPolygonEditor::GetRelativePolyPoint(aTempPolyPolygon, rDrag.GetHdl()->GetSourceHdlNum(), nPoly, nPnt))

            {

                basegfx::B2DPolygon aCandidate(aTempPolyPolygon.getB2DPolygon(nPoly));

                aCandidate.remove(nPnt);

                if(aCandidate.count() < 2)

                {

                    aTempPolyPolygon.remove(nPoly);

                }