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, 1157 insertions, 0 deletions

diff --git a/svx/source/svdraw/svdocirc.cxx b/svx/source/svdraw/svdocirc.cxx
new file mode 100644
index 0000000000..becc496c76
--- /dev/null
+++ b/svx/source/svdraw/svdocirc.cxx
@@ -0,0 +1,1157 @@
+/* -*- 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 <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <math.h>
+#include <rtl/ustrbuf.hxx>
+
+#include <svx/dialmgr.hxx>
+#include <svx/strings.hrc>
+
+#include <sdr/contact/viewcontactofsdrcircobj.hxx>
+#include <sdr/properties/circleproperties.hxx>
+#include <svx/svddrag.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svdocirc.hxx>
+#include <svx/svdopath.hxx>
+#include <svx/svdtrans.hxx>
+#include <svx/svdview.hxx>
+#include <svx/sxciaitm.hxx>
+#include <sxcikitm.hxx>
+#include <svx/xfillit0.hxx>
+#include <svx/xlineit0.hxx>
+#include <svx/xlnedit.hxx>
+#include <svx/xlnedwit.hxx>
+#include <svx/xlnstit.hxx>
+#include <svx/xlnstwit.hxx>
+#include <svx/xlnwtit.hxx>
+#include <vcl/canvastools.hxx>
+#include <vcl/ptrstyle.hxx>
+
+using namespace com::sun::star;
+
+static Point GetAnglePnt(const tools::Rectangle& rR, Degree100 nAngle)
+{
+    Point aCenter(rR.Center());
+    tools::Long nWdt=rR.Right()-rR.Left();
+    tools::Long nHgt=rR.Bottom()-rR.Top();
+    tools::Long nMaxRad=(std::max(nWdt,nHgt)+1) /2;
+    double a = toRadians(nAngle);
+    Point aRetval(FRound(cos(a)*nMaxRad),-FRound(sin(a)*nMaxRad));
+    if (nWdt==0) aRetval.setX(0 );
+    if (nHgt==0) aRetval.setY(0 );
+    if (nWdt!=nHgt) {
+        if (nWdt>nHgt) {
+            if (nWdt!=0) {
+                // stop possible overruns for very large objects
+                if (std::abs(nHgt)>32767 || std::abs(aRetval.Y())>32767) {
+                    aRetval.setY(BigMulDiv(aRetval.Y(),nHgt,nWdt) );
+                } else {
+                    aRetval.setY(aRetval.Y()*nHgt/nWdt );
+                }
+            }
+        } else {
+            if (nHgt!=0) {
+                // stop possible overruns for very large objects
+                if (std::abs(nWdt)>32767 || std::abs(aRetval.X())>32767) {
+                    aRetval.setX(BigMulDiv(aRetval.X(),nWdt,nHgt) );
+                } else {
+                    aRetval.setX(aRetval.X()*nWdt/nHgt );
+                }
+            }
+        }
+    }
+    aRetval+=aCenter;
+    return aRetval;
+}
+
+
+// BaseProperties section
+
+std::unique_ptr<sdr::properties::BaseProperties> SdrCircObj::CreateObjectSpecificProperties()
+{
+    return std::make_unique<sdr::properties::CircleProperties>(*this);
+}
+
+
+// DrawContact section
+
+std::unique_ptr<sdr::contact::ViewContact> SdrCircObj::CreateObjectSpecificViewContact()
+{
+    return std::make_unique<sdr::contact::ViewContactOfSdrCircObj>(*this);
+}
+
+SdrCircKind ToSdrCircKind(SdrObjKind eKind)
+{
+    switch (eKind)
+    {
+        case SdrObjKind::CircleOrEllipse: return SdrCircKind::Full;
+        case SdrObjKind::CircleSection: return SdrCircKind::Section;
+        case SdrObjKind::CircleArc: return SdrCircKind::Arc;
+        case SdrObjKind::CircleCut: return SdrCircKind::Cut;
+        default: assert(false);
+    }
+    return SdrCircKind::Full;
+}
+
+SdrCircObj::SdrCircObj(
+    SdrModel& rSdrModel,
+    SdrCircKind eNewKind)
+:   SdrRectObj(rSdrModel)
+{
+    nStartAngle=0_deg100;
+    nEndAngle=36000_deg100;
+    meCircleKind=eNewKind;
+    m_bClosedObj=eNewKind!=SdrCircKind::Arc;
+}
+
+SdrCircObj::SdrCircObj(SdrModel& rSdrModel, SdrCircObj const & rSource)
+:   SdrRectObj(rSdrModel, rSource)
+{
+    meCircleKind = rSource.meCircleKind;
+    nStartAngle = rSource.nStartAngle;
+    nEndAngle = rSource.nEndAngle;
+    m_bClosedObj = rSource.m_bClosedObj;
+}
+
+SdrCircObj::SdrCircObj(
+    SdrModel& rSdrModel,
+    SdrCircKind eNewKind,
+    const tools::Rectangle& rRect)
+:   SdrRectObj(rSdrModel, rRect)
+{
+    nStartAngle=0_deg100;
+    nEndAngle=36000_deg100;
+    meCircleKind=eNewKind;
+    m_bClosedObj=eNewKind!=SdrCircKind::Arc;
+}
+
+SdrCircObj::SdrCircObj(
+    SdrModel& rSdrModel,
+    SdrCircKind eNewKind,
+    const tools::Rectangle& rRect,
+    Degree100 nNewStartAngle,
+    Degree100 nNewEndAngle)
+:   SdrRectObj(rSdrModel, rRect)
+{
+    Degree100 nAngleDif=nNewEndAngle-nNewStartAngle;
+    nStartAngle=NormAngle36000(nNewStartAngle);
+    nEndAngle=NormAngle36000(nNewEndAngle);
+    if (nAngleDif==36000_deg100) nEndAngle+=nAngleDif; // full circle
+    meCircleKind=eNewKind;
+    m_bClosedObj=eNewKind!=SdrCircKind::Arc;
+}
+
+SdrCircObj::~SdrCircObj()
+{
+}
+
+void SdrCircObj::TakeObjInfo(SdrObjTransformInfoRec& rInfo) const
+{
+    bool bCanConv=!HasText() || ImpCanConvTextToCurve();
+    rInfo.bEdgeRadiusAllowed    = false;
+    rInfo.bCanConvToPath=bCanConv;
+    rInfo.bCanConvToPoly=bCanConv;
+    rInfo.bCanConvToContour = !IsFontwork() && (rInfo.bCanConvToPoly || LineGeometryUsageIsNecessary());
+}
+
+SdrObjKind SdrCircObj::GetObjIdentifier() const
+{
+    switch (meCircleKind)
+    {
+    case SdrCircKind::Full: return SdrObjKind::CircleOrEllipse;
+    case SdrCircKind::Section: return SdrObjKind::CircleSection;
+    case SdrCircKind::Cut: return SdrObjKind::CircleCut;
+    case SdrCircKind::Arc: return SdrObjKind::CircleArc;
+    default: assert(false);
+    }
+    return SdrObjKind::CircleOrEllipse;
+}
+
+bool SdrCircObj::PaintNeedsXPolyCirc() const
+{
+    // XPoly is necessary for all rotated ellipse objects, circle and
+    // ellipse segments.
+    // If not WIN, then (for now) also for circle/ellipse segments and circle/
+    // ellipse arcs (for precision)
+    bool bNeed = maGeo.m_nRotationAngle || maGeo.m_nShearAngle || meCircleKind == SdrCircKind::Cut;
+    // If not WIN, then for everything except full circle (for now!)
+    if (meCircleKind!=SdrCircKind::Full) bNeed = true;
+
+    const SfxItemSet& rSet = GetObjectItemSet();
+    if(!bNeed)
+    {
+        // XPoly is necessary for everything that isn't LineSolid or LineNone
+        drawing::LineStyle eLine = rSet.Get(XATTR_LINESTYLE).GetValue();
+        bNeed = eLine != drawing::LineStyle_NONE && eLine != drawing::LineStyle_SOLID;
+
+        // XPoly is necessary for thick lines
+        if(!bNeed && eLine != drawing::LineStyle_NONE)
+            bNeed = rSet.Get(XATTR_LINEWIDTH).GetValue() != 0;
+
+        // XPoly is necessary for circle arcs with line ends
+        if(!bNeed && meCircleKind == SdrCircKind::Arc)
+        {
+            // start of the line is here if StartPolygon, StartWidth!=0
+            bNeed=rSet.Get(XATTR_LINESTART).GetLineStartValue().count() != 0 &&
+                  rSet.Get(XATTR_LINESTARTWIDTH).GetValue() != 0;
+
+            if(!bNeed)
+            {
+                // end of the line is here if EndPolygon, EndWidth!=0
+                bNeed = rSet.Get(XATTR_LINEEND).GetLineEndValue().count() != 0 &&
+                        rSet.Get(XATTR_LINEENDWIDTH).GetValue() != 0;
+            }
+        }
+    }
+
+    // XPoly is necessary if Fill !=None and !=Solid
+    if(!bNeed && meCircleKind != SdrCircKind::Arc)
+    {
+        drawing::FillStyle eFill=rSet.Get(XATTR_FILLSTYLE).GetValue();
+        bNeed = eFill != drawing::FillStyle_NONE && eFill != drawing::FillStyle_SOLID;
+    }
+
+    if(!bNeed && meCircleKind != SdrCircKind::Full && nStartAngle == nEndAngle)
+        bNeed = true; // otherwise we're drawing a full circle
+
+    return bNeed;
+}
+
+basegfx::B2DPolygon SdrCircObj::ImpCalcXPolyCirc(const SdrCircKind eCircleKind, const tools::Rectangle& rRect1, Degree100 nStart, Degree100 nEnd) const
+{
+    const basegfx::B2DRange aRange = vcl::unotools::b2DRectangleFromRectangle(rRect1);
+    basegfx::B2DPolygon aCircPolygon;
+
+    if(SdrCircKind::Full == eCircleKind)
+    {
+        // create full circle. Do not use createPolygonFromEllipse; it's necessary
+        // to get the start point to the bottom of the circle to keep compatible to
+        // old geometry creation
+        aCircPolygon = basegfx::utils::createPolygonFromUnitCircle(1);
+
+        // needs own scaling and translation from unit circle to target size (same as
+        // would be in createPolygonFromEllipse)
+        const basegfx::B2DPoint aCenter(aRange.getCenter());
+        const basegfx::B2DHomMatrix aMatrix(basegfx::utils::createScaleTranslateB2DHomMatrix(
+            aRange.getWidth() / 2.0, aRange.getHeight() / 2.0,
+            aCenter.getX(), aCenter.getY()));
+        aCircPolygon.transform(aMatrix);
+    }
+    else
+    {
+        // mirror start, end for geometry creation since model coordinate system is mirrored in Y
+        const double fStart(toRadians((36000_deg100 - nEnd) % 36000_deg100));
+        const double fEnd(toRadians((36000_deg100 - nStart) % 36000_deg100));
+
+        // create circle segment. This is not closed by default
+        aCircPolygon = basegfx::utils::createPolygonFromEllipseSegment(
+            aRange.getCenter(), aRange.getWidth() / 2.0, aRange.getHeight() / 2.0,
+            fStart, fEnd);
+
+        // check closing states
+        const bool bCloseSegment(SdrCircKind::Arc != eCircleKind);
+        const bool bCloseUsingCenter(SdrCircKind::Section == eCircleKind);
+
+        if(bCloseSegment)
+        {
+            if(bCloseUsingCenter)
+            {
+                // add center point at start (for historical reasons)
+                basegfx::B2DPolygon aSector;
+                aSector.append(aRange.getCenter());
+                aSector.append(aCircPolygon);
+                aCircPolygon = aSector;
+            }
+
+            // close
+            aCircPolygon.setClosed(true);
+        }
+    }
+
+    // #i76950#
+    if (maGeo.m_nShearAngle || maGeo.m_nRotationAngle)
+    {
+        // translate top left to (0,0)
+        const basegfx::B2DPoint aTopLeft(aRange.getMinimum());
+        basegfx::B2DHomMatrix aMatrix(basegfx::utils::createTranslateB2DHomMatrix(
+            -aTopLeft.getX(), -aTopLeft.getY()));
+
+        // shear, rotate and back to top left (if needed)
+        aMatrix = basegfx::utils::createShearXRotateTranslateB2DHomMatrix(
+            -maGeo.mfTanShearAngle,
+            maGeo.m_nRotationAngle ? toRadians(36000_deg100 - maGeo.m_nRotationAngle) : 0.0,
+            aTopLeft) * aMatrix;
+
+        // apply transformation
+        aCircPolygon.transform(aMatrix);
+    }
+
+    return aCircPolygon;
+}
+
+void SdrCircObj::RecalcXPoly()
+{
+    basegfx::B2DPolygon aPolyCirc(ImpCalcXPolyCirc(meCircleKind, getRectangle(), nStartAngle, nEndAngle));
+    mpXPoly = XPolygon(aPolyCirc);
+}
+
+OUString SdrCircObj::TakeObjNameSingul() const
+{
+    TranslateId pID=STR_ObjNameSingulCIRC;
+    if (getRectangle().GetWidth() == getRectangle().GetHeight() && maGeo.m_nShearAngle == 0_deg100)
+    {
+        switch (meCircleKind) {
+            case SdrCircKind::Full: pID=STR_ObjNameSingulCIRC; break;
+            case SdrCircKind::Section: pID=STR_ObjNameSingulSECT; break;
+            case SdrCircKind::Arc: pID=STR_ObjNameSingulCARC; break;
+            case SdrCircKind::Cut: pID=STR_ObjNameSingulCCUT; break;
+            default: break;
+        }
+    } else {
+        switch (meCircleKind) {
+            case SdrCircKind::Full: pID=STR_ObjNameSingulCIRCE; break;
+            case SdrCircKind::Section: pID=STR_ObjNameSingulSECTE; break;
+            case SdrCircKind::Arc: pID=STR_ObjNameSingulCARCE; break;
+            case SdrCircKind::Cut: pID=STR_ObjNameSingulCCUTE; break;
+            default: break;
+        }
+    }
+    OUString sName(SvxResId(pID));
+
+    OUString aName(GetName());
+    if (!aName.isEmpty())
+        sName += " '" + aName + "'";
+    return sName;
+}
+
+OUString SdrCircObj::TakeObjNamePlural() const
+{
+    TranslateId pID=STR_ObjNamePluralCIRC;
+    if (getRectangle().GetWidth() == getRectangle().GetHeight() && maGeo.m_nShearAngle == 0_deg100)
+    {
+        switch (meCircleKind) {
+            case SdrCircKind::Full: pID=STR_ObjNamePluralCIRC; break;
+            case SdrCircKind::Section: pID=STR_ObjNamePluralSECT; break;
+            case SdrCircKind::Arc: pID=STR_ObjNamePluralCARC; break;
+            case SdrCircKind::Cut: pID=STR_ObjNamePluralCCUT; break;
+            default: break;
+        }
+    } else {
+        switch (meCircleKind) {
+            case SdrCircKind::Full: pID=STR_ObjNamePluralCIRCE; break;
+            case SdrCircKind::Section: pID=STR_ObjNamePluralSECTE; break;
+            case SdrCircKind::Arc: pID=STR_ObjNamePluralCARCE; break;
+            case SdrCircKind::Cut: pID=STR_ObjNamePluralCCUTE; break;
+            default: break;
+        }
+    }
+    return SvxResId(pID);
+}
+
+rtl::Reference<SdrObject> SdrCircObj::CloneSdrObject(SdrModel& rTargetModel) const
+{
+    return new SdrCircObj(rTargetModel, *this);
+}
+
+basegfx::B2DPolyPolygon SdrCircObj::TakeXorPoly() const
+{
+    const basegfx::B2DPolygon aCircPolygon(ImpCalcXPolyCirc(meCircleKind, getRectangle(), nStartAngle, nEndAngle));
+    return basegfx::B2DPolyPolygon(aCircPolygon);
+}
+
+namespace {
+
+struct ImpCircUser : public SdrDragStatUserData
+{
+    tools::Rectangle                   aR;
+    Point                       aCenter;
+    Point                       aP1;
+    tools::Long                        nHgt;
+    tools::Long                        nWdt;
+    Degree100                          nStart;
+    Degree100                          nEnd;
+
+public:
+    ImpCircUser()
+    :   nHgt(0),
+        nWdt(0),
+        nStart(0),
+        nEnd(0)
+    {}
+    void SetCreateParams(SdrDragStat const & rStat);
+};
+
+}
+
+sal_uInt32 SdrCircObj::GetHdlCount() const
+{
+    if(SdrCircKind::Full != meCircleKind)
+    {
+        return 10;
+    }
+    else
+    {
+        return 8;
+    }
+}
+
+void SdrCircObj::AddToHdlList(SdrHdlList& rHdlList) const
+{
+    for (sal_uInt32 nHdlNum=(SdrCircKind::Full==meCircleKind)?2:0; nHdlNum<=9; ++nHdlNum)
+    {
+        Point aPnt;
+        SdrHdlKind eLocalKind(SdrHdlKind::Move);
+        sal_uInt32 nPNum(0);
+        tools::Rectangle aRectangle = getRectangle();
+        switch (nHdlNum)
+        {
+            case 0:
+                aPnt = GetAnglePnt(aRectangle, nStartAngle);
+                eLocalKind = SdrHdlKind::Circle;
+                nPNum = 1;
+                break;
+            case 1:
+                aPnt = GetAnglePnt(aRectangle, nEndAngle);
+                eLocalKind = SdrHdlKind::Circle;
+                nPNum = 2;
+                break;
+            case 2:
+                aPnt = aRectangle.TopLeft();
+                eLocalKind = SdrHdlKind::UpperLeft;
+                break;
+            case 3:
+                aPnt = aRectangle.TopCenter();
+                eLocalKind = SdrHdlKind::Upper;
+                break;
+            case 4:
+                aPnt = aRectangle.TopRight();
+                eLocalKind = SdrHdlKind::UpperRight;
+                break;
+            case 5:
+                aPnt = aRectangle.LeftCenter();
+                eLocalKind = SdrHdlKind::Left;
+                break;
+            case 6:
+                aPnt = aRectangle.RightCenter();
+                eLocalKind = SdrHdlKind::Right;
+                break;
+            case 7:
+                aPnt = aRectangle.BottomLeft();
+                eLocalKind = SdrHdlKind::LowerLeft;
+                break;
+            case 8:
+                aPnt = aRectangle.BottomCenter();
+                eLocalKind = SdrHdlKind::Lower;
+                break;
+            case 9:
+                aPnt = aRectangle.BottomRight();
+                eLocalKind = SdrHdlKind::LowerRight;
+                break;
+        }
+
+        if (maGeo.m_nShearAngle)
+        {
+            ShearPoint(aPnt, aRectangle.TopLeft(), maGeo.mfTanShearAngle);
+        }
+
+        if (maGeo.m_nRotationAngle)
+        {
+            RotatePoint(aPnt, aRectangle.TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
+        }
+
+        std::unique_ptr<SdrHdl> pH(new SdrHdl(aPnt,eLocalKind));
+        pH->SetPointNum(nPNum);
+        pH->SetObj(const_cast<SdrCircObj*>(this));
+        pH->SetRotationAngle(maGeo.m_nRotationAngle);
+        rHdlList.AddHdl(std::move(pH));
+    }
+}
+
+
+bool SdrCircObj::hasSpecialDrag() const
+{
+    return true;
+}
+
+bool SdrCircObj::beginSpecialDrag(SdrDragStat& rDrag) const
+{
+    const bool bAngle(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind());
+
+    if(bAngle)
+    {
+        if(1 == rDrag.GetHdl()->GetPointNum() || 2 == rDrag.GetHdl()->GetPointNum())
+        {
+            rDrag.SetNoSnap();
+        }
+
+        return true;
+    }
+
+    return SdrTextObj::beginSpecialDrag(rDrag);
+}
+
+bool SdrCircObj::applySpecialDrag(SdrDragStat& rDrag)
+{
+    const bool bAngle(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind());
+
+    if(bAngle)
+    {
+        Point aPt(rDrag.GetNow());
+
+        if (maGeo.m_nRotationAngle)
+            RotatePoint(aPt, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
+
+        if (maGeo.m_nShearAngle)
+            ShearPoint(aPt, getRectangle().TopLeft(), -maGeo.mfTanShearAngle);
+
+        aPt -= getRectangle().Center();
+
+        tools::Long nWdt = getRectangle().Right() - getRectangle().Left();
+        tools::Long nHgt = getRectangle().Bottom() - getRectangle().Top();
+
+        if(nWdt>=nHgt)
+        {
+            aPt.setY(BigMulDiv(aPt.Y(),nWdt,nHgt) );
+        }
+        else
+        {
+            aPt.setX(BigMulDiv(aPt.X(),nHgt,nWdt) );
+        }
+
+        Degree100 nAngle=NormAngle36000(GetAngle(aPt));
+
+        if (rDrag.GetView() && rDrag.GetView()->IsAngleSnapEnabled())
+        {
+            Degree100 nSA=rDrag.GetView()->GetSnapAngle();
+
+            if (nSA)
+            {
+                nAngle+=nSA/2_deg100;
+                nAngle/=nSA;
+                nAngle*=nSA;
+                nAngle=NormAngle36000(nAngle);
+            }
+        }
+
+        if(1 == rDrag.GetHdl()->GetPointNum())
+        {
+            nStartAngle = nAngle;
+        }
+        else if(2 == rDrag.GetHdl()->GetPointNum())
+        {
+            nEndAngle = nAngle;
+        }
+
+        SetBoundAndSnapRectsDirty();
+        SetXPolyDirty();
+        ImpSetCircInfoToAttr();
+        SetChanged();
+
+        return true;
+    }
+    else
+    {
+        return SdrTextObj::applySpecialDrag(rDrag);
+    }
+}
+
+OUString SdrCircObj::getSpecialDragComment(const SdrDragStat& rDrag) const
+{
+    const bool bCreateComment(rDrag.GetView() && this == rDrag.GetView()->GetCreateObj());
+
+    if(bCreateComment)
+    {
+        OUStringBuffer aBuf(ImpGetDescriptionStr(STR_ViewCreateObj));
+        const sal_uInt32 nPointCount(rDrag.GetPointCount());
+
+        if(SdrCircKind::Full != meCircleKind && nPointCount > 2)
+        {
+            const ImpCircUser* pU = static_cast<const ImpCircUser*>(rDrag.GetUser());
+            Degree100 nAngle;
+
+            aBuf.append(" (");
+
+            if(3 == nPointCount)
+            {
+                nAngle = pU->nStart;
+            }
+            else
+            {
+                nAngle = pU->nEnd;
+            }
+
+            aBuf.append(SdrModel::GetAngleString(nAngle));
+            aBuf.append(')');
+        }
+
+        return aBuf.makeStringAndClear();
+    }
+    else
+    {
+        const bool bAngle(rDrag.GetHdl() && SdrHdlKind::Circle == rDrag.GetHdl()->GetKind());
+
+        if(bAngle)
+        {
+            const Degree100 nAngle(1 == rDrag.GetHdl()->GetPointNum() ? nStartAngle : nEndAngle);
+
+            return ImpGetDescriptionStr(STR_DragCircAngle) +
+                " (" +
+                SdrModel::GetAngleString(nAngle) +
+                ")";
+        }
+        else
+        {
+            return SdrTextObj::getSpecialDragComment(rDrag);
+        }
+    }
+}
+
+
+void ImpCircUser::SetCreateParams(SdrDragStat const & rStat)
+{
+    rStat.TakeCreateRect(aR);
+    aR.Normalize();
+    aCenter=aR.Center();
+    nWdt=aR.Right()-aR.Left();
+    nHgt=aR.Bottom()-aR.Top();
+    nStart=0_deg100;
+    nEnd=36000_deg100;
+    if (rStat.GetPointCount()>2) {
+        Point aP(rStat.GetPoint(2)-aCenter);
+        if (nWdt==0) aP.setX(0 );
+        if (nHgt==0) aP.setY(0 );
+        if (nWdt>=nHgt) {
+            if (nHgt!=0) aP.setY(aP.Y()*nWdt/nHgt );
+        } else {
+            if (nWdt!=0) aP.setX(aP.X()*nHgt/nWdt );
+        }
+        nStart=NormAngle36000(GetAngle(aP));
+        if (rStat.GetView()!=nullptr && rStat.GetView()->IsAngleSnapEnabled()) {
+            Degree100 nSA=rStat.GetView()->GetSnapAngle();
+            if (nSA) { // angle snapping
+                nStart+=nSA/2_deg100;
+                nStart/=nSA;
+                nStart*=nSA;
+                nStart=NormAngle36000(nStart);
+            }
+        }
+        aP1 = GetAnglePnt(aR,nStart);
+        nEnd=nStart;
+    } else aP1=aCenter;
+    if (rStat.GetPointCount()<=3)
+        return;
+
+    Point aP(rStat.GetPoint(3)-aCenter);
+    if (nWdt>=nHgt) {
+        aP.setY(BigMulDiv(aP.Y(),nWdt,nHgt) );
+    } else {
+        aP.setX(BigMulDiv(aP.X(),nHgt,nWdt) );
+    }
+    nEnd=NormAngle36000(GetAngle(aP));
+    if (rStat.GetView()!=nullptr && rStat.GetView()->IsAngleSnapEnabled()) {
+        Degree100 nSA=rStat.GetView()->GetSnapAngle();
+        if (nSA) { // angle snapping
+            nEnd+=nSA/2_deg100;
+            nEnd/=nSA;
+            nEnd*=nSA;
+            nEnd=NormAngle36000(nEnd);
+        }
+    }
+}
+
+void SdrCircObj::ImpSetCreateParams(SdrDragStat& rStat)
+{
+    ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
+    if (pU==nullptr) {
+        pU=new ImpCircUser;
+        rStat.SetUser(std::unique_ptr<ImpCircUser>(pU));
+    }
+    pU->SetCreateParams(rStat);
+}
+
+bool SdrCircObj::BegCreate(SdrDragStat& rStat)
+{
+    rStat.SetOrtho4Possible();
+    tools::Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
+    aRect1.Normalize();
+    rStat.SetActionRect(aRect1);
+    setRectangle(aRect1);
+    ImpSetCreateParams(rStat);
+    return true;
+}
+
+bool SdrCircObj::MovCreate(SdrDragStat& rStat)
+{
+    ImpSetCreateParams(rStat);
+    ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
+    rStat.SetActionRect(pU->aR);
+    setRectangle(pU->aR); // for ObjName
+    ImpJustifyRect(maRectangle);
+    nStartAngle=pU->nStart;
+    nEndAngle=pU->nEnd;
+    SetBoundRectDirty();
+    m_bSnapRectDirty=true;
+    SetXPolyDirty();
+
+    // #i103058# push current angle settings to ItemSet to
+    // allow FullDrag visualisation
+    if(rStat.GetPointCount() >= 4)
+    {
+        ImpSetCircInfoToAttr();
+    }
+
+    return true;
+}
+
+bool SdrCircObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
+{
+    ImpSetCreateParams(rStat);
+    ImpCircUser* pU=static_cast<ImpCircUser*>(rStat.GetUser());
+    bool bRet = false;
+    if (eCmd==SdrCreateCmd::ForceEnd && rStat.GetPointCount()<4) meCircleKind=SdrCircKind::Full;
+    if (meCircleKind==SdrCircKind::Full) {
+        bRet=rStat.GetPointCount()>=2;
+        if (bRet) {
+            tools::Rectangle aRectangle(pU->aR);
+            ImpJustifyRect(aRectangle);
+            setRectangle(aRectangle);
+        }
+    } else {
+        rStat.SetNoSnap(rStat.GetPointCount()>=2);
+        rStat.SetOrtho4Possible(rStat.GetPointCount()<2);
+        bRet=rStat.GetPointCount()>=4;
+        if (bRet) {
+            tools::Rectangle aRectangle(pU->aR);
+            ImpJustifyRect(aRectangle);
+            setRectangle(aRectangle);
+            nStartAngle=pU->nStart;
+            nEndAngle=pU->nEnd;
+        }
+    }
+    m_bClosedObj=meCircleKind!=SdrCircKind::Arc;
+    SetBoundAndSnapRectsDirty();
+    SetXPolyDirty();
+    ImpSetCircInfoToAttr();
+    if (bRet)
+        rStat.SetUser(nullptr);
+    return bRet;
+}
+
+void SdrCircObj::BrkCreate(SdrDragStat& rStat)
+{
+    rStat.SetUser(nullptr);
+}
+
+bool SdrCircObj::BckCreate(SdrDragStat& rStat)
+{
+    rStat.SetNoSnap(rStat.GetPointCount()>=3);
+    rStat.SetOrtho4Possible(rStat.GetPointCount()<3);
+    return meCircleKind!=SdrCircKind::Full;
+}
+
+basegfx::B2DPolyPolygon SdrCircObj::TakeCreatePoly(const SdrDragStat& rDrag) const
+{
+    const ImpCircUser* pU = static_cast<const ImpCircUser*>(rDrag.GetUser());
+
+    if(rDrag.GetPointCount() < 4)
+    {
+        // force to OBJ_CIRC to get full visualisation
+        basegfx::B2DPolyPolygon aRetval(ImpCalcXPolyCirc(SdrCircKind::Full, pU->aR, pU->nStart, pU->nEnd));
+
+        if(3 == rDrag.GetPointCount())
+        {
+            // add edge to first point on ellipse
+            basegfx::B2DPolygon aNew;
+
+            aNew.append(basegfx::B2DPoint(pU->aCenter.X(), pU->aCenter.Y()));
+            aNew.append(basegfx::B2DPoint(pU->aP1.X(), pU->aP1.Y()));
+            aRetval.append(aNew);
+        }
+
+        return aRetval;
+    }
+    else
+    {
+        return basegfx::B2DPolyPolygon(ImpCalcXPolyCirc(meCircleKind, pU->aR, pU->nStart, pU->nEnd));
+    }
+}
+
+PointerStyle SdrCircObj::GetCreatePointer() const
+{
+    switch (meCircleKind) {
+        case SdrCircKind::Full: return PointerStyle::DrawEllipse;
+        case SdrCircKind::Section: return PointerStyle::DrawPie;
+        case SdrCircKind::Arc: return PointerStyle::DrawArc;
+        case SdrCircKind::Cut: return PointerStyle::DrawCircleCut;
+        default: break;
+    } // switch
+    return PointerStyle::Cross;
+}
+
+void SdrCircObj::NbcMove(const Size& aSize)
+{
+    moveRectangle(aSize.Width(), aSize.Height());
+    moveOutRectangle(aSize.Width(), aSize.Height());
+    maSnapRect.Move(aSize);
+    SetXPolyDirty();
+    SetBoundAndSnapRectsDirty(true);
+}
+
+void SdrCircObj::NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact)
+{
+    Degree100 nAngle0 = maGeo.m_nRotationAngle;
+    bool bNoShearRota = (maGeo.m_nRotationAngle == 0_deg100 && maGeo.m_nShearAngle == 0_deg100);
+    SdrTextObj::NbcResize(rRef,xFact,yFact);
+    bNoShearRota |= (maGeo.m_nRotationAngle == 0_deg100 && maGeo.m_nShearAngle == 0_deg100);
+    if (meCircleKind!=SdrCircKind::Full) {
+        bool bXMirr=(xFact.GetNumerator()<0) != (xFact.GetDenominator()<0);
+        bool bYMirr=(yFact.GetNumerator()<0) != (yFact.GetDenominator()<0);
+        if (bXMirr || bYMirr) {
+            // At bXMirr!=bYMirr we should actually swap both line ends.
+            // That, however, is pretty bad (because of forced "hard" formatting).
+            // Alternatively, we could implement a bMirrored flag (maybe even
+            // a more general one, e. g. for mirrored text, ...).
+            Degree100 nS0=nStartAngle;
+            Degree100 nE0=nEndAngle;
+            if (bNoShearRota) {
+                // the RectObj already mirrors at VMirror because of a 180deg rotation
+                if (! (bXMirr && bYMirr)) {
+                    Degree100 nTmp=nS0;
+                    nS0=18000_deg100-nE0;
+                    nE0=18000_deg100-nTmp;
+                }
+            } else { // mirror contorted ellipses
+                if (bXMirr!=bYMirr) {
+                    nS0+=nAngle0;
+                    nE0+=nAngle0;
+                    if (bXMirr) {
+                        Degree100 nTmp=nS0;
+                        nS0=18000_deg100-nE0;
+                        nE0=18000_deg100-nTmp;
+                    }
+                    if (bYMirr) {
+                        Degree100 nTmp=nS0;
+                        nS0=-nE0;
+                        nE0=-nTmp;
+                    }
+                    nS0 -= maGeo.m_nRotationAngle;
+                    nE0 -= maGeo.m_nRotationAngle;
+                }
+            }
+            Degree100 nAngleDif=nE0-nS0;
+            nStartAngle=NormAngle36000(nS0);
+            nEndAngle  =NormAngle36000(nE0);
+            if (nAngleDif==36000_deg100) nEndAngle+=nAngleDif; // full circle
+        }
+    }
+    SetXPolyDirty();
+    ImpSetCircInfoToAttr();
+}
+
+void SdrCircObj::NbcShear(const Point& rRef, Degree100 nAngle, double tn, bool bVShear)
+{
+    SdrTextObj::NbcShear(rRef,nAngle,tn,bVShear);
+    SetXPolyDirty();
+    ImpSetCircInfoToAttr();
+}
+
+void SdrCircObj::NbcMirror(const Point& rRef1, const Point& rRef2)
+{
+    bool bFreeMirr=meCircleKind!=SdrCircKind::Full;
+    Point aTmpPt1;
+    Point aTmpPt2;
+    if (bFreeMirr) { // some preparations for using an arbitrary axis of reflection
+        Point aCenter(getRectangle().Center());
+        tools::Long nWdt = getRectangle().GetWidth() - 1;
+        tools::Long nHgt = getRectangle().GetHeight() - 1;
+        tools::Long nMaxRad=(std::max(nWdt,nHgt)+1) /2;
+        // starting point
+        double a = toRadians(nStartAngle);
+        aTmpPt1=Point(FRound(cos(a)*nMaxRad),-FRound(sin(a)*nMaxRad));
+        if (nWdt==0) aTmpPt1.setX(0 );
+        if (nHgt==0) aTmpPt1.setY(0 );
+        aTmpPt1+=aCenter;
+        // finishing point
+        a = toRadians(nEndAngle);
+        aTmpPt2=Point(FRound(cos(a)*nMaxRad),-FRound(sin(a)*nMaxRad));
+        if (nWdt==0) aTmpPt2.setX(0 );
+        if (nHgt==0) aTmpPt2.setY(0 );
+        aTmpPt2+=aCenter;
+        if (maGeo.m_nRotationAngle)
+        {
+            RotatePoint(aTmpPt1, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
+            RotatePoint(aTmpPt2, getRectangle().TopLeft(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
+        }
+        if (maGeo.m_nShearAngle)
+        {
+            ShearPoint(aTmpPt1, getRectangle().TopLeft(), maGeo.mfTanShearAngle);
+            ShearPoint(aTmpPt2, getRectangle().TopLeft(), maGeo.mfTanShearAngle);
+        }
+    }
+    SdrTextObj::NbcMirror(rRef1,rRef2);
+    if (meCircleKind!=SdrCircKind::Full) { // adapt starting and finishing angle
+        MirrorPoint(aTmpPt1,rRef1,rRef2);
+        MirrorPoint(aTmpPt2,rRef1,rRef2);
+        // unrotate:
+        if (maGeo.m_nRotationAngle)
+        {
+            RotatePoint(aTmpPt1, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); // -sin for reversion
+            RotatePoint(aTmpPt2, getRectangle().TopLeft(), -maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle); // -sin for reversion
+        }
+        // unshear:
+        if (maGeo.m_nShearAngle)
+        {
+            ShearPoint(aTmpPt1, getRectangle().TopLeft(), -maGeo.mfTanShearAngle); // -tan for reversion
+            ShearPoint(aTmpPt2, getRectangle().TopLeft(), -maGeo.mfTanShearAngle); // -tan for reversion
+        }
+        Point aCenter(getRectangle().Center());
+        aTmpPt1-=aCenter;
+        aTmpPt2-=aCenter;
+        // because it's mirrored, the angles are swapped, too
+        nStartAngle=GetAngle(aTmpPt2);
+        nEndAngle  =GetAngle(aTmpPt1);
+        Degree100 nAngleDif=nEndAngle-nStartAngle;
+        nStartAngle=NormAngle36000(nStartAngle);
+        nEndAngle  =NormAngle36000(nEndAngle);
+        if (nAngleDif==36000_deg100) nEndAngle+=nAngleDif; // full circle
+    }
+    SetXPolyDirty();
+    ImpSetCircInfoToAttr();
+}
+
+std::unique_ptr<SdrObjGeoData> SdrCircObj::NewGeoData() const
+{
+    return std::make_unique<SdrCircObjGeoData>();
+}
+
+void SdrCircObj::SaveGeoData(SdrObjGeoData& rGeo) const
+{
+    SdrRectObj::SaveGeoData(rGeo);
+    SdrCircObjGeoData& rCGeo=static_cast<SdrCircObjGeoData&>(rGeo);
+    rCGeo.nStartAngle=nStartAngle;
+    rCGeo.nEndAngle  =nEndAngle;
+}
+
+void SdrCircObj::RestoreGeoData(const SdrObjGeoData& rGeo)
+{
+    SdrRectObj::RestoreGeoData(rGeo);
+    const SdrCircObjGeoData& rCGeo=static_cast<const SdrCircObjGeoData&>(rGeo);
+    nStartAngle=rCGeo.nStartAngle;
+    nEndAngle  =rCGeo.nEndAngle;
+    SetXPolyDirty();
+    ImpSetCircInfoToAttr();
+}
+
+static void Union(tools::Rectangle& rR, const Point& rP)
+{
+    if (rP.X()<rR.Left  ()) rR.SetLeft(rP.X() );
+    if (rP.X()>rR.Right ()) rR.SetRight(rP.X() );
+    if (rP.Y()<rR.Top   ()) rR.SetTop(rP.Y() );
+    if (rP.Y()>rR.Bottom()) rR.SetBottom(rP.Y() );
+}
+
+void SdrCircObj::TakeUnrotatedSnapRect(tools::Rectangle& rRect) const
+{
+    rRect = getRectangle();
+    if (meCircleKind!=SdrCircKind::Full) {
+        const Point aPntStart(GetAnglePnt(getRectangle(), nStartAngle));
+        const Point aPntEnd(GetAnglePnt(getRectangle(), nEndAngle));
+        Degree100 a=nStartAngle;
+        Degree100 e=nEndAngle;
+        rRect.SetLeft(getRectangle().Right() );
+        rRect.SetRight(getRectangle().Left() );
+        rRect.SetTop(getRectangle().Bottom() );
+        rRect.SetBottom(getRectangle().Top() );
+        Union(rRect,aPntStart);
+        Union(rRect,aPntEnd);
+        if ((a<=18000_deg100 && e>=18000_deg100) || (a>e && (a<=18000_deg100 || e>=18000_deg100))) {
+            Union(rRect, getRectangle().LeftCenter());
+        }
+        if ((a<=27000_deg100 && e>=27000_deg100) || (a>e && (a<=27000_deg100 || e>=27000_deg100))) {
+            Union(rRect, getRectangle().BottomCenter());
+        }
+        if (a>e) {
+            Union(rRect, getRectangle().RightCenter());
+        }
+        if ((a<=9000_deg100 && e>=9000_deg100) || (a>e && (a<=9000_deg100 || e>=9000_deg100))) {
+            Union(rRect, getRectangle().TopCenter());
+        }
+        if (meCircleKind==SdrCircKind::Section) {
+            Union(rRect, getRectangle().Center());
+        }
+        if (maGeo.m_nRotationAngle)
+        {
+            Point aDst(rRect.TopLeft());
+            aDst -= getRectangle().TopLeft();
+            Point aDst0(aDst);
+            RotatePoint(aDst,Point(), maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
+            aDst-=aDst0;
+            rRect.Move(aDst.X(),aDst.Y());
+        }
+    }
+    if (maGeo.m_nShearAngle==0_deg100)
+        return;
+
+    tools::Long nDst = FRound((rRect.Bottom() - rRect.Top()) * maGeo.mfTanShearAngle);
+    if (maGeo.m_nShearAngle > 0_deg100)
+    {
+        Point aRef(rRect.TopLeft());
+        rRect.AdjustLeft( -nDst );
+        Point aTmpPt(rRect.TopLeft());
+        RotatePoint(aTmpPt, aRef, maGeo.mfSinRotationAngle, maGeo.mfCosRotationAngle);
+        aTmpPt-=rRect.TopLeft();
+        rRect.Move(aTmpPt.X(),aTmpPt.Y());
+    } else {
+        rRect.AdjustRight( -nDst );
+    }
+}
+
+void SdrCircObj::RecalcSnapRect()
+{
+    if (PaintNeedsXPolyCirc()) {
+        maSnapRect=GetXPoly().GetBoundRect();
+    } else {
+        TakeUnrotatedSnapRect(maSnapRect);
+    }
+}
+
+void SdrCircObj::NbcSetSnapRect(const tools::Rectangle& rRect)
+{
+    if (maGeo.m_nRotationAngle || maGeo.m_nShearAngle || meCircleKind != SdrCircKind::Full)
+    {
+        tools::Rectangle aSR0(GetSnapRect());
+        tools::Long nWdt0=aSR0.Right()-aSR0.Left();
+        tools::Long nHgt0=aSR0.Bottom()-aSR0.Top();
+        tools::Long nWdt1=rRect.Right()-rRect.Left();
+        tools::Long nHgt1=rRect.Bottom()-rRect.Top();
+        NbcResize(maSnapRect.TopLeft(),Fraction(nWdt1,nWdt0),Fraction(nHgt1,nHgt0));
+        NbcMove(Size(rRect.Left()-aSR0.Left(),rRect.Top()-aSR0.Top()));
+    } else {
+        setRectangle(rRect);
+        ImpJustifyRect(maRectangle);
+    }
+    SetBoundAndSnapRectsDirty();
+    SetXPolyDirty();
+    ImpSetCircInfoToAttr();
+}
+
+sal_uInt32 SdrCircObj::GetSnapPointCount() const
+{
+    if (meCircleKind==SdrCircKind::Full) {
+        return 1;
+    } else {
+        return 3;
+    }
+}
+
+Point SdrCircObj::GetSnapPoint(sal_uInt32 i) const
+{
+    switch (i)
+    {
+        case 1 : return GetAnglePnt(getRectangle(), nStartAngle);
+        case 2 : return GetAnglePnt(getRectangle(), nEndAngle);
+        default: return getRectangle().Center();
+    }
+}
+
+void SdrCircObj::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
+{
+    SetXPolyDirty();
+    SdrRectObj::Notify(rBC,rHint);
+    ImpSetAttrToCircInfo();
+}
+
+
+void SdrCircObj::ImpSetAttrToCircInfo()
+{
+    const SfxItemSet& rSet = GetObjectItemSet();
+    SdrCircKind eNewKind = rSet.Get(SDRATTR_CIRCKIND).GetValue();
+
+    Degree100 nNewStart = rSet.Get(SDRATTR_CIRCSTARTANGLE).GetValue();
+    Degree100 nNewEnd = rSet.Get(SDRATTR_CIRCENDANGLE).GetValue();
+
+    bool bKindChg = meCircleKind != eNewKind;
+    bool bAngleChg = nNewStart != nStartAngle || nNewEnd != nEndAngle;
+
+    if(bKindChg || bAngleChg)
+    {
+        meCircleKind = eNewKind;
+        nStartAngle = nNewStart;
+        nEndAngle = nNewEnd;
+
+        if(bKindChg || (meCircleKind != SdrCircKind::Full && bAngleChg))
+        {
+            SetXPolyDirty();
+            SetBoundAndSnapRectsDirty();
+        }
+    }
+}
+
+void SdrCircObj::ImpSetCircInfoToAttr()
+{
+    const SfxItemSet& rSet = GetObjectItemSet();
+
+    SdrCircKind eOldKindA = rSet.Get(SDRATTR_CIRCKIND).GetValue();
+    Degree100 nOldStartAngle = rSet.Get(SDRATTR_CIRCSTARTANGLE).GetValue();
+    Degree100 nOldEndAngle = rSet.Get(SDRATTR_CIRCENDANGLE).GetValue();
+
+    if(meCircleKind == eOldKindA && nStartAngle == nOldStartAngle && nEndAngle == nOldEndAngle)
+        return;
+
+    // since SetItem() implicitly calls ImpSetAttrToCircInfo()
+    // setting the item directly is necessary here.
+    if(meCircleKind != eOldKindA)
+    {
+        GetProperties().SetObjectItemDirect(SdrCircKindItem(meCircleKind));
+    }
+
+    if(nStartAngle != nOldStartAngle)
+    {
+        GetProperties().SetObjectItemDirect(makeSdrCircStartAngleItem(nStartAngle));
+    }
+
+    if(nEndAngle != nOldEndAngle)
+    {
+        GetProperties().SetObjectItemDirect(makeSdrCircEndAngleItem(nEndAngle));
+    }
+
+    SetXPolyDirty();
+    ImpSetAttrToCircInfo();
+}
+
+rtl::Reference<SdrObject> SdrCircObj::DoConvertToPolyObj(bool bBezier, bool bAddText) const
+{
+    const bool bFill(meCircleKind != SdrCircKind::Arc);
+    const basegfx::B2DPolygon aCircPolygon(ImpCalcXPolyCirc(meCircleKind, getRectangle(), nStartAngle, nEndAngle));
+    rtl::Reference<SdrObject> pRet = ImpConvertMakeObj(basegfx::B2DPolyPolygon(aCircPolygon), bFill, bBezier);
+
+    if(bAddText)
+    {
+        pRet = ImpConvertAddText(std::move(pRet), bBezier);
+    }
+
+    return pRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */