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

#include <svx/strings.hrc>

#include <basegfx/matrix/b2dhommatrix.hxx>

#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include <basegfx/point/b2dpoint.hxx>

#include <basegfx/polygon/b2dpolygon.hxx>

#include <basegfx/polygon/b2dpolypolygon.hxx>

#include <editeng/editdata.hxx>

#include <editeng/editobj.hxx>

#include <editeng/eeitem.hxx>

#include <editeng/flditem.hxx>

#include <editeng/measfld.hxx>

#include <editeng/outlobj.hxx>

#include <math.h>

#include <svl/style.hxx>

#include <sdr/contact/viewcontactofsdrmeasureobj.hxx>

#include <sdr/properties/measureproperties.hxx>

#include <svx/svddrag.hxx>

#include <svx/svdhdl.hxx>

#include <svx/svdmodel.hxx>

#include <svx/svdogrp.hxx>

#include <svx/svdomeas.hxx>

#include <svx/svdopath.hxx>

#include <svx/svdoutl.hxx>

#include <svx/svdpage.hxx>

#include <svx/svdtrans.hxx>

#include <svx/svdview.hxx>

#include <svx/sxmbritm.hxx>

#include <svx/sxmlhitm.hxx>

#include <sxmsitm.hxx>

#include <sxmtaitm.hxx>

#include <svx/sxmtfitm.hxx>

#include <svx/sxmtpitm.hxx>

#include <svx/sxmtritm.hxx>

#include <svx/sxmuitm.hxx>

#include <svx/xlnedcit.hxx>

#include <svx/xlnedit.hxx>

#include <svx/xlnedwit.hxx>

#include <svx/xlnstcit.hxx>

#include <svx/xlnstit.hxx>

#include <svx/xlnstwit.hxx>

#include <svx/xlnwtit.hxx>

#include <svx/xpoly.hxx>

#include <unotools/syslocale.hxx>

#include <unotools/localedatawrapper.hxx>

#include <vcl/ptrstyle.hxx>

SdrMeasureObjGeoData::SdrMeasureObjGeoData() {}

SdrMeasureObjGeoData::~SdrMeasureObjGeoData() {}

OUString SdrMeasureObj::TakeRepresentation(SdrMeasureFieldKind eMeasureFieldKind) const

{

    OUString aStr;

    double fMeasureScale = 1.0;

    bool bTextRota90(false);

    bool bShowUnit(false);

    FieldUnit eMeasureUnit(FieldUnit::NONE);

    FieldUnit eModUIUnit(FieldUnit::NONE);

    const SfxItemSet& rSet = GetMergedItemSet();

    bTextRota90 = rSet.Get(SDRATTR_MEASURETEXTROTA90).GetValue();

    eMeasureUnit = rSet.Get(SDRATTR_MEASUREUNIT).GetValue();

    fMeasureScale = rSet.Get(SDRATTR_MEASURESCALE).GetValue();

    bShowUnit = rSet.Get(SDRATTR_MEASURESHOWUNIT).GetValue();

    sal_Int16 nNumDigits = rSet.Get(SDRATTR_MEASUREDECIMALPLACES).GetValue();

    switch(eMeasureFieldKind)

    {

        case SdrMeasureFieldKind::Value:

        {

            eModUIUnit = getSdrModelFromSdrObject().GetUIUnit();

            if(eMeasureUnit == FieldUnit::NONE)

                eMeasureUnit = eModUIUnit;

            sal_Int32 nLen(GetLen(m_aPt2 - m_aPt1));

            double fFact = 1.0;

            if(eMeasureUnit != eModUIUnit)

            {

                // for the unit conversion

                fFact *= GetMapFactor(eModUIUnit, eMeasureUnit).X();

            }

            if(fMeasureScale != 1.0)

            {

                fFact *= fMeasureScale;

            }

            if(fFact != 1.0)

            {

                nLen = nLen * fFact;

            }

            aStr = getSdrModelFromSdrObject().GetMetricString(nLen, true, nNumDigits);

            SvtSysLocale aSysLocale;

            const LocaleDataWrapper& rLocaleDataWrapper = aSysLocale.GetLocaleData();

            sal_Unicode cDec(rLocaleDataWrapper.getNumDecimalSep()[0]);

            sal_Unicode cDecAlt(rLocaleDataWrapper.getNumDecimalSepAlt().toChar());

            if(aStr.indexOf(cDec) != -1 || (cDecAlt && aStr.indexOf(cDecAlt) != -1))

            {

                sal_Int32 nLen2(aStr.getLength() - 1);

                while(aStr[nLen2] == '0')

                {

                    aStr = aStr.copy(0, nLen2);

                    nLen2--;

                }

                if(aStr[nLen2] == cDec || (cDecAlt && aStr[nLen2] == cDecAlt))

                {

                    aStr = aStr.copy(0, nLen2);

                    nLen2--;

                }

                if(aStr.isEmpty())

                    aStr += "0";

            }

            break;

        }

        case SdrMeasureFieldKind::Unit:

        {

            if(bShowUnit)

            {

                eModUIUnit = getSdrModelFromSdrObject().GetUIUnit();

                if(eMeasureUnit == FieldUnit::NONE)

                    eMeasureUnit = eModUIUnit;

                aStr = SdrModel::GetUnitString(eMeasureUnit);

            }

            break;

        }

        case SdrMeasureFieldKind::Rotate90Blanks:

        {

            if(bTextRota90)

            {

                aStr = " ";

            }

            break;

        }

    }

    return aStr;

}

// BaseProperties section

std::unique_ptr<sdr::properties::BaseProperties> SdrMeasureObj::CreateObjectSpecificProperties()

{

    return std::make_unique<sdr::properties::MeasureProperties>(*this);

}

// DrawContact section

std::unique_ptr<sdr::contact::ViewContact> SdrMeasureObj::CreateObjectSpecificViewContact()

{

    return std::make_unique<sdr::contact::ViewContactOfSdrMeasureObj>(*this);

}

SdrMeasureObj::SdrMeasureObj(SdrModel& rSdrModel)

:   SdrTextObj(rSdrModel),

    m_bTextDirty(false)

{

    // #i25616#

    mbSupportTextIndentingOnLineWidthChange = false;

}

SdrMeasureObj::SdrMeasureObj(SdrModel& rSdrModel, SdrMeasureObj const & rSource)

:   SdrTextObj(rSdrModel, rSource),

    m_bTextDirty(false)

{

    // #i25616#

    mbSupportTextIndentingOnLineWidthChange = false;

    m_aPt1 = rSource.m_aPt1;

    m_aPt2 = rSource.m_aPt2;

    m_bTextDirty = rSource.m_bTextDirty;

}

SdrMeasureObj::SdrMeasureObj(

    SdrModel& rSdrModel,

    const Point& rPt1,

    const Point& rPt2)

:   SdrTextObj(rSdrModel),

    m_aPt1(rPt1),

    m_aPt2(rPt2),

    m_bTextDirty(false)

{

    // #i25616#

    mbSupportTextIndentingOnLineWidthChange = false;

}

SdrMeasureObj::~SdrMeasureObj()

{

}

void SdrMeasureObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const

{

    rInfo.bMoveAllowed      =true;

    rInfo.bResizeFreeAllowed=true;

    rInfo.bResizePropAllowed=true;

    rInfo.bRotateFreeAllowed=true;

    rInfo.bRotate90Allowed  =true;

    rInfo.bMirrorFreeAllowed=true;

    rInfo.bMirror45Allowed  =true;

    rInfo.bMirror90Allowed  =true;

    rInfo.bTransparenceAllowed = false;

    rInfo.bShearAllowed     =true;

    rInfo.bEdgeRadiusAllowed=false;

    rInfo.bNoOrthoDesired   =true;

    rInfo.bNoContortion     =false;

    rInfo.bCanConvToPath    =false;

    rInfo.bCanConvToPoly    =true;

    rInfo.bCanConvToPathLineToArea=false;

    rInfo.bCanConvToPolyLineToArea=false;

    rInfo.bCanConvToContour = LineGeometryUsageIsNecessary();

}

SdrObjKind SdrMeasureObj::GetObjIdentifier() const

{

    return SdrObjKind::Measure;

}

struct ImpMeasureRec : public SdrDragStatUserData

{

    Point                       aPt1;

    Point                       aPt2;

    css::drawing::MeasureTextHorzPos eWantTextHPos;

    css::drawing::MeasureTextVertPos eWantTextVPos;

    tools::Long                        nLineDist;

    tools::Long                        nHelplineOverhang;

    tools::Long                        nHelplineDist;

    tools::Long                        nHelpline1Len;

    tools::Long                        nHelpline2Len;

    bool                        bBelowRefEdge;

    bool                        bTextRota90;

    bool                        bTextUpsideDown;

    bool                        bTextAutoAngle;

    Degree100                   nTextAutoAngleView;

};

namespace {

struct ImpLineRec

{

    Point                       aP1;

    Point                       aP2;

};

}

struct ImpMeasurePoly

{

    ImpLineRec                  aMainline1; // those with the 1st arrowhead

    ImpLineRec                  aMainline2; // those with the 2nd arrowhead

    ImpLineRec                  aMainline3; // those in between

    ImpLineRec                  aHelpline1;

    ImpLineRec                  aHelpline2;

    Size                        aTextSize;

    tools::Long                        nLineLen;

    Degree100                   nLineAngle;

    Degree100                   nTextAngle;

    Degree100                   nHlpAngle;

    double                      nLineSin;

    double                      nLineCos;

    sal_uInt16                      nMainlineCnt;

    css::drawing::MeasureTextHorzPos eUsedTextHPos;

    css::drawing::MeasureTextVertPos eUsedTextVPos;

    tools::Long                        nLineWdt2;  // half the line width

    tools::Long                        nArrow1Len; // length of 1st arrowhead; for Center, use only half

    tools::Long                        nArrow2Len; // length of 2nd arrowhead; for Center, use only half

    tools::Long                        nArrow1Wdt; // width of 1st arrow

    tools::Long                        nArrow2Wdt; // width of 2nd arrow

    tools::Long                        nShortLineLen; // line length, if PfeileAussen (arrowheads on the outside)

    bool                        bAutoUpsideDown; // UpsideDown via automation

    bool                        bBreakedLine;

};

void SdrMeasureObj::ImpTakeAttr(ImpMeasureRec& rRec) const

{

    rRec.aPt1 = m_aPt1;

    rRec.aPt2 = m_aPt2;

    const SfxItemSet& rSet = GetObjectItemSet();

    rRec.eWantTextHPos     =rSet.Get(SDRATTR_MEASURETEXTHPOS        ).GetValue();

    rRec.eWantTextVPos     =rSet.Get(SDRATTR_MEASURETEXTVPOS        ).GetValue();

    rRec.nLineDist         =rSet.Get(SDRATTR_MEASURELINEDIST        ).GetValue();

    rRec.nHelplineOverhang =rSet.Get(SDRATTR_MEASUREHELPLINEOVERHANG).GetValue();

    rRec.nHelplineDist     =rSet.Get(SDRATTR_MEASUREHELPLINEDIST    ).GetValue();

    rRec.nHelpline1Len     =rSet.Get(SDRATTR_MEASUREHELPLINE1LEN    ).GetValue();

    rRec.nHelpline2Len     =rSet.Get(SDRATTR_MEASUREHELPLINE2LEN    ).GetValue();

    rRec.bBelowRefEdge     =rSet.Get(SDRATTR_MEASUREBELOWREFEDGE    ).GetValue();

    rRec.bTextRota90       =rSet.Get(SDRATTR_MEASURETEXTROTA90      ).GetValue();

    rRec.bTextUpsideDown   =static_cast<const SdrMeasureTextUpsideDownItem&   >(rSet.Get(SDRATTR_MEASURETEXTUPSIDEDOWN  )).GetValue();

    rRec.bTextAutoAngle    =rSet.Get(SDRATTR_MEASURETEXTAUTOANGLE    ).GetValue();

    rRec.nTextAutoAngleView=static_cast<const SdrMeasureTextAutoAngleViewItem&>(rSet.Get(SDRATTR_MEASURETEXTAUTOANGLEVIEW)).GetValue();

}

static tools::Long impGetLineStartEndDistance(const basegfx::B2DPolyPolygon& rPolyPolygon, tools::Long nNewWidth, bool bCenter)

{

    const basegfx::B2DRange aPolygonRange(rPolyPolygon.getB2DRange());

    const double fOldWidth(std::max(aPolygonRange.getWidth(), 1.0));

    const double fScale(static_cast<double>(nNewWidth) / fOldWidth);

    tools::Long nHeight(basegfx::fround<tools::Long>(aPolygonRange.getHeight() * fScale));

    if(bCenter)

    {

        nHeight /= 2;

    }

    return nHeight;

}

void SdrMeasureObj::ImpCalcGeometrics(const ImpMeasureRec& rRec, ImpMeasurePoly& rPol) const

{

    Point aP1(rRec.aPt1);

    Point aP2(rRec.aPt2);

    Point aDelt(aP2); aDelt-=aP1;

    rPol.aTextSize=GetTextSize();

    rPol.nLineLen=GetLen(aDelt);

    rPol.nLineWdt2=0;

    tools::Long nArrow1Len=0; bool bArrow1Center=false;

    tools::Long nArrow2Len=0; bool bArrow2Center=false;

    tools::Long nArrow1Wdt=0;

    tools::Long nArrow2Wdt=0;

    rPol.nArrow1Wdt=0;

    rPol.nArrow2Wdt=0;

    tools::Long nArrowNeed=0;

    tools::Long nShortLen=0;

    bool bPfeileAussen = false;

    const SfxItemSet& rSet = GetObjectItemSet();

    sal_Int32 nLineWdt = rSet.Get(XATTR_LINEWIDTH).GetValue(); // line width

    rPol.nLineWdt2 = (nLineWdt + 1) / 2;

    nArrow1Wdt = rSet.Get(XATTR_LINESTARTWIDTH).GetValue();

    if(nArrow1Wdt < 0)

        nArrow1Wdt = -nLineWdt * nArrow1Wdt / 100; // <0 = relative

    nArrow2Wdt = rSet.Get(XATTR_LINEENDWIDTH).GetValue();

    if(nArrow2Wdt < 0)

        nArrow2Wdt = -nLineWdt * nArrow2Wdt / 100; // <0 = relative

    basegfx::B2DPolyPolygon aPol1(rSet.Get(XATTR_LINESTART).GetLineStartValue());

    basegfx::B2DPolyPolygon aPol2(rSet.Get(XATTR_LINEEND).GetLineEndValue());

    bArrow1Center = rSet.Get(XATTR_LINESTARTCENTER).GetValue();

    bArrow2Center = rSet.Get(XATTR_LINEENDCENTER).GetValue();

    nArrow1Len = impGetLineStartEndDistance(aPol1, nArrow1Wdt, bArrow1Center) - 1;

    nArrow2Len = impGetLineStartEndDistance(aPol2, nArrow2Wdt, bArrow2Center) - 1;

    // nArrowLen is already halved at bCenter.

    // In the case of 2 arrowheads each 4mm long, we can't go below 10mm.

    nArrowNeed=nArrow1Len+nArrow2Len+(nArrow1Wdt+nArrow2Wdt)/2;

    if (rPol.nLineLen<nArrowNeed) bPfeileAussen = true;

    nShortLen=(nArrow1Len+nArrow1Wdt + nArrow2Len+nArrow2Wdt) /2;

    rPol.eUsedTextHPos=rRec.eWantTextHPos;

    rPol.eUsedTextVPos=rRec.eWantTextVPos;

    if (rPol.eUsedTextVPos == css::drawing::MeasureTextVertPos_AUTO)

        rPol.eUsedTextVPos = css::drawing::MeasureTextVertPos_EAST;

    bool bBrkLine=false;

    if (rPol.eUsedTextVPos == css::drawing::MeasureTextVertPos_CENTERED)

    {

        OutlinerParaObject* pOutlinerParaObject = SdrTextObj::GetOutlinerParaObject();

        if (pOutlinerParaObject!=nullptr && pOutlinerParaObject->GetTextObject().GetParagraphCount()==1)

        {

            bBrkLine=true; // dashed line if there's only on paragraph.

        }

    }

    rPol.bBreakedLine=bBrkLine;

    if (rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_AUTO) { // if text is too wide, push it outside

        bool bOutside = false;

        tools::Long nNeedSiz=!rRec.bTextRota90 ? rPol.aTextSize.Width() : rPol.aTextSize.Height();

        if (nNeedSiz>rPol.nLineLen) bOutside = true; // text doesn't fit in between

        if (bBrkLine) {

            if (nNeedSiz+nArrowNeed>rPol.nLineLen) bPfeileAussen = true; // text fits in between, if arrowheads are on the outside

        } else {

            tools::Long nSmallNeed=nArrow1Len+nArrow2Len+(nArrow1Wdt+nArrow2Wdt)/2/4;

            if (nNeedSiz+nSmallNeed>rPol.nLineLen) bPfeileAussen = true; // text fits in between, if arrowheads are on the outside

        }

        rPol.eUsedTextHPos=bOutside ? css::drawing::MeasureTextHorzPos_LEFTOUTSIDE : css::drawing::MeasureTextHorzPos_INSIDE;

    }

    if (rPol.eUsedTextHPos != css::drawing::MeasureTextHorzPos_INSIDE) bPfeileAussen = true;

    rPol.nArrow1Wdt=nArrow1Wdt;

    rPol.nArrow2Wdt=nArrow2Wdt;

    rPol.nShortLineLen=nShortLen;

    rPol.nArrow1Len=nArrow1Len;

    rPol.nArrow2Len=nArrow2Len;

    rPol.nLineAngle=GetAngle(aDelt);

    double a = toRadians(rPol.nLineAngle);

    double nLineSin=sin(a);

    double nLineCos=cos(a);

    rPol.nLineSin=nLineSin;

    rPol.nLineCos=nLineCos;

    rPol.nTextAngle=rPol.nLineAngle;

    if (rRec.bTextRota90) rPol.nTextAngle+=9000_deg100;

    rPol.bAutoUpsideDown=false;

    if (rRec.bTextAutoAngle) {

        Degree100 nTmpAngle=NormAngle36000(rPol.nTextAngle-rRec.nTextAutoAngleView);

        if (nTmpAngle>=18000_deg100) {

            rPol.nTextAngle+=18000_deg100;

            rPol.bAutoUpsideDown=true;

        }

    }

    if (rRec.bTextUpsideDown) rPol.nTextAngle+=18000_deg100;

    rPol.nTextAngle=NormAngle36000(rPol.nTextAngle);

    rPol.nHlpAngle=rPol.nLineAngle+9000_deg100;

    if (rRec.bBelowRefEdge) rPol.nHlpAngle+=18000_deg100;

    rPol.nHlpAngle=NormAngle36000(rPol.nHlpAngle);

    double nHlpSin=nLineCos;

    double nHlpCos=-nLineSin;

    if (rRec.bBelowRefEdge) {

        nHlpSin=-nHlpSin;

        nHlpCos=-nHlpCos;

    }

    tools::Long nLineDist=rRec.nLineDist;

    tools::Long nOverhang=rRec.nHelplineOverhang;

    tools::Long nHelplineDist=rRec.nHelplineDist;

    tools::Long dx = basegfx::fround<tools::Long>(nLineDist * nHlpCos);

    tools::Long dy = basegfx::fround<tools::Long>(nLineDist * -nHlpSin);

    tools::Long dxh1a = basegfx::fround<tools::Long>((nHelplineDist - rRec.nHelpline1Len) * nHlpCos);

    tools::Long dyh1a = basegfx::fround<tools::Long>((nHelplineDist - rRec.nHelpline1Len) * -nHlpSin);

    tools::Long dxh1b = basegfx::fround<tools::Long>((nHelplineDist - rRec.nHelpline2Len) * nHlpCos);

    tools::Long dyh1b = basegfx::fround<tools::Long>((nHelplineDist - rRec.nHelpline2Len) * -nHlpSin);

    tools::Long dxh2 = basegfx::fround<tools::Long>((nLineDist + nOverhang) * nHlpCos);

    tools::Long dyh2 = basegfx::fround<tools::Long>((nLineDist + nOverhang) * -nHlpSin);

    // extension line 1

    rPol.aHelpline1.aP1=Point(aP1.X()+dxh1a,aP1.Y()+dyh1a);

    rPol.aHelpline1.aP2=Point(aP1.X()+dxh2,aP1.Y()+dyh2);

    // extension line 2

    rPol.aHelpline2.aP1=Point(aP2.X()+dxh1b,aP2.Y()+dyh1b);

    rPol.aHelpline2.aP2=Point(aP2.X()+dxh2,aP2.Y()+dyh2);

    // dimension line

    Point aMainlinePt1(aP1.X()+dx,aP1.Y()+dy);

    Point aMainlinePt2(aP2.X()+dx,aP2.Y()+dy);

    if (!bPfeileAussen) {

        rPol.aMainline1.aP1=aMainlinePt1;

        rPol.aMainline1.aP2=aMainlinePt2;

        rPol.aMainline2=rPol.aMainline1;

        rPol.aMainline3=rPol.aMainline1;

        rPol.nMainlineCnt=1;

        if (bBrkLine) {

            tools::Long nNeedSiz=!rRec.bTextRota90 ? rPol.aTextSize.Width() : rPol.aTextSize.Height();

            tools::Long nHalfLen=(rPol.nLineLen-nNeedSiz-nArrow1Wdt/4-nArrow2Wdt/4) /2;

            rPol.nMainlineCnt=2;

            rPol.aMainline1.aP2=aMainlinePt1;

            rPol.aMainline1.aP2.AdjustX(nHalfLen );

            RotatePoint(rPol.aMainline1.aP2,rPol.aMainline1.aP1,nLineSin,nLineCos);

            rPol.aMainline2.aP1=aMainlinePt2;

            rPol.aMainline2.aP1.AdjustX( -nHalfLen );

            RotatePoint(rPol.aMainline2.aP1,rPol.aMainline2.aP2,nLineSin,nLineCos);

        }

    } else {

        tools::Long nLen1=nShortLen; // arrowhead's width as line length outside of the arrowhead

        tools::Long nLen2=nShortLen;

        tools::Long nTextWdt=rRec.bTextRota90 ? rPol.aTextSize.Height() : rPol.aTextSize.Width();

        if (!bBrkLine) {

            if (rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_LEFTOUTSIDE) nLen1=nArrow1Len+nTextWdt;

            if (rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE) nLen2=nArrow2Len+nTextWdt;

        }

        rPol.aMainline1.aP1=aMainlinePt1;

        rPol.aMainline1.aP2=aMainlinePt1; rPol.aMainline1.aP2.AdjustX( -nLen1 ); RotatePoint(rPol.aMainline1.aP2,aMainlinePt1,nLineSin,nLineCos);

        rPol.aMainline2.aP1=aMainlinePt2; rPol.aMainline2.aP1.AdjustX(nLen2 ); RotatePoint(rPol.aMainline2.aP1,aMainlinePt2,nLineSin,nLineCos);

        rPol.aMainline2.aP2=aMainlinePt2;

        rPol.aMainline3.aP1=aMainlinePt1;

        rPol.aMainline3.aP2=aMainlinePt2;

        rPol.nMainlineCnt=3;

        if (bBrkLine && rPol.eUsedTextHPos==css::drawing::MeasureTextHorzPos_INSIDE) rPol.nMainlineCnt=2;

    }

}

basegfx::B2DPolyPolygon SdrMeasureObj::ImpCalcXPoly(const ImpMeasurePoly& rPol)

{

    basegfx::B2DPolyPolygon aRetval;

    basegfx::B2DPolygon aPartPolyA;

    aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline1.aP1.X(), rPol.aMainline1.aP1.Y()));

    aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline1.aP2.X(), rPol.aMainline1.aP2.Y()));

    aRetval.append(aPartPolyA);

    if(rPol.nMainlineCnt > 1)

    {

        aPartPolyA.clear();

        aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline2.aP1.X(), rPol.aMainline2.aP1.Y()));

        aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline2.aP2.X(), rPol.aMainline2.aP2.Y()));

        aRetval.append(aPartPolyA);

    }

    if(rPol.nMainlineCnt > 2)

    {

        aPartPolyA.clear();

        aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline3.aP1.X(), rPol.aMainline3.aP1.Y()));

        aPartPolyA.append(basegfx::B2DPoint(rPol.aMainline3.aP2.X(), rPol.aMainline3.aP2.Y()));

        aRetval.append(aPartPolyA);

    }

    aPartPolyA.clear();

    aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline1.aP1.X(), rPol.aHelpline1.aP1.Y()));

    aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline1.aP2.X(), rPol.aHelpline1.aP2.Y()));

    aRetval.append(aPartPolyA);

    aPartPolyA.clear();

    aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline2.aP1.X(), rPol.aHelpline2.aP1.Y()));

    aPartPolyA.append(basegfx::B2DPoint(rPol.aHelpline2.aP2.X(), rPol.aHelpline2.aP2.Y()));

    aRetval.append(aPartPolyA);

    return aRetval;

}

bool SdrMeasureObj::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_uInt16 nPos,

    bool bEdit,

    std::optional<Color>& rpTxtColor, std::optional<Color>& rpFldColor, std::optional<FontLineStyle>& rpFldLineStyle, OUString& rRet) const

{

    const SvxFieldData* pField=rField.GetField();

    const SdrMeasureField* pMeasureField=dynamic_cast<const SdrMeasureField*>( pField );

    if (pMeasureField!=nullptr) {

        rRet = TakeRepresentation(pMeasureField->GetMeasureFieldKind());

        if (rpFldColor && !bEdit)

        {

            rpFldColor.reset();

        }

        return true;

    } else {

        return SdrTextObj::CalcFieldValue(rField,nPara,nPos,bEdit,rpTxtColor,rpFldColor,rpFldLineStyle,rRet);

    }

}

void SdrMeasureObj::UndirtyText() const

{

    if (!m_bTextDirty)

        return;

    SdrOutliner& rOutliner=ImpGetDrawOutliner();

    OutlinerParaObject* pOutlinerParaObject = SdrTextObj::GetOutlinerParaObject();

    if(pOutlinerParaObject==nullptr)

    {

        rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Rotate90Blanks), EE_FEATURE_FIELD), ESelection(0,0));

        rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Value), EE_FEATURE_FIELD),ESelection(0,1));

        rOutliner.QuickInsertText(u" "_ustr, ESelection(0,2));

        rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Unit), EE_FEATURE_FIELD),ESelection(0,3));

        rOutliner.QuickInsertField(SvxFieldItem(SdrMeasureField(SdrMeasureFieldKind::Rotate90Blanks), EE_FEATURE_FIELD),ESelection(0,4));

        if(GetStyleSheet())

            rOutliner.SetStyleSheet(0, GetStyleSheet());

        rOutliner.SetParaAttribs(0, GetObjectItemSet());

        // cast to nonconst

        const_cast<SdrMeasureObj*>(this)->NbcSetOutlinerParaObject( rOutliner.CreateParaObject() );

    }

    else

    {

        rOutliner.SetText(*pOutlinerParaObject);

    }

    rOutliner.SetUpdateLayout(true);

    rOutliner.UpdateFields();

    Size aSiz(rOutliner.CalcTextSize());

    rOutliner.Clear();

    // cast to nonconst three times

    const_cast<SdrMeasureObj*>(this)->maTextSize = aSiz;

    const_cast<SdrMeasureObj*>(this)->mbTextSizeDirty = false;

    const_cast<SdrMeasureObj*>(this)->m_bTextDirty = false;

}

void SdrMeasureObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const

{

    if (m_bTextDirty) UndirtyText();

    ImpMeasureRec aRec;

    ImpMeasurePoly aMPol;

    ImpTakeAttr(aRec);

    ImpCalcGeometrics(aRec,aMPol);

    // determine TextSize including text frame margins

    Size aTextSize2(aMPol.aTextSize);

    if (aTextSize2.Width()<1) aTextSize2.setWidth(1 );

    if (aTextSize2.Height()<1) aTextSize2.setHeight(1 );

    aTextSize2.AdjustWidth(GetTextLeftDistance()+GetTextRightDistance() );

    aTextSize2.AdjustHeight(GetTextUpperDistance()+GetTextLowerDistance() );

    Point aPt1b(aMPol.aMainline1.aP1);

    tools::Long nLen=aMPol.nLineLen;

    tools::Long nLWdt=aMPol.nLineWdt2;

    tools::Long nArr1Len=aMPol.nArrow1Len;

    tools::Long nArr2Len=aMPol.nArrow2Len;

    if (aMPol.bBreakedLine) {

        // In the case of a dashed line and Outside, the text should be

        // placed next to the line at the arrowhead instead of directly

        // at the arrowhead.

        nArr1Len=aMPol.nShortLineLen+aMPol.nArrow1Wdt/4;

        nArr2Len=aMPol.nShortLineLen+aMPol.nArrow2Wdt/4;

    }

    Point aTextPos;

    bool bRota90=aRec.bTextRota90;

    bool bUpsideDown=aRec.bTextUpsideDown!=aMPol.bAutoUpsideDown;

    bool bBelowRefEdge=aRec.bBelowRefEdge;

    css::drawing::MeasureTextHorzPos eMH=aMPol.eUsedTextHPos;

    css::drawing::MeasureTextVertPos eMV=aMPol.eUsedTextVPos;

    if (!bRota90) {

        switch (eMH) {

            case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: aTextPos.setX(aPt1b.X()-aTextSize2.Width()-nArr1Len-nLWdt ); break;

            case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: aTextPos.setX(aPt1b.X()+nLen+nArr2Len+nLWdt ); break;

            default: aTextPos.setX(aPt1b.X() ); aTextSize2.setWidth(nLen );

        }

        switch (eMV) {

            case css::drawing::MeasureTextVertPos_CENTERED:

                aTextPos.setY(aPt1b.Y()-aTextSize2.Height()/2 ); break;

            case css::drawing::MeasureTextVertPos_WEST: {

                if (!bUpsideDown) aTextPos.setY(aPt1b.Y()+nLWdt );

                else aTextPos.setY(aPt1b.Y()-aTextSize2.Height()-nLWdt );

            } break;

            default: {

                if (!bUpsideDown) aTextPos.setY(aPt1b.Y()-aTextSize2.Height()-nLWdt );

                else aTextPos.setY(aPt1b.Y()+nLWdt );

            }

        }

        if (bUpsideDown) {

            aTextPos.AdjustX(aTextSize2.Width() );

            aTextPos.AdjustY(aTextSize2.Height() );

        }

    } else { // also if bTextRota90==TRUE

        switch (eMH) {

            case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: aTextPos.setX(aPt1b.X()-aTextSize2.Height()-nArr1Len ); break;

            case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: aTextPos.setX(aPt1b.X()+nLen+nArr2Len ); break;

            default: aTextPos.setX(aPt1b.X() ); aTextSize2.setHeight(nLen );

        }

        switch (eMV) {

            case css::drawing::MeasureTextVertPos_CENTERED:

                aTextPos.setY(aPt1b.Y()+aTextSize2.Width()/2 ); break;

            case css::drawing::MeasureTextVertPos_WEST: {

                if (!bBelowRefEdge) aTextPos.setY(aPt1b.Y()+aTextSize2.Width()+nLWdt );

                else aTextPos.setY(aPt1b.Y()-nLWdt );

            } break;

            default: {

                if (!bBelowRefEdge) aTextPos.setY(aPt1b.Y()-nLWdt );

                else aTextPos.setY(aPt1b.Y()+aTextSize2.Width()+nLWdt );

            }

        }

        if (bUpsideDown) {

            aTextPos.AdjustX(aTextSize2.Height() );

            aTextPos.AdjustY( -(aTextSize2.Width()) );

        }

    }

    if (aMPol.nTextAngle != maGeo.m_nRotationAngle) {

        const_cast<SdrMeasureObj*>(this)->maGeo.m_nRotationAngle=aMPol.nTextAngle;

        const_cast<SdrMeasureObj*>(this)->maGeo.RecalcSinCos();

    }

    RotatePoint(aTextPos,aPt1b,aMPol.nLineSin,aMPol.nLineCos);

    aTextSize2.AdjustWidth( 1 ); aTextSize2.AdjustHeight( 1 ); // because of the Rect-Ctor's odd behavior

    rRect=tools::Rectangle(aTextPos,aTextSize2);

    rRect.Normalize();

    const_cast<SdrMeasureObj*>(this)->setRectangle(rRect);

    if (aMPol.nTextAngle != maGeo.m_nRotationAngle) {

        const_cast<SdrMeasureObj*>(this)->maGeo.m_nRotationAngle=aMPol.nTextAngle;

        const_cast<SdrMeasureObj*>(this)->maGeo.RecalcSinCos();

    }

}

rtl::Reference<SdrObject> SdrMeasureObj::CloneSdrObject(SdrModel& rTargetModel) const

{

    return new SdrMeasureObj(rTargetModel, *this);

}

OUString SdrMeasureObj::TakeObjNameSingul() const

{

    OUString sName(SvxResId(STR_ObjNameSingulMEASURE));

    OUString aName( GetName() );

    if (!aName.isEmpty())

        sName += " '" + aName + "'";

    return sName;

}

OUString SdrMeasureObj::TakeObjNamePlural() const

{

    return SvxResId(STR_ObjNamePluralMEASURE);

}

basegfx::B2DPolyPolygon SdrMeasureObj::TakeXorPoly() const

{

    ImpMeasureRec aRec;

    ImpMeasurePoly aMPol;

    ImpTakeAttr(aRec);

    ImpCalcGeometrics(aRec,aMPol);

    return ImpCalcXPoly(aMPol);

}

sal_uInt32 SdrMeasureObj::GetHdlCount() const

{

    return 6;

}

void SdrMeasureObj::AddToHdlList(SdrHdlList& rHdlList) const

{

    ImpMeasureRec aRec;

    ImpMeasurePoly aMPol;

    ImpTakeAttr(aRec);

    aRec.nHelplineDist=0;

    ImpCalcGeometrics(aRec,aMPol);

    for (sal_uInt32 nHdlNum=0; nHdlNum<6; ++nHdlNum)

    {

        Point aPt;

        switch (nHdlNum) {

            case 0: aPt=aMPol.aHelpline1.aP1; break;

            case 1: aPt=aMPol.aHelpline2.aP1; break;

            case 2: aPt=m_aPt1;       break;

            case 3: aPt=m_aPt2;       break;

            case 4: aPt=aMPol.aHelpline1.aP2; break;

            case 5: aPt=aMPol.aHelpline2.aP2; break;

        } // switch

        std::unique_ptr<SdrHdl> pHdl(new ImpMeasureHdl(aPt,SdrHdlKind::User));

        pHdl->SetObjHdlNum(nHdlNum);

        pHdl->SetRotationAngle(aMPol.nLineAngle);

        rHdlList.AddHdl(std::move(pHdl));

    }

}

bool SdrMeasureObj::hasSpecialDrag() const

{

    return true;

}

bool SdrMeasureObj::beginSpecialDrag(SdrDragStat& rDrag) const

{

    const SdrHdl* pHdl = rDrag.GetHdl();

    if(pHdl)

    {

        const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum());

        if(nHdlNum != 2 && nHdlNum != 3)

        {

            rDrag.SetEndDragChangesAttributes(true);

        }

        return true;

    }

    return false;

}

bool SdrMeasureObj::applySpecialDrag(SdrDragStat& rDrag)

{

    ImpMeasureRec aMeasureRec;

    const SdrHdl* pHdl = rDrag.GetHdl();

    const sal_uInt32 nHdlNum(pHdl->GetObjHdlNum());

    ImpTakeAttr(aMeasureRec);

    ImpEvalDrag(aMeasureRec, rDrag);

    switch (nHdlNum)

    {

        case 2:

        {

            m_aPt1 = aMeasureRec.aPt1;

            SetTextDirty();

            break;

        }

        case 3:

        {

            m_aPt2 = aMeasureRec.aPt2;

            SetTextDirty();

            break;

        }

        default:

        {

            switch(nHdlNum)

            {

                case 0:

                case 1:

                {

                    ImpMeasureRec aOrigMeasureRec;

                    ImpTakeAttr(aOrigMeasureRec);

                    if(aMeasureRec.nHelpline1Len != aOrigMeasureRec.nHelpline1Len)

                    {

                        SetObjectItem(makeSdrMeasureHelpline1LenItem(aMeasureRec.nHelpline1Len));

                    }

                    if(aMeasureRec.nHelpline2Len != aOrigMeasureRec.nHelpline2Len)

                    {

                        SetObjectItem(makeSdrMeasureHelpline2LenItem(aMeasureRec.nHelpline2Len));

                    }

                    break;

                }

                case 4:

                case 5:

                {

                    ImpMeasureRec aOrigMeasureRec;

                    ImpTakeAttr(aOrigMeasureRec);

                    if(aMeasureRec.nLineDist != aOrigMeasureRec.nLineDist)

                    {

                        SetObjectItem(makeSdrMeasureLineDistItem(aMeasureRec.nLineDist));

                    }

                    if(aMeasureRec.bBelowRefEdge != aOrigMeasureRec.bBelowRefEdge)

                    {

                        SetObjectItem(SdrMeasureBelowRefEdgeItem(aMeasureRec.bBelowRefEdge));

                    }

                }

            }

        }

    } // switch

    SetBoundAndSnapRectsDirty();

    SetChanged();

    return true;

}

OUString SdrMeasureObj::getSpecialDragComment(const SdrDragStat& /*rDrag*/) const

{

    return OUString();

}

void SdrMeasureObj::ImpEvalDrag(ImpMeasureRec& rRec, const SdrDragStat& rDrag) const

{

    Degree100 nLineAngle=GetAngle(rRec.aPt2-rRec.aPt1);

    double a = toRadians(nLineAngle);

    double nSin=sin(a);

    double nCos=cos(a);

    const SdrHdl* pHdl=rDrag.GetHdl();

    sal_uInt32 nHdlNum(pHdl->GetObjHdlNum());

    bool bOrtho=rDrag.GetView()!=nullptr && rDrag.GetView()->IsOrtho();

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

    bool bBelow=rRec.bBelowRefEdge;

    Point aPt(rDrag.GetNow());

    switch (nHdlNum) {

        case 0: {

            RotatePoint(aPt,m_aPt1,nSin,-nCos);

            rRec.nHelpline1Len=m_aPt1.Y()-aPt.Y();

            if (bBelow) rRec.nHelpline1Len=-rRec.nHelpline1Len;

            if (bOrtho) rRec.nHelpline2Len=rRec.nHelpline1Len;

        } break;

        case 1: {

            RotatePoint(aPt,m_aPt2,nSin,-nCos);

            rRec.nHelpline2Len=m_aPt2.Y()-aPt.Y();

            if (bBelow) rRec.nHelpline2Len=-rRec.nHelpline2Len;

            if (bOrtho) rRec.nHelpline1Len=rRec.nHelpline2Len;

        } break;

        case 2: case 3: {

            bool bAnf=nHdlNum==2;

            Point& rMov=bAnf ? rRec.aPt1 : rRec.aPt2;

            Point aMov(rMov);

            Point aFix(bAnf ? rRec.aPt2 : rRec.aPt1);

            if (bOrtho) {

                tools::Long ndx0=aMov.X()-aFix.X();